An implicit memory leak brought by dictionary

Beware of an implicit memory leak caused by dictionary

Recently, when looking at the source code of the dictionary, suddenly think of the improper use of dictionary there is a possibility of a hidden memory leak.

Simplifying usage scenarios

Little A is writing a simple book sales system.

The first thing he needs to deal with is the collection of books and orders. Then he found himself needing a specific memory structure to temporarily save all the orders and their accompanying collection of sales books to reduce the pressure on the database. Small a think of the dictionary dictionary the best structure to save the associated data-the order object as a key, the corresponding sales bibliography books as a value, saved in the dictionary.

The order contains the order ID/order Person ID/order time. Little a knows that to use the order object as a key, he must rewrite the GetHashCode () method of the Order class and The Equals () method so that the two functions make sense rather than accept the default implementation of the system, which is required by dictionary. This feature is implemented as follows:

Order Class

2. Internal class Order
4. {
6. public int ID {get; set;}
8. public int Patronid {get; set;}
10. Public DateTime boughttime {get; set;}
14. // ...
18. public override bool Equals (object obj)
20. {
22. if (obj = = null)
24. {
26. return false;
28. }
32. Order Ordertocompare = obj as order;
34. if (Ordertocompare = = null)
36. {
38. return false;
40. }
44. return ID = = Ordertocompare.id &&
46. Patronid = = Ordertocompare.patronid &&
48. Boughttime = = Ordertocompare.boughttime;
50. }
54. public override int GetHashCode ()
56. {
58. return ("ID" + ID.) ToString () +
60. "Patronid" + patronid.tostring () +
62. "TimeStamp" + boughttime.tostring ())
64. . GetHashCode ();
66. }
68. }

Later, he found that for some orders that already existed, if there were any user changes to the purchased books, the orders needed to be updated, and the timestamp of the order would need to be updated after the update:

Update Order Property

1. public void Updateordertime (order order)
2. {
3. Order. Boughttime = DateTime.Now;
4. }

This simple system has just sent to the quality department after the test for two days, the boss put small a called to the eyes of the has penny, "Memory leak!"

What is the problem?

The problem is with the order object as the dictionary key.

The dictionary. NET implementation has an implicit feature that is easier to overlook, which is how it locates the stored data. Dictionary is calculated by hashing the hash value of the key to determine where its corresponding value is stored. The Add/delete/modify operations within dictionary are completely dependent on this positioning method. This positioning method is embodied in the dictionary source code as a findentry () operation:

2. private int findentry (TKey key) {
4. if (key = = null) {
6. Throwhelper.throwargumentnullexception (Exceptionargument.key);
8. }
12. if (buckets! = null) {
14. int hashcode = comparer. GetHashCode (key) & 0x7FFFFFFF;
16. for (int i = buckets[hashcode% buckets. Length]; I >= 0; i = entries[i].next) {
18. if (Entries[i].hashcode = = Hashcode && comparer. Equals (Entries[i].key, key)) return I;
20. }
22. }
24. return-1;
26. }

When the Boughttime property of an order changes, the hash value of the corresponding order is changed, and the list of books accompanying the order is still in dictionary, but the Findentry () operation is not able to locate it. This list of bibliographies will remain in the dictionary until the end of the dictionary life cycle. This is an implicit memory leak. If this is a WinForm program, perhaps the impact is not very large. However, if a network service that requires high online rates is used, the memory usage of overflow exceptions will certainly be unavoidable.

Memory leaks In this simple scenario can be more subtle and more difficult to spot in more complex scenarios. Although the basic rationale is the same, in more complex business logic, we may be more likely to ignore its harm.

Conclusion

If a business object may be modified in the business logic, do not use it as a dictionary key!!! When using objects as keys to dictionary, it is prudent to consider whether the object will be implicitly or explicitly changed in the rest of the way.

Proper use of dictionary.

An implicit memory leak brought by dictionary