blocks|key|4767006|text|从内存中不能确定Dictionary是否有Dispose()，但它肯定有Clear()。在设置对null的任何引用之前，调用这两个函数中的任何一个。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4767007|然后，简单地让垃圾收集器来做它的工作。自己显式地调用GC.Collect()几乎从来都不是一个好主意，它甚至可能无法完成您想要/需要/期望的事情，最终会降低您的性能。静态代码分析(=FxCop)不会用Reliability+rule+CA2001无缘无故地警告你，你知道吗？除非你真的知道自己在做什么，否则就不要这么做。即使那样也不要这样做。;-)|4767008|你确定字典有那么大吗？它不是只有10Mb的内存，其余的都由你的应用程序占用了吗？可能对您有帮助的问题:您是否使用过分析器来查看内存实际消耗的位置……？|4767009|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/bb385973.aspx^0|8|A|L|9|10|7|1C|4|0|Q|C|2S|N|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@$9|13|A|14|1|15]]|E|$]]|$1|H|3|I|5|6|7|16|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|Q]]]]

Not sure from memory if <code>Dictionary</code> has a <code>Dispose()</code> or not, but it's bound to have a <code>Clear()</code>. Call either of these before setting any references to <code>null</code>.

Then, simply let the garbage collector do its work. It is almost never a good idea to call <code>GC.Collect()</code> explicitly yourself and it might not even do what you want/need/expect and end up costing you performance. Static Code Analysis (=FxCop) doesn't warn you with <a href="http://msdn.microsoft.com/en-us/library/bb385973.aspx" rel="nofollow noreferrer">Reliability rule CA2001</a> about this for nothing, you know? Simply do not do this unless you really know what you're doing. And even then don't do it. ;-)

Are you sure the dictionary is that huge? Isn't it just 10 Mb of memory and the rest is otherwise taken by your application? Question that might help you: Have you used a profiler yet to see where memory is actually consumed...?

blocks|key|1218840|text|如果你调用GC.Collect()，它会开始做它的工作，但它会立即返回，它不会阻塞，所以你看不到它的影响，如果你只是调用GC.WaitForPendingFinalizers()之后，它会阻塞你的应用程序，直到GC.Collect()完成它的工作|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1218841|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

if u call GC.Collect() it start to do its job , but it returns immediately, it doesnt block, so you dont see its affect, if you just call GC.WaitForPendingFinalizers() after that it will block your app until GC.Collect() finish its job

blocks|key|704081|text|最有可能的是，您在其他地方隐藏了对字典的引用。因此，字典不会被收集，但是如果您对其执行Clear()操作，则会收集内容。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|704082|正如其他人已经注意到的，不建议强制GC。这可能会导致内存被推入更高的“代”，而这些“代”通常不会被收集，从而浪费的内存比长期获得的内存更多。|704083|entityMap^0|17|7|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|N|8|@]|D|@]|E|$]]]|I|$]]

Most probably you have a hidden reference to the dictionary somewhere else. Thus the dictionary is not collected, but if you <code>Clear()</code> it, the contents get collected.

As others have already noted, forcing the GC is not recommended. This might lead to memory being pushed into higher "generations" which are not often collected, thereby wasting more memory than gained in the long run.

blocks|key|4767186|text|编辑：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4767187|公平地说，将引用设置为null并不会释放内存，它会将其容器分配给一个不同的地址，在本例中为null。根据MSDN的说法，调用Clear()会这样做：“Count属性被设置为0，并且从集合的元素对其他对象的引用也会被释放。容量保持不变。”|offset|length|style|CODE|4767188|..。|4767189|您永远不应该调用垃圾收集器。您正在使用没有本机资源的托管对象，请相信垃圾回收器会在您之后进行清理。|4767190|除了字典的大小，你不需要担心内存，内存不是你的问题，它是垃圾收集器的问题。|4767191|调用Clear()将移除对内部包含的任何对象的引用，但容量保持不变。|4767192|从技术上讲，收集内存是昂贵的，并且是相当耗时的操作。原因是，GC不仅处理堆内存和清理堆，它还对堆进行某种程度的碎片整理。它试图将内存移动到连续的块中，以便在某些代码发出大型请求时加快分配速度。|4767193|附注：你使用的155MB内存的字典有多大？|4767194|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/b5txwy7s(VS.85).aspx)^0|0|1Q|7|1G|4|0|0|0|0|0|2|7|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@$D|13|E|14|F|G]]|9|@$D|15|E|16|1|17]]|A|$]]|$1|H|3|I|5|6|7|18|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|19|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|1A|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|1B|8|@$D|1C|E|1D|F|G]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1E|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1F|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|U|$V|$5|W|X|Y|A|$Z|10]]]]

Edit:

To be fair, setting the reference to null does not free the memory, it assigns it's container to a different address, in this case null. According to <a href="http://msdn.microsoft.com/en-us/library/b5txwy7s(VS.85).aspx" rel="nofollow noreferrer">MSDN</a>, calling <code>Clear()</code>, does this: "The Count property is set to 0, and references to other objects from elements of the collection are also released. The capacity remains unchanged."

...

You should never call the garbage collector. You are using managed objects with no native resources, trust the garbage collector to clean up after you.

Besides the size of your dictionary, you don't need to worry about memory, memory isn't your problem, it's garbage collectors problem.

Calling <code>Clear()</code> will remove the references to any contained object inside, but the capacity remains unchanged.

