C＃内联语句的性能

Question

I'm having a Collection of a Model

public class MobileModelInfo
{
    public string Name { get; set; }
    public string Catagory { get; set; }
    public string Year { get; set; }
}

Here I'm assigning the MobileModelInfo into a ObservableCollection via Inline Single Execution Statement

Approach #1

ObservableCollection<MobileModelInfo> mobList = new ObservableCollection<MobileModelInfo>((new List<MobileModelInfo>(){
    new MobileModelInfo { Name = "S4", Catagory = "Smart Phone", Year = "2011" },
    new MobileModelInfo { Name = "S5", Catagory = "Smart Phone", Year = "2013" },
    new MobileModelInfo { Name = "S6", Catagory = "Ultra Smart Phone", Year = "2015" },
    new MobileModelInfo { Name = "", Catagory = "Ultra Smart Phone", Year = "2016" }
}).Where(i => !string.IsNullOrEmpty(i.Name)).ToList());

Now Consider the Comman Way of Implementation

Approach #2

ObservableCollection<MobileModelInfo> mobList = new ObservableCollection<MobileModelInfo>();
MobileModelInfo mobObject = new MobileModelInfo();

mobObject.Name = "S4";
mobObject.Catagory = "Smart Phone";
mobObject.Year = "2011";
if(!string.IsNullOrEmpty(mobObject.Name))
    mobList.Add(mobObject);

mobObject = new MobileModelInfo();
mobObject.Name = "S5";
mobObject.Catagory = "Smart Phone";
mobObject.Year = "2013";
if(!string.IsNullOrEmpty(mobObject.Name))
    mobList.Add(mobObject);

mobObject = new MobileModelInfo();
mobObject.Name = "S6";
mobObject.Catagory = "Ultra Smart Phone";
mobObject.Year = "2015";
if(!string.IsNullOrEmpty(mobObject.Name))
    mobList.Add(mobObject);

mobObject = new MobileModelInfo();
mobObject.Name = "";
mobObject.Catagory = "Ultra Smart Phone";
mobObject.Year = "2016";
if(!string.IsNullOrEmpty(mobObject.Name))
    mobList.Add(mobObject);

Out of these two approach which one gives good performance? In my main Project I'm having a very complex Model Class Collection. So, kindly assist me to choose a best way...

In the First Approach only one Execution should Perform since it will be expanded by the compiler but in Second Approach more than 25 (>25) Execution should Perform. So, I need to clarify which one is best approach in the Complex Data-structure.

Answer 1

The second is not "the Comman Way" (Which is a term I never heard before). It is:

• Convoluted (checking name property for null after setting it.
• The ONLY way to do it before a certain ancient .NET update enabled the new syntax.

Which pretty much is why you learned it. Old syntax. There is no significant - particularly no measurable - performance difference.

Answer 2

The new syntax object initializers are basically just a shorthand format that is translated into the long form. You can confirm this with a disassembler of some sort if you like. You will find that the code is as close to identical as it can get, barring some compiler optimizations.

For instance, this code:

TestClass t1 = new TestClass { iVal = 1, sVal = "two" };

Generates the following IL (according to LINQPad):

IL_0001:  newobj      UserQuery+TestClass..ctor
IL_0006:  stloc.2     
IL_0007:  ldloc.2     
IL_0008:  ldc.i4.1    
IL_0009:  stfld       UserQuery+TestClass.iVal
IL_000E:  ldloc.2     
IL_000F:  ldstr       "two"
IL_0014:  stfld       UserQuery+TestClass.sVal
IL_0019:  ldloc.2     
IL_001A:  stloc.0     // t1

Here's the other way:

TestClass t2 = new TestClass();
t2.iVal = 1;
t2.sVal = "two";

And its IL:

IL_001B:  newobj      UserQuery+TestClass..ctor
IL_0020:  stloc.1     // t2
IL_0021:  ldloc.1     // t2
IL_0022:  ldc.i4.1    
IL_0023:  stfld       UserQuery+TestClass.iVal
IL_0028:  ldloc.1     // t2
IL_0029:  ldstr       "two"
IL_002E:  stfld       UserQuery+TestClass.sVal

The only difference here is that the first creates a temporary variable ( loc.2 ) to do the creation and then stores it in the named local variable ( loc.0 ). That difference disappears when you turn optimization on.

So you can use either method with virtually 0 difference in performance. Personally I prefer the new object initializer form, just like I prefer the LINQ query syntax. Both are just syntactic sugar for things happening in the background, but they can have large differences in the way you read the code, and in how you write it.

Incidentally, array initializers are exactly the same. These two produce virtually identical code:

int[] a1 = new int[] { 1, 2, 3 };

int[] a2 = new int[3];
a2[0] = 1;
a2[1] = 2;
a2[2] = 3;