- Por ejemplo
El encadenamiento de métodos (encadenamiento de métodos) es una sintaxis común en los lenguajes de programación orientados a objetos, que permite a los desarrolladores realizar múltiples llamadas a métodos para el mismo objeto mientras solo hacen referencia al objeto una vez. Aunque las llamadas en cadena no están incluidas en los 23 patrones de diseño, es un método de diseño de código de uso común.
Los métodos de extensión le permiten "agregar" métodos a un tipo existente sin tener que crear un nuevo tipo derivado, recompilar o modificar el tipo original. Un método de extensión es un método estático, pero se puede llamar como un método de instancia en un tipo de extensión.
Al escribir código, el uso de llamadas en cadena puede aclarar el comportamiento del código, mientras que los métodos de extensión pueden agregar comportamientos a los tipos sin modificar los tipos originales (incluidos los tipos integrados como int y string).
Por ejemplo, agregue métodos a los tipos int y string de C#:
usando Sistema;
usando System.Text;
espacio de nombres Proyecto de ejemplo
{
programa de clase
{
vacío estático Principal (cadena [] arg)
{
int núm = 1.Más(40)
.Más(9)
.Restar(2)
.Múltiples(10)
.Dividir(2);
string str = "¡Hola mundo!".Add(" Esto es C#.")
.Remove("Mundo");
Consola.WriteLine(núm);
Consola.WriteLine(cadena);
}
}
///<resumen>
/// Método de extensión de tipo int
///</summary>
clase estática pública clase1
{
int estático público Plus (este int num1, int num2)
{
devolver número1+núm2;
}
resta int estática pública (este int num1, int num2)
{
devolver número1-número2;
}
público estático int Multi (este int num1, int num2)
{
devolver número1*número2;
}
public static int Divide (este int num1, int num2)
{
devolver número1/núm2;
}
}
///<resumen>
///Método de extensión de tipo cadena
///</summary>
clase estática pública clase2
{
cadena estática pública Agregar (esta cadena str1, cadena str2)
{
devolver cadena1+cadena2;
}
cadena estática pública Eliminar (esta cadena str1, cadena str2)
{
cadena[] cadenas = str1.Split(nueva cadena[]{str2},StringSplitOptions.RemoveEmptyEntries);
cadena1 = "";
foreach (elemento var en cadenas)
{
str1+=elemento;
}
devolver cadena1;
}
}
}
//Producción:
//240
//¡Hola! Esto es C#.
- Escribir un código y verlo juntos
/// <resumen>
/// Ejemplo de programación en cadena en EntityFramwork
/// </summary>
vacío privado Ejemplo1()
{
usando (NorthwindEFEntities northwindEFEntities = new NorthwindEFEntities())
{
NorthwindEFEntidades.Empleados
.Donde(e => e.FirstName.StartsWith("C"))
.Select(e => e.Nombre)
.OrderBy(s => s);
}
}
Esta consulta básica realiza tres operaciones: 1. Buscar empleados cuyo nombre comience con C, 2. Obtener el nombre del empleado, 3. Ordenar los nombres.
- Solo se necesita una declaración en EF, y las tres se encadenan en una sola declaración a través de . Se pueden vincular más declaraciones más adelante.
El siguiente código tiene alguna evolución:
/// <resumen>
/// Ejemplo de programación en cadena 2
/// </summary>
vacío estático privado Ejemplo2()
{
Persona persona = nueva Persona { Nombre = "Tom" }
.Correr()
.Cantar()
.Nadar();
}
persona de clase
{
Nombre de cadena pública {obtener; colocar; }
Ejecución de persona pública()
{
Console.WriteLine("Ejecutar");
devolver esto;
}
persona pública nadar()
{
Console.WriteLine("Nadar");
devolver esto;
}
persona pública cantar()
{
Console.WriteLine("Cantar");
devolver esto;
}
}
Este código define la clase Peoson, que tiene tres operaciones: correr, nadar y cantar. Una vez completada la operación, devuelve esto (tener un valor de retorno es la clave para la programación en cadena). Devolver esto a sí mismo es como decir no te vayas después de ejecutar la operación. Hay (tal vez) otras operaciones por hacer, como en el Ejemplo 2: primero crea un Pueblo, primero ordena que corran, no descanses antes de cantar. , luego nada, nada bien.
La programación en cadena consiste en vincular múltiples operaciones (múltiples líneas de código) a través del punto "." en una oración de código. (La definición no es estricta, corríjala si sabe expresarse bien)
- Aquí hay una comparación del código normal y el código de cadena:
/// <resumen>
/// Comparación del ejemplo 3 de programación en cadena
/// </summary>
vacío privado Ejemplo3()
{
//código de cadena
Persona persona = nueva Persona { Nombre = "Tom" }
.Correr()
.Cantar()
.Nadar()
.Correr()
.Cantar()
.Nadar();
//código normal
Person person2 = new Person();
person2.Run();
person2.Sing();
person2.Swim();
person2.Run();
person2.Sing();
person2.Swim();
}
为了增强效果，都执行了两轮操作。个人感觉链式代码更加精炼简洁易读。
链式代码要求操作有返回值，但对于很多操作大都是void型，什么也不返回，这样就很难链起来了。当然也有解决办法，可能不太优雅。
- 使用扩展方法解决这个问题，首先引入一个泛型扩展：
/// <summary>
/// 先执行操作，再返回自身
/// </summary>
public static T Do<T>(this T t, Action<T> action)
{
action(t);
return t;
}
下面是调用示例，其中Student类操作都是void型的。
/// <summary>
/// 链式编程示例4
/// </summary>
private static void Example4()
{
new Student { Name = "Tom" }
.Do(s => s.Run())
.Do(s => s.Sing())
.Do(s => s.Sing())
.Do(s => s.Name = "Bob");
}
public class Student
{
public string Name { get; set; }
public void Run() { Console.WriteLine("Run"); }
public void Swim() { Console.WriteLine("Swim"); }
public void Sing() { Console.WriteLine("Sing"); }
}