Traite la sous-classe comme sa superclasse lorsque seulement un membre diffère par son type

Question

J'ai une classe Variable et 3 sous-classes: VariableBool, VariableLong et VariableDouble. Chaque sous-classe définit uniquement un membre de valeur du type du suffixe.

Maintenant, j'ai besoin de transférer des objets basés sur ces classes sur WCF. J'ai plusieurs clients qui enregistrent leur variale sur un serveur. Chaque fois qu'une valeur change sur un client, elle est mise à jour dans tous les autres clients.

Ma question est: est-il un moyen de le faire:

someVar.Value = anotherVar.Value; 

quel que soit le type, wihout avoir à vérifier le type, par exemple .:

VariableBool anotherVarBool = anotherVar as VariableBool; 
if (anotherVarBool != null) { 
    (someVar as VariableBool).Value = anotherVar.Value; 
} 
// check other types... 

Qu'est-ce que je manque? Y a-t-il une sorte de paternité? Pourrais-je utiliser la réflexion? En outre, je ne pense pas que je peux utiliser des génériques à cause de la WCF (j'ai essayé mais je pourrais le faire fonctionner).

Merci

Answer 1

Si vous utilisez proxy WCF généré Mex, alors je soupçonne que la réflexion (ou ComponentModel) est en effet l'option la plus simple - quelque chose comme:

public static void Copy<T>(T source, T destination, 
    string propertyName) { 
    PropertyInfo prop = typeof(T).GetProperty(propertyName); 
    prop.SetValue(destination, prop.GetValue(source, null), null); 
} 

Ou si vous voulez l'utiliser même avec les types de variables en tant que classe de base:

public static void Copy(object source, object destination, 
    string propertyName) { 
    PropertyInfo sourceProp = source.GetType().GetProperty(propertyName); 
    PropertyInfo destProp = destination.GetType().GetProperty(propertyName); 
    destProp.SetValue(destination, sourceProp.GetValue(source, null), null); 
} 

Answer 2

Pourquoi ne pas placer le membre Value dans la variable de classe de base. Dans ce cas,

public void UpdateValue(Variable variable) 
{ 
    if(variable != null) 
     // do something with variable.Value 
} 

Cependant, si vous voulez vraiment utiliser l'héritage, vous devez dire à la classe de base quels sont les sous-types en utilisant l'attribut KnownType et sa méthode

[DataContract()] 
[KnownType("GetKnownType")] 
public class Variable 
{ 

public object Value; 

private static Type[] GetKnownType() 
{ 
    // properties 
    return new []{ typeof(VariableBool), 
        typeof(VariableLong), 
        typeof(VariableDouble),}; 
} 
} 

[DataContract()] 
public class VariableBool : Variable 
{ 
} 

[DataContract()] 
public class VariableLong : Variable 
{ 
} 

[DataContract()] 
public class VariableDouble : Variable 
{ 
}