Declaring and creating an object then adding to collection VS Adding object to collection using new keyword to create object

Ok so the title may have been confusing so i have posted 2 code snippets to illustrate what i mean.

NOTE: allUsers is just a collection.

RegularUser regUser = new RegularUser(userName, password, name, emailAddress);
        allUsers.Add(regUser);

VS

       开发者_开发知识库 allUsers.Add(new RegularUser(userName, password, name, emailAddress));

1. Which snippet A or B is better and why?
2. What are the advantages or disadvantages?
3. The example i wrote was C# but does the language (C#, Java etc) make a difference?

As far as C# is concerned, both of your code examples are practically identical at the IL level. The second examples still creates a reference to the created object and pushes it onto the stack, you just don't have a local variable hooked up to it. This will not create any performance problems at all.

1) Which snippet A or B is better and why?

They're really identical. The compiled code will be nearly identical, since a temporary object is pushed onto the stack, then used in the method call.

2) What are the advantages or disadvantages?

The main advantages and disadvantages to the approach are really just readability.

Your first example has the advantage of keeping a single "operation" per line of code, which, in many ways, is more maintainable.

The second example removes the unnecessary variable declaration, which may be more maintainable.

Personally, I feel that the number of parameters in your RegularUser constructor would probably push me, in this instance, towards your first option. I typically find that, when a line of code gets to be more than about half a screen width on an average monitor, it's easier to read and understand if it's split up. Splitting this up by introducing the temporary and calling Add separately makes this more clear.

However, if you're just adding an integer or a class that's very small, I'd probably vote to skip the unnecessary variable. This is completely a personal preference, however - your milage may (and probably will) vary.

3) The example i wrote was C# but does the language (C#, Java etc) make a difference?

No, for the most part. This is really language/implementation dependent, but most languages will have the same basic behavior and performance in both cases. It is possible (and highly likely) that some languages may treat this differently, but most mainstream languages will not.

I really like to create them the first way unless I really really know what is going on. It is much harder to do debugging if you don't create the object first...

The compiler will just turn the 2nd version into the 1st for you, anyway, so there isn't a net negative effect.

Pros of #1:

• easier to debug (!)
• theoretically easier to read, clearer
• can use the object later

Cons:

• more verbose
• can be unnecessary, especially for trivial objects

Result:

• 1 for anything complex to create, or that may need to be inspected easily at debug time
• 2 for lots of annoying little stuff, like the following.

var list = new List<NameValuePair>(3);
list.Add( new NameValuePair("name", "valuable");
list.add( new NameValuePair("age",  "valuable");
list.add( new NameValuePair("height", "not valuable");

var dates = new List<date>();
dates.Add(DateTime.Now());
dates.Add(DateTime.Now().Date().AddYears(-2));

As far as I know there isn't a real difference between languages when it comes to this. Some may not allow it, though.

Both are equal in terms of performance.

In terms of maintainability the second case is a nightmare, it is (nearly) impossible to trace in a debugger. So I tend to prefer the first one. In my early oop days I was always writing the second, because "I knew that they were objects and I was sooo good at grasping objects that I ... blah blah blah", but that wore off with time and especially maintenance time

Also, suppose that someone wants you to

FilterClass.FilterUser(regUser)

or

Database.AddToDatabase(regUser)

because it is the right place to do so, the first scenario is better.

Finally, when do you stop?

allUsers.Add(new RegularUser(new ReadFromInput(new EscapedName(new Name(new String(userName)))), password, name, emailAddress));