C#: ¿cómo definir un método de extensión como "con" en F #?

Question

F # tiene una función muy cómoda "con", ejemplo:

type Product = { Name:string; Price:int };; 
let p = { Name="Test"; Price=42; };; 
let p2 = { p with Name="Test2" };; 

F # palabra clave creada "con", como los tipos de registro por defecto son inmutables.

Ahora, ¿es posible definir una extensión similar en C#? parece que es un poco complicado, ya que en C# no estoy seguro de cómo convertir una cadena

Name="Test2" 

a un delegado o expresión?

Answer 1

public static T With<T, U>(this T obj, Expression<Func<T, U>> property, U value) 
    where T : ICloneable { 
    if (obj == null) 
     throw new ArgumentNullException("obj"); 
    if (property == null) 
     throw new ArgumentNullException("property"); 
    var memExpr = property.Body as MemberExpression; 
    if (memExpr == null || !(memExpr.Member is PropertyInfo)) 
     throw new ArgumentException("Must refer to a property", "property"); 
    var copy = (T)obj.Clone(); 
    var propInfo = (PropertyInfo)memExpr.Member; 
    propInfo.SetValue(copy, value, null); 
    return copy; 
} 

public class Foo : ICloneable { 
    public int Id { get; set; } 
    public string Bar { get; set; } 
    object ICloneable.Clone() { 
     return new Foo { Id = this.Id, Bar = this.Bar }; 
    } 
} 

public static void Test() { 
    var foo = new Foo { Id = 1, Bar = "blah" }; 
    var newFoo = foo.With(x => x.Bar, "boo-ya"); 
    Console.WriteLine(newFoo.Bar); //boo-ya 
} 

O, usando un constructor de copia:

public class Foo { 
    public Foo(Foo other) { 
     this.Id = other.Id; 
     this.Bar = other.Bar; 
    } 
    public Foo() { } 
    public int Id { get; set; } 
    public string Bar { get; set; } 
} 

public static void Test() { 
    var foo = new Foo { Id = 1, Bar = "blah" }; 
    var newFoo = new Foo(foo) { Bar = "boo-ya" }; 
    Console.WriteLine(newFoo.Bar); 
} 

Y una ligera variación en excelente sugerencia de George, que permite múltiples tareas:

public static T With<T>(this T obj, params Action<T>[] assignments) 
    where T : ICloneable { 
    if (obj == null) 
     throw new ArgumentNullException("obj"); 
    if (assignments == null) 
     throw new ArgumentNullException("assignments"); 
    var copy = (T)obj.Clone(); 
    foreach (var a in assignments) { 
     a(copy); 
    } 
    return copy; 
} 

public static void Test() { 
    var foo = new Foo { Id = 1, Bar = "blah" }; 
    var newFoo = foo.With(x => x.Id = 2, x => x.Bar = "boo-ya"); 
    Console.WriteLine(newFoo.Bar); 
} 

Probablemente usaría el segundo, ya que (1) cualquier solución de uso general será innecesariamente lenta y complicada; (2) tiene la sintaxis más cercana a lo que desea (y la sintaxis hace lo que espera); (3) Las expresiones F # copy-and-update se implementan de manera similar.

Answer 2

Tal vez algo como esto:

void Main() 
{ 
    var NewProduct = ExistingProduct.With(P => P.Name = "Test2"); 
} 

// Define other methods and classes here 

public static class Extensions 
{ 
    public T With<T>(this T Instance, Action<T> Act) where T : ICloneable 
    { 
     var Result = Instance.Clone(); 
     Act(Result); 

     return Result; 
    } 
} 

Answer 3

Como alternativa a la función lambda, puede usar parámetros con valores predeterminados. El único problema es que usted tiene que escoger un valor por defecto que significa no cambia este parámetro (para los tipos de referencia), pero null debe ser una opción segura:

class Product { 
    public string Name { get; private set; } 
    public int Price { get; private set; } 
    public Product(string name, int price) { 
    Name = name; Price = price; 
    } 

    // Creates a new product using the current values and changing 
    // the values of the specified arguments to a new value 
    public Product With(string name = null, int? price = null) { 
    return new Product(name ?? Name, price ?? Price); 
    } 
} 

// Then you can write: 
var prod2 = prod1.With(name = "New product"); 

Usted tiene que definir el método mismo , pero ese es siempre el caso (a menos que vayas a utilizar el reflejo, que es menos eficiente). Creo que la sintaxis es razonablemente buena también. Si quieres hacerlo tan bonito como en F #, entonces tendrás que usar F # :-)

Answer 4

No hay una habilidad nativa para hacer esto en C# salvo un método de extensión, pero ¿a qué costo? un y b son los tipos de referencia y cualquier sugerencia de que b se basa ("con") en un causas confusión inmediata en cuanto a la cantidad de objetos que estamos trabajando. ¿Hay solo uno? Es b una copia de a? ¿Tiene b punto a a?

C# no es F #.

Por favor, vea una pregunta anterior, por lo mío como respondida por Eric Lippert:

"Entre mis reglas de oro para escribir código claro es: poner todos los efectos secundarios en los estados; expresiones no de los estados no deben tener ningún lado efectos. "

More fluent C#/.NET