Best practice and is there a difference?

  • Thread starter Thread starter Jim H
  • Start date Start date
J

Jim H

When creating member objects in a C# class what's the difference between
initializing the member where it's defined and using a constructor. Is
there a best practice for this. I come from a C/C++ background and like
constructors, but I don't know if there is a performance and/or readability
preference in C#. This is for basic classes and not classes where the
constructor takes arguments.


example:

public class A
{
private String string1;
private int number1;
private List<String> bigList;

public A()
{
string1 = String.Empty;
number1 = 16;
bigList = new List<String>();
}
}

or

public class A
{
private String string1 = String.Empty;
private int number1 = 16;
private List<String> bigList = new List<String>();

}



Side question: Do the new preoperty defs with anonymous members need to be
initialized manually or in the constructor, or does it happen automatically?

example:
public class A
{
public String FileName { get; set; }
}
 
When creating member objects in a C# class what's the difference between
initializing the member where it's defined and using a constructor. Is
there a best practice for this. I come from a C/C++ background and like
constructors, but I don't know if there is a performance and/or
readability preference in C#. This is for basic classes and not classes
where the constructor takes arguments.
Click to expand...

I go back and forth on this one myself. Most of the time I initialize in the
declaration, but sometimes I do it in the constructor. Most of the time that
I do it in the constructor is when I have lists or dictionaries that I'm
going to fill during construction. "One-off" variables (especially value
types) I almost never do in the constructor. But that's just my preference.
Side question: Do the new preoperty defs with anonymous members need to be
initialized manually or in the constructor, or does it happen
automatically?

example:
public class A
{
public String FileName { get; set; }
}
Click to expand...

Every private member variable (including the hidden ones created for
automatic properties) is initialized to its default value automatically.
Numerics get 0, reference types get null, etc.
 
Jim said:
When creating member objects in a C# class what's the difference between
initializing the member where it's defined and using a constructor.
Click to expand...

None, except for the order in which fields are initialized. If the order
matters, use a constructor and be explicit, because you're setting yourself
up for a maintenance problem otherwise. Fields are initialized in the order
they are declared, but people would expect to be able to move the
declarations around without this causing problems.
Is there a best practice for this. I come from a C/C++ background and
like constructors, but I don't know if there is a performance and/or
readability preference in C#.
Click to expand...

There is no performance benefit either way, and readability isn't part of
the language, so use whatever you think is best.
Side question: Do the new preoperty defs with anonymous members need to be
initialized manually or in the constructor, or does it happen automatically?
Click to expand...
Automatically. An automatic property is just a property with an implicit
backing field. Functionally it's no different from a regular property, and
unlike C++, there is no such thing as an uninitialized field in C#. In some
scenarios your initialization may not have run yet, but there's always
default initialization.
public class A
{
public String FileName { get; set; }
}
Click to expand...
The (implicitly named) backing field of FileName will be initialized to null.
 
When creating member objects in a C# class what's the difference
between initializing the member where it's defined and using a
constructor. Is there a best practice for this. I come from a C/C++
background and like constructors, but I don't know if there is a
performance and/or readability preference in C#. This is for basic
classes and not classes where the constructor takes arguments.


example:

public class A
{
private String string1;
private int number1;
private List<String> bigList;

public A()
{
string1 = String.Empty;
number1 = 16;
bigList = new List<String>();
}
}

or

public class A
{
private String string1 = String.Empty;
private int number1 = 16;
private List<String> bigList = new List<String>();

}



Side question: Do the new preoperty defs with anonymous members need
to be initialized manually or in the constructor, or does it happen
automatically?

example:
public class A
{
public String FileName { get; set; }
}
Click to expand...

Here is my take on it, fwiw. Barring special needs (always have to have
the disclaimer...), If a members value doesn't depend upon parameters
passed to the constructor, I go ahead and initialize them where it is
defined. Since all objects in C++ have to be new-ed to exist, this
works out to be similar to the default constructor in C++. For members
which take on values based upon parameters, I initialize them in the
constructor. So, I might have...

public class A
{
private List<string> myStrings = new List<string>();
private ExternalState myExternalState;

A(ExternalState externalState)
{
myExternalState = externalState;
myStrings.Add("one");
}
}

In the above case, while I create the list at the member declaration, I
still have to add elements to it in the constructor (just as you would
in C++).

So, in short, I use member declaration initialization to take the place
of default construction and otherwise put things into the constructor.

joe
 
Jeroen said:
None, except for the order in which fields are initialized. If the order
matters, use a constructor and be explicit, because you're setting
yourself up for a maintenance problem otherwise. Fields are initialized
in the order they are declared, but people would expect to be able to
move the declarations around without this causing problems.
Click to expand...

I very strongly agree with this.

Initialization in constructor gives a clear sequential flow
that should be obvious to any reader.

Arne
 
Back
Top