Eredita da una classe base generica, applica un vincolo e implementa un'interfaccia in C #

Questa è una domanda di sintassi. Ho una classe generica che eredita da una classe base generica e applica un vincolo a uno dei parametri di tipo. Voglio anche che la classe derivata implementi un'interfaccia. Per la vita di me, non riesco a capire la sintassi corretta.

Questo è quello che ho:

DerivedFoo<T1,T2> : ParentFoo<T1, T2> where T2 : IBar { ... }

La prima cosa che mi è venuta in mente è stata questa:

DerivedFoo<T1,T2> : ParentFoo<T1, T2> where T2 : IBar, IFoo { ... }

Ma questo non è corretto in quanto ciò fa sì che T2 debba implementare sia IBar che IFoo, non DerivedFoo per implementare IFoo.

Ho provato un po 'di ricerca su Google, uso di due punti, punto e virgola, ecc., Ma sono risultato breve. Sono sicuro che la risposta sia semplicissima.

Includete l'intera firma della vostra classe prima di definire i vincoli generici.

class DerivedFoo<T1, T2> : ParentFoo<T1, T2>, IFoo where T2 : IBar
{
    ...
}

Il mio consiglio: quando hai una domanda sulla sintassi del linguaggio C #, leggi le specifiche; ecco perché lo pubblichiamo. Ti consigliamo di leggere la sezione 10.1.

Per rispondere alla tua domanda specifica, l'ordine delle cose in una dichiarazione di classe è:

• attributi, tra parentesi quadre
• modificatori ("public", "static" e così via)
• "parziale"
• "classe"
• il nome della classe
• un elenco separato da virgole di dichiarazioni di parametri di tipo all'interno di parentesi angolari
• i due punti seguono un elenco separato da virgole di tipi di base (classe base e interfacce implementate, la classe base deve essere inserita per prima se ce n'è una)
• tipo vincoli di parametro
• il corpo della classe, circondato da parentesi graffe
• un punto e virgola

Tutto su quell'elenco è facoltativo tranne "classe", il nome e il corpo, ma tutto deve apparire in questo ordine se appare.

public interface IFoo {}
public interface IBar {}

public class ParentFoo<T,T1> { }
public class DerivedFoo<T, T1> : ParentFoo<T, T1>, IFoo where T1 : IBar { }

public class KeyAndValue<T>
{
    public string Key { get; set; }
    public virtual T Value { get; set; }
}

public class KeyAndValue : KeyAndValue<string>
{
    public override string Value { get; set; }
}

Questa è un'estensione delle risposte esistenti. Il valore predefinito è stringse non si fornisce un tipo. Non ho implementato un'interfaccia ma ciò non dovrebbe richiedere nulla di diverso dal solito.