改进你的c#代码的5个技巧（四）

时间 2021-01-19

标签 c# 函数性能学习测试 spa pwa code orm 对象栏目 C# 繁體版

原文原文链接

像每一篇文章同样，我会重复几行。我在个人Core i3 CPU、4GB主内存和Windows 7平台上测试了如下代码。若是你在不一样的硬件配置或使用不一样的平台，那么你的输出可能会随着个人输出屏幕而变化，而且输出可能会根据当前运行的进程而变化。因为全部的点都是性能测试，我已经在发布模式下对它们进行了测试，并在一个稳定的状况下对全部代码进行了截图。让咱们从第一条建议开始。c#

如何检查代码中的空字符串?函数

在这一点上，我将向你展现三种空或空字符串检查样式。我但愿你熟悉全部的风格，但可能不熟悉他们的表现。让咱们从一个小例子开始。下面有三个函数(是的，都是静态的)。我很懒，不想再次建立对象)。在第一种样式中，我使用Length属性。在第二种状况下，我使用一个空格或空字符串(" ")。在第三种状况下，我使用string类的空属性。下面是个人测试代码。性能

using System;  
using System.Collections.Generic;  
using System.Diagnostics;  
using System.IO;  
namespace Test1  
{  
    public class Compare  
    {  
        public static void First(string Value)  
        {  
            if (Value.Length != 0)  
            {  
            }  
        }  
        public static void Second(string Value)  
        {  
            if (Value != "")  
            {  
            }  
        }  
        public static void Third(string Value)  
        {  
            if (Value != string.Empty )  
            {  
            }  
        }  
    }  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            Stopwatch sw = new Stopwatch();  
            sw.Start();  
            Compare.First("Sourav");  
            sw.Stop();  
            Console.WriteLine("Using Length: "+sw.ElapsedTicks);  
            sw.Restart();  
            Compare.Second("Sourav");  
            sw.Stop();  
            Console.WriteLine("Using !=     " +sw.ElapsedTicks);  
            sw.Restart();  
            Compare.Third("Sourav");  
            sw.Stop();  
            Console.WriteLine("Using Empty: " + sw.ElapsedTicks);  
            Console.ReadLine();  
        }  
    }  
}

输出结果以下：学习

咱们能够看到长度测量风格(第一种)花费的时间最多。字符串空样式是耗时最少的过程。测试

因此，最后一句是"使用String.Empty检查字符串是否为空”。spa

更改你的类型转换风格pwa

是的，若是你没有实现正确的类型转换技术，请更改它。下面我将展现两种传统的类型转换风格及其对代码性能的影响。第一种风格(也是最糟糕的一种)很是简单，使用大多数开发人员都使用的圆括号()。第二种风格是经过as关键字。在下面的代码中，我实现了这两个功能。让咱们来看看下面的代码。code

using System;  
using System.Collections.Generic;  
using System.Diagnostics;  
using System.IO;  
namespace Test1  
{  
    public class Base  
    {  
    }  
    public class Derive : Base  
    {  
    }  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            Derive d = new Derive();  
            Stopwatch sw = new Stopwatch();  
            sw.Start();  
            Base b =(Base) d;  
            sw.Stop();  
            Console.WriteLine("Using type cust : "+ sw.ElapsedTicks);  
            sw.Restart();  
            Base c = d as Base;  
            sw.Stop();  
            Console.WriteLine("Using as keyword : "+ sw.ElapsedTicks);  
            Console.ReadLine();  
        }  
    }  
}

下面是输出内容：orm

嗯. .咱们流行的最差技术比as关键字慢6倍。如今，在这一点上，我不会写结论，如何转换对象是你的选择。对象

高字符串比较法

是的，关于字符串的另外一个技巧。咱们知道有两种经常使用的字符串比较方法。一个是“操做符==”，另外一个是使用String类的Equals()方法。

有一天我问个人一个同事:“你最喜欢哪个?”他回答了第一个(换句话说，==)。我问他为何?他回答说:“它很是简单，容易，从我第一次学习c#开始，我就一直在使用它，我对它很满意，我不会改变个人风格。”嗯，若是你也处于这种状况，那么我建议你先看看输出屏幕，而后再看看代码。

