C# - Visual Studio 2008 capable of Conditional Compilation?

Question

Referring to the "Configuration Manager" under the Build menu.

Is there a way to comment my C# code so that the commented out code does not compile while the solution is in Debug mode, but would compile if I changed it to Release mode?

Update: Judging by the answers, I should have said why I wanted this. The reason I want to have code that will be compiled in Release mode but not in Debug is that I've got some code that will not work from my dev PC (code that sends emails from my host, etc...).

Instead of having to run back through my code and uncomment lines before publishing, I'd like that to be automatic.

Answer 1

Are you looking for something like this?

#if DEBUG
     Console.WriteLine("Debug Mode");
#else
     Console.WriteLine("Release Mode");
#endif

If you only care about release mode, you can use:

#if !DEBUG
     Console.WriteLine("Release Mode");
#endif

Answer 2

You could use the Conditional attribute on methods (but not individual lines of code) for this purpose

e.g. The following will only be compiled into DEBUG builds.

[Conditional("DEBUG")]
public void MyMethod()
{
    // Do Stuff
}

The DEBUG symbol is already specified in the project settings. You'd have to create your own symbol for a release build, say "RELEASE", so that you can do this:

[Conditional("RELEASE")]
public void MyMethod()
{
    // Do Stuff
}

However, I'd recommend stepping back and looking at your problem anew from a higher level as I wouldn't really recommend this solution.

Answer 3

I may be wrong, but I think that comments are ignored by the compiler. If I look at an assembly of mine using .net reflector, I don't see any comments that I know exist.

BlueMonkMN's method will work to run different code depending on compile mode.

If you want to have different code running depending on what mode of compile (and other variables) you are using, check out PostSharp. It's a post-compiling compiler that can add and remove code to your assembly.

Example use: - I love to have detailed debug and trace info for my projects. - I hate having a print or trace.write statement after every method result or method call, as this extra debugging code obscures the function doing the work.

You can configure PostSharp to create this extra debug info dynamically! A couple config tweaks and you can have every call to every function printed AND the result (with variable contents) from each call. This makes it very easy to follow the program logic flow.

Answer 4

I would attempt to solve your problem with an object oriented technique. Using dependency injection, I would construct a class that performs your necessary Debug actions.

Something like:

public class MyClass {

  public MyClass(IDoOtherStuff stuffToDo) {

     DoOtherStuff = stuffToDo;

  }

  private IDoOtherStuff DoOtherStuff { get; set; }

  public void Do() {

    DoOtherStuff.BeforeDo();

    // Blah blah blah..  

    DoOtherStuff.AfterDo();    

  }

}

public interface IDoOtherStuff {
   void BeforeDo();
   void AfterDo();
}

public class DebugOtherStuff : IDoOtherStuff {

   public void BeforeDo() {
      Debug.WriteLine("At the beginning of Do");
   }

   public void AfterDo() {
      Debug.WriteLine("At the end of Do");
   }
}

public class ReleaseOtherStuff : IDoOtherStuff {
   public void BeforeDo() { }
   public void AfterDo() { }
}

Now, you can use an IoC container like Windsor, Unity, Ninject, or Spring.Net to configure your development environment versus Release environment.