blocks|key|1943784|text|.NET|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1943785|实现IDisposable接口的所有对象都要求在不再需要它们时调用它们的Dispose方法。using块只是一个try-+C#块的C#糖，它在finally块中处理IDiposable，只要它不是null。因此，即使在try块中抛出异常，也会发生处理。|ordered-list-item|offset|length|style|CODE|1943786|非托管代码。|1943787|Dispose方法可以执行编写Dispose方法的开发人员所放入的任何代码！通常，这涉及释放“非托管”资源，这些资源不是由运行时管理的，例如数据库连接、窗口句柄和文件句柄。请注意，GC管理堆，因此在引用变为不可访问的对象之前将引用设置为null不会有太大帮助。|1943788|这是一个读得好。|1943789|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/system.idisposable%2528v=VS.80%2529.aspx|1|http://www.c-sharpcorner.com/UploadFile/puranindia/ManagedcodeUnmanagedcodeNET06252009005013AM/ManagedcodeUnmanagedcodeNET.aspx|2|http://msdn.microsoft.com/en-us/library/b1yfkh5e%2528VS.71%2529.aspx^0|0|10|7|1A|5|2A|A|2|B|0|0|0|5|1|0|0|7|F|7|0|4|3|2|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@$E|12|F|13|G|H]|$E|14|F|15|G|H]|$E|16|F|17|G|H]]|9|@$E|18|F|19|1|1A]]|A|$]]|$1|I|3|J|5|D|7|1B|8|@]|9|@$E|1C|F|1D|1|1E]]|A|$]]|$1|K|3|L|5|D|7|1F|8|@$E|1G|F|1H|G|H]|$E|1I|F|1J|G|H]]|9|@]|A|$]]|$1|M|3|N|5|6|7|1K|8|@]|9|@$E|1L|F|1M|1|1N]]|A|$]]|$1|O|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]|W|$5|R|S|T|A|$U|X]]|Y|$5|R|S|T|A|$U|Z]]]]

.NET

<ol>
<li>All objects that implement the <a href="http://msdn.microsoft.com/en-us/library/system.idisposable%28v=VS.80%29.aspx" rel="nofollow noreferrer">IDisposable</a> interface are asking that their <code>Dispose</code> methods are called when they are no longer required. The <code>using</code> block is just C# sugar for a try-finally block that disposes the <code>IDiposable</code> in the finally block, as long as it is not null. Consequently, disposal occurs even if an exception is thrown in the try block.</li>
<li><a href="http://www.c-sharpcorner.com/UploadFile/puranindia/ManagedcodeUnmanagedcodeNET06252009005013AM/ManagedcodeUnmanagedcodeNET.aspx" rel="nofollow noreferrer">Unmanaged Code</a>.</li>
<li>The <code>Dispose</code> method does whatever code the developer who wrote the <code>Dispose</code> method put in it! Typically this involves releasing 'unmanaged' resources, which are not managed by the runtime, such as database connections, window handles and file handles. Note that the GC manages the heap, so setting a reference to null just before the object it references becomes unreachable doesn't help all that much.</li>
</ol>

This is a <a href="http://msdn.microsoft.com/en-us/library/b1yfkh5e%28VS.71%29.aspx" rel="nofollow noreferrer">good read</a>.

blocks|key|1588836|text|这个答案只涉及你问题的.NET部分|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1588837|在.NET/Java中应该手动处理什么样的变量？我知道，SqlConnection应该总是手动释放，或者在使用{}块中使用。是对的吗？应该处理的其他类型的变量是什么？|blockquote|1588838|在.NET中，实现IDisposable的所有对象都应该显式地释放(或者在using块中使用)。|offset|length|style|CODE|1588839|我在某个地方读到，必须手动处理非托管代码。是这样吗？什么是非托管代码?我如何知道变量是托管的还是非托管的？|1588840|你可能指的是非托管资源，因为代码不能被处理.所有使用非托管资源的类(未在托管堆上分配内存，win32句柄.)应该实现IDisposable，并且应该明确地进行处理，因为它们不是由垃圾收集器管理的。|1588841|最后，如何处理变量？我知道that+()方法并没有真正地释放变量。那么处置()是做什么的呢？我应该将它们设置为null()吗？垃圾收集器的工作逻辑是什么？|1588842|我不太明白你的问题..。如果不释放变量，则由垃圾收集器管理。当不再使用托管内存时，所有托管内存都会自动释放(也就是说，代码无法访问它，因为没有对它的引用)。IDisposable.Dispose方法仅适用于不受GC管理的资源。|1588843|编辑:作为附带说明，我想补充一点，IDisposable主要用于清理非托管资源，但也经常用于执行其他清理操作和保证状态或数据完整性。例如，IDbTransaction实现IDisposable，以便在提交事务之前发生异常时回滚事务：|1588844|using+(var+trx+=+connection.BeginTransaction())
{
++++//+Do+some+work+in+the+transaction
++++...

++++//+Commit
++++trx.Commit();

}+//+the+transaction+is+implicitly+rolled+back+when+Dispose+is+called|code-block|syntax|javascript|1588845|entityMap^0|0|0|9|B|11|5|0|0|1M|B|0|0|26|J|0|H|B|1X|E|2D|B|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|12|8|@]|9|@]|A|$]]|$1|E|3|F|5|6|7|13|8|@$G|14|H|15|I|J]|$G|16|H|17|I|J]]|9|@]|A|$]]|$1|K|3|L|5|D|7|18|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|19|8|@$G|1A|H|1B|I|J]]|9|@]|A|$]]|$1|O|3|P|5|D|7|1C|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1D|8|@$G|1E|H|1F|I|J]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1G|8|@$G|1H|H|1I|I|J]|$G|1J|H|1K|I|J]|$G|1L|H|1M|I|J]]|9|@]|A|$]]|$1|U|3|V|5|W|7|1N|8|@]|9|@]|A|$X|Y]]|$1|Z|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]]|10|$]]

