引用本文:

This is actually by design. There seems to be no good reason to inherit a static class. It has public static members that you can always access via the class name itself. The only reasons I have seen for inheriting static stuff have been bad ones, such as saving a couple of characters of typing. There may be reason to consider mechanisms to bring static members directly into scope (and we will in fact consider this after the Orcas product cycle), but static class inheritance is not the way to go: It is the wrong mechanism to use, and works only for static members that happen to reside in a static class. (Mads Torgersen, C# Language PM)

来自9频道的其他观点

Inheritance in .NET works only on instance base. Static methods are defined on the type level not on the instance level. That is why overriding doesn't work with static methods/properties/events... Static methods are only held once in memory. There is no virtual table etc. that is created for them. If you invoke an instance method in .NET, you always give it the current instance. This is hidden by the .NET runtime, but it happens. Each instance method has as first argument a pointer (reference) to the object that the method is run on. This doesn't happen with static methods (as they are defined on type level). How should the compiler decide to select the method to invoke? (littleguru)

作为一个有价值的想法，littleuru对这个问题有一个部分的“变通方案”:单例模式。

你可以用合成代替…这将允许您从静态类型访问类对象。但仍然不能实现接口或抽象类

我的回答是:糟糕的设计选择。: -)

这是一场关于语法影响的有趣辩论。在我看来，争论的核心是一个设计决策导致了密封的静态类。关注静态类的名称出现在顶层的透明度，而不是隐藏在子名称后面(“混乱”)?人们可以想象语言实现可以直接访问基类或子类，这很令人困惑。

这是一个伪示例，假设以某种方式定义了静态继承。

public static class MyStaticBase
{
    SomeType AttributeBase;
}

public static class MyStaticChild : MyStaticBase
{
    SomeType AttributeChild;
}

会导致:

 // ...
 DoSomethingTo(MyStaticBase.AttributeBase);
// ...

哪个可能(会?)影响相同的存储

// ...
DoSomethingTo(MyStaticChild.AttributeBase);
// ...

很困惑!

但是等等!编译器如何处理MyStaticBase和MyStaticChild在两者中定义了相同的签名?如果子覆盖比我上面的例子不会改变相同的存储，也许?这导致了更多的困惑。

我相信有限的静态继承有很强的信息空间理由。稍后会详细介绍极限。这个伪代码显示了以下值:

public static class MyStaticBase<T>
{
   public static T Payload;
   public static void Load(StorageSpecs);
   public static void Save(StorageSpecs);
   public static SomeType AttributeBase
   public static SomeType MethodBase(){/*...*/};
}

然后你会得到:

public static class MyStaticChild : MyStaticBase<MyChildPlayloadType>
{
   public static SomeType AttributeChild;
   public static SomeType SomeChildMethod(){/*...*/};
   // No need to create the PlayLoad, Load(), and Save().
   // You, 'should' be prevented from creating them, more on this in a sec...
} 

用法如下:

// ...
MyStaticChild.Load(FileNamePath);
MyStaticChild.Save(FileNamePath);
doSomeThing(MyStaticChild.Payload.Attribute);
doSomething(MyStaticChild.AttributeBase);
doSomeThing(MyStaticChild.AttributeChild);
// ...

创建静态子对象的人不需要考虑序列化过程，只要他们了解平台或环境的序列化引擎上可能存在的任何限制。

静态变量(单例和其他形式的“全局变量”)经常出现在配置存储中。静态继承将允许这种职责分配在语法中清晰地表示，以匹配配置的层次结构。但是，正如我所指出的，如果实现基本的静态继承概念，就有可能产生大量的歧义。

我相信正确的设计选择是允许静态继承，但有特定的限制:

没有重写任何东西。子元素不能替换基底元素 属性、字段或方法…重载应该是可以的 只要有不同的签名允许编译器 整理出child和base。 只允许通用静态基，不能继承 非通用静态基。

您仍然可以通过通用引用MyStaticBase<ChildPayload>. somebasefield来更改相同的存储。但是您可能会感到气馁，因为必须指定泛型类型。而子引用会更干净:MyStaticChild.SomeBaseField。

我不是编译器的作者，所以我不确定我是否忽略了在编译器中实现这些限制的困难。也就是说，我坚信有限的静态继承需要信息空间，基本的答案是你不能因为糟糕的(或过于简单的)设计选择。

静态类和类成员用于创建可以在不创建类实例的情况下访问的数据和函数。静态类成员可用于分离独立于任何对象标识的数据和行为:无论对象发生了什么，数据和函数都不会改变。当类中没有依赖于对象标识的数据或行为时，可以使用静态类。

类可以声明为静态的，这表明它只包含静态成员。不能使用new关键字创建静态类的实例。当包含静态类的程序或命名空间被加载时，由. net Framework公共语言运行库(CLR)自动加载静态类。

使用静态类来包含与特定对象不关联的方法。例如，通常需要创建一组不作用于实例数据且与代码中的特定对象不关联的方法。您可以使用静态类来保存这些方法。

以下是静态类的主要特性:

它们只包含静态成员。 它们不能被实例化。 它们是密封的。 它们不能包含实例构造函数(c#编程指南)。

因此，创建静态类基本上与创建只包含静态成员和私有构造函数的类相同。私有构造函数阻止类被实例化。

使用静态类的好处是编译器可以检查以确保没有意外添加实例成员。编译器将保证不能创建该类的实例。

静态类是密封的，因此不能被继承。它们不能从Object以外的任何类继承。静态类不能包含实例构造函数;但是，它们可以有一个静态构造函数。要了解更多信息，请参阅静态构造函数(c#编程指南)。

当我试图对第三方库编写IComparer<T>实现时，我遇到了这个问题，其中T是嵌入在类中的enum，如下所示:

public class TheClass
{
    public enum EnumOfInterest
    {
    }
}

但是因为枚举是在第三方库类中定义的，所以我不能编写比较器，因为下面给出了“不能扩展列表”错误:

public class MyComparer : IComparer<TheClass.EnumOfInterest>
{
}

我甚至没有扩展静态类——我只是实现类中定义的枚举的比较器。

当创建只包含静态成员和私有构造函数的静态类时。唯一的原因是静态构造函数阻止类被实例化，因为我们不能继承静态类。访问静态类成员的唯一方法是使用类名本身。试图继承静态类并不是一个好主意。