<!--

***********************************************************************************************

Microsoft.Common.CurrentVersion.targets

WARNING: DO NOT MODIFY this file unless you are knowledgeable about MSBuild and have

created a backup copy. Incorrect changes to this file will make it

impossible to load or build your projects from the command-line or the IDE.

This file defines the steps in the standard build process for .NET projects. It

contains all the steps that are common among the different .NET languages, such as

Visual Basic, and Visual C#.

Copyright (C) Microsoft Corporation. All rights reserved.

***********************************************************************************************

-->

<Project DefaultTargets="Build" TreatAsLocalProperty="OutDir">

<Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="'$(MicrosoftCommonPropsHasBeenImported)' != 'true' and Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />

<PropertyGroup>

<ImportByWildcardBeforeMicrosoftCommonTargets Condition="'$(ImportByWildcardBeforeMicrosoftCommonTargets)' == ''">true</ImportByWildcardBeforeMicrosoftCommonTargets>

<ImportByWildcardAfterMicrosoftCommonTargets Condition="'$(ImportByWildcardAfterMicrosoftCommonTargets)' == ''">true</ImportByWildcardAfterMicrosoftCommonTargets>

<ImportUserLocationsByWildcardBeforeMicrosoftCommonTargets Condition="'$(ImportUserLocationsByWildcardBeforeMicrosoftCommonTargets)' == ''">true</ImportUserLocationsByWildcardBeforeMicrosoftCommonTargets>

<ImportUserLocationsByWildcardAfterMicrosoftCommonTargets Condition="'$(ImportUserLocationsByWildcardAfterMicrosoftCommonTargets)' == ''">true</ImportUserLocationsByWildcardAfterMicrosoftCommonTargets>

</PropertyGroup>

<Import Project="$(MSBuildUserExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.targets\ImportBefore\*" Condition="'$(ImportUserLocationsByWildcardBeforeMicrosoftCommonTargets)' == 'true' and exists('$(MSBuildUserExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.targets\ImportBefore')"/>

<Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.targets\ImportBefore\*" Condition="'$(ImportByWildcardBeforeMicrosoftCommonTargets)' == 'true' and exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.targets\ImportBefore')"/>

<Import Project="$(MSBuildProjectFullPath).user" Condition="Exists('$(MSBuildProjectFullPath).user')"/>

<!-- VS10 without SP1 and without VS11 will not have VisualStudioVersion set, so do that here -->

<PropertyGroup>

<VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion>

</PropertyGroup>

<PropertyGroup>

<CustomBeforeMicrosoftCommonTargets Condition="'$(CustomBeforeMicrosoftCommonTargets)'==''">$(MSBuildExtensionsPath)\v$(MSBuildToolsVersion)\Custom.Before.Microsoft.Common.targets</CustomBeforeMicrosoftCommonTargets>

<CustomAfterMicrosoftCommonTargets Condition="'$(CustomAfterMicrosoftCommonTargets)'==''">$(MSBuildExtensionsPath)\v$(MSBuildToolsVersion)\Custom.After.Microsoft.Common.targets</CustomAfterMicrosoftCommonTargets>

<ReportingServicesTargets Condition="'$(ReportingServicesTargets)'==''">$(MSBuildExtensionsPath)\Microsoft\VisualStudio\v$(VisualStudioVersion)\ReportingServices\Microsoft.ReportingServices.targets</ReportingServicesTargets>

</PropertyGroup>

<Import Project="$(CustomBeforeMicrosoftCommonTargets)" Condition="'$(CustomBeforeMicrosoftCommonTargets)' != '' and Exists('$(CustomBeforeMicrosoftCommonTargets)')"/>

<!-- By default, we are creating a managed app because .NET 2.0 projects did not have this property. -->

<PropertyGroup Condition="'$(TargetRuntime)' == ''">

<TargetRuntime>Managed</TargetRuntime>

</PropertyGroup>

<!-- Because .NET 2.0 apps did not set TargetFrameworkIdentifier, we need to set it for them here by default. If

the runtime is set to Managed, we also need to set these. Otherwise they should be blank (for instance Javascript or

Native apps) because they do not target a .NET Framework. -->

<PropertyGroup Condition="'$(TargetRuntime)' == 'Managed'">

<TargetFrameworkIdentifier Condition="'$(TargetFrameworkIdentifier)' == ''">.NETFramework</TargetFrameworkIdentifier>

<TargetFrameworkVersion Condition=" '$(TargetFrameworkVersion)' == '' ">v4.0</TargetFrameworkVersion>

</PropertyGroup>

<!-- AvailablePlatforms is the list of platform targets available. -->

<PropertyGroup>

<AvailablePlatforms Condition="'$(VisualStudioVersion)' == '10.0' or '$(VisualStudioVersion)' == ''">Any CPU,x86,x64,Itanium</AvailablePlatforms>

<AvailablePlatforms Condition="'$(VisualStudioVersion)' != '' and '$(VisualStudioVersion)' > '10.0'">Any CPU,x86,x64</AvailablePlatforms>

</PropertyGroup>

<!-- Import depends on if it is .NETCore. Imports for .NETFramework is a superset of that for .NETCore-->

<Import Project="Microsoft.NETFramework.props" Condition="'$(TargetFrameworkIdentifier)' == '.NETFramework' or '$(TargetFrameworkIdentifier)' == 'Silverlight'"/>

<Import Project="Microsoft.NET.props" Condition="'$(TargetFrameworkIdentifier)' == '.NETStandard' or '$(TargetFrameworkIdentifier)' == '.NETCoreApp'"/>

<PropertyGroup>

<!-- Generates full paths for the 'File' property in errors, warnings and messages in many targets -->

<GenerateFullPaths Condition="'$(GenerateFullPaths)' == ''">true</GenerateFullPaths>

<!-- Yield optimization properties -->

<YieldDuringToolExecution Condition="'$(YieldDuringToolExecution)' == ''">true</YieldDuringToolExecution>

</PropertyGroup>

<PropertyGroup Condition="'$(TargetFrameworkIdentifier)' != '' and '$(TargetFrameworkVersion)' != ''">

<TargetFrameworkMoniker Condition="'$(TargetFrameworkMoniker)' == '' and '$([System.String]::IsNullOrWhitespace($(TargetFrameworkProfile)))' != 'true'">$(TargetFrameworkIdentifier),Version=$(TargetFrameworkVersion),Profile=$(TargetFrameworkProfile)</TargetFrameworkMoniker>

<TargetFrameworkMoniker Condition="'$(TargetFrameworkMoniker)' == ''">$(TargetFrameworkIdentifier),Version=$(TargetFrameworkVersion)</TargetFrameworkMoniker>

<!-- When working off a packaged reference assemblies, do not go to machine-global locations. This property is target-framework-specific, so it cannot be overridden in msbuild.exe.config once and for all. -->

<FrameworkPathOverride Condition="'$(EnableFrameworkPathOverride)' != 'false' And '$(FrameworkPathOverride)' == '' And Exists('$(TargetFrameworkRootPath)$(TargetFrameworkIdentifier)\$(TargetFrameworkVersion)')">$(TargetFrameworkRootPath)$(TargetFrameworkIdentifier)\$(TargetFrameworkVersion)</FrameworkPathOverride>

<!-- The FrameworkPathOverride is required for the inproc visual basic compiler to initialize when targeting target frameworks less than 4.0. If .net 2.0 is not installed then the property value above will not provide the location

of mscorlib. This is also true if the build author overrides this property to some other directory which does not contain mscorlib.dll. In the case we cannot find mscorlib.dll at the correct location

we need to find a directory which does contain mscorlib to allow the inproc compiler to initialize and give us the chance to show certain dialogs in the IDE (which only happen after initialization).-->

<FrameworkPathOverride Condition="'$(EnableFrameworkPathOverride)' != 'false' And '$(FrameworkPathOverride)' == ''">$([Microsoft.Build.Utilities.ToolLocationHelper]::GetPathToStandardLibraries($(TargetFrameworkIdentifier), $(TargetFrameworkVersion), $(TargetFrameworkProfile), $(PlatformTarget), $(TargetFrameworkRootPath), $(TargetFrameworkFallbackSearchPaths)))</FrameworkPathOverride>

<FrameworkPathOverride Condition="'$(EnableFrameworkPathOverride)' != 'false' And !Exists('$(FrameworkPathOverride)\mscorlib.dll')">$(MSBuildFrameworkToolsPath)</FrameworkPathOverride>

</PropertyGroup>

<PropertyGroup>

<TargetPlatformIdentifier Condition="'$(TargetPlatformIdentifier)' == '' and '$(_EnableDefaultWindowsPlatform)' != 'false'">Windows</TargetPlatformIdentifier>

<TargetPlatformVersion Condition="'$(TargetPlatformVersion)' == '' and '$(_EnableDefaultWindowsPlatform)' != 'false'">7.0</TargetPlatformVersion>

<TargetPlatformSdkPath Condition="'$(TargetPlatformSdkPath)' == '' and '$(TargetPlatformSdkRootOverride)' != ''">$(TargetPlatformSdkRootOverride)\</TargetPlatformSdkPath>

