Is is possible to keep track of the current number of instances of a class?

user_11808605 0
Viewed 576

In .NET, I understand that there is a garbage collector that will manage the memory that's being used during the execution of a program. This means that objects will be cleaned up when they go unused.

I was wondering if I could keep a static counter in a certain class that automatically updates when instances of that class are created or garbage collected. For example, if I create some instances of some CountableInstance class, then they could each have an InstanceIndex that keeps track of their current position based on when they were created.

Such a flow could look like this:

  1. Program starts
  2. CountableInstance ctble0 is created with InstanceIndex == 0
  3. CountableInstance ctble1 is created with InstanceIndex == 1
  4. CountableInstance ctble2 is created with InstanceIndex == 2
  5. CountableInstance ctble1 goes unused and gets garbage collected
  • ctble0's index stays the same
  • ctble2's index becomes 1
  1. Program ends

I'm guessing that keeping track of the number of CountableInstance instances would look like this:

public class CountableInstance
{
    public static int total = 0;
    public CountableInstance()
    {
        InstanceIndex = total;
        total++; // Next instance will have an increased InstanceIndex
    }
    public CountableInstance(...) : this()
    {
        // Constructor logic goes here
    }

    public int InstanceIndex { get; private set; }
}

This takes care of how many instances there are and it also assigns the correct index to each new object. However, this implementation misses the logic that should happen when an instance is garbage collected.

If possible, how could I implement it? Would it also work to keep track of instances of objects that use a particular interface?

.net-core static class c#
3 Answers

You can achieve the gist of this as below, but this seems like a bad idea IMO; in particular:

  1. finalizers aren't free (and neither is IDisposable.Dispose())
  2. you can create objects without ever running a constructor (if you try hard enough)

Anyway, code:

public class CountableInstance
{
    static int s_Total, s_Alive;
    public CountableInstance() {
        // need a separate total vs alive so we don't give duplicate
        // InstanceIndex, at least for the first 4 billion objects
        InstanceIndex = Interlocked.Increment(ref s_Total);
        Interlocked.Increment(ref s_Alive);
    }
    ~CountableInstance() {
        Interlocked.Decrement(ref s_Alive);
    }
    public int InstanceIndex { get; }
    public static int Alive => Volatile.Read(ref s_Alive);
    public static int Total => Volatile.Read(ref s_Total);
}
Marc_Gravell_233540

you could do something like this:

public class CountableInstance : IDisposable
{
    public static int total = 0;
    ...




    public void Dispose()
    {
         //total--;
         //Edit:
         Interlocked.Decrement(total);
    }

}

this would keep track of what happens within your application. but as far as i know garbage collection could still be delayed to a later point long after Dispose.

user_90075600

If you want your indexes of your created instances to change if one instance is removed, you'll need to store them in a list. See this solution:

public class CountableInstance : IDisposable
{
    private static List<CountableInstance> instances = new List<CountableInstance>();
    
    public CountableInstance()
    {
        InstanceIndex = instances.Count;
        instances.Add(this);
    }
    
    public void Dispose()
    {
        instances.Remove(this);
        for(int i = InstanceIndex; i < instances.Count; i++)
        {
            instances[i].InstanceIndex = i;
        }
    }
    
    public int InstanceIndex { get; private set; }
}

Note that since the instances are stored in the list, they will never get garbage collected before you call Dispose(). You'll have to call Dispose() manually if you don't need your object anymore, which let's you lose a big advantage of garbage collection. Also note that this solution is not thread safe.

Online demo: https://dotnetfiddle.net/A1LptG

user_82485700
Related