interfacce generiche nidificati

Question

ho uno schema di interfacce come il seguente (C#) .NET4

interface A 
{ 

} 

interface B 
{ 
    List<A> a; 
} 

interface C 
{ 
    List<B> b; 
} 

e ho implementato in questo modo:

public interface A 
{ 

} 

public interface B<T> where T : A 
{ 
    List<T> a { get; set; } 
} 

public interface C<T> where T : B 
{ 
    List<T> b { get; set; } // << ERROR: Using the generic type 'B<T>' requires 1 type arguments 
} 

Non so come evitare l'errore L'utilizzo del tipo generico 'B' richiede 1 tipo argomenti

Answer 1

Poiché interface B<T> è generico, è necessario fornire un argomento di tipo formale per esso quando si dichiara interface C<T>. In altre parole, il problema attuale è che non si sta dicendo al compilatore quale tipo di interfaccia B di interfaccia "eredita" da.

I due T s non si riferiscono necessariamente allo stesso tipo. Essi possono essere dello stesso tipo, come in

public interface C<T> where T : B<T>, A { ... } 

oppure possono essere di due tipi distinti:

public interface C<T, U> where T : B<U> where U : A { ... } 

Le restrizioni sull'argomento tipo sono ovviamente più stretto nel primo caso.

Answer 2

C è simile al tipo Generico generico (per mancanza di una parola migliore).

Questa definizione di C dovrebbe invece funzionare?

public interface C<T,U> where T : B<U> where U : A 
{ 
    List<T> b{ get; set; } 
} 

Answer 3

dal tipo generico nell'interfaccia B può essere solo un'istanza di tipo A, in un'interfaccia C è necessario dichiarare T di tipo B<A>:

public interface A { } 
public interface B<T> where T : A 
{ 
    List<T> a { get; set; } 
} 
public interface C<T> where T : B<A> 
{ 
    List<T> b { get; set; } 
} 

Answer 4

Questo è perché avete un <List<T>> dove T è B<T> nel momento in cui lo si ha come List<B> dove è necessario specificare un tipo per B. Questa è la ragione del tuo errore.

public interface C<T, T2> where T : B<T2> 
    where T2 : A 
{ 
    List<T> b { get; set; } 
} 

Fusioni T2-A e poi si andrà bene :)

Answer 5

è possibile aggiungere più di un'interfaccia qui come

public interface A { } 
public interface B<T> where T : A 
{ 
    List<T> a { get; set; } 
} 
public interface BA : B<A> 
{ 
} 
public interface C<T> where T : BA 
{ 
    List<T> b { get; set; } // << ERROR: Using the generic type 'B<T>' requires 1 type arguments 
} 

non risolve lo scopo?