像每一篇文章一样，我会重复几行。我在我的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检查字符串是否为空”。

更改你的类型转换风格

是的，http://groups.tianya.cn/post-191232-3f86c9429ad14bdd837402176a20a625-1.shtml如果你没有实现正确的类型转换技术，请更改它。下面我将展示两种传统的类型转换风格及其对代码性能的影响。第一种风格(也是最糟糕的一种)非常简单，使用大多数开发人员都使用的圆括号()。第二种风格是通过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的一个漂亮特性是继承，它减少了代码冗余，改进了代码维护等等。我并不否认这些，但我的第五点是反对到处不必要地设立小类。如果真的不需要，那么就不要创建类层次结构。看看下面的代码。
http://groups.tianya.cn/post-191232-ac1a31fa1a244a64962fef370f9f1f99-1.shtml
复制代码
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
namespace Test1
{
http://groups.tianya.cn/post-191232-47e6e6c83bb04b9291d069b5e4a93ce7-1.shtml
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()方法中，我创建了它们的一个对象。让我们看看输出屏幕。

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