सी #: एफ # में एक एक्सटेंशन विधि को "साथ" के रूप में परिभाषित करने के लिए कैसे करें?

Question

एफ # "के साथ", उदाहरण के लिए एक सुविधाजनक सुविधा है:

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

एफ # बनाई कीवर्ड "के साथ" के रूप में रिकॉर्ड प्रकारों डिफ़ॉल्ट अपरिवर्तनीय द्वारा कर रहे हैं।

अब, क्या सी # में समान एक्सटेंशन को परिभाषित करना संभव है? मुझे यकीन है कि कैसे एक स्ट्रिंग

Name="Test2" 

एक प्रतिनिधि या अभिव्यक्ति को

कन्वर्ट करने के लिए नहीं कर रहा हूँ यह थोड़ा मुश्किल है, सी # में के रूप में लगता है?

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 
} 

या, एक प्रति निर्माता का उपयोग कर:

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); 
} 

और जॉर्ज उत्कृष्ट सुझाव पर एक मामूली बदलाव, जो एक से अधिक कार्य के लिए अनुमति देता है:

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); 
} 

मैं शायद दूसरे के बाद से उपयोग करूंगा (1) किसी भी सामान्य प्रयोजन समाधान को अनावश्यक रूप से धीमा और गड़बड़ाना होगा; (2) यह आपके इच्छित चीज़ों के निकटतम वाक्यविन्यास है (और वाक्यविन्यास जो आप उम्मीद करते हैं); (3) एफ # कॉपी-एंड-अपडेट एक्सप्रेशन समान रूप से कार्यान्वित किए जाते हैं।

Answer 2

हो सकता है कि कुछ इस तरह:

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

लैम्ब्डा फ़ंक्शन के विकल्प के रूप में, आप डिफ़ॉल्ट मानों के साथ पैरामीटर का उपयोग कर सकते हैं। केवल मामूली मुद्दा आप कुछ डिफ़ॉल्ट मान का मतलब है कि (संदर्भ प्रकार के लिए) इस पैरामीटर में परिवर्तन नहीं करते लेने के लिए है कि है, लेकिन null एक सुरक्षित विकल्प होना चाहिए:

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"); 

आप विधि अपने आप को परिभाषित करने के लिए है , लेकिन यह हमेशा मामला है (जब तक कि आप प्रतिबिंब का उपयोग नहीं कर रहे हैं, जो कम कुशल है)। मुझे लगता है कि वाक्यविन्यास भी काफी अच्छा है। यदि आप इसे F # में जितना अच्छा बनाना चाहते हैं, तो आपको F # :-)

Answer 4

किसी एक्सटेंशन विधि के C# में कम करने की कोई मूल क्षमता नहीं है, लेकिन किस कीमत पर? एक और ख संदर्भ प्रकार और एक कारणों तत्काल भ्रम पर किसी भी सुझाव है कि ख आधारित है कि कितने वस्तुओं हम साथ काम कर रहे है के रूप में ("के साथ") कर रहे हैं। क्या केवल एक है? बी की एक प्रति? बी?

सी # एफ # नहीं है।

के रूप में एरिक Lippert द्वारा उत्तर दिया कृपया मेरा एक पिछले तो सवाल यह देखें:

"स्पष्ट कोड लिखने के लिए अंगूठे का मेरा नियम के बीच है: बयान में सभी दुष्प्रभाव डाल; गैर बयान भाव कोई साइड होना चाहिए प्रभाव। "

More fluent C#/.NET