Question

Is it possible to use Generic mechanism within function body?

for exammple

if (!(someClass is IClass<T, G> where T : someInterface, G : anotherInterface))
{
    return;
 }

or do casting like this:

var v = (IClass <T, G> where T : someInterface, G: anotherInterface)something;

Answer 1

You can do this, but you have to make sure your interface is covariant:

interface IClass<out T, out S>
{
    // Methods that can return a T or S but not accept one as input
}

By marking the type parameters as out, you are basically saying “I will only ever get a T or an S out of this interface”. For example, IEnumerable<out T> as you can only get a T out of it, but only List<T> because you can put a T into a list as well as get one out.

Having defined your interface as such, an IClass<string, string> is an IClass<object, object>: you know your IClass<string, string> will only ever give you a string, but since a string is an object then that’s fine, and if you assign it to an IClass<object, object> you know it will only ever give you an object.

(You can’t do this if you interface allows you to put a T or an S into something. If this was the case, and you assigned your IClass<string, string> to an IClass<object, object>, you could try to put an int into it and it would fail, because the underlying class only really accepts a string.)

What this then lets you do is

if (!(something is IClass<object, object>))
{
    return;
}

or

var v = (IClass<object, object>)something;

and both will work if something is actually an object that implements, say, IClass<string, string>.