C# code survey

[Lost User]

The same still applies; anything that is required should be there in the constructor. If it is not required for the objects existence, then it becomes a property. For a DTO, I'd expect an Id-field, and without an Id such object should not exist.

Bastard Programmer from Hell :suss: If you can't read my code, try converting it here[^] "If you just follow the bacon Eddy, wherever it leads you, then you won't have to think about politics." -- Some Bell.

[Marc Clifton]

Neither. It shouldn't be the responsiblity of MyFooClass to return a FooDto, it should be FooDto's class to take a MyFooClass and convert it to a FooDto. So you have instead:

public class FooDto
{
public static FooDto From(MyFooClass c)
{
// ...mapping...
}
}

And to make this more re-usable for different data objects and to avoid repeating From for every type of "from - to" conversion, use interfaces:

public class FooDto : IFooDto
{
public static IFooDto From(IFooClass c)
{
// ...mapping...
}
}

This promotes consistency between properties in FooDto and properties in the "from" class that can be mapped to FooDto.

Latest Article - A Concise Overview of Threads Learning to code with python is like learning to swim with those little arm floaties. It gives you undeserved confidence and will eventually drown you. - DangerBunny Artificial intelligence is the only remedy for natural stupidity. - CDP1802

[Dan Neely]

Of the two choices given, I'd take 1; but would prefer a third option.:

public class FooDto
{
public FooDto(MyFooClass foo)
{
Property1 = foo.property1;
// .....
Property24 = foo.property24;
}

public T1 Property1 { get; }
// ....
public T24 Property24 { get; }
}
// ....
class MyFooClass
{
private T1 property1;
// ....
private T24 property24;
}

If for some reason I

Did you ever see history portrayed as an old man with a wise brow and pulseless heart, weighing all things in the balance of reason? Is not rather the genius of history like an eternal, imploring maiden, full of fire, with a burning heart and flaming soul, humanly warm and humanly beautiful? --Zachris Topelius Training a telescope on one’s own belly button will only reveal lint. You like that? You go right on staring at it. I prefer looking at galaxies. -- Sarah Hoyt

[Foothill]

If you really want to bake their noodle, put all the value maps in Attributes and then have the object built via Reflection such as in this article[^]. It's a super complicated way to do simple tasks :laugh:

if (Object.DividedByZero == true) { Universe.Implode(); }

[realJSOP]

Of course, using reasonable defaults would prevent you from having runaway parameter lists for your constructors, and all you have to do is set the properties that need to be changed.

".45 ACP - because shooting twice is just silly" - JSOP, 2010
-----
You can never have too much ammo - unless you're swimming, or on fire. - JSOP, 2010
-----
When you pry the gun from my cold dead hands, be careful - the barrel will be very hot. - JSOP, 2013

[Gary Wheeler]

public class Foo
{
public class DTO
{
public T1 P1 { set; get; } = P1_default_value;
...
public T24 P24 { set; get; } = P24_default_value;
}

public void In(DTO dto)
{
// Set _P* from dto.P*
}

public DTO Out()
{
DTO dto = new DTO();

// set dto.P\* from \_P\*

return dto;

}

private T1 _P1;
...
private T24 _P24;
}

The DTO object constructs itself with a consistent default set of values. The DTO property accessors are responsible for maintaining consistency of that set. The In and Out methods of the Foo class manage its internal state based on accepting or producing a DTO, respectively. This approach lets you do things like this:

Foo foo = new Foo();
...
foo.In(new DTO() { P3 = Fred, P17 = Wilma; });
Foo foo2 = new Foo();
foo2.In(foo.Out());

Software Zen: delete this;

[Rob Philpott]

So option 1 gives you simplicity, whereas option 2 gives you immutability. There are arguments for both, the immutability one being that one DTO can be safely shared by many things as none of them can alter it. With option 1, by rights you need to keep cloning the thing to prevent any badly behaved code messing up the 'master' copy. So there's a memory/performance trade off with all that. You often get that cloning for free through serialization mind. That said, when you wish to change one property on option 2, it becomes a screaming nightmare of reconstructing a new one with one difference in the constructor parameter list. We had option 2, but it was too much to stomach in the end.

Regards, Rob Philpott.

[ScottM1]

