blocks|key|5041189|text|这里有两个不同的概念。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5041190|5041191|Disposing|ordered-list-item|5041192|Garbage集合|5041193|5041194|这两个概念之间有很大的区别。|5041195|虽然Graphics在被GC收集时会被释放，但为什么要等待GC运行并增加应用程序的内存占用呢？|offset|length|style|CODE|5041196|这是Graphics析构函数的代码。|5041197|~Graphics()
{
++try
++{
++++this.Dispose(false);
++}
++finally
++{
++++//+ISSUE:+explicit+finalizer+call
++++//+ISSUE:+explicit+non-virtual+call
++++__nonvirtual+(((object)+this).Finalize());
++}
}|code-block|syntax|javascript|5041198|阅读更多|5041199|Fundamentals+of+Garbage+Collection|5041200|what+is+relation+between+GC,+Finalize()+and+Dispose?|5041201|What+and+where+are+the+stack+and+heap?|5041202|entityMap|0|LINK|mutability|MUTABLE|url|https://msdn.microsoft.com/en-us/library/ee787088(v=vs.110).aspx|1|https://stackoverflow.com/questions/2344240/what-is-relation-between-gc-finalize-and-dispose|2|https://stackoverflow.com/questions/79923/what-and-where-are-the-stack-and-heap^0|0|0|0|0|0|0|2|8|0|2|8|0|0|0|0|Y|0|0|0|1G|1|0|0|12|2|0^^$0|@$1|2|3|4|5|6|7|1H|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|1J|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|1K|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|1M|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1N|8|@$M|1O|N|1P|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1Q|8|@$M|1R|N|1S|O|P]]|9|@]|A|$]]|$1|S|3|T|5|U|7|1T|8|@]|9|@]|A|$V|W]]|$1|X|3|Y|5|6|7|1U|8|@]|9|@]|A|$]]|$1|Z|3|10|5|6|7|1V|8|@]|9|@$M|1W|N|1X|1|1Y]]|A|$]]|$1|11|3|12|5|6|7|1Z|8|@]|9|@$M|20|N|21|1|22]]|A|$]]|$1|13|3|14|5|6|7|23|8|@]|9|@$M|24|N|25|1|26]]|A|$]]|$1|15|3|-4|5|6|7|27|8|@]|9|@]|A|$]]]|16|$17|$5|18|19|1A|A|$1B|1C]]|1D|$5|18|19|1A|A|$1B|1E]]|1F|$5|18|19|1A|A|$1B|1G]]]]

There are two different concepts here.

<ol>
<li>Disposing</li>
<li>Garbage Collection</li>
</ol>

There is a lot of difference between those two concepts.

Although <code>Graphics</code> get disposed when collected by GC but why you should wait for GC to run and increase the memory footage of your application?

Here is the code for <code>Graphics</code> destructor. 

<pre><code>~Graphics()
{
 try
 {
 this.Dispose(false);
 }
 finally
 {
 // ISSUE: explicit finalizer call
 // ISSUE: explicit non-virtual call
 __nonvirtual (((object) this).Finalize());
 }
}
</code></pre>

Read more

<a href="https://msdn.microsoft.com/en-us/library/ee787088(v=vs.110).aspx" rel="nofollow noreferrer">Fundamentals of Garbage Collection</a>

<a href="https://stackoverflow.com/questions/2344240/what-is-relation-between-gc-finalize-and-dispose">what is relation between GC, Finalize() and Dispose?</a>

<a href="https://stackoverflow.com/questions/79923/what-and-where-are-the-stack-and-heap">What and where are the stack and heap?</a>

blocks|key|1256455|text|那么|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1256456|肯定会像任何其他变量一样，在过程完成时自动处理掉，不是吗？|blockquote|1256457|1256458|1256459|不幸的是，并不是所有的System.Drawing类都是这样的(编辑:阅读点数答案)|1256460|还有其他一些棘手的类，比如Bitmap，虽然它是“托管”的，但它的大小很小。所以，每当它被延迟处理时，它就会导致内存不足！|1256461|在内存泄漏发生之前丢弃一个未使用的对象是一种更好的做法。|1256462|不过细节要复杂得多。|1256463|您可以在System.Drawing中搜索有关非托管资源的更多信息以了解更多信息。|1256464|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$]]|$1|E|3|-4|5|6|7|U|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|V|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|Y|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|Z|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

<blockquote>
 Then surely like any other variables, it will get disposed of automatically when the procedure completes, wouldn't it?