This answer deals only with the .NET part of your question

<blockquote>
 What kind of variables should be disposed manually in .NET/Java? I know
 that SqlConnection should always be
 either disposed manually or used in a
 using{} block. Is it right? What are
 the other kind of variables that
 should be disposed?
</blockquote>

In .NET, all objects that implement <code>IDisposable</code> should be disposed explicitly (or used in a <code>using</code> block).

<blockquote>
 I read somewhere that unmanaged code must be disposed manually. Is
 that right? What exactly is unmanaged
 code and how do I know if a variable
 is managed or unmanaged?
</blockquote>

You probably mean unmanaged resources, as code can't be disposed... All classes that use unmanaged resources (memory allocated not on the managed heap, win32 handles...) should implement <code>IDisposable</code>, and should be disposed explictly, since they are not managed by the garbage collector.

<blockquote>
 Finally, how do I dispose variables? I know that the Dispose()
 method does not really dispose a
 variable. So what does Dispose() do?
 Should I set them to null()? What is
 the logic by which the garbage
 collector works?
</blockquote>

I'm not sure I understand your question... you don't dispose a variable, it is managed by the garbage collector. All managed memory is automatically released when it's not used anymore (i.e. it is not accessible by code because there are no references left to it). The <code>IDisposable.Dispose</code> method is only intended for resources that are not managed by the GC.

<hr>

EDIT: as a side note, I would like to add that <code>IDisposable</code> is primarily intended to clean-up unmanaged resources, but is also frequently used to perform other cleanup actions and guarantee state or data integrity. For instance, <code>IDbTransaction</code> implements <code>IDisposable</code> in order to rollback the transaction if an exception occurs before the transaction was committed :

<pre><code>using (var trx = connection.BeginTransaction())
{
 // Do some work in the transaction
 ...

 // Commit
 trx.Commit();

} // the transaction is implicitly rolled back when Dispose is called
</code></pre>

blocks|key|391822|text|在Java中，您“关闭”而不是"dispose“。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|391823|JDBC连接，除非您从池中获得它们。|unordered-list-item|391824|JDBC+ResultSets，取决于JDBC连接器。|391825|InputStreams、OutputStreams、读取器和作家(字节数组和字符串支持的除外)。|391826|一些第三方Java库或框架的类需要手动处理/关闭/销毁。|391827|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$]]|$1|E|3|F|5|D|7|O|8|@]|9|@]|A|$]]|$1|G|3|H|5|D|7|P|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Q|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|L|$]]

In Java, you "close" rather than "dispose".

<ul>
<li>JDBC Connections, unless you got them from a pool.</li>
<li>JDBC ResultSets, depending on the JDBC connector.</li>
<li>InputStreams, OutputStreams, Readers and Writers (with the exception of those that are byte array and string backed).</li>
</ul>

Some third-party Java libraries or frameworks have classes that need to be manually disposed / closed / destroyed.

blocks|key|1588873|text|托马斯主要讨论了这一点，但在第三点上作了进一步阐述：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1588874|最后，如何处理变量？我知道that+()方法并没有真正地释放变量。那么处置()是做什么的呢？我应该将它们设置为null()吗？垃圾收集器的工作逻辑是什么？|blockquote|1588875|它们的关键是Dispose()告诉对象释放它当前持有的任何非托管资源，而不是释放对象本身。|1588876|垃圾收集器知道如何释放对象，但是对于IDisposable对象，只有对象本身知道如何释放它的私有资源，因此您必须确保在垃圾收集器释放该对象之前调用Dispose()。|1588877|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$]]|$1|E|3|F|5|6|7|M|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|N|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|O|8|@]|9|@]|A|$]]]|J|$]]