<TargetPlatformSdkPath Condition="'$(TargetPlatformSdkPath)' == '' and '$(TargetPlatformIdentifier)' == 'Windows' and $([MSBuild]::IsOSPlatform('Windows')) and '$(MSBuildRuntimeType)' != 'Core'">$([MSBuild]::GetRegistryValueFromView('HKEY_LOCAL_MACHINE\Software\Microsoft\Microsoft SDKs\Windows\v$(TargetPlatformVersion)', InstallationFolder, null, RegistryView.Registry32, RegistryView.Default))</TargetPlatformSdkPath>

<TargetPlatformSdkPath Condition="'$(TargetPlatformSdkPath)' == ''">$([Microsoft.Build.Utilities.ToolLocationHelper]::GetPlatformSDKLocation($(TargetPlatformIdentifier), $(TargetPlatformVersion)))</TargetPlatformSdkPath>

<TargetPlatformSdkMetadataLocation Condition="'$(TargetPlatformSdkMetadataLocation)' == '' and Exists('$(TargetPlatformSdkPath)')">$(TargetPlatformSdkPath)Windows Metadata</TargetPlatformSdkMetadataLocation>

<TargetPlatformSdkMetadataLocation Condition="Exists('$(TargetPlatformSdkPath)') and ('$(TargetPlatformSdkMetadataLocation)' == '' or !Exists('$(TargetPlatformSdkMetadataLocation)'))">$(TargetPlatformSdkPath)References\CommonConfiguration\Neutral</TargetPlatformSdkMetadataLocation>

<TargetPlatformWinMDLocation Condition="'$(TargetPlatformWinMDLocation)' == '' and Exists('$(TargetPlatformSdkMetadataLocation)')">$(TargetPlatformSdkMetadataLocation)</TargetPlatformWinMDLocation>

<UseOSWinMdReferences Condition="'$(UseOSWinMdReferences)' == '' and ('$(TargetPlatformWinMDLocation)' == '' and '$(TargetPlatformIdentifier)' == 'Windows' and '$(TargetPlatformVersion)' &gt; '7.0')">true</UseOSWinMdReferences>

<TargetPlatformWinMDLocation Condition="'$(UseOsWinMdReferences)' == 'true'">$(WinDir)\System32\WinMetadata</TargetPlatformWinMDLocation>

<TargetPlatformMoniker Condition="'$(TargetPlatformMoniker)' == '' and '$(TargetPlatformIdentifier)' != '' and '$(TargetPlatformVersion)' != ''">$(TargetPlatformIdentifier),Version=$(TargetPlatformVersion)</TargetPlatformMoniker>

<TargetPlatformDisplayName Condition="'$(TargetPlatformDisplayName)' == ''">$([Microsoft.Build.Utilities.ToolLocationHelper]::GetPlatformSDKDisplayName($(TargetPlatformIdentifier), $(TargetPlatformVersion)))</TargetPlatformDisplayName>

</PropertyGroup>

<!--

Several properties must be set in the main project file, before using this .TARGETS file.

However, if the properties are not set, we pick some defaults.

OutDir:

Indicates the final output location for the project or solution. When building a solution,

OutDir can be used to gather multiple project outputs in one location. In addition,

OutDir is included in AssemblySearchPaths used for resolving references.

BaseOutputPath:

This is the top level folder where all configuration specific output folders will be created.

Default value is bin\

OutputPath:

This is the full Output Path, and is derived from BaseOutputPath, if none specified

(eg. bin\Debug). If this property is overridden, then setting BaseOutputPath has no effect.

For Legacy projects using only Common targets, this property is usually specified in the project file

and is used to initialize OutDir. Some SDKs including the .NET SDK derive this automatically.

OutDir and OutputPath are distinguished for legacy reasons, and OutDir should be used if at all possible.

BaseIntermediateOutputPath:

This is the top level folder where all configuration specific intermediate output folders will be created.

Default value is obj\

IntermediateOutputPath:

This is the full intermediate Output Path, and is derived from BaseIntermediateOutputPath, if none specified

(eg. obj\Debug). If this property is overridden, then setting BaseIntermediateOutputPath has no effect.

Ensure any and all path property has a trailing slash, so it can be concatenated.

-->

<PropertyGroup>

<!-- Example, AnyCPU -->

<_OriginalPlatform>$(Platform)</_OriginalPlatform>

<!-- Example, Debug -->

<_OriginalConfiguration>$(Configuration)</_OriginalConfiguration>

<!-- Check whether OutputPath was specified for valid Configuration/Platform combination -->

<_OutputPathWasMissing Condition="'$(_OriginalPlatform)' != '' and '$(_OriginalConfiguration)' != '' and '$(OutputPath)' == ''">true</_OutputPathWasMissing>

<!-- Check whether BaseOutputPath was specified -->

<BaseOutputPathWasSpecified Condition="'$(BaseOutputPath)' != ''">true</BaseOutputPathWasSpecified>

</PropertyGroup>

<PropertyGroup>

<Platform Condition="'$(Platform)' == ''">AnyCPU</Platform>

<PlatformName Condition="'$(PlatformName)' == ''">$(Platform)</PlatformName>

<Configuration Condition="'$(Configuration)' == ''">Debug</Configuration>

<ConfigurationName Condition="'$(ConfigurationName)' == ''">$(Configuration)</ConfigurationName>

<BaseOutputPath Condition="'$(BaseOutputPath)' == ''">bin\</BaseOutputPath>

<BaseOutputPath Condition="!HasTrailingSlash('$(BaseOutputPath)')">$(BaseOutputPath)\</BaseOutputPath>

<OutputPath Condition="'$(OutputPath)' == '' and '$(PlatformName)' == 'AnyCPU'">$(BaseOutputPath)$(Configuration)\</OutputPath>

<OutputPath Condition="'$(OutputPath)' == '' and '$(PlatformName)' != 'AnyCPU'">$(BaseOutputPath)$(PlatformName)\$(Configuration)\</OutputPath>

<OutputPath Condition="!HasTrailingSlash('$(OutputPath)')">$(OutputPath)\</OutputPath>

<BaseIntermediateOutputPath Condition="'$(BaseIntermediateOutputPath)' == ''">obj\</BaseIntermediateOutputPath>

<BaseIntermediateOutputPath Condition="!HasTrailingSlash('$(BaseIntermediateOutputPath)')">$(BaseIntermediateOutputPath)\</BaseIntermediateOutputPath>

<IntermediateOutputPath Condition="'$(IntermediateOutputPath)' == '' and '$(PlatformName)' == 'AnyCPU'">$(BaseIntermediateOutputPath)$(Configuration)\</IntermediateOutputPath>

<IntermediateOutputPath Condition="'$(IntermediateOutputPath)' == '' and '$(PlatformName)' != 'AnyCPU'">$(BaseIntermediateOutputPath)$(PlatformName)\$(Configuration)\</IntermediateOutputPath>

<IntermediateOutputPath Condition="!HasTrailingSlash('$(IntermediateOutputPath)')">$(IntermediateOutputPath)\</IntermediateOutputPath>

</PropertyGroup>

<PropertyGroup>

<!-- Determine OutputType property from the legacy TargetType property -->

<OutputType Condition=" '$(TargetType)' != ''">$(TargetType)</OutputType>

<OutputType Condition=" '$(TargetType)' == 'Container' or '$(TargetType)' == 'DocumentContainer' ">library</OutputType>

<OutputType Condition=" '$(OutputType)' == '' ">exe</OutputType>

<DebugSymbols Condition=" '$(ConfigurationName)' == 'Debug' and '$(DebugSymbols)' == '' and '$(DebugType)'==''">true</DebugSymbols>

<!-- Whether or not a .pdb file is produced. -->

<_DebugSymbolsProduced>false</_DebugSymbolsProduced>

<_DebugSymbolsProduced Condition="'$(DebugSymbols)'=='true'">true</_DebugSymbolsProduced>

<_DebugSymbolsProduced Condition="'$(DebugType)'=='none'">false</_DebugSymbolsProduced>

<_DebugSymbolsProduced Condition="'$(DebugType)'=='pdbonly'">true</_DebugSymbolsProduced>

<_DebugSymbolsProduced Condition="'$(DebugType)'=='full'">true</_DebugSymbolsProduced>

<_DebugSymbolsProduced Condition="'$(DebugType)'=='portable'">true</_DebugSymbolsProduced>

<_DebugSymbolsProduced Condition="'$(DebugType)'=='embedded'">false</_DebugSymbolsProduced>

<_DebugSymbolsProduced Condition="'$(ProduceOnlyReferenceAssembly)'=='true'">false</_DebugSymbolsProduced>

<!-- Whether or not a .xml file is produced. -->

<_DocumentationFileProduced>true</_DocumentationFileProduced>

<_DocumentationFileProduced Condition="'$(DocumentationFile)'==''">false</_DocumentationFileProduced>

<!-- Whether or not a reference assembly is produced. -->

<ProduceReferenceAssembly Condition="'$(ProduceReferenceAssembly)' == ''">false</ProduceReferenceAssembly>

</PropertyGroup>

<!--

For Legacy projects that define properties per Configuration/Platform combination, the validity of an

invalid combination is determined by the non-empty value of the 'OutputPath' property specified under

the IDE generated Configuration/Platform specific 'PropertyGroup' section.

