{"id":1225,"date":"2018-06-12T13:04:32","date_gmt":"2018-06-12T05:04:32","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/seteplia\/?p=1225"},"modified":"2019-06-11T21:22:33","modified_gmt":"2019-06-12T04:22:33","slug":"dissecting-new-generics-constraints-in-c-7-3","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/premier-developer\/dissecting-new-generics-constraints-in-c-7-3\/","title":{"rendered":"Dissecting new generic constraints in C# 7.3"},"content":{"rendered":"

During the last Build conference, Microsoft has announced the next version of Visual Studio with C# 7.3 support. This is yet another minor language update with some quite interesting features. The main change was related to generics, starting from C# 7.3 there 3 more constraints: unmanaged<\/code>, System.Enum<\/code> and System.Delegate<\/code>.<\/p>\n

The unmanaged<\/code> constraint<\/h4>\n

The unmanaged<\/code> constraint on generic type T<\/code> enforces the type to be an ‘unmanaged’ struct that does not recursively contain reference type fields. The concept of ‘unmanaged types’ existed in the C# language for a long time and you can find this term in the C# language specification and in the official documentation, but now the compiler can actually enforce it.<\/p>\n

This feature could be useful for low-level scenarios, like native-managed interoperability, but could be helpful for common enterprise scenarios as well. An instance of ‘unmanaged’ type T<\/code> is convertible to T*<\/code> which is convertible to byte*<\/code> that opens some interesting possibilities. Let suppose you want to keep your data in a key-value store. To get a key you may consider using SHA1<\/code> or some other hashing algorithm, but you don’t want to implement the hashing logic for every type in the system.<\/p>\n

Now you can implement this logic for all ‘unmanaged’ types in your application the following way:<\/p>\n

public unsafe static byte[] ComputeHash<T>(T data) where T : unmanaged\r\n{\r\n    byte* bytes = (byte*)(&data);\r\n    using (var sha1 = SHA1.Create())\r\n    {\r\n        var size = sizeof(T);\r\n        using (var ms = new UnmanagedMemoryStream(bytes, size))\r\n        {\r\n            return sha1.ComputeHash(ms);\r\n        }\r\n    }\r\n}<\/pre>\n
This code works perfectly fine because sizeof<\/code> operator is actually designed for ‘unmanaged’ types<\/a> even though there was no special constraint in the language to enforce the correctness of this operator at compile time.<\/p>\n
The feature is relatively simple but there are some caveats:<\/p>\n