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

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

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

在这一点上，我将向你展示三种空或空字符串检查样式。我希望你熟悉所有的风格，但可能不熟悉他们的表现。让我们从一个小例子开始。下面有三个函数(是的，都是静态的)。我很懒，不想再次创建对象)。在第一种样式中，我使用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检查字符串是否为空”。

更改你的类型转换风格

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

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();  
        }  
    }  
} 

下面是输出内容：

嗯. .我们流行的最差技术比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()方法中，我创建了它们的一个对象。让我们看看输出屏幕。

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

结论

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

欢迎关注我的公众号，如果你有喜欢的外文技术文章，可以通过公众号留言推荐给我。