Como soy nuevo en C#, me gustaría saber sobre Interfaces y Delegados en C#, la diferencia entre ellos y los escenarios que se utilizarán. Por favor, no proporcione ningún enlace, me gustaría una explicación en palabras simples.¿Qué son las interfaces y los delegados en C#?
Una cita de C# en Nutshell.
Un problema que se puede resolver con un delegado también se puede resolver con una interfaz .Por ejemplo, lo siguiente explica cómo resolver nuestro problema filtro utilizando una interfaz ITransformer:
public interface ITransformer
{
int Transform (int x);
}
public class Util
{
public static void TransformAll (int[] values, ITransformer t)
{
for (int i = 0; i < values.Length; i++)
values[i] = t.Transform (values[i]);
}
}
class Squarer : ITransformer
{
public int Transform (int x) { return x * x; }
}
...
static void Main()
{
int[] values = { 1, 2, 3 };
Util.TransformAll (values, new Squarer());
foreach (int i in values)
Console.WriteLine (i);
}
Un diseño delegado puede ser una mejor opción que un diseño de la interfaz cuando se cumplen uno o más de estas condiciones:
En el ejemplo de ITransformer, no es necesario multidifundir. Sin embargo, la interfaz define solo un único método. Además, nuestro suscriptor puede necesitar implementar ITransformador varias veces, para admitir diferentes transformaciones, como cuadrado o cubo. Con las interfaces, nos vemos obligados a escribir un tipo diferente por transformación, ya que la prueba puede implementar ITransformador solo una vez. Esto es bastante engorroso:
class Squarer : ITransformer
{
public int Transform (int x) { return x * x; }
}
class Cuber : ITransformer
{
public int Transform (int x) {return x * x * x; }
}
...
static void Main()
{
int[] values = { 1, 2, 3 };
Util.TransformAll (values, new Cuber());
foreach (int i in values)
Console.WriteLine (i);
}
Y aquí está el código con el delegado
public delegate int Transformer (int x);
class Util
{
public static void Transform (int[] values, Transformer t)
{
for (int i = 0; i < values.Length; i++)
values[i] = t (values[i]);
}
}
class Test
{
static void Main()
{
int[] values = { 1, 2, 3 };
Util.Transform (values, Square); // Dynamically hook in Square
foreach (int i in values)
Console.Write (i + " "); // 1 4 9
}
static int Square (int x) { return x * x; }
}
Una interfaz es un contrato: define los métodos y las propiedades que cualquier clase de implementación debe tener y, como tal, cualquier consumidor de la interfaz sabrá que existen y puede usarlos.
Un delegado es un sitio de devolución de llamada: define una firma de método que puede invocar cualquier método que tenga la misma firma.
Consulte delegates y interfaces en la guía de programación C#.
Un ejemplo de una interfaz es la interfaz IEnumerable. Solo tiene un miembro definido: GetEnumerator. Cualquier objeto que implemente esta interfaz tendrá este método y cualquier código que use dicho objeto puede llamar a este método.
Un ejemplo de un delegado es el delegado Predicate<T>. Es un delegado genérico que es define como la siguiente:
public delegate bool Predicate<in T>(T obj);
Esto significa que se necesita en cualquier tipo T y devuelve un bool. Cualquier método que tome un parámetro de tipo único y devuelva un bool coincide con este delegado y puede usarse con él.
Dado que los delegados también son objetos, se pueden pasar a las funciones. Por lo tanto, cualquier función que tenga un delegado Predicate<T> puede pasar en cualquier mathod que coincida con él. Muchos de los operadores de Linq tienen delegados como parámetros. Ver ejemplos here.
Una interfaz es una colección de métodos vinculados a un único objeto. (Nota al margen: los objetos pueden exponer múltiples interfaces, lo que les permite exhibir múltiples "personalidades").
Un delegado es una abstracción de una llamada a un solo método. Llamar a un delegado tiene el efecto de llamar a algún otro código, sobre el cual la persona que llama no sabe nada.
Una visión algo simplificada de las cosas que sin embargo da el sabor es pensar en un delegado como un caso especial de una interfaz con exactamente un método.
Una interfaz se puede considerar como una definición funcional (o contrato). En el mundo real, muchos objetos tienen interfaces bien conocidas que los hacen en gran medida (pero no completamente) intercambiables.
Por ejemplo, tome un automóvil. Una vez que aprenda a conducir un automóvil, aprenderá la "Interfaz de conducción de automóviles". Sabes que habrá una función Accelerate() y una función Stop() y, por lo general, una función ShiftGears() (incluso si solo la está sacando del parque y poniéndola en la unidad). También hay una función Steer() y una función SignalTurn().
No hay garantía de que una implementación determinada haga algo de la misma manera. Por ejemplo, un Toyota puede tener un método "Stop()" en su interfaz CarDriving que llame a Accelerate().
El automóvil puede admitir intefaces adicionales, como la interfaz de SeatBelt o la interfaz de Radio. Si bien cada implementación de estos objetos puede diferir, siempre hay un conjunto básico de funcionalidades que es común entre todos los tipos de estos objetos.Esto les permite ser utilizados en gran medida de forma intercambiable sin tener que volver a aprender una interfaz diferente.
Las interfaces en C# son similares. Las diferentes implementaciones de objetos pueden contener la misma implementación de interfaz, y lo que hacen puede ser diferente, pero puede tratar un objeto que implementa una interfaz específica de la misma manera que trata a otro objeto que implementa la misma interfaz.
Si entiende qué es la herencia, entonces otra forma de pensar en las interfaces es que son las mismas que una clase, pero no tienen implementación. Entonces, cuando una clase hereda de otra clase, hereda ambas clases "inteface" y es "implementación". Si una clase ingresa solo una interfaz, entonces carece de una implementación y la nueva clase debe crear esa implementación en sí misma.
Un delegado, es completamente diferente. Un delegado es (entre otras cosas) un puntero de función que es consciente de los objetos. Un puntero a la función es una variable, similar a otras variables, pero su tipo es "delegado" en lugar de "int" o "cadena". Y, en lugar de contener datos, contiene un puntero a un método (junto con cierta información de estado) para que pueda invocar dinámicamente diferentes funciones en tiempo de ejecución.
En el siguiente código, se corrige la llamada a "foo". No se puede, en tiempo de ejecución, decidir que desea llamar "barra" en su lugar:
DoSometing()
{
foo();
}
Si, en vez has hecho algo como lo siguiente, a continuación, puede pasar a diferentes métodos como argumentos para el método y tener que llamarlos dynically :
DoSomething(MyFunction func)
{
MyFunction myfunc = func;
myfunc();
}
Los delegados pueden hacer más que eso, pero esa es una forma básica de pensar en ellos.
OK, puedo hablar con usted en inglés. Eres humano. Puedo hablar con cualquier ser humano en inglés; No necesito conocer a todos los humanos en la tierra para hablarles en inglés; lo único que me importa es que hablan inglés.
Bien, entonces un humano es un objeto. Inglés es la interfaz.
Muchos humanos implementan la interfaz IEnglish!
Ahora aplique eso en un sentido clásico de la ingeniería. Tengo un auto y una batería de automóvil. Al automóvil no le importa qué tipo de batería, dónde se fabricó ni qué forma tiene. La batería no se preocupa por el automóvil. Son funcionalmente abstractos el uno del otro.
La batería proporciona energía e implementa la interfaz IBattery. El automóvil SÓLO aceptará objetos que implementen IBattery (es decir, objetos físicos que son baterías de automóvil !!)
Semánticamente, las interfaces y los delegados son en gran parte equivalentes. Una interfaz define qué hace un objeto (métodos y propiedades) ... y un delegado define lo que hace un método en particular. Los delegados indican los parámetros de una función o método ... son punteros de función seguros. Tendré que pensar más para encontrar un ejemplo de vida real para esto.
interfase? ¿Te refieres a Interface? – kennytm
mis disculpas, su interfaz. – Anuya
@karthik Podría ser útil que nos dijera con qué lenguajes de programación ya está familiarizado. Entonces podríamos relacionar interfaces y delegar conceptos que ya conocemos. –