Wie implementieren von virtuellen statischen Eigenschaften?

Für Sie noch nicht über ein accpted Antwort über fünf Jahre später, lassen Sie mich es versuchen, (wieder) ..

Habe ich jemals daran gedacht, über die Neugierig Recurring Template Pattern als ein workaround, aber da Sie offenen BaseClass für die Vererbung wäre es nicht eine gute Idee sein. Möchten Sie vielleicht einen Blick auf Herr Lippert ' s Blog für ein besseres Verständnis des warum.

• Lösung 1: Sie müssen sich nicht registrieren, die ich nicht erkennen ..

  public abstract class BaseClass {
      protected static void Register<U>(String identifier) where U : BaseClass {
          m_identities.Add(typeof(U).GetHashCode(), identifier);
      }
  
      public static String GetIdentifier<U>() where U : BaseClass {
          var t = typeof(U);
          var identifier = default(String);
          RuntimeHelpers.RunClassConstructor(t.TypeHandle);
          m_identities.TryGetValue(t.GetHashCode(), out identifier);
          return identifier;
      }
  
      static Dictionary<int, String> m_identities = new Dictionary<int, String> { };
  }
  
  public class DerivedClassA:BaseClass {
      static DerivedClassA() {
          BaseClass.Register<DerivedClassA>("12dc2490-065d-449e-a199-6ba051c93622");
      }
  }
  
  public class DerivedClassB:BaseClass {
      static DerivedClassB() {
          BaseClass.Register<DerivedClassB>("9745e24a-c38b-417d-a44d-0717e10e3b96");
      }
  }

  ---

  test:

  Debug.Print("{0}", BaseClass.GetIdentifier<DerivedClassA>());
  Debug.Print("{0}", BaseClass.GetIdentifier<DerivedClassB>());

Dies ist ein relativ einfaches Muster, das durch die typeninitialisierer. Die Register Methode ist nur ausgesetzt abgeleiteten Klasse; und sowohl die GetIdentifier und Register Methoden eingeschränkt sind aufgerufen, mit einer Art argument, das abgeleitet ist von BaseClass. Obwohl wir nicht mit Gewalt in den abgeleiteten Klassen zu überschreiben nichts, wenn Sie nicht selbst registrieren, GetIdentifier es nicht wiedererkennt und zurück null.

• Lösung 2: Bevor Sie zeigen Ihre Identität, das ich Sie kaufen ein Standard. Wer Sie denken, Sie sind, glaube ich -- so lange, wie es keine Mehrdeutigkeit.

  public abstract class BaseClass {
      public abstract String Identifier {
          get;
      }
  
      public static Type GetDerivedClass(String identifier) {
          return m_aliases[identifier];
      }
  
      public static String GetIdentifier(Type t) {
          var value = default(String);
  
          if(t.IsSubclassOf(typeof(BaseClass))) {
              var key = t.GetHashCode();
  
              if(!m_identities.TryGetValue(key, out value)) {
                  value=""+key;
                  m_aliases.Add(value, t);
                  m_identities[key]=value;
              }
          }
  
          return value;
      }
  
      static void UpdateAlias(BaseClass x) {
          var t = x.GetType();
          var value = x.Identifier;
          m_aliases.Add(value, t);
          m_identities[t.GetHashCode()]=value;
      }
  
      protected BaseClass() {
          BaseClass.UpdateAlias(this);
      }
  
      static Dictionary<String, Type> m_aliases = new Dictionary<String, Type> { };
      static Dictionary<int, String> m_identities = new Dictionary<int, String> { };
  }

  ---

  public class DerivedClassA:BaseClass {
      public override String Identifier {
          get {
              return "just text";
          }
      }
  }
  
  public class DerivedClassB:BaseClass {
      public override String Identifier {
          get {
              return "just text";
          }
      }
  }

  ---

  und der test:

  public static void TestMethod() {
      var idBeforeInstantiation = BaseClass.GetIdentifier(typeof(DerivedClassA));
      var y = new DerivedClassA { };
      var idAfterInstantiation = BaseClass.GetIdentifier(typeof(DerivedClassA));
  
      Debug.Print("B's: {0}", BaseClass.GetIdentifier(typeof(DerivedClassB)));
      Debug.Print("A's after: {0}", idAfterInstantiation);
      Debug.Print("A's before: {0}", idBeforeInstantiation);
      Debug.Print("A's present: {0}", BaseClass.GetIdentifier(typeof(DerivedClassA)));
  
      var type1 = BaseClass.GetDerivedClass(idAfterInstantiation);
      var type2 = BaseClass.GetDerivedClass(idBeforeInstantiation);
  
      Debug.Print("{0}", type2==type1); //true
      Debug.Print("{0}", type2==typeof(DerivedClassA)); //true
      Debug.Print("{0}", type1==typeof(DerivedClassA)); //true
  
      var typeB=BaseClass.GetDerivedClass(BaseClass.GetIdentifier(typeof(DerivedClassB)));
  
      var x = new DerivedClassB { }; //confilct
  }