Option 1

[Sander Rossel]

It depends. I use option 2 only for values that are absolutely necessary for the class to work (and that should never be 24 parameters, that's just bad design!). And option 2 is ideal for constructor injection in DI. Other than that, option 1.

Best, Sander sanderrossel.com Continuous Integration, Delivery, and Deployment arrgh.js - Bringing LINQ to JavaScript Object-Oriented Programming in C# Succinctly

[DerekT P]

Could you not just use inheritance and do away with all the property setting?

public class FooDto
{
public FooDto(T1 value1 /** 24 values later */, T24 value24)
{
Property1 = value1;
// .....
Property24 = value24;
}

public T1 Property1 { get; }
// ....
public T24 Property24 { get; }
}
// ....
class MyFooClass : FooDto
{
// ....
}

This exposes properties T1 ... T24 of the base FooDto class but that may or may not be an issue. There are arguments against combining DTOs and inheritance, so without knowing the details of your implementation this may not be appropriate. Part of "knowing the details" of course involves the use of a crystal ball to envisage future changes, but depending on the scenario you can pretty much rule out a lot of potential stuff and, in this case, save yourself a lot of code.

[Hooga Booga]

Down-vote! :-)

Outside of a dog, a book is a man's best friend; inside of a dog, it's too dark to read. -- Groucho Marx

[jhunley]

Nobody seems to have yet mentioned any other alternatives...one would be passing in a structure with 24 members as an initializer, although in C# that doesn't really eliminate the problem, since you'd have a similar problem with how to initialize the structure. Might be useful tho if you instantiated a lot of these objects with mostly the same parameters. I would never condone instantiating a class without initializing all member data items, but if there are reasonable default values for them, I could see an initializer (or maybe even a few) that initialized all or most of them to default values, and only set one or two to non-default values. Don't ever want to leave values uninitialized, however. Of course, there are those who would say that any object that needs this many initializers is poorly designed and should be refactored. It would be up to the author in each individual case to decide if this is feasible. For my money, this makes a good case for a language feature I've been wanting ever since the days I worked with the ADA language - named parameter lists. Then you could offer default values for all parameters, and let the caller set only the ones (s)he wants to differ from the default values. Of course, you can emulate this now in C#, but it requires 2^n constructors. I've done it with three parameters (eight constructors), but of course it would be impractical with 24.

[Bruce Patin]

I strongly prefer the code your prefer. Putting all of those properties as separate parameters of a method is something I was forced to do by someone who got his code from a glorious "whitepaper", and has resulted in hours added on to debugging when one of the parameters is wrong in some way, and has resulted in unnecessarily lengthy code calling those methods for every property even when only one or two properties need to be set.

[michaelakin]

Good ideas about the default values. And C# actually does have named paramaters. So, if they all have default values, you could just pass in a few that need to be set.

[michaelakin]

Good ideas about the default values. And C# actually does have named parameters. So, if they all have default values, you could just pass in a few that need to be set. Named and Optional Arguments (C# Programming Guide) | Microsoft Docs

[jhunley]

Good to know that named parameters were actually implemented. At my job, we're still using VS 2008, so I wasn't aware that they had taken my advice!

[michaelakin]

You could propose an option 3, that has an object with all the items that need to be passed in. According to Martin Fowler, too many options passed into a constructor is a code smell.

Quote:

A large list of construction parameters, like any large parameter list, is a CodeSmell. Usually when I see these I find that many of the parameters are DataClumps and should be replaced by their own object. Having said that it's not unusual for constructor methods to have more parameters than other methods - but they are a good place to spot data clumps.

Martin Fowler - Constructor Initialization

[michaelakin]

:) You should really try and get them to update or you should go somewhere else. That sound ridiculous to still be using VS2008.

[jhunley]

Yeah, I know. But it's about the only job available in my relatively small city, and I'm nearing retirement anyway, so I'm basically just playing out the clock...

[Super Lloyd]

Such a FoodDto is absolutely useless, a snapshot in time... There is little point in deriving from it... This FooDto sole purpose is to be turned into json and vice versa. It comes from an object that do update each individual property in real time (mostly hardware read status)

A new .NET Serializer All in one Menu-Ribbon Bar Taking over the world since 1371!