C# 要在子类中从父类更改的静态变量

我想创建一个狗、猫、狮子等的子类。我想让每个动物都创建一个自己的对象。当它在自己的物体上创造时，我想让它记录有多少种动物。例如，如果有3条狗，那么dog类知道它有4条狗。其他所有的都一样

狗的示例代码：

class Dog {
    static int numberOfDogs = 0;

    public Dog() {
    }

    public void AddDog() {
        numberOfDogs++;
    }

    public void MinusDog() {
        numberOfDogs--;
    }
}

现在，如果我想对一只猫做同样的事情，我需要重写所有的代码，并用

cat

替换

dog

，以此类推

我想做的是创建一个父类，它在一个点上有所有重复的代码，但是当我创建一个Dog时，它将添加到Dog变量中，并且与cat一样，等等。我对家长班的看法是：

class Animal {
    public static int NumberOfAnimals;

    public void AddAnimal() {
        NumberOfAnimals++;
    }

    public void MinusAnimal() {
        NumberOfAnimals--;
    }
}

如果我从

Animal

派生

Dog

并调用

Dog.AddAnimal（）

，它将添加到所有

Animal

的静态变量中。我怎样才能使

Dog

中有一个静态变量，可以使用父类

Animal

更改该变量

---

或者，如果我问了一个错误的问题，我怎样才能得到拥有许多静态变量的动物的期望结果呢？

如果你想让类狗成为动物的派生类，这样你就可以从类狗访问类动物，你必须做->

`类动物{

公共动物（int&NumberOfAnimals；） {NumberOfAnimals++；}

公共动物（int和NumberOfAnimals） {NumberOfAnimals--；} }

狗类：公共动物{

int numberOfDogs=0

动物obj

公共无效AddDog（） {obj.AddAnimal（numberOfDogs）；}

public void MinusDog（）{obj.MinusAnimal（numberOfDogs）；}'

---

如果你想让numberOfDogs成为静态的，你就不能在加或减时增加或减少它的值。如果你想让Class Dog成为动物的派生类，这样你就可以从Class Dog访问Class Animal，你必须这样做->

`类动物{

公共动物（int&NumberOfAnimals；） {NumberOfAnimals++；}

公共动物（int和NumberOfAnimals） {NumberOfAnimals--；} }

狗类：公共动物{

int numberOfDogs=0

动物obj

公共无效AddDog（） {obj.AddAnimal（numberOfDogs）；}

public void MinusDog（）{obj.MinusAnimal（numberOfDogs）；}'

---

如果你想让numberOfDogs成为静态的，那么当你加或者减的时候，你将不能增加或者减少它的值，我不相信这个类本身是计算你有多少的正确位置。但是，你的问题中没有足够的信息来对更广泛的目标做出良好的评估

就你的要求而言，你有很多选择。这里有几个

一种简单的方法是让基类有一个字典：

class Animal
{
    private static readonly Dictionary<Type, int> _counts =
        new Dictionary<Type, int>();

    protected Animal()
    {
        int count;

        _counts.TryGetValue(this.GetType(), out count);
        _counts[this.GetType()] = count + 1;
    }
}

class Dog : Animal { ... }

类动物
{
专用静态只读字典\u计数=
新字典（）；
受保护动物（）
{
整数计数；
_counts.TryGetValue（this.GetType（），out count）；
_计数[this.GetType（）]=count+1；
}
}
狗类：动物{…}

另一个选项是让运行时处理特定于类型的计数：

class Animal<T>
{
    private static int _count;

    protected Animal()
    {
        _count++;
    }
}

class Dog : Animal<Dog> { ... }

类动物
{
私有静态整数计数；
受保护动物（）
{
_计数++；
}
}
狗类：动物{…}

详细说明第二个选项，因为对于C#新手来说可能有点困惑。从你的评论开始

你那里有什么东西

这是

Animal

类声明的一部分，使其成为泛型类。也就是说，在使用该类时，必须为该类提供一个类型参数（即其他类型的名称），其中该类型参数以一种有用的方式专门化泛型类型（其中“有用”取决于您使用它的方式）。在本例中，我的示例使基类成为泛型的，以利用泛型类型的静态字段对于所使用的每个不同类型参数都是唯一的这一事实

也就是说，对于声明的类

类Dog:Animal{…}

，基类中的字段

\u count

实际上是一个不同于其他声明类的变量，例如

类Cat:Animal{…}

。这样，每个子类（如

Dog

、

Cat

等）都会为该字段获取自己的值

在这两种情况下，您仍然需要确定如何实际获得计数并使用它们。从你的问题中不清楚这是怎么回事

还要注意的是，上面这些都不是线程安全的，而静态成员通常是线程安全的。我省略了这一部分，但您需要添加同步以确保线程安全，因此没有什么意外

综上所述，如果这真的超出了你的想象，而你实际上刚刚开始学习OOP、继承和C#，我会回到我最初的陈述，我不相信在类本身中实现这一点是正确的

更好的方法是让其他类知道您正在创建的不同

动物
对象，并以某种方式跟踪它们。例如，它可以有一个
字典
，其中键
类型
可以是例如
typeof（Dog）
、
typeof（Cat）
，值
列表
可以是
动物
对象的特定类型的列表。然后，您不仅可以立即访问count（因为
List
类具有
count
属性），还可以立即检索您创建的所有对象

我再具体不过了，因为你的问题对于这些物体的实际用途是相当模糊的。如果您所要做的只是学习OOP和继承是如何工作的，那么现在最好不要担心创建的对象数量。
public abstract class Animal
    {
        public static List<Type> AnimalList=new List<Type>();

        protected Animal(Type animalType)
        {

            AnimalList.Add(animalType);
        }   
    }

 public class Dog : Animal
  {
    public Dog(Type animalType) : base(animalType)
    {

    }
    public static int CountDogs
    {
        get { return AnimalList.Count(x => x == typeof (Dog)); }
    }
  }

Animal a =new Dog(typeof(Dog));
Animal a1=new Dog(typeof(Dog));
var c = Dog.CountDogs;