.NET Assemblies Explained: Private vs Shared + GAC Tutorial (2026)

1. Application Base Directory
   → C:\MyApp\MyApp.exe looks for MyLib.dll

2. Culture-Specific Subdirectories
   → C:\MyApp\en-US\MyLib.dll (for English-US culture)

3. Subdirectories specified in <probing> element
   → C:\MyApp\bin\MyLib.dll
   → C:\MyApp\lib\MyLib.dll

The search stops at the first match found.

System.Data,
  Version=4.0.0.0,
  Culture=neutral,
  PublicKeyToken=b77a5c561934e089

Breaking it down:
• Simple Name: System.Data
• Version: 4.0.0.0 (Major.Minor.Build.Revision)
• Culture: neutral (not culture-specific)
• Public Key Token: b77a5c561934e089 (derived from public key)

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <runtime>
    <!-- Bind to specific version -->
    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
      <dependentAssembly>
        <assemblyIdentity name="SharedLib"
                          publicKeyToken="b77a5c561934e089"
                          culture="neutral" />
        <bindingRedirect oldVersion="1.0.0.0"
                         newVersion="2.0.0.0" />
      </dependentAssembly>
    </assemblyBinding>
  </runtime>
</configuration>

// Code Access Security (CAS)
[assembly: SecurityPermission(
    SecurityAction.RequestMinimum,
    Execution = true)]

// Strong Name Verification
// - Ensures assembly hasn't been tampered with
// - Cryptographic signature validation
// - Publisher identity verification

// Evidence-Based Security
// - Where did the assembly come from?
// - Internet, Intranet, or Local machine?
// - Different trust levels applied automatically

# Using .NET CLI (Recommended for 2026)
dotnet new classlib -n MyPrivateLibrary -f net9.0

# Or using Visual Studio 2026:
# File → New → Project → Class Library (.NET 9.0)

using System;

namespace MyPrivateLibrary
{
    /// <summary>
    /// A simple math utility class for demonstration
    /// </summary>
    public class MathHelper
    {
        /// <summary>
        /// Adds two integers and returns the result
        /// </summary>
        public int Add(int a, int b)
        {
            return a + b;
        }

        /// <summary>
        /// Multiplies two integers
        /// </summary>
        public int Multiply(int a, int b)
        {
            return a * b;
        }

        /// <summary>
        /// Calculates factorial recursively
        /// </summary>
        public long Factorial(int n)
        {
            if (n <= 1) return 1;
            return n * Factorial(n - 1);
        }
    }

    /// <summary>
    /// String manipulation utilities
    /// </summary>
    public class StringHelper
    {
        /// <summary>
        /// Reverses a string
        /// </summary>
        public string Reverse(string input)
        {
            if (string.IsNullOrEmpty(input))
                return input;

            char[] charArray = input.ToCharArray();
            Array.Reverse(charArray);
            return new string(charArray);
        }

        /// <summary>
        /// Checks if a string is a palindrome
        /// </summary>
        public bool IsPalindrome(string input)
        {
            if (string.IsNullOrEmpty(input))
                return false;

            string cleaned = input.ToLower()
                .Replace(" ", "");
            return cleaned == Reverse(cleaned);
        }
    }
}

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

  <PropertyGroup>
    <!-- Target Framework -->
    <TargetFramework>net9.0</TargetFramework>

    <!-- Assembly Information -->
    <AssemblyName>MyPrivateLibrary</AssemblyName>
    <RootNamespace>MyPrivateLibrary</RootNamespace>

    <!-- Version Information -->
    <Version>1.0.0</Version>
    <AssemblyVersion>1.0.0.0</AssemblyVersion>
    <FileVersion>1.0.0.0</FileVersion>

    <!-- Documentation -->
    <GenerateDocumentationFile>true</GenerateDocumentationFile>

    <!-- Nullable Reference Types (C# 9+) -->
    <Nullable>enable</Nullable>

    <!-- Language Version -->
    <LangVersion>latest</LangVersion>
  </PropertyGroup>

  <PropertyGroup>
    <!-- Package/Assembly Metadata -->
    <Authors>Your Name</Authors>
    <Company>Your Company</Company>
    <Product>MyPrivateLibrary</Product>
    <Description>A private assembly for application-specific utilities</Description>
    <Copyright>Copyright © 2026</Copyright>
  </PropertyGroup>

</Project>

# Build in Debug mode
dotnet build

# Build in Release mode (optimized)
dotnet build -c Release

# Output location:
# bin/Debug/net9.0/MyPrivateLibrary.dll
# bin/Release/net9.0/MyPrivateLibrary.dll

# Create console application
dotnet new console -n MyConsoleApp -f net9.0

# Add reference to private library
cd MyConsoleApp
dotnet add reference ../MyPrivateLibrary/MyPrivateLibrary.csproj

using MyPrivateLibrary;
using System;

namespace MyConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("=== Private Assembly Demo ===\n");

            // Using MathHelper
            var mathHelper = new MathHelper();
            Console.WriteLine($"Add(5, 3) = {mathHelper.Add(5, 3)}");
            Console.WriteLine($"Multiply(4, 7) = {mathHelper.Multiply(4, 7)}");
            Console.WriteLine($"Factorial(5) = {mathHelper.Factorial(5)}");

            Console.WriteLine();

            // Using StringHelper
            var stringHelper = new StringHelper();
            string testString = "racecar";
            Console.WriteLine($"Original: {testString}");
            Console.WriteLine($"Reversed: {stringHelper.Reverse(testString)}");
            Console.WriteLine($"Is Palindrome: {stringHelper.IsPalindrome(testString)}");

            Console.WriteLine("\nPress any key to exit...");
            Console.ReadKey();
        }
    }
}

