具有下限和上限的C ++数组定义？(C++ Array Definition with Lower and Upper Bound?)

 因为，一般来说，这将是合理的建议。 如果您在基础实现中更改某些内容，则调用base将确保一切都能继续工作。 
 
 编译器与您没有相同的知识。 你知道没有必要调用base，编译器没有。 编译器确实知道你正在做的事情并不违法，所以它只是发出一个警告，告诉你有一些代码可能需要你注意（并且警告总是引起你的注意）。 
 
 如果这真的是你想要的，请禁止警告，但我个人会调用基础构造函数，就像编译器建议的那样。 
 
 你现在在做什么并没有错。 它是完全有效的C＃代码，但编译器决定发出警告，因为它“知道”（为简单起见）关于如何通常实现ISerializable与序列化构造函数的组合。 
 
 假设在下一次迭代中， BaseClass添加了自己的一些属性，即Foo属性，并假设我们希望该属性（de-）序列化。 您可能会在BaseClass（SerializationInfo，StreamingContext）构造函数中实现反序列化所需的代码 
 
public class BaseClass : AbstractBaseClass, ISerializable
{
    public int Foo { get; set; }

    protected BaseClass(SerializationInfo info, StreamingContext context)
        : base(info, context)
    {
        // ...
        Foo = info.GetInt32("Foo");
        // ...
  }
}
 
 在当前的设置中，当反序列化FinalClass ，BaseClass的Foo属性不会反序列化，因为您决定调用this(string fileName, string password)构造函数，而不是base(SerializationInfo, StreamingContext)构造函数。 这就是这个警告的全部情况。 该设置不是未来证明，并且在将来也应该在构造函数中反序列BaseClass任何对AbstractBaseClass或BaseClass添加将在您当前的实现中不被反序列化。 
 
 所以是的，你可以说当前的实现是一个设计错误，虽然我可能更可能称之为设计的错误实现。 

Because, in general, that would be sound advice. Should you ever change something in the base implementation, calling base would ensure that everything will keep working. 
 
The compiler doesn't have the same knowledge as you. You know it's not necessary to call base, the compiler doesn't. The compiler does know that it's not illegal what you're doing, so it just emits a warning, telling you that there's some code that might require your attention (and warnings always should get your attention). 
 
If this is really what you want, suppress the warning, but I personally would call the base constructor, just like the compiler suggests.
 
What you are doing now is not wrong perse. It's perfectly valid C# code, but the compiler decided to issue a warning because it "knows" (for simplicity's sake) about how ISerializable in combination with a serialization constructor is usually implemented.
 
Let's say in a next iteration BaseClass adds some property of its own, the Foo property, and assume that we want that property (de-)serialized. You would probably implement the necessary code for deserialization in the BaseClass(SerializationInfo, StreamingContext) constructor
 
public class BaseClass : AbstractBaseClass, ISerializable
{
    public int Foo { get; set; }

    protected BaseClass(SerializationInfo info, StreamingContext context)
        : base(info, context)
    {
        // ...
        Foo = info.GetInt32("Foo");
        // ...
  }
}
 
In your current setup, when deserializing FinalClass, the Foo property of BaseClass would not be deserialized, since you decided to call the this(string fileName, string password) constructor, instead of base(SerializationInfo, StreamingContext) constructor. And that's the scenario that this warning is all about. The setup is not future proof, and any addition to either AbstractBaseClass or BaseClass in the future that should also be deserialized in the constructor will in your current implementation not be deserialized.
 
So yes, you could say that the current implementation is a design mistake, although I would probably more likely call it a wrong implementation of the design.