If 'BaseOutputPath' is specified, we can skip the validation, since, we assume the 'OutputPath' property

will be derived (e.g.: from the 'BaseOutputPath' property).

-->

<PropertyGroup Condition="'$(BaseOutputPathWasSpecified)' != 'true' and '$(_OutputPathWasMissing)' == 'true'">

<!--

When 'OutputPath' is missing or empty (along with non-existent 'BaseOutputPath') at this point means,

we're in legacy mode and we shall assume the current Configuration/Platform combination as invalid.

Whether this is considered an error or a warning depends on the value of $(SkipInvalidConfigurations).

-->

<_InvalidConfigurationMessageSeverity Condition=" '$(SkipInvalidConfigurations)' == 'true' ">Warning</_InvalidConfigurationMessageSeverity>

<_InvalidConfigurationMessageSeverity Condition=" '$(SkipInvalidConfigurations)' != 'true' ">Error</_InvalidConfigurationMessageSeverity>

</PropertyGroup>

<!--

IDE Macros available from both integrated builds and from command line builds.

The following properties are 'macros' that are available via IDE for

pre and post build steps.

-->

<PropertyGroup>

<TargetExt Condition="'$(TargetExt)' == '' and '$(OutputType)'=='exe'">.exe</TargetExt>

<TargetExt Condition="'$(TargetExt)' == '' and '$(OutputType)'=='winexe'">.exe</TargetExt>

<TargetExt Condition="'$(TargetExt)' == '' and '$(OutputType)'=='appcontainerexe'">.exe</TargetExt>

<TargetExt Condition="'$(TargetExt)' == '' and '$(OutputType)'=='library'">.dll</TargetExt>

<TargetExt Condition="'$(TargetExt)' == '' and '$(OutputType)'=='module'">.netmodule</TargetExt>

<TargetExt Condition="'$(TargetExt)' == '' and '$(OutputType)'=='winmdobj'">.winmdobj</TargetExt>

</PropertyGroup>

<PropertyGroup>

<!-- Required for enabling Team Build for packaging app package-generating projects -->

<OutDirWasSpecified Condition=" '$(OutDir)'!='' and '$(OutDirWasSpecified)'=='' ">true</OutDirWasSpecified>

<OutDir Condition=" '$(OutDir)' == '' ">$(OutputPath)</OutDir>

<!-- Example, bin\Debug\ -->

<!-- Ensure OutDir has a trailing slash, so it can be concatenated -->

<OutDir Condition="'$(OutDir)' != '' and !HasTrailingSlash('$(OutDir)')">$(OutDir)\</OutDir>

<ProjectName Condition=" '$(ProjectName)' == '' ">$(MSBuildProjectName)</ProjectName>

<!-- Example, MyProject -->

<!-- For projects that generate app packages or ones that want a per-project output directory, update OutDir to include the project name -->

<OutDir Condition="'$(OutDir)' != '' and '$(OutDirWasSpecified)' == 'true' and (('$(WindowsAppContainer)' == 'true' and '$(GenerateProjectSpecificOutputFolder)' != 'false') or '$(GenerateProjectSpecificOutputFolder)' == 'true')">$(OutDir)$(ProjectName)\</OutDir>

<AssemblyName Condition=" '$(AssemblyName)'=='' ">$(MSBuildProjectName)</AssemblyName>

<TargetName Condition="'$(TargetName)' == '' and '$(OutputType)' == 'winmdobj' and '$(RootNamespace)' != ''">$(RootNamespace)</TargetName>

<TargetName Condition=" '$(TargetName)' == '' ">$(AssemblyName)</TargetName>

<!-- Example, MyAssembly -->

<ProjectFileName Condition=" '$(ProjectFileName)' == '' ">$(MSBuildProjectFile)</ProjectFileName>

<!-- Example, MyProject.csproj -->

<ProjectExt Condition=" '$(ProjectExt)' == '' ">$(MSBuildProjectExtension)</ProjectExt>

<!-- Example, .csproj -->

<WinMDExpOutputWindowsMetadataFilename Condition="'$(WinMDExpOutputWindowsMetadataFilename)' == '' and '$(OutputType)' == 'winmdobj'">$(TargetName).winmd</WinMDExpOutputWindowsMetadataFilename>

<TargetFileName Condition=" '$(TargetFileName)' == '' and '$(OutputType)' == 'winmdobj'">$(WinMDExpOutputWindowsMetadataFilename)</TargetFileName>

<TargetFileName Condition=" '$(TargetFileName)' == '' ">$(TargetName)$(TargetExt)</TargetFileName>

<!-- Example, MyAssembly.dll -->

</PropertyGroup>

<PropertyGroup>

<!--

The PublishableProject property is used when invoking the publish target on a solution that

contains multiple projects. The property determines which projects should be published, and

which projects should be skipped in the publish target. By default any "Windows Application"

or "Console Application" project type is publishable. However, a project that would otherwise

be published can be skipped by defining the PublishableProject property in the project itself.

-->

<_DeploymentPublishableProjectDefault Condition="'$(OutputType)'=='winexe' or '$(OutputType)'=='exe' or '$(OutputType)'=='appcontainerexe'">true</_DeploymentPublishableProjectDefault>

<PublishableProject Condition="'$(PublishableProject)'==''">$(_DeploymentPublishableProjectDefault)</PublishableProject>

<_DeploymentTargetApplicationManifestFileName Condition="'$(OutputType)'=='library'">Native.$(AssemblyName).manifest</_DeploymentTargetApplicationManifestFileName>

<!-- Example, Native.MyAssembly.manifest -->

<_DeploymentTargetApplicationManifestFileName Condition="'$(OutputType)'=='winexe'">$(TargetFileName).manifest</_DeploymentTargetApplicationManifestFileName>

<!-- Example, MyAssembly.exe.manifest -->

<_DeploymentTargetApplicationManifestFileName Condition="'$(OutputType)'=='exe'">$(TargetFileName).manifest</_DeploymentTargetApplicationManifestFileName>

<!-- Example, MyAssembly.exe.manifest -->

<_DeploymentTargetApplicationManifestFileName Condition="'$(OutputType)'=='appcontainerexe'">$(TargetFileName).manifest</_DeploymentTargetApplicationManifestFileName>

<!-- Example, MyAssembly.exe.manifest -->

<TargetDeployManifestFileName Condition="'$(TargetDeployManifestFileName)' == '' and '$(HostInBrowser)' != 'true'">$(AssemblyName).application</TargetDeployManifestFileName>

<!-- Example, MyAssembly.application -->

<TargetDeployManifestFileName Condition="'$(TargetDeployManifestFileName)' == '' and '$(HostInBrowser)' == 'true'">$(AssemblyName).xbap</TargetDeployManifestFileName>

<!-- Example, MyAssembly.xbap -->

<GenerateClickOnceManifests Condition="'$(OutputType)'=='winexe' or '$(OutputType)'=='exe' or '$(OutputType)'=='appcontainerexe'">$(GenerateManifests)</GenerateClickOnceManifests>

<_DeploymentApplicationManifestIdentity Condition="'$(OutputType)'=='library'">Native.$(AssemblyName)</_DeploymentApplicationManifestIdentity>

<_DeploymentApplicationManifestIdentity Condition="'$(OutputType)'=='winexe'">$(AssemblyName).exe</_DeploymentApplicationManifestIdentity>

<_DeploymentApplicationManifestIdentity Condition="'$(OutputType)'=='exe'">$(AssemblyName).exe</_DeploymentApplicationManifestIdentity>

<_DeploymentApplicationManifestIdentity Condition="'$(OutputType)'=='appcontainerexe'">$(AssemblyName).exe</_DeploymentApplicationManifestIdentity>

<_DeploymentDeployManifestIdentity Condition="'$(HostInBrowser)' != 'true'">$(AssemblyName).application</_DeploymentDeployManifestIdentity>

<_DeploymentDeployManifestIdentity Condition="'$(HostInBrowser)' == 'true'">$(AssemblyName).xbap</_DeploymentDeployManifestIdentity>

<_DeploymentFileMappingExtension Condition="'$(MapFileExtensions)'=='true'">.deploy</_DeploymentFileMappingExtension>

<_DeploymentFileMappingExtension Condition="'$(MapFileExtensions)'!='true'"></_DeploymentFileMappingExtension>

<_DeploymentBuiltUpdateInterval Condition="'$(UpdatePeriodically)'=='true'">$(UpdateInterval)</_DeploymentBuiltUpdateInterval>

<_DeploymentBuiltUpdateIntervalUnits Condition="'$(UpdatePeriodically)'=='true'">$(UpdateIntervalUnits)</_DeploymentBuiltUpdateIntervalUnits>

<_DeploymentBuiltUpdateInterval Condition="'$(UpdatePeriodically)'!='true'">0</_DeploymentBuiltUpdateInterval>

<_DeploymentBuiltUpdateIntervalUnits Condition="'$(UpdatePeriodically)'!='true'">Days</_DeploymentBuiltUpdateIntervalUnits>

<_DeploymentBuiltMinimumRequiredVersion Condition="'$(UpdateRequired)'=='true' and '$(Install)'=='true'">$(MinimumRequiredVersion)</_DeploymentBuiltMinimumRequiredVersion>

<_DeploymentLauncherBased Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">true</_DeploymentLauncherBased>

