在C#中处理对象的正确方法？

嗨，我是这个伟大社区的新成员，我有我的第一个问题。希望这是在正确的地方（我希望我的英语是正确的）：

我是一名新手开发人员，我必须改进C#应用程序，因此我找到了这段代码，我想知道这是否是正确的方法：

ObjClass obj = new ObjClass();
obj.SomeText = TextBox1.Text;
obj.SomeNumber = Convert.ToInt32(TextBox2.Text);

ObjClass的定义如下：

    using System;

namespace SomeObject
{
    public class ObjClass : IDisposable
    {
        public string SomeText { get; set; }
        public int SomeNumber{ get; set; }

        public void Dispose()
        {
            GC.SuppressFinalize(this); 
        }
    }
}

if(obj.SomeNumber != null)
{
    //doing something else
    obj.Dispose();
}

然后在使用对象后，完成或处理对象的代码如下所示：

    using System;

namespace SomeObject
{
    public class ObjClass : IDisposable
    {
        public string SomeText { get; set; }
        public int SomeNumber{ get; set; }

        public void Dispose()
        {
            GC.SuppressFinalize(this); 
        }
    }
}

if(obj.SomeNumber != null)
{
    //doing something else
    obj.Dispose();
}

---

如果一个类是一次性的，确保它被释放的最佳方法是使用

using

块

using(var foo = new ObjClass())
{
    // do something
}

---

这将确保即使发生异常，也会释放该对象。

如果类是一次性的，确保该类被释放的最佳方法是使用

块

using(var foo = new ObjClass())
{
    // do something
}

这将确保即使发生异常，也会释放该对象。
如果类是一次性的，确保该类被释放的最佳方法是使用
块

using(var foo = new ObjClass())
{
    // do something
}

这将确保即使发生异常，也会释放该对象。
如果类是一次性的，确保该类被释放的最佳方法是使用
块

using(var foo = new ObjClass())
{
    // do something
}

这将确保即使发生异常也会释放对象。
正确的方法是根本不编写
Dispose
函数。充其量，您只是在捆绑GC，阻止它释放您的对象，直到它在GUI线程上调用它（减慢它的速度）并得到它已运行的确认。在最坏的情况下，你写的和你写的一样糟糕，最终可能导致内存泄漏

现在，如果您直接在对象中处理本机内存或资源（这种情况很少见，您可以避免处理大多数内存或资源，而将其留给.NET），编写终结器（即您缺少的部分！）的正确方法是：

如果您的代码只是阻止终结器运行，则此代码要么在终结器中调用
Dispose（false）
（即当GC确定您的对象无用并试图释放它时），要么在您自己调用
Dispose（）
时调用
Dispose（true）
（然后阻止GC调用终结器，这样您就不会处理两次）

至于如何使用，这是正确的方法：

using(var obj = new Base())
{
   // do whatever you want
   // obj.Dispose() will automatically be called at the end of scope
}

其功能等同于：

try
{ 
   var obj = new Base();  
   // use the object
} 
finally 
{
   // always called, even during exception stack unwinding  
   obj.Dispose();
}

同样，正确的方法不是编写
Dispose
。每次你被要求这样做时，框架都无法为你提供正确的工具，让你留在托管世界中。如今，这些实例越来越少。
正确的方法是根本不编写
Dispose
函数。充其量，你是e只是捆绑GC，阻止它释放你的对象，直到它在GUI线程上调用它（减慢它的速度）并得到它已经运行的确认。在最坏的情况下，你写的和你写的一样糟糕，并最终导致潜在的内存泄漏

现在，如果您直接在对象中处理本机内存或资源（这种情况很少见，您可以避免处理大多数内存或资源，而将其留给.NET），编写终结器（即您缺少的部分！）的正确方法是：

如果您的代码只是阻止终结器运行，则此代码要么在终结器中调用
Dispose（false）
（即当GC确定您的对象无用并试图释放它时），要么在您自己调用
Dispose（）
时调用
Dispose（true）
（然后阻止GC调用终结器，这样您就不会处理两次）

至于如何使用，这是正确的方法：

using(var obj = new Base())
{
   // do whatever you want
   // obj.Dispose() will automatically be called at the end of scope
}

其功能等同于：

try
{ 
   var obj = new Base();  
   // use the object
} 
finally 
{
   // always called, even during exception stack unwinding  
   obj.Dispose();
}

同样，正确的方法不是编写
Dispose
。每次你被要求这样做时，框架都无法为你提供正确的工具，让你留在托管世界中。如今，这些实例越来越少。
正确的方法是根本不编写
Dispose
函数。充其量，你是e只是捆绑GC，阻止它释放你的对象，直到它在GUI线程上调用它（减慢它的速度）并得到它已经运行的确认。在最坏的情况下，你写的和你写的一样糟糕，并最终导致潜在的内存泄漏

现在，如果您直接在对象中处理本机内存或资源（这种情况很少见，您可以避免处理大多数内存或资源，而将其留给.NET），编写终结器（即您缺少的部分！）的正确方法是：

如果您的代码只是阻止终结器运行，则此代码要么在终结器中调用
Dispose（false）
（即当GC确定您的对象无用并试图释放它时），要么在您自己调用
Dispose（）
时调用
Dispose（true）
（然后阻止GC调用终结器，这样您就不会处理两次）

至于如何使用，这是正确的方法：

using(var obj = new Base())
{
   // do whatever you want
   // obj.Dispose() will automatically be called at the end of scope
}

其功能等同于：

try
{ 
   var obj = new Base();  
   // use the object
} 
finally 
{
   // always called, even during exception stack unwinding  
   obj.Dispose();
}

同样，正确的方法不是编写
Dispose
。每次你被要求这样做时，框架都无法为你提供正确的工具，让你留在托管世界中。如今，这些实例越来越少。
正确的方法是根本不编写
Dispose
函数。充其量，你是e只是捆绑GC，阻止它释放你的对象，直到它在GUI线程上调用它（减慢它的速度）并得到它已经运行的确认。在最坏的情况下，你写的和你写的一样糟糕，并最终导致潜在的内存泄漏

现在，如果您直接在对象中处理本机内存或资源（这种情况很少见，您可以避免处理大多数内存或资源，而将其留给.NET），编写终结器（即您缺少的部分！）的正确方法是：

如果您的代码只是阻止终结器运行，则此代码要么在终结器中调用
Dispose（false）
（即当GC确定您的对象无用并试图释放它时），要么在您自己调用
Dispose（）
时调用
Dispose（true）
（然后阻止GC）