new keyword not forcing hiding OOP C#

I have the following scenario:

I want to mock an interface so I can unit test my app. I am trying not to create a new mock class implementing my interface but creating a new class that inherits the original concrete class and use new keyword to force new behaviour when that method would be called. But for some reason, the concrete classs' method is being called and not the class that I created (as a mock)

Following Code:

public interface IMyService 
{ 
    Model GetModelData(int id)
}

public class MyService : IMyService
{
    public Model GetModelData(int id)
    { 
       //call to db     
    }
}

public class MyService2 : MyService
{
    public MyService2()
        : base(new MyRepository())
    {    
    }

    public new Model GetModelData(int id)
    { 
        return new Model();
    }
}

Injecting dependency:

x.ForRequestedType<IMyService>().TheDefaultIsConcreteType<MyService2>();

Retrieving the concrete class : on debugging I can see myService points to MyService2 class but the method executes on MyService class.

_myServie = ObjectFactory.GetInstance<IMyService>();
                Model modelData = _myServie.GetModelData(5);
Jon Skeet
people
quotationmark

Just using new creates a new method without associating it with the interface. You're using the interface in your real code (I assume) so you want the binding of the interface method to the new method. To do that, you have to declare that you're implementing the interface again. Here's an example showing the difference:

using System;

interface IFoo
{
    void Bar();
}

class Normal : IFoo
{
    public void Bar()
    {
        Console.WriteLine("Normal.Bar");
    }
}

class Extended1 : Normal
{
    public new void Bar()
    {
        Console.WriteLine("Extended1.Bar");
    }
}

class Extended2 : Normal, IFoo
{
    public new void Bar()
    {
        Console.WriteLine("Extended2.Bar");
    }
}

class Test
{
    static void Main()
    {
        IFoo x = new Extended1();
        IFoo y = new Extended2();

        x.Bar();
        y.Bar();
    }
}

Output:

Normal.Bar
Extended2.Bar

So if you change your class declaration to:

public class MyService2 : MyService, IMyService

you should find it just works. I can't say I'm a big fan of this approach, mind you - anything within MyService which calls the method will call its own implementation unless it happens to call through an IMyService-type reference. You could make the interface implementation in your concrete class virtual and override it in your subclass instead; that would be better in someways but worse in others. Basically, this sort of "half-inheritance" feels pretty fragile to me.

I suspect it would be cleaner if you had an abstract base class that both your real implementation and your test implementation derived from...

people

See more on this question at Stackoverflow