I don’t believe the first code sample is a valid C# code. Switch-case statements expect constants for case conditions and runtime types are not constants, obviously. What you can do is something like this:

void MyMethod(object arg)
{
    if (arg.GetType() == typeof(int))
        MyTypedMethod((int)arg);
    else if (arg.GetType() == typeof(int?))
        MyTypedMethod((int?)arg);
    else if (arg.GetType() == typeof(long))
        MyTypedMethod((long)arg);
}

This will work, but the problem here is that inheritance will fuck you up. All the types we check in this example are sealed and we don’t really have to worry about it in this case, but generally this code is… just bad.

And yes, the correct way of implementing something like this is by using generic types. Starting from C# 7.0 we have this cool structure:

void MyMethod<T>(T arg)
{
    switch (arg)
    {
        case null:
            // Do something with null
            break;
        case int intArg:
            // Do something with intArg
            break;
        case long longArg:
            // Do something with longArg
            break;
    }
}

You’ll have to check for null separately, as you can’t use Nullable<> there, but overall, it looks much cleaner and handles inheritance properly for you.

This is called pattern matching, you can read more about it here: https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/operators/patterns

If you don’t want to go the pattern matching route you can also use reflection with MakeGenericMethod to specify the generic type and then invoke it.

Untested example:

var type = field.GetType();
var methodInfo = typeof(GenericClass).GetMethod("GenericMethod").MakeGenericMethod(type);
methodInfo.Invoke(null, field);

Edit: wrong documentation link https://learn.microsoft.com/en-us/dotnet/api/system.reflection.methodinfo.makegenericmethod?view=net-8.0 ~~https://learn.microsoft.com/en-us/dotnet/api/system.reflection.emit.methodbuilder.makegenericmethod?view=net-8.0~~

You can actually use the dynamic type here for late binding of overloads. You will get a runtime error for unknown types though.

You essentially define the function overloaded for each type. Then call the function with a dynamic and the runtime will figure out what method to call

Here’s a real world side project example of how I handle this situation:

 public IResult<T> GetResourceValue<T>(string path)
    {
        string err = $"{typeof(T).FullName} is not available from this Resource ({nameof(FileSystemResource)})";

        switch (typeof(T))
        {
            case Type t when t == typeof(DriveInfo):
                return (IResult<T>)new Ok<DriveInfo>(BackingValue);
            case Type t when t == typeof(DirectoryInfo):
                err = $"Directory path invalid: {path}";
                var dir = new DirectoryInfo(path);

                if (dir.Exists)
                    return (IResult<T>)new Ok<DirectoryInfo>(dir);
                break;
            case Type t when t == typeof(FileInfo):
                err = $"File path invalid: {path}";
                var file = new FileInfo(path);

                if (file.Exists)
                    return (IResult<T>)new Ok<FileInfo>(file);
                break;
        }
        return new Error<T>(err);
    }

You said elsewhere that it feels like you’re doing something wrong if you have to check for every type just to use a Generic. I think you’re right in thinking along those lines. There should be a minimal number of types to check, and Ideally limited via a type constraint.

Here’s example that includes a constraint:

    public IResult<T> GetValue<T>() where T : struct =>
        typeof(T) switch
        {
            Type t when t == typeof(int) && value <= int.MaxValue =>
             (IResult<T>)new Ok<int>((int)value),
            Type t when t == typeof(uint) && value <= uint.MaxValue && value >= uint.MinValue =>
             (IResult<T>)new Ok<uint>((uint)value),
            Type t when t == typeof(byte) && value <= byte.MaxValue && value >= byte.MinValue =>
             (IResult<T>)new Ok<byte>((byte)value),
            Type t when t == typeof(sbyte) && value <= (int)sbyte.MaxValue =>
             (IResult<T>)new Ok<sbyte>((sbyte)value),
            Type t when t == typeof(short) && value <= (int)short.MaxValue =>
             (IResult<T>)new Ok<short>((short)value),
            Type t when t == typeof(ushort) && value <= ushort.MaxValue =>
             (IResult<T>)new Ok<ushort>((ushort)value),
            Type t when t == typeof(long) && value <= long.MaxValue =>
             (IResult<T>)new Ok<long>((long)value),
            Type t when t == typeof(ulong) => (IResult<T>)new Ok<int>((int)value),
            _ => new IntegerError<T>()
        };