PROSAGA码农传奇-场景模型-正确使用IDisposable接口

16 条回复

0#
回复此人
v-star*위위 | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”> <P> 如果 <code> MyCollection </code> 无论如何都要收集垃圾，然后你不需要处理它。这样做只会使CPU超过必要的流失，甚至可能使垃圾收集器已经执行的一些预先计算的分析无效。 </p> <P> 我用 <code> IDisposable </code> 做一些事情，比如确保正确处理线程，以及非托管资源。 </p> <P> 的<strong> 编辑 </强> 回应斯科特的评论： </p> <BLOCKQUOTE> <P> <EM> GC性能指标受影响的唯一时间是调用[sic] GC.Collect（）的时间。 </EM> </p> </BLOCKQUOTE> <P> 从概念上讲，GC维护对象引用图的视图，以及从线程的堆栈帧对它的所有引用。这个堆可能非常大并且跨越许多页面的内存。作为优化，GC会缓存对不太可能经常更改的页面的分析，以避免不必要地重新扫描页面。当页面中的数据发生更改时，GC会从内核接收通知，因此它知道页面很脏并需要重新扫描。如果集合在Gen0中，那么页面中的其他内容可能也会发生变化，但这在Gen1和Gen2中的可能性较小。有趣的是，这些挂钩在Mac OS X中不适用于将GC移植到Mac以便在该平台上运行Silverlight插件的团队。 </p> <P> 反对不必要的资源处置的另一点：想象一个过程正在卸载的情况。想象一下，这个过程已经运行了一段时间。有可能该进程的许多内存页面已被交换到磁盘。至少他们不再处于L1或L2缓存中。在这种情况下，卸载的应用程序没有必要将所有这些数据和代码页交换回内存，以“释放”当进程终止时将由操作系统释放的资源。这适用于托管甚至某些非托管资源。只有处理非后台线程活动的资源必须处理，否则进程将保持活动状态。 </p> <P> 现在，在正常执行期间，必须正确清理短暂的资源（正如@fezmonkey指出的那样） <EM> 数据库连接，套接字，窗口句柄 </EM> ）以避免非托管内存泄漏。这些是必须处理的事物。如果你创建一个拥有一个线程的类（并且拥有我的意思是它创建了它，因此负责确保它停止，至少通过我的编码风格），那么该类很可能必须实现 <code> IDisposable </code> 然后拆掉线程 <code> Dispose </code> 。 </p> <P> .NET框架使用 <code> IDisposable </code> 接口作为信号，甚至警告，给开发人员这个类 <EM> 必须 </EM> 被处置。我想不出框架中实现的任何类型 <code> IDisposable </code> （不包括显式接口实现），其中dispos是可选的。 </p> </DIV>

编辑
1#
回复此人
敢嫁就敢娶 | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”> <P> 我不会重复关于使用或释放未受管理资源的常规内容，这些内容已全部涵盖。但我想指出似乎是一种常见的误解。 <BR/> 给出以下代码 <BR/> </p> <pre> Public Class LargeStuff Implements IDisposable Private _Large as string() 'Some strange code that means _Large now contains several million long strings. Public Sub Dispose() Implements IDisposable.Dispose _Large=Nothing End Sub </pre> <P> 我意识到Disposable实现不符合当前的指导原则，但希望你们都能理解。 <BR/> 现在，当调用Dispose时，释放多少内存？ <BR/> <BR/> 答：没有。 <BR/> 调用Dispose可以释放非托管资源，它不能回收托管内存，只有GC可以做到这一点。多数民众赞成不是说上述不是一个好主意，遵循上述模式实际上仍然是一个好主意。一旦运行了Dispose，就没有什么能阻止GC重新声明_Large正在使用的内存，即使LargeStuff的实例可能仍然在范围内。 _Large中的字符串也可能在gen 0中，但LargeStuff的实例可能是gen 2，因此，内存将更快地被重新声明。 <BR/> 添加finaliser来调用上面显示的Dispose方法没有意义。这将延迟重新声明内存以允许终结者运行。 </p> </DIV>

