Make Getting sizeof(T) where T : struct Possible

[jcouv]

@whoisj commented on Sun May 31 2015

I took often find myself writing long lists of methods (like below) where I'm reading the bits of stack values for things like hashing, serialization, encryption, etc. because I'm unable to acquire sizeof(T) even when T : struct which I I find fairly frustrating.

        public unsafe void Write(DateTime value)
        {
            lock (_buffer)
            {
                fixed (byte* b = _buffer)
                {
                    *((DateTime*)b) = value;
                }
                Write(_buffer, 0, sizeof(DateTime));
            }
        }

Ideally the sizeof(...) operator would work on generics so long as the type being measured is guaranteed to be a value type (ala struct).

This should be perfectly legal code:

        public unsafe void Write<T>(T value)
            where T : blittable struct
        {
            lock (_buffer)
            {
                fixed (byte* b = _buffer)
                {
                    *((T*)b) = value;
                }
                Write(_buffer, 0, sizeof(T));
            }
        }

Then I would only need a single method and not a dozen.

Support for T* is #3210

---

@whoisj commented on Tue Jun 02 2015

Updated based on the conversation happening in #3210

---

@damageboy commented on Thu Apr 14 2016

@whoisj while I would obviously agree with you that this is very handy and should be supported directly in c#, isn't something along the lines of http://stackoverflow.com/questions/18167216/size-of-generic-structure a temporary workaround for you? (With very little performance overhead...)

---

@whoisj commented on Thu Apr 14 2016

The solution presented on SO seems reasonable, but I'm not certain about the runtime costs associated with passing value through the marshaler to get its size. Still, it seems to me to be a work-around for a missing feature, especially when the underlying IL supports the operation and it is C# which imposes the limitation.

    public static int SizeOf<T>() where T : struct
    {
        return Marshal.SizeOf(default(T));
    }

---

@axel-habermaier commented on Thu Aug 25 2016

There is also DotNetCross.Memory.Unsafe that exposes some IL instructions as regular .NET methods that are unavailable in C#. The library is implemented using IL instead of C#. For instance:

var size = Unsafe.SizeOf<T>();

In my opinion, however, most of the stuff exposed by the library should be available directly in C#.

---

@ghord commented on Thu Aug 25 2016

blittable constraint is such a nice way to solve most of the issues with generic pointers, yet everyone keeps insisting on using hacks like Unsafe.Size<T>(). Just look how clean following code is:

    public unsafe class NativeArray<T> where T : blittable
    {
        IntPtr ptr_;
        public NativeArray(int size)
        {
            ptr_ = Marshal.AllocHGlobal(size * sizeof(T));
        }

        public T* this[int i]
        {
            get { return ((T*)ptr_) + i; }
        }

        public int ElementSize => sizeof(T);

        //finalizers etc..
    }

---

@jcouv commented on Sat Oct 21 2017

Moving language design discussion to csharplang. Thanks

[IS4Code]

The problem with adding more generic constraints is that it would either need extending CIL to support them, or some workaround like custom attributes, both of which would in this case also need to be able to be handled by other languages and compilers, to ensure type and memory safety.

But it doesn't mean it is impossible, F# already has that, albeit stored in the assembly resources understood only by F#.

[yaakov-h]

Why is this needed as a language feature beyond using static System.Runtime.InteropServices.Marshal;?

If it’s as a constant, what happens when the struct is in a different assembly?

[IS4Code]

For non-primitive types, sizeof is not a constant, as it depends on the layout the runtime chooses for the type (alignment etc.), even if it is in the same assembly.

[dangi12012]

WE NEED BLITTABLE GENERIC CONSTRAINT.
I made so many high performance application where the whole system would be so much faster if C# would support this.

[jcouv]

@dangi12012 When in Rome, do as the Romans do.

Have you seen other participants in csharplang use all-caps and bold for effect?
If you want people to engage with your request, I suggest that you follow the discussion style that permeates the forum instead. Along those lines, I would suggest that you add details to your proposal (example code, expected behavior, motivating scenarios, micro-benchmark code, ...) to make it clear what you mean and why it's useful/important.
Thanks in advance.

[tannergooding]

@dangi12012, the unmanaged constraint now exists. See #187

[masonwheeler]

@IllidanS4 sizeof is a constant in every way that matters. It's set at the very beginning of the program's runtime and can't be changed by anything that happens inside the program. The internal JIT code that deals with sizeof even treats it as a numerical constant. It's just not a constant whose value is necessarily known at (C#-level) compile time.

[nguerrera]

See also #1508 (comment)