强制转换实现接口中所有方法的类

Question

If a class happens to implement all of the methods in an interface (but doesn't explicitly implement it), is there a way of casting an instance of the class to that interface?

To demonstrate the issue I've set up the following simple classes. Scavenger is a demonstration class that I want to unit test.

The IFinder interface can be implemented by a dictionary (or could be implemented some other way). Finder is a sample implementation of the interface using a dictionary to handle the lifting.

//System under test
public class Scavenger
{
    private readonly IFinder _lookup;

    public Scavenger(IFinder lookup)
    {
        _lookup = lookup;
    }

    public string WhatIs(string key)
    {
        if (_lookup.ContainsKey(key)) return _lookup[key];
        return null;
    }
}

//Interface that can be met by a dictionary
public interface IFinder
{
    bool ContainsKey(string key);
    string this[string key] { get; set; }
}


//Implement IFinder using a dictionary
public class Finder : Dictionary<string,string>, IFinder
{
    public Finder()
    {
        this.Add("A","Hello");
        this.Add("B","Goodbye");
    }
}

I'd hoped to be able to setup a test for Scavenger along these lines...

    /// <summary>
    /// This will fail because due to failed cast a Dictionary to an IFinder
    /// </summary>
    [TestMethod]
    public void LookupUsingDictionary()
    {
        var dic = new Dictionary<string, string>();
        dic.Add("A","B");
        var scavenger = new Scavenger(dic as IFinder);
        var res = scavenger.WhatIs("A");
        Assert.AreEqual("B", res);
    }

The issue is that (dic as IFinder) == null . I know I can setup a mock class similar to Finder, or use a mocking framework, but I just want to check if I'm missing some way of casting a dictionary to do the job .

Answer 1

When you have an interface and a class that implements all of the appropriate methods, but doesn't implement the interface, you can use the adaptor pattern to accopmlish your goal. Create a class that implements the given interface and accepts an instance of the type that has all of the needed methods. It can then redirect all of the methods to the composed class:

public class DictionaryFinder : IFinder
{
    private Dictionary<string, string> dictionary;
    public DictionaryFinder(Dictionary<string, string> dictionary)
    {
        this.dictionary = dictionary;
    }


    public bool ContainsKey(string key)
    {
        return dictionary.ContainsKey(key);
    }

    public string this[string key]
    {
        get { return dictionary[key]; }
        set { dictionary[key] = value; }
    }
}

This allows you to write:

var scavenger = new Scavenger(new DictionaryFinder(dic));

Answer 2

No, you cannot do that. That's called duck typing and C# does not allow that.

Answer 3

You can use the dynamic keyword to accomplish this...

Make your scavenger class like this:

public class Scavenger
{
    private readonly dynamic _lookup;

    public Scavenger(dynamic lookup)
    {
        _lookup = lookup;
    }

    public string WhatIs(string key)
    {
        if (_lookup.ContainsKey(key)) return _lookup[key];
        return null;
    }
}

This will attempt to find the methods at runtime instead. See more at: http://msdn.microsoft.com/en-us/library/dd264741.aspx

Answer 4

You might be able to use ImpromptuInterface . I've used it to essentially do duck typing-like behavior.

C# does allow duck typing, to some degree, thanks to the dynamic language runtime introduced in 4.0 (I believe it was 4.0), just be very careful you don't burn yourself. ImpromptuInterface is proof of this.