编辑
2#
回复此人
無口君 | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”> <P> 如果你想的<strong> 现在删除 </强> ，使用的<strong> 非托管内存 </强> 。 </p> <P> 看到： </p> <UL> <LI> <a href="http://msdn.microsoft.com/en-us/library/vstudio/system.runtime.interopservices.marshal.allochglobal%28v=vs.100%29.aspx"> Marshal.AllocHGlobal </A> </LI> <LI> <a href="http://msdn.microsoft.com/en-us/library/vstudio/system.runtime.interopservices.marshal.freehglobal%28v=vs.100%29.aspx"> Marshal.FreeHGlobal </A> </LI> <LI> <a href="http://msdn.microsoft.com/en-us/library/vstudio/system.runtime.interopservices.marshal.destroystructure%28v=vs.100%29.aspx"> Marshal.DestroyStructure </A> </LI> </UL> </DIV>

编辑
3#
回复此人
机器设备维修 | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”> <P> 处理管理资源的最合理用例是为GC准备回收原本无法收集的资源。 </p> <P> 一个主要的例子是循环引用。 </p> <P> 虽然最佳做法是使用避免循环引用的模式，但如果你最终得到（例如）一个“子”对象，该对象的引用又回到了它的“父”，那么如果你放弃它就可以停止父级的GC收集引用并依赖GC - 如果你已经实现了终结器，它将永远不会被调用。 </p> <P> 绕过此方法的唯一方法是通过在子项上将Parent引用设置为null来手动中断循环引用。 </p> <P> 在父级和子级上实现IDisposable是执行此操作的最佳方式。在Parent上调用Dispose时，在所有子项上调用Dispose，在子Dispose方法中，将Parent references设置为null。 </p> </DIV>

