5

我有类似以下情况：

class Base
{
     public static int x;
     public int myMethod()
     {
          x += 5;
          return x;
     }

}

class DerivedA : Base
{
}

class DerivedB : Base
{
}

我正在尝试进行设置，以便每个派生类都有自己的 x 静态实例，如果我执行以下操作：

 DerivedA.x = 5;
 DerivedB.x = 10;

然后当我运行时：

 DerivedA.myMethod(); //The result will be 10
 DerivedB.myMethod(); //The reusult will be 15

我可以做这样的事情吗？如何设置派生类来实现这一点？多谢你们。

编辑：基本上，我有一堆派生类，每个派生类都有该类独有的属性。它不会因每个实例而异，因此我认为应该是一个静态变量。此外，该属性是由一个方法设置的，对于这些类中的每一个都是相同的。我试图避免在每个派生类中复制和粘贴该属性和方法的逻辑。我认为最好以某种方式将该逻辑移至派生这些类中的每一个的基类。但是，我需要每个派生类都有自己的该属性的副本。我不一定必须这样做，如果你们有任何更好的实践建议，我会很高兴听到一些......谢谢！

4

4 回答 4

12

嗯，是的，你可以，但它围绕着一个关于泛型的技巧。

如果你修复你的设计，这样你就不需要那个静态字段，或者至少不需要每个后代，那就更好了，但是这里有：

class Base<TDescendant>
    where TDescendant : Base
{
     public static int x;
     public int myMethod()
     {
          x += 5;
          return x;
     }

}

class DerivedA : Base<DerivedA>
{
}

class DerivedB : Base<DerivedB>
{
}

这依赖于这样一个事实，即具有静态字段的泛型类型将为您调用它的每种类型获得这些静态字段的单独副本。

但是，如果您打算从 DerivedA 或 DerivedB 下降，就会变得棘手，因此我不建议您走这条路。

于 2011-02-20T21:35:29.243 回答
5

您将需要重新定义和隐藏所有派生类型中的字段和方法。

例子：

class DerivedA : Base
{
  public new static int x;
  public new int myMethod()
  {
    x += 5;
    return x;
  }
}

注意：不要这样做。修复您的设计。

编辑：

实际上，我有一个类似的结构。我用一个抽象（如果你需要一个默认值，使用virtual）属性来解决它，然后从基类中使用它：

public abstract class Base
{
   public abstract string Name { get; }

   public void Refresh()
   {
     //do something with Name
   }
}

public class DerivedA
{
  public override string Name { get { return "Overview"; } }
}

您应该能够针对您的用例进行调整。protected如果只有派生类应该能够看到它，您当然可以创建该属性。

于 2011-02-20T21:31:35.793 回答
1

以 Type 作为键的静态字典应该这样做。我的意思是避免每个派生类型的逻辑重复和不同的值，但在实例之间共享。

public class Base
{
    private static Dictionatry<Type,int> _values;

    public int MyMethod()
    {
        _values[this.GetType()]+=5;
        return _values[this.GetType()];
    }
}
于 2016-05-14T19:29:23.583 回答
0

我通常将子类特定的东西实现为抽象的 get 属性

public class Base
{
    // You must pick one option below

    // if you have a default value in the base class
    public virtual int x { get { return 7; /* magic default value */} }

    // if you don't have a default value
    // if you choose this alternative you must also make the Base class abstract
    public abstract int x { get; }
}

public class DerivedA : Base
{
    public override int x { get { return 5; } }
}

public class DerivedB : Base
{
    public override int x { get { return 10; } }
}
于 2011-02-20T21:58:50.957 回答