Original: Several ways to design a good structure to improve the performance of .NET applications

Written in front

A well-designed system, in addition to the excellent design at the architectural level, most of the rest lies in how to design well-designed code. NET provides many types, which are very flexible , Also very easy to use, such as List, Dictionary, HashSet, StringBuilder, string and so on. In most cases, everyone looks at the business needs to use it directly, and there seems to be no problem. From my actual experience, there are indeed very few problems. A friend asked me before, if I have encountered a memory leak, I said that the system I wrote did not, but a colleague wrote that I have encountered it several times.

In order to record the problems that have occurred, and to avoid similar problems in the future, I summarize this article and try to summarize several methods to effectively improve the performance of .NET from a statistical perspective.

This article is based on .NET Core 3.0 Preview4, and uses [Benchmark] for testing. If you don’t know Benchmark, I suggest you read this article after you finish.

collection-hidden initial capacity and automatic expansion

in .NET Here, the collection types List, Dictionary, and HashSet all have initial capacity. When the newly added data is larger than the initial capacity, it will be automatically expanded. Maybe you seldom pay attention to this hidden detail when using it (Not here yet. Consider the default initial capacity, load factor, expansion increment).

Automatic expansion gives users the perception of unlimited capacity. If it is not used very well, it may bring some new problems. Because whenever the newly added data of the collection is larger than the currently applied capacity, a larger memory capacity will be applied, which is generally twice the current capacity. This means that we may need additional memory overhead during the collection operation.

In this test, I used four scenarios, which may not be complete, but very illustrative. Each method is looped 1000 times, and the time complexity is all O(1000):

• DynamicCapacity: do not set the default length
• LargeFixedCapacity: the default length is 2000
• FixedCapacity: the default length is 1000
• FixedAndDynamicCapacity: The default length is 100

The following figure shows the test results of List, you can see that its comprehensive performance ranking is FixedCapacity>LargeFixedCapacity>DynamicCapacity>FixedAndDynamicCapacity

p>

The picture below is From the test results of Dictionary, it can be seen that its comprehensive performance ranking is FixedCapacity>LargeFixedCapacity>FixedAndDynamicCapacity>DynamicCapacity. In the Dictionary scene, the performance difference between the two methods of FixedAndDynamicCapacity and DynamicCapacity is not large, and it may be that the amount is not large enough

< p>

The following figure shows the test result of HashSet, you can see it The overall performance ranking is FixedCapacity>LargeFixedCapacity>FixedAndDynamicCapacity>DynamicCapacity. In the HashSet scene, the performance difference between the two methods of FixedAndDynamicCapacity and DynamicCapacity is still very large.

To sum up:

A proper initial value of capacity , Can effectively improve the efficiency of the collection operation. If it is not good to set an accurate data, you can apply for a slightly larger space than the actual one, but it will waste memory space and actually reduce the collection operation performance. You need to pay special attention when programming.

