Reference a solution project from multiple other projects with a different Platform

[ArcanoxDragon]

I am writing a Source Generator project in my company's solution, and it needs to reference another low-level shared library from the same solution. I will call that the Core project. Most of the solution projects explicitly compile using the x64 Platform (we define <Platforms>x64</Platforms> in Directory.Build.props). The Core project overrides this and defines <Platforms>x64;AnyCPU</Platforms>.

The Source Generator project itself needs to be able to run on ARM64 processors (e.g. if building something on ARM64 Mac devices that will utilize the generator), so it explicitly sets <Platforms>AnyCPU</Platforms> and only ever targets AnyCPU. It should, therefore, reference the AnyCPU version of Core. I have tried to accomplish this as follows:

<ItemGroup>
	<ProjectReference Include="Path\To\Core\Core.csproj">
		<SetConfiguration>Configuration=Debug</SetConfiguration>
		<SetConfiguration Condition="'$(Configuration)' == 'Release'">Configuration=Release</SetConfiguration>
		<SetPlatform>Platform=AnyCPU</SetPlatform>
	</ProjectReference>
</ItemGroup>

However, when building the solution (from Visual Studio or command line), I see the following warning:

warning MSB3270: There was a mismatch between the processor architecture of the project being built "MSIL" and the processor architecture of the reference "C:\Git\Path\To\Core\bin\x64\Debug\netstandard2.0\Core.dll", "AMD64". This mismatch may cause runtime failures. Please consider changing the targeted processor architecture of your project through the Configuration Manager so as to align the processor architectures between your project and references, or take a dependency on references with a processor architecture that matches the targeted processor architecture of your project.

I used the MSBuild Structured Log Viewer to see what was happening, and it looks like the AssignProjectConfiguration task is overriding SetConfiguration, SetPlatform, Configuration, Platform, and FullConfiguration to use whatever Configuration/Platform mapping is defined for the Core project in the solution file.

Obviously I don't want to use that mapping, as I'm explicitly setting SetPlatform and SetConfiguration to something else - I'm not sure why MSBuild just ignores that entirely.

I tried the following hack just to see if it would fix the problem:

<Target Name="FixCoreConfigurationAndPlatform"
		AfterTargets="AssignProjectConfiguration">
	<ItemGroup>
		<_ProjectReferenceWithConfiguration>
			<SetConfiguration Condition="$([System.String]::new('%(_ProjectReferenceWithConfiguration.Identity)').Contains('Core.csproj'))">Configuration=Debug</SetConfiguration>
			<SetPlatform Condition="$([System.String]::new('%(_ProjectReferenceWithConfiguration.Identity)').Contains('Core.csproj'))">Platform=AnyCPU</SetPlatform>
			<Configuration Condition="$([System.String]::new('%(_ProjectReferenceWithConfiguration.Identity)').Contains('Core.csproj'))">Debug</Configuration>
			<Platform Condition="$([System.String]::new('%(_ProjectReferenceWithConfiguration.Identity)').Contains('Core.csproj'))">AnyCPU</Platform>
			<FullConfiguration Condition="$([System.String]::new('%(_ProjectReferenceWithConfiguration.Identity)').Contains('Core.csproj'))">Debug|AnyCPU</FullConfiguration>
		</_ProjectReferenceWithConfiguration>
		<ProjectReferenceWithConfiguration>
			<SetConfiguration Condition="$([System.String]::new('%(ProjectReferenceWithConfiguration.Identity)').Contains('Core.csproj'))">Configuration=Debug</SetConfiguration>
			<SetPlatform Condition="$([System.String]::new('%(ProjectReferenceWithConfiguration.Identity)').Contains('Core.csproj'))">Platform=AnyCPU</SetPlatform>
			<Configuration Condition="$([System.String]::new('%(ProjectReferenceWithConfiguration.Identity)').Contains('Core.csproj'))">Debug</Configuration>
			<Platform Condition="$([System.String]::new('%(ProjectReferenceWithConfiguration.Identity)').Contains('Core.csproj'))">AnyCPU</Platform>
			<FullConfiguration Condition="$([System.String]::new('%(ProjectReferenceWithConfiguration.Identity)').Contains('Core.csproj'))">Debug|AnyCPU</FullConfiguration>
		</ProjectReferenceWithConfiguration>
	</ItemGroup>
</Target>

This actually works on command line! Even if I fully clean the solution (remove all the bin and obj folders), it will build the Core project using the normal Solution configuration (Debug|x64 or whatever), and then right before it builds the Source Generator project, it will build Core again using the Debug|AnyCPU configuration. The Source Generator project consumes the correct version of the DLL (from bin\Debug instead of bin\x64\Debug).

Unfortunately, however, this solution does not work inside Visual Studio. If I remove the bin and obj folders and then try to build the solution inside Visual Studio, I get a build error from the Source Generator project:

error CS0006: Metadata file 'C:\Git\Path\To\Core\obj\Debug\netstandard2.0\ref\Core.dll' could not be found

I used the instructions here to produce a binary log of Visual Studio's specific invocation of MSBuild to see what was different. I narrowed it down to the following:

msbuild/src/Tasks/Microsoft.Common.CurrentVersion.targets

