- C Conditional Compile For Dev Vs Production 1
- C Conditional Compile For Dev Vs Production Software
- C Conditional Compile For Dev Vs Productions
- Aug 17, 2017 Ryzen vs Intel compilation times, 07:13 PM. I currently have an i7 950 and I want to get a new processor. EngineBuildBatchFilesBuild.bat ShaderCompileWorker Win64 Development EngineBuildBatchFilesBuild.bat UE4Editor Win64 Development. I remember getting 45 minutes on compiling 4.11 or earlier versions!
- Production Deployment. Most of the tips below are enabled by default if you are using Vue CLI. This section is only relevant if you are using a custom build setup. Turn on Production Mode. During development, Vue provides a lot of warnings to help you with common errors and pitfalls.
A conditional is a directive that instructs the preprocessor to select whether or not to include a chunk of code in the final token stream passed to the compiler. Preprocessor conditionals can test arithmetic expressions, or whether a name is defined as a macro, or both simultaneously using the special defined operator. A conditional in the C preprocessor resembles in some.
By Rick Anderson and Kirk Larkin
ASP.NET Core configures app behavior based on the runtime environment using an environment variable.
View or download sample code (how to download)
Environments
To determine the runtime environment, ASP.NET Core reads from the following environment variables:
ASPNETCORE_ENVIRONMENT
when ConfigureWebHostDefaults is called. The default ASP.NET Core web app templates callConfigureWebHostDefaults
. TheASPNETCORE_ENVIRONMENT
value overridesDOTNET_ENVIRONMENT
.
IHostEnvironment.EnvironmentName
can be set to any value, but the following values are provided by the framework:- Development : The launchSettings.json file sets
ASPNETCORE_ENVIRONMENT
toDevelopment
on the local machine. - Production : The default if
DOTNET_ENVIRONMENT
andASPNETCORE_ENVIRONMENT
have not been set.
The following code:
- Calls UseDeveloperExceptionPage when
ASPNETCORE_ENVIRONMENT
is set toDevelopment
. - Calls UseExceptionHandler when the value of
ASPNETCORE_ENVIRONMENT
is set toStaging
,Production
, orStaging_2
. - Injects IWebHostEnvironment into
Startup.Configure
. This approach is useful when the app only requires adjustingStartup.Configure
for a few environments with minimal code differences per environment. - Is similar to the code generated by the ASP.NET Core templates.
The Environment Tag Helper uses the value of IHostEnvironment.EnvironmentName to include or exclude markup in the element:
The About page from the sample code includes the preceding markup and displays the value of
IWebHostEnvironment.EnvironmentName
.On Windows and macOS, environment variables and values aren't case-sensitive. Linux environment variables and values are case-sensitive by default.
Create EnvironmentsSample
The sample code used in this document is based on a Razor Pages project named EnvironmentsSample.
The following code creates and runs a web app named EnvironmentsSample:
When the app runs, it displays some of the following output:
Development and launchSettings.json
The development environment can enable features that shouldn't be exposed in production. For example, the ASP.NET Core templates enable the Developer Exception Page in the development environment.
The environment for local machine development can be set in the PropertieslaunchSettings.json file of the project. Environment values set in launchSettings.json override values set in the system environment.
The launchSettings.json file:
- Is only used on the local development machine.
- Is not deployed.
- contains profile settings.
The following JSON shows the launchSettings.json file for an ASP.NET Core web projected named EnvironmentsSample created with Visual Studio or
dotnet new
:The preceding markup contains two profiles:
IIS Express
: The default profile used when launching the app from Visual Studio. The'commandName'
key has the value'IISExpress'
, therefore, IISExpress is the web server. You can set the launch profile to the project or any other profile included. For example, in the image below, selecting the project name launches the Kestrel web server.EnvironmentsSample
: The profile name is the project name. This profile is used by default when launching the app withdotnet run
. The'commandName'
key has the value'Project'
, therefore, the Kestrel web server is launched.
The value of
commandName
can specify the web server to launch. commandName
can be any one of the following:IISExpress
: Launches IIS Express.IIS
: No web server launched. IIS is expected to be available.Project
: Launches Kestrel.
The Visual Studio project properties Debug tab provides a GUI to edit the launchSettings.json file. Changes made to project profiles may not take effect until the web server is restarted. Kestrel must be restarted before it can detect changes made to its environment.
The following launchSettings.json file contains multiple profiles:
Profiles can be selected from Visual Studio or using
dotnet run --launch-profile <Profile Name>
.Warning
launchSettings.json shouldn't store secrets. The Secret Manager tool can be used to store secrets for local development.
When using Visual Studio Code, environment variables can be set in the .vscode/launch.json file. The following example sets several Host configuration values environment variables:
The .vscode/launch.json file is only used by Visual Studio Code.
Production
The production environment should be configured to maximize security, performance, and application robustness. Some common settings that differ from development include:
- Caching.
- Client-side resources are bundled, minified, and potentially served from a CDN.
- Diagnostic error pages disabled.
- Friendly error pages enabled.
- Production logging and monitoring enabled. For example, using Application Insights.
Set the environment
It's often useful to set a specific environment for testing with an environment variable or platform setting. If the environment isn't set, it defaults to
Production
, which disables most debugging features. The method for setting the environment depends on the operating system.When the host is built, the last environment setting read by the app determines the app's environment. The app's environment can't be changed while the app is running.
The About page from the sample code displays the value of
IWebHostEnvironment.EnvironmentName
.Azure App Service
To set the environment in Azure App Service, perform the following steps:
- Select the app from the App Services blade.
- In the Settings group, select the Configuration blade.
- In the Application settings tab, select New application setting.
- In the Add/Edit application setting window, provide
ASPNETCORE_ENVIRONMENT
for the Name. For Value, provide the environment (for example,Staging
). - Select the Deployment slot setting check box if you wish the environment setting to remain with the current slot when deployment slots are swapped. For more information, see Set up staging environments in Azure App Service in the Azure documentation.
- Select OK to close the Add/Edit application setting window.
- Select Save at the top of the Configuration blade.
Azure App Service automatically restarts the app after an app setting is added, changed, or deleted in the Azure portal.
Windows
C Conditional Compile For Dev Vs Production 1
Environment values in launchSettings.json override values set in the system environment.
To set the
ASPNETCORE_ENVIRONMENT
for the current session when the app is started using dotnet run, the following commands are used:Command prompt
PowerShell
The preceding command sets
ASPNETCORE_ENVIRONMENT
only for processes launched from that command window.To set the value globally in Windows, use either of the following approaches:
- Open the Control Panel > System > Advanced system settings and add or edit the
ASPNETCORE_ENVIRONMENT
value: - Open an administrative command prompt and use the
setx
command or open an administrative PowerShell command prompt and use[Environment]::SetEnvironmentVariable
:Command promptThe/M
switch indicates to set the environment variable at the system level. If the/M
switch isn't used, the environment variable is set for the user account.PowerShellTheMachine
option value indicates to set the environment variable at the system level. If the option value is changed toUser
, the environment variable is set for the user account.
When the
ASPNETCORE_ENVIRONMENT
environment variable is set globally, it takes effect for dotnet run
in any command window opened after the value is set. Environment values in launchSettings.json override values set in the system environment.web.config
To set the
ASPNETCORE_ENVIRONMENT
environment variable with web.config, see the Setting environment variables section of ASP.NET Core Module.Project file or publish profile
For Windows IIS deployments: Include the
<EnvironmentName>
property in the publish profile (.pubxml) or project file. This approach sets the environment in web.config when the project is published:Per IIS Application Pool
To set the
ASPNETCORE_ENVIRONMENT
environment variable for an app running in an isolated Application Pool (supported on IIS 10.0 or later), see the AppCmd.exe command section of the Environment Variables <environmentVariables> topic. When the ASPNETCORE_ENVIRONMENT
environment variable is set for an app pool, its value overrides a setting at the system level.When hosting an app in IIS and adding or changing the
ASPNETCORE_ENVIRONMENT
environment variable, use any one of the following approaches to have the new value picked up by apps:- Execute
net stop was /y
followed bynet start w3svc
from a command prompt. - Restart the server.
macOS
Setting the current environment for macOS can be performed in-line when running the app:
Alternatively, set the environment with
export
prior to running the app:Machine-level environment variables are set in the .bashrc or .bash_profile file. Edit the file using any text editor. Add the following statement:
Linux
For Linux distros, use the
export
command at a command prompt for session-based variable settings and bash_profile file for machine-level environment settings.Set the environment in code
Call UseEnvironment when building the host. See .NET Generic Host.
Configuration by environment
To load configuration by environment, see Configuration in ASP.NET Core.
Environment-based Startup class and methods
Inject IWebHostEnvironment into the Startup class
Inject IWebHostEnvironment into the
Startup
constructor. This approach is useful when the app requires configuring Startup
for only a few environments with minimal code differences per environment.C Conditional Compile For Dev Vs Production Software
In the following example:
- The environment is held in the
_env
field. _env
is used inConfigureServices
andConfigure
to apply startup configuration based on the app's environment.
Startup class conventions
When an ASP.NET Core app starts, the Startup class bootstraps the app. The app can define multiple
Startup
classes for different environments. The appropriate Startup
class is selected at runtime. The class whose name suffix matches the current environment is prioritized. If a matching Startup{EnvironmentName}
class isn't found, the Startup
class is used. This approach is useful when the app requires configuring startup for several environments with many code differences per environment. Typical apps will not need this approach.To implement environment-based
Startup
classes, create a Startup{EnvironmentName}
classes and a fallback Startup
class:Use the UseStartup(IWebHostBuilder, String) overload that accepts an assembly name:
Startup method conventions
Configure and ConfigureServices support environment-specific versions of the form
Configure<EnvironmentName>
and Configure<EnvironmentName>Services
. This approach is useful when the app requires configuring startup for several environments with many code differences per environment:Additional resources
By Rick Anderson
ASP.NET Core configures app behavior based on the runtime environment using an environment variable.
View or download sample code (how to download)
Environments
ASP.NET Core reads the environment variable
ASPNETCORE_ENVIRONMENT
at app startup and stores the value in IHostingEnvironment.EnvironmentName. ASPNETCORE_ENVIRONMENT
can be set to any value, but three values are provided by the framework:- Production (default)
The preceding code:
- Calls UseDeveloperExceptionPage when
ASPNETCORE_ENVIRONMENT
is set toDevelopment
. - Calls UseExceptionHandler when the value of
ASPNETCORE_ENVIRONMENT
is set one of the following:Staging
Production
Staging_2
The Environment Tag Helper uses the value of
IHostingEnvironment.EnvironmentName
to include or exclude markup in the element:On Windows and macOS, environment variables and values aren't case-sensitive. Linux environment variables and values are case-sensitive by default.
Development
The development environment can enable features that shouldn't be exposed in production. For example, the ASP.NET Core templates enable the Developer Exception Page in the development environment.
The environment for local machine development can be set in the PropertieslaunchSettings.json file of the project. Environment values set in launchSettings.json override values set in the system environment.
The following JSON shows three profiles from a launchSettings.json file:
Note
The
applicationUrl
property in launchSettings.json can specify a list of server URLs. Use a semicolon between the URLs in the list:When the app is launched with dotnet run, the first profile with
'commandName': 'Project'
is used. The value of commandName
specifies the web server to launch. commandName
can be any one of the following:IISExpress
IIS
Project
(which launches Kestrel)
When an app is launched with dotnet run:
- launchSettings.json is read if available.
environmentVariables
settings in launchSettings.json override environment variables. - The hosting environment is displayed.
The following output shows an app started with dotnet run:
The Visual Studio project properties Debug tab provides a GUI to edit the launchSettings.json file:
Changes made to project profiles may not take effect until the web server is restarted. Kestrel must be restarted before it can detect changes made to its environment.
Warning
launchSettings.json shouldn't store secrets. The Secret Manager tool can be used to store secrets for local development.
When using Visual Studio Code, environment variables can be set in the .vscode/launch.json file. The following example sets the environment to
Development
:A .vscode/launch.json file in the project isn't read when starting the app with
dotnet run
in the same way as Properties/launchSettings.json. When launching an app in development that doesn't have a launchSettings.json file, either set the environment with an environment variable or a command-line argument to the dotnet run
command.Production
The production environment should be configured to maximize security, performance, and app robustness. Some common settings that differ from development include:
- Caching.
- Client-side resources are bundled, minified, and potentially served from a CDN.
- Diagnostic error pages disabled.
- Friendly error pages enabled.
- Production logging and monitoring enabled. For example, Application Insights.
Set the environment
It's often useful to set a specific environment for testing with an environment variable or platform setting. If the environment isn't set, it defaults to
Production
, which disables most debugging features. The method for setting the environment depends on the operating system.When the host is built, the last environment setting read by the app determines the app's environment. The app's environment can't be changed while the app is running.
Environment variable or platform setting
Azure App Service
To set the environment in Azure App Service, perform the following steps:
![C Conditional Compile For Dev Vs Production C Conditional Compile For Dev Vs Production](/uploads/1/2/6/0/126004855/136680992.jpg)
- Select the app from the App Services blade.
- In the Settings group, select the Configuration blade.
- In the Application settings tab, select New application setting.
- In the Add/Edit application setting window, provide
ASPNETCORE_ENVIRONMENT
for the Name. For Value, provide the environment (for example,Staging
). - Select the Deployment slot setting check box if you wish the environment setting to remain with the current slot when deployment slots are swapped. For more information, see Set up staging environments in Azure App Service in the Azure documentation.
- Select OK to close the Add/Edit application setting window.
- Select Save at the top of the Configuration blade.
Azure App Service automatically restarts the app after an app setting (environment variable) is added, changed, or deleted in the Azure portal.
Windows
To set the
ASPNETCORE_ENVIRONMENT
for the current session when the app is started using dotnet run, the following commands are used:Command prompt
PowerShell
These commands only take effect for the current window. When the window is closed, the
ASPNETCORE_ENVIRONMENT
setting reverts to the default setting or machine value.To set the value globally in Windows, use either of the following approaches:
- Open the Control Panel > System > Advanced system settings and add or edit the
ASPNETCORE_ENVIRONMENT
value: - Open an administrative command prompt and use the
setx
command or open an administrative PowerShell command prompt and use[Environment]::SetEnvironmentVariable
:Command promptThe/M
switch indicates to set the environment variable at the system level. If the/M
switch isn't used, the environment variable is set for the user account.PowerShellTheMachine
option value indicates to set the environment variable at the system level. If the option value is changed toUser
, the environment variable is set for the user account.
When the
ASPNETCORE_ENVIRONMENT
environment variable is set globally, it takes effect for dotnet run
in any command window opened after the value is set.web.config
To set the
ASPNETCORE_ENVIRONMENT
environment variable with web.config, see the Setting environment variables section of ASP.NET Core Module.Project file or publish profile
For Windows IIS deployments: Include the
<EnvironmentName>
property in the publish profile (.pubxml) or project file. This approach sets the environment in web.config when the project is published:Per IIS Application Pool
To set the
ASPNETCORE_ENVIRONMENT
environment variable for an app running in an isolated Application Pool (supported on IIS 10.0 or later), see the AppCmd.exe command section of the Environment Variables <environmentVariables> topic. When the ASPNETCORE_ENVIRONMENT
environment variable is set for an app pool, its value overrides a setting at the system level.Important
When hosting an app in IIS and adding or changing the
ASPNETCORE_ENVIRONMENT
environment variable, use any one of the following approaches to have the new value picked up by apps:- Execute
net stop was /y
followed bynet start w3svc
from a command prompt. - Restart the server.
![C conditional compile for dev vs production 1 C conditional compile for dev vs production 1](/uploads/1/2/6/0/126004855/328849554.png)
macOS
Setting the current environment for macOS can be performed in-line when running the app:
Alternatively, set the environment with
export
prior to running the app:Machine-level environment variables are set in the .bashrc or .bash_profile file. Edit the file using any text editor. Add the following statement:
Linux
For Linux distros, use the
export
command at a command prompt for session-based variable settings and bash_profile file for machine-level environment settings.Set the environment in code
Call UseEnvironment when building the host. See ASP.NET Core Web Host.
Configuration by environment
To load configuration by environment, we recommend:
- appsettings files (appsettings.{Environment}.json). See Configuration in ASP.NET Core.
- Environment variables (set on each system where the app is hosted). See ASP.NET Core Web Host and Safe storage of app secrets in development in ASP.NET Core.
- Secret Manager (in the Development environment only). See Safe storage of app secrets in development in ASP.NET Core.
Environment-based Startup class and methods
Inject IHostingEnvironment into Startup.Configure
Inject IHostingEnvironment into
Startup.Configure
. This approach is useful when the app only requires configuring Startup.Configure
for only a few environments with minimal code differences per environment.Inject IHostingEnvironment into the Startup class
Inject IHostingEnvironment into the
Startup
constructor and assign the service to a field for use throughout the Startup
class. This approach is useful when the app requires configuring startup for only a few environments with minimal code differences per environment.In the following example:
C Conditional Compile For Dev Vs Productions
- The environment is held in the
_env
field. _env
is used inConfigureServices
andConfigure
to apply startup configuration based on the app's environment.
Startup class conventions
When an ASP.NET Core app starts, the Startup class bootstraps the app. The app can define separate
Startup
classes for different environments (for example, StartupDevelopment
). The appropriate Startup
class is selected at runtime. The class whose name suffix matches the current environment is prioritized. If a matching Startup{EnvironmentName}
class isn't found, the Startup
class is used. This approach is useful when the app requires configuring startup for several environments with many code differences per environment.To implement environment-based
Startup
classes, create a Startup{EnvironmentName}
class for each environment in use and a fallback Startup
class:Use the UseStartup(IWebHostBuilder, String) overload that accepts an assembly name:
Startup method conventions
Configure and ConfigureServices support environment-specific versions of the form
Configure<EnvironmentName>
and Configure<EnvironmentName>Services
. This approach is useful when the app requires configuring startup for several environments with many code differences per environment.Additional resources
-->While you are debugging an application during development, both your tracing and debugging output go to the Output window in Visual Studio. However, to include tracing features in a deployed application, you must compile your instrumented applications with the TRACE compiler directive enabled. This allows tracing code to be compiled into the release version of your application. If you do not enable the TRACE directive, all tracing code is ignored during compilation and is not included in the executable code that you will deploy.
Both the tracing and debugging methods have associated conditional attributes. For example, if the conditional attribute for tracing is true, all trace statements are included within an assembly (a compiled .exe file or .dll); if the Trace conditional attribute is false, the trace statements are not included.
You can have either the Trace or Debug conditional attribute turned on for a build, or both, or neither. Thus, there are four types of build: Debug, Trace, both, or neither. Some release builds for production deployment might contain neither; most debugging builds contain both.
You can specify the compiler settings for your application in several ways:
- The property pages
- The command line
- #CONST (for Visual Basic) and #define (for C#)
To change compile settings from the property pages dialog box
- Right-click the project node in Solution Explorer.
- Choose Properties from the shortcut menu.
- In Visual Basic, click the Compile tab in the left pane of the property page, then click the Advanced Compile Options button to display the Advanced Compiler Settings dialog box. Select the check boxes for the compiler settings you want to enable. Clear the check boxes for settings you want to disable.
- In C#, click the Build tab in the left pane of the property page, then select the check boxes for the compiler settings you want to enable. Clear the check boxes for settings you want to disable.
To compile instrumented code using the command line
- Set a conditional compiler switch on the command line. The compiler will include trace or debug code in the executable.For example, the following compiler instruction entered on the command line would include your tracing code in a compiled executable:For Visual Basic: vbc -r:System.dll -d:TRACE=TRUE -d:DEBUG=FALSE MyApplication.vbFor C#: csc -r:System.dll -d:TRACE -d:DEBUG=FALSE MyApplication.csTipTo compile more than one application file, leave a blank space between the file names, for example, MyApplication1.vb MyApplication2.vb MyApplication3.vb or MyApplication1.cs MyApplication2.cs MyApplication3.cs.The meaning of the conditional-compilation directives used in the above examples is as follows:
Directive Meaning vbc
Visual Basic compiler csc
C# compiler -r:
References an external assembly (EXE or DLL) -d:
Defines a conditional compilation symbol NoteYou must spell TRACE or DEBUG with uppercase letters. For more information about the conditional compilation commands, entervbc /?
(for Visual Basic) orcsc /?
(for C#) at the command prompt. For more information, see Building from the Command Line (C#) or Invoking the Command-Line Compiler (Visual Basic).
To perform conditional compilation using #CONST or #define
- Type the appropriate statement for your programming language at the top of the source code file.
Language Statement Result Visual Basic #CONST TRACE = true Enables tracing #CONST TRACE = false Disables tracing #CONST DEBUG = true Enables debugging #CONST DEBUG = false Disables debugging C# #define TRACE Enables tracing #undef TRACE Disables tracing #define DEBUG Enables debugging #undef DEBUG Disables debugging
To disable tracing or debugging
Delete the compiler directive from your source code.
- or -
Comment out the compiler directive.
Note
When you are ready to compile, you can either choose Build from the Build menu, or use the command line method but without typing the d: to define conditional compilation symbols.