改善C#编程的50个建议(21-25)

-------------------------翻译 By Cryking-----------------------------
-----------------------转载请注明出处,谢谢!------------------------ 

21 限制类型的可见性

不是每个类型都需要Public。你应给你的类型最少的可见度来达到你的目的,内部或私有类能实现公共的接口。很多独立的类应当创建为内部的。你可以使用protected或私有嵌套类进一步来限制其可见性,可见性越小,当你之后更新时,整个系统的更改也就越少,越少的地方访问你的代码,你修改的地方也就越少。
  只暴露那些需要暴露的。对于可见性小的类,尝试使用公共接口来暴露。

// For illustration, not complete source
public class List<T> : IEnumerable<T>
{
    private class Enumerator<T> : IEnumerator<T>
    {
        // Contains specific implementation of
        // MoveNext(), Reset(), and Current.
        public Enumerator(List<T> storage)
        {
            // elided
        }
    }
    public IEnumerator<T> GetEnumerator()
    {
        return new Enumerator<T>(this);
    }
    // other List members.
}

客户端代码不需要知道类的Enumerator<T>。
.NET很多集合类也是这样设计的,如Dictionary<T>包含了私有的DictionaryEnumerator<T>,Queue<T>包含了QueueEnumerator<T>.
  创建internal类是一种被忽视的限制类型范围的方法。缺省情况下,大部分程序员总是创建Public类,没有去考虑其他,因为这些都是VS .NET向导做的事。在接收默认形式的时候,你应留心你的新创建的类会用在哪里？是所有客户端还是主要在程序集内部使用？
  使用接口暴露你的函数使你更容易创建internal类,如:

public interface IPhoneValidator
{
  bool ValidateNumber(PhoneNumber ph);
}
internal class USPhoneValidator : IPhoneValidator
{
	public bool ValidateNumber(PhoneNumber ph)
	{
	  // perform validation.
	  // Check for valid area code, exchange.
	  return true;
	}
}

22 偏爱定义和实现接口而不是继承
抽象基类提供了类层次的祖先。一个接口描述了一个能被类实现的原子功能。
接口以一种契约的方式来设计:一个实现了接口的类必须提供一个预期的方法实现。抽象基类为一系列相关的类型提供了一个公共抽象方法。继承意思是是什么,接口意思是行为像什么.这都是老生常谈的问题,但也是它们的工作。它们描述两个不同的概念:基类描述的是对象是什么,接口描述的是对象的一种行为方式。
  接口描述了一组功能或者说是一个契约。你可以在接口中创建方法、属性、索引器、事件等。你也可以创建接口所没有的方法,因为方法没有具体的数据成员,你可以使用扩展方法来扩充接口功能。如扩展泛型接口IEnumerable<T>:

    public static class Extensions
   {
	public static void ForAll<T>(
		this IEnumerable<T> sequence,
		Action<T> action)
	{
		foreach (T item in sequence)
		action(item);
	}
   }
        // usage
foo.ForAll((n) => Console.WriteLine(n.ToString()));

抽象基类可以为它的派生类提供一些公共的实现方法,它通过virtual方法来为派生类指定数据成员、具体方法等。这个基类实现带了一个好处:如果你给基类增加一个方法,那么它的所有派生类都自动隐式地增加.但是给接口增加一个方法将会导致实现它的所有类都产生错误.选择一个抽象基类还是一个接口,这涉及到如何能最好地总是支持你的抽象功能.接口总是固定的:你发行一个接口作为一系列任何类都能实现的功能的契约.基类总是能被扩展的.这些扩展也会成为其派生类的一部分.
  这两种模型是可以混合使用的.一个例子是.NET框架中的IEnumerable<T>接口和System.Linq.Enumerable类.System.Linq.Enumerable类包含了基于System.Collections.Generic.IEnumerable<T>接口的大量扩展方法。
  接口可以被任意数量的不相关类型来实现。编写接口给编写基类的开发者提供了非常大的灵活性。因为.NET环境中只支持单继承,而接口解决了多继承问题。使用接口还可以使你偶尔能减少structs类型拆箱的代价。如:

