A delegálthoz rendelt általános módszer

A kérdésnek nincs értelme, mert soha nem használhat nyílt általános típust a tárolási hely deklarálására (például helyi változó vagy mező). Mindig zárva kell lennie.

Úgy tudom, hogy egy GenericDelegate<T>-et szeretne átadni egy ilyen értéket argumentumként használó metódusnak. De még ekkor is a delegált típus zárttá válik, és az általános típusparaméter a T.

A mintakódodba írod

someDelegate = GenericMethod;

de milyen típusúnak kell lennie a someDelegate-nek? Nyilvánvalóan be kell zárni (GenericDelegate<string>), vagy le kell zárni egy általános típusparaméterrel a külső hatókörből:

void SomeOuterMethod<T>() where T : ISomeClass {
    GenericDelegate<T> someDelegate = GenericMethod<T>;
}

Remélem értettem a problémádat. Ha nem, kérem pontosítsa. Ha egy kicsit kifejti, hogymit szeretne elérni, megpróbálok praktikus megoldást javasolni.

Más nyelvek, például a Haskell, támogatják a nyílt általános típusok értékeinek átadását (más szóval, rendelkezhet egy IEnumerable<> típusú változóval). Ez szükséges a monádok megvalósításához. A CLR nem rendelkezik ezzel a funkcióval.

Új gondolat: delegált helyett létrehozhat egy nem általános alaptípust egy általános metódussal, amely felülbírálható:

interface CheckHandler {
 public void Check<T>(T someArg);
}

Remélhetőleg ez lefedi az Ön forgatókönyvét. Nem lehet szabadon elhaladni egyetlen CheckHandler mellett sem. A Check metódusa ezután tetszőleges típusú argumentummal hívható meg.

Lehetséges egyetlen "dolog", amely több paramétertípuson is működhet, de a Delegate osztály erre nem alkalmas. Ehelyett meg kell határoznia egy interfészt. Egyszerű példaként:

public interface IMunger<TConstraint>
{
    void Munge<T>(ref T it) where T : TConstraint;
}
public class Cloner : IMunger<ICloneable>
{
    public void Munge<T>(ref T it) where T : ICloneable
    {
        if (typeof(T).IsValueType) // See text
            return;
        it = (T)(it.Clone());
    }
}

Még akkor is, ha a rendszernek van egy előre definiált delegált típusa by-ref paraméterrel (így például a ActByRef<ICloneable> aláírása void Invoke(ref ICloneable p1) lenne), az ilyen delegált csak egy pontos ICloneable típusú változónál használható. Ezzel szemben a Cloner nem általános osztálytípus egyetlen objektuma olyan metódust tud biztosítani, amely alkalmas bármilyen tárolóhelytípushoz, amely megvalósítja a ICloneable elemet. Vegye figyelembe azt is, hogy ha a metódus egy ref értéket ad át egy olyan változónak, amely egy bekeretezett értéktípusú példányra hivatkozik, akkor lecseréli azt a példány másolatára való hivatkozásra, de ha egy ref értéket ad át egy értéktípusra. változót, úgy hagyja, ahogy van (kivéve, ha az értéktípus megtartja állapotát egy változtatható osztályobjektumban, amelyre hivatkozik – ez egy nagyon fura minta –, ha a StructType foo = (StructType)(bar.Clone()); csak foo = bar-nek felel meg; a struktúra típusa esetleg implementálja a ICloneable kódot, hogy részt vehessen egy mély klónozási hierarchiában, de ez nem jelenti azt, hogy a Clone metódusának bármit is kell tennie.

Frissítettük a példát, hogy támogassa a metódust paraméterként, amely csak azt mutatja be, hogyan hívható meg az általános delegáció más metódus paramétereként.

class Program
{
    public delegate T Transformer<T>(T arg) where T : IComparable;

    public static void Transform<T>(T value, Transformer<T> method) where T: IComparable
    {
        Console.WriteLine(method(value));
    }

    static void Main(string[] args)
    {
        Transform(5, Square);
    }

    static int Square(int x)
    {
        return x * x;
    }
}

Kipróbáltam a következőket:

public class Test
{
    public interface ISomeClass { }

    public class ImplementsSomeClass : ISomeClass { }

    public delegate void GenericDelegate<T>() where T : ISomeClass;

    public void GenericMethod<T>() 
    {
        // EDIT: returns typeof(ImplementsSomeClass)
        var t = typeof(T); 
    }

    public void CheckDelegate(GenericDelegate<ISomeClass> mechanism)
    {
        // EDIT: call without generic argument since it is already determined 
        mechanism(); 
    }

    public void test()
    {
        GenericDelegate<ISomeClass> someDelegate = GenericMethod<ImplementsSomeClass>;
        CheckDelegate(someDelegate);
    }
}

És nincs fordítási hibám. Ez futásidejű probléma, vagy félreértettem a probléma leírását?