using System;  
using System.Collections.Generic;  
using System.Diagnostics;  
using System.IO;  
namespace Test1  
{  
    public class Test  
    {  
        public static void First(String Value)  
        {  
            for (int i = 0; i < 100; i++)  
            {  
                if (Value == "Sourav")  
                {  
                    continue;  
                }  
            }  
        }  
        public static void Second(String Value)  
        {  
            for (int i = 0; i < 100; i++)  
            {  
                if (Value.Equals("Sourav"))  
                {  
                    continue;  
                }  
            }  
        }  
   }  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            Stopwatch sw = new Stopwatch();  
            sw.Start();  
            Test.First("Sourav");  
            sw.Stop();  
            Console.WriteLine("Using == : "+ sw.ElapsedTicks);  
            sw.Restart();  
            Test.Second("Sourav");  
            sw.Stop();  
            Console.WriteLine("Using Equals : "+ sw.ElapsedTicks);  
            Console.ReadLine();  
        }  
    }  
}

你有一个附带快速计算的计算器。屏幕显示，使用"=="样式比字符串比较函数(Equals())慢190倍。我不会写结论。这是你的责任，改变你的风格，并分享上面的图像(输出屏幕)给你的朋友。

用一个小技巧刺穿循环

在开始以前，我想告诉你一件事。这不是很重要的一点。不然这将是一个很是重要的适应技巧。这里，我将展现如何实现传统的for循环。若是你遍历下面的代码，那么会发如今第二个“for”实现中，局部变量使用的时间更少，这就是为何消耗的时间更少，但并非很是少。所以，最好的作法是减小变量的使用次数。

using System;  
using System.Collections.Generic;  
using System.Diagnostics;  
using System.IO;  
namespace Test1  
{  
    public class Base  
    {  
        public static void First(Int32 limit)  
        {  
            for (int i = 0; ++i <= limit; )  
            {  
            }  
        }  
        public static void Second(Int32 limit)  
        {  
            for (int i = limit; -- i >= 0; )  
            {  
            }  
        }  
    }  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            Stopwatch sw = new Stopwatch();  
            sw.Start();  
            Base.First(100);  
            sw.Stop();  
            Console.WriteLine("First "+ sw.ElapsedTicks);  
            sw.Restart();  
            Base.Second(100);  
            sw.Stop();  
            Console.WriteLine("Second : "+ sw.ElapsedTicks);  
            Console.ReadLine();  
        }  
    }  
}

下面是输出内容：

让咱们写一行结论:“在编写循环迭代代码时要聪明。”

继承是一种很好的实践，但并不老是如此

咱们知道OOP的一个漂亮特性是继承，它减小了代码冗余，改进了代码维护等等。我并不否定这些，但个人第五点是反对处处没必要要地设立小类。若是真的不须要，那么就不要建立类层次结构。看看下面的代码。

using System;  
using System.Collections.Generic;  
using System.Diagnostics;  
using System.IO;  
namespace Test1  
{  
    public class Base  
    {  
    }  
    public class Derive  :Base  
    {  
        public string name;  
    }  
    public class Concrete  
    {  
        public string name;  
    }  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            Stopwatch sw = new Stopwatch();  
            sw.Start();  
            Derive d = new Derive();  
            d.name = "Sourav";  
            sw.Stop();  
            Console.WriteLine("Derive style : "+ sw.ElapsedTicks);  
            sw.Restart();  
            Concrete c = new Concrete();  
            c.name = "Sourav";  
            sw.Stop();  
            Console.WriteLine("Concrete class : "+ sw.ElapsedTicks);  
            Console.ReadLine();  
        }  
    }  
}

首先，我建立了两个小类，在它们之间我根本没有使用第一个类。它做为基类服务。在第二个场景中，我建立了一个具体的类;它没有继承的概念。在main()方法中，我建立了它们的一个对象。让咱们看看输出屏幕。

正如输出屏幕所示，在具体类中建立对象要比在派生类中快得多。让咱们以一行注释结束“若是不须要，不要实现类层次结构”。

结论

亲爱的读者，感谢你花费宝贵的时间完成这篇文章。(由于大多数读者不会从头读到尾，若是你读了，那是个人我的成就)。欢迎你们提出各类意见。

欢迎关注个人公众号，若是你有喜欢的外文技术文章，能够经过公众号留言推荐给我。

原文连接：https://www.c-sharpcorner.com/UploadFile/dacca2/5-tips-to-improve-performance-of-C-Sharp-code-part-3/