This was mostly covered by Thomas, but to expand on the third point:

<blockquote>
 Finally, how do I dispose variables? I know that the Dispose()
 method does not really dispose a
 variable. So what does Dispose() do?
 Should I set them to null()? What is
 the logic by which the garbage
 collector works?
</blockquote>

They key is that the Dispose() tells the object to free any unmanaged resources that it currently holds, it does not free the object itself.

The garbage collector knows how to free the object, but for IDisposable objects, only the object itself knows how to dispose of it's private resources, so you have to make sure that Dispose() gets called before the garbage collector frees the object.

blocks|key|1588894|text|适用于Java：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1588895|SWT是一个必须配置资源(如图像)的框架，因为该框架使用了必须发布的本机库和系统句柄。当需要处置时，SWT类将被记录下来并告知。|1588896|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

For Java:

SWT is a framework where we have to dispose resources (like images), because the framework uses native libs and system handles which have to released. SWT classes are documented and tell, when dispose is required.

blocks|key|391932|text|跟进其他.NET解决方案..。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|391933|如果您的对象拥有非托管资源，那么仅仅在Dispose()调用时清除它们是不够的，因为您无法保证Dispose将被调用。全面的解决办法是：|391934|为类添加一个终结器。|ordered-list-item|391935|添加一个称为Disposed的公共bool属性，该属性指示对象已被释放。|391936|添加受保护的处置(Bool)方法。public+Dispose()方法没有参数。|391937|当调用Dispose()时，如果已释放的属性为false，它将调用Dispose(true)，并调用GC.SuppressFinalize()来禁用终结器。这对于保持.NET垃圾收集器的正常运行是必不可少的。对于垃圾收集器清理而言，带有未解析终结器的类将到达行尾，因此它们几乎成为内存泄漏。|391938|那么，public+Dispose()方法应该将已释放的属性设置为true。|391939|终结器调用Dispose(false)。|391940|Dispose(bool)总是会清理自己的托管资源，但只有在调用Dispose(true)时才会清理非托管资源。注意，所有的资源清理都在受保护的Dispose(bool)方法中，而不是在public+()方法中。|offset|length|style|BOLD|391941|如果类不是密封的，那么受保护的Dispose(bool)方法应该是一个虚拟方法。需要进行清理的子类可以覆盖Dispose(bool)和与上面相同的逻辑。此外，他们应该用给定的参数调用base.Dispose(bool)。|391942|entityMap^0|0|0|0|0|0|0|0|0|1N|3|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|13|8|@]|9|@]|A|$]]|$1|I|3|J|5|F|7|14|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|15|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|16|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|17|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|18|8|@$S|19|T|1A|U|V]]|9|@]|A|$]]|$1|W|3|X|5|F|7|1B|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|Z|$]]

Following up on other .NET solutions...

If your object owns unmanaged resources, it's not enough to simply clean them up on Dispose() calls, because you have no guarantee that Dispose will get called. The full solution is:

<ol>
<li>Add a finalizer for the class.</li>
<li>Add a public bool property called Disposed, which indicates that the object has been disposed.</li>
<li>Add a protected Dispose(bool) method. The public Dispose() method has no parameters.</li>
<li>When Dispose() is called, if the Disposed property is false, it will call Dispose(true), and call GC.SuppressFinalize() to disable the finalizer. Ths is essential to keep .NET's garbage collector happy. Classes with unspressed finalizers go to the end of the line for garbage collector cleanup, so they become almost a memory leak.</li>
<li>The public Dispose() method should then set the Disposed property to true.</li>
<li>The finalizer calls Dispose(false).</li>
<li>The Dispose(bool) will always clean up its own managed resources, but it will clean up unmanaged resources only when called as Dispose(true). Note that all resource cleanup is in the protected Dispose(bool) method, not in the public Dispose() method.</li>
<li>If the class is not sealed, then the protected Dispose(bool) method should be a virtual method. Subclasses that need to do cleanup can override Dispose(bool) and followht e same logic as above. In addition, they should call base.Dispose(bool) with the parameter they were given.</li>
</ol>

