clase - interfaces c#

Encontrar el tipo concreto detrás de una instancia de interfaz

Question

Para abreviar, tengo una función C # que realiza una tarea en un Tipo dado que se pasa como una instancia de Objeto. Todo funciona bien cuando se pasa una instancia de clase. Sin embargo, cuando el objeto se declara como una interfaz, realmente me gustaría encontrar la clase concreta y realizar la acción sobre ese tipo de clase.

Aquí está el mal ejemplo omnipresente (resplandeciente con carcasa de propiedad incorrecta, etc.):

public interface IA
{
    int a { get; set; }
}
public class B : IA
{
    public int a { get; set; }
    public int b { get; set; }
}
public class C : IA
{
    public int a { get; set; }
    public int c { get; set; }
}

// snip

IA myBObject = new B();
PerformAction(myBObject);

IA myCObject = new C();
PerformAction(myCObject);

// snip

void PerformAction(object myObject)
{
    Type objectType = myObject.GetType();   // Here is where I get typeof(IA)
    if ( objectType.IsInterface )
    {
        // I want to determine the actual Concrete Type, i.e. either B or C
        // objectType = DetermineConcreteType(objectType);
    }
    // snip - other actions on objectType
}

Me gustaría que el código en PerformAction use Reflection contra su parámetro y vea que no es solo una instancia de IA sino que es una instancia de B y para ver la propiedad "b" a través de GetProperties (). Si uso .GetType () obtengo el tipo de IA, no lo que quiero.

¿Cómo puede PerformAction determinar el tipo concreto subyacente de la instancia de IA?

Algunos podrían tener la tentación de sugerir el uso de una clase abstracta, pero esa es solo la limitación de mi mal ejemplo. La variable se declarará originalmente como una instancia de interfaz.

Answer 1

¿Qué estás haciendo realmente es el diseño de la cama, pero no tienes que usar el reflejo? Puedes comprobarlo así

void PerformAction(object myObject)
{
    B objectType = myObject as B;   // Here is where I get typeof(IA)
    if ( objectType != null )
    {
        //use objectType.b
    }
    else
    {
       //Same with A 
    }
    // snip - other actions on objectType
}

Answer 2

Nunca puedes tener instancias de una interfaz. Por lo tanto, no es posible determinar si se trata de una interfaz o un tipo concreto, ya que siempre se tratará de un tipo concreto. Entonces no estoy seguro de que tu pregunta tenga algún sentido. ¿Qué estás tratando de hacer exactamente y por qué?

Answer 3

Tal vez estás buscando el operador es

void PerformAction(object myObject)
{
    if (myObject is B)
    {
        B myBObject = myObject as B;
        myBObject.b = 1;
    }

    if (myObject is C)
    {
        C myCObject = myObject as C;
        myCObject.c = 1;
    }

    // snip - other actions on objectType
}

Answer 4

Tengo que estar de acuerdo sobre el mal diseño. Si tiene una interfaz, debe ser porque necesita utilizar algunas funcionalidades comunes sin preocuparse por la implementación concreta. Dado que eres un ejemplo, parece que el método PerformAction debería ser parte de la interfaz:

public interface IA
{
    int a { get; set; }
    void PerformAction();
}

public class B: IA
{
    public int a { get; set; }
    public int b { get; set; }

    public void PerformAction()
    {
        // perform action specific to B
    }
}

public class C : IA
{
    public int a { get; set; }
    public int c { get; set; }

    public void PerformAction()
    {
        // perform action specific to C
    }
}

void PerformActionOn(IA instance)
{
    if (instance == null) throw new ArgumentNullException("instance");

    instance.PerformAction();

    // Do some other common work...
}


B b = new B();
C c = new C();

PerformActionOn(b);
PerformActionOn(c);

Answer 5

Type objectType = myObject.GetType();

Todavía debería darle el tipo concreto, de acuerdo con su ejemplo.