sobrecarga - tipos de metodos en c#

Método con el mismo nombre y firma pero diferente tipo de devolución en C#

Question

Tuve una entrevista donde me preguntaron lo siguiente:

Pregunta: Un método con el mismo nombre y firma pero diferente tipo de devolución. ¿Es posible y cómo se llama este tipo me preguntó?

Alguien por favor me puede decir lo siguiente:

1. ¿Lo anterior es posible en cualquier escenario (como uno en la clase base y otro en la clase derivada al menos?) Si es así, ¿qué tipo es? ¿Te gusta la compilación o el polimorfismo en tiempo de ejecución?

2. En el polimorfismo de tiempo de compilación, ¿qué sucede si los tipos de métodos de retorno también son diferentes junto con la firma? Pero solo el nombre de la función es el mismo. ¿Es tiempo de compilación el polimorfismo todavía?

3. Al reemplazar, ¿qué sucede si tengo un tipo de retorno diferente pero el nombre y la firma del método son los mismos? Es posible ? (Él me hizo esta pregunta, respondí mal): () Por favor, ayúdame.

Gracias

Answer 1

Aunque la covarianza de tipo de retorno no es compatible con C #, es posible emularla mediante el uso explícito de la implementación y la ocultación de métodos. Ese es un patrón que se usa a fondo en las API de ADO.NET.

P.ej:

public interface ISomeValue { }
public abstract class SomeValueBase : ISomeValue { }
public class SomeValueImpl : SomeValueBase { }

public interface ISomeObject { ISomeValue GetValue(); }

public abstract class SomeObjectBase : ISomeObject
{
    ISomeValue ISomeObject.GetValue() { return GetValue(); }
    public SomeValueBase GetValue() { return GetValueImpl(); }

    protected abstract SomeValueBase GetValueImpl();
}

public class SomeObjectImpl : SomeObjectBase
{
    protected override SomeValueBase GetValueImpl() { return GetValue(); }
    public new SomeValueImpl GetValue() { return null; }
}

Al hacer eso, el resultado neto de llamar a GetValue() es que siempre coincidirá con el tipo disponible más específico.

Answer 2

En C #, no puedes tener métodos como

int Foo() { return 1; }

void Foo() { return; }

Deben variar por más del tipo de retorno.

Si los argumentos son diferentes, entonces estás listo.

int Foo(string x) { return 1; }

void Foo(double x) { return; }

Answer 3

Hace poco tuve este problema exacto, ya que estaba analizando un archivo de configuración con varios tipos que usan una interfaz de tipo estándar tipo config.Parse (string settingName).

Método genérico de 1ª solución:

T Parse<T> (string settingName)
{
    T Result;
    doParsing...
    return T;
}

Realmente no me gustó esto, ya que implicaba especificar explícitamente el tipo que se está utilizando, como someSetting = Parse<float>("param");

Así que la solución que utilicé es redundante pero mucho más limpia en mi opinión:

T Parse<T> (string settingName, out T result)
{
    doParsing...
    return T;
}

La variable de salida y el retorno son idénticos, por lo que es un poco redundante, pero permite lo que creo que es una interfaz mucho más limpia:

setting = Parse("intparam", out setting);

Y obtiene métodos que varían solo según el tipo de devolución por un ligero costo de redundancia. Además de eso, si el tipo de sus datos cambia, por ejemplo, de un doble a un flotante, entonces todo seguirá funcionando bien, mientras que con la primera solución que obtendría no se pueden convertir errores de manera implícita.

Answer 4

Puede utilizar un tipo de retorno dynamic :

