C# code survey
-
When a method has more than, say, four arguments, I strongly dislike it, its author, and the Italian governement. :)
CPallini wrote:
dislike ... the Italian governement.
I thought that was mandatory in Italy, regardless.
Wrong is evil and must be defeated. - Jeff Ello
-
CPallini wrote:
dislike ... the Italian governement.
I thought that was mandatory in Italy, regardless.
Wrong is evil and must be defeated. - Jeff Ello
-
Yes it's a programming question, but wait a moment, I am NOT asking to solve any problem here, I am asking to select your favourite of 2 options. I think what they want me to do here at work is disgusting. I have to suck it up anyway, since it's the guy who accepts pull request that tells me to do it, period. But I am curious whether or not I am in good company with my prejudice. It's about DTO, constructors with zillion of parameters and all private properties. code I prefer and put in my pull request, with 24 properties (i.e large number of properties)
public class FooDto
{
public T1 Property1 { get; set; }
// ....
public T24 Property24 { get; set; }
}
// ....
class MyFooClass
{
private T1 property1;
// ....
private T24 property24;public FooDto ToDto() { return new FooDto() { Property1 = property1, //.... Property24 = property24, }; }}
how I have asked to rewrite the code, feels disgusting to me, but curious how many people share, or dislike, my opinion
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
{
private T1 property1;
// ....
private T24 property24;public FooDto ToDto() { return new FooDto(property1 /\*\* \*/, property24); }}
In his defence he has an argument. If someone use that DTO as well, the compiler will force them to initialise all values. Though one could counter argument that we got unit test for just that. At any rate, which of those 2 is your favourite code style?
A new .NET Serializer All in one Menu-Ribbon Bar Taking over the world since 1371!
-
Yes it's a programming question, but wait a moment, I am NOT asking to solve any problem here, I am asking to select your favourite of 2 options. I think what they want me to do here at work is disgusting. I have to suck it up anyway, since it's the guy who accepts pull request that tells me to do it, period. But I am curious whether or not I am in good company with my prejudice. It's about DTO, constructors with zillion of parameters and all private properties. code I prefer and put in my pull request, with 24 properties (i.e large number of properties)
public class FooDto
{
public T1 Property1 { get; set; }
// ....
public T24 Property24 { get; set; }
}
// ....
class MyFooClass
{
private T1 property1;
// ....
private T24 property24;public FooDto ToDto() { return new FooDto() { Property1 = property1, //.... Property24 = property24, }; }}
how I have asked to rewrite the code, feels disgusting to me, but curious how many people share, or dislike, my opinion
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
{
private T1 property1;
// ....
private T24 property24;public FooDto ToDto() { return new FooDto(property1 /\*\* \*/, property24); }}
In his defence he has an argument. If someone use that DTO as well, the compiler will force them to initialise all values. Though one could counter argument that we got unit test for just that. At any rate, which of those 2 is your favourite code style?
A new .NET Serializer All in one Menu-Ribbon Bar Taking over the world since 1371!
Option 1. Agree that Too much parameters in Option 2 is terrible one. Too much parameters require changes in other places(Ex: Business Logic layer, Code-behind, etc.,) when you need to remove/add parameters later.
thatraja
Coming soon1 | Coming soon2 | Coming soon3New
-
Yes it's a programming question, but wait a moment, I am NOT asking to solve any problem here, I am asking to select your favourite of 2 options. I think what they want me to do here at work is disgusting. I have to suck it up anyway, since it's the guy who accepts pull request that tells me to do it, period. But I am curious whether or not I am in good company with my prejudice. It's about DTO, constructors with zillion of parameters and all private properties. code I prefer and put in my pull request, with 24 properties (i.e large number of properties)
public class FooDto
{
public T1 Property1 { get; set; }
// ....
public T24 Property24 { get; set; }
}
// ....
class MyFooClass
{
private T1 property1;
// ....
private T24 property24;public FooDto ToDto() { return new FooDto() { Property1 = property1, //.... Property24 = property24, }; }}
how I have asked to rewrite the code, feels disgusting to me, but curious how many people share, or dislike, my opinion
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
{
private T1 property1;
// ....
private T24 property24;public FooDto ToDto() { return new FooDto(property1 /\*\* \*/, property24); }}
In his defence he has an argument. If someone use that DTO as well, the compiler will force them to initialise all values. Though one could counter argument that we got unit test for just that. At any rate, which of those 2 is your favourite code style?
A new .NET Serializer All in one Menu-Ribbon Bar Taking over the world since 1371!
Really blow his mind. Make the constructor accept a Tuple instead.
This space for rent
-
Yes it's a programming question, but wait a moment, I am NOT asking to solve any problem here, I am asking to select your favourite of 2 options. I think what they want me to do here at work is disgusting. I have to suck it up anyway, since it's the guy who accepts pull request that tells me to do it, period. But I am curious whether or not I am in good company with my prejudice. It's about DTO, constructors with zillion of parameters and all private properties. code I prefer and put in my pull request, with 24 properties (i.e large number of properties)
public class FooDto
{
public T1 Property1 { get; set; }
// ....
public T24 Property24 { get; set; }
}
// ....
class MyFooClass
{
private T1 property1;
// ....
private T24 property24;public FooDto ToDto() { return new FooDto() { Property1 = property1, //.... Property24 = property24, }; }}
how I have asked to rewrite the code, feels disgusting to me, but curious how many people share, or dislike, my opinion
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
{
private T1 property1;
// ....
private T24 property24;public FooDto ToDto() { return new FooDto(property1 /\*\* \*/, property24); }}
In his defence he has an argument. If someone use that DTO as well, the compiler will force them to initialise all values. Though one could counter argument that we got unit test for just that. At any rate, which of those 2 is your favourite code style?
A new .NET Serializer All in one Menu-Ribbon Bar Taking over the world since 1371!
Super Lloyd wrote:
In his defence he has an argument. If someone use that DTO as well, the compiler will force them to initialise all values.
Yeah, initialization does not inherently mean useful values, so why force lazy coders to initialize meaningless values?
var dto = new FooDto(actualT1Val,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null);
"Never attribute to malice that which can be explained by stupidity." - Hanlon's Razor
-
Super Lloyd wrote:
In his defence he has an argument. If someone use that DTO as well, the compiler will force them to initialise all values.
Yeah, initialization does not inherently mean useful values, so why force lazy coders to initialize meaningless values?
var dto = new FooDto(actualT1Val,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null);
"Never attribute to malice that which can be explained by stupidity." - Hanlon's Razor
:laugh:
A new .NET Serializer All in one Menu-Ribbon Bar Taking over the world since 1371!
-
Super Lloyd wrote:
In his defence he has an argument. If someone use that DTO as well, the compiler will force them to initialise all values.
Yeah, initialization does not inherently mean useful values, so why force lazy coders to initialize meaningless values?
var dto = new FooDto(actualT1Val,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null);
"Never attribute to malice that which can be explained by stupidity." - Hanlon's Razor
I think I might add a couple of unit test just like that, for giggle... :laugh:
A new .NET Serializer All in one Menu-Ribbon Bar Taking over the world since 1371!
-
Really blow his mind. Make the constructor accept a Tuple instead.
This space for rent
that's a good one! :D in fact it might the easiest way how to go about it.. by that I mean I can implement that with some quick copy paste... whereas implementing the constructor is going to be manually intensive and bug prone! :~
A new .NET Serializer All in one Menu-Ribbon Bar Taking over the world since 1371!
-
Yes it's a programming question, but wait a moment, I am NOT asking to solve any problem here, I am asking to select your favourite of 2 options. I think what they want me to do here at work is disgusting. I have to suck it up anyway, since it's the guy who accepts pull request that tells me to do it, period. But I am curious whether or not I am in good company with my prejudice. It's about DTO, constructors with zillion of parameters and all private properties. code I prefer and put in my pull request, with 24 properties (i.e large number of properties)
public class FooDto
{
public T1 Property1 { get; set; }
// ....
public T24 Property24 { get; set; }
}
// ....
class MyFooClass
{
private T1 property1;
// ....
private T24 property24;public FooDto ToDto() { return new FooDto() { Property1 = property1, //.... Property24 = property24, }; }}
how I have asked to rewrite the code, feels disgusting to me, but curious how many people share, or dislike, my opinion
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
{
private T1 property1;
// ....
private T24 property24;public FooDto ToDto() { return new FooDto(property1 /\*\* \*/, property24); }}
In his defence he has an argument. If someone use that DTO as well, the compiler will force them to initialise all values. Though one could counter argument that we got unit test for just that. At any rate, which of those 2 is your favourite code style?
A new .NET Serializer All in one Menu-Ribbon Bar Taking over the world since 1371!
I don't mind either option, but I think I like v1 better. When it comes to long lists of assignments I generally copy/paste back and forth with an instance of Excel.
Director of Transmogrification Services Shinobi of Query Language Master of Yoda Conditional
-
Yes it's a programming question, but wait a moment, I am NOT asking to solve any problem here, I am asking to select your favourite of 2 options. I think what they want me to do here at work is disgusting. I have to suck it up anyway, since it's the guy who accepts pull request that tells me to do it, period. But I am curious whether or not I am in good company with my prejudice. It's about DTO, constructors with zillion of parameters and all private properties. code I prefer and put in my pull request, with 24 properties (i.e large number of properties)
public class FooDto
{
public T1 Property1 { get; set; }
// ....
public T24 Property24 { get; set; }
}
// ....
class MyFooClass
{
private T1 property1;
// ....
private T24 property24;public FooDto ToDto() { return new FooDto() { Property1 = property1, //.... Property24 = property24, }; }}
how I have asked to rewrite the code, feels disgusting to me, but curious how many people share, or dislike, my opinion
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
{
private T1 property1;
// ....
private T24 property24;public FooDto ToDto() { return new FooDto(property1 /\*\* \*/, property24); }}
In his defence he has an argument. If someone use that DTO as well, the compiler will force them to initialise all values. Though one could counter argument that we got unit test for just that. At any rate, which of those 2 is your favourite code style?
A new .NET Serializer All in one Menu-Ribbon Bar Taking over the world since 1371!
-
Yes it's a programming question, but wait a moment, I am NOT asking to solve any problem here, I am asking to select your favourite of 2 options. I think what they want me to do here at work is disgusting. I have to suck it up anyway, since it's the guy who accepts pull request that tells me to do it, period. But I am curious whether or not I am in good company with my prejudice. It's about DTO, constructors with zillion of parameters and all private properties. code I prefer and put in my pull request, with 24 properties (i.e large number of properties)
public class FooDto
{
public T1 Property1 { get; set; }
// ....
public T24 Property24 { get; set; }
}
// ....
class MyFooClass
{
private T1 property1;
// ....
private T24 property24;public FooDto ToDto() { return new FooDto() { Property1 = property1, //.... Property24 = property24, }; }}
how I have asked to rewrite the code, feels disgusting to me, but curious how many people share, or dislike, my opinion
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
{
private T1 property1;
// ....
private T24 property24;public FooDto ToDto() { return new FooDto(property1 /\*\* \*/, property24); }}
In his defence he has an argument. If someone use that DTO as well, the compiler will force them to initialise all values. Though one could counter argument that we got unit test for just that. At any rate, which of those 2 is your favourite code style?
A new .NET Serializer All in one Menu-Ribbon Bar Taking over the world since 1371!
Neither. One does not "force" all or none. The constructor-parameters are added for all variables that the object needs before it can initialize. Any other option that can be set later should be a public property. If you have more than three parameters, consider creating a class for them and to pass the thing to the constructor.
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.
-
Neither. One does not "force" all or none. The constructor-parameters are added for all variables that the object needs before it can initialize. Any other option that can be set later should be a public property. If you have more than three parameters, consider creating a class for them and to pass the thing to the constructor.
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.
it's a DTO, i.e. all those could be field really (except it would sparkle another argument). No code is either run into that class, just a bag of well known property....
A new .NET Serializer All in one Menu-Ribbon Bar Taking over the world since 1371!
-
Super Lloyd wrote:
select your favourite of 2 options.
I prefer favorite.
Everyone is born right handed. Only the strongest overcome it. Fight for left-handed rights and hand equality.
I live in Australia..... I am giving in the local area grammar Nazi... :sigh: :((
A new .NET Serializer All in one Menu-Ribbon Bar Taking over the world since 1371!
-
it's a DTO, i.e. all those could be field really (except it would sparkle another argument). No code is either run into that class, just a bag of well known property....
A new .NET Serializer All in one Menu-Ribbon Bar Taking over the world since 1371!
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.
-
Yes it's a programming question, but wait a moment, I am NOT asking to solve any problem here, I am asking to select your favourite of 2 options. I think what they want me to do here at work is disgusting. I have to suck it up anyway, since it's the guy who accepts pull request that tells me to do it, period. But I am curious whether or not I am in good company with my prejudice. It's about DTO, constructors with zillion of parameters and all private properties. code I prefer and put in my pull request, with 24 properties (i.e large number of properties)
public class FooDto
{
public T1 Property1 { get; set; }
// ....
public T24 Property24 { get; set; }
}
// ....
class MyFooClass
{
private T1 property1;
// ....
private T24 property24;public FooDto ToDto() { return new FooDto() { Property1 = property1, //.... Property24 = property24, }; }}
how I have asked to rewrite the code, feels disgusting to me, but curious how many people share, or dislike, my opinion
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
{
private T1 property1;
// ....
private T24 property24;public FooDto ToDto() { return new FooDto(property1 /\*\* \*/, property24); }}
In his defence he has an argument. If someone use that DTO as well, the compiler will force them to initialise all values. Though one could counter argument that we got unit test for just that. At any rate, which of those 2 is your favourite code style?
A new .NET Serializer All in one Menu-Ribbon Bar Taking over the world since 1371!
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
Fromfor 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
FooDtoand properties in the "from" class that can be mapped toFooDto.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
-
Yes it's a programming question, but wait a moment, I am NOT asking to solve any problem here, I am asking to select your favourite of 2 options. I think what they want me to do here at work is disgusting. I have to suck it up anyway, since it's the guy who accepts pull request that tells me to do it, period. But I am curious whether or not I am in good company with my prejudice. It's about DTO, constructors with zillion of parameters and all private properties. code I prefer and put in my pull request, with 24 properties (i.e large number of properties)
public class FooDto
{
public T1 Property1 { get; set; }
// ....
public T24 Property24 { get; set; }
}
// ....
class MyFooClass
{
private T1 property1;
// ....
private T24 property24;public FooDto ToDto() { return new FooDto() { Property1 = property1, //.... Property24 = property24, }; }}
how I have asked to rewrite the code, feels disgusting to me, but curious how many people share, or dislike, my opinion
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
{
private T1 property1;
// ....
private T24 property24;public FooDto ToDto() { return new FooDto(property1 /\*\* \*/, property24); }}
In his defence he has an argument. If someone use that DTO as well, the compiler will force them to initialise all values. Though one could counter argument that we got unit test for just that. At any rate, which of those 2 is your favourite code style?
A new .NET Serializer All in one Menu-Ribbon Bar Taking over the world since 1371!
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
-
Yes it's a programming question, but wait a moment, I am NOT asking to solve any problem here, I am asking to select your favourite of 2 options. I think what they want me to do here at work is disgusting. I have to suck it up anyway, since it's the guy who accepts pull request that tells me to do it, period. But I am curious whether or not I am in good company with my prejudice. It's about DTO, constructors with zillion of parameters and all private properties. code I prefer and put in my pull request, with 24 properties (i.e large number of properties)
public class FooDto
{
public T1 Property1 { get; set; }
// ....
public T24 Property24 { get; set; }
}
// ....
class MyFooClass
{
private T1 property1;
// ....
private T24 property24;public FooDto ToDto() { return new FooDto() { Property1 = property1, //.... Property24 = property24, }; }}
how I have asked to rewrite the code, feels disgusting to me, but curious how many people share, or dislike, my opinion
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
{
private T1 property1;
// ....
private T24 property24;public FooDto ToDto() { return new FooDto(property1 /\*\* \*/, property24); }}
In his defence he has an argument. If someone use that DTO as well, the compiler will force them to initialise all values. Though one could counter argument that we got unit test for just that. At any rate, which of those 2 is your favourite code style?
A new .NET Serializer All in one Menu-Ribbon Bar Taking over the world since 1371!
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(); }
-
Option 1, but I do see the argument for option 2, especially if the properties are mandatory.
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 -
Yes it's a programming question, but wait a moment, I am NOT asking to solve any problem here, I am asking to select your favourite of 2 options. I think what they want me to do here at work is disgusting. I have to suck it up anyway, since it's the guy who accepts pull request that tells me to do it, period. But I am curious whether or not I am in good company with my prejudice. It's about DTO, constructors with zillion of parameters and all private properties. code I prefer and put in my pull request, with 24 properties (i.e large number of properties)
public class FooDto
{
public T1 Property1 { get; set; }
// ....
public T24 Property24 { get; set; }
}
// ....
class MyFooClass
{
private T1 property1;
// ....
private T24 property24;public FooDto ToDto() { return new FooDto() { Property1 = property1, //.... Property24 = property24, }; }}
how I have asked to rewrite the code, feels disgusting to me, but curious how many people share, or dislike, my opinion
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
{
private T1 property1;
// ....
private T24 property24;public FooDto ToDto() { return new FooDto(property1 /\*\* \*/, property24); }}
In his defence he has an argument. If someone use that DTO as well, the compiler will force them to initialise all values. Though one could counter argument that we got unit test for just that. At any rate, which of those 2 is your favourite code style?
A new .NET Serializer All in one Menu-Ribbon Bar Taking over the world since 1371!
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
InandOutmethods of theFooclass 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;