如何将强制类型转换为接口

Question

I am trying to mock the ManagementObjectSearcher class and have created a IManagementInfo interface, so how can i cast the interface to the ManagementObjectSearcher class?

 ManagementObjectSearcher s = new ManagementObjectSearcher();
 IManagementInfo info = s as IManagementInfo;

this creates me a null info object

ManagementObjectSearcher s = new ManagementObjectSearcher();
 IManagementInfo info =IManagementInfo(s);

this gives me run time error (cannot typecast)

Answer 1

You cannot do that. Do you want to do it so that you can write unit tests? If you are trying to mock a class that you have no control of, then you have to wrap it in another class.

public class MyManagementObjectSearcherWrapper : IManagementInfo
{
    public void TheMethodToMock()
    {
        var searcher = new ManagementObjectSearcher();        
        // The code you want to mock goes here
    }
}

And you run your code like this:

public void YourCode(IManagementInfo info)
{
    info.TheMethodToMock();
}

Then YourCode() will take either your wrapper or the mocked object. You create your mock using the IManagementInfo interface.

Answer 2

It looks as if you are trying to wrap a 3rd party/system object in order to aid unit testing.

Say that your starting point is

public class Dependency {

    public string Foo() {
       return "foo";  // machine, system, time, something else, dependent result
    }

    public string Bar() {
       return "bar";
    }
}

public class MySimpleClass {

    public string MyFunc() {
         return new Dependency().Foo();
    }

}

[TestMethod]
public void TestSimple() {

    var client = new MySimpleClass();

    Assert.AreEqual("foo", client.MyFunc());

}

We are creating the Dependency inside the call because we are considering the creation cost to be less important than holding on to an instance of the Dependency. This will be dependent upon the situation. We could as easily have created a Dependency in the ctor and stored a copy which we invoked each time. Either way, we have no control over the output which makes unit testing messy.

We need to create a proxy for it.

1. Define an interface for the members that we need
Most likely, we do not need to use all of the members of the wrappee so only include in the interface those about which we care.

public interface IDependencyProxy {
    string Foo();
}

2. Create a Proxy Class
We then create a proxy class wrapping the dependency and implementing interface. Again, we can create at start or on a call by call basis.

public class DependencyProxy : IDependencyProxy {

    public string Foo() {
        return new Dependency.Foo();
    }

}

3. Define our client code in terms of the interface
We modify our client code slightly to use the IDependencyProxy interface instead of the Dependency. There are a few ways of doing this. I generally use an internal ctor which takes the dependency chained from a public ctor. (Use [InternalsVisibleTo] to allow the unit tests to see it)

public class MyRevisedClass {

    private readonly IDependencyProxy dependency;

    public MyRevisedClass() 
       : this( new DependencyProxy()) {}

    internal MyRevisedClass(IDependencyProxy dependency) {
        this.dependency = dependency;
    }

    public string MyFunc() {
        return dependency.Foo();
    }

}

This allows us a default behaviour for the production code (invokes the System object) and allows us to mock out the results for unit testing.

[TestMethod]
public void TestRevisedDefault() {

     var client = new MyRevisedClass();
     Assert.AreEqual("foo", client.MyFunc());

}


[TestMethod]
public void TestRevisedWithMockedDependency() {

    var dep = new Mock<IDependencyProxy>();
    dep.Setup(mk => mk.Foo()).Returns("bar");
    var client = new MyRevisedClass(dep.Object);

    Assert.AreEqual("bar", client.MyFunc());

}