Global Assembly Cache (GAC) | .NET Framework Documentation

What is the Global Assembly Cache?

The Global Assembly Cache (GAC) is a repository used by the .NET Framework to store assemblies that are shared by multiple applications. It allows for versioning and makes assemblies accessible to any application that needs them, preventing naming conflicts and improving system stability by isolating application dependencies.

When you install an assembly into the GAC, it becomes available to all applications on the machine that are configured to use that specific version of the assembly. This is particularly useful for libraries and components that are intended to be used by many applications, such as runtime libraries provided by Microsoft or third-party shared components.

Key Concepts

Strong Name: Assemblies must have a strong name to be placed in the GAC. A strong name includes the assembly's manifest, version number, culture information, and a public key token generated from the developer's private key.
Versioning: The GAC supports multiple versions of the same assembly. This allows applications to depend on specific versions without interfering with other applications that may require a different version.
Shared Assemblies: Assemblies in the GAC are considered shared. They are not tied to a specific application's directory.
Installation: Assemblies are typically installed into the GAC using Windows Installer (MSI) packages or through command-line tools like gacutil.exe.

Benefits of Using the GAC

Dependency Management: Simplifies the deployment and management of shared libraries.
Version Control: Allows multiple versions of an assembly to coexist on a system.
Reduced DLL Hell: Helps mitigate issues where different applications require conflicting versions of the same DLL.
Security: Strong naming provides a mechanism for verifying the authenticity and integrity of assemblies.

Managing the GAC

The primary tool for interacting with the GAC is the Global Assembly Cache Tool (gacutil.exe). This tool allows you to install, uninstall, and list assemblies in the GAC.

Using `gacutil.exe`

gacutil.exe is typically located in the .NET Framework SDK directory. You will need to run it from a command prompt with administrator privileges.

Common `gacutil.exe` Commands:

Install an assembly:

gacutil /i <assembly_path>

Example:

gacutil /i "C:\MyProject\bin\Debug\MySharedLibrary.dll"

Uninstall an assembly:
```
gacutil /u <assembly_name>
```
The assembly name should include the version, culture, and public key token (e.g., MySharedLibrary,Version=1.0.0.0,Culture=neutral,PublicKeyToken=your_public_key_token). Example:
```
gacutil /u MySharedLibrary,Version=1.0.0.0,Culture=neutral,PublicKeyToken=a1b2c3d4e5f67890
```
List all assemblies in the GAC:
```
gacutil /l
```
List a specific assembly:
```
gacutil /l <assembly_name>
```
Force an uninstall (use with caution):
```
gacutil /f /u <assembly_name>
```

Important: Always ensure you have the correct assembly name, including its full version and public key token, when uninstalling. Incorrect commands can lead to system instability.

GAC Viewer (`shfusion.dll`)

You can also view the GAC using the GAC Viewer. In Windows Explorer, navigate to %SystemRoot%\assembly. This folder displays assemblies with an "Assembly name," "Version," and "Culture" structure. You can also access it by running shfusion.dll (e.g., regsvr32 shfusion.dll then browse to %SystemRoot%\assembly, or directly navigate to %SystemRoot%\assembly).

When to Use the GAC

The GAC is generally recommended for:

Assemblies that are part of the .NET Framework itself.
Assemblies provided by third-party vendors that are intended for system-wide use.
Your own assemblies that are designed to be shared by multiple, unrelated applications and that benefit from strong naming and versioning.

For assemblies specific to a single application, it's usually better to deploy them alongside that application (e.g., in the application's bin directory) to avoid unnecessary complexity and potential versioning conflicts.

Considerations and Best Practices

Keep it Clean: Only install assemblies that are truly needed in the GAC. An overcrowded GAC can sometimes lead to performance issues or make troubleshooting more difficult.
Versioning Strategy: Plan your versioning strategy carefully. Use semantic versioning principles where possible.
Strong Naming: Always use strong names for assemblies intended for the GAC.
Security: Be cautious when installing assemblies from untrusted sources.
Uninstall Properly: Ensure you uninstall assemblies correctly when they are no longer needed, and understand any dependencies other applications might have.