Unterklasse wie ihre Oberklasse behandeln, wenn sich nur ein Mitglied durch seinen Typ unterscheidet

Question

Ich habe eine Klasse Variable und 3 Unterklassen: VariableBool, VariableLong und VariableDouble. Jede Unterklasse definiert nur ein Wertmitglied vom Typ des Suffixes.

Nun muss ich Objekte, die auf diesen Klassen basieren, über WCF transferieren. Ich habe mehrere Clients, die ihre Variablen auf einem Server registrieren. Immer wenn sich ein Wert auf einem Client ändert, wird er in allen anderen Clients aktualisiert.

Meine Frage ist: gibt es eine Möglichkeit zu tun:

someVar.Value = anotherVar.Value;

unabhängig vom Typ, ohne dass der Typ geprüft werden muss, z. B.:

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

Was übersehe ich? Gibt es irgendeine Art von Vaterschaft? Könnte ich eine Reflexion verwenden? Außerdem glaube ich nicht, ich kann Generics wegen der WCF verwenden (ich habe versucht, aber ich konnte es funktionieren).

Danke

Answer 1

Wenn Sie mex-generierte WCF-Proxies verwenden, dann vermute ich, dass Reflexion (oder ComponentModel) in der Tat die einfachste Option ist - etwas wie:

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);
}

Oder wenn Sie es sogar mit den variablen Typen als Basisklasse verwenden wollen:

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

Warum setzen Sie nicht das Value-Mitglied in die Basisklasse Variable. In diesem Fall,

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

Wenn Sie jedoch die Vererbung wirklich nutzen wollen, müssen Sie der Basisklasse mitteilen, welche Untertypen es gibt, indem Sie das Attribut KnownType und seine Methode

[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
{
}