• dinámico (Referencia C #)
• Usando Type dynamic (C # Guía de programación)

Answer 5

Puedes hacerlo con interfaz

   public interface IMyInterface
{
    int Metoda1()enter code here`;
}
public class MyClass : test.IMyInterface
{
    public IMyInterface Metoda1()
    {
        return new MyClas();
    }
    int test.IMyInterface.Metoda1()
    {
        return 1;
    }
}
   static void Main(string[] args)
    {
        MyClass instance = new MyClass();
        IMyInterface inst = instance.Metoda1();
     /*   IMyInterface ints2 = inst.Metoda1(); //will not compile*/
        Console.WriteLine(inst.GetType().ToString()); ;
        object inst3 = inst.Metoda1();
        Console.WriteLine(inst3.GetType().ToString());
    }

Answer 6

Sí, es posible tener múltiples métodos con la misma firma pero diferentes tipos de retorno, utilizando la Implementación de Interfaz Explícita como se muestra aquí:

public interface I {
  int foo();
}

public class C : I {
  double foo() { return 2.0; }
  int I.foo() { return 4; }
}

Answer 7

Ya que esta es una pregunta de entrevista, puedes correr un poco con tu respuesta.

Estrictamente hablando, un método con diferente tipo de devolución y la misma firma no es posible. Sin embargo, en términos generales, hay muchas formas de implementar un método cuyo tipo de retorno de tiempo de ejecución concreto varía.

Uno está usando parámetros genéricos. Otra es devolver una interfaz o una súper clase con múltiples implementaciones. O bien, puede devolver un objeto, que se puede convertir a cualquier cosa.

Como muchos mencionaron, también puede usar la palabra clave "nueva" para devolver un tipo derivado del mismo método en una subclase.

Answer 8

sí, puede utilizar el mismo método, los mismos parámetros (necesidad de personalizar) y diferentes valores de retorno.

Simplemente siga los códigos a continuación, podría ayudarle.

public class myClass
{
    public int myReturn() { return 123; }
    public string myReturn(string temp = null) { return "test"; }
}

La cosa es que requiere un parámetro para hacer que se ejecuten las funciones, pero aún puede ignorar los parámetros, ya que tiene la string temp = null como parámetros opcionales, lo que significa que aún puede llamar a las funciones con o sin los parámetros.

Answer 9

Asumo que la pregunta es sobre covarianza de tipo de retorno

Permite que un método devuelva un tipo más derivado que el declarado en un tipo base, por ejemplo

public interface ISomeInterface
{
    object GetValue();
}

public class SomeClass : ISomeInterface
{
    public string GetValue() { return "Hello world"; }
}

Esto se admite en Java pero no en C #. Lo anterior no se compilará ya que el tipo de retorno de SomeClass.GetValue es una string no un object .

Tenga en cuenta que no puede sobrecargar los métodos basados ​​únicamente en el tipo de retorno, es decir, lo siguiente no es válido:

public class SomeClass
{
    public int GetValue() { return 1; }
    public string GetValue() { return "abc"; }
}

Podría hacer algo similar utilizando interfaces, aunque tendría que implementarlas explícitamente para desambiguar:

public interface IValue<T> { T GetValue(); }
public class SomeClass : IValue<int>, IValue<string>
{
    string IValue<string>.GetValue() { return "abc"; }
    int IValue<int>.GetValue() { return 1; }
}

Si los nombres son los mismos pero los parámetros son diferentes, entonces se trata de una sobrecarga de métodos. Esta es una forma de polimorfismo (polimorfismo ad hoc). Las sobrecargas se resuelven de forma estática en el tipo de compilación (a menos que esté usando dynamic en cuyo caso se difieren al tiempo de ejecución).

Puede sobrecargar tanto el número de parámetros como su tipo, por lo que todos los siguientes son válidos:

public void DoSomething(int value) { }
public void DoSomething(string value) { }
public void DoSomething(int value, string value) { }

Tenga en cuenta que puede variar el tipo de retorno de estos métodos: los métodos no solo pueden sobrecargarse solo por su tipo de retorno sino que pueden diferir si sus listas de parámetros son diferentes.

De nuevo, esto es una covarianza de tipo de retorno y no es compatible con C #.