Obtenir la valeur de Dictionnaire<string, object> sans unboxing?

Je me demandais si il est possible d'exécuter le code suivant mais sans l'unboxing de la ligne:-

t.Value = (T)x;

Ou peut-être si il ya une autre façon de faire ce genre d'opération?

Voici le code complet:-

public class ValueWrapper<T>
{
    public T Value { get; set; }
    public bool HasValue { get; set; }

    public ValueWrapper()
    {
        HasValue = false;
    }
}

class Program
{
    static void Main(string[] args)
    {
        Dictionary<string, object> myDictionary = new Dictionary<string, object>();

        myDictionary.Add("key1", 6);
        myDictionary.Add("key2", "a string");

        var x2 = GetValue<int>(myDictionary, "key1");
        if (x2.HasValue)
            Console.WriteLine("'{0}' = {1}", "key1", x2.Value);
        else
            Console.WriteLine("No value found");

        Console.ReadLine();
    }

    static ValueWrapper<T> GetValue<T>(IDictionary<string, object> dictionary, string key)
    {
        ValueWrapper<T> t = new ValueWrapper<T>();

        object x = null;
        if (dictionary.TryGetValue(key, out x))
        {
            if (x.GetType() == typeof(T))
            {
                t.Value = (T)x;
                t.HasValue = true;
            }
        }

        return t;
    }
}

Merci d'avance!!

Richard.

Non, si votre object est une boîte de type de valeur, alors il faut être "unboxed". Est-il une raison pourquoi vous voulez éviter les unboxing?
Surtout pour la performance de mon projet où ce code est utilisé avec d'autres trucs de l'unboxing augmente le temps d'exécution d' ~200ms à ~1700ms. Ce qui est encore acceptable, je voulais juste savoir pour mon propre avantage, s'il existe une alternative.
Il est extrêmement peu probable que cela drastique de la dégradation des performances est due à unboxing. Utiliser un profiler pour déterminer quel est le véritable goulot d'étranglement.

OriginalL'auteur Richard Adnams | 2010-10-20

  1. 6

    Quelques commentaires:

    1. t.Value = (T)x;

    Le casting est nécessaire. C'est parce que t.Value est de type T et x est de type object. Fortement typées la nature de C# nécessite que vous dire au compilateur "regardez, je sais que cela peut dangereux, mais vous pouvez juste essayer de le faire pour moi, de toute façon, que ce soit par la conversion ou unboxing ou quoi? Merci!"

    2.

    object x = null;
if (dictionary.TryGetValue(key, out x)) {
    if (x.GetType() == typeof(T)) {
        t.Value = (T)x;
        t.HasValue = true;
    }
}

return t;

    Que si x est une instance d'une classe qui dérive de T? Ou si x est une instance d'une classe qui implémente une interface et T est que l'interface? Maintenant, vous allez retourner une instance de ValueWrapper<T> que indique il n'y a pas d'objet dans le dictionnaire avec la clé key. Je dirais que c'est très contre-intuitif de ce que la plupart des gens s'attendent.

    En outre, si vous n'êtes pas à l'envie de vomir quand dictionary ne contient pas une valeur correspondant à la clé key, je pense que vous devez renommer votre méthode pour TryGetValue, accepter une out paramètre de type ValueWrapper<T>, et de retourner une bool indiquant la réussite ou l'échec.

    3.

    De répondre à votre commentaire, voici une solution.

    public interface IValueWrapper {
object Value { get; set; }
bool HasValue { get; set; }
}
public class ValueWrapper<T> : IValueWrapper {
public T Value { get; set; }
object IValueWrapper.Value { 
get { return Value; }
set { this.Value = (T)value; }
}
public bool HasValue { get; set; }
public ValueWrapper() {
this.HasValue = false;
}
public ValueWrapper(T value) {
this.Value = value;
this.HasValue = value != null;
}
}
public static class DictionaryExtensions {
public static void Add<T>(
this IDictionary<string, IValueWrapper> dictionary,
string key,
T value
) {
ValueWrapper<T> valueWrapper = new ValueWrapper<T>(value);
dictionary.Add(key, valueWrapper);
}
public static bool TryGetWrappedValue<T>(
IDictionary<string, IValueWrapper> dictionary,
string key,
out ValueWrapper<T> value
) {
IValueWrapper valueWrapper;
if (dictionary.TryGetValue(key, out valueWrapper)) {
value = (ValueWrapper<T>)valueWrapper;
return true;
}
else {
value = null;
return false;
}
}
}

    Utilisation:

    var dict = new Dictionary<string, IValueWrapper>();
dict.Add("hello", 5);
ValueWrapper<int> value;
dict.TryGetWrappedValue("hello", out value);

    Vous aurez à ajouter de vérification des paramètres etc.

    Merci pour la réponse si rapide, j'ai été voir si il y avait un moyen que vous pouvez le faire donc l'objet n'était pas le V dans le dictionnaire, mais peut-être que quelque chose d'autre pour empêcher l'unboxing car il peut être très lente. Aussi, j'ai changé ma méthode de ref un ValueWrapper et retourner true/false qui ne se sentent un peu mieux pour moi, pour être honnête, je n'avais pas pensé à ça.
    Il devrait être out au lieu de ref.
    Adnams: je doute conduisant à des problèmes de performances, mais vous ne pouvez savoir si vous profil. Veuillez voir mon montage pour une manière de résoudre le problème que vous essayez de résoudre, cependant.
    Merci Jason, vous avez été d'une grande aide.. maintenant pour obtenir un café et de digérer cette :)!

    OriginalL'auteur jason