编辑
4#
回复此人
绵绵 | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”> <P> 您给出的代码示例不是一个很好的例子 <code> IDisposable </code> 用法。字典清除 <EM> 一般 </EM> 不应该去 <code> Dispose </code> 方法。当字典项超出范围时，它将被清除并处理。 <code> IDisposable </code> 实现需要释放一些即使在超出范围之后也不会释放/释放的内存/处理程序。 </p> <P> 以下示例显示了IDisposable模式的一个很好的示例，其中包含一些代码和注释。 </p> <pre> <code> public class DisposeExample { // A base class that implements IDisposable. // By implementing IDisposable, you are announcing that // instances of this type allocate scarce resources. public class MyResource: IDisposable { // Pointer to an external unmanaged resource. private IntPtr handle; // Other managed resource this class uses. private Component component = new Component(); // Track whether Dispose has been called. private bool disposed = false; // The class constructor. public MyResource(IntPtr handle) { this.handle = handle; } // Implement IDisposable. // Do not make this method virtual. // A derived class should not be able to override this method. public void Dispose() { Dispose(true); // This object will be cleaned up by the Dispose method. // Therefore, you should call GC.SupressFinalize to // take this object off the finalization queue // and prevent finalization code for this object // from executing a second time. GC.SuppressFinalize(this); } // Dispose(bool disposing) executes in two distinct scenarios. // If disposing equals true, the method has been called directly // or indirectly by a user's code. Managed and unmanaged resources // can be disposed. // If disposing equals false, the method has been called by the // runtime from inside the finalizer and you should not reference // other objects. Only unmanaged resources can be disposed. protected virtual void Dispose(bool disposing) { // Check to see if Dispose has already been called. if(!this.disposed) { // If disposing equals true, dispose all managed // and unmanaged resources. if(disposing) { // Dispose managed resources. component.Dispose(); } // Call the appropriate methods to clean up // unmanaged resources here. // If disposing is false, // only the following code is executed. CloseHandle(handle); handle = IntPtr.Zero; // Note disposing has been done. disposed = true; } } // Use interop to call the method necessary // to clean up the unmanaged resource. [System.Runtime.InteropServices.DllImport("Kernel32")] private extern static Boolean CloseHandle(IntPtr handle); // Use C# destructor syntax for finalization code. // This destructor will run only if the Dispose method // does not get called. // It gives your base class the opportunity to finalize. // Do not provide destructors in types derived from this class. ~MyResource() { // Do not re-create Dispose clean-up code here. // Calling Dispose(false) is optimal in terms of // readability and maintainability. Dispose(false); } } public static void Main() { // Insert code here to create // and use the MyResource object. } } </code> </pre> </DIV>

编辑
5#
回复此人
樱花弄๑•ั็•็ | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”> <P> 在您发布的示例中，它仍然不“立即释放内存”。所有内存都是垃圾回收，但它可能允许在早期收集内存 <a href="http://aspalliance.com/828_Understanding_Garbage_Collection_in_NET" rel="noreferrer"> 代 </A> 。你必须运行一些测试才能确定。 </p> <HR /> <P> 框架设计指南是指南，而不是规则。它们告诉您接口主要用于什么，何时使用它，如何使用它以及何时不使用它。 </p> <P> 我曾经使用IDisposable读取了一个简单的RollBack（）故障代码。下面的MiniTx类将检查Dispose（）上的标志，如果是 <code> Commit </code> 电话永远不会发生，然后会打电话 <code> Rollback </code> 就自己而言。它添加了一层间接，使调用代码更容易理解和维护。结果看起来像： </p> <pre> <code> using( MiniTx tx = new MiniTx() ) { // code that might not work. tx.Commit(); } </code> </pre> <P> 我也看到计时/日志代码做同样的事情。在这种情况下，Dispose（）方法停止计时器并记录该块已退出。 </p> <pre> <code> using( LogTimer log = new LogTimer("MyCategory", "Some message") ) { // code to time... } </code> </pre> <P> 所以这里有几个具体的例子，它们不做任何非托管资源清理，但是成功地使用了IDisposable来创建更干净的代码。 </p> </DIV>

编辑
6#
回复此人
子阳 | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”> <P> 我看到很多答案已经转移到谈论对托管和非托管资源使用IDisposable。我建议将这篇文章作为我发现如何实际使用IDisposable的最佳解释之一。 </p> <P> <a href="https://www.codeproject.com/Articles/29534/IDisposable-What-Your-Mother-Never-Told-You-About" rel="nofollow noreferrer"> https://www.codeproject.com/Articles/29534/IDisposable-What-Your-Mother-Never-Told-You-About </A> </p> <P> 对于实际问题;你应该使用IDisposable来清理占用大量内存的托管对象吗？的<strong> 没有 </强> 。原因是一旦你处理了IDisposable，你应该让它超出范围。此时，任何引用的子对象也超出范围并将被收集。 </p> <P> 唯一真正的例外是，如果您在托管对象中占用了大量内存，并且您已阻止该线程等待某些操作完成。如果在完成调用之后不需要那些对象，那么将这些引用设置为null可能允许垃圾收集器更快地收集它们。但是这种情况会代表需要重构的坏代码 - 而不是IDisposable的用例。 </p> </DIV>

编辑
7#
回复此人
哎？小查查 | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”> <P> 如果有的话，我希望代码是 <EM> 减 </EM> 离开时有效率。 </p> <P> 调用Clear（）方法是不必要的，如果Dispose没有这样做，GC可能不会这样做...... </p> </DIV>

编辑
8#
回复此人
冷月如霜·胡狼 | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”> <P> 大多数“非托管资源”讨论的一个问题是它们并没有真正定义术语，但似乎暗示它与非托管代码有关。虽然许多类型的非托管资源确实与非托管代码进行交互，但在这些术语中考虑非托管资源是没有用的。 </p> <P> 相反，人们应该认识到所有管理资源的共同点：它们都需要一个对象，要求某些外部“事物”代表它做某事，损害其他一些“事物”，而另一个实体同意这样做直到另行通知。如果对象被抛弃并消失得无影无踪，那就没有什么可以告诉外面的“事物”它不再需要代表不再存在的对象来改变它的行为;因此，“事物的有用性将永久地减少。 </p> <P> 因此，一个非托管资源代表一些外部“事物”的协议，以代表一个对象改变它的行为，如果该对象被抛弃并不再存在，那将无用地损害该外部“事物”的有用性。托管资源是这样一个协议的受益人，但是如果它被放弃则已经注册接收通知，并且在被销毁之前将使用这样的通知将其事务整理好。 </p> </DIV>

编辑
9#
回复此人
一瓶泡沫 | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”> <P> 除了它作为一种控制方式的主要用途的<strong> 一生 </强> 的的<strong> 系统资源 </强> （完全涵盖了令人敬畏的答案 <EM> 伊恩 </EM> ，荣誉！），的<strong> IDisposable接口/使用 </强> 组合也可以用来的<strong> 范围（关键）全球资源的状态变化 </强> ： <EM> 安慰 </EM> ， <EM> 线程 </EM> ， <EM> 处理 </EM> ，任何 <EM> 全球对象 </EM> 像一个 <EM> 应用实例 </EM> 。 </p> <P> 我写了一篇关于这种模式的文章： <a href="http://pragmateek.com/c-scope-your-global-state-changes-with-idisposable-and-the-using-statement/" rel="nofollow"> http://pragmateek.com/c-scope-your-global-state-changes-with-idisposable-and-the-using-statement/ </A> </p> <P> 它说明了如何保护一些常用的全局状态的<strong> 可重复使用 </强> 和的<strong> 可读 </强> 方式： <EM> 控制台颜色 </EM> ，当前 <EM> 线程文化 </EM> ， <EM> Excel应用程序对象属性 </EM> ... </p> </DIV>

编辑
10#
回复此人
至此 | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”> <P> 有些东西是 <code> Dispose() </code> 操作在示例代码中执行 <EM> 威力 </EM> 具有不会因正常的GC而发生的效果 <code> MyCollection </code> 宾语。 </p> <P> 如果引用的对象 <code> _theList </code> 要么 <code> _theDict </code> 然后由其他对象引用 <code> List<> </code> 要么 <code> Dictionary<> </code> 对象不会被收集，但突然没有内容。如果示例中没有Dispose（）操作，那些集合仍将包含其内容。 </p> <P> 当然，如果是这种情况，我会称之为破碎的设计 - 我只是指出（迂腐地，我想）， <code> Dispose() </code> 操作可能不是完全冗余的，取决于是否有其他用途 <code> List<> </code> 要么 <code> Dictionary<> </code> 片段中未显示的内容。 </p> </DIV>

编辑
11#
回复此人
trpnest | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”> <P> 方案我使用IDisposable：清理非托管资源，取消订阅事件，关闭连接 </p> <P> 我用来实现IDisposable的成语（ <EM> 不是线程安全的 </EM> ）： </p> <pre> <code> class MyClass : IDisposable { // ... #region IDisposable Members and Helpers private bool disposed = false; public void Dispose() { Dispose(true); GC.SuppressFinalize(this); } private void Dispose(bool disposing) { if (!this.disposed) { if (disposing) { // cleanup code goes here } disposed = true; } } ~MyClass() { Dispose(false); } #endregion } </code> </pre> </DIV>

编辑
12#
回复此人
那年 | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”> <P> <code> IDisposable </code> 有利于取消订阅活动。 </p> </DIV>

编辑
13#
回复此人
岁爵 | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”> <P> <code> IDisposable </code> 经常被用来利用 <code> using </code> 声明并利用一种简单的方法来对托管对象进行确定性清理。 </p> <pre> <code> public class LoggingContext : IDisposable { public Finicky(string name) { Log.Write("Entering Log Context {0}", name); Log.Indent(); } public void Dispose() { Log.Outdent(); } public static void Main() { Log.Write("Some initial stuff."); try { using(new LoggingContext()) { Log.Write("Some stuff inside the context."); throw new Exception(); } } catch { Log.Write("Man, that was a heavy exception caught from inside a child logging context!"); } finally { Log.Write("Some final stuff."); } } } </code> </pre> </DIV>

编辑
14#
回复此人
那月静好 | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”> <P> 首先是定义。对我来说，非托管资源意味着一些类，它实现了IDisposable接口或使用dll调用创建的东西。 GC不知道如何处理这些对象。如果类仅具有值类型，那么我不认为此类是具有非托管资源的类。对于我的代码，我遵循以下做法： </p> <OL> <LI> 如果我创建类使用一些非托管资源，那么这意味着我还应该实现IDisposable接口以清理内存。 <BR/> </LI> <LI> 我完成使用后立即清理对象。 <BR/> </LI> <LI> 在我的dispose方法中，我遍历所有类的IDisposable成员并调用Dispose。 <BR/> </LI> <LI> 在我的Dispose方法中调用GC.SuppressFinalize（this）以通知垃圾收集器我的对象已被清理。我这样做是因为调用GC是昂贵的操作。 <BR/> </LI> <LI> 作为额外的预防措施，我尝试多次调用Dispose（）。 <BR/> </LI> <LI> 有时我添加私有成员_disposed和check in方法调用对象被清理。如果它被清理干净然后生成 <a href="https://msdn.microsoft.com/en-us/library/system.objectdisposedexception(v=vs.110).aspx" rel="nofollow"> 的ObjectDisposedException </A> <BR/> 以下模板演示了我在单词中描述的代码示例： <BR/> </LI> </醇> <P> </p> <pre> <code> public class SomeClass : IDisposable { /// <summary> /// As usually I don't care was object disposed or not /// </summary> public void SomeMethod() { if (_disposed) throw new ObjectDisposedException("SomeClass instance been disposed"); } public void Dispose() { Dispose(true); } private bool _disposed; protected virtual void Dispose(bool disposing) { if (_disposed) return; if (disposing)//we are in the first call { } _disposed = true; } } </code> </pre> </DIV>

编辑

登录后才能参与评论