c#在派生类之外使用公共静态属性

我是C#的初学者。我想做以下工作：

在名称空间nA中有类A，我需要在名称空间nB中实现类B，它继承了A的所有内容并添加了一些功能，这很好

在ProjectA中，我有：

namespace nA{
    public abstract class A{
        public const int a = 1;
    }
}

在ProjectB t中，我有：

using ProjectA.nA;
namespace nB{
    class abstract B : A{
        public const int b = 2; 
    }
}

在ProjectC中，我有

using ProjectB.nB;
namespace nC{
    class C{
        void someMethod(){
            int valueA = B.a //error, nB.B does not contain a definition for 'a'
            int valueB = B.b //works just fine
        }
    }
}

---

常量和静态成员总是通过实际定义它们的类来访问<代码>A.A将起作用。还请注意，它可以从任何类访问，而不仅仅是从继承器访问。

常量和静态成员总是通过实际定义它们的类访问<代码>A.A将起作用。还请注意，它可以从任何类访问，而不仅仅是从继承器访问。

常量和静态成员总是通过实际定义它们的类访问<代码>A.A将起作用。还请注意，它可以从任何类访问，而不仅仅是从继承器访问。

常量和静态成员总是通过实际定义它们的类访问<代码>A.A将起作用。还请注意，它可以从任何类访问，而不仅仅是从继承器访问。

在project B write中：

using ProjectA.nA;
namespace nB{
    class abstract B : A{
        public const int a = A.a; 
        public const int b = 2; 
    }
}

然后项目C应该编译。或者可以这样做：

using ProjectB.nB;
namespace nC{
    class C{
        void someMethod(){
            int valueA = ProjectA.nA.a;
            int valueB = B.b;
        }
    }
}

因为ProjectC必须参考ProjectA

这里更好的教训是从关注点分离的角度来思考。如果类C不应该直接知道类A，那么它现在也不应该知道类A定义的常量。相反，在B中应该有一些使用常量的功能，并且对于类B试图完成的任务是有意义的。因此，B类所关心的是什么，它使用了A类并提供了这种适当的分离。

在项目B中写道：

using ProjectA.nA;
namespace nB{
    class abstract B : A{
        public const int a = A.a; 
        public const int b = 2; 
    }
}

然后项目C应该编译。或者可以这样做：

using ProjectB.nB;
namespace nC{
    class C{
        void someMethod(){
            int valueA = ProjectA.nA.a;
            int valueB = B.b;
        }
    }
}

因为ProjectC必须参考ProjectA

这里更好的教训是从关注点分离的角度来思考。如果类C不应该直接知道类A，那么它现在也不应该知道类A定义的常量。相反，在B中应该有一些使用常量的功能，并且对于类B试图完成的任务是有意义的。因此，B类所关心的是什么，它使用了A类并提供了这种适当的分离。

在项目B中写道：

using ProjectA.nA;
namespace nB{
    class abstract B : A{
        public const int a = A.a; 
        public const int b = 2; 
    }
}

然后项目C应该编译。或者可以这样做：

using ProjectB.nB;
namespace nC{
    class C{
        void someMethod(){
            int valueA = ProjectA.nA.a;
            int valueB = B.b;
        }
    }
}

因为ProjectC必须参考ProjectA

这里更好的教训是从关注点分离的角度来思考。如果类C不应该直接知道类A，那么它现在也不应该知道类A定义的常量。相反，在B中应该有一些使用常量的功能，并且对于类B试图完成的任务是有意义的。因此，B类所关心的是什么，它使用了A类并提供了这种适当的分离。

在项目B中写道：

using ProjectA.nA;
namespace nB{
    class abstract B : A{
        public const int a = A.a; 
        public const int b = 2; 
    }
}

然后项目C应该编译。或者可以这样做：

using ProjectB.nB;
namespace nC{
    class C{
        void someMethod(){
            int valueA = ProjectA.nA.a;
            int valueB = B.b;
        }
    }
}

因为ProjectC必须参考ProjectA

---

---

这里更好的教训是从关注点分离的角度来思考。如果类C不应该直接知道类A，那么它现在也不应该知道类A定义的常量。相反，在B中应该有一些使用常量的功能，并且对于类B试图完成的任务是有意义的。因此，类B所关心的是使用类A并提供这种适当分离的对象。

既然它应该工作，我建议您检查您的项目中是否缺少任何程序集引用。

既然它应该工作，我建议您检查项目中是否缺少任何程序集引用。

因为它应该可以工作，我建议您检查项目中是否缺少任何程序集引用。

因为它应该工作，我建议您检查项目中是否缺少任何程序集引用。

此行应为：

int valueA=A.A

。始终按静态成员的类名而不是派生类名引用静态成员。这包括常量。您可能还需要使用ProjectA.nA包含

在项目C中，但我不是100%确定。你试过了吗？这是一个限制，我不能将项目a包含在项目C中。对不起，我没有指定。这是一个奇怪的限制。但是您可以添加
public const int a=a.a到B类。你真正想要实现什么？似乎是缺乏实际使用背景的任意需要和限制。@Maluchi从
A
中“继承”常量对
B
没有意义，因为
B
永远不能被视为
A
，只有
B
的实例才能被视为
A
的实例。这里没有涉及实例对象，该类只是充当常量的名称空间。如果您想将所有常量列在一起，为什么不将它们放在第四个类中，
a
、
B
和
C
三个类都可以访问
A
仍然不需要“知道”只有
B
使用的常量。此行应该是：
int valueA=A.A
。始终按静态成员的类名而不是派生类名引用静态成员。这包括常量。您可能还需要使用ProjectA.nA包含
在项目C中，但我不是100%确定。你试过了吗？这是一个限制，我不能将项目a包含在项目C中。对不起，我没有指定。这是一个奇怪的限制。但是您可以添加
public const int a=a.a到B类。你真正想要实现什么？似乎是缺乏实际使用背景的任意需要和限制。@Maluchi从
A
中“继承”常量对
B
没有意义，因为
B
永远不能被视为
A
，只有
B
的实例才能被视为
A
的实例。这里没有涉及实例对象，该类只是充当常量的名称空间。如果你想把所有常数都列出来