#507 – You can #define Other Symbols within a #if Block

January 27, 2012 Leave a Comment

Within the body of an #if/#endif pair, you can include #define or #undef directives.  If the body of the #if does contain #define or #undef directives, it must appear before the first token of the containing source file.

#define DOGSBARK

#if DOGSBARK || DOGSGROWL
#define DOGSMAKENOISE
#endif

using System;
using DogLibrary;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main()
        {
            Dog d = new Dog("Kirby", 12);
#if DOGSMAKENOISE
            d.BarkOrGrowl();
#endif
        }
    }
}

Filed under Basics Tagged with , , , ,

#506 – Using Expressions in #if and #elif Directives

January 26, 2012 Leave a Comment

You can use more complex expressions in #if and #elif directives, instead of just checking to see whether a single conditional compilation symbol is defined.

In the example below, the #elif directive triggers if the DOGSBARK symbol is defined and then DOGSGROWL symbol is not defined.

#define DOGSBARK
//#define DOGSWAG
//#define DOGSGROWL

using System;
using DogLibrary;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main()
        {
            Dog d = new Dog("Kirby", 12);

#if DOGSWAG
            d.WagTail();
#elif DOGSBARK && !DOGSGROWL
            d.Bark();
#else
            d.BarkAndGrowl();
#endif

        }
    }
}

You can build more complex expressions using parentheses and the && (logical AND) and || (logical OR) operators.

#if (DOGSWAG && DOGSDOTRICKS) || (DOGSDOEVERYTHING)
            d.WagAndFetch();
#endif

Filed under Basics Tagged with , , , ,

#505 – Using the #elif Directive

January 25, 2012 Leave a Comment

When you check whether a conditional compilation symbol is defined using the #if, #else and #endif directives, you can include additional clauses within the scope of the #if directive by using the #elif directive.  The #elif directive adds an additional expression to check, if any earlier expressions evaluate to false.

In the example below, we check both the DOGSBARK and the DOGSWAG symbols to determine which line to compile.

//#define DOGSBARK
#define DOGSWAG

using System;
using DogLibrary;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main()
        {
            Dog d1 = new Dog("Kirby", 12);
#if DOGSBARK
            d1.Bark();
#elif DOGSWAG
            d1.WagTail();
#else
            d1.JustSitThere();
#endif
        }
    }
}


You can include as many #elif clauses as you like.

Filed under Basics Tagged with , , , ,

#504 – Using the #else Directive

January 24, 2012 Leave a Comment

You can conditionally compile code using the #if and #endif preprocessor directive.  You can also use an #else clause between the #if and the #endif.

In the code below, we’ve commented out the definition of DOGSBARK, so the code between the #else and #endif will be compiled.

//#define DOGSBARK

using System;
using DogLibrary;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main()
        {
            Dog d1 = new Dog("Kirby", 12);
#if DOGSBARK
            d1.Bark();
#else
            d1.WagTail();
#endif
        }
    }
}

Note that the code after the #if directive is greyed out, while the code after the #else is formatted normally.

Filed under Basics Tagged with , , , , ,

#503 – Conditionally Compile Code Using #if / #endif Directives

January 23, 2012 Leave a Comment

Once you define a conditional compilation symbol using the #define directive, you can use the #if directive to conditionally compile code when the corresponding conditional compilation symbol is defined.

In the code sample below, the Dog.Bark method is called, because the DOGSBARK symbol is defined and so the line containing the call to Bark is compiled.

#define DOGSBARK

using System;
using DogLibrary;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main()
        {
            Dog d1 = new Dog("Kirby", 12);
#if DOGSBARK
            d1.Bark();
#endif
        }
    }
}

If we don’t define the DOGSBARK symbol, then the compiler doesn’t compile the line between the #if and #endif directives.  In fact, since the compiler doesn’t even look at these lines in this case, they don’t even have to contain valid C# syntax.

Filed under Basics Tagged with , , , , ,

#502 – #define and #undef Scope

January 20, 2012 Leave a Comment

When you include a #define or #undef preprocessor directive in a file, the scope in which that conditional symbol is defined (or not defined) is limited to that single file.

