Constructor with too many arguments [closed]

Question

We have a Transaction class that's very loaded; so loaded that I originally ended up passing almost 20 argument to the ctor. After extracting a few value objects, there are still 12 arguments left, which I still think is too much.

How would I go at avoiding this? I think it's reasonable the arguments are passed to the constructor since they're all required, and I want to make that explicit. I also like how if I add a property, I can add it to the ctor and let my compiler find the places it broke, instead of having to rely on tests for this per se. I don't think object initializers, or builders do the problem any good. It might become more obvious in the next coming days which arguments belong together, and could be composed.

public class MyEntity() 
{
    public MyEntity(ValueType prop2, ValueType prop3, ...) 
    {
        Id = Guid.NewGuid();
        Prop2 = prop2;
        Prop3 = prop3;
        ...
    }

    public Guid Id { get; private set; }

    public ValueType Prop2 { get; private set; }

    public ValueType Prop3 { get; private set; }

    public ...
}

Answer 1

It's hard to help without knowing more about your code and why do you have so many parameters.

Here are some possible reasons for many parameters and how would you fix that:

1. Your class is doing too much, it violates the single responsibility principle. You should split it into multiple classes, each with smaller number of arguments.
2. You're using some of the parameters only to construct some other object. You should have that object directly as a parameter. Dependency injection could help you with this.
3. The parameter types are badly designed, maybe some of them should be combined into a single type.

Answer 2

I would suggest you use the Builder Pattern for this. This allows you to first instanciate a builder which is essentially a container for all your constructor arguments. The builder would be an inner class of MyEntity and would have setter methods for the different parameters. This has the advantage that you get descriptive names for passing your parameters. Also, should some parameters have sensible defaults, you can still make them optional.

MyEntity entityBuilder = MyEntity.newBuilder()
    .setProp1(someProp1)
    .setProp2(someProp2)
    .build()

The build() method could throw some exception if the combination of parameters is nonsensical, for instance if there is a missing parameter.