Anscheinend ist dies eine kompliziertere Lösung. Wie Sie sehen können idBeforeInstantiation und idAfterInstantiation sind unterschiedlich, aber Sie sind entweder ein Gültiger Bezeichner für DerivedClassA. m_identities enthält die Letzte Aktualisierung Bezeichner für jede abgeleitete Klasse und m_aliases enthält alle Bezeichner Aliase für die abgeleiteten Klassen. Da die Kombination von virtuellen und statische ist nicht eine Funktion der Sprache, die derzeit(noch nie ..), wenn wir wollen, dass die Durchsetzung der überschreiben dann müssen wir es durch einige Abhilfe. Wenn Sie wählen, solution2, möchten Sie vielleicht, um implemenet Sie eigene UpdateAlias um zu verhindern, dass die abgeleiteten Klassen, die von der Bereitstellung von zu viel verschiedene Aliase für eine einzige Art, obwohl Sie alle gültig sein. Die Letzte Anweisung in der Prüfung sind, setzen Sie bewusst, um zu demonstrieren, den Konflikt von Bezeichnern.

Für diese beiden Lösungen sind sorgfältig entworfen, für Ihre Betrachtung der nicht zu instanziieren den abgeleiteten Klassen, keiner von Ihnen erfordert, dass.

Einen anderen Weg, dies zu tun, ist es nicht erforderlich eine Klasse registriert werden, aber erfordert ein wenig zusätzliche Arbeit zu schaffen, ist eine statische Klasse, hält die "statischen" Daten, die für jede abgeleitete Klasse Typ und eine Konstante/statischer Wert aus der statischen Klasse. Lassen Sie mich erklären die Besonderheiten dieses Ansatzes.

Einen großen Grund dafür, dass eine statische Eigenschaft, die immer das gleiche für jedes Mitglied der Klasse ist, um zu vermeiden, unnötigen Speicher zu verwenden und die Wiederholung. Während die Methode demonstriert hier nicht vermeiden diese gänzlich, ist es immer noch umgeht die meisten der "extra" - overhead. Der einzige Anwendungsfall, der dem Beispiel unten nicht erfüllt ist, wenn der Grund für die Verwendung einer statischen Eigenschaft, so dass Sie nicht haben, um eine Instanz haben, da müssen Sie eine Instanz haben, um auf die Daten.

Wenn Sie benötigen ein virtuelles Feld oder eine Eigenschaft, die immer die gleichen für jedes Mitglied der Klasse (statisch), verwenden Sie eine nicht-statische Konstanteneigenschaft, dass gibt eine "Konstante" oder statische Daten wie diese:

public static class MyStaticData
{
    public static const string Class1String = "MyString1";
    public static const int Class1Int = 1;
    public static const string Class2String = "MyString2";
    public static const int Class2Int = 2;
    //etc...
}

public abstract class MyBaseClass
{
    public abstract string MyPseudoVirtualStringProperty { get; }
    public abstract int MyPseudoVirtualIntProperty { get; }
}

public class MyDerivedClass1 : My BaseClass
{
    public override string MyPseudoVirtualStringProperty { get { return MyStaticData.Class1String; } }
    public override int MyPseudoVirtualIntProperty { get { return MyStaticData.Class1Int } }
}

public class MyDerivedClass2 : My BaseClass
{
    public override string MyPseudoVirtualStringProperty { get { return MyStaticData.Class2String; } }
    public override int MyPseudoVirtualIntProperty { get { return MyStaticData.Class2Int } }
}