For example, suppose that we define the symbol QUIET within a file that creates an instance of a Dog and then calls the Bark method of the Dog object.

// Code from Program.cs
#define QUIET

using System;
using DogLibrary;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main()
        {
            Dog d1 = new Dog("Kirby", 12);
            d1.Bark();
        }
    }
}

Let’s also suppose that the Dog.Bark method, which exists in a separate file, compiles differently depending on whether the symbol QUIET is defined.

// Code from Dog.cs
        public void Bark()
        {
#if QUIET
            Console.WriteLine("Arf");
#else
            Console.WriteLine("WOOOOOF!");
#endif
        }

Because QUIET is defined in Program.cs but not in Dog.cs, the Bark method will use the second (not quiet) line.

Filed under Basics Tagged with , , , ,

#501 – Differences Between #define in C++ and C#

January 19, 2012 Leave a Comment

In C++, you could use the #define preprocessor directive in three ways:

  • Define a symbol and then later check to see if the symbol exists
  • Define a symbol, giving it a particular value that you can later check
  • Define a symbol and give it a definition (a macro)
  • Provide parameters as part of the symbol’s definition

In C++, the #define directive assigns some arbitrary text to a symbol and the preprocessor substitutes the text for the symbol, wherever the symbol appears in your code.

As an example, you could use C++ to create a macro by defining the symbol MAX as follows:

#define MAX(a,b) (a>b)?a:b

The #define directive in C# is much more limited.  Of the four uses for #define listed above, only the first one is supported in C#.  You use the #define directive to define a symbol that is either present or not present.

Filed under Basics Tagged with , ,

#500 – #define and #undef Must Be at Top of File

January 18, 2012 Leave a Comment

In C#, all #define and #undef  preprocessor directives must appear at the top of a source code file, i.e. before any valid C# tokens.  The definition (or un-definition) then remains in effect until the end of the file is reached.

#define QUIET

using System;
using DogLibrary;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main()
        {
            Dog d1 = new Dog("Kirby", 12);
#if QUIET
            d1.Bark("Arf");
#else
            d1.bark("WOOOF");
#endif
        }
    }
}

In this case, because the conditional compilation symbol is included directly in the code, Intellisense already knows which of the two Bark methods will be included in the code.  It displays the line that will not be compiled in grey.

In this example, the second Bark method is not compiled at all.

 

Filed under Basics Tagged with , , , , ,

#499 – Conditional Compilation Symbols Are Defined or Undefined

January 17, 2012 Leave a Comment

At any given point in your source code, while the compiler is compiling that section of code, a particular conditional compilation symbol is either defined or undefined.

You define a conditional compilation symbol

  • Using the #define preprocessor directive
  • Using the /define option on the compiler command line
  • Implicitly (for DEBUG and TRACE symbols), when selecting a build option for a project

You undefine a conditional compilation symbol

  • Using the #undef preprocessor directive
  • When reaching the end of a source file

A conditional compilation symbol is either defined or undefined–it has no value.

You check whether a conditional compilation symbol is defined by using the #if or #elif preprocessor directives.

A conditional compilation symbol remains defined in a source file until the end of the containing source file or until encountering an #undef directive (whichever comes first).

Filed under Basics Tagged with , , , , , , ,

#498 – Creating a New Solution Configuration

January 16, 2012 Leave a Comment

We saw how to create a new build configuration and, optionally, create a matching solution configuration.  You can also create a new solution configuration and, optionally, create new matching build configurations in each project.

To create a new solution configuration, first open the Configuration Manager.

Now click on the list of solution configurations and select <New…>

You’ll see the New Solution Configuration dialog.  Give the new configuration a name and pick a solution configuration that you want to copy settings from.

After pressing OK, you can set build configuration and platform choices for the new solution configuration.

In the example below, we’ve created a new configuration that uses the same build configuration choices as Debug but builds only the top-level application.

We now see our new solution configuration as a choice in the main solution configurations dropdown.

Filed under Visual Studio Tagged with , ,

← Older posts

Follow

Get every new post delivered to your Inbox.

Join 38 other followers