how to include a shared class between several project in visual studio code

Question

I am trying to include a shared class between 2 projects, but i can't seem to find out how add them to the project visual studio code, so i can use them. I hope this image helps explain I am trying to ask

Answer 1

I'm not sure for what reason you'd want to have the source code shared between projects instead of the resulting compiled assembly, but given this directory structure...

• ProjectA\
  • ProjectA.csproj
  • Program.cs
• ProjectB\
  • ProjectB.csproj
  • Program.cs
• Shared\
  • Shared.cs

...I was able to use a shared code file (Shared\Shared.cs) like this...

namespace Shared
{
    internal static class Example
    {
        internal static void SayHello()
        {
            string assemblyName = System.Reflection.Assembly.GetExecutingAssembly().GetName().Name;

            System.Console.WriteLine($"Hello, World!  This is {assemblyName}.");
        }
    }
}

...from console application code files (ProjectA\Program.cs and ProjectB\Program.cs) like this...

namespace ProjectA // or ProjectB
{
    class Program
    {
        static void Main()
        {
            Shared.Example.SayHello();
        }
    }
}

...by modifying the default console application project files (ProjectA\ProjectA.csproj and ProjectB\ProjectB.csproj) like this to include all .cs files from the Shared\ directory...

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>netcoreapp3.1</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <Compile Include="..\Shared\*.cs" />
  </ItemGroup>
</Project>

...which yielded these results when run from the base directory...

PS> dotnet run --project ProjectA
Hello, World!  This is ProjectA.
PS> dotnet run --project ProjectB
Hello, World!  This is ProjectB.

Interestingly, I ran the dotnet msbuild command like this...

dotnet msbuild ProjectA -preprocess:fullproject.xml

...to produce a file showing the behind-the-scenes definitions MSBuild would use, and it included a comment describing this same hierarchy with even the same sample names I used...

<!-- WARNING: This pattern is there to ignore folders such as .git and .vs, but it will also match items included with a
      relative path outside the project folder (for example "..\Shared\Shared.cs").  So be sure only to apply it to items
      that are in the project folder. -->
<DefaultExcludesInProjectFolder>$(DefaultItemExcludesInProjectFolder);**/.*/**</DefaultExcludesInProjectFolder>

Maybe not a good solution, but another solution would be to use symlinks/hardlinks/junctions to include the shared code file(s)/directory directly in each project like this...

• ProjectA\
  • ProjectA.csproj
  • Program.cs
  • Shared.cs → ..\Shared\Shared.cs
• ProjectB\
  • ProjectB.csproj
  • Program.cs
  • Shared.cs → ..\Shared\Shared.cs
• Shared\
  • Shared.cs

...or this...

• ProjectA\
  • ProjectA.csproj
  • Program.cs
  • Shared\ → ..\Shared\
    • Shared.cs
• ProjectB\
  • ProjectB.csproj
  • Program.cs
  • Shared\ → ..\Shared\
    • Shared.cs
• Shared\
  • Shared.cs

...although I could see that causing some headaches with source control.

In all of the above examples I used a convenient base directory and relative paths, but there's no reason you couldn't use absolute paths, if needed.

Answer 2

Create your ProjectA and ProjectB as you would normally do. Then create a shared project, say CommonProject. Once the shared project is referenced into the ProjectA and ProjectB, you should be able to access all the shared classes from all the referenced projects. Also you can include conditional compilations symbols within the class to suit the class definition per project.

Answer 3

I think that first you should create an .NET Standard Class Library Project and reference it like this: Reference image

Answer 4

For .NET Core & SDK style projects

Add Directory.Build.props to solution folder (ie- a parent folder of both projects):

<Project>  
    <PropertyGroup>
        <CoreCompileDependsOn>InitGlobal;$(CoreCompileDependsOn)</CoreCompileDependsOn>
    </PropertyGroup>
</Project>

Add Directory.Build.targets to solution folder (ie- a parent folder of both projects):

<Project>  
    <Target Name="InitGlobal" >
        <ItemGroup>
            <Compile Include="$(MSBuildThisFileDirectory)\Global\*.cs" />
        </ItemGroup>
    </Target>
</Project>

Finally

Add the shared/common class file(s) to \Global folder (relative to the Directory.Build.* files above). Careful that any dependencies used are included in each project, or that you add the dependencies in the Directory.Build.props.

Note - the global files will be included in the Build and the IntelliSense, but not visible in the solution. You can make them show as linked classes, by removing the element from the .targets and and putting it in the .props file