Generic Method With BitConverter.GetBytes() Throws Error: CS1503 Argument 1: cannot convert from 'T' to 'bool'

Hello And Good Day!

There was a post in VBForums Generic Method with BitConverter.GetBytes problem on how to pass a T variable without causing the issue CS1503 Argument 1: cannot convert from 'T' to 'bool'

 private static byte[] GetBytes<T> (T valu) 
        {
            var bytes = BitConverter.GetBytes(valu);
            if (BitConverter.IsLittleEndian)
                Array.Reverse(bytes);
            return bytes;
        }

Since Generic Constraints for a numeric types isn't available at this time, I attempted to solve this issue by checking the type of T and then perform the conversion explicity.

private static byte[] GetBytes<T>(T value) 
      {
         byte[] bytes;
         ushort val1;
         uint val2;
         Type t = typeof(T);

         if (t == typeof(ushort))
         {
            val1 = Convert.ToUInt16(value);
            bytes = BitConverter.GetBytes(val1);            
         }
         else if (t == typeof(uint))
         {
            val2 = Convert.ToUInt32(value);
            bytes = BitConverter.GetBytes(val2);
         }
         else
         {
            bytes = null;
         }

         if (BitConverter.IsLittleEndian && bytes != null)
            Array.Reverse(bytes);

         return bytes;
      }

However, this solution will defeat the purpose of generics and is limited to two types being converted. Another workaround was to assign the value parameter into a dynamic object and then passed that object to the GetBytes() function. This will fulfill the purpose of generics but will generate a runtime error if a string variable is passed to the GetBytes() function. The fix for this runtime error is to wrap the GetBytes() function in a try/catch function and handle the exception from there.

private static byte[] GetBytes<T>(T value)
      {
         byte[] bytes;
         dynamic obj = value;

         try
         {
            bytes = BitConverter.GetBytes(obj);
            if (BitConverter.IsLittleEndian)
               Array.Reverse(bytes);
         }
         catch (Exception ex) 
         {
            //handle runtime errors (logging), for now assign null
            bytes = null;
         }

         return bytes;
      }

The curiosity with a Generic Constraint solution led me to research more and arrived at a StackOverflow post Is there a constraint that restricts my generic method to numeric types? with a different approach called Policies. There are two components in this perspective, first is an interface with two generic arguments and has a single method called Convert().

 public interface IConvert<TResut, T>
   {
      TResut Convert(T value);
   }

The other piece is a class that implements the interface with two method implementations for specific primitive types uint and ushort. This class also utilizes the singleton design pattern.

public struct ConvertPolicies : IConvert<byte[], ushort>, IConvert<byte[], uint>
   {
      public static ConvertPolicies Instance = new ConvertPolicies();

      public byte[] Convert(ushort value)
      {
         var bytes = BitConverter.GetBytes(value);
         if (BitConverter.IsLittleEndian)
            Array.Reverse(bytes);

         return bytes;
      }

      public byte[] Convert(uint value)
      {
         var bytes = BitConverter.GetBytes(value);
         if (BitConverter.IsLittleEndian)
            Array.Reverse(bytes);

         return bytes;
      }
   }

Output