Determining if a type is IParsable, and invoking Parse

[Ethereal77]

I'm experimenting with some of the new types in .NET 7 and syntax in C# 11. Specifically I was trying to determine in a generic method whether a provided type T is parsable so it can be read using the Parse method. Imagine something like this:

bool Test<T>()
{
  var dummy = new T();  // Don't know if can be tested without this dummy

  // Obviously, this is invalid syntax
  return T is IParsable<T>;

  // This results in an error, as T have not enough information about being IParsable<T>,
  // and also IParsable is defined recursively: interface IParsable<T> where T : IParsable<T>
  return dummy is IParsable<T>;

  // Some way of doing this without reflection? Or at least, as performant as possible?
  return typeof(T).GetInterface("IParsable`1") is not null);
}

The goal I had was test the type (unconstrained) and, if parsable, call a specific method that calls Parse, and if not do something else.
The problem lies in the the recursive definition.

Another doubt I have is, whenever I somehow have determined that T is parsable, how do I call Parse? T is unconstrained, so the compiler doesn't know that it can call Parse. Even if I could do an if (dummy is IParsable<T>), you can't invoke Parse from just the interface. You need the concrete type for invoking the abstract static method.

I've already discussed this with several people in the C# Discord server, and the consensus is that it can't be done without reflection. I wanted to confirm here with people more knowledgeable in the runtime and the new types.
At least if it can't be done, can you tell me what would be the most efficient way from a performance perspective?

Thanks.

[tannergooding]

This is a limitation of the language with a small proposal on how it could be handled here: dotnet/csharplang#6308

Such a language feature may also require runtime work.

[Ethereal77]

So basically this answers both questions then. There's right now no way to test a type for a more constrained type and take advantage of that information. Is this a thing for .NET 8?

Also, even if the language doesn't support this checks right now, is there some way to do the check in a more-or-less performant way even if it is by "playing" with the types (like in the BCL where you read things like (T) (object) value in some places)?

[tannergooding]

Not that I'm aware of (outside reflection).

I'd recommend commenting on the issue about the need to try and get it looked at/championed by the C# language design team.