I have several classes in a project which need to only be in certain builds of the application which are currently not ready for release or debug.
To prevent these classes from being used, I want to set around them this:
#if USE_MYCLASS
// Code here...
#endif
Unfortunately, I don't know how to setup a project-wide #define.
Is there functionality in Visual Studio to set project-wide definitions?
If there is, though I don't need it right now, is there a functionality to set solution-wide definitions?
If there is no functionality for such (seeing as C# does not have include files, I suppose it's possible), is there any method or plugin of doing this functionality without using the command line compiler and /D?
You can do that in the project properties, but not in source code.
Project Properties => Build => Conditional compilation symbols
You can specify whichever symbols you need (space delimited, but IIRC is is quite forgiving). Note that DEBUG and TRACE can also be toggled with a checkbox.
I have some projects with multiple "release" build configurations, with different symbols in each (for building 2.0 vs 3.0 vs 3.5 versions - see <DefineConstants> here)
Related
For example, I have two projects let's say project A and project B. I have the source code of project A and project B.
Then in my project A, there are some .a files made by project B. Project A use those .a files to compile and run.
The question is, when I run project A, I want to debug the codes in those .a file. Is it possible? If possible, how can I do it?
I'm using Visual Studio for Mac.
Note: Project A is written in C# and Project B is written in C++.
It‘s a Xamarin project.
If you have no source code of project B, then you can only debug in assembly mode.
If you do have source code of project B, make sure .a files reserving debug info(like dwarf) and use lldb source-map technique to perform mapping.
But, if you have .a file's source, why not just build with project B source.
You need to attach with Visual studio to the running process. Attaching to process with Visual Studio is done with Alt + Ctrl + P on windows.
In case the code you wish to debug is run at startup of your app, place your breakpoints and add a 30 seconds sleep (before any of your breakpoints) so you have time to attach.
When picking the process, make sure to tick the right code types to debug by clicking Select...
If you have access to source code for both projects, I would recommend to create a solution with both projects, as you may be able to use different language projects on same solution (please check this, as an example: https://social.msdn.microsoft.com/Forums/en-US/737e2bf3-86ab-49aa-bafa-b3a3d05ce826/mixed-languages-in-visual-studio?forum=csharpgeneral).
To debug C++ code inside the C# project, check options for your current Visual Studio version, as suggested in this post:
Debug c++ dll in C#
Set project A (C#) as start project, and, if references are correct, you should be able to debug .a files referenced from project B.
You can build both Debug and Release into separate preset directories in any IDE. This is a good practice for all builds - using Configuration -> Release and Debug. You may name the libraries as libname_d.lib and libname.a so they do not get mixed up.
Then you can link to the appropriate library (libname_d.a) while debugging. Its a matter of choice - some may not recommend linking multiple projects into the same Solution (or Workspace), since each separate library will have a separate set of tests. These are difficult to manage in a single project.
Ideally, each library can be coded and tested separately and built into Release and Debug. This way functionality can be isolated and object-based design can be followed.
Its also important to understand the difference between .a (Linux, Mac) and .lib (Windows) - see here - What's the difference between .lib and .a files?
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 need to add some logging to my app, and it needs to be in release mode, and I need to make sure that the logging code isn't running in production. Therefore I'd like to use a #define and #if to make sure the log statements are removed when I move to production.
Trouble is, I need the logging in multiple files, and it's a pain to put a #define at the top of every file. Is there a way to have a centralized #define? That way I can remove the single #define rather than a #define from all files(which means I'll almost assuredly forget one).
On the command line, use the /define switch. In Visual Studio, choose the "Build" tab from the properties page for the project and fill in the "Conditional Compilation Symbols" section.
Consider also instead of using conditional compilation, to instead make your logging methods conditional methods. That's a more pleasant-looking alternative. That's how Debug.Assert works; it is a conditional method, so if the debug preprocessor symbol is not defined, the compiler simply removes all calls to the method before code generation.
See also my article on the subject:
http://ericlippert.com/2009/09/10/whats-the-difference-between-conditional-compilation-and-the-conditional-attribute/
Are you using Visual Studio? In the project Properties page, on the "Build" tab, there's a "Conditional compilation symbols" text box.
Yes, this is typically done in your build file, or the script you use which creates your build. You specify it as command-line arguments to MSBuild.
To add to Dave's answer, global conditional compilation symbols can also be specified in Visual.
Right-click on your project and go to Properties
Go to the Build tab
You can specify the symbols that you like (DEBUG is already turned on by default for Debug configurations, so this might actually give you what you want already) for the given configuration, or select "All Configurations" at the top to specify certain symbols for all configurations.
Call the logging everywhere you want.
Define the logging api entry methods with
[Conditional ("DEBUG")]
public void WriteDebugMessage(...)
Build your program in debug mode (which, by default, defines 'DEBUG' in VS). These calls will be part of your assembly.
Build your program in release mode (or - remove the DEBUG symbol from the build definition). These calls are now meaningless no-ops and won't run.
Seems like what you want?
I have a base library to maintain in multiple versions. I do a SVN switch whenever I need to work on another version.
I don't have multiple versions of my test application solution, so I thought that for different versions I could do multiple solution / project configurations that define symbols for the version to be able to have version-specific code in my test.
Currently I have the following build configurations in the test application solution: Debug, Release, DebugV10, ReleaseV10, DebugV15, ReleaseV15. In the *V10 and *V15 configs, I created and selected corresponding *V10 and *V15 PROJECT configurations for the two projects that have version-specific test code (not for all projects, most run normal Debug / Release configuration in the solution -Vx configuration).
In those project configurations I entered the corresponding conditional compilation symbols (VERSION10 and VERSION15).
Now in my code in the project I go like
#if VERSION10
// do v1.0 stuff
#elif VERSION15
// do v1.5 stuff
#else
// do trunk stuff
#endif
But apparently VS doesn't recognize the symbols. Even a simple #if DEBUG does not work anymore, allthoug define DERBUG constant is checked in all Debug* project configurations.
Is this a known thing? What can I do about it?
The concept that you describe sounds fine.
That is, the code uses:
#if VERSION10 ... #endif
and the Project configuration defines VERSION10
and a Solution configuration is set up that is set to use the above Project configuration.
As long as these are all set up correctly, I'd expect it to work.
The fact that you say even #if DEBUG isn't working as expected suggests that something is very broken.
I'd suggest you try the simplest possible case, to ensure you undersatand how to set it up: Create a new minimal "hello world" application that just has simple code that allows you to tell apart the versions:
#if VERSION1
Console.WriteLine("Hello from version 1");
#else
Console.WriteLine("Hello from version 2");
#endif
Then create project configurations ("Debug Version 1", "Debug version 2") and see if you can set them up (one with VERSION1 defined, one without) to get the two outputs when built.
Then add Solution configurations that use the above Project configurations, and build them to check that they print the right things when executed.
Once you've done this you should have a working system (an understanding of how these elements relate to each other) that you can apply back to your more complex project. To apply them back, I suggest deleting most of the project/solution configurations and then rebuilding them from scratch now that you are sure you know what to do - often rebuilding these things from first principles works out better than trying to tweak an existing 'broken' setup back into life.
Conditional compilation in C# is different from C and C++. See here for info on the ConditionalAttribute class.
For example:
doDebugOutput(); // unconditionally call the optional code
Conditional["DEBUG"]
void DoDebugOutput()
{
// do expensive debug-only output here
}