Member Variable Initialization in C#: Declaration or Constructor – Which is Better?

Member variable initialization in C#: declaration or constructor?

In object-oriented programming using C#, a common question is whether class member variables should be initialized when declared, or in the default constructor. This article explores the pros and cons of both approaches.

Performance Considerations

In terms of performance, there is almost no difference between initializing member variables at declaration time and initializing them in the constructor. Field initializers are actually converted to constructor logic during compilation. However, field initializers execute before any constructor logic, including the execution of the base constructor or this constructor.

Auto-implemented properties

For auto-implemented properties, the constructor approach is preferable because auto-implemented properties cannot be initialized using field initializers. For example:

<code class="language-csharp">[DefaultValue("")]
public string Foo { get; set; }
public Bar()
{
  Foo = "";
}</code>

Locality and organization

Many developers prefer field initializers because they keep related code localized. For example, declaring a private list of items using a field initializer makes the list and its accessor properties more independent:

<code class="language-csharp">private readonly List<SomeClass> items = new List<SomeClass>();
public List<SomeClass> Items { get { return items; } }</code>

This approach reduces the need to search through multiple code segments to find where member variables are assigned values.

Complex initialization and constructor overloading

However, when complex initialization logic is required or when handling multiple constructors, constructors are the preferred method. For example, when initializing the Bar class, consider the following constructor:

<code class="language-csharp">public Bar() : this("") {}
public Bar(string foo) { Foo = foo; }</code>

In this case, field Foo can be initialized to different values ​​depending on which constructor is called, while the field initializer sets it to the same value for all constructors.

Conclusion

Whether to initialize member variables at declaration time or in the constructor ultimately depends on the specific needs of the code. For simplicity and locality, field initializers are usually preferable. However, for automatically implemented properties, complex initialization logic, or handling multiple constructors, constructor-based initialization is recommended.

The above is the detailed content of Member Variable Initialization in C#: Declaration or Constructor – Which is Better?. For more information, please follow other related articles on the PHP Chinese website!