System.MissingMethodException: Method not found?

⚠️ Wrong Nuget Package Version ⚠️

I had a unit test project which was pulling in our companies internal EF Nuget data access package and that code pulled in an external package whose version was way behind the current version.

The issue was that the Nuget settings for the top level package was set to the least version; and the lower level/older version won, and that was used during the operations....

Hence it silently got the wrong version for a common assembly used by both the package and the app.

💡 Solution 💡

By Setting/updating the package in Nuget to use and [get] the latest, fixed the issue.

I resolved this issue by installing the correct .NET Framework version on the server. The website was running under version 4.0 and the assembly it was calling to was compiled for 4.5. After installation of .NET Framework 4.5 and upgrading the website to 4.5, all works fine.

Restarting Visual Studio actually fixed it for me. I'm thinking it was caused by old assembly files still in use, and performing a "Clean Build" or restarting VS should fix it.

Check your References!

Be sure that you are consistently pointing to the same 3rd party libraries (don't just trust versions, look at the path) across your solutions projects.

For example, If you use iTextSharp v.1.00.101 in one project and you NuGet or reference iTextSharp v1.00.102 somewhere else you will get these types of runtime errors that somehow trickle up into your code.

I changed my reference to iTextSharp in all 3 projects to point to the same DLL and everything worked.

also.. try to "clean" your projects or solution and rebuild again!

I just ran into this on a .NET MVC project. The root cause was conflicting versions of NuGet packages. I had a solution with several projects. Each of the projects had some NuGet packages. In one project I had a version of the Enterprise Library Semantic Logging package, and in two other projects (that reference the first) I had older versions of the same package. It all compiles without error, but it gave a mysterious "Method not found" error when I tried to use the package.

The fix was to remove the old NuGet packages from the two projects, so that it was only included in the one project that actually needed it. (Also I did a clean rebuild of the whole solution.)

I had this happen to me with a file referenced in the same assembly, not a separate dll. Once I excluded the file from the project and then included it again, everything worked fine.

If developing with your own NuGet server, make sure the assembly versions are all the same:

[assembly: AssemblyVersion("0.2.6")]
[assembly: AssemblyFileVersion("0.2.6")]
[assembly: AssemblyInformationalVersion("0.2.6")]

Have you tried turning if off and on again? Jokes aside, restarting my computer was what actually did the trick for me and isn't mentioned in any of the other answers.

I've just had this issue and it turned out that it was because I was referencing a previous version of the DLL from my UI project. Therefore, when compiling it was happy. But when running it was using the previous version of the DLL.

Check references on all other projects before assuming you need to rebuild/clean/redeploy your solutions.

Must be a reference bug from Microsoft.

I cleaned, rebuild on all my libraries and still got the same problem and couldnt resolve this.

All i did was close the Visual Studio Application and opened it again. That did the trick.

Its very frustrating that such a simple issue can take that long to fix because you wouldnt think that it will be something like that.

I ran into a novel manifestation of this issue, which is related to several existing answers but not quite the same as any of them.

One of our top-level applications had a reference to an internal package, and subsequently referenced an assembly from that package. We'll call this reference version 1.0.

At runtime, it loaded a plugin which also had a reference to the same internal package (and assembly from the package) but a more recent version, we'll call this reference version 2.0.

Version 2.0 was not available anywhere in the runtime path. We have an assembly load redirection which satisfied the dependency by loading version 1.0 of the reference from a different location from the automatic load that happened from the direct reference.

The missing member exception issued for an extension method against an interface implemented by a type in the application. The problem was that when the runtime tried to find the extension method, it found the namespace from the second load of the assembly. The type difference was by the particular instance of the assembly even though both were the same version (ultimately two different copies on disk of the exact same file).

The fix is the same, reconcile the versions involved. In this case, we might also tweak our existing resolution code to not re-load an assembly that is already loaded.

I had a similar scenario where I was getting this same exception being thrown. I had two projects in my web application solution, named, for sake of example, DAL and DAL.CustSpec. The DAL project had a method named Method1, but DAL.CustSpec did not. My main project had a reference to the DAL project and also a reference to another project named AnotherProj. My main project made a call to Method1. The AnotherProj project had a reference to the DAL.CustSpec project, and not the DAL project. The Build configuration had both the DAL and DAL.CustSpec projects configured to be built. After everything was built, my web application project had the AnotherProj and DAL assemblies in its Bin folder. However, when I ran the website, the Temporary ASP.NET folder for the website had the DAL.CustSpec assembly in its files and not the DAL assembly, for some reason. Of course, when I ran the part that called Method1, I received a "Method not found" error.

What I had to do to fix this error was to change the reference in the AnotherProj project from DAL.CustSpec to just DAL, deleted all the files in the Temporary ASP.NET Files folder, and then reran the website. After that, everything started working. I also made sure that the DAL.CustSpec project was not being built by unchecking it in the Build Configuration.

I thought I would share this in case it helps someone else in the future.

It's also possible the problem is with a parameter or return type of the method that's reported missing, and the "missing" method per se is fine.

That's what was happening in my case, and the misleading message made it take much longer to figure out the issue. It turns out the assembly for a parameter's type had an older version in the GAC, but the older version actually had a higher version number due to a change in version numbering schemes used. Removing that older/higher version from the GAC fixed the problem.

In my case it was a copy/paste problem. I somehow ended up with a PRIVATE constructor for my mapping profile:

using AutoMapper;

namespace Your.Namespace
{
    public class MappingProfile : Profile
    {
        MappingProfile()
        {
            CreateMap<Animal, AnimalDto>();
        }
    }
}

(take note of the missing "public" in front of the ctor)

which compiled perfectly fine, but when AutoMapper tries to instantiate the profile it can't (of course!) find the constructor!

Using Costura.Fody 1.6 & 2.0:
After wasting a bunch of time looking into this same kind of error with all other potential solutions not working, I found that an older version of the DLL I was embedding was in the same directory I was running my newly compiled .exe from. Apparently it looks for a local file in the same directory first, then looks inward to its embedded library. Deleting the old DLL worked.

To be clear, it wasn't that my reference was pointing to an old DLL, it was that a copy of an old DLL was in the directory I was testing my application from on a separate system from that which it was compiled on.

In my case, my project was referencing Microsoft.Net.Compilers.2.10.0. When I switched it to Microsoft.Net.Compilers.2.7.0, the error went away. What a mysterious error with such a variety of causes.

In my case, the MissingMethodException was for a method that was in the same file!

However, I had just added a NuGet package that uses .Net Standard2 to my 4.7.1-targeting project, which caused a version conflict for System.Net.Http (4.7.1: version 4.0.0.0, the NuGet package using .NET Standard 2 wants 4.2.0.0). This seem to be known issues that should be better in 4.7.2 (see note 2).

I had used a binding redirect like this in all other my projects, because there were exceptions as soon as it tried to load the 4.2.0.0 which I didn't have:

  <dependentAssembly>
    <assemblyIdentity name="System.Net.Http" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />
    <bindingRedirect oldVersion="0.0.0.0-4.2.0.0" newVersion="4.0.0.0" />
  </dependentAssembly>

Except in this one project, where it seems it tries to load System.Net.Http only while calling a local function that uses a System.Net.Http.HttpResponseMessage as it's parameter or return type (parameter during debugging, return type when I run the tests without the debugger, also a bit strange). And instead of showing a message that it could not load the 4.2.0.0 version of System.Net.Http, it returns this exception.

I came across the same situation in my ASP.NET website. I deleted the published files, restarted VS, cleaned and rebuild the project again. After the next publish, the error was gone...

I solved this problem by making a shelveset with my changes and running TFS Power Tools 'scorch' in my workspace (https://visualstudiogallery.msdn.microsoft.com/f017b10c-02b4-4d6d-9845-58a06545627f). Then I unshelved the changes and recompiled the project. This way you will cleanup any 'hanging-parties' that may be around in your workspace and will startup with a fresh one. This requires, of course, that you are using TFS.

In my case it was a folder with olders DLLs of the same name that those wich were referenced in my .csproj file although the path was explicitly given they were somehow included therefore the several versions of the same DLLs were in conflict.

In case the problem is caused by an old version of the assembly in the GAC.
This can help: How to: Remove an Assembly from the Global Assembly Cache.

This may have been mentioned already, but for me the problem was that the project was referencing 2 nuget packages, and each of those nuget packages referenced a different version of another nuget package.

So:

Project -> Nuget A -> Nuget X 1.1

Project -> Nuget B -> Nuget X 1.2

Both versions of Nuget X had the same extension method that was being called from Project.

When I updated both Nuget A & B to versions that referenced the same version of Nuget X, the error went away.

Ran into this error after updating a variety of Nuget packages. Check your Visual Studio Error List (or build output) for a warning similar to the following:

Found conflicts between different versions of the same dependent assembly. In Visual Studio, double-click this warning (or select it and press Enter) to fix the conflicts; otherwise, add the following binding redirects to the "runtime" node in the application configuration file:
...

Double-clicking this warning in Visual Studio automatically adjusted a variety of bindingRedirect package versions in my web.config and resolved the error.

Possible case could be

Mismatched nuget assembles versions

Problem In Detail

We had more then one nuget packages being generated by a solution.

Class A in packageA 1.0

Class B in packageB 1.0

A is referring B

so when A and B both have update we have to update packageA and packageB, but issue was one of my team member did not update packageB

now PackageA 1.1 still has dependency on PackageB 1.0 But PackageB don't have updated version of Class B

and hence it was not been able to find the method

Solution

Move both packages to +1 Version in this case I moved

PackageA 1.1 -> PackageA 1.2

PackageB 1.0 -> PackageB 1.1

but to make matters more symmetrical to can move both to same Version

PackageA 1.1 -> PackageA 1.2

PackageB 1.0 -> PackageB 1.2

I solved this problem using an approach not mentioned in replies above.

In my case, the target project framework of my project that called the class method was set incorrectly.

(The target framework of the calling project was incorrect. The target framework of the called class/method was correct and I kept it the same).

This happened to me using MVC4, and I decided after reading this thread to rename the object that was throwing the error.

I did a clean and rebuild and noted that it was skipping two projects. When I rebuilt one of them, there was an error where I'd started a function and not finished it.

So VS was referencing a model that I had rewritten without asking me if I wanted to do that.

Just in case it helps anyone, although it's an old issue, my problem was a bit odd.

I had this error while using Jenkins.

Eventually found out that the system date was manually set to a future date, which caused dll to be compiled with that future date. When the date was set back to normal, MSBuild interpreted that the file was newer and didn't require recompile of the project.

I ran into this issue, and what it was for me was one project was using a List which was in Example.Sensors namespace and and another type implemented the ISensorInfo interface. Class Type1SensorInfo, but this class was one layer deeper in the namespace at Example.Sensors.Type1. When trying to deserialize Type1SensorInfo into the list, it threw the exception. When I added using Example.Sensors.Type1 into the ISensorInfo interface, no more exception!

namespace Example
{
    public class ConfigFile
    {
        public ConfigFile()
        {
            Sensors = new List<ISensorInfo<Int32>>();
        }
        public List<ISensorInfo<Int32>> Sensors { get; set; }
     }
   }
}

**using Example.Sensors.Type1; // Added this to not throw the exception**
using System;

namespace Example.Sensors
{
    public interface ISensorInfo<T>
    {
        String SensorName { get; }
    }
}

using Example.Sensors;

namespace Example.Sensors.Type1
{
    public class Type1SensorInfo<T> : ISensorInfo<T>
    {
        public Type1SensorInfo() 
    }
}