# Run the application
dotnet run

# Expected output:
# === Private Assembly Demo ===
#
# Add(5, 3) = 8
# Multiply(4, 7) = 28
# Factorial(5) = 120
#
# Original: racecar
# Reversed: racecar
# Is Palindrome: True

MyConsoleApp/
├── bin/
│   └── Debug/
│       └── net9.0/
│           ├── MyConsoleApp.exe          ← Main executable
│           ├── MyConsoleApp.dll
│           ├── MyPrivateLibrary.dll      ← Private assembly (copied here!)
│           ├── MyConsoleApp.pdb
│           └── MyPrivateLibrary.pdb

The private assembly is copied to the application's output directory.
This is XCOPY deployment in action!

# Create shared library project
dotnet new classlib -n MySharedLibrary -f net9.0
cd MySharedLibrary

# Using .NET SDK (Modern approach for 2026)
dotnet new tool-manifest
dotnet tool install --local dotnet-sn

# Generate strong name key pair
dotnet sn -k MySharedLibrary.snk

# Alternative: Using Visual Studio Developer Command Prompt
sn -k MySharedLibrary.snk

# This creates a .snk file containing public/private key pair

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

  <PropertyGroup>
    <TargetFramework>net9.0</TargetFramework>

    <!-- Strong Name Configuration -->
    <SignAssembly>true</SignAssembly>
    <AssemblyOriginatorKeyFile>MySharedLibrary.snk</AssemblyOriginatorKeyFile>

    <!-- Assembly Information -->
    <AssemblyName>MySharedLibrary</AssemblyName>
    <RootNamespace>MySharedLibrary</RootNamespace>

    <!-- Versioning (Critical for shared assemblies!) -->
    <Version>1.0.0</Version>
    <AssemblyVersion>1.0.0.0</AssemblyVersion>
    <FileVersion>1.0.0.0</FileVersion>

    <!-- Documentation -->
    <GenerateDocumentationFile>true</GenerateDocumentationFile>
    <Nullable>enable</Nullable>
  </PropertyGroup>

  <PropertyGroup>
    <Authors>Your Name</Authors>
    <Company>Your Company</Company>
    <Product>MySharedLibrary</Product>
    <Description>A shared assembly for system-wide utilities</Description>
    <Copyright>Copyright © 2026</Copyright>
  </PropertyGroup>

</Project>

using System;
using System.Text;

namespace MySharedLibrary
{
    /// <summary>
    /// Shared utility class available system-wide
    /// </summary>
    public class SharedUtilities
    {
        /// <summary>
        /// Generates a unique identifier
        /// </summary>
        public string GenerateUniqueId()
        {
            return Guid.NewGuid().ToString("N");
        }

        /// <summary>
        /// Formats bytes into human-readable size
        /// </summary>
        public string FormatFileSize(long bytes)
        {
            string[] sizes = { "B", "KB", "MB", "GB", "TB" };
            double len = bytes;
            int order = 0;

            while (len >= 1024 && order < sizes.Length - 1)
            {
                order++;
                len = len / 1024;
            }

            return $"{len:0.##} {sizes[order]}";
        }

