关于c#:改进你的c代码的5个技巧二

在本文中，我将向你展现 c# 编程的 5 个最佳实际。我从日常编程教训中学到了这些实际。我在 release 模式下测试了所有的代码，并在开发环境稳固后进行了截屏。我想你会喜爱这些倡议的。

在应用数据类型之前抉择它

对于许多类型，咱们宁愿不决定在日常编程生存中应用什么数据类型。就在几个月前，我也是其中之一。然而当我开始学习编程中的最佳实际以进步代码性能时，我理解到了谬误的数据类型是如何影响代码的。我将展现一个演示来证实这个概念。

static void Main(string[] args)  
{List<Int32> li = new List<int>();  
    Stopwatch sw =new Stopwatch();  
    sw.Start();  
    for (int i = 0; i < 10000; i++)  
    {li.Add(i);  
    }  
    sw.Stop();  
    Console.Write("Using Arraylist(Object)" + sw.ElapsedTicks + "n");  
    sw.Reset();  
    sw.Start();  
    Int32[] a = new Int32[10000];  
    for (int i = 0; i < 10000; i++)  
    {a[i] = i;  
    }  
    sw.Stop();  
    Console.Write("Using Value(Integer Array)" + sw.ElapsedTicks);  
    Console.ReadLine();} 

在下面的代码中，首先我应用了一个 list 来存储 1000 个整数值，在第二次执行雷同的操作时，我应用了一个整数数组。我的输入截图显示了哪种存储机制最适宜整数数组。当初，你可能会想为什么这个 list 要花更多的工夫呢? 起因是，list 以对象格局存储数据，当咱们首先尝试存储值类型时，它将其转换为援用类型，而后再存储。因而，第一点是始终抉择适当的存储机制以获得最佳性能。

应用 for 循环代替 foreach

我当初要解释一个十分乏味的事实。我想你们都相熟 for 和 foreach 循环。当初如果我问你哪个更快? 嗯…不晓得。对吧?

伙计们，for 循环比 foreach 循环快得多。让咱们看看上面的例子。

List<Int32> Count = new List<int>();
List<Int32> lst1 = new List<Int32>();
List<Int32> lst2 = new List<Int32>();

for (int i = 0; i < 10000; i++)
{Count.Add(i);
}

Stopwatch sw = new Stopwatch();
sw.Start();
for (int i = 0; i < Count.Count; i++)
{lst1.Add(i);
}
sw.Stop();

Console.Write("For Loop :-" + sw.ElapsedTicks + "n");
sw.Restart();

foreach (int a in Count)
{lst2.Add(a);
}
sw.Stop();
Console.Write("Foreach Loop:-" + sw.ElapsedTicks);
Console.ReadLine();

不要放心，我曾经在公布模式下测试了这个示例，这个屏幕截图是在几次测试运行后拍摄的。

抉择何时应用类，何时应用构造体

承受这样一个事实，即根本了解了 c# 中的构造体和类，或者至多了解了最喜爱的编程语言中的构造体和类(如果它们存在的话)。好吧，如果你在想“很久以前我学过构造体，但在日常编码生存中从未应用过它”，那么你就是那 95% 从未测量过类和构造体性能的开发人员中的一员。别放心; 在写这篇文章之前，我也没有。

那么类呢? 是的，咱们时不时地在日常我的项目开发中实现一个类。

当初我的问题是“哪个更快，类还是构造体”? 我猜你会想“从未测试过”。好的，咱们来测试一下。看看上面的代码。

namespace BlogProject
{
    struct MyStructure
    {
        public string Name;
        public string Surname;
    }
    class MyClass
    {
        public string Name;
        public string Surname;
    }
    class Program
    {static void Main(string[] args)
        {MyStructure[] objStruct = new MyStructure[1000];
            MyClass[] objClass = new MyClass[1000];


            Stopwatch sw = new Stopwatch();
            sw.Start();
            for (int i = 0; i < 1000; i++)
            {objStruct[i] = newMyStructure();
                objStruct[i].Name = "Sourav";
                objStruct[i].Surname = "Kayal";
            }
            sw.Stop();
            Console.WriteLine("For Structure:-" + sw.ElapsedTicks);
            sw.Restart();

            for (int i = 0; i < 1000; i++)
            {objClass[i] = newMyClass();
                objClass[i].Name = "Sourav";
                objClass[i].Surname = "Kayal";
            }
            sw.Stop();
            Console.WriteLine("For Class:-" + sw.ElapsedTicks);

            Console.ReadLine();}
    }
}

输入后果如下：

当初很显著，构造体要比类快得多。同样，我在公布模式下测试了这段代码，并取得了至多 20 个输入，以使程序达到稳固的地位。

当初最大的问题是“为什么构造体比类快?”

正如咱们所知，构造体变量是值类型，值 (或构造体变量) 存储在一个地位。

类对象是援用类型。如果是对象类型，则创立援用，并将值存储在内存的其余地位。基本上，值存储在一个可治理的堆中，指针创立在堆栈中。以这种形式在内存中实现一个对象，通常要比构造体变量破费更多的工夫。

始终应用 Stringbuilder 进行字符串连贯操作

这一点对开发人员来说十分要害。在进行大量字符串拼接操作时，请应用 StringBuilder 代替 String。为了演示它对代码性能的影响，我筹备了以下示例代码。我在 for 循环中执行了 500 次字符串拼接操作。

public classTest
{public static string Name { get; set;}
    public static string surname;  
}  
class Program
{static void Main(string[] args)
    {
        string First = "A";
        StringBuilder sb = new StringBuilder("A");

        Stopwatch st = new Stopwatch();
        st.Start();
        for (int i = 0; i < 500; i++)
        {First = First + "A";}
        st.Stop();
        Console.WriteLine("Using String :-" + st.ElapsedTicks);
        st.Restart();

        for (int i = 0; i < 500; i++)
        {sb.Append("A");
        }
        st.Stop();
        Console.WriteLine("Using Stringbuilder :-" + st.ElapsedTicks);
        Console.ReadLine();}
}

 这是输入：

抉择调配类数据成员的最佳形式

在为类变量赋值之前，我倡议你当初查看以下代码和输入屏幕。

namespace Test
{  
    public class Test  
    {public staticstring Name { get; set;}
        public staticString surname;
    }
    class Program
    {static void Main(string[] args)
        {Stopwatch st = new Stopwatch();
            st.Start();
            for (int i = 0; i < 100; i++)
            {Test.Name = "Value";}
            st.Stop();
            Console.WriteLine("Using Property:" + st.ElapsedTicks);
            st.Restart();
            for (int i = 0; i < 100; i++)
            {Test.surname = "Value";}
            st.Stop();
            Console.WriteLine("Direct Assign:" + st.ElapsedTicks);
            Console.ReadLine();}
    }  
} 

 是的，咱们的输入屏幕是说，应用属性调配数据成员比间接调配要慢得多。

 欢送关注我的公众号，如果你有喜爱的外文技术文章，能够通过公众号留言举荐给我。