[C # advanced series] 07 constants and fields,

[C # advanced series] 07 constants and fields,

Constant

Constants are always regarded as static members.

Constants can be not limited to primitive types, but must be initialized to null. (I think this is the same as what I do not know. I have automatically ignored it from my mind. Many times, in my eyes, there is no difference between difficult code and junk code. I hate to have simple and easy-to-understand solutions. programmers who have to dazzle some uncommon and useless technologies always like to use this method to make my brother unable to get off work on time)

During compilation, the constant values are directly extracted and embedded into the IL code. Therefore, no space needs to be allocated during runtime.

Field

Previously, we have discussed that CLR supports static fields and instance fields.

Static fields are placed in the type object. The type object is created when the type is loaded to an AppDomain (usually any method that references this type is used for JIT compilation for the first time ),

The instance field is placed in the instance object.

In addition to the default instance field and static field, the modifier of the field also has readonly to indicate read-only fields.

As we all know, read-only fields can only be written to or initialized inline by one constructor method (that is, values are directly assigned when declared in the Code, rather than using constructor ).

In fact, inline initialization uses a constructor to initialize fields. inline Initialization is just a syntax simplification. (In fact, there are still some performance issues to consider during inline initialization. Write it in the next chapter)

Of course, there are other ways to do this. For example, if you use reflection, it is a pity to modify the readonly field.

There is also a modifier that is rarely used, volatile (the document is translated as variable and the author expresses it as variable, because this field can be modified by multiple threads). To be honest, I did not know such a modifier before I read this book. ⊙ ‖ ↓

When a field is modified with volatile, the compiler, CLR, and hardware will not perform "thread-unsafe" optimization measures on the code accessing this field. (This is mentioned in the thread synchronization behind this book. I haven't seen it yet. Please write it later)