Question

实用性的两个类都是一次性的。

我理解使用块的功能。但我不确定它能够或需要使用的所有方式。

例如这是正确的吗？

using (MyClass myClass = new MyClass(params))
{
     myClass.name = "Steve";

     SecondClass myClassSecond = new SecondClass(params);
     myClassSecond.name = "George";
     myClassSecond.msg = "Hello Man in the Yellow Hat";
}

上述两个类都被处理掉了吗？

或者我在使用声明中是否需要两者？

using (MyClass myClass = new MyClass(params))
{
     myClass.name = "Steve";

     using (SecondClass myClassSecond = new SecondClass(params))
     {
          myClassSecond.name = "George";
          myClassSecond.msg = "Hello Man in the Yellow Hat";
     }
}

以上是否正确，或者是否有更好的方法来使用多个using语句？

Answer 1

你的第二个例子是正确的，假设SecondClass确实是不可能的。如果是第一个例子则不正确，因为mySecondClass不会被处理掉。如果一段代码控制一次性实例的生命周期，它应该总是处理它。

仅供参考我更喜欢这种风格在同一个区块中处理多个对象，因为我觉得它更具可读性。

using (MyClass myClass = new MyClass(params))
using (SecondClass myClassSecond = new SecondClass(params))     
{
     myClassSecond.name = "George";
     myClassSecond.msg = "Hello Man in the Yellow Hat";     
}

两个usings共享相同的范围，并按声明的相反顺序进行处理。

Answer 2

当您使用实现IDisposable接口的任何内容时，使用块非常方便。 MSDN：

[using Statement]定义范围，在该范围之外将放置一个或多个对象。

所以，这些实际上相当于

IDisposable resource = new Whatever();
try {
    // whatever
}
finally {
    resource.Dispose();
}

using的主要优点是：它会在离开using块时自动处理对象，因此（1）您不会忘记这样做;（2）它会进行清理例外情况。

简短规则：

无论何时打开文件/数据库连接或创建需要进行任何清理的类实例，都可以在using块中执行此操作。
如果对象的生命周期应该扩展方法范围 - 将其包装在类中，在该类中实现IDisposable，在构造函数中实例化资源，在Dispose中进行清理。

Answer 3

using语句允许程序员指定何时使用资源的对象应该释放它们。
提供给using语句的对象必须实现IDisposable接口。
此接口提供Dispose方法，该方法应释放对象的资源。

以下是显示使用using语句的示例：

using System;
//Object of this class will be given to using hence IDisposable
class C : IDisposable        
{
    public void UseLimitedResource()
    {
        Console.WriteLine("Using limited resource...");
    }

    //Dispose() Method
    void IDisposable.Dispose()
    {
        Console.WriteLine("Disposing limited resource.");
    }
}

class Program
{
    static void Main()
    {
        using (C c = new C())  //Object of Class defined above
        {
            c.UseLimitedResource();
            //Object automatically disposed before closing.
        }                            
        Console.WriteLine("Now outside using statement.");
        Console.ReadLine();
    }
}

在以下情况下可以退出using语句：

已到达using语句的结尾或
如果抛出异常并且控制在语句结束之前离开语句块。

哪种方法适当？

正如你所说的那样

实用性方面的两个类都是一次性的

。然后你的第二种方法是合适的。那就是：

using (MyClass myClass = new MyClass(params))
{
     myClass.name = "Steve";

     using (SecondClass myClassSecond = new SecondClass(params))
     {
          myClassSecond.name = "George";
          myClassSecond.msg = "Hello Man in the Yellow Hat";
     }
}

Answer 4

使用块不会自动处理实现IDisposable的任何子对象。如果您希望它们被丢弃，您必须使用块包裹内部一次性物品。但是，你有一些不同的选择。

您可以使用块嵌套多个，并且它们在最内部到最外部进行评估。有一种更好的方法可以做到这一点，但以下示例有效：

using (MyClass myClass = new MyClass(parameters))
{
     using (SecondClass myClassSecond = new SecondClass(parameters))
     {
          myClassSecond.name = "George";
          myClassSecond.msg = "Hello Man in the Yellow Hat";
     }
}

如果声明是连续的，并且您不需要在两者之间执行任何操作，则以下语法更简洁：

using (MyClass myClass = new MyClass(parameters))
using (SecondClass myClassSecond = new SecondClass(parameters))
{
    myClassSecond.name = "George";
    myClassSecond.msg = "Hello Man in the Yellow Hat";
}

如果你需要在声明之间做一些事情，那么你的后一个例子是正确的：

using (MyClass myClass = new MyClass(parameters))
{
     myClass.name = "Steve";

     using (SecondClass myClassSecond = new SecondClass(parameters))
     {
          myClassSecond.name = "George";
          myClassSecond.msg = "Hello Man in the Yellow Hat";
     }
}

Answer 5

我的经验法则是......如果它实现了idisposable，我会使用一个使用块。

总是比抱歉更安全。

要回答你的问题，我会选择第二种选择。

Answer 6

简单的答案是，如果类有一个dispose方法，请使用。

http://msdn.microsoft.com/en-us/library/system.io.streamreader.aspx

如果没有，则不需要。

http://msdn.microsoft.com/en-us/library/system.random.aspx

我一直希望在MSDN文档中更多的是你。在一天结束时，它是实现IDisposable的类，但实际上我想要的是页面上某种巨大的图标，以某种方式说。 '注意假人！你必须自己管理！'

Answer 7

using块纯粹是一种处理IDisposable对象的语法简单方法。如果您了解using的作用，那么您应该了解它是如何使用的。

请参阅此问题以确切了解using块的内容： Uses of "using" in C#

Answer 8

这取决于这些类是什么以及它们如何处置它们使用的任何资源。 using语句与try/finally块（无catch）基本相同，它在finally块中处理其资源（通过调用.Dispose() on有问题的对象。）

所以，首先，如果有问题的类没有实现IDisposable那么这是一个没有实际意义的点，你不能在using块中使用它在这种情况下。如果它实现IDisposable，那么由于某种原因它可能会这样做，并且当你完成它时应该在该对象上调用.Dispose()。在这些情况下，谨慎地将其包裹在using块中以保证处置。（好吧，“保证”就会执行finally块。这通常是的情况，除非发生了更糟糕的事情。）

Answer 9

我喜欢在我创建的类中实现IDisposable，如果他们使用大量资源，或者我将其创建为文件处理或网络资源的包装器。

在我使用的类对象中，我认为如果有问题的对象打开文件，创建网络连接等，使用using块调用很重要。

一些开发人员会编写一个实现IDisposable的类，这样他们就可以将代码置于更清晰的using块中，但我认为这会滥用创建Disposable的原因。

我需要使用多个using语句吗？

9 个答案: