KeyValuePair Covariance

Question

Esiste un modo migliore per simulare Covariance in questo esempio? Idealmente mi piacerebbe fare:

private IDictionary<string, ICollection<string>> foos; 

public IEnumerable<KeyValuePair<string, IEnumerable<string>> Foos 
{ 
    get 
    { 
     return foos; 
    } 
} 

Ma KeyValuePair<TKey, TValue> non è covariante.

Invece quello che devo fare:

public IEnumerable<KeyValuePair<string, IEnumerable<string>>> Foos 
{ 
    get 
    { 
     return foos.Select(x => 
      new KeyValuePair<string, IEnumerable<string>>(x.Key, x.Value)); 
    } 
} 

C'è un modo migliore/più pulito?

Answer 1

Sfortunatamente, KeyValuePair<TKey, TValue> è una struttura; e le strutture non mostrano varianza in .NET.

Ovviamente si può risolvere questo problema, scrivendo la propria interfaccia covariante Pair ed alcuni aiutanti semplici per la conversione tra sequenze di KeyValuePair e l'interfaccia personalizzata Pair. Questo vi permetterà di fare:

var dict = new Dictionary<string, ICollection<string>>(); 

// Notice that you can "weaken" both the key and the value. 
var dictView = dict.GetCovariantView() 
        .CastPairs<object, IEnumerable<string>>(); 

Ecco qualche esempio di codice che vi permetterà di raggiungere questo obiettivo:

public interface IPair<out TKey, out TValue> 
{ 
    TKey Key { get; } 
    TValue Value { get; } 
} 

public class Pair<TKey, TValue> : IPair<TKey, TValue> 
{ 
    public TKey Key { get; private set; } 
    public TValue Value { get; private set; } 

    public Pair(TKey key, TValue value) 
    { 
     Key = key; 
     Value = value; 
    } 

    public Pair(KeyValuePair<TKey, TValue> pair) 
     : this(pair.Key, pair.Value) { } 
} 

public static class PairSequenceExtensions 
{ 
    public static IEnumerable<IPair<TKey, TValue>> GetCovariantView<TKey, TValue> 
      (this IEnumerable<KeyValuePair<TKey, TValue>> source) 
    { 
     if (source == null) 
      throw new ArgumentNullException("source"); 

     return source.Select(pair => new Pair<TKey, TValue>(pair)); 
    } 

    public static IEnumerable<IPair<TKey, TValue>> CastPairs<TKey, TValue> 
     (this IEnumerable<IPair<TKey, TValue>> source) 
    { 
     if (source == null) 
      throw new ArgumentNullException("source"); 

     return source; 
    } 
} 

Answer 2

Difficilmente. KVP è una struct: Not an ennerface, è di ValueType.

Interessante SO post sulla varianza.

penso calchi sono più performante, quindi preferisco codice come questo:

private IDictionary<string, IEnumerable<string>> foos; 

public IEnumerable<KeyValuePair<string, IEnumerable<string>> Foos 
{ 
    get 
    { 
     return foos; 
    } 
} 

e cast KeyValuePair.Value a ICollection in cui ho davvero bisogno di. Parlando francamente, dipende da come viene usato il foos.