Overview of Assembly Loading in .NET

Assemblies are the building blocks of .NET applications. They contain compiled code that the Common Language Runtime (CLR) executes. .NET provides several methods for loading assemblies dynamically at runtime, with LoadFile and LoadFrom being two common methods. Understanding the differences between these methods is crucial for developers who want to manage assemblies effectively.

Assembly Loading Mechanisms in .NET

LoadFile Method

The LoadFile method is a part of the System.Reflection.Assembly class. It is used to load an assembly given its file path. This method is straightforward and does not involve any assembly resolution, meaning it doesn't consult the Global Assembly Cache (GAC), configuration files, or application base directories.

Characteristics of LoadFile

• No Assembly Resolution: LoadFile strictly loads the assembly from the specified path. It does not attempt to resolve dependencies or check other directories.
• Unique Context: Each call to LoadFile creates a unique context. Assemblies loaded by this method are isolated in their own domain and do not interact across contexts.
• Use Case: Best suited for applications where the assembly location is fixed and well-known, or when loading plugins from specific paths.

Example of LoadFile

• Assembly Resolution: If dependencies are not found in the specified path, LoadFrom will search the GAC, the application's base directory, and probe paths defined in the application's configuration.
• Default Load Context: Assemblies loaded via LoadFrom share the default load context of the application, making it easier to resolve dependencies already in use by other assemblies.
• Use Case: Ideal for scenarios where assemblies might dynamically change locations or when leveraging diverse libraries that need resolution support.
• LoadFile: Since LoadFile does not perform resolution across contexts, it can be safer if you want to avoid inadvertently using potentially malicious assemblies present elsewhere.
• LoadFrom: Due to its resolution capabilities, consider assembly trust levels. Unverified assemblies can pose security risks if loaded.
• LoadFile may be marginally faster for loading individual, known-location assemblies due to its lack of resolution.
• LoadFrom can introduce slight overhead due to resolution steps but simplifies dependency management.