<MaxTargetPath Condition="'$(MaxTargetPath)'==''">100</MaxTargetPath>

</PropertyGroup>

<PropertyGroup>

<!--

By default, GenerateApplicationManifest puts all satellite assemblies to the manifest

record by default by setting TargetCulture to *.

-->

<TargetCulture Condition="'$(TargetCulture)'==''">*</TargetCulture>

<FallbackCulture Condition="'$(UICulture)'!='' and '$(FallbackCulture)'==''">$(UICulture)</FallbackCulture>

</PropertyGroup>

<ItemGroup>

<!-- Not used any more-->

<_OutputPathItem Include="$(OutDir)"/>

<_UnmanagedRegistrationCache Include="$(BaseIntermediateOutputPath)$(MSBuildProjectFile).UnmanagedRegistration.cache"/>

<_ResolveComReferenceCache Include="$(IntermediateOutputPath)$(MSBuildProjectFile).ResolveComReference.cache"/>

</ItemGroup>

<PropertyGroup>

<!-- Example, C:\MyProjects\MyProject\bin\Debug\ -->

<!--

Condition intentionally omitted on this one, because it causes problems

when we pick up the value of an environment variable named TargetDir

-->

<TargetDir Condition="'$(OutDir)' != ''">$([MSBuild]::Escape($([System.IO.Path]::GetFullPath(`$([System.IO.Path]::Combine(`$(MSBuildProjectDirectory)`, `$(OutDir)`))`))))</TargetDir>

<!-- Example, C:\MyProjects\MyProject\bin\Debug\MyAssembly.dll -->

<TargetPath Condition=" '$(TargetPath)' == '' ">$(TargetDir)$(TargetFileName)</TargetPath>

<TargetRefPath Condition=" '$(TargetRefPath)' == '' and '$(ProduceReferenceAssembly)' == 'true' and '$(ProduceReferenceAssemblyInOutDir)' == 'true' ">$([MSBuild]::NormalizePath($(TargetDir), 'ref', $(TargetFileName)))</TargetRefPath>

<TargetRefPath Condition=" '$(TargetRefPath)' == '' and '$(ProduceReferenceAssembly)' == 'true' ">$([MSBuild]::NormalizePath($(MSBuildProjectDirectory), $(IntermediateOutputPath), 'ref', $(TargetFileName)))</TargetRefPath>

<!-- Example, C:\MyProjects\MyProject\ -->

<ProjectDir Condition=" '$(ProjectDir)' == '' ">$([MSBuild]::EnsureTrailingSlash($(MSBuildProjectDirectory)))</ProjectDir>

<!-- Example, C:\MyProjects\MyProject\MyProject.csproj -->

<ProjectPath Condition=" '$(ProjectPath)' == '' ">$(ProjectDir)$(ProjectFileName)</ProjectPath>

</PropertyGroup>

<ItemGroup>

<!-- This is not used here but remains for backwards compatibility -->

<AppConfigFileDestination Include="$(OutDir)$(TargetFileName).config"/>

</ItemGroup>

<!--

IDE Macros available only from integrated builds.

The following properties are 'macros' that are available via IDE for

pre and post build steps. However, they are not defined when directly building

a project from the command line, only when building a solution.

-->

<PropertyGroup>

<DevEnvDir Condition="'$(DevEnvDir)'==''">*Undefined*</DevEnvDir>

<SolutionName Condition="'$(SolutionName)'==''">*Undefined*</SolutionName>

<!-- Example, MySolution -->

<SolutionFileName Condition="'$(SolutionFileName)'==''">*Undefined*</SolutionFileName>

<!-- Example, MySolution.sln -->

<SolutionPath Condition="'$(SolutionPath)'==''">*Undefined*</SolutionPath>

<!-- Example, f:\MySolutions\MySolution\MySolution.sln -->

<SolutionDir Condition="'$(SolutionDir)'==''">*Undefined*</SolutionDir>

<!-- Example, f:\MySolutions\MySolution\ -->

<SolutionExt Condition="'$(SolutionExt)'==''">*Undefined*</SolutionExt>

<!-- Example, .sln -->

</PropertyGroup>

<PropertyGroup>

<GenerateBindingRedirectsOutputType Condition="'$(OutputType)'=='exe' or '$(OutputType)'=='winexe'">true</GenerateBindingRedirectsOutputType>

<!-- It would be a breaking change to automatically turn on binding redirects for existing projects, so turn them on only when opting into a new framework. -->

<AutoGenerateBindingRedirects Condition="'$(AutoGenerateBindingRedirects)' == '' and '$(TargetFrameworkIdentifier)' == '.NETFramework' and '$(TargetFrameworkVersion.TrimStart(vV))' >= '4.7.2'">true</AutoGenerateBindingRedirects>

</PropertyGroup>

<PropertyGroup Condition="'$(AutoUnifyAssemblyReferences)' == ''">

<AutoUnifyAssemblyReferences>true</AutoUnifyAssemblyReferences>

<AutoUnifyAssemblyReferences Condition="'$(GenerateBindingRedirectsOutputType)' == 'true' and '$(AutoGenerateBindingRedirects)' != 'true'">false</AutoUnifyAssemblyReferences>

</PropertyGroup>

<PropertyGroup>

<CleanFile Condition="'$(CleanFile)'==''">$(MSBuildProjectFile).FileListAbsolute.txt</CleanFile>

<!-- During DesignTime Builds, skip project reference build as Design time is only queueing information.-->

<BuildProjectReferences Condition="'$(BuildProjectReferences)' == '' and '$(DesignTimeBuild)' == 'true'">false</BuildProjectReferences>

<!-- By default we will build (and if applicable, clean) all project references. But this can be used to disable that-->

<BuildProjectReferences Condition="'$(BuildProjectReferences)' == ''">true</BuildProjectReferences>

<BuildInParallel Condition="'$(BuildInParallel)' == ''">true</BuildInParallel>

<_ResolveReferenceDependencies Condition="'$(_ResolveReferenceDependencies)' == ''">false</_ResolveReferenceDependencies>

<_GetChildProjectCopyToOutputDirectoryItems Condition="'$(_GetChildProjectCopyToOutputDirectoryItems)' == ''">true</_GetChildProjectCopyToOutputDirectoryItems>

<OverwriteReadOnlyFiles Condition="'$(OverwriteReadOnlyFiles)' == ''">false</OverwriteReadOnlyFiles>

<ComReferenceNoClassMembers Condition="'$(ComReferenceNoClassMembers)' == ''">false</ComReferenceNoClassMembers>

</PropertyGroup>

<PropertyGroup>

<_GenerateBindingRedirectsIntermediateAppConfig>$(IntermediateOutputPath)$(TargetFileName).config</_GenerateBindingRedirectsIntermediateAppConfig>

</PropertyGroup>

<PropertyGroup Condition="'$(MSBuildCopyMarkerName)' == ''">

<MSBuildCopyMarkerName>$(MSBuildProjectFile)</MSBuildCopyMarkerName>

<!-- For a long MSBuildProjectFile let's shorten this to 17 chars - using the first 8 codepoints of the filename and a filename hash. -->

<MSBuildCopyMarkerName Condition="'$(MSBuildCopyMarkerName.Length)' &gt; '17'">$([MSBuild]::SubstringByAsciiChars($(MSBuildProjectFile), 0, 8)).$([MSBuild]::StableStringHash($(MSBuildProjectFile)).ToString("X8"))</MSBuildCopyMarkerName>

<MSBuildCopyMarkerName>$(MSBuildCopyMarkerName).Up2Date</MSBuildCopyMarkerName>

</PropertyGroup>

<ItemGroup>

<IntermediateAssembly Include="$(IntermediateOutputPath)$(TargetName)$(TargetExt)"/>

<FinalDocFile Include="@(DocFileItem->'$(OutDir)%(Filename)%(Extension)')"/>

<CopyUpToDateMarker Include="$([MSBuild]::NormalizePath('$(MSBuildProjectDirectory)', '$(IntermediateOutputPath)', '$(MSBuildCopyMarkerName)'))" />

</ItemGroup>

<ItemGroup Condition="'$(ProduceReferenceAssembly)' == 'true'">

<IntermediateRefAssembly Include="$(IntermediateOutputPath)refint\$(TargetName)$(TargetExt)" Condition="'@(IntermediateRefAssembly)' == ''" />

<CreateDirectory Include="@(IntermediateRefAssembly->'%(RootDir)%(Directory)')" />

<CreateDirectory Include="$(OutDir)ref" Condition=" '$(ProduceReferenceAssemblyInOutDir)' == 'true'" />

<CreateDirectory Include="$(IntermediateOutputPath)ref" Condition=" '$(ProduceReferenceAssemblyInOutDir)' != 'true'" />

</ItemGroup>

<ItemGroup Condition="'$(_DebugSymbolsProduced)' == 'true'">

<_DebugSymbolsIntermediatePath Include="$(IntermediateOutputPath)$(TargetName).compile.pdb" Condition="'$(OutputType)' == 'winmdobj' and '@(_DebugSymbolsIntermediatePath)' == ''"/>

<_DebugSymbolsIntermediatePath Include="$(IntermediateOutputPath)$(TargetName).pdb" Condition="'$(OutputType)' != 'winmdobj' and '@(_DebugSymbolsIntermediatePath)' == ''"/>

