为什么需要在客户端项目中引用EntityFramework.dll来使DbContext IDisposable ?

创建一个包含实体框架模型和对象上下文的类库。然后向解决方案添加一个新的控制台应用程序。从控制台应用程序中，引用具有您的模型的项目。

现在在控制台应用程序中输入以下内容:

static void Main(string[] args)
{
    using (var context = new ExperimentalDbContext())
    {
    }
    Console.ReadKey();
}

当你构建时，你会得到一个错误报告:

类型为"System.Data.Entity"。DbContext'在程序集中定义没有被引用。必须添加对程序集的引用EntityFramework……Yada Yada Yada…

在过去的几年里，我已经做过很多次了，但每次我得到这个错误，我又一次无助地在网上搜索解决方案，我已经忘记了。

解决这个问题需要在ConsoleClient项目中安装EntityFramework NuGet包。

所以，我的问题不是关于修复是什么，而是为什么?因为这根本说不通!

只是为了完整起见，我使用的是v6.1.3的实体框架。但是多年来，我在早期版本中也见过很多次这个错误。

似乎只有当您使用using代码块时才会出现问题，该代码块意味着在IDisposable s上调用Dispose。

要测试这个假设，创建一个控制台应用程序，它在同一个解决方案中引用ClassLibrary1，它在同一个解决方案中引用ClassLibrary2，代码如下:

using ClassLibrary1;
using System;
namespace TestHypothesis1
{
    class Program
    {
        // Testing the hypothesis presented in this answer: http://stackoverflow.com/a/38130945/303685
        // This seems to be the behavior with just (or may be even others I haven't tested for)
        // IDisposable.
        // anotherFoo instance is created just fine, but the moment I uncomment
        // the using statement code, it shrieks.
        static void Main(string[] args)
        {
            //using (var foo = new Foo())
            //{
            //    foo.Gar = "Gar";
            //    Console.WriteLine(foo.Gar);
            //}
            var anotherFoo = new Foo() { Gar = "Another gar" };
            Console.WriteLine(anotherFoo.Gar);
            Console.ReadKey();
        }
    }
}

using ClassLibrary2;
using System;
namespace ClassLibrary1
{
    public class Foo: Bar, IDisposable
    {
        public string Gar { get; set; }
        public void Dispose()
        {
            throw new NotImplementedException();
        }
    }
}

namespace ClassLibrary2
{
    public class Bar
    {
        public string Name { get; set; }
    }
}

并且您将观察到编译器仅对第一个Foo的实例化抱怨缺少引用，而对第二个实例则没有。

奇怪的是，在第一个EntityFramework示例中，如果您从控制台应用程序中删除了对EntityFramework.dll的引用，并将Main中的代码更改为此，它仍然会抱怨缺少引用。

static void Main(string[] args)
{
    var context = new ExperimentalDbContext();
    Console.ReadKey();
    context.Dispose();
}

此外，如果注释掉对context.Dispose()的调用，即上面代码片段的最后一行，代码仍然可以正常工作，即使它抛出InvalidOperationException，但我猜测，这是由于上下文的竞争条件在其迭代器完成MoveNext调用之前被处理。

static void Main(string[] args)
{
    var context = new ExperimentalDbContext();
    Console.ReadKey();
    // context.Dispose();
}

所以，新的附加问题现在变成:

using语句的实现方式是什么，使得编译器在链接引用时停止?

原来的问题仍然存在。

又一次更新

现在看来，问题可能进一步归零到对IDisposable.Dispose方法的调用，因此问题不在于using语句的实现。using语句似乎只是一个无辜的保证，Dispose将被调用，而不是其他。

因此，在上面的Foo示例中，如果在末尾插入对anotherFoo.Dispose的调用，编译器又开始报错。像这样:

using ClassLibrary1;
using System;
namespace TestHypothesis1
{
    class Program
    {
        // Testing the hypothesis presented in this answer: http://stackoverflow.com/a/38130945/303685
        // This seems to be the behavior with just (or may be even others I haven't tested for)
        // IDisposable.
        // anotherFoo instance is created just fine, but the moment I uncomment
        // the using statement code, it shrieks.
        // Final update:
        // The trigger for the error seems to be the call to the Dispose method and not
        // particularly the implementation of the using statement, which apparently, simply
        // ensures that Dispose is called, as is also well-known and documented.
        static void Main(string[] args)
        {
            //using (var foo = new Foo())
            //{
            //    foo.Gar = "Gar";
            //    Console.WriteLine(foo.Gar);
            //}
            var anotherFoo = new Foo() { Gar = "Another gar" };
            Console.WriteLine(anotherFoo.Gar);
            anotherFoo.Dispose();
            Console.ReadKey();
        }
    }
}

那么，最后一个问题，总结起来是:

为什么调用Dispose会阻止编译器链接汇编引用?

我想我们现在有点进展了。

(inside Main)
Console.WriteLine(anotherFoo.Name);

{
    ResourceType resource = expression;
    try {
        statement;
    }
    finally {
        ((IDisposable)resource).Dispose();
    }
}

// our first, base class. put this in it's own project.
namespace SecondLevel
{
    public class SecondLevel
    {
        public void DoSomething()
        {
        }
    }
}

// our second class that references the base class. Add this to it's own project as well. 
namespace FirstLevel
{
    public class FirstLevel
    {
        public SecondLevel.SecondLevel reference;
        public FirstLevel()
        {
            reference = new SecondLevel.SecondLevel();
        }
        public void DoSomethingWithReferencedClass()
        {
            reference.DoSomething();
        }
    }
}

// our "Client" console app that does nothing, but indicates the compiler errors.
// also in it's own project 
// Reference the project that "FirstLevel" is in, 
// but not the one that "Second Level" is in. 
namespace ConsoleTest
{
    class Program
    {
        static void Main(string[] args)
        {
            var primary = new FirstLevel.FirstLevel();
            primary.reference.DoSomething(); // will cause compiler error telling you to reference "Second Level"
            primary.DoSomethingWithReferencedClass(); // no compiler error: does the same thing the right way.
        }
    }
}