Stuck with generic constraint.

Question

Stuck with generic constraint.

Adel 21

Hi every one!
Say I have those 2 methods:

static unsafe int SizeOf<T> where T : unmanaged => sizeof(T);
static int GetSize<T> => is T unmanaged ? SizeOf<T> : IntPtr.Size;

What construct to put in place of 'is T unmanaged'? How to force the compiler to call a method with constraint?
Can someone help me?
Thanks.

0 comments

Answer accepted by question author

0 additional answers

Your answer

Answer 1

@Adel , Welcome to Microsoft Q&A, based on your code, you want to return the size of unmanaged type if T is unmanaged type and return the default size if T is managed type.

First, I want to mention that we could not use lambda expression in the generic constraint.

We could create the method with constraint like the following:

 static unsafe int SizeOf<T>() where T : unmanaged  
        {  
            return sizeof(T);  
        }

Second, I have found the method to replace the 'is T unmanaged', but it is still hard to achieve you wanted.

The following code can be used to check if T is unmanaged.

public static class UnmanagedTypeExtensions  
{  
    private static Dictionary<Type, bool> cachedTypes =  
    new Dictionary<Type, bool>();  
    public static bool IsUnManaged(this Type t)  
    {  
        var result = false;  
        if (cachedTypes.ContainsKey(t))  
            return cachedTypes[t];  
        else if (t.IsPrimitive || t.IsPointer || t.IsEnum)  
            result = true;  
        else if (t.IsGenericType || !t.IsValueType)  
            result = false;  
        else  
            result = t.GetFields(BindingFlags.Public |   
               BindingFlags.NonPublic | BindingFlags.Instance)  
                .All(x => x.FieldType.IsUnManaged());  
        cachedTypes.Add(t, result);  
        return result;  
    }  
}

However, When I use it in the method, it will give the complie error because we could not convert common T to unmanaged T.

Finally, I think we need to separate the two cases.

Like the above method:

static unsafe int GetSizeforunmanaged<T>() where T : unmanaged
{
return sizeof(T);
}

    static unsafe int GetSizeformanaged<T>()   
    {  
        return IntPtr.Size;  
        

    }  
    //=> is T unmanaged ? SizeOf<T> : IntPtr.Size;  
    static void Main(string[] args)  
    {  
        int result=0;  
        result = GetSizeforunmanaged<int>();  
        Console.WriteLine(result);  
        result = GetSizeformanaged<string>();  
        Console.WriteLine(result);  

    }

We could use complie error to check if type is unmanaged.
Like the following:

If we used managed type in the GetSizeforunmanaged method, visual studio will give me a complie error.

Best Regards,
Jack

Hope my exmplanation could help you.

If the answer is the right solution, please click "Accept Answer" and upvote it.If you have extra questions about this answer, please click "Comment".

Note: Please follow the steps in our documentation to enable e-mail notifications if you want to receive the related email notification for this thread.

Adel 21 Reputation points

2022-05-25T10:22:33.827+00:00

Thanks. Your explanation is very helpful, but what i want is to stop the spread of the constraint to the caller.
let's take a more pedagogical example:
Suppose that you are building a library, and in that library you have a class for processing data. Let's call this class Processor. In that class there is a generic method called Process<T>(T) used to make some computing on its parameter. Suppose that you know a special algorithm that is much faster then the default one when T is a struct type. so you decide to hide all this stuff to your client and provide a unique public method Process<T>(T) in which, according to T, you apply the best algorithm:

public static class Processor { //private: static void FastProcessing<T>(T data) where T: struct { //...} static void DefaultProcessing<T>(T data) {//...} //public: public static void Process<T>(T data) //no constraints here! { /* if T is struct then call FastProcessing(data) else call DefaultProcessing(data); */ }

How to implement the Process method? How to dispatch the call to the correct algorithm?
You see what I mean? I want to stop the "bubbling up" of the constraint.
Thank for your help.
Jack J Jun 25,306 Reputation points

2022-05-26T07:39:20.727+00:00

@Adel ，thanks for the feedback, as I metioned before, the key to solve the problem is that we could not convert T type to stuct type.
I have done the following code, but based on my test. currently there is no way to convert common T to struct T.

public static class Processor { //private: static void FastProcessing<T>(T data) where T : struct { } static void DefaultProcessing<T>(T data) { } public static void Process<T>(T data) //no constraints here! { Type type = typeof(T); bool isStruct = type.IsValueType && !type.IsPrimitive; if(isStruct) { } else { DefaultProcessing<T>(data); } } }

Share via

Stuck with generic constraint.

0 additional answers

Your answer