Skip to main content

Custom configuration files for each developer machine

I think that all of you use configuration files. When we are working with a complex project, where many developers need to configure their environment in a way to have a custom configuration, there are cases when they install some application in different locations for example, or they have the SQL server with a different name.
What we can do with these cases? In a perfect world we would not have this problem, but for example a part of the team want to use the SQL Azure and another part of the team want to use their own SQL server instance.
When the configuration is in the web.config or in the app.config, Microsoft offer to us a very nice solution. We can have different configuration for each developer (on their local machine). Each time we will rebuild the solution, the configuration file will be regenerated.
This feature is supported from Visual Studio 2008 2010, but is not well known by all developers. In the next part of the post we will see how we can configure our project to support this functionality.
  • First step that need to be done is to remove the web.config file from TFS. This simple trick can be done if you follow the next steps:
  • Select your project, right-click on it and unload it (“Unload Project”)
  • Select your unloaded project, right-click on it and open with the XML editor (“Edit [ProjectName]”)
  • Search all the node named “Content” where the “Include” attribute point to the configuration files
  • Comment all the “DependentUpon” nodes that are under these nodes
  • Save the file and reload the project (right-click on the project and click on “Reload Project”)
<Content Include="Web.Debug.config">
  <!--<DependentUpon>Web.config</DependentUpon>-->
</Content>
<Content Include="Web.Release.config">
  <!--<DependentUpon>Web.config</DependentUpon>-->
</Content>
  • Duplicate the configuration file and rename the copy to “Web.base.config”
  • Remove the web.config file from TFS
In this moment we excluded the configuration file from TFS. Also we create a base configuration file that will be used by the system as the original configuration file.
After this step you can reopen the project with the XML editor and uncomment the “DependentUpon” nodes.
Now, we need to specify to the build to recreate the configuration file at each build using the base configuration file and the custom configuration files that can be found in the project. Next steps need to be done to be able to define this functionality:
  • Add a file to your project named[YourProjectName].wpp.targets
  • Add the following content to it:
Visual Studio 2010:
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
    <UsingTask TaskName="TransformXml"
               AssemblyFile="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v10.0\Web\Microsoft.Web.Publishing.Tasks.dll"/>  
    <Target Name="CopyWebConfig" BeforeTargets="Build;Rebuild">
        <Copy SourceFiles="Web.base.config"
              DestinationFiles="Web.config"
              OverwriteReadOnlyFiles="true"
              SkipUnchangedFiles="false" />
    </Target>
    <Target Name="CustomTarget" BeforeTargets="BeforeBuild">
        <Message Text="Transforming: Web.$(Configuration).config" Importance="high" />
        <TransformXml Source="Web.base.config"
                      Transform="Web.$(Configuration).config"
                      Destination="Web.config" />
    </Target>
</Project>
Visual Studio 2012:
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
    <UsingTask TaskName="TransformXml"
               AssemblyFile="$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v11.0\Web\Microsoft.Web.Publishing.Tasks.dll"/>  
    <Target Name="CopyWebConfig" BeforeTargets="Build;Rebuild">
        <Copy SourceFiles="Web.base.config"
              DestinationFiles="Web.config"
              OverwriteReadOnlyFiles="true"
              SkipUnchangedFiles="false" />
    </Target>
    <Target Name="CustomTarget" BeforeTargets="BeforeBuild">
        <Message Text="Transforming: Web.$(Configuration).config" Importance="high" />
        <TransformXml Source="Web.base.config"
                      Transform="Web.$(Configuration).config"
                      Destination="Web.config" />
    </Target>
</Project>

This file is necessary in the build process to create the configuration file based on the base file and our custom configuration file that we will add.
Because each build configuration is custom for each machine, we can add many build configurations we want. For each build configuration we can add a custom configuration file. Let’s see how we can add a build configuration and to generate a configuration file for our custom build:
  • Go to “Build” menu from Visual Studio and select “Configuration Manager”
  • On the “Active solution configuration” combo-box select “New” and create a new build configuration with any name you want. I recommend a name like [username.machinename]
  • Close the “Configuration Manager” windows
  • Right-click on the configuration file from your project and click on “Add Config Transform”
  • Success, the system created our custom configuration file.  Don’t forget to NOT check-in this configuration file to the TFS. Also the “Add Config Transform” will be active only when there are some new changes in the “Configuration Manager”.
From now on when we will run our application using our custom configuration for the build, the configuration file will be recreated using the base configuration and our custom configuration file, specified for our custom build.
In this way we can have custom configuration on each developer machine without any kind of problemes.

Comments

  1. Nice :)
    Using this solution, is it possible for a developer to have separate solution configurations for Debug/Release/etc.. ?

    ReplyDelete
    Replies
    1. You can have any kind of configuration. Your current build will not be named Debug for examle. Will be named MyCustomBuild. This happens because you need to create a new "Configuration Manager" for your build.

      Delete
  2. This comment has been removed by a blog administrator.

    ReplyDelete

Post a Comment

Popular posts from this blog

Windows Docker Containers can make WIN32 API calls, use COM and ASP.NET WebForms

After the last post , I received two interesting questions related to Docker and Windows. People were interested if we do Win32 API calls from a Docker container and if there is support for COM. WIN32 Support To test calls to WIN32 API, let’s try to populate SYSTEM_INFO class. [StructLayout(LayoutKind.Sequential)] public struct SYSTEM_INFO { public uint dwOemId; public uint dwPageSize; public uint lpMinimumApplicationAddress; public uint lpMaximumApplicationAddress; public uint dwActiveProcessorMask; public uint dwNumberOfProcessors; public uint dwProcessorType; public uint dwAllocationGranularity; public uint dwProcessorLevel; public uint dwProcessorRevision; } ... [DllImport("kernel32")] static extern void GetSystemInfo(ref SYSTEM_INFO pSI); ... SYSTEM_INFO pSI = new SYSTEM_INFO(

Azure AD and AWS Cognito side-by-side

In the last few weeks, I was involved in multiple opportunities on Microsoft Azure and Amazon, where we had to analyse AWS Cognito, Azure AD and other solutions that are available on the market. I decided to consolidate in one post all features and differences that I identified for both of them that we should need to take into account. Take into account that Azure AD is an identity and access management services well integrated with Microsoft stack. In comparison, AWS Cognito is just a user sign-up, sign-in and access control and nothing more. The focus is not on the main features, is more on small things that can make a difference when you want to decide where we want to store and manage our users.  This information might be useful in the future when we need to decide where we want to keep and manage our users.  Feature Azure AD (B2C, B2C) AWS Cognito Access token lifetime Default 1h – the value is configurable 1h – cannot be modified

What to do when you hit the throughput limits of Azure Storage (Blobs)

In this post we will talk about how we can detect when we hit a throughput limit of Azure Storage and what we can do in that moment. Context If we take a look on Scalability Targets of Azure Storage ( https://azure.microsoft.com/en-us/documentation/articles/storage-scalability-targets/ ) we will observe that the limits are prety high. But, based on our business logic we can end up at this limits. If you create a system that is hitted by a high number of device, you can hit easily the total number of requests rate that can be done on a Storage Account. This limits on Azure is 20.000 IOPS (entities or messages per second) where (and this is very important) the size of the request is 1KB. Normally, if you make a load tests where 20.000 clients will hit different blobs storages from the same Azure Storage Account, this limits can be reached. How we can detect this problem? From client, we can detect that this limits was reached based on the HTTP error code that is returned by HTTP