C# 通过泛型继承实现静态成员可访问性

我最近提出了一些相当时髦的单例工作，发现我可以使用使用泛型的相同继承基础从任何唯一继承类型访问受保护的静态成员。我所说的一个例子如下：

public abstract class Class<T>
{
    protected static int number = 5;

    public void Print()
    {
        Console.WriteLine(number);
    }
}

public class ClassA : Class<ClassA>
{
}

public class ClassB : Class<ClassB>
{
    public ClassB()
    {
        number = 1;
    }
}

public class ClassC : Class<ClassC>
{
    public ClassC()
    {
        number = ClassA.number;//I don't want to be able to see "number"
    }
}

公共抽象类
{
受保护静态整数=5；
公开作废印刷品（）
{
控制台写入线（编号）；
}
}
公共课A：课堂
{
}
公共类B类：类
{
公共类别B（）
{
数字=1；
}
}
公共类C类：类
{
公共类别c（）
{
number=ClassA.number；//我不想看到“number”
}
}

因为这里使用泛型，所以每个唯一的继承类型都有自己的“编号”（这就是我想要的）。但是当使用泛型时，我不喜欢从继承相同基类型的其他类型访问“number”。有办法解决这个问题吗？还有为什么会发生这种情况（我理解为什么在没有泛型的继承中会发生这种情况，但在泛型中发生这种情况似乎是不对的）

您可以使用修饰符使静态成员对后代不可见。仅当希望子体能够访问它时，才使用“受保护”。通用与非通用没有区别

public abstract class Class<T>
{
    private static int number = 5;  //Private now

    public void Print()
    {
        Console.WriteLine(number);  //Works
    }
}

public class ClassA : Class<ClassA>
{
    //No number
}

public class ClassB : Class<ClassB>
{
    public ClassB()
    {
        number = 1;  //Will not compile
    }
}

public class ClassC : Class<ClassC>
{
    public ClassC()
    {
        number = ClassA.number;//Will not compile
    }
}

公共抽象类
{
private static int number=5；//现在是private
公开作废印刷品（）
{
Console.WriteLine（number）；//有效
}
}
公共课A：课堂
{
//没有号码
}
公共类B类：类
{
公共类别B（）
{
number=1；//将不编译
}
}
公共类C类：类
{
公共类别c（）
{
number=ClassA.number；//将不编译
}
}

如果希望静态变量仅可供某些子体访问，而不可供其他子体访问，请在继承链中需要访问的第一个类中定义该变量：

public abstract class Class<T>
{
}

public class ClassA : Class<ClassA>
{
    static private int number = 7;
}

public class ClassB : Class<ClassB>
{
    static private int number = 7;

    public ClassB()
    {
        ClassA.number = 5;  //Does not compile
        ClassB.number = 6;
    }
}

public class ClassC : Class<ClassC>
{
    static private int number = 7;

    public ClassC()
    {
        Console.WriteLine(ClassA.number);  //Does not compile
        Console.WriteLine(ClassB.number);  //Does not compile
        Console.WriteLine(ClassC.number);  //Compiles
    }
}

公共抽象类
{
}
公共课A：课堂
{
静态私有整数=7；
}
公共类B类：类
{
静态私有整数=7；
公共类别B（）
{
ClassA.number=5；//不编译
类别b.编号=6；
}
}
公共类C类：类
{
静态私有整数=7；
公共类别c（）
{
Console.WriteLine（ClassA.number）；//不编译
Console.WriteLine（ClassB.number）；//不编译
Console.WriteLine（ClassC.number）；//编译
}
}

您不能在祖先类中定义某个对象并将其从后代中删除

可以使用修改器使静态成员对后代不可见。仅当希望子体能够访问它时，才使用“受保护”。通用与非通用没有区别

public abstract class Class<T>
{
    private static int number = 5;  //Private now

    public void Print()
    {
        Console.WriteLine(number);  //Works
    }
}

public class ClassA : Class<ClassA>
{
    //No number
}

public class ClassB : Class<ClassB>
{
    public ClassB()
    {
        number = 1;  //Will not compile
    }
}