<_DebugSymbolsOutputPath Include="@(_DebugSymbolsIntermediatePath->'$(OutDir)%(Filename)%(Extension)')" />

</ItemGroup>

<PropertyGroup Condition="'$(_DebugSymbolsProduced)' == 'true' and '$(OutputType)' == 'winmdobj'">

<WinMDExpOutputPdb Condition="'$(WinMDExpOutputPdb)' == ''">$(IntermediateOutputPath)$(TargetName).pdb</WinMDExpOutputPdb>

<_WinMDDebugSymbolsOutputPath>$([System.IO.Path]::Combine('$(OutDir)', $([System.IO.Path]::GetFileName('$(WinMDExpOutputPdb)'))))</_WinMDDebugSymbolsOutputPath>

</PropertyGroup>

<PropertyGroup Condition="'$(OutputType)' == 'winmdobj' and '$(DocumentationFile)'!=''">

<WinMDOutputDocumentationFile Condition="'$(WinMDOutputDocumentationFile)' == ''">$(IntermediateOutputPath)$(TargetName).xml</WinMDOutputDocumentationFile>

<_WinMDDocFileOutputPath>$([System.IO.Path]::Combine('$(OutDir)', $([System.IO.Path]::GetFileName('$(WinMDOutputDocumentationFile)'))))</_WinMDDocFileOutputPath>

</PropertyGroup>

<PropertyGroup Condition="'$(WinMDExpOutputWindowsMetadataFilename)' != ''">

<_IntermediateWindowsMetadataPath>$(IntermediateOutputPath)$(WinMDExpOutputWindowsMetadataFilename)</_IntermediateWindowsMetadataPath>

<_WindowsMetadataOutputPath>$(OutDir)$(WinMDExpOutputWindowsMetadataFilename)</_WindowsMetadataOutputPath>

</PropertyGroup>

<!-- ARM64-related properties -->

<PropertyGroup>

<_SupportedArchitectures>amd64 arm64</_SupportedArchitectures>

</PropertyGroup>

<ItemGroup>

<!-- Create an item for entry point of the ClickOnce application (Example: WindowsApplication1.exe) -->

<_DeploymentManifestEntryPoint Include="@(IntermediateAssembly)">

<TargetPath>$(TargetFileName)</TargetPath>

</_DeploymentManifestEntryPoint>

<!-- Create an item for the application icon if one exists in the project (Example: app.ico) -->

<!-- NOTE: The item Include and the Exists function are operating relative to the PROJECT (.csproj, .vbproj etc.) directory in this case -->

<_DeploymentManifestIconFile Include="$(ApplicationIcon)" Condition="Exists('$(ApplicationIcon)')">

<TargetPath>$(ApplicationIcon)</TargetPath>

</_DeploymentManifestIconFile>

<!-- Create an item for the output application manifest (Example: WindowsApplication1.exe.manifeset) -->

<ApplicationManifest Include="$(IntermediateOutputPath)$(_DeploymentTargetApplicationManifestFileName)">

<TargetPath>$(_DeploymentTargetApplicationManifestFileName)</TargetPath>

</ApplicationManifest>

<!-- Create an item for the final application manifest (Example: WindowsApplication1.exe.manifeset)

This item represents the final output application manifest used for project-to-project

references and for copying to the publish output location. -->

<_ApplicationManifestFinal Include="$(OutDir)$(_DeploymentTargetApplicationManifestFileName)">

<TargetPath>$(_DeploymentTargetApplicationManifestFileName)</TargetPath>

</_ApplicationManifestFinal>

<!-- Create an item for the output deploy manifest (Example: WindowsApplication1.application) -->

<DeployManifest Include="$(IntermediateOutputPath)$(TargetDeployManifestFileName)">

<TargetPath>$(TargetDeployManifestFileName)</TargetPath>

</DeployManifest>

<!-- Create an item for the intermediate trust info file -->

<_DeploymentIntermediateTrustInfoFile Include="$(IntermediateOutputPath)$(TargetName).TrustInfo.xml" Condition="'$(TargetZone)'!=''"/>

</ItemGroup>

<!--

Determine the <deploymentProvider> (_DeploymentUrl) for the ClickOnce deployment manifest.

Prefer the UpdateUrl, falling back to InstallUrl or PublishUrl if not specified.

If the UpdateUrl is specified then _DeploymentUrl is always set to the UpdateUrl.

Otherwise, only set the _DeploymentUrl if it's an installed app and updates are enabled.

-->

<PropertyGroup>

<_DeploymentUrl Condition="'$(_DeploymentUrl)'==''">$(UpdateUrl)</_DeploymentUrl>

<_DeploymentUrl Condition="'$(_DeploymentUrl)'==''">$(InstallUrl)</_DeploymentUrl>

<_DeploymentUrl Condition="'$(_DeploymentUrl)'==''">$(PublishUrl)</_DeploymentUrl>

<_DeploymentUrl Condition="!('$(UpdateUrl)'=='') and '$(Install)'=='false'"></_DeploymentUrl>

<_DeploymentUrl Condition="'$(_DeploymentUrl)'!=''">$(_DeploymentUrl)$(TargetDeployManifestFileName)</_DeploymentUrl>

<!--

Need to explicitly blank out the _DeploymentUrl when it's not used. Otherwise an

inappropriate value may be used. For example a local path from the PublishUrl

is something we never want to see in the manifest because it means you could

only install the app from that machine.

-->

<_DeploymentUrl Condition="'$(UpdateUrl)'=='' and !('$(Install)'=='true' and '$(UpdateEnabled)'=='true')"></_DeploymentUrl>

<_DeploymentUrl Condition="'$(ExcludeDeploymentUrl)'=='true'"></_DeploymentUrl>

</PropertyGroup>

<!-- Determine the URLs for the bootstrapper. -->

<PropertyGroup>

<_DeploymentApplicationUrl Condition="'$(IsWebBootstrapper)'=='true'">$(InstallUrl)</_DeploymentApplicationUrl>

<_DeploymentApplicationUrl Condition="'$(IsWebBootstrapper)'=='true' and '$(InstallUrl)'==''">$(PublishUrl)</_DeploymentApplicationUrl>

<_DeploymentComponentsUrl Condition="'$(BootstrapperComponentsLocation)'=='Absolute'">$(BootstrapperComponentsUrl)</_DeploymentComponentsUrl>

</PropertyGroup>

<!-- Output location for publish target. -->

<PropertyGroup>

<PublishDir Condition="'$(PublishDir)' != '' and !HasTrailingSlash('$(PublishDir)')">$(PublishDir)\</PublishDir>

<PublishDir Condition="'$(PublishDir)'==''">$([MSBuild]::EnsureTrailingSlash('$(OutputPath)'))app.publish\</PublishDir>

</PropertyGroup>

<!--

ClickOncePublishDir property is the output location used by all ClickOnce publish targets. This should be same as PublishDir except

for a trailing slash. PublishDir when specified as a global property on the command line cannot be changed to add a trailing slash.

-->

<PropertyGroup>

<ClickOncePublishDir>$(PublishDir)</ClickOncePublishDir>

<ClickOncePublishDir Condition="!HasTrailingSlash('$(ClickOncePublishDir)')">$(ClickOncePublishDir)\</ClickOncePublishDir>

</PropertyGroup>

<!--

ProcessorArchitecture is the target processor architecture.

-->

<PropertyGroup Condition="'$(ProcessorArchitecture)'==''">

<!--

If ProcessorArchitecture is not set, set it to PlatformTarget

Note: if $(PlatformTarget) is also blank resolve assembly reference defaults to msil which is the

desired behavior in this case

-->

<ProcessorArchitecture>$(PlatformTarget)</ProcessorArchitecture>

<!--

If Processor architecture is not set and PlatformTarget is a known target translate the

PlatformTarget into something ResolveAssemblyReference knows about

-->

<ProcessorArchitecture Condition=" '$(PlatformTarget)' == 'AnyCpu' ">msil</ProcessorArchitecture>

<ProcessorArchitecture Condition=" '$(PlatformTarget)' == 'x64' ">amd64</ProcessorArchitecture>

<ProcessorArchitecture Condition=" '$(PlatformTarget)' == 'Itanium' ">ia64</ProcessorArchitecture>

<ProcessorArchitecture Condition=" '$(PlatformTarget)' == 'x86' ">x86</ProcessorArchitecture>

<ProcessorArchitecture Condition=" '$(PlatformTarget)' == 'ARM' ">arm</ProcessorArchitecture>

</PropertyGroup>

<PropertyGroup>

<ConsiderPlatformAsProcessorArchitecture Condition="'$(ConsiderPlatformAsProcessorArchitecture)' == ''">true</ConsiderPlatformAsProcessorArchitecture>

</PropertyGroup>

<PropertyGroup Condition="'$(ProcessorArchitecture)' == '' and '$(ConsiderPlatformAsProcessorArchitecture)' == 'true'">

<!-- We need to do this here because if we were to just compare against platform visual would parse them out as available platforms which may not be the case -->

<ProcessorArchitectureAsPlatform>$(Platform)</ProcessorArchitectureAsPlatform>

