基类方法使用的C#成员变量重写

好吧，我承认这有点疯狂…但它确实有一个合乎逻辑的目的。我正在为当前项目使用C#，我试图找到一种方法来重写派生类中的成员变量，但在基类方法中访问被重写的变量。为了让事情更“有趣”，最好是重写的成员变量是静态的（下面的示例代码中没有显示）

以下是我的示例代码：

class baseclass
{
    protected string[] array = null;

    public string method()
    {
        string str = "";
        foreach (string x in this.array)
        {
            str += x + "  "; 
        }

        return str;
    }
}

class subclass1 : baseclass
{
    new string[] array = new string[]
    {
        "class1value1",
        "class1value2",
        "class1value3",
        "class1value4"
    };
}

class subclass2 : baseclass
{
    new string[] array = new string[]
    {
        "class2value1",
        "class2value2",
        "class2value3",
        "class2value4"
    };
}

---

关于为什么这不起作用以及如何绕过它，您有什么想法吗？

为什么需要重写该变量？从你的代码来看，仅仅设置值就足够了，不是吗

---

另外，静态变量绑定到类（而不是实例），因此在任何情况下都不能重写它。

有什么原因不能使用虚拟属性吗？这将提供您想要的功能。这不是一个领域

protected abstract string[] array { get; }

---

就是不要用新的。在子类的构造函数中设置数组

编辑：使用代码：

class subclass1 : baseclass
{
    public subclass1()
    {
        array = new string[]
        {
            "class1value1",
            "class1value2",
            "class1value3",
            "class1value4"
        };
    }
}

class subclass2 : baseclass
{
    public subclass2()
    {
        array = new string[]
        {
            "class2value1",
            "class2value2",
            "class2value3",
            "class2value4"
        };
    }
}

类基类
{
公共虚拟字符串方法（）
{
返回字符串。空；
}
}
抽象类基类：基类，其中T:BaseClass
{
受保护的静态字符串[]字符串；
公共重写字符串方法（）
{
返回string.Join（“，strings）；
}
}
类子类1：基类
{
静态子类1（）
{
strings=new[]{“ClassValue1”、“ClassValue2”、“ClassValue3”}；
}
}
类子类2：基类
{
静态子类2（）
{
strings=new[]{“class2value1”、“class2value2”、“class2value3”}；
}
}

---

重要的部分是泛型参数

T

，它基本上是字符串数组的索引。

您试图从数组中获取多态行为，但您正在为类本地行为定义它

数组必须是虚拟的，或者基类中的method（）将被编译以始终访问基类中的数组-数组也应该是一个属性而不是一个字段来执行此操作，即

字符串[]_数组={…}/基类局部值 受保护的虚拟字符串[]数组{get{return}}}//使数组属性可重写

然后在子类中，需要执行以下操作

字符串[]_数组={…}//子类局部值 虚拟字符串[]数组{get{return _array；}}}//这将重写基类属性

---

为了获得所需的影响

成员变量不是多态的方法。初始化数组以在每个子类中包含所需的值。您创建单独的类只是为了保存不同的数据，+1我现在正在处理这个问题。。。你是对的，这可能有用。。。仍然在玩。谢谢你给我的想法增加了信心。这不允许我有一个静态数组

class subclass1 : baseclass
{
    public subclass1()
    {
        array = new string[]
        {
            "class1value1",
            "class1value2",
            "class1value3",
            "class1value4"
        };
    }
}

class subclass2 : baseclass
{
    public subclass2()
    {
        array = new string[]
        {
            "class2value1",
            "class2value2",
            "class2value3",
            "class2value4"
        };
    }
}

class BaseClass
{
    public virtual string Method()
    {
        return string.Empty;
    }
}

abstract class BaseClass<T> : BaseClass where T : BaseClass<T>
{
    protected static string[] strings;

    public override string Method()
    {
        return string.Join("  ", strings);
    }
}

class Subclass1 : BaseClass<Subclass1>
{
    static Subclass1()
    {
        strings = new[] { "class1value1", "class1value2", "class1value3" };
    }
}

class Subclass2 : BaseClass<Subclass2>
{
    static Subclass2()
    {
        strings = new[] { "class2value1", "class2value2", "class2value3" };
    }
}