{"id":31389,"date":"2017-06-13T13:24:35","date_gmt":"2017-06-13T20:24:35","guid":{"rendered":"https:\/\/blog.xamarin.com\/?p=31389"},"modified":"2019-04-04T08:30:53","modified_gmt":"2019-04-04T15:30:53","slug":"demystifying-build-configurations","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/xamarin\/demystifying-build-configurations\/","title":{"rendered":"Demystifying Build Configurations"},"content":{"rendered":"

\t\t\t\tMost developers are familiar with the Debug<\/code> and Release<\/code> configurations in most solution templates in use. It seems obvious to use the Debug<\/code> configuration when building your project for debugging and to use the Release<\/code> configuration when building your project for release. What may be less clear, though, is what’s actually happening when you switch configurations, or how to add your own custom configurations. Today, we’re going to dive a little deeper into the world of build configurations to see how they can greatly improve your build times and productivity.<\/p>\n

\"\"<\/p>\n

\"\"<\/p>\n

What Are Configurations?<\/h2>\n

Simply stated, configurations are a set of project properties. In the default Debug<\/code> configuration, for instance, debugging will be enabled, while in a Release<\/code> configuration it will not be. You can set what linker options to use in each configuration, what architectures (CPUs) to build for, etc. You can also further define platforms so that you can have separate project settings depending on whether you are building for a device or emulator. In other words, you can set separate project settings for each Configuration|Platform<\/code> combination that you have available in your project.<\/p>\n

How Can I Edit a Configuration?<\/h2>\n

To illustrate how to edit, and later add, a configuration we’ll start with a template Android project:<\/p>\n

In VS for Mac<\/em> create a new “Android App”: New Project > Android > App > Android App.
\nIn VS for Windows<\/em> create a “Single-View App (Android)”: Create new project… > Android > Single-View App (Android).<\/p>\n

The template creates a simple Android app with a button that counts clicks. It has two configurations set up by default, Debug<\/code> and Release<\/code>, and one platform, AnyCPU<\/code>. These are simply names that don’t have any inherent meaning, except being reflective of when the configuration should be used. We’re going to add two new configurations named DebugDevice<\/code> and DebugEmulator<\/code> later on. These will allow us to quickly set the desired project options\/properties when debugging to a device (ARM) or an emulator (x86). Each will only build for the architectures needed for a device or an emulator, reducing build time during development.<\/p>\n

First, let’s see what’s different between the two default Debug<\/code> and Release<\/code> configurations. To do so, open the project properties by right-clicking on the project in the solution explorer and selecting “Options” (VS for Mac) or “Properties” (VS for Windows). Once the project options\/properties are open, you’ll see configuration and platform fields towards the top with drop-down lists to select which configuration and platform you want to see the property settings for.<\/p>\n

\"Project<\/p>\n

\"Project<\/p>\n

The drop-down may not be there (VS for Mac) or disabled (VS for Windows), which means that the settings on the settings page you have selected are global, i.e. they will apply to all configurations and platforms. You can see this for the Build > General settings page in VS for Mac and in the Application settings page in VS for Windows.<\/p>\n

Most of the differences in the project settings for the default Debug<\/code> and Release<\/code> configurations are in the Android Build \/ Android Options settings page shown above. Open the project options\/properties and select the Android Build (VS for Mac) \/ Android Options (VS for Windows) on the left. Make sure Debug<\/code> is selected at the top in the configuration drop down. Note that the “Use Shared Mono Runtime” on VS for Mac or “Use Shared Runtime” in VS for Windows is selected, as well as the “Fast Assembly Deployment” (VS for Mac) \/ “Use Fast Deployment” (VS for Windows) option.<\/p>\n

These are great options when you are debugging as they will decrease build and deploy times when developing an app, but they are not at all good for building a release version as it is unlikely that an end user will have a shared mono runtime installed on their Android devices so the app would fail to run at all since there would be no runtime. For Release<\/code> builds you would want to disable that option. If you now select Release<\/code> in the configuration drop-down at the top, you will see that the default Release<\/code> configuration has those options disabled.<\/p>\n

You can check the Linker behaviour of the respective configurations:<\/p>\n

In VS for Mac:<\/em> In the Android Build page select the “Linker” tab. You will see the “Linking Behaviour” is set to “Don’t Link” for Debug<\/code> configuration and “Link SDK assemblies only” for Release<\/code> configuration.\nIn VS for Windows:<\/em> In the Android Options page scroll to the “Linker Properties” section. You will see the “Linking” option is set to “None” for Debug<\/code> configuration and “SDK assemblies only” for Release<\/code> configuration.<\/p>\n

These default options allow for faster build during debugging and a smaller app bundle for your release build.<\/p>\n

The “Advanced” tab (Mac)\/button (Windows) allows you to set which CPUs (ABIs) to build for when building for Debug or Release. You will note that by default the Debug configuration builds for all possible CPUs. Every CPU you build for will take time so it might be nice to streamline this so we are only building for the CPU we will be running the app on. If we are only testing on an x86 emulator, then we can only build for x86 and deselect the other ABIs that are not needed. Go ahead and deselect all but x86 using the Advanced tab\/button.<\/p>\n

Congratulations, you have now just edited a configuration. Editing a configuration is as simple as opening the Project Options\/Properties, selecting the configuration you want to change settings for, and changing those settings.<\/p>\n

How Can I Add a Configuration?<\/h2>\n

Wouldn’t it be nice if you could easily choose which architectures to build for during debugging simply by selecting a configuration? If debugging to a device I choose one configuration, DebugDevice<\/code>, and for building to an emulator I choose DebugEmulator<\/code>. Let’s get that set up.<\/p>\n

Visual Studio for Mac:<\/h3>\n

To add a configuration in Visual Studio for Mac:<\/p>\n

    \n
  1. Open the Solution Options by double clicking on the solution in the solution explorer.<\/li>\n
  2. Select Build > Configurations on the left (not<\/em> Run > Configurations).
    \n \"\"<\/li>\n
  3. Since we want a variant of the Debug<\/code> configuration, in the configuration list select Debug<\/code> and click “Copy”. This will copy the current Debug<\/code> settings to your new configuration.<\/li>\n
  4. Enter the name for this configuration, i.e. DebugDevice<\/code>.<\/li>\n
  5. Keep the default Any CPU for the Platform.<\/li>\n
  6. Click “OK”.<\/li>\n
  7. Repeat steps 4-8 for the DebugEmulator<\/code> configuration.<\/li>\n<\/ol>\n

    Visual Studio (Windows):<\/h3>\n

    To add a configuration in Visual Studio (Windows):<\/p>\n

      \n
    1. Open the Configuration Manager with the Build > Configuration Manager menu.<\/li>\n
    2. Click on the Active Solution Configuration drop down and select “New”.
      <img src="https:\/\/devblogs.microsoft.com\/wp-content\/uploads\/sites\/44\/2019\/03\/NewConfigurationVS.png" alt="" class="alignnone size-full wp-image-31444" \/<\/li>\n
    3. Enter DebugDevice<\/code> for the Name field.<\/li>\n
    4. Select Debug<\/code> in the “Copy settings from” drop down list.<\/li>\n
    5. Make sure the “Create new project configurations” option is checked.
      \"\"<\/li>\n
    6. Click OK.<\/li>\n
    7. Repeat steps 2 – 6 using DebugEmulator<\/code> for the Name field.<\/li>\n<\/ol>\n

      Now you will see four configurations in the list, Debug, DebugDevice, DebugEmulator, and Release.<\/p>\n

      \"\"\n\"\"<\/p>\n

      Now you just have to open the Android project options and make the desired changes to these two new configurations:<\/p>\n

        \n
      1. Open the Android project options.<\/li>\n
      2. Select the Android Build (Mac) \/ Android Options (Windows) > Advanced tab.<\/li>\n
      3. Select DebugDevice<\/code> from the Configuration drop down.<\/li>\n
      4. Uncheck all of the Supported ABIs except<\/strong> armeabi-v7a.<\/li>\n
      5. Select DebugEmulator<\/code> from the Configuration drop down.<\/li>\n
      6. Uncheck all of the Supported ABIs except<\/strong> x86.<\/li>\n<\/ol>\n

        You can now select DebugDevice<\/code> whenever you want to debug using an actual Android device, and you can select DebugEmulator<\/code> whenever you want to debug to an x86 emulator. Your debug builds will be faster since you are only building for the one needed architecture.<\/p>\n

        Congratulations, you have now added two configurations and set them up for specific debugging scenarios.<\/p>\n

        How Can I Add a Platform?<\/h2>\n

        What we did above works, but it may be better to define platforms instead of configurations to switch between building for device or emulator. You will notice this is done by default for iOS projects. There are two platforms defined for iOS projects, iPhone and iPhoneSimulator. We could do the same for Android if we like. For this exercise, start with a new Xamarin Forms project, PCL or Shared type does not matter for this exercise.<\/p>\n

        \"\"<\/p>\n

        \"\"<\/p>\n

        Visual Studio for Mac:<\/h3>\n

        To add a platform in Xamarin\/Visual Studio for Mac:<\/p>\n

          \n
        1. Open the Solution Options by double clicking on the solution in the solution explorer.<\/li>\n
        2. Select Build > Configurations on the left (not Run > Configurations).<\/li>\n
        3. Select the General tab.<\/li>\n
        4. Since we want variants of the Debug<\/code> configuration, in the configuration list select Debug<\/code> and click “Copy”. This will copy the current Debug<\/code> settings to your new configuration.
          \"\"<\/li>\n
        5. Enter the name for this configuration, in this case keep it the same, Debug<\/code>, since we only want to add a platform not a configuration.<\/li>\n
        6. Enter AndroidDevice<\/code> for the Platform field.<\/li>\n
        7. Make sure the “Create Configurations for all solution items” option is not<\/strong> checked. We only want this platform for the Android project. If this option were selected, we would be adding this platform to the iOS project as well.
          \"\"<\/li>\n
        8. Click “OK”.<\/li>\n
        9. Repeat steps 4-8 using AndroidEmulator<\/code> for the Platform field.<\/li>\n
        10. Since we did not add this new platform to the projects (step 7), we will need to repeat steps 4-8 in the Android Project Options > Build > Configurations. Do this for both the AndroidDevice<\/code> and AndroidEmulator<\/code> platforms.
          \"\"<\/a><\/li>\n<\/ol>\n

          You will then have to map the solution custom platform to the project custom platform:<\/p>\n

            \n
          1. Open the Solution Options > Build > Configurations > Configuration Mappings tab.<\/li>\n
          2. Select the AndroidDevice<\/code> platform for the Platform field at the top.<\/li>\n
          3. In Configuration column for the Android app project, select Debug|AndroidDevice<\/code>.
            \"\"<\/li>\n
          4. Select the AndroidEmulator<\/code> platform for the Platform field at the top.<\/li>\n
          5. In Configuration column for the Android app project, select Debug|AndroidEmulator<\/code>.<\/li>\n<\/ol>\n

            Now in the main configuration drop down list you will see Debug|AndroidDevice<\/code> and Debug|AndroidEmulator<\/code>.
            \"\"<\/p>\n

            You can edit the settings for each platform just as you did for the configurations we set up earlier, just select the correct platform that you want to edit the build settings for in the Platform drop down in the Project Options > Android Build (Mac) settings page.<\/p>\n

            Visual Studio (Windows):<\/h3>\n

            Adding custom platforms is not as straightforward in Visual Studio as it is in Xamarin Studio. You can easily add the custom platform name at the solution level, but adding it at the project level requires some editing of the .csproj file. Here’s how to do all this in Visual Studio:<\/p>\n

            Add a solution level platform:<\/p>\n

              \n
            1. Open the Configuration Manager with the Build > Configuration Manager menu.<\/li>\n
            2. Click on the Active Solution Platform drop down and select “New”.
              \"\"<\/li>\n
            3. Enter AndroidDevice<\/code> for the Name field.<\/li>\n
            4. Select AnyCPU<\/code> in the “Copy settings from” drop down list.<\/li>\n
            5. Make sure the “Create new project configurations” option is not<\/strong> checked. You will get an error if this is checked since the Android app project does not have an AndroidDevice<\/code> platform yet.
              \"\"<\/li>\n
            6. Click OK.<\/li>\n
            7. Repeat steps 2 – 6 using Androidmulator<\/code> for the Name field.<\/li>\n<\/ol>\n

              Now for the hard part, adding the new platforms to the Android app project.<\/p>\n

                \n
              1. Unload the Android app project (right click on the project and select Unload).<\/li>\n
              2. Edit the AppName.csproj<\/code> file (right click on the project and select “Edit .csproj”.<\/li>\n
              3. Paste the following XML right below the opening Project tag:\n
                \n  AndroidDevice\n  AnyCPU\n\n\n  AndroidEmulator\n  AnyCPU\n<\/code><\/pre>\n<\/li>\n
              4. Look for the following element:\n
                <\/code><\/pre>\n<\/li>\n
              5. Select all of the text for the above PropertyGroup<\/code> including the opening and closing PropertyGroup<\/code> tag and copy it.<\/li>\n
              6. Paste the text twice right below the ending PropertyGroup<\/code> tag copied above.<\/li>\n
              7. Edit the pasted property groups, changing:\n
                <\/code><\/pre>\n
                 to <\/p>\n
                <\/code><\/pre>\n
                 for the first copy and <\/p>\n
                <\/code><\/pre>\n
                 for the second copy.<\/li>\n
              8. Not required, but best to have a separate OutputPath<\/code> for each platform, so change: \n
                bin\\Debug<\/code><\/pre>\n
                 to <\/p>\n
                bin\\AndroidDevice\\Debug<\/code><\/pre>\n
                 for the first copy and <\/p>\n
                bin\\AndroidEmulator\\Debug<\/code><\/pre>\n
                 for the second copy.<\/li>\n
              9. Save and close the .csproj file.<\/li>\n
              10. Reload the project.<\/li>\n<\/ol>\n
                You will then have to map the solution custom platform to the project custom platform:<\/p>\n
                  \n
                1. Open the Configuration Manager again.<\/li>\n
                2. Select the AndroidDevice<\/code> platform for the Active Solution Platform.<\/li>\n
                3. In Platform column for the Android app project, select AndroidDevice<\/code>.
                  \"\"<\/li>\n
                4. Select the AndroidEmulator<\/code> platform for the Active Solution Platform.<\/li>\n
                5. In Platform column for the Android app project, select AndroidEmulator<\/code>.<\/li>\n<\/ol>\n
                  Now you will want to open the Android project properties and edit the Configuration|Platform<\/code> settings to only build for the relevant architectures, i.e. armeabi-v7s for AndroidDevice<\/code> and x86 for AndroidEmulator<\/code>, like you did earlier for the new configurations.<\/p>\n
                  \"\"<\/p>\n
                  Configuration Mapping<\/h2>\n
                  When we added the configurations above, we added them at the solution level but also added them to each project in the solution by selecting the “Create Configurations for all solution items” on Mac and “Create new project configurations” in Windows (or added them manually in the .csproj<\/code> file). This way the new configurations are available at the project and the solution level. You can then map solution level configurations to project level configurations using the Configuration Manager in Windows or on Mac using the Solution Options > Build > Configurations > Configuration Mappings tab. You will see that for each project, you can select which project configuration will build when you select the active solution configuration in the Configuration drop-down list.<\/p>\n
                  You can also set which projects build with each solution configuration. If you have a solution with multiple app projects, you can add a configuration to only build the project(s) needed at the time. For a Xamarin Forms app (or any solution with multiple platform projects), you may want to add a configuration that only builds the iOS project (and PCL project if used), and one to only build the Android project (and PCL project if used). This would again speed up build times, so you are only building for the platform you are currently debugging.\n\"\"<\/p>\n
                  \"\"<\/p>\n
                  Configurations and MSBuild Properties in Your .csproj File<\/h2>\n
                  We touched briefly on the .csproj<\/code> file when adding custom platforms to an app project in Visual Studio since the UI provides no way of doing that as in Xamarin Studio. Mostly you will never have to edit a .csproj<\/code> file but I feel it is useful to at least touch on the items in the .csproj<\/code> file that are affected when you switch the active Configuration|Platform<\/code> in the IDE.<\/p>\n
                  When we added the custom platform above, we copied and pasted a PropertyGroup<\/code> twice to add the new platforms and set the build output path for the new platforms. The property groups that are used for each configuration is simply a set of MSBuild properties and values that will be used when the corresponding Configuration|Platform<\/code> combination is selected for build. For instance, the following property group will be used when the Debug|AnyCPU<\/code>  Configuration|Platform<\/code> is selected:<\/p>\n
                  \n\n...\n\n<\/pre>\n
                  When the condition '$(Configuration)|$(Platform)' == 'Debug|AnyCPU'<\/code> is met, then the values for the MSBuild properties in that group will be used. For instance, you will find the below in the above property group:<\/p>\n
                  \nNone\n<\/pre>\n
                  This sets the Linker options to “None” when using Debug|AnyCPU<\/code> Configuration|Platform<\/code> combination. Your configurations and platforms are really just a way for you to set a bunch of MSBuild properties to specific values just by choosing a Configuration|Platform<\/code> for your build. If building from the command line, you can manually set any available MSBuild property using the \/p:MSBuildProperty=value<\/code> syntax. In other words, if you wanted to build the Debug|AnyCPU<\/code> Configuration|Platform<\/code> from the command line but wanted to enable the linker option “Link SDK Assemblies Only”, you would do the following (Windows):<\/p>\n
                  \nMSBuild.exe MySolution.csproj \/p:Configuration=Debug \/p:Platform=AnyCPU \/p:AndroidLinkMode=SdkOnly\n<\/pre>\n
                  …or on Mac:<\/p>\n
                  \nMSBuild MySolution.csproj \/p:Configuration=Debug \/p:Platform=AnyCPU \/p:AndroidLinkMode=SdkOnly\n<\/pre>\n
                  Any property you see defined in a PropertyGroup<\/code> in the .csproj<\/code> file can be set to a specific value in the command line with the \/p:PropertyName=PropertyValue<\/code> switch when doing a command line build. Here is the MSBuild Command Line reference<\/a> for more information.<\/p>\n
                  Summary<\/h2>\n
                  You have now learned how to create custom configurations and platforms and how to edit them so that the build options you want for a particular scenario can all be set just by selecting the appropriate configuration | platform combination.\t\t<\/p>\n","protected":false},"excerpt":{"rendered":"
                  Most developers are familiar with the Debug and Release configurations in most solution templates in use. It seems obvious to use the Debug configuration when building your project for debugging and to use the Release configuration when building your project for release. What may be less clear, though, is what’s actually happening when you switch […]<\/p>\n","protected":false},"author":554,"featured_media":39167,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[2],"tags":[5,6,4],"class_list":["post-31389","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-developers","tag-android","tag-ios","tag-xamarin-platform"],"acf":[],"blog_post_summary":"
                  Most developers are familiar with the Debug and Release configurations in most solution templates in use. It seems obvious to use the Debug configuration when building your project for debugging and to use the Release configuration when building your project for release. What may be less clear, though, is what’s actually happening when you switch […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/posts\/31389","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/users\/554"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/comments?post=31389"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/posts\/31389\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/media\/39167"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/media?parent=31389"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/categories?post=31389"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/xamarin\/wp-json\/wp\/v2\/tags?post=31389"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}