Question

Given a Queue<MyMessage>, where MyMessage is the base class for some types of messages: all message types have different fields, so they will use a different amount of bytes. Therefore it would make sense to measure the fill level of this queue in terms of bytes rather than of elements present in the queue.
In fact, since this queue is associated with a connection, I could better control the message flow, reducing the traffic if the queue is nearly full.

In order to get this target, I thought to wrap a simple Queue with a custom class MyQueue.

public class MyQueue
{
    private Queue<MyMessage> _outputQueue;
    private Int32 _byteCapacity;
    private Int32 _currentSize;   // number of used bytes

    public MyQueue(int byteCapacity)
    {
        this._outputQueue = new Queue<MyMessage>();
        this._byteCapacity = byteCapacity;
        this._currentSize = 0;
    }

    public void Enqueue(MyMessage msg)
    {
        this._outputQueue.Enqueue(msg);
        this._currentSize += Marshal.SizeOf(msg.GetType());
    }

    public MyMessage Dequeue()
    {
        MyMessage result = this._outputQueue.Dequeue();
        this._currentSize -= Marshal.SizeOf(result.GetType());
        return result;
    }
}

The problem is that this is not good for classes, because Marshal.SizeOf throws an ArgumentException exception.

1. Is it possible to calculate in some way the size of an object (instance of a class)?
2. Are there some alternatives to monitor the fill level of a queue in terms of bytes?
3. Are there any queues that can be managed in this way?

UPDATE: As an alternative solution I could add a method int SizeBytes() on each message type, but this solution seems a little ugly, although it would perhaps be the most efficient since You cannot easily measure a reference type.

public interface MyMessage
{
    Guid Identifier
    {
        get;
        set;
    }

    int SizeBytes();
}

The classes that implement this interface must, in addition to implementing the SizeBytes() method, also implement an Identifier property.

public class ExampleMessage
{
    public Guid Identifier { get; set; }   // so I have a field and its Identifier property
    public String Request { get; set; }

    public int SizeBytes()
    {
        return (Marshal.SizeOf(Identifier));   // return 16
    }
}

The sizeof operator can not be used with Guid because it does not have a predefined size, so I use Marshal.SizeOf(). But at this point perhaps I should use the experimentally determined values​​: for example, since Marshal.SizeOf() returns 16 for a Guid and since a string consists of N char, then the SizeBytes() method could be as following:

public int SizeBytes()
{
   return (16 + Request.Length * sizeof(char));
}

Answer 1

If you could edit the MyMessage base class with a virtual method SizeOf(), then you could have the message classes use the c# sizeof operator on its primitive types. If you can do that, the rest of your code is gold.