blocks|key|391951|text|如果.net，如果您可以在一个“使用”语句中使用一个对象，这意味着该对象实现了iDisposable，并且在实际操作完成后，您应该调用它的处理方法。请注意，处理方法可能并不总是被称为"+Dispose+"，但是您总是可以通过将对象转换为iDisposable，然后调用Dispose来调用它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|391952|请注意，某些类型的"iDisposable“对象不处理任何非托管资源，而是订阅事件。如果这样的对象没有被正确地释放，那么它可能不会被垃圾收集，除非或者直到它持有订阅事件的所有对象本身都是垃圾收集。在某些情况下，在应用程序退出之前，这种情况永远不会发生。|391953|例如，iEnumerable集合返回的枚举数可能订阅该对象的“集合更改”事件，在调用其dispose方法时取消订阅。如果从未调用dispose方法，则只要集合调用，枚举数就会继续存在。如果集合本身停留了很长时间，并且经常被枚举，这可能会造成巨大的内存泄漏。|391954|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

If .net, if you can use an object in a "using" statement, that means the object implements iDisposable and you should when practical call it's disposal method when you're done with it. Note that the disposal method may not always be called "Dispose", but you can always call it by casting the object to iDisposable and then calling Dispose on that.

Note that some types of "iDisposable" objects don't handle any unmanaged resources, but do subscribe to events. If such an object isn't properly disposed, it might not get garbage-collected unless or until all of the objects for which it holds subscribed events are themselves garbage-collected. In some cases, that may never happen until an application exits.

For example, the enumerator returned by an iEnumerable collection might subscribe to that object's "collection changed" event, unsubscribing when its dispose method is called. If the dispose method is never called, the enumerator would remain around as long as the collection did. If the collection itself stayed around a long time and was enumerated frequently, this could create a huge memory leak.

blocks|key|1943887|text|我同意上面的内容，我将添加一个关于将变量设置为null的后续问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1943888|您不需要使用方法中使用的变量来完成此操作(它们将超出范围，因此只有当它们中的状态必须通过IDisposable.Disopse发出需要清理的信号时，您才不得不担心这一点)。|1943889|例如，内存和静态成员很少有用，因为内存不是人们通常认为的那样宝贵的资源(是一种宝贵的资源，但大多数试图在几行代码中处理它的尝试就像在有一个突发主程序时关闭龙头一样)。|offset|length|style|BOLD|1943890|如果您有一个类的静态或实例成员，并且(A)它是一个大对象(B)“拥有”对象可能会在内存中停留很长一段时间，并且(C)您知道不需要这个值增益来将该成员设置为null，那么它是很有用的。|1943891|实际上，这并不是一个非常常见的组合。如果有疑问，就别管了。|1943892|现在，请在这里阅读其他答案，因为他们对do+()方法的看法更为重要。|1943893|entityMap^0|0|0|10|1B|0|0|2J|0|0|T|0|0|Y|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|T|8|@$F|U|G|V|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|W|8|@$F|X|G|Y|H|I]]|9|@]|A|$]]|$1|L|3|M|5|6|7|Z|8|@$F|10|G|11|H|I]]|9|@]|A|$]]|$1|N|3|O|5|6|7|12|8|@$F|13|G|14|H|I]]|9|@]|A|$]]|$1|P|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|Q|$]]

I'm in agreement with the above, I'll just add to the subsequent question about setting a variable to null.

You don't need to do this with variables used in a method (they will fall out of scope so it's only if they have state within them that must be signalled as needing clean-up, through IDisposable.Disopse that you have to worry abou this).

It's rarely useful for instance or static members, as memory isn't as precious a resource as people often think (it is a precious resource, but most attempts to deal with it in a few lines of code is like turning off your taps while you've a burst main.

It is though useful if you have a static or instance member of a class and (A) it is a large object (B) the "owning" object is likely to stay in memory for a long time and (C) you know you won't need that value gain, to set that member to null.

In practice this isn't a very common combination. If in doubt, just leave alone.

Now, do read the other answers here, as what they say about the Dispose() method is much more important.

Three questions:

<ol>
<li>What kind of variables should be disposed manually in .NET/Java? I know that SqlConnection should always be either disposed manually or used in a using{} block. Is it right? What are the other kind of variables that should be disposed?</li>
<li>I read somewhere that unmanaged code must be disposed manually. Is that right? What exactly is unmanaged code and how do I know if a variable is managed or unmanaged? </li>
<li>Finally, how do I dispose variables? I know that the Dispose() method does not really dispose a variable. So what does Dispose() do? Should I set them to null()? What is the logic by which the garbage collector works?</li>
</ol>

What are the kind of variables that must be disposed? (.NET/Java)

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

三个问题：在.NET/Java中应该手动处理什么样的变量？我知道，SqlConnection应该总是手动释放，或者在使用{}块中使用。是对的吗？应该处理的其他类型的变量是什么？我在某个地方读到，必须手动处理非托管代码。是那么回事吗？什么是非托管代码?我如何知道变量是托管的还是非托管的？最后，如何处理变量？我知道that...

问必须处理的变量类型是什么？(.NET/Java)
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问必须处理的变量类型是什么？(.NET/Java)EN