Is There a C# Alternative to Python’s issubclass for Invoking Static Abstract Methods?

I have an interface that defines a static abstract method and is implemented by dynamically loaded plugins. My goal is to call the static method without using reflection. In Python, I can do this elegantly with an issubclass check and direct invocation, like so:

PYTHONCopied
if issubclass(data_source_type, IUpgradableDataSource):
    upgraded_configuration = await data_source_type.upgrade_source_configuration(configuration)
    ...
else:
    ...

In C#, my interface looks like this:

CSHARPCopied
public interface IUpgradableDataSource
{
    static abstract Task<JsonElement> UpgradeSourceConfigurationAsync(
        JsonElement configuration,
        CancellationToken cancellationToken
    );
}

The plugin's type is obtained dynamically, so I currently resort to reflection to invoke its static method. For example:

CSHARPCopied
var dataSourceType = <the System.Type of the plugin>
var dataSourceInterfaceTypes = dataSourceType.GetInterfaces();

if (dataSourceInterfaceTypes.Any(x => x == typeof(IUpgradableDataSource)))
{
    var methodInfo = dataSourceType
        .GetMethod(
            nameof(IUpgradableDataSource.UpgradeSourceConfigurationAsync), 
            BindingFlags.Public | BindingFlags.Static
        )!;

    var upgradedConfiguration = await (Task<JsonElement>)methodInfo.Invoke(
        default,
        [
            configuration,
            cancellationToken
        ]
    )!;

    // ...
}
else
{
    // ...
}

I attempted to cast the System.Type directly using:

CSHARPCopied
var myCastedType = dataSourceType as IUpgradableDataSource;
await myCastedType.UpgradeSourceConfigurationAsync(...);

but this resulted in a compile-time error. Is there a C# feature similar to Python's issubclass that allows me to check if the System.Type derives from IUpgradableDataSource and then invoke its static method directly, without reflection?

I've seen that with the new static abstract members in interfaces, C# supports compile-time polymorphism via generic constraints; however, my plugin scenario requires runtime type handling. Any guidance on how to work around this limitation?