什么是C＃中的界面强制转换？

Question

I do understand how writing an interface works in C#, as for example described here: codeguru explanation

interface IIntelligence
   {
      bool intelligent_behavior();
   }

   class Human: IIntelligence
   {
      public Human()
      {
          //.............
      }

/// Interface method definition in the class that implements it
      public bool intelligent_behavior()
      {
         Console.WriteLine("........");
         return true
      }
   }

I am however confused about the following process of interface casting:

Human human = new Human();
// The human object is casted to the interface type
IIntelligence humanIQ = (IIntelligence)human;
humanIQ.intelligent_behavior();

What is the sense of having a class ( Human in this case) implement an interface, and then casting its instance human back to the interface? The question is not how it works, but why it is done.

Answer 1

.net offers two types of interface implementations implicit implementation and explicit implementation.

When you are using implicit implementation , it will become part of the type interface itself for example if you have a IPerson interface like this :

public interface IPerson
{
string Name{get;}
}

and you implement it as follows :

public class Person:IPerson
{
public string Name{get; ....}
}

you can access it like this (implicitly):

aPerson.Name;

but if you implement it like this (explicitly) :

public class Person:IPerson
{
string IPerson.Name{get; ....} // notice that there's no need to include access modifier.
}

Then it can only be accessed using IPerson interface:

((IPerson)aPerson).Name;

UPDATE:

Actually ,explicit interface implementation allow us to implement different interfaces with members that have same name.(as shown in this Tutorial )

Answer 2

有时您可能不知道对象是什么，但您知道它实现了某个接口。

Answer 3

I found out casting to interface useful when developing plugins for main application. I created three projects. First project 'connectorInterface' contains only one class definition which is inteface. Interface code:

public interface IConnectorDataReader
{
  int ColumnCount
  {
    get;
  }

  bool readNextRecord();

  string this[int i]
  {
    get;
  }

  void reset();
}

Second project 'dataSource1' (plugin for main application) implements IConnectorDataReader interface and also class that implements interface has some additional private methods. Third project 'main application' when using plugin 'dataSource1' uses this code to read data from plugin 'dataSource1':

  Assembly assembly = Assembly.LoadFile(path); // path to dll
  Type type = assembly.GetType("dataSource1.DataReader");
  object myInstance = Activator.CreateInstance(type);

  MethodInfo method = type.GetMethod("getConnectorDataReader");
  object data = method.Invoke(myInstance, null);

  IConnectorDataReader reader =(IConnectorDataReader)data;

  // method usage
  while (reader.readNextRecord() == true) ....

In my case casting is useful to read plugins data. I do not care how plugin is implemented as long as it implements common interface. All I care and use is common methods for reading data. I suppose interfaces are useful and also casting back to interfaces.

Answer 4

It's to get access to explicit interface implementation.

Sometimes you want to hide the fact that a class implements an interface. This is done by implementing the interface explicitly.

public class MyClass : IInterface
{
     string IInterface.TheMethod(){}
}

Answer 5

出于同样的原因，您将派生类强制转换回它的基类。

Answer 6

A brief and popular example. We can implement such code: interface IIntelligence { string Talk(); }

   class Cat: ICreature
   {
      public string Talk()
      {
         Console.WriteLine("Meow!");
         return true
      }
   }

   class Dog: ICreature
   {
      public string Talk()
      {
         Console.WriteLine("Arf!");
         return true
      }
   }

   class Human: ICreature
   {
      public string Talk()
      {
         Console.WriteLine("Hello!");
         return true
      }
   }

And then we can use following code:

ICreature() creatures = new ICreature(){new Human(), new Dog(), new Cat()};
foreach(IIntelligence creature in creatures){
  Console.WriteLine(creature.Talk());
}

For more detailed information, see "Polymorphism in object-oriented programming" in google.

Answer 7

Consider this situation. I've added a method to your example.

interface IIntelligence
{
    bool intelligent_behavior();
}

class Human: IIntelligence
{
    public Human() { }  

    /// Interface method definition in the class that implements it
    public bool IIntelligence.intelligent_behavior()
    {
        Console.WriteLine("........");
        return true;
    }    

    //Some other method definition
    public bool intelligent_behaviour()
    {
        return false;
    }
}

You would cast to IIntelligence to get the method implementation you wanted.