Lines 2120 to 2168 in ce25c01

	<Target
	Name="ResolveProjectReferences"
	DependsOnTargets="PrepareProjectReferences"
	Returns="@(_ResolvedNativeProjectReferencePaths);@(_ResolvedProjectReferencePaths)">
	<!--
	When building this project from the IDE, just gather the referenced build outputs.
	The IDE will already have built the project, so there's no need to do it again here.
	The ContinueOnError setting is here so that, during project load, as
	much information as possible will be passed to the compilers.
	-->
	<MSBuild
	Projects="@(_MSBuildProjectReferenceExistent)"
	Targets="GetTargetPath"
	BuildInParallel="$(BuildInParallel)"
	Properties="%(_MSBuildProjectReferenceExistent.SetConfiguration); %(_MSBuildProjectReferenceExistent.SetPlatform); %(_MSBuildProjectReferenceExistent.SetTargetFramework)"
	Condition="'%(_MSBuildProjectReferenceExistent.BuildReference)' == 'true' and '@(ProjectReferenceWithConfiguration)' != '' and ('$(BuildingInsideVisualStudio)' == 'true' or '$(BuildProjectReferences)' != 'true') and '$(VisualStudioVersion)' != '10.0' and '@(_MSBuildProjectReferenceExistent)' != ''"
	ContinueOnError="!$(BuildingProject)"
	RemoveProperties="%(_MSBuildProjectReferenceExistent.GlobalPropertiesToRemove)$(_GlobalPropertiesToRemoveFromProjectReferences)">
	<Output TaskParameter="TargetOutputs" ItemName="_ResolvedProjectReferencePaths"
	Condition="'%(_MSBuildProjectReferenceExistent.ReferenceOutputAssembly)'=='true'" />
	<Output TaskParameter="TargetOutputs"
	ItemName="%(_MSBuildProjectReferenceExistent.OutputItemType)"
	Condition="'%(_MSBuildProjectReferenceExistent.OutputItemType)' != ''" />
	</MSBuild>
	<!--
	Build referenced projects when building from the command line.
	-->
	<MSBuild
	Projects="@(_MSBuildProjectReferenceExistent)"
	Targets="%(_MSBuildProjectReferenceExistent.Targets)"
	BuildInParallel="$(BuildInParallel)"
	Properties="%(_MSBuildProjectReferenceExistent.SetConfiguration); %(_MSBuildProjectReferenceExistent.SetPlatform); %(_MSBuildProjectReferenceExistent.SetTargetFramework)"
	Condition="'%(_MSBuildProjectReferenceExistent.BuildReference)' == 'true' and '@(ProjectReferenceWithConfiguration)' != '' and '$(BuildingInsideVisualStudio)' != 'true' and '$(BuildProjectReferences)' == 'true' and '@(_MSBuildProjectReferenceExistent)' != ''"
	ContinueOnError="$(ContinueOnError)"
	RemoveProperties="%(_MSBuildProjectReferenceExistent.GlobalPropertiesToRemove)$(_GlobalPropertiesToRemoveFromProjectReferences)">
	<Output TaskParameter="TargetOutputs" ItemName="_ResolvedProjectReferencePaths"
	Condition="'%(_MSBuildProjectReferenceExistent.ReferenceOutputAssembly)'=='true' or '$(DesignTimeBuild)' == 'true'" />
	<Output TaskParameter="TargetOutputs"
	ItemName="%(_MSBuildProjectReferenceExistent.OutputItemType)"
	Condition="'%(_MSBuildProjectReferenceExistent.OutputItemType)' != ''" />
	</MSBuild>

It seems like it explicitly skips building the project if the build is invoked from Visual Studio:

Condition="... and '$(BuildingInsideVisualStudio)' != 'true' and ..."

Is there a way to actually accomplish what I am trying to accomplish? I don't want to use a bunch of custom MSBuild stuff for this (e.g. I don't want to do anything along the lines of manually invoking MSBuild tasks to force-build the project or anything like that).

It would be great if I could just do something with the solution configuration mappings so that it always builds both the x64 and AnyCPU platforms for the Core project, but it doesn't seem like that's possible.

I can potentially change the Core project so that it always targets AnyCPU, but it would be deviating from the expectation that ALL of our other projects up to this point have referenced its x64 DLL. Even if that ends up being the route I take, it would be nice to know how to solve the original problem in case I ever encounter this situation again where the other projects must have architecture-specific target platforms (e.g. native AOT or something).

[hippi345]

The VS part is by design. Inside VS, project references are only queried for their output path, not built, and each project builds once per solution config. So you can't get Core built as both x64 and AnyCPU in one VS build.

You probably don't need to though. MSB3270 looks at the assembly's processor architecture (PlatformTarget), not the Platform name, and the SDK only derives PlatformTarget from Platform when it's empty. A netstandard2.0 lib has no reason to be x64-only, so in Core.csproj:

<PropertyGroup>
  <PlatformTarget>AnyCPU</PlatformTarget>
</PropertyGroup>

It still builds under the x64 solution platform, same output path, but the dll is MSIL. Then the generator can use a plain ProjectReference with no SetPlatform. If Core really has to be arch-specific, a second project compiling the same sources with Platforms=AnyCPU is the usual way.