<ProcessorArchitecture Condition=" '$(ProcessorArchitectureAsPlatform)' == 'AnyCpu' or '$(ProcessorArchitectureAsPlatform)' == 'Any Cpu'">msil</ProcessorArchitecture>

<ProcessorArchitecture Condition=" '$(ProcessorArchitectureAsPlatform)' == 'x64' or '$(ProcessorArchitectureAsPlatform)' == 'amd64'">amd64</ProcessorArchitecture>

<ProcessorArchitecture Condition=" '$(ProcessorArchitectureAsPlatform)' == 'Itanium' ">ia64</ProcessorArchitecture>

<ProcessorArchitecture Condition=" '$(ProcessorArchitectureAsPlatform)' == 'x86' or '$(ProcessorArchitectureAsPlatform)' == 'win32'">x86</ProcessorArchitecture>

<ProcessorArchitecture Condition=" '$(ProcessorArchitectureAsPlatform)' == 'ARM' ">arm</ProcessorArchitecture>

<!--For compatibility with the 4.0 behavior, if not set above, default to the environment. To override this, set ProcessorArchitecture explicitly. We also need to disable the warning since we do not know if what the environment is set to is correct-->

<ResolveAssemblyWarnOrErrorOnTargetArchitectureMismatch Condition="'$(ProcessorArchitecture)'==''">None</ResolveAssemblyWarnOrErrorOnTargetArchitectureMismatch>

<ProcessorArchitecture Condition="'$(ProcessorArchitecture)'==''">$(PROCESSOR_ARCHITECTURE)</ProcessorArchitecture>

</PropertyGroup>

<!-- Sensible defaults for the most-commonly-desired MSBuildRuntime and MSBuildArchitecture values. The Core runtime does not currently support specifying task architecture or runtime.

If support for out-of-proc task execution is added on other runtimes, make sure each task's logic is checked against the current state of support. -->

<PropertyGroup Condition="'$(DisableOutOfProcTaskHost)' == '' and '$(MSBuildRuntimeType)' == 'Full'">

<TargetFrameworkAsMSBuildRuntime Condition="'$(TargetFrameworkVersion)' == 'v2.0' or '$(TargetFrameworkVersion)' == 'v3.0' or '$(TargetFrameworkVersion)' == 'v3.5'">CLR2</TargetFrameworkAsMSBuildRuntime>

<TargetFrameworkAsMSBuildRuntime Condition="'$(TargetFrameworkVersion)' == 'v4.0' or '$(TargetFrameworkVersion)' == 'v4.5'">CLR4</TargetFrameworkAsMSBuildRuntime>

<TargetFrameworkAsMSBuildRuntime Condition="'$(TargetFrameworkAsMSBuildRuntime)' == ''">CurrentRuntime</TargetFrameworkAsMSBuildRuntime>

<PlatformTargetAsMSBuildArchitectureExplicitlySet Condition="'$(PlatformTargetAsMSBuildArchitecture)' != ''">true</PlatformTargetAsMSBuildArchitectureExplicitlySet>

<PlatformTargetAsMSBuildArchitectureExplicitlySet Condition="'$(PlatformTargetAsMSBuildArchitecture)' == ''">false</PlatformTargetAsMSBuildArchitectureExplicitlySet>

<PlatformTargetAsMSBuildArchitecture Condition="'$(PlatformTarget)' == 'x86' or ('$(PlatformTarget)' == 'x64' and '$(MSBuildExtensionsPath64)' != '')">$(PlatformTarget)</PlatformTargetAsMSBuildArchitecture>

<PlatformTargetAsMSBuildArchitecture Condition="'$(PlatformTarget)' == 'arm'">x86</PlatformTargetAsMSBuildArchitecture>

<PlatformTargetAsMSBuildArchitecture Condition="('$(PlatformTarget)' == 'ia64' and '$(MSBuildExtensionsPath64)' != '')">x64</PlatformTargetAsMSBuildArchitecture>

<PlatformTargetAsMSBuildArchitecture Condition="'$(PlatformTargetAsMSBuildArchitecture)' == ''">CurrentArchitecture</PlatformTargetAsMSBuildArchitecture>

</PropertyGroup>

<!-- Flavor is the project flavor. For example, Client, Smart Devices, SQL Server, etc. -->

<PropertyGroup>

<ProjectFlavor Condition="'$(ProjectFlavor)'==''">Client</ProjectFlavor>

</PropertyGroup>

<!--

The default for compilers is to not delay-sign. If $(DelaySign) is false, let the compiler

use its default rather than forcing a no-delay-sign flag to be passed in. This is so that

attributes in the source code can override this decision.

-->

<PropertyGroup>

<DelaySign Condition="'$(SignAssembly)' != 'true'">false</DelaySign>

<DelaySign Condition="'$(DelaySign)'!='true'"></DelaySign>

</PropertyGroup>

<!-- These properties control web reference proxy generation. -->

<PropertyGroup>

<WebReference_EnableProperties Condition=" '$(WebReference_EnableProperties)' == '' ">true</WebReference_EnableProperties>

<WebReference_EnableSQLTypes Condition=" '$(WebReference_EnableSQLTypes)' == '' ">true</WebReference_EnableSQLTypes>

<WebReference_EnableLegacyEventingModel Condition=" '$(WebReference_EnableLegacyEventingModel)' == '' ">false</WebReference_EnableLegacyEventingModel>

</PropertyGroup>

<!--

These parameters control where to look in the registry for directories to search for

assemblies in the assembly resolution tasks.

-->

<PropertyGroup>

<AssemblyFoldersSuffix Condition=" '$(AssemblyFoldersSuffix)' == '' ">AssemblyFoldersEx</AssemblyFoldersSuffix>

<FrameworkRegistryBase Condition=" '$(FrameworkRegistryBase)' == '' ">Software\Microsoft\$(TargetFrameworkIdentifier)</FrameworkRegistryBase>

<TargetPlatformRegistryBase Condition="'$(TargetPlatformRegistryBase)' == ''">Software\Microsoft\Microsoft SDKs\$(TargetPlatformIdentifier)</TargetPlatformRegistryBase>

<AssemblyFoldersConfigFile Condition="'$(AssemblyFoldersConfigFile)' == ''">$([MSBuild]::GetToolsDirectory32())\AssemblyFolders.config</AssemblyFoldersConfigFile>

<AssemblyFoldersConfigFileSearchPath Condition="Exists('$(AssemblyFoldersConfigFile)')">{AssemblyFoldersFromConfig:$(AssemblyFoldersConfigFile),$(TargetFrameworkVersion)};</AssemblyFoldersConfigFileSearchPath>

<!--

These are the extensions that assembly reference resolution will consider for resolution.

Add new extensions here if you want to add new file types to consider (for example, .metadata_dll).

Put the most likely extensions first for reference resolution speed.

-->

<AllowedReferenceAssemblyFileExtensions Condition=" '$(AllowedReferenceAssemblyFileExtensions)' == '' ">

.winmd;

.dll;

.exe

</AllowedReferenceAssemblyFileExtensions>

<!--

These are the extensions that reference resolution will consider when looking for files related

to resolved references. Add new extensions here if you want to add new file types to consider.

-->

<AllowedReferenceRelatedFileExtensions Condition=" '$(AllowedReferenceRelatedFileExtensions)' == '' ">

.pdb;

.xml;

.pri;

.dll.config;

.exe.config

</AllowedReferenceRelatedFileExtensions>

<!--

These names are used when determining which TargetFramework subset to use. If the any of the FullReferenceAssemblyNames

are seen in the list of client subsets, RAR will assume that no client subset is being used. The list is semicolon seperated

For example : Full;Complete;AllThere

-->

<FullReferenceAssemblyNames Condition="'$(FullReferenceAssemblyNames)' == ''">Full</FullReferenceAssemblyNames>

</PropertyGroup>

<PropertyGroup Condition="$(AssemblySearchPaths) == ''">

<!--

The SearchPaths property is set to find assemblies in the following order:

(1) Files from current project - indicated by {CandidateAssemblyFiles}

(2) $(ReferencePath) - the reference path property, which comes from the .USER file.

(3) The hintpath from the referenced item itself, indicated by {HintPathFromItem}.

(4) The directory of MSBuild's "target" runtime from GetFrameworkPath.

The "target" runtime folder is the folder of the runtime that MSBuild is a part of.

(5) Assembly folders from AssemblyFolders.config file (provided by Visual Studio Dev15+).

(6) Registered assembly folders, indicated by {Registry:*,*,*}

(7) Legacy registered assembly folders, indicated by {AssemblyFolders}

(8) Resolve to the GAC.

(9) Treat the reference's Include as if it were a real file name.

(10) Look in the application's output folder (like bin\debug)

-->

<AssemblySearchPaths Condition="'$(AssemblySearchPath_UseCandidateAssemblyFiles)' != 'false'">{CandidateAssemblyFiles}</AssemblySearchPaths>

<AssemblySearchPaths Condition="'$(AssemblySearchPath_UseReferencePath)' != 'false'">$(AssemblySearchPaths);$(ReferencePath)</AssemblySearchPaths>

<AssemblySearchPaths Condition="'$(AssemblySearchPath_UseHintPathFromItem)' != 'false'">$(AssemblySearchPaths);{HintPathFromItem}</AssemblySearchPaths>

