How can I assign a value to a generic parameter in C#?

I want to write code that reads and writes data to a stream for packet serialization.

Classify data types and write and read data through Bitconverter.

I wrote this simply as below.

public int WritePrimitiveType(ArraySegment<byte> stream, int offset, object data)
{
    string data_type = data.GetType().Name;
    switch (data_type)
    {
        case "Boolean":
            Array.Copy(BitConverter.GetBytes((Boolean)data), 0, stream.Array, stream.Offset + offset, sizeof(Boolean));
            return sizeof(Boolean);
        case "Byte":
            Array.Copy(BitConverter.GetBytes((Byte)data), 0, stream.Array, stream.Offset + offset, sizeof(Byte));
            return sizeof(Byte);       
        case "Int32":
            Array.Copy(BitConverter.GetBytes((Int32)data), 0, stream.Array, stream.Offset + offset, sizeof(Int32));
            return sizeof(Int32);        
        default:
            return 0;
    }
}


public int ReadPrimitiveType<T>(ArraySegment<byte> stream, int offset, ref T data)
{
    switch (typeof(T).Name)
    {
        case "Boolean":
            data = (T)((object)BitConverter.ToBoolean(stream.Array, stream.Offset + offset));
            return sizeof(Boolean);
        case "Byte":
            data = (T)((object)BitConverter.ToInt16(stream.Array, stream.Offset + offset));
            return sizeof(Byte);       
        case "Int32":
            data = (T)((object)BitConverter.ToInt32(stream.Array, stream.Offset + offset));
            return sizeof(Int32);
        default:
            data = default(T);
            return 0;
    }
}

It appears to have been written in an immature way.

How to properly write such code in C#? I would like to improve the above code.

The simple way is to forget about using generics at all. Just write the 6 functions with the same names and let the C# compiler work out which one to call based on the provided data argument;

public int WritePrimitiveType(ArraySegment<byte> stream, int offset, bool data){ ... }
public int WritePrimitiveType(ArraySegment<byte> stream, int offset, byte data){ ... }
public int WritePrimitiveType(ArraySegment<byte> stream, int offset, int data){ ... }
public int ReadPrimitiveType(ArraySegment<byte> stream, int offset, ref bool data){ ... }
public int ReadPrimitiveType(ArraySegment<byte> stream, int offset, ref byte data){ ... }
public int ReadPrimitiveType(ArraySegment<byte> stream, int offset, ref int data){ ... }

If you really want to use generics, you could use generic delegates to call the type specific BitConverter methods.

public static class Converter<T>{
    private static Func<byte[], int, T> reader;
    private static Action<byte[], int, T> writer;
    static Converter(){
        if (typeof(T) == typeof(bool)){
            reader =  (Func<byte[], int, T>)(object) new Func<byte[], int, bool>(BitConverter.ToBoolean);
            writer = ...
        }
        ... etc
    }
    public static int ReadPrimitiveType(ArraySegment<byte> stream, int offset, ref T data){
        data = reader(stream.Array, stream.Offset + offset);
        return sizeof(T);
    }

}

At least this will avoid boxing and unboxing on every read.

You can generalize your code and replace the switch statement with the Dictionary or other data structure. This will simplify the situation a lot, but may make the code slower and in some cases less readable.

Here we have introduced the the special ProcessingData class to store conversion functions for each type. Then we filled the Dictionary with instances of such a type - one instance for each target type we want to read or write.

And now we can just do a dictionary lookup and use the given instance of ProcessingData to process the given data.

private static readonly Dictionary<Type, ProcessingData> Processors = new()
{
[typeof(bool)] = new
(
readFunc: (s, o) => BitConverter.ToBoolean(s, o),
writeFunc: d => BitConverter.GetBytes((bool)d),
size: sizeof(bool)
),
[typeof(byte)] = new
(
readFunc: (s, o) => BitConverter.ToBoolean(s, o),
writeFunc: d => new[] { (byte)d },
size: sizeof(byte)
),
[typeof(int)] = new
(
readFunc: (s, o) => BitConverter.ToInt32(s, o),
writeFunc: d => BitConverter.GetBytes((int)d),
size: sizeof(int)
),
};
public int WritePrimitiveType(ArraySegment<byte> stream, int offset, object data)
{
if (Processors.TryGetValue(data.GetType(), out var processor))
{
return processor.Write(stream, offset, data);
}
else
{
return 0;
}
}
public int ReadPrimitiveType<T>(ArraySegment<byte> stream, int offset, ref T? data)
{
if (Processors.TryGetValue(typeof(T), out var processor))
{
return processor.Read(stream, offset, out data);
}
else
{
data = default;
return 0;
}
}
internal class ProcessingData
{
private readonly Func<byte[], int, object> _readFunc;
private readonly Func<object, byte[]> _writeFunc;
private readonly int _size;
public ProcessingData(Func<byte[], int, object> readFunc,
Func<object, byte[]> writeFunc, int size)
{
_readFunc = readFunc;
_writeFunc = writeFunc;
_size = size;
}
public int Read<T>(ArraySegment<byte> stream, int offset, out T data)
{
data = (T)_readFunc(stream.Array, stream.Offset + offset);
return _size;
}
public int Write(ArraySegment<byte> stream, int offset, object data)
{
Array.Copy(_writeFunc(data), 0, stream.Array, stream.Offset + offset, _size);
return _size;
}
}

You can try to play with generics to go from the object-based code in the ProcessingData to generic one. And this should significantly improve the readability of the dictionary initialization code because you will be able to write just BitConverter.ToBoolean (method group) instead of (s, o) => BitConverter.ToBoolean(s, o) labmda. But I'm not sure if such a generics-based approach is possible.