public struct URLInfo : IComparable<URLInfo>, IComparable
{
    private string URL;
    private string description;
    #region IComparable<URLInfo> Members
    public int CompareTo(URLInfo other)
    {
        return URL.CompareTo(other.URL);
    }
    #endregion
    #region IComparable Members
    int IComparable.CompareTo(object obj)
    {
        if (obj is URLInfo)
        {
            URLInfo other = (URLInfo)obj;
            return CompareTo(other);
        }
        else
            throw new ArgumentException(
            "Compared object is not URLInfo");
    }
    #endregion
}

任何基于IComparable的代码将会减少装箱和拆箱,因为可以调用IComparable.CompareTo方法而不用拆箱对象.


23 理解接口方法和虚拟方法的不同
刚开始,可能以为实现一个接口和重写一个虚拟方法一样,但实际上实现一个接口和重写虚拟方法是大不相同的.首先在接口中的成员方法并不是默认以virtual声明的.派生类不能重写基类中已实现的接口成员,接口可以显示实现,这样可以隐藏从类继承而来的公共接口。它们是在不同的用途是不同的概念。
  你可以在派生类中修改接口的实现。如:

interface IMsg
{
    void Message();
}
public class MyClass : IMsg
{
    public void Message()
    {
        Console.WriteLine("MyClass");
    }
}

Message()方法现在是MyClass类的公共接口。Message也可以通过IMsg指针来访问。现在我们来增加一个派生类:

public class MyDerivedClass : MyClass
{
    public void Message()
    {
        Console.WriteLine("MyDerivedClass");
    }
}

因为MyClass.Message()不是虚拟的,派生类是不能提供一个重写的Message()版本的。此时派生类创建了一个新的Message()方法,它把基类的Message()方法给隐藏了,相当于new void Message()。通过IMsg引用MyClass.Message仍然是可以用的:
MyDerivedClass d = new MyDerivedClass();
d.Message(); // prints "MyDerivedClass".
IMsg m = d as IMsg;
m.Message(); // prints "MyClass"
当你实现一个接口,你实际在类中声明了一个特殊契约的具体实现。但是通常我们想在基类创建、实现接口,然后在派生类中修改它:

    public class MyClass : IMsg
    {
        public virtual void Message()
        {
            Console.WriteLine("MyClass");
        }
    }
    public class MyDerivedClass : MyClass
    {
        public override void Message()
        {
            Console.WriteLine("MyDerivedClass");
        }
    }

MyDerivedClass以及所有从MyClass派生的类都能声明它们自己的Message方法。这个重写版本能被派生类引用访问、能被接口引用访问、能被基类引用访问,如果你不喜欢虚函数的概念,你可以这样来重新定义基类:
public abstract class MyClass : IMsg
{
public abstract void Message();
}
对,你可以在基类中不实际实现一个接口,声明它为抽象方法。这样所有派生类必须实现这个接口方法。派生类可以通过密封该方法来阻止它自己的派生重写它:

    public class MyDerivedClass2 : MyClass
    {
        public sealed override void Message()
        {
            Console.WriteLine("MyDerivedClass");
        }
    }

另一种解决方法是实现接口,然后包含一个调用该虚方法的方法,如:

    public class MyClass2 : IMsg
    {
        protected virtual void OnMessage()
        {
        }
        public void Message()
        {
            OnMessage();
            Console.WriteLine("MyClass");
        }
    }

任何派生类都能重写OnMessage方法,还可以在Message方法中增加它们自己的工作。.NET事件方法几乎都用这种模式。
  基类能提供一个缺省的接口方法实现,然后派生类可以通过继承基类声明并实现接口方法,如:

    public class DefaultMessageGenerator
    {
        public void Message()
        {
            Console.WriteLine("This is a default message");
        }
    }
    public class AnotherMessageGenerator :
    DefaultMessageGenerator, IMsg
    {
        // No explicit Message() method needed.
    }

