如何使用带接口的方法

Question

I'm not sure if the terms I'm using is right or not, but basically I want something like this.

public interface IMovements
{
    Boolean Run(string mammal);
}

public MovementService: IMovement
{
    public Boolean Run(string mammal)
    {
       if(mammal == human)
       {
         Console.WriteLine("Human is now running");
         return true;
       }
       else
       {
         Console.WriteLine("This creature can't run");
         return false;
       }
    }
}

Then in the main class I just wanna call just the interface to execute the run operation.

[Dependency]
IMovement Mov {get; set; }

//Do something with Mov
Mov.Run("Human");

Move.Run("Worm");

And the output would be:

Human is now running
This creature can't run

Answer 1

If you want to inject dependency as an interface you have options like

• constructor injection where you pass interface and Dependency injection framework like Ninject will instantiate it for you
• property injection as you describe. MEF from Microsoft can do this with [Import] Attribute. And also Unity with [Dependency] Attribute.

Answer 2

This seems to be about a classical Interface misconception. A bit of history: The Designers of .NET wanted to avoid a lot of problems that were common at the time.

Multiple Inheritance leads to the Diamond problem and it is one of the things they wanted to solve. So they decided: In .NET there will be Single Inheritance only.

But with single inhertiance has it's own set of issues so they needed to invent something close to multiple Inheritance it, without creating the Diamond Problem. Interfaces were the solution.

Interfaces are - in lack of a better term - more abstract then a abstract class.

• A abstrtact class may or may not include code. That is up to the programmer writing it
• A interface can not ever incldue code

You can only put one abstract calss into the inheritance chain. But you can put as many Interfaces as you want there. As they lack function implementations, they never cause that diamond problem.