C#: Vererben getrennte statische Elemente für abgeleitete Klassen

Question

Mein Problem in Kürze:

class A 
{ 
    /* Other stuff in my class*/ 
    protected static staticMember; 
} 

class B : A 
{ 
    /* Other stuff in my class*/ 
    // Will have A.staticMember but I want B.staticMember (same type) 
} 

class C : A 
{ 
    /* Other stuff in my class*/ 
    // Will have A.staticMember but I want C.staticMember (same type) 
} 

Deshalb möchte ich alle meine abgeleiteten Klasse eine gemeinsam genutzte Daten haben, die für die paricular Klasse geteilt wird, sondern haben eine gemeinsame Signatur definiert in die Basisklasse.

Ich erstelle ein einfaches RTS-Spiel zum Spaß in meiner Freizeit. Es gibt verschiedene Arten von Einheiten (Raumschiffe, Gebäude usw.), die einige grundlegende Eigenschaften haben. Diese Einheiten können von den Spielern aufgerüstet werden (alle Einheiten des gleichen Typs, die zu den gleichen Spieler werden aufgerüstet z. B. Spieler A den Tanks' Aufwertungen bedeutet, dass alle seine Panzer bessere Rüstung haben.)

Hier wie ich versuchte, dies achive:

abstract class Unit 
{ 
    /*several methods that is common for all units*/ 

    /*We don't know the unit's attributes at this point*/ 
    protected abstract double getMaxHitpoints(); 
    protected abstract double getFusionArmor(); 
    protected abstract double getNormalArmor(); 
    // and more similar abstract methods to come. 

    double maxHitpoints; 
    double fusionArmor; 
    double normalArmor; 
    //... 

    // This method is called on construction and after upgrade completion. 
    public void cacheAttributes(Player forPlayer) 
    { 
     Upgrade upgradesForThisUnit; //<<< Upgrade is class that is used like a struct to hold the upgrades for this kind of unit. 
     upgrades.TryGetValue(forPlayer,out upgradesForThisUnit); ///< get upgrades if available (if not available it will give the default value [=no bonuses]) 

     maxHitpoints=getMaxHitpoints()+upgradesForThisUnit.hitpointBonus; 
     fusionArmor=getFusionArmor()+upgradesForThisUnit.fusionArmorBonus; 
     normalArmor=getNormalArmor()+upgradesForThisUnit.normalArmorBonus; 
     //... 
    } 
    // This data structure is intended to hold the upgrades for every player for this kind of the unit 
    // but unfortunally derived classes have this instance too so if the player upgrades the tanks it will upgrade the interceptors, peasants, buildings too... 

    protected static Dictionary<Player,Upgrade> upgrades; 
} 

class Tank : Unit 
{ 
    protected override double getMaxHitpoints() {return 1000;} 
    protected override double getFusionArmor() {return 10;} 
    protected override double getNormalArmor() {return 50;} 
    //... 
} 

ich dachte über einen zusätzlichen Schlüssel zu meinem dictonary Hinzufügen (verschachtelten Wörterbuch verwenden): Typ-Strukturen als Schlüssel und den Code wie folgt zu ändern:

protected static Dictionary<Player,Dictionary<Type,Upgrade>> upgrades; 

public void cacheAttributes(Player forPlayer) 
{ 
    Dictionary<Type,Upgrade> upgradesForThePlayer; 
    upgrades.TryGetValue(forPlayer,out upgradesForThePlayer); 

    Upgrade upgradesForThisUnit; //<<< Upgrade is class that is used like a struct to hold the upgrades for this kind of unit. 
    upgradesForThePlayer.TryGetValue(GetType(),out upgradesForThisUnit); ///< get upgrades if available (if not available it will give the default value [=no bonuses]) 

    maxHitpoints=getMaxHitpoints()+upgradesForThisUnit.hitpointBonus; 
    fusionArmor=getFusionArmor()+upgradesForThisUnit.fusionArmorBonus; 
    normalArmor=getNormalArmor()+upgradesForThisUnit.normalArmorBonus; 
    //... 
} 

Aber ich " Ich bin mir nicht sicher, ob das wie erwartet funktioniert.

Die Lösung ist wahrscheinlich einfach, aber ich habe keine Ahnung, wie Sie das jetzt lösen.

Answer 1

Wenn Sie mit einem Wörterbuch von Wörterbüchern etwas wie Dictionary<Player, Dictionary<Type, Upgrade>> dann meinen, dann wird das wie erwartet funktionieren, und es ist eine feine Lösung für das Problem wie angegeben. Du könntest auch ein Array von Wörterbüchern verwenden, wenn du eine kleine Anzahl von maximalen Spielern hast, du bekommst nicht wirklich etwas übermäßig nützliches aus 4 Werten. (Wenn Sie ein Maximum von 4 Spielern)

Answer 2

public class Singleton<T> 
    { 
     private static string _value; 
     public string Value 
     { 
      get 
      { 
       return _value; 
      } 
      set 
      { 
       _value = value; 
      } 
     } 
    } 
    public class At<T> 
    { 
     public static Singleton<T> field = new Singleton<T>(); 
    } 

    public class Bt : At<Bt> 
    { 
    } 

    public class Ct : At<Ct> 
    { 
    } 
... 
    Bt.field.Value = "bt"; 
    Ct.field.Value = "ct"; 

Answer 3

Eine ziemlich alte Frage, aber die Menschen in der Zukunft zu profitieren, hier ist, wie ich um ein ähnliches Problem.

class A 
{ 
    /* Other stuff in my class*/ 
    protected MyClass nonStaticMember; 
} 

class B : A 
{ 
    private static B _instance; 
    public static B instance 
    { 
     get 
     { 
      return _instance; 
     } 
    } 
    static B() 
    { 
     _instance = new B(); 
    } 
    /* Other stuff in my class*/ 
    // Will have B.instance.nonStaticMember 
} 

class C : A 
{ 
    private static C _instance; 
    public static C instance 
    { 
     get 
     { 
      return _instance; 
     } 
    } 
    static C() 
    { 
     _instance = new C(); 
    } 
    /* Other stuff in my class*/ 
    // Will have C.instance.nonStaticMember 
} 

Dies setzt voraus, Sie C.instance.doSomethingTo_nonStaticMember() von einer anderen Klasse zugreifen möchten.