Const vs protected static readonly

Question

I've got a wrapper class which encapsulates a piece of information that needs to be transmitted as a byte array.

In that way, the class encapsulates the necessary header (with fields like DATA_LENGTH or MESSAGE_TYPE) into the corresponding byte positions. For that I want to define positions and length in constants, for example:

HEADER_DATA_LENGTH_IX = 0;
HEADER_DATA_LENGTH_LENGTH = 2;

which means DATA_LENGTH starts at 0 and takes two bytes.

but so far I'm struggling with making them constants or static readonly fields. Const cannot be protected, therefore I won't be able to derive a new class and change the constants if a use them, on the other way I might declare new constants in the derived class and the use them.

What will be your approach?

Answer 1

If you want to change the value of these params in a derived class, you can make them readonly and change them in the constructor of the derived class

I wouldn't make them const anyhow, because they're not...

Answer 2

The basic difference is when the variable is initialized. 'readonly' is set at initialization, or in the contructor, while 'const' is set at compile time.

I think the big decision is if you want to inherit the class and override the value. If you do, go readonly. Otherwise I don't think it really matters.

readonly C#ref: http://msdn.microsoft.com/en-us/library/acdd6hb7.aspx

const C# ref: http://msdn.microsoft.com/en-us/library/e6w8fe1b.aspx

Answer 3

这个确切的问题由msdn上的官方c＃faq回答

Answer 4

I wouldn't make these constant because they simply aren't constants. When declaring something as const you should ask yourself: can this change? Your message lengths might change one day, so they are better to be made readonly.

Answer 5

Create an inner class with the constants. The deriving classes can then later override the inner class and change the constants as necessary.

eg base class:

public class Stuff
{
  public class HeaderInformation
  {
    public const int HEADER_DATA_LENGTH_IX = 0;
    public const int  HEADER_DATA_LENGTH_LENGTH = 2;
  }
}

Then the derived class can do this:

public class DerivedStuff : Stuff
{
  public new class HeaderInformation : Stuff.HeaderInformation
  {
    public new const int HEADER_DATA_LENGTH_IX = 10;
  }
}

This way, you have flexibility. In DerivedStuff , the HeaderInformation class has all of the constants in the base Stuff.HeaderInformation class, but can change any of them, or keep the ones it has.