¿Qué es fundición de interfaz para C#?

Question

entiendo cómo escribir una interfaz funciona en C#, como se describe, por ejemplo aquí: 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 
     } 
    } 

Sin embargo, estoy confundido sobre el siguiente proceso de fundición de interfaz:

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

Cuál es el sentido de tener una clase (Humanos en este caso) implementar una interfaz, y luego emitir su instancia humana de nuevo a la interfaz? La pregunta no es cómo funciona, pero por qué está hecho.

Answer 1

Es para tener acceso a la implementación de interfaz explícita.

Algunas veces desea ocultar el hecho de que una clase implementa una interfaz. Esto se hace implementando la interfaz de forma explícita.

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

Answer 2

A veces puede que no sepas qué es un objeto, pero sabes que implementa una determinada interfaz.

Answer 3

Por la misma razón, volverías a convertir una clase derivada en su clase base.

Answer 4

Un ejemplo breve y popular. Podemos implementar dicho código: interfaz IIntelligence { cadena 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 
     } 
    } 

Y entonces podemos utilizar siguiente código:

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

Para obtener información más detallada, consulte "polimorfismo en la programación orientada a objetos" en Google.

Answer 5

Tenga en cuenta esta situación. He agregado un método a tu ejemplo.

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; 
    } 
} 

Se lanzará a IIntelligence para obtener la implementación del método que desea.

Answer 6

.net ofrece dos tipos de implementaciones de interfaz implementación implícita e implementación explícita.

Cuando se está utilizando la aplicación implícita, se convertirá en parte del tipo de interfaz en sí, por ejemplo, si tiene una interfaz IPerson así:

public interface IPerson 
{ 
string Name{get;} 
} 

y ponerlo en práctica de la siguiente manera:

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

se puede acceder a ella como este (implícitamente):

aPerson.Name; 

pero si se implementa como este (explícitamente):

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

A continuación, sólo se puede acceder mediante la interfaz IPerson:

((IPerson)aPerson).Name; 

ACTUALIZACIÓN:

En realidad, la implementación de interfaz explícita nos permiten implementar diferentes interfaces con los miembros que tienen el mismo nombre. (como se muestra en this Tutorial)

Answer 7

Encontré la conversión a la interfaz útil cuando desarrollé g complementos para la aplicación principal. Creé tres proyectos. El primer proyecto 'connectorInterface' contiene solo una definición de clase que es inteface. código de la interfaz:

public interface IConnectorDataReader 
{ 
    int ColumnCount 
    { 
    get; 
    } 

    bool readNextRecord(); 

    string this[int i] 
    { 
    get; 
    } 

    void reset(); 
} 

segundo proyecto 'DataSource1' (plug-in para la aplicación principal) implementa la interfaz IConnectorDataReader y también la clase que implementa la interfaz tiene algunos métodos privados adicionales. 'Aplicación principal' cuando usando el plugin 'DataSource1' tercer proyecto utiliza este código para leer datos desde el 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) .... 

En mi caso casting es útil leer los datos de plugins. No me importa cómo se implementa el complemento siempre que implemente una interfaz común. Todo lo que me importa y uso son métodos comunes para leer datos. Supongo que las interfaces son útiles y también regresan a las interfaces.