</blockquote>

Unfortunately, this may not be always the case for all System.Drawing classes (edit: read dotctor answer)

There are some other tricky classes like Bitmap where, though it is "managed", but the size is small. So, whenever it is late to be disposed, it will cause out of memory!

It is kind of better practice to dipose an unused object before memory leak occurs.

The details are more complicated though.

You can search more on unmanaged resource in System.Drawing to understand this more.

blocks|key|5041284|text|The+Microsoft+.NET+class+library+provides+a+managed+interface+for+GDI%2B+via+the+System.Drawing+namespace.+GDI%2B是基于C%2B%2B的，并生成对非托管对象的引用。因此，处置System.Drawing命名空间的可处置对象非常重要，因为垃圾回收器不会自动处置非托管对象。这些对象可能包含执行作业的终结器；但是，您无法控制何时执行这些终结器。另外，挂起的终结器使堆变得混乱。因此，最好显式或通过using-statement调用Dispose()。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5041285|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Graphics_Device_Interface^0|6S|5|79|9|0|2W|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@$9|S|A|T|1|U]]|E|$]]|$1|F|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

<a href="https://en.wikipedia.org/wiki/Graphics_Device_Interface" rel="nofollow">The Microsoft .NET class library provides a managed interface for GDI+ via the System.Drawing namespace.</a> GDI+ is C++-based and yields references to non-managed objects. It is therefore important to dispose the disposable objects of the System.Drawing namespace, because non-manged objects are not disposed automatically by the garbage collector. These objects might contain finalizers that do the job; however, you are not in the control of when these finalizers are executed. Also pending finalizers are cluttering the heap. It is therefore better to call <code>Dispose()</code> explicitly or by the means of a <code>using</code>-statement.

blocks|key|1256576|text|通常，您无法知道对象何时会被垃圾回收，从而被释放。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1256577|在释放之前，一些对象将保留对资源的引用，这些资源将使用您的内存或禁止某些操作。因此，最好在这些对象不再使用时立即将其丢弃。|1256578|我正在处理一个bug，其中一个临时的SQLite数据库文件在使用后无法删除，但只有在某些时候才会删除！经过三天令人沮丧的研究，我发现问题出在一个没有及时处理的SQLite命令对象。|1256579|所以使用你的using+;-)|offset|length|style|CODE|1256580|entityMap^0|0|0|0|6|5|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Q|8|@$H|R|I|S|J|K]]|9|@]|A|$]]|$1|L|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|M|$]]

In general you can't know when the object will be garbage collected, and thus disposed.

Before disposal, some objects will keep references to resources that will use your memory or inhibit some operations. So it's good to dispose these objects as soon as they are not of use anymore.

I was working on a bug where a temporary SQLite database file could not be deleted after being used, but only sometimes! After three frustrating days of research, I've found that the problem was a SQLite command object which was not timely disposed.

So use your <code>using</code>s ;-)

Suppose I have a procedure for e.g. a button click.

And I create a Graphics object.

Apparently i'm supposed to dispose of it e.g.

<pre><code>using(Graphics gr__=this.CreateGraphics()) {

} 
</code></pre>

or with calling <code>.Dispose()</code> in the <code>finally</code> of a try-catch-finally.

But considering that the procedure is going to end pretty quickly.

Suppose I create it local to the procedure (not global, not in a using). But local to the procedure.

Then surely like any other variables, it will get disposed of automatically when the procedure completes, wouldn't it?

So why is it important for me to dispose it manually/explicitly?

Why can't I let it garbage collect automatically like any other variable?

Sure it may be perhaps a bit bigger than an 'int' but it might still be quite small and won't be in memory for long since the procedure ends so fast anyway. It may even be that straight after the using is finished or the <code>Dispose()</code> is called, the procedure ends and thus I suppose it'd be disposed, if the variable was local to the procedure. So why bother with the explicit garbage collection of <code>Dispose()</code>/<code>using</code>?

Why dispose an object which will surely get disposed of soon regardless?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

假设我有一个用于点击按钮的过程。我创建了一个Graphics对象。显然我应该把它处理掉。using(Graphics gr__=this.CreateGraphics())  {} 或者在try-catch-finally的finally中调用.Dispose()。但考虑到这个过程很快就会结束。假设我在过程本地创建它(...

问为什么要处理一个肯定很快就会被处理的对象呢？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么要处理一个肯定很快就会被处理的对象呢？EN