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

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确实是dispoable。 如果是第一个例子则不正确，因为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

using块不会自动处理任何实现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块的内容： C＃中“使用”的使用

Answer 8

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

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

Answer 9

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

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

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