Instantiation: Moving a List into the Arguments

Question

I'm new to C# and have been struggling to find an idiomatic way to initialize a list within a constructor.

Related questions that don't quite solve the issue:

• How to initialize a list with constructor?
• Initializing lists in a constructor.

This works, but with a flaw:

class Datapoint
{
    public bool Debug { get; set; }
    public string Pattern { get; private set; }

    // I would prefer to initialize this list in the constructor
    public List<Dictionary<string, dynamic>> operations = 
            new List<Dictionary<string, dynamic>>();

    // constructor
    public Datapoint(bool debug = false, 
                string pattern = ""
                // I would prefer operations to go here 
                // but the following doesn't work:
                // List<Dictionary<string, dynamic>> operations = 
                //     new List<Dictionary<string, dynamic>>()
                ) 
    {
        Debug = debug;
        Pattern = pattern;
    }
}


// Let's define some Datapoints
class Definitions 
{
    public static Datapoint turtles = new Datapoint
    (
        pattern: @"turtle pattern",
        // I would prefer operations to go here
    )
    {
        operations =
                { new Dictionary<string, dynamic>
                    {
                        ["func"] = "stitch_lines"
                    }
                }
    };
}

The flaw is that I cannot set operations as private, otherwise I get an error when creating turtles.

Ideally I would like operations to be a parameter of the constructor, but I am missing something as every combination I try yields this error:

Default parameter value for operations must be a compile-time constant.

Thanks in advance for any insights.

Answer 1

You can take in a null and then check for it in your constructor:

public Datapoint(
    bool debug = false, 
    string pattern = "",
    List<Dictionary<string, dynamic>> operations = null
)
{
    Debug = debug;
    Pattern = pattern;
    this.operations = operations ?? new List<Dictionary<string, dynamic>>();
}

However, see the comments of D Stanley's answer for a discussion of drawbacks in the general case.

Answer 2

As the error indicates, default values must be compile-time constants. I would do this as two overloads:

// constructor
public Datapoint(bool debug = false, 
            string pattern = "")
{
    Debug = debug;
    Pattern = pattern;

    operations = new List<Dictionary<string, dynamic>>();
}

public Datapoint(List<Dictionary<string, dynamic>> operations,
            bool debug = false, 
            string pattern = "")
{
    Debug = debug;
    Pattern = pattern;

    this.operations = operations;
}

Note that you need to reorder the parameters in the second overload since optional parameters must go at the end of the parameter list.

Answer 3

Avoid using optional parameters this way

//constructor
public Datapoint(
    bool debug = false, //dangerous
    string pattern = "",//dangerous
    List<Dictionary<string, dynamic>> operations = null
)

Instead use:

//constructor
public Datapoint(
    bool? debug = null, 
    string pattern = null,
    List<Dictionary<string, dynamic>> operations = null
)
{
    Debug = debug.HasValue && debug.Value;
    Pattern = pattern;
    this.operations = (operations == null) ? 
              new List<Dictionary<string, dynamic>>() 
              : operations ;
}

Source: C# In Depth – Optional Parameters and Named Arguments