C#

class A
{
  public virtual void Message()
  {
     Console.WriteLine("Original Message");
  }
}

class B : A
{
  public new void Message()
  {
     Console.WriteLine("Class B's Message");
  }
}

class C : A
{
  public override void Message()
  {
     Console.WriteLine("Class C's Message");
  }
}

A myA = new A();
B myB = new B();
C myC = new C();

myA.Message(); //Outputs "Original Message"
myB.Message(); //Outputs "Class B's Message"
myC.Message(); //Outputs "Class C's Messgae"

//Notice that these are of type A
A myAB = new B(); 
A myAC = new C();

myAB.Message(); //Outputs "Original Message"
myAC.Message(); //Outputs "Class C's Message"

George_George wrote:

If I call remove method to remove some elements from the Dictionary, will the memory footprint be reduced? (suppose there is no other reference to the removed item) I have some suspecision that Dictionary is not truly removing the element and just mark a flag or something, which still refer this removed item to block it from GCed.

George_George wrote:

The other is to create a new Dictionary instance, and insert only necessary items into the new Dictionary instance, and reference only the new Dictionary instance in the future.

George_George wrote:

Which way is better from memory footprint reduce perspective?

George_George wrote:

I do not quite understand "the key value pair is cleared, but kept", kept for what? I think the word clear is conflicting to "kept".

George_George wrote:

Could you provide more descriptions about why based on the above theory, reference types are cleared from memory, but value types are not?

George_George wrote:

I think when insert value types into Dictionary, it will be value copied, right?

George_George wrote:

My confusion is, if the item is removed, GCed, then its memory is reclaimed and saved. But a new instance of default value of the reference type is created? So, no space saved?

George_George wrote:

Sounds like the way to reduce memory footprint to maximum is to create a new one and insert only necessary ones. Right?

Guffa wrote:

The data that the dictionary needs to keep track of each item is typically 16 bytes.

Guffa wrote:

There has to be quite a lot of unused entries before there are so much memory to reclaim that it's worth it.

Guffa wrote:

If the dictionary doesn't have that many entries to get rid of, all you accomplish is more work for the garbage collector.

George_George wrote:

4 bytes for key reference variable and 4 bytes for value reference variable on a 32-bit machine? And the total should be (8 + 8) 16 bytes for a 64-bit machine?

[StructLayout(LayoutKind.Sequential)]
private struct Entry {
    public int hashCode;
    public int next;
    public TKey key;
    public TValue value;
}

George_George wrote:

Why "there are so much memory to reclaim that it's worth it"?

George_George wrote:

Why "all you accomplish is more work for the garbage collector"?

George_George wrote:

next field is used to keep a linked list for all the items which has the same hash code?

George_George wrote:

So, each reference type variable will use 8 bytes on 32-bit machine, and 16 bytes on a 64-bit machine?

George_George wrote:

In C#, is it working the same way -- only grow when it is full?

George_George wrote:

I am confused about why do you think a Dictionary is always keeping at least 50% unused items

George_George wrote:

For example, if in the old Dictionary, the capability is 10 but used item is only 3. If I create a new Dictionary, and insert the 3 elements into the new Dictionary, I am not sure whether the capability of the new Dictionary is still 10.

Guffa wrote:

I never said that. Where did you get that from?

George_George wrote:

This is what you said before -- "This means that the dictionary would have to contain at least 50% unused items before you are sure to gain anything at all by moving the items to a new dictionary.".

George_George wrote:

From your above sample, there is possibility that the new Dictionary could be smaller than the old one, right?

Guffa wrote:

If the dictionary have too few unused entries, you can not gain anything by moving the items to a new dictionary. It has to have something like 50% unused items, otherwise it's likely that the new dictionary will just get the same capacity as the current dictionary.