<AssemblySearchPaths Condition="'$(AssemblySearchPath_UseTargetFrameworkDirectory)' != 'false'">$(AssemblySearchPaths);{TargetFrameworkDirectory}</AssemblySearchPaths>

<AssemblySearchPaths Condition="'$(AssemblySearchPath_UseAssemblyFoldersConfigFileSearchPath)' != 'false'">$(AssemblySearchPaths);$(AssemblyFoldersConfigFileSearchPath)</AssemblySearchPaths>

<AssemblySearchPaths Condition="'$(AssemblySearchPath_UseRegistry)' != 'false'">$(AssemblySearchPaths);{Registry:$(FrameworkRegistryBase),$(TargetFrameworkVersion),$(AssemblyFoldersSuffix)$(AssemblyFoldersExConditions)}</AssemblySearchPaths>

<AssemblySearchPaths Condition="'$(AssemblySearchPath_UseAssemblyFolders)' != 'false'">$(AssemblySearchPaths);{AssemblyFolders}</AssemblySearchPaths>

<AssemblySearchPaths Condition="'$(AssemblySearchPath_UseGAC)' != 'false'">$(AssemblySearchPaths);{GAC}</AssemblySearchPaths>

<AssemblySearchPaths Condition="'$(AssemblySearchPath_UseRawFileName)' != 'false'">$(AssemblySearchPaths);{RawFileName}</AssemblySearchPaths>

<AssemblySearchPaths Condition="'$(AssemblySearchPath_UseOutDir)' != 'false'">$(AssemblySearchPaths);$(OutDir)</AssemblySearchPaths>

</PropertyGroup>

<!-- ContinueOnError takes 3 values: WarnAndContinue (true), ErrorAndStop (false), and ErrorAndContinue.

Default to ErrorAndStop, since that matches the behaviour in previous versions, and what users

typically expect -->

<PropertyGroup>

<ContinueOnError Condition="'$(ContinueOnError)' == ''">false</ContinueOnError>

</PropertyGroup>

<!-- Users familiar with how some other repos work try to use NoWarn with MSBuild in place of MSBuildWarningsAsMessages. -->

<PropertyGroup>

<MSBuildWarningsAsMessages>$(MSBuildWarningsAsMessages);$(NoWarn)</MSBuildWarningsAsMessages>

<MSBuildWarningsAsErrors Condition="'$(MSBuildWarningsAsErrors)'==''">$(WarningsAsErrors)</MSBuildWarningsAsErrors>

<MSBuildWarningsNotAsErrors Condition="'$(MSBuildWarningsNotAsErrors)'==''">$(WarningsNotAsErrors)</MSBuildWarningsNotAsErrors>

</PropertyGroup>

<!-- Common Project System support -->

<PropertyGroup>

<CommonXamlResourcesDirectory Condition=" '$(CommonXamlResourcesDirectory)' == '' ">$(MSBuildThisFileDirectory)$(LangName)\</CommonXamlResourcesDirectory>

</PropertyGroup>

<!-- We need to fallback to en-US in case the xaml rules are not localized (possibly happen on community languages). -->

<PropertyGroup Condition="!Exists('$(CommonXamlResourcesDirectory)')">

<CommonXamlResourcesDirectory>$(MSBuildThisFileDirectory)en-US\</CommonXamlResourcesDirectory>

</PropertyGroup>

<ItemGroup Condition=" '$(DefineCommonItemSchemas)' == 'true' ">

<PropertyPageSchema Include="$(CommonXamlResourcesDirectory)ProjectItemsSchema.xaml"/>

<PropertyPageSchema Include="

$(CommonXamlResourcesDirectory)General.xaml;

$(CommonXamlResourcesDirectory)Debugger_General.xaml">

<Context>Project</Context>

</PropertyPageSchema>

<PropertyPageSchema Include="$(CommonXamlResourcesDirectory)General.BrowseObject.xaml">

<Context>BrowseObject</Context>

</PropertyPageSchema>

<PropertyPageSchema Include="$(CommonXamlResourcesDirectory)General_File.xaml">

<Context>File</Context>

</PropertyPageSchema>

<PropertyPageSchema Include="$(CommonXamlResourcesDirectory)SCC.xaml">

<Context>Invisible</Context>

</PropertyPageSchema>

<PropertyPageSchema Include="

$(CommonXamlResourcesDirectory)Folder.xaml;

$(CommonXamlResourcesDirectory)None.xaml;

$(CommonXamlResourcesDirectory)Content.xaml;

$(CommonXamlResourcesDirectory)EmbeddedResource.xaml;

">

<Context>File;BrowseObject</Context>

</PropertyPageSchema>

<PropertyPageSchema Include="$(CommonXamlResourcesDirectory)SpecialFolder.xaml;">

<Context>File;ProjectSubscriptionService</Context>

</PropertyPageSchema>

</ItemGroup>

<PropertyGroup>

<DefineCommonReferenceSchemas Condition=" '$(DefineCommonReferenceSchemas)' == '' ">$(DefineCommonItemSchemas)</DefineCommonReferenceSchemas>

</PropertyGroup>

<ItemGroup Condition=" '$(DefineCommonReferenceSchemas)' == 'true' ">

<!-- Assembly references -->

<PropertyPageSchema Include="$(CommonXamlResourcesDirectory)assemblyreference.xaml">

<Context>;BrowseObject</Context>

</PropertyPageSchema>

<PropertyPageSchema Include="$(CommonXamlResourcesDirectory)ResolvedAssemblyReference.xaml">

<Context>ProjectSubscriptionService;BrowseObject</Context>

</PropertyPageSchema>

<!-- COM references -->

<PropertyPageSchema Include="$(CommonXamlResourcesDirectory)COMReference.xaml">

<Context>;BrowseObject</Context>

</PropertyPageSchema>

<PropertyPageSchema Include="$(CommonXamlResourcesDirectory)ResolvedCOMReference.xaml">

<Context>ProjectSubscriptionService;BrowseObject</Context>

</PropertyPageSchema>

<!-- Project references -->

<PropertyPageSchema Include="$(CommonXamlResourcesDirectory)ProjectReference.xaml">

<Context>;BrowseObject</Context>

</PropertyPageSchema>

<PropertyPageSchema Include="$(CommonXamlResourcesDirectory)ResolvedProjectReference.xaml">

<Context>ProjectSubscriptionService;BrowseObject</Context>

</PropertyPageSchema>

</ItemGroup>

<ItemGroup Condition=" '$(DefineCommonCapabilities)' == 'true' ">

<ProjectCapability Include="

AssemblyReferences;

COMReferences;

ProjectReferences;

SharedProjectReferences;

OutputGroups;

AllTargetOutputGroups;

VisualStudioWellKnownOutputGroups;

SingleFileGenerators;

DeclaredSourceItems;

UserSourceItems;

" />

<ProjectCapability Condition=" '$(TargetPlatformIdentifier)' == 'Windows' and '$(TargetPlatformVersion)' &lt; 8.0 "

Include="BuildWindowsDesktopTarget" />

</ItemGroup>

<ItemDefinitionGroup Condition=" '$(DefineExplicitDefaults)' == 'true' ">

<None>

<CopyToOutputDirectory>Never</CopyToOutputDirectory>

</None>

<Content>

<CopyToOutputDirectory>Never</CopyToOutputDirectory>

</Content>

<Compile>

<CopyToOutputDirectory>Never</CopyToOutputDirectory>

</Compile>

<EmbeddedResource>

<CopyToOutputDirectory>Never</CopyToOutputDirectory>

</EmbeddedResource>

</ItemDefinitionGroup>

<!--

Target that allows targets consuming source control confirmation to establish a dependency on targets producing this information.

Any target that reads SourceRevisionId, PrivateRepositoryUrl, SourceRoot, and other source control properties and items

should depend on this target and be conditioned on '$(SourceControlInformationFeatureSupported)' == 'true'.

SourceRevisionId property uniquely identifies the source control revision of the repository the project belongs to.

For Git repositories this id is a commit hash, for TFVC repositories it's the changeset number, etc.

PrivateRepositoryUrl property stores the URL of the repository supplied by the CI server or retrieved from source control manager.

Targets consuming this property shall not publish its value implicitly as it might inadvertently reveal an internal URL.

Instead, they shall only do so if the project sets PublishRepositoryUrl property to true. For example, the NuGet Pack target

may include the repository URL in the nuspec file generated for NuGet package produced by the project if PublishRepositoryUrl is true.

SourceRoot item group lists all source roots that the project source files reside under and their mapping to source control server URLs,

if available. This includes both source files under source control as well as source files in source packages. SourceRoot items are

used by compilers to determine path map in deterministic build and by SourceLink provider, which maps local paths to URLs of source files

stored on the source control server.

Source control information provider that sets these properties and items shall execute before this target (by including

InitializeSourceControlInformation in its BeforeTargets) and set source control properties and items that haven't been initialized yet.

-->

<Target Name="InitializeSourceControlInformation" />

<PropertyGroup>

<SourceControlInformationFeatureSupported>true</SourceControlInformationFeatureSupported>

</PropertyGroup>

<!--

***********************************************************************************************

***********************************************************************************************

Build Section

***********************************************************************************************

***********************************************************************************************

-->

