Comment sécuriser le type autour des valeurs de Variant

Question

Je travaille avec un contrôle Serveur OPC qui stocke les balises de données sous forme de types de variantes, décrit par System.Runtime.InteropServices.VarEnum . Ces types incluent les suivants: VT_BSTR (chaîne), VT_I2 (court) et VT_I4 (long).

Toutes ces valeurs sont stockées par le serveur sous forme d'objets , puis je dois attribuer la valeur correcte lorsque je les récupère.

Je sais que je peux faire quelque chose comme ce qui suit:

object tagValue = (object)"testing"; //this would be returned from a function rather than created this way!!
var typedVariant = new TypedVariant<string>(tagValue);
string actualString = typedVariant.Value;

Où TypedVariant est une classe générique, par exemple:

class TypedVariant<T> where T : class, struct
{          
    public TypedVariant(object variant)
    {
        Value = variant as T;
    }

    public T Value { private set; get; }

    public static implicit operator TypedVariant<T> (T m)
    {
        // code to convert from TypedVariant<T> to T
        return new TypedVariant<T>(m);
    }

    public static implicit operator T (TypedVariant<T> m)
    {
        // code to convert from T to TypedVariant<T>
        return m.Value;
    }  
}

Mais y a-t-il un moyen de tout faire à l'exécution, c'est-à-dire quelque chose comme ce qui suit:

TypedVariant<> typedVariant = TypedVariant.Create(VarEnum.VT_BSTR, tagValue);
//typedVariant should now be of type TypedVariant<string>    

Évidemment, ce code ne compilera pas, mais peut-il être fait comme ça?

Mise à jour : comme l'a suggéré @ Konamiman, j'ai modifié la classe pour autoriser la diffusion implicite. Donc, vous pouvez maintenant écrire ce code et tout ce qui est typé, vous ne pouvez donc pas stocker la variante dans un type différent de celui avec lequel elle a été créée.

object objectStr = (object)"testing"; //created this way just for testing        
TypedVariant<string> typedVariant = (string)objectStr;
string actualString = typedVariant;

Answer 1

Je pense que l’encapsuleur TypedVariant est une bonne idée. Vous pouvez l’étendre pour redéfinir l’opérateur de conversion implicite de / vers le type encapsulé pour pouvoir l’utiliser de manière plus transparente. comme:

var typedVariant = (string)tagValue;
string actualString = typedVariant;

Voir ici: " implicit " référence de mot clé sur MSDN