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~~
Yes, I agree that this is a bit of an anti-pattern, as you lose quite a few benefits from the Generics compile-time safety and instead open yourself to runtime exceptions. Not sure what your use case is, but if you want to maintain type safety it might be better to have multiple overloads for each type you want to process rather than a Generic. Typically you use Generics when the actual type doesn't matter to the method being called (e.g. LINQ uses Generics for
IEnumerable<T>.Where
because T can be anything and it just calls aFunc<T, bool>
on each element).