I need to put some code under a preprocessor directive.
such directives can be defined in different projects.
My situation is the following:
File Constants.cs (which is in project Proj1Dll.csproj)
#define DEV
... rest of the code
File Page1.cs (which is in project MainProj.csproj, which references Proj1Dll)
#define SHOW_BTN
...
#if (DEV && SHOW_BTN)
public static void Foo()
{
Debug.WriteLine("Both DEV and SHOW_BTN directives are defined");
}
#endif
Such configuration is not working, in the sense that method Foo() is not part of the compilation.
If I check instead #if (DEBUG && SHOW_BTN) everything is fine.
Is there a way to deal with such directives when they are defined in different projects?
Assuming you are using Visual Studio, you can go to the Project Properties, and under the Build tab, you will see 'Conditional compilation symbols'
Put your synbols in here and they will be recognised project wide.
In your example you would put just DEV if you wanted more than one, separate them with semicolon e.g. DEV;SHOW_BTN
If you want something to be solution wide and need only one symbol you can use the configuration manager to create a new configuration specifically for this build and call it what you like - this then gives you the same effect.
(It's why in your example DEBUG works)
Hope that helps.
Related
I'm currently struggling using custom configurations.
My solution has one .NET Standard Library and two other Projects (one for Windows, one for Android) which uses the library.
What I try to do is giving the library the compiler constant WINDOWS and MOBILE.
Thats how I tried it several times:
Create two new configurations WindowsDE and MobileDE, copy settings from Debug configuration and create new project configuration. At some trys I also deleted the default Debug configuration but that didn't helped
Properties of the library -> Build, choose WindowsDE and put WINDOWS into Conditional compilation symbols field then choose MobileDE and put ANDROID in it.
I'm testing it with calling a method in the library :
#if WINDOWS
System.Diagnostics.Debug.WriteLine("Windows");
#endif
#if ANDROID
System.Diagnostics.Debug.WriteLine("Android");
#endif
But that doesn't work at all. Also just using
System.Diagnostics.Debug.WriteLine("anything");
without having any #if does not print and at some trys I could not even debug the library anymore.
Would appreciate any help on this
You can define conditional compiling constants in the project properties
#if WINDOWS
System.Diagnostics.Debug.WriteLine("Windows"); // NOT printed!
#endif
#if ANDROID
System.Diagnostics.Debug.WriteLine("Android"); // Printed!
#endif
You can enter several symbols separated by semicolons. Don't set them true or false. The ones that are listed are true. The missing ones are automatically false.
If neither the one nor the other prints, then possibly the solution does not compile and you are running an old code. Try to rebuild the solution.
I have .net C# application. In the application have two set of code for different client.
We were thinking of removing the part of code through preprocessor. Diabling the part with config file parameter is not an option for us.
We want simple setup like:
#define DEBUG
//....
#if DEBUG
Console.WriteLine("Debug version");
#endif
The only issue is, our part of code is distributed into multiple files and multiple projects in the solution.
So we want to define globally the preprocessor “DEBUG” at one place. Preferably in project property or something.
What is the best option for us?
Look for "Conditional Compilation Symbols" on the "Build" page of the project property dialog. You can set it per-build configuration.
I have the following code (inherited from a contractor):
public partial class StoredProcedures
{
#if NO_THREAD
readonly static String version = "XXXX, Version 1.02, Apr/29/2010";
#else
readonly static String version = "XXXX, Version 0.93, Dec/21/2006";
#endif
I can't seem to find NO_THREAD anywhere else. This is code that compiles and installs as a SQL assembly. Is it something special or am I missing something simple?
Try to check Project Properties->Build->General->Conditional compilation symbols for all Build configurations which you have for the project, It may be there.
Look for a #define statement. See the docs for #if preprocessor conditionals : http://msdn.microsoft.com/en-us/library/4y6tbswk.aspx
If you can't find a
define #NO_THREAD
Anywhere in the code, then it's probably because the contractor was defining the symbol by passing the /define compiler option.
See here for more details (typing from a cell, sorry for the format):
http://msdn.microsoft.com/en-us/library/0feaad6z.aspx
you should probably have a look at the c# pre-processor directives
No_Thread here is a symbol which can be defined by using #define No_Thread and when #define No_Thread is present then #if NO_THREAD will result in true and at compile time readonly static String version = "XXXX, Version 1.02, Apr/29/2010"; this statement will be compiled otherwise the next statement will be compiled.
this is generally used to differentiate between debug and release versions. have you noticed there are 2 versions in VS when you create a new project. if you write something like this somewhere in you code
#if DEBUG
Console.WriteLine("DEBUG VERSION");
#endif
then the string "DEBUG VERSION" would only be printed on the console when the project is in debug mode because the VS inserts a symbol DEBUG if you manually do it using the #define pre-processor then too this line would be compiled
NO_THREAD is a symbol for conditional compilation.
It can come from, #define NO_THREAD, from the project file, or from the nant file (or whatever method you use for building).
If it's defined, the first line of code is counted as part of the C# code. If it isn't, then the second is.
If that's the sole occurence, I'd say it was a hangover from something removed, but if you're uesd to using visual studio to build, then make sure there isn't a build file for nant in case the previous developer used that instead.
This is a conditional compilation symbol. In Visual Studio 2010, these appear on the Build page of your Project Properties in the Conditional compilation symbols text box. Probably one of your Configuration Manager configurations either contains this symbol or has at some point in the past. Presumably, there is another #if somewhere that disables a block of code that uses multiple threads if the NO_THREAD symbol is present.
Is this possible to check in assembly what client (winforms app or asp.net page) is running it?
I want to add some methods but only for specific client.
I know, there is predefined DEBUG (#if DEBUG). Where can I find full list, what can I check using preprocessor?
To expand on m0sa's answer, preprocessor directives are basically just a string passed to the compiler.
If you are so inclined, you can add new build configurations (example: instead of Debug/AnyCPU and Release/AnyCPU, you could make WebDebug/AnyCPU, WinformsDebug/AnyCPU, WebRelease/AnyCPU, etc).
Then in the properties page of your project, for each configuration you could provide a value in the 'Conditional compilation symbols' field. For example, for WebDebug and WebRelease, you could provide the conditional symbol WEB. Then, you would be able to use:
#if WEB
using MyNamespace.WebStuff;
#endif
You will need multiple build configurations for that and define different a preprocessor directive for each one. You can set the conditional preprocessor directives in the Build tab of the project Properties page.There are no other directives defined, just the DEBUG directive which you can turn on and off (together with the TRACE directive) in the same tab. Note that DEBUG it is not defined for the "release" build configuration. This is kind of what you will need to do to enable different versions of the assembly to be built.
References:
MSDN
www.davidarno.org <-- see this one for a more visual description
Scattered throughout a software project I am working on are many lines of code that were written for debugging and utility purposes. Before I compile my code, I want a way to select whether or not these blocks of code should be included into my compile (something that won't require navigating the code commenting out). How can I do this?
I'm programming in c# and using Microsoft Visual Studio 2010.
Add the attribute [Conditional("DEBUG")] onto methods you only want to have execute in your debug build. See here for more detailed information.
I would suggest enclosing your blocks in #ifdef SOMETHING and #endif, and then defining SOMETHING in your project settings when you want to include that block in your compile.
You need preprocessor directives, or conditional compile statements. You can read about them here.
An example from that link:
#define TEST
using System;
public class MyClass
{
public static void Main()
{
#if (TEST)
Console.WriteLine("TEST is defined");
#else
Console.WriteLine("TEST is not defined");
#endif
}
}
The code is only compiled if TEST is defined at the top of the code. A lot of developers use #define DEBUG so they can enable debugging code and remove it again just by altering that one line at the top.
Consider using the Debug class to conditionally log, assert, etc. There are many advantages to this. You can choose to log (or not) at runtime. They limit you to (mostly) non-behavior-changing actions, addressing some of #STW's (valid) concern. They allow the use of third-party logging tools.
If they are for debugging, then the only acceptable solution is to surround such code with:
#ifdef DEBUG
#endif
This ensures that the code is included when you compile in debug mode but excluded in release mode.
You can use preprocessor directives w/ #if
You may want to consider moving these debugging functions out of the classes entirely--having your classes "change shape" between Debug and Release mode can be a real headache and can be difficult to diagnose problems.
You could consider creating a seperate "Debug" assembly which contains all your debugging helpers--then just make sure you can exclude it from the solution and build successfully without it.