es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

  • es.davy.ai/
  • Programación /
  • C# Cómo hacer referencia a la implementación de la interfaz predeterminada en una clase implementadora.

C# Cómo hacer referencia a la implementación de la interfaz predeterminada en una clase implementadora.

30 May, 2023 Programación

Considere la siguiente interfaz, con una implementación predeterminada de TestMethod

lang-c#
public interface TestInterface
{
public int TestMethod()
{
return 15;
}
}

Llamar a TestMethod en la siguiente clase causará una excepción StackOverflowException:

lang-c#
public class TestClass : TestInterface
{
public int TestMethod()
{
return 1 + (this como TestInterface).TestMethod();
}
}

Ahora entiendo por qué sucede esto, pero ¿hay alguna manera de solucionarlo? ¿Algo como base.TestMethod() para hacer referencia a una de las interfaces implementadas por la clase?

Sé que podría cambiar el nombre del método en TestInterface y hacer referencia a él de esa manera en TestClass, pero eso causaría problemas para otras clases que no necesitan hacer referencia a la implementación predeterminada.

Tags:  , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Como experto en IT especializado en C#, interfaces e implementación por defecto, entiendo el problema que se plantea al llamar al TestMethod en la TestClass. Esta llamada causará un bucle infinito de llamadas recursivas entre TestMethod en la TestClass y la implementación por defecto de TestMethod en la TestInterface, resultando en una StackOverflowException.

    Para solucionar este problema, una forma es utilizar la implementación explícita de interfaces. Esto significa implementar el método de la interfaz de forma explícita en la clase, sin exponerlo como un miembro público de la clase. La sintaxis para implementar explícitamente un método de interfaz es la siguiente:

    “`lang-c#
    public class TestClass : TestInterface
    {
    int TestInterface.TestMethod()
    {
    return 1 + (this as TestInterface).TestMethod();
    }
    }


    De esta manera, el `TestMethod` en `TestClass` no es lo mismo que la implementación por defecto de `TestMethod` en `TestInterface`. En su lugar, el `TestMethod` en `TestClass` es una implementación explícita del `TestMethod` de `TestInterface` y solo se puede llamar a través de una referencia a la interfaz. Esto elimina la llamada recursiva a la implementación predeterminada y evita la StackOverflowException.

Otra forma es utilizar la composición en lugar de la herencia. En lugar de implementar la `TestInterface` en la `TestClass`, puede hacer que sea una propiedad de la `TestClass` y llamar a su método `TestMethod` a través de esa propiedad. Por ejemplo:

```lang-c#
public class TestClass
{
    private TestInterface testInterface = new TestInterfaceImpl();

    public int TestMethod()
    {
        return 1 + testInterface.TestMethod();
    }

    private class TestInterfaceImpl : TestInterface
    {
        public int TestMethod()
        {
            return 15;
        }
    }
}

    De esta manera, la TestClass tiene una propiedad privada testInterface que es una instancia de una clase anidada privada TestInterfaceImpl que implementa la TestInterface. La TestClass puede llamar al TestMethod de la TestInterface a través de la propiedad testInterface, sin necesidad de herencia o implementación por defecto.

    Ambos enfoques tienen sus ventajas y desventajas, y la elección depende de los requisitos específicos y el diseño de la aplicación. Sin embargo, ambos proporcionan formas de solucionar el problema de las llamadas recursivas a la implementación de interfaz predeterminada y evitar la StackOverflowException.

Comments are closed.