The following is the test source code of List, and the other two types of test codes are basically the same:

  1: public class ListTest

 2: {

 3:  private

 4: 

 5:  [Benchmark]

 6:  public< /span> void DynamicCapacity()

 7:  {

 8:  List<int> list = new List< int>();

 9:  for (int i = 0; i 
 10:  {
 11:  list.Add(i);
 12:  }
 13:  }
 14: 
 15:  [Benchmark]
 16:  public void LargeFixedCapacity()
 17:  {
 18:  List<int> list = new List<int>(2000);
 19:  for (int i = 0; i 
 20:  {
 21:  list.Add(i);
 22:  }
  23:  }
 24: 
 25:  [Benchmark]
 26:  public < span class="kwrd">void FixedCapacity()
 27:  {
< span class="lnum"> 28:  List<int> list = new List<int>(size);
 29:  for< /span> (int i = 0; i 
 30:  {< /pre> 
 31:  list.Add(i);
 32: < /span> }
 33:  }
 34: 
 35:  [Benchmark]
 36:   public void FixedAndDynamicCapacity()
 37:  { 
 38:  List<int> list = new List<int>(100);
 39:  for (int i = 0; i 
 40:  {
 41:  list.Add(i);
 42:  }
 43:  }
 44: }

Structures and classes

Structures are value types, one of reference types and value types The difference is that reference types are allocated on the heap and garbage collected, while value types are allocated on the stack and released when the stack is expanded, or inline containing types and released when their containing types are released. Therefore, the allocation and release of value types are usually less expensive than the allocation and release of reference types.

Generally speaking, most types in the framework should be classes. However, in some cases, the characteristics of value types make it more suitable for using structures.

If the instance of the type is relatively small and usually has a short lifetime or is usually embedded in other objects, define the structure instead of the class.

This type has all the following characteristics and can define a structure:

• It logically represents a single value, similar to the primitive type (int< /code>, double, etc.)

• Its instance size is less than 16 bytes

• < p>It is immutable

• It will not be boxed frequently

 1: < span class="kwrd">public struct UserStructTest

 2: { 
 3:  public int UserId {get;set; }
 4: 
 5:  public int Age {get; set; }
 6: }
 7: 
 8: public class UserClassTest
 9: {
 10:  public int UserId {get; set; }
 11: 
 12:  public  int Age {get; set; }
 13:  }
 14: 
 15: public class StructTest
 16: {
 
 17:  private int size = 1000;
 18: 
 19:  [Benchmark]
 20:  public void TestByStruct()
 21:  {
 22:  UserStructTest[] test = new UserStructTest[this.size];
 23: < /span> for (int i = 0; i 
 24:  {
 25:  test[i].UserId = 1;
 
 26:  test[i].Age = 22;
 27: < /span> }
 28:  }
 29:  span>
 30:  [Benchmark]
 31:  public void TestByClass()
 32:  {
 33:  UserClassTest[] test = new UserClassTest[< span class="kwrd">this.size];
 34:  for ( int i = 0; i 
 35:  { 
 36:  test[i] = new UserClassTest
 37:  {
 38:  UserId = 1,
 39:  Age = 22
 40:  };
 41:  }
 42:  }
 43: }

 1: public class StringBuilderTest

< span class="lnum"> 2: {

 3:  p rivate int size = 5;

 4: 

 5:  [Benchmark]

 6:  public void TestByString()

 7:  {< /pre> 
 8:  string s = string.Empty ;
 9:  for (int  i = 0; i 
 10:  {
 11:  s += "a";
 12:  s += "b";
 13:  } 
 14: < /span> }
 15: 
 16:  [Benchmark]
 17:  public void TestByStringBuilder()
 18:  {
 19:  StringBuilder sb = new StringBuilder();
 20:  for (int i = 0; i 
 21:  {
 22:  sb.Append("a");
 23:  sb.Append("b") ;
 24:  }
 25: < /pre> 
 26:  string s = sb.ToString();

 27:  }
 28: }

< span class="lnum"> 1: public class DestructionTest

 2: {

 3:  private int size = 5;

 4: 

 5:  [Benchmark]

 6:  public span> void NoDestruction()

 7:  {

 9:  {

 10:  UserTest userTest = new UserTest();

 11 :  }

 12:  }

 13: 

 14:  [Benchmark]

 15:  public void Destruction()

 16:  {

 17:  for (int i = 0; i <this.size; i++)

 18: < /span> {

 20:  }

 21:  }

 22: }

 23: 

 24: public class UserTest: IDisposable

  25: {

 26:  public < span class="kwrd">int UserId {get; set; }

 27: 

 29: 

 30:  public void Dispose()

 31:  {

 32:  Console.WriteLine("11");

 34: }

 35: 

 36: public  class UserDestructionTest

 37: {

 39:  {

 40: 

 41:  }

 43:   public int UserId {get; set; }

 44: 

 45:  public int Age {get; set; }

 46: }

 1: public class ListTest

 2: {

 3:  private int size = 1000;

 4: 

 5:  [Benchmark]

 6:  public void DynamicCapacity()

 7:  {

 8:  List<int> list = new List<int>();

 9:  for (int i = 0; i 
  10:  {
 11:  list.Add(i); pre> 
 12:  }
 13:  }
 
 14: 
 15:  [Benchmark]
 
 16:  public void LargeFixedCapacity()
 
 17:  {
 18:  List<int> list = new List<int>(2000);
 19:  for (int i = 0; i 
 20:  {
 21:  list.Add(i);
< span class="lnum"> 22:  }
 23:  }
 24: 
 25:  [Benchmark]
 26:  public void FixedCapacity()
 27:  {
 28:  List<int > list = new List<int>(size);
 29:  for (int i = 0; i 
 30:  {
 31:  list.Add(i);
 32:  }
 33:  }
 34: 
 35:  [Benchmark]
 36:  public void FixedAndDynamicCapacity()
 37:  {
 38:  List<int> list = new List<int>(100);
 39:  for (int i = 0; i  
 40:  {
 41:  list.Add(i );
 42:  }
 43:  }
 44: }

 1: public struct UserStructTest
 2: {
 3:  public int UserId {get;set ; }
 4: 
 5:  < span class="kwrd">public int Age {get; set; }
 6: < /span>}
 7: 
 8: public class UserClassTest
 9: {
 10:  public int UserId {get; set; }
 11: 
 12:  public int  Age {get; set; }
 13: }
 14: 
 15: public class StructTest
 16: {
 17:  private int size = 1000;
 18: 
 19:  [Benchmark]
 20:  public void TestByStruct()
 21:  {
  22:  UserStructTest[] test = new UserStructTest[this.size] ;
 23:  for (int  i = 0; i 
 24:  {
 25:  test[i].UserId = 1;
 26:  test[i].Age = 22 ;
  27:          }
  28:      } 
  29:   
  30:      [Benchmark] 
  31:      public void TestByClass()
  32:      {
  33:  < /span>        Use rClassTest[] test = new UserClassTest[this.size];
  34:          for (int i = 0; i < size; i++)
  35:          {
  36:              test[i] = new UserClassTest
  37:              {
  38:                  UserId = 1,
  39:                  Age = 22
  40:              };
  41:          }
  42:      }
  43:  }

   1:  public class Stri ngBuilderTest
   2:  {
   3:      private int size = 5;
   4:   
   5:      [Benchmark]
   6:      public void TestByString()
   7:      {
   8:          string s = string.Empty;
   9:          for (int i = 0; i < size; i++)
  10:          {
  11:              s += "a";
  12:              s += "b";
  13:          }
  14:      }
  15:   
  16:      [Benchmark]
  17:      public void TestByStringBuilder()
  18:      {
  19:          StringBuilder sb = new StringBuilder();
  20:          for (int i = 0; i < size; i++)
  21:          {
  22:              sb.Append("a");
  23:              sb.Append("b");
 24:  } 
  25:   
  26:          string s = sb.ToString();
  27:      }
  28:  }

   1:  public class DestructionTest
   2:  {
   3:      private int size = 5;
   4:   
   5:      [Benchmark]
   6:      public void NoDestruction()
   7:      {
   8:          < span class="kwrd">for (int i = 0; i < this.size; i++)
   9:          {
  10:              UserTest userTest = new UserTest();
  11:          }
  12:      }
  13:   
  14:      [Benchmark]
  15:      public void Destruction()
  16:      {
  17:          for (int i = 0; i < this.size; i++)
  18:          {
  19:              UserDestructionTest userTest = new UserDestructionTest();
  20:          }
  21:      }
  22:  }
  23:   
  24:  public class UserTest: IDisposable
  25:  {
  26:      public int UserId { get; set; }
  27:   
  28:      public int Age { get; set; }
  29:   
  30:      public void Dispose()
  31:      {
  32:          Console.WriteLine("11");
  33:      }
  34:  }
  35:   
  36:  public class UserDestructionTest
  37:  {
  38:      ~UserDestructionTest()
  39:      {
  40:   
  41:      }
  42:   
  43:      public int UserId { get; set; }
  44:   
  45:      public int Age { get; set; }
  46:  }