注意派生类能声明这个接口作为它自己契约的一部分,即使它没有提供IMsg方法的实现,它通过继承基类的方法,隐式实现了该接口方法。


24 使用委托来表示回调
  回调函数用来从服务器向客户端异步地提供一个反馈。它们可能涉及多线程,或者简单提供一个同步更新的入口点。回调函数在C#中通过委托来表现。
  委托提供一个类型安全的回调函数定义。虽然委托用的最多的是事件,但这不是委托唯一能用的地方。委托让你在运行时配置目标,并且通知多个客户端。一个委托就是一个包含方法引用的对象。包含的方法可以是静态方法或者实例方法。使用委托,你可以在运行时与一个或多个客户端对象交流、配置。
  C#提供了一个紧凑的语法(lambda表达式)来表达委托。.NET框架库定义了很多常见的委托形式,如:Predicate<T>, Action<>, and Func<>.predicate是一个用来测试条件的布尔函数。Func<>需要一些数值参数,然后产生一个结果。也就是Func<T, bool>和Predicate<T>有相同的形式。Action<>输入任何数量的参数,然后返回一个void类型。LINQ就是建立在这些概念上的。
  List<T>类也包含了很多利用回调函数的方法,如:
List<int> numbers = Enumerable.Range(1, 200).ToList();
var oddNumbers = numbers.Find(n => n % 2 == 1);
var test = numbers.TrueForAll(n => n < 50);
numbers.RemoveAll(n => n % 2 == 0);
numbers.ForEach(item => Console.WriteLine(item));
Find()方法接收一个委托,以Predicate<int>的形式来测试列表中的每一个元素。这是一种简单的回调。List.ForEach()方法在每个列表元素中执行指定的动作。实际上编译器将lambda表达式转换为一个方法,然后创建一个委托来指向该方法.所有的LINQ都是建立在委托上的。在WPF和Windows Form中,回调是用来处理跨线程的封送处理的。
  由于历史原因,所有的委托都是多播委托。多播委托封装所有的目标函数然后添加在一个调用里。这种构造存在两个问题:一个是在面对异常时不安全,另一个是返回值将是最后一个目标函数调用的返回值。


25 实现事件模式的通知
  .NET的事件模式,无非是观察者模式的一个语法转换而已。事件定义了你的类的通知。事件基于委托提供了一个类型安全的函数签名。
  考虑一个简单的例子。你已经建立了一个log类,它是一个应用的所有消息的调度器。它将接收应用的所有消息,并且调度这些消息到对其感兴趣的监听者上。这些监听者可能是依附在控制台、数据库、系统日志等等,定义如下:

public class LoggerEventArgs : EventArgs
    {
        public string Message { get; private set; }
        public int Priority { get; private set; }
        public LoggerEventArgs(int p, string m)
        {
            Priority = p;
            Message = m;
        }
    }
    public class Logger
    {
        static Logger()
        {
            theOnly = new Logger();
        }
        private Logger()
        {
        }
        private static Logger theOnly = null;
        public static Logger Singleton
        {
            get { return theOnly; }
        }
        // Define the event:
        public event EventHandler<LoggerEventArgs> Log;
        // add a message, and log it.
        public void AddMsg(int priority, string msg)
        {
            // This idiom discussed below.
            EventHandler<LoggerEventArgs> l = Log;
            if (l != null)
                l(this, new LoggerEventArgs(priority, msg));
        }
    }

AddMsg方法展示了合适的抛出异常的方式。在多线程程序的静态条件上引用log事件句柄的临时变量是很重要的保护措施。C#编译器为事件创建了add和remove访问器:
public event EventHandler<LoggerEventArgs> Log
{
  add { log = log + value; }
  remove { log = log - value; }
}
log的使用:

    class ConsoleLogger
    {
        static ConsoleLogger()
        {
            Logger.Singleton.Log += (sender, msg) =>
            {
                Console.Error.WriteLine("{0}:\t{1}",
                msg.Priority.ToString(),
                msg.Message);
            };
        }
    }