        /// <summary>
        /// Encodes string to Base64
        /// </summary>
        public string EncodeBase64(string input)
        {
            var bytes = Encoding.UTF8.GetBytes(input);
            return Convert.ToBase64String(bytes);
        }

        /// <summary>
        /// Decodes Base64 string
        /// </summary>
        public string DecodeBase64(string input)
        {
            var bytes = Convert.FromBase64String(input);
            return Encoding.UTF8.GetString(bytes);
        }
    }
}

# Build the assembly
dotnet build -c Release

# Verify strong name signing
sn -v bin/Release/net9.0/MySharedLibrary.dll

# Expected output:
# Assembly 'MySharedLibrary.dll' is valid

# View assembly information including public key token
sn -T bin/Release/net9.0/MySharedLibrary.dll

# Output shows something like:
# Public key token is a1b2c3d4e5f67890

# Method 1: Using gacutil (Classic approach)
# Requires Visual Studio Developer Command Prompt with Admin rights
gacutil /i bin\Release\net9.0\MySharedLibrary.dll

# Method 2: Using PowerShell (Modern approach for 2026)
# Must run as Administrator
[System.Reflection.Assembly]::Load("System.EnterpriseServices, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a")
$publish = New-Object System.EnterpriseServices.Internal.Publish
$publish.GacInstall("C:\Full\Path\To\MySharedLibrary.dll")

# Verify installation
gacutil /l MySharedLibrary

# Or browse GAC location:
# C:\Windows\Microsoft.NET\assembly\GAC_MSIL\MySharedLibrary

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

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net9.0</TargetFramework>
  </PropertyGroup>

  <ItemGroup>
    <!-- Reference by strong name -->
    <Reference Include="MySharedLibrary">
      <HintPath>..\MySharedLibrary\bin\Release\net9.0\MySharedLibrary.dll</HintPath>
      <!-- The assembly will be resolved from GAC at runtime -->
    </Reference>
  </ItemGroup>

</Project>

using MySharedLibrary;
using System;

namespace MyApp
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("=== Shared Assembly Demo ===\n");

            var utils = new SharedUtilities();

            // Generate unique ID
            string id = utils.GenerateUniqueId();
            Console.WriteLine($"Generated ID: {id}");

            // Format file size
            long bytes = 1073741824; // 1 GB
            Console.WriteLine($"File Size: {utils.FormatFileSize(bytes)}");

            // Base64 encoding
            string original = "Hello, Shared Assembly!";
            string encoded = utils.EncodeBase64(original);
            string decoded = utils.DecodeBase64(encoded);

            Console.WriteLine($"\nOriginal: {original}");
            Console.WriteLine($"Encoded: {encoded}");
            Console.WriteLine($"Decoded: {decoded}");

            Console.WriteLine("\nThis assembly is loaded from the GAC!");
            Console.WriteLine("Press any key to exit...");
            Console.ReadKey();
        }
    }
}

using System;
using System.Reflection;

namespace MyApp
{
    class AssemblyVerifier
    {
        public static void VerifyLoadLocation()
        {
            // Get the loaded assembly
            Assembly sharedAssembly = Assembly.Load(
                "MySharedLibrary, Version=1.0.0.0, Culture=neutral, PublicKeyToken=a1b2c3d4e5f67890"
            );

            // Display assembly information
            Console.WriteLine("Assembly Full Name:");
            Console.WriteLine(sharedAssembly.FullName);
            Console.WriteLine();

            Console.WriteLine("Assembly Location:");
            Console.WriteLine(sharedAssembly.Location);
            Console.WriteLine();

            // Check if loaded from GAC
            Console.WriteLine("Loaded from GAC: " + sharedAssembly.GlobalAssemblyCache);
        }
    }
}

# Update version in .csproj
# Change: <Version>2.0.0</Version>
# Change: <AssemblyVersion>2.0.0.0</AssemblyVersion>

# Rebuild
dotnet build -c Release

# Install new version to GAC (both versions will coexist)
gacutil /i bin\Release\net9.0\MySharedLibrary.dll

# List all versions in GAC
gacutil /l MySharedLibrary

# Output shows:
# MySharedLibrary, Version=1.0.0.0, Culture=neutral, PublicKeyToken=a1b2...
# MySharedLibrary, Version=2.0.0.0, Culture=neutral, PublicKeyToken=a1b2...

# Uninstall specific version
gacutil /u MySharedLibrary,Version=1.0.0.0

# Uninstall all versions
gacutil /u MySharedLibrary

# Verify removal
gacutil /l MySharedLibrary

# Should show: "Number of items = 0" if all removed