IDictionary<TKey, TValue> en.NET 4 no covariante

.net-4.0 covariance

Question

IDictionary<TKey, TValue> en .NET 4 / Silverlight 4 no es compatible con la covarianza, es decir, no puedo hacer una

IDictionary<string, object> myDict = new Dictionary<string, string>();

análogo a lo que puedo hacer con IEnumerable<T> s ahora.

Probablemente se reduce a KeyValuePair<TKey, TValue> tampoco es covariante. Creo que la covarianza debe permitirse en los diccionarios, al menos para los valores.

Entonces, ¿es eso un error o una característica? ¿Alguna vez vendrá, tal vez en .NET 37.4?

ACTUALIZACIÓN (2 años después):

Habrá un IReadOnlyDictionary<TKey, TValue> en .NET 4.5, pero no será covariante tampoco :·/ , porque deriva de IEnumerable<KeyValuePair<TKey, TValue>> , y KeyValuePair<TKey, TValue> no es una interfaz y por lo tanto no puede ser covariante.

El equipo de BCL debería rediseñar mucho para poder utilizar ICovariantPair<TKey, TValue> . Tampoco son posibles los indexadores fuertemente tipados a la this[TKey key] para las interfaces covariantes. Un fin similar solo se puede lograr colocando un método de extensión GetValue<>(this IReadOnlyDictionary<TKey, TValue> self, TKey key) algún lugar que de alguna manera internamente tendría que llamar a una implementación real, lo que podría parecer un enfoque bastante desordenado.

Answer 1

.NET 4 solo admite la covarianza no en . Funciona con IEnumerable porque IEnumerable es de solo lectura.

Answer 2

Es una característica. .NET 4.0 solo admite una covarianza segura . El reparto que mencionas es potencialmente peligroso, ya que podrías agregar un elemento que no sea de cuerda al diccionario si fuera posible:

IDictionary<string, object> myDict = new Dictionary<string, string>();
myDict["hello"] = 5; // not an string

Por otro lado, IEnumerable<T> es una interfaz de solo lectura. El parámetro de tipo T está solo en sus posiciones de salida (tipo de retorno de la propiedad Current ) por lo que es seguro tratar IEnumerable<string> como IEnumerable<object> .

Answer 3

Pero entonces podrías decir

myDict.Add("Hello, world!", new DateTime(2010, 1, 27));

que fallaría miserablemente El problema es que TValue en IDictionary<TKey, TValue> se usa tanto en las posiciones de entrada como de salida. Esto es:

myDict.Add(key, value);   

y

TValue value = myDict[key];

Entonces, ¿es eso un error o una característica?

Es por diseño.

¿Alguna vez vendrá, tal vez en .NET 37.4?

No, es intrínsecamente inseguro.

Answer 4

Tuve un problema similar, pero con tipos derivados más especializados (en lugar de objetos de los que todo se deriva)

El truco es hacer que el método sea genérico y poner una cláusula where poniendo la restricción relevante. Suponiendo que se trata de tipos básicos y tipos derivados, lo siguiente funciona:

using System;
using System.Collections.Generic;

namespace GenericsTest
{
class Program
{
    static void Main(string[] args)
    {
        Program p = new Program();

        p.Run();
    }

    private void Run()
    {

        Dictionary<long, SpecialType1> a = new Dictionary<long, SpecialType1> {
        { 1, new SpecialType1 { BaseData = "hello", Special1 = 1 } },
        { 2, new SpecialType1 { BaseData = "goodbye", Special1 = 2 } } };

        Test(a);
    }

    void Test<Y>(Dictionary<long, Y> data) where Y : BaseType
    {
        foreach (BaseType x in data.Values)
        {
            Console.Out.WriteLine(x.BaseData);
        }
    }
}

public class BaseType
{
    public string BaseData { get; set; }
}

public class SpecialType1 : BaseType
{
    public int Special1 { get; set; }
}
}

Answer 5

Una IDictionary para un tipo específico de covarianza útil en IDictionary

public static class DictionaryExtensions
{
    public static IReadOnlyDictionary<TKey, IEnumerable<TValue>> ToReadOnlyDictionary<TKey, TValue>(
        this IDictionary<TKey, List<TValue>> toWrap)
    {
        var intermediate = toWrap.ToDictionary(a => a.Key, a => a.Value!=null ? 
                                        a.Value.ToArray().AsEnumerable() : null);
        var wrapper = new ReadOnlyDictionary<TKey, IEnumerable<TValue>>(intermediate);
        return wrapper;
    }   
}