How do you create immutable objects with many parameters?

Question

I need to create an immutable object but it requires several parameters to work like:

class FooRepo
{
    public string ConnectionStringName { get; }
    public string SchemaName { get; }
    public string TableName { get; }
    public Dictionary<string, int> ColumnLengths { get; }
    public Dictionary<Type, SqlDbType> TypeMappings { get; }

    // some queries...
    public IEnumerable<string> GetStrings(object param1) { ... }
}

I find there are too many parameters to pass them all via the constructor (I might add more later).

The idea of locking the object after it's been setup doesn't sound good either.

I thought about creating a FooBuilder but this would only hide a huge constructor.

The only resonable solution I can think of is to define default values for some properties like ColumnLengths and TypeMappings and allow the user to override/customize them by deriving from the original class.

What would you say? Or maybe there are better ways for such a task?

Answer 1

Assumed your class is not "too large" (which you should check first), instead of having a huge constructor argument list in FooRepo, you can pass the values in by utilizing a mutable DTO object as a form of "helper object". This might be a class FooRepoDTO, or when you follow the builder pattern, it could be the FooRepoBuilder itself (which must provide access to all the data passed in by the "Set..." methods.

Answer 2

You pass them in via the constructor. If that means your constructor is too large, then maybe your giant class shouldn't be so giant.

There are very few things in the world that have 5+ independent, but cohesive elements.

Answer 3

OK, I think I got it but it's a little bit different then the origial builder pattern. If the builder is nested inside the immutable object it then can still access its properties and set them even if they remain private to the actual object:

class Foo
{
    public Foo() {} 

    public string Bar { get; private set; }

    public string Qux { get; }

    public class Builder
    {
        private Foo _foo = new Foo();
        private Builder() {}

        public static Builder Create() 
        {
            return new Builder();
        }

        public Builder Bar(string bar) 
        {
            _foo.Bar = bar;
            return this;
        }

        public Foo ToFoo()
        {
            return new Foo() 
            {
                Bar = _foo.Bar
            };
        }
    }
}

Usage:

var foo = Foo.Builder.Create().Bar("baz").ToFoo();
var bar = foo.Bar;