<Target Name="_AddOutputPathToGlobalPropertiesToRemove">

<PropertyGroup>

<_GlobalPropertiesToRemoveFromProjectReferences Condition="'$(PassOutputPathToReferencedProjects)'=='false'">$(_GlobalPropertiesToRemoveFromProjectReferences);OutputPath</_GlobalPropertiesToRemoveFromProjectReferences>

</PropertyGroup>

</Target>

<!--

============================================================

_CheckForInvalidConfigurationAndPlatform

This target checks for errors in statically defined properties. By setting BeforeTargets, we try

to ensure that the target runs before any build related targets.

If your target requires this check and is running as a BeforeTargets of one of the first targets

of $(BuildDependsOn), $(RebuildDependsOn), or $(CleanDependsOn) you will need to set your DependsOn

to this target.

============================================================

-->

<Target

Name="_CheckForInvalidConfigurationAndPlatform"

BeforeTargets="$(BuildDependsOn);Build;$(RebuildDependsOn);Rebuild;$(CleanDependsOn);Clean">

<PropertyGroup>

<_InvalidConfigurationMessageResourceName Condition=" '$(BuildingInsideVisualStudio)' == 'true' ">CommonSdk.InvalidConfigurationTextWhenBuildingInsideVisualStudio</_InvalidConfigurationMessageResourceName>

<_InvalidConfigurationMessageResourceName Condition=" '$(BuildingInsideVisualStudio)' != 'true' ">CommonSdk.InvalidConfigurationTextWhenBuildingOutsideVisualStudio</_InvalidConfigurationMessageResourceName>

</PropertyGroup>

<MSBuildInternalMessage Condition="'$(_InvalidConfigurationMessageSeverity)' != ''" ResourceName="$(_InvalidConfigurationMessageResourceName)" Severity="$(_InvalidConfigurationMessageSeverity)" FormatArguments="$(MSBuildProjectFile);$(_OriginalConfiguration);$(_OriginalPlatform)"/>

<Message Condition="'$(DesignTimeBuild)' != 'true'" Text="Configuration=$(Configuration)" Importance="Low" />

<Message Condition="'$(DesignTimeBuild)' != 'true'" Text="Platform=$(Platform)" Importance="Low" />

<!-- Although we try to ensure a trailing slash, it's possible to circumvent this if the property is set on the command line -->

<MSBuildInternalMessage Condition="'$(OutDir)' != '' and !HasTrailingSlash('$(OutDir)')" ResourceName="CommonSdk.PropertyWithTrailingSlash" Severity="Error" FormatArguments="OutDir"/>

<MSBuildInternalMessage Condition="'$(IntermediateOutputPath)' != '' and !HasTrailingSlash('$(IntermediateOutputPath)')" ResourceName="CommonSdk.PropertyWithTrailingSlash" Severity="Error" FormatArguments="IntermediateOutputPath"/>

<MSBuildInternalMessage Condition="'$(BaseIntermediateOutputPath)' != '' and !HasTrailingSlash('$(BaseIntermediateOutputPath)')" ResourceName="CommonSdk.PropertyWithTrailingSlash" Severity="Error" FormatArguments="BaseIntermediateOutputPath"/>

<!-- Also update the value of PlatformTargetAsMSBuildArchitecture per the value of Prefer32Bit. We are doing

this here because Prefer32Bit may be set anywhere in the targets, so we can't depend on it having the

correct value when we're trying to figure out PlatformTargetAsMSBuildArchitecture -->

<PropertyGroup Condition="'$(Prefer32Bit)' == 'true' and ('$(PlatformTarget)' == 'AnyCPU' or '$(PlatformTarget)' == '') and '$(PlatformTargetAsMSBuildArchitectureExplicitlySet)' != 'true'">

<PlatformTargetAsMSBuildArchitecture>x86</PlatformTargetAsMSBuildArchitecture>

</PropertyGroup>

<MSBuildInternalMessage Condition=" '$(Prefer32Bit)' == 'true' and '$(PreferNativeArm64)' == 'true' " ResourceName="CommonSdk.Prefer32BitAndPreferNativeArm64Enabled" Severity="Error"/>

<MSBuildInternalMessage Condition=" '$(NoWin32Manifest)' == 'true' and '$(PreferNativeArm64)' == 'true' " ResourceName="CommonSdk.NoWin32ManifestAndPreferNativeArm64Enabled" Severity="Error"/>

<MSBuildInternalMessage Condition=" '$(PreferNativeArm64)' == 'true' and '$(Platform)' != 'AnyCPU' " ResourceName="CommonSdk.PlatformIsAnyCPUAndPreferNativeArm64Enabled" Severity="Warning" FormatArguments="$(Platform)" />

<!--

Log an error MSB3540 if the user set MSBuildProjectExtensionsPath in the body of a project. In an SDK style project

if you set a value in the body, the value is not used by the top implicit import but is used by the bottom.

This can lead to confusing behavior and builds can fail for obscure reasons.

-->

<MSBuildInternalMessage

Condition=" '$(_InitialMSBuildProjectExtensionsPath)' != '' And '$(MSBuildProjectExtensionsPath)' != '$(_InitialMSBuildProjectExtensionsPath)' "

ResourceName="CommonSdk.MSBuildProjectExtensionsPathModifiedAfterUse"

Severity="Error"

/>

<!--

Log a warning MSB3539 if:

1. $(EnableBaseIntermediateOutputPathMismatchWarning) is 'true'

2. $(BaseIntermediateOutputPath) was set in the body of a project after its default value was set in Microsoft.Common.props

3. $(BaseIntermediateOutputPath) is not the same as $(MSBuildProjectExtensionsPath)

Similar to the error above, there are cases when users set $(BaseIntermediateOutputPath) in the body of their project and things build but only by coincidence.

MSBuild does not know if $(BaseIntermediateOutputPath) changing would cause problems so tools like NuGet must set $(EnableBaseIntermediateOutputPathMismatchWarning)

to 'true'.

-->

<MSBuildInternalMessage

Condition=" '$(EnableBaseIntermediateOutputPathMismatchWarning)' == 'true' And '$(_InitialBaseIntermediateOutputPath)' != '$(BaseIntermediateOutputPath)' And '$(BaseIntermediateOutputPath)' != '$(MSBuildProjectExtensionsPath)' "

ResourceName="CommonSdk.BaseIntermediateOutputPathMismatchWarning"

Severity="Warning"

/>

</Target>

<!--

============================================================

Build

The main build entry point.

============================================================

-->

<PropertyGroup>

<BuildDependsOn>

BeforeBuild;

CoreBuild;

AfterBuild

</BuildDependsOn>

</PropertyGroup>

<Target

Name="Build"

Condition=" '$(_InvalidConfigurationWarning)' != 'true' "

DependsOnTargets="$(BuildDependsOn)"

Returns="@(TargetPathWithTargetPlatformMoniker)" />

<!--

============================================================

BeforeBuild

Redefine this target in your project in order to run tasks just before Build

============================================================

-->

<Target Name="BeforeBuild"/>

<!--

============================================================

AfterBuild

Redefine this target in your project in order to run tasks just after Build

============================================================

-->

<Target Name="AfterBuild"/>

<!--

============================================================

CoreBuild

The core build step calls each of the build targets.

============================================================

-->

<PropertyGroup>

<CoreBuildDependsOn>

BuildOnlySettings;

PrepareForBuild;

PreBuildEvent;

ResolveReferences;

PrepareResources;

ResolveKeySource;

Compile;

ExportWindowsMDFile;

UnmanagedUnregistration;

GenerateSerializationAssemblies;

CreateSatelliteAssemblies;

GenerateManifests;

GetTargetPath;

PrepareForRun;

UnmanagedRegistration;

IncrementalClean;

PostBuildEvent

</CoreBuildDependsOn>

</PropertyGroup>

<Target

Name="CoreBuild"

DependsOnTargets="$(CoreBuildDependsOn)">

<OnError ExecuteTargets="_TimeStampAfterCompile;PostBuildEvent" Condition="'$(RunPostBuildEvent)'=='Always' or '$(RunPostBuildEvent)'=='OnOutputUpdated'"/>

<OnError ExecuteTargets="_CleanRecordFileWrites"/>

</Target>

<!--

============================================================

Rebuild

Delete all intermediate and final build outputs, and then build the project from scratch.

============================================================

-->

<PropertyGroup>

<_ProjectDefaultTargets Condition="'$(MSBuildProjectDefaultTargets)' != ''">$(MSBuildProjectDefaultTargets)</_ProjectDefaultTargets>

<_ProjectDefaultTargets Condition="'$(MSBuildProjectDefaultTargets)' == ''">Build</_ProjectDefaultTargets>

<RebuildDependsOn>

BeforeRebuild;

Clean;

$(_ProjectDefaultTargets);

AfterRebuild;

</RebuildDependsOn>

<RebuildDependsOn Condition=" '$(MSBuildProjectDefaultTargets)' == 'Rebuild' " >

BeforeRebuild;

Clean;

Build;

AfterRebuild;

</RebuildDependsOn>

</PropertyGroup>

<Target

Name="Rebuild"

Condition=" '$(_InvalidConfigurationWarning)' != 'true' "

DependsOnTargets="$(RebuildDependsOn)"