Analysis and Solutions for System.MissingMethodException

Problem Phenomenon and Background

During the development of ASP.NET WebForms applications, developers may encounter a perplexing runtime exception: System.MissingMethodException: Method not found. This exception typically appears in previously functioning applications that suddenly start throwing method not found errors.

Consider the following typical scenario: a generic handler class implementing the IHttpHandler interface with a simple call structure:

public class MyHandler: IHttpHandler
{
    public void ProcessRequest(HttpContext context)
    {
        // Throws System.MissingMethodException: Method not found here
        this.DoThis(); 
    }

    public void DoThis(){ ... }
}

From a code logic perspective, the DoThis method indeed exists within the same class and should not theoretically result in a method not found situation. This apparent contradiction often puzzles developers.

Core Cause Analysis

DLL Version Conflicts

The most common cause is old version DLL files lingering somewhere in the system. When the application runs, it might load the wrong assembly version, leading to method signature mismatches. This situation is particularly prone to occur in the following scenarios:

• Failure to thoroughly clean old files after multiple deployments
• Different projects referencing different versions of assemblies
• Version conflicts caused by improper NuGet package management
• Residual old version files in build output directories

Multi-Target Framework Compilation Issues

In complex project structures, especially those involving multi-target framework compilation, more subtle problems may arise. Consider the following scenario:

Assume there is a core library project Core.csproj targeting both netstandard2.0 and net8.0:

// Core.csproj
// <TargetFrameworks>netstandard2.0;net8.0</TargetFrameworks>
namespace Core;
public class Config { public int X { get; init; } }

To support init-only properties in netstandard2.0, the IsExternalInit type needs to be manually added:

#if NETSTANDARD2_0
namespace System.Runtime.CompilerServices;
internal class IsExternalInit;
#endif

When another library project Library.csproj targets netstandard2.0 and references the core library:

// Library.csproj
// <TargetFramework>netstandard2.0</TargetFramework>
public static class ConfigFactory
{
    public static Config Create(int value) => new () { X = value };
}

And an application project targets net8.0 and references the above library:

// Application.exe
// <TargetFramework>net8.0</TargetFramework>
using Factory;
var config = ConfigFactory.Create(42);
Console.WriteLine("Done!");

In this case, the runtime actually loads the core library version targeting net8.0, but the library project was compiled referencing the version targeting netstandard2.0. This mismatch causes MissingMethodException because the type references in method signatures are inconsistent.

Solutions

Basic Solutions

For simple DLL version conflict issues, the most effective solution is:

1. Thoroughly delete all build output files
2. Clean all generated files in the solution
3. Rebuild the entire solution
4. Ensure the latest version of assemblies are deployed
5. Check and remove all folders that might hide old version assemblies

This approach can resolve most problems caused by version residue.

Advanced Solutions

For complex issues caused by multi-target framework compilation, more refined solutions are required:

Using PolySharp NuGet Package

PolySharp is a NuGet package specifically designed to solve such compatibility issues, automatically handling type forwarding and compatibility wrapping:

<PackageReference Include="PolySharp" Version="1.13.1" />

After installation, PolySharp automatically generates appropriate forwarding logic for required types, ensuring compatibility across different target frameworks.

Manual Type Forwarding

If third-party packages cannot be used, manual type forwarding can be implemented:

#if NETSTANDARD2_0
namespace System.Runtime.CompilerServices;
internal class IsExternalInit;
#else
[assembly: global::System.Runtime.CompilerServices.TypeForwardedTo(
    typeof(global::System.Runtime.CompilerServices.IsExternalInit))]
#endif

This method uses TypeForwardedToAttribute to tell the runtime to look for corresponding types in the base class library, ensuring consistency in type references.

Conditional Compilation Strategy

For complex multi-target projects, a more refined conditional compilation strategy can be adopted:

public class Config 
{
    public int X 
    { 
        get; 
#if NETSTANDARD2_0
        set;
#else
        init;
#endif
    }
}

Although this approach increases code complexity, it ensures complete compatibility across different target frameworks.

Preventive Measures

Build and Deployment Best Practices

• Perform complete cleanup operations before each deployment
• Use unified assembly version management strategies
• Ensure all related projects use the same version of dependencies
• Regularly check and update NuGet package references

Project Structure Optimization

• Reasonably plan the scope of multi-target framework usage
• Avoid unnecessary multi-target compilation
• Use conditional compilation to isolate framework-specific code
• Establish clear dependency relationship management

Debugging Techniques

When encountering MissingMethodException, the following debugging methods can be employed:

1. Use Fusion Log Viewer to examine assembly loading details
2. Check the application's dependency tree
3. Verify the actual assembly versions loaded at runtime
4. Use IL Disassembler to analyze method IL code
5. Check type reference consistency in method signatures

Through these systematic analyses and solutions, developers can effectively diagnose and fix System.MissingMethodException exceptions, ensuring stable operation of applications.