On a technical note, collecting memory is expensive and a considerable time consuming operating. Reason being, not only does the GC handle heap memory and clean up your heap, it also sort of defrags the heap. It tries to move memory into contiguous blocks to speed up allocation for when some piece of code makes a large request.

p.s. How big is your dictionary that you use 155MB of memory?

blocks|key|3923654|text|私有字节反映了进程的内存使用情况。当对象被收集时，相关的内存段可能会释放给操作系统，也可能不会释放。CLR在操作系统级别管理内存，由于分配和释放内存并不是免费的，因此没有理由立即释放每一块内存，因为应用程序很可能稍后会请求更多内存。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3923655|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Private bytes reflect the process' memory usage. When objects are collected the associated memory segment may or may not be freed to the OS. The CLR manages memory at the OS level and since allocating and freeing memory isn't free there's no reason to free each piece of memory immediately as chances are that the application will probably request more memory later.

blocks|key|3923690|text|Windows有两个内存可用性事件。我希望CLR会对此做出回应。如果有足够的内存可用，明智的做法是不要运行垃圾收集器。因此，为了确保您确实观察到了糟糕的CLR行为，请使用另一个使用大内存堆的虚拟应用程序重复此测试。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3923691|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Windows has two memory availability events. I'd expect the CLR to respond to this. If there's plenty of memory available, the smart thing is to NOT run the garbage collector. So, to make sure that you are indeed observing bad CLR behavior, please repeat this test with another dummy application using a big heap of memory.

blocks|key|1210561|text|你需要找回记忆吗？内存是可用的，只是没有被回收。您不应该清除字典，持有字典的weak+reference，然后让运行库完成它的工作。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1210562|如果您想深入了解正在发生的事情，请查看.NET+Memory+Profiler。这将让你了解你的对象到底发生了什么，它是哪一代的，什么东西正在使用什么内存等等。:)|1210563|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/system.weakreference.aspx|1|http://memprofiler.com/^0|12|E|0|0|J|K|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]]|C|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@$A|U|B|V|1|W]]|C|$]]|$1|F|3|-4|5|6|7|X|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]]]

Do you need the memory back? The memory is available, it's just not being reclaimed. You should not clear the dictionary, hold a <a href="http://msdn.microsoft.com/en-us/library/system.weakreference.aspx" rel="nofollow noreferrer">weak reference</a> to it and let the runtime do its job.

If you want to see really deep into what's going on, check out the <a href="http://memprofiler.com/" rel="nofollow noreferrer">.NET Memory Profiler</a>. That will give you visibility into exactly what's happening with your object, what generation it is, what memory is being used by what and on and on. :)

blocks|key|4767365|text|好吧，我有个理论……字典是KeyValuePair的集合，它也是一个引用类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4767366|您的字典中包含这些keyValuePairs。当你说：|4767367|Txns+=+null|code-block|syntax|javascript|4767368|它从这些KeyValuePair集合中释放引用'Txns‘。但是150Mb的实际内存仍然被这些KeyValuePair引用，并且它们在作用域中，因此还没有准备好进行垃圾收集。|4767369|但是当你使用以下代码时：|4767370|Txns.Clear();
Txns+=+null;
GC.Collect();|4767371|在这里，clear方法还从它们各自的KeyValuePair对象引用中释放了150Mb的数据。因此，这些对象已准备好进行垃圾回收。|4767372|这只是我在这里的一个胡乱猜测。欢迎评论:)|4767373|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$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|F|7|Z|8|@]|9|@]|A|$G|H]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|11|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

Ok, I have a theory here...
Dictionary is a collection of KeyValuePair which is again a reference type.

Your dictionary contains these keyValuePairs. When you say:

<pre><code>Txns = null
</code></pre>

It frees the reference 'Txns' from those KeyValuePair collection. But still the actual memory of 150 Mb is being referenced by those KeyValuePair and they are in scope, thus not ready for garbage collection.

But when you use the following:

<pre><code>Txns.Clear();
Txns = null;
GC.Collect();
</code></pre>

Here, the clear method also frees the 150Mb of data from their respective KeyValuePair object references. Thus those objects were ready for garbage collection.

Its just a wild guess I am making here. Comments are welcome :)

I've create a c# application which uses up 150mb of memory (private bytes), mainly due to a big dictionary:

<pre><code>Dictionary&lt;string, int&gt; Txns = new Dictionary&lt;string, int&gt;();
</code></pre>

I was wondering how to free this memory up. I've tried this:

<pre><code>Txns = null;
GC.Collect();
</code></pre>

But it doesn't seem to make much of a dent in my private bytes - they drop from say 155mb to 145mb.
Any clues?

Thanks

-edit-

Okay I'm having more luck with this code (it gets the private bytes down to 50mb), but why?

<pre><code>Txns.Clear(); // &lt;- makes all the difference
Txns = null;
GC.Collect();
</code></pre>

-edit-

Okay for everyone who says 'don't use GC.collect', fair enough (I'm not going to debate that, other than saying you can see my C background coming through), but it doesn't really answer my question:
Why does the garbage collector only free the memory if i clear the transaction list first? Shouldn't it free the memory anyway, since the dictionary has been dereferenced?

Explicitly freeing memory in c#

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我已经创建了一个c#应用程序，它使用了150mb的内存(私有字节)，这主要是因为有一个大字典：Dictionary<string, int> Txns = new Dictionary<string, int>();我想知道如何释放这个内存。我试过了：Txns = null;GC.Collect();但它似乎并没有对我...

问在c#中显式释放内存
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在c#中显式释放内存EN