40

想象一下,您有一个内部使用 IDisposable 对象(例如流读取器)的方法,并且在从文件中读取项目时,yield 返回项目。像这样:

public IEnumerable<YourObject> Read(string filename)
{
    using(var filestream = new FileStream(filename, FileMode.Open))
    {
        using(var reader = new StreamReader(filestream))
        {
            string line;

            while((line = reader.ReadLine()) != null)
            {
                yield return new YourObject(line);
            }
        }
    }
}

当我使用不迭代完整集合的 LINQ 方法时,reader和 会被处理吗?filestream

YourOjbect firstLine = Read("myfile.txt").First();
4

3 回答 3

28

当您使用yield关键字编译器生成嵌套类,它实现IEnumerableIEnumeratorIDisposable存储所有上下文数据:

[CompilerGenerated]
private sealed class <Read>d__0 : IEnumerable<YourObject>, IEnumerable, IEnumerator<YourObject>, IEnumerator, IDisposable
{
    // Fields
    private int <>1__state;
    private YourObject <>2__current;
    public string <>3__filename;
    public Foo <>4__this;
    private int <>l__initialThreadId;
    public FileStream <filestream>5__1;
    public string <line>5__3;
    public StreamReader <reader>5__2;
    public string filename;

    // Methods
    [DebuggerHidden]
    public <Read>d__0(int <>1__state);
    private void <>m__Finally4();
    private void <>m__Finally5();
    private bool MoveNext();
    [DebuggerHidden]
    IEnumerator<YourObject> IEnumerable<YourObject>.GetEnumerator();
    [DebuggerHidden]
    IEnumerator IEnumerable.GetEnumerator();
    [DebuggerHidden]
    void IEnumerator.Reset();
    void IDisposable.Dispose();

    // Properties
    YourObject IEnumerator<YourObject>.Current { [DebuggerHidden] get; }
    object IEnumerator.Current { [DebuggerHidden] get; }
}

如您所见, yield 方法上下文中的所有局部变量都被移动到这个生成的类的字段中。有趣的方法是那些m_Finally以它们的名字命名的方法:

private void <>m__Finally4()
{
    this.<>1__state = -1;
    if (this.<filestream>5__1 != null)
    {
        this.<filestream>5__1.Dispose();
    }
}

如您所见,这些方法处理您的一次性对象(FileStreamStreamReader)。什么时候叫?在枚举结束时,或何时Dispose调用:

private bool MoveNext()
{
    bool CS$1$0000;
    try
    {
        int CS$4$0001 = this.<>1__state;
        if (CS$4$0001 != 0)
        {
            if (CS$4$0001 != 3)
            {
                goto Label_00AB;
            }
            goto Label_0074;
        }
        this.<>1__state = -1;
        this.<filestream>5__1 = new FileStream(this.filename, FileMode.Open);
        this.<>1__state = 1;
        this.<reader>5__2 = new StreamReader(this.<filestream>5__1);
        this.<>1__state = 2;
        while ((this.<line>5__3 = this.<reader>5__2.ReadLine()) != null)
        {
            this.<>2__current = new YourObject(this.<line>5__3);
            this.<>1__state = 3;
            return true;
        Label_0074:
            this.<>1__state = 2;
        }
        this.<>m__Finally5();
        this.<>m__Finally4();
    Label_00AB:
        CS$1$0000 = false;
    }
    fault
    {
        this.System.IDisposable.Dispose();
    }
    return CS$1$0000;
}

void IDisposable.Dispose()
{
    switch (this.<>1__state)
    {
        case 1:
        case 2:
        case 3:
            try
            {
                switch (this.<>1__state)
                {
                    case 2:
                    case 3:
                        break;

                    default:
                        break;
                }
                try
                {
                }
                finally
                {
                    this.<>m__Finally5();
                }
            }
            finally
            {
                this.<>m__Finally4();
            }
            break;
    }
}

如果您查看 的First()实现Enumerable,那么您会看到 - 它Dispose在返回第一项后调用:

using (IEnumerator<TSource> enumerator = source.GetEnumerator())
{
   if (enumerator.MoveNext())
   {
       return enumerator.Current;
   }
}

因此Dispose将调用自动生成的类,所有需要处理的局部变量将通过调用m_Finally方法来处理。

顺便说一句(不是关于 LINQ 的使用),如果您查看foreach 语句实现,您会看到枚举器在枚举后被释放。因此,即使在出现异常Dispose的情况下也会调用生成的类。break

于 2012-06-01T12:08:02.997 回答
17

是的,它们被处理掉了。

[编辑] 只要您使用 LINQ 方法或 foreach 循环,就会自动处理处理。但是,如果您决定手动调用.Enumerator().MoveNext()该方法,那么您需要自己处理处置。[/编辑]

这段代码:

class something : IDisposable
{
    public void Dispose()
    {
        Console.WriteLine("Disposing");
        Console.WriteLine(Environment.StackTrace);
    }
}
static IEnumerable<string> ie()
{
    using (new something())
    {
        Console.WriteLine("first");
        yield return "first";
        Console.WriteLine("second");
        yield return "second";
    }
}
static void Main(string[] args)
{
    Console.WriteLine("before");
    ie().First();
    Console.WriteLine("after");
}

印刷:

before
first
Disposing
   at System.Environment.GetStackTrace(Exception e, Boolean needFileInfo)
   at System.Environment.get_StackTrace()
   at TestApp.Program.something.Dispose() in C:\Users\Tim\Documents\Visual Studi
o 2010\Projects\TestApp\TestApp\Program.cs:line 198
   at TestApp.Program.<ie>d__0.<>m__Finally2() in C:\Users\Tim\Documents\Visual
Studio 2010\Projects\TestApp\TestApp\Program.cs:line 0
   at TestApp.Program.<ie>d__0.System.IDisposable.Dispose() in C:\Users\Tim\Docu
ments\Visual Studio 2010\Projects\TestApp\TestApp\Program.cs:line 0
   at System.Linq.Enumerable.First[TSource](IEnumerable`1 source)
   at TestApp.Program.Main(String[] args) in C:\Users\Tim\Documents\Visual Studi
o 2010\Projects\TestApp\TestApp\Program.cs:line 214
   at System.AppDomain._nExecuteAssembly(RuntimeAssembly assembly, String[] args
)
   at System.AppDomain.ExecuteAssembly(String assemblyFile, Evidence assemblySec
urity, String[] args)
   at Microsoft.VisualStudio.HostingProcess.HostProc.RunUsersAssembly()
   at System.Threading.ThreadHelper.ThreadStart_Context(Object state)
   at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, C
ontextCallback callback, Object state, Boolean ignoreSyncCtx)
   at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, C
ontextCallback callback, Object state)
   at System.Threading.ThreadHelper.ThreadStart()
after
于 2012-06-01T11:54:14.687 回答
1

这是一个一般的 LINQ 问题/问题,是的 - LINQ 将在执行时处理它获得的所有一次性元素。

于 2012-06-01T12:01:52.497 回答