public class ClassC : Class<ClassC>
{
    public ClassC()
    {
        number = ClassA.number;//Will not compile
    }
}

公共抽象类
{
private static int number=5；//现在是private
公开作废印刷品（）
{
Console.WriteLine（number）；//有效
}
}
公共课A：课堂
{
//没有号码
}
公共类B类：类
{
公共类别B（）
{
number=1；//将不编译
}
}
公共类C类：类
{
公共类别c（）
{
number=ClassA.number；//将不编译
}
}

如果希望静态变量仅可供某些子体访问，而不可供其他子体访问，请在继承链中需要访问的第一个类中定义该变量：

public abstract class Class<T>
{
}

public class ClassA : Class<ClassA>
{
    static private int number = 7;
}

public class ClassB : Class<ClassB>
{
    static private int number = 7;

    public ClassB()
    {
        ClassA.number = 5;  //Does not compile
        ClassB.number = 6;
    }
}

public class ClassC : Class<ClassC>
{
    static private int number = 7;

    public ClassC()
    {
        Console.WriteLine(ClassA.number);  //Does not compile
        Console.WriteLine(ClassB.number);  //Does not compile
        Console.WriteLine(ClassC.number);  //Compiles
    }
}

公共抽象类
{
}
公共课A：课堂
{
静态私有整数=7；
}
公共类B类：类
{
静态私有整数=7；
公共类别B（）
{
ClassA.number=5；//不编译
类别b.编号=6；
}
}
公共类C类：类
{
静态私有整数=7；
公共类别c（）
{
Console.WriteLine（ClassA.number）；//不编译
Console.WriteLine（ClassB.number）；//不编译
Console.WriteLine（ClassC.number）；//编译
}
}

您不能在祖先类中定义某个对象并将其从后代中删除

当使用泛型时，我不喜欢从继承相同基类的其他类访问“number”。有办法解决这个问题吗

唯一真正的解决方法是为每个类声明单独的

私有静态

变量。这将使您无法从任何其他类类型中看到一个类类型中的数字变量

public abstract class Class<T>
{
    private static int number = 5;

    public void Print()
    {
        Console.WriteLine(number);
    }
}

public class ClassA : Class<ClassA>
{
}

public class ClassB : Class<ClassB>
{
    private static int number;

    public ClassB()
    {
        number = 1;
    }
}

public class ClassC : Class<ClassC>
{
    private static int number;

    public ClassC()
    {
        number = 123; // Cannot see ClassA.number because it is private to `Class<T>`
    }
}

公共抽象类
{
私有静态整数=5；
公开作废印刷品（）
{
控制台写入线（编号）；
}
}
公共课A：课堂
{
}
公共类B类：类
{
私有静态整数；
公共类别B（）
{
数字=1；
}
}
公共类C类：类
{
私有静态整数；
公共类别c（）
{
number=123；//无法看到ClassA.number，因为它是`类'的私有`
}
}

副作用是由于声明变量

protectedstatic

并将其与继承一起使用而引起的。当您所追求的行为是

私有静态

字段时，不清楚您为什么会尝试这样做

当使用泛型时，我不喜欢从继承相同基类的其他类访问“number”。有办法解决这个问题吗

唯一真正的解决方法是为每个类声明单独的

私有静态

变量。这将使您无法从任何其他类类型中看到一个类类型中的数字变量

public abstract class Class<T>
{
    private static int number = 5;

    public void Print()
    {
        Console.WriteLine(number);
    }
}

public class ClassA : Class<ClassA>
{
}

public class ClassB : Class<ClassB>
{
    private static int number;

    public ClassB()
    {
        number = 1;
    }
}

public class ClassC : Class<ClassC>
{
    private static int number;

    public ClassC()
    {
        number = 123; // Cannot see ClassA.number because it is private to `Class<T>`
    }
}

公共抽象类
{
私有静态整数=5；
公开作废印刷品（）
{
控制台写入线（编号）；
}
}
公共课A：课堂
{
}
公共类B类：类
{
私有静态整数；
公共类别B（）
{
数字=1；
}
}
公共类C类：类
{
私有静态整数；
公共类别c（）
{
number=123；//无法看到ClassA.number，因为它是`类'的私有`
}
}