摘要

任何一个C#入门的程序员都知道——当一个类型在实现接口的时候，有两种方法实现：显式实现、隐式实现。而且大家也都知道，当一个类型实现的两个接口存在相同成员定义时，显示实现可以解决这种情况。

 

但是，在一个命名比较规范的项目中，几乎不可能出现上述情况。

 

那么，显示实现有什么具体存在的意义吗？

本人根据这小几年的开发历经，感觉显式实现最觉的两个作用就是：

1. 改变接口成员的使用权限
2. 改变接口成员的出入参数

下面本人将会对这两种作用进一一说明

---

接口定义

本篇文章将会使用一个示例来讲述这两个作用。

我们先来看一下示例吧：

1. 定义一个接口类型，表示一个"元件"，元件拥有两个成员
   1. 元件名称，主要是用来和其它元件进行区分
   2. 使用元件，需要一个Object类型的参数，表示将元件使用在哪个目标对象上
2. 定义一个接口类型，表示一个"元件工厂"，用来生成"元件"的实例，元件工厂拥有两个成员
   1. 根据指定的元件名称，生成一个元件实例
   2. 注册一个元件，只有被注册过的元件才能够被生产

 

例子还是挺简单的，我们来把这些接口类型码出来吧：

/// <summary>
/// 一个元件接口
/// </summary>
interface IComponent
{
    /// <summary>
    /// 元件的名称，用于区别于其它元件
    /// </summary>
    String ComponentName { get; }

    /// <summary>
    /// 使用这个元件
    /// <param name="target">对哪个对象使用这个元件</param>
    /// </summary>
    void Use(Object target);
}

/// <summary>
/// 一个元件工厂接口
/// </summary>
interface IComponentFactory
{
    /// <summary>
    /// 创建元件
    /// </summary>
    /// <param name="componentName"></param>
    /// <returns></returns>
    IComponent CreateComponent(String componentName);

    /// <summary>
    /// 注册一个元件
    /// </summary>
    /// <param name="component"></param>
    void RegistComponent(IComponent component);
}

 

---

 

 

实现锁与钥匙的关系

光有接口，我们是无法工作的。因此我们开发一个叫钥匙的元件，再开发一个密码锁，钥匙可以用来开密码锁，当两者的编号相同时，锁才可以被打开。我们再做一个工厂，根据锁的编号生成一把钥匙，然后就可以开锁了。

我们先用隐式实现来做这件事

/// <summary>
/// 密码锁
/// </summary>
class PasswordLocker
{
    /// <summary>
    /// 开锁用的密码
    /// </summary>
    public String Code { get; set; }
}

/// <summary>
/// 钥匙
/// </summary>
class Key : IComponent
{
    /// <summary>
    /// 对应的解锁密码，只有和锁的Code相同时才可以开锁
    /// </summary>
    public string Code { get; set; }

    public string ComponentName
    {
        get { return this.Code; }
    }

    public void Use(object target)
    {
        //由于入参是继承了接口的Object类型，所以必须先对入参进行类型判断
        if (target is PasswordLocker)
        {
            PasswordLocker pl = (PasswordLocker)target;
            if (pl.Code == this.Code) Console.WriteLine("打开锁了");
            else Console.WriteLine("未能把锁打开");
        }
        else
            Console.WriteLine("目前类型不是锁，暂时不能使用该元件");

    }
}

/// <summary>
/// 钥匙工厂
/// </summary>
class KeyFactory : IComponentFactory
{
    private Dictionary<String, IComponent> components = new Dictionary<string, IComponent>();

    public IComponent CreateComponent(string componentName)
    {
        return components[componentName];
    }

    /// <summary>
    /// 由外部创建一个元件
    /// </summary>
    /// <param name="component"></param>
    public void RegistComponent(IComponent component)
    {
        components[component.ComponentName] = component;
    }
}

然后我们再写一代段码使用他们：

PasswordLocker locker = new PasswordLocker();
locker.Code = "12345";

Key k = new Key();
k.Code = "12345";
KeyFactory factory = new KeyFactory();
factory.RegistComponent(k);
factory.CreateComponent(locker.Code).Use(locker);

功能全部OK，但是有一些小小的瑕疵：

1. 这把钥匙从代码上看，还可以用在不是PasswordLocker的类型上，所以Use方法中还要对入参类型进行判断；
2. 明明是钥匙工厂，但从代码上看生产出来的依然只是元件接口类型，注册的时候也是，希能够直接使用钥匙类型；