एक अवलोकन योग्य <T> कक्षा बनाना: ओवरलोडिंग = ऑपरेटर?

Question

मैं एक वर्ग बनाने की कोशिश कर रहा हूं जिसमें मूल्य है, जब भी मूल्य बदलता है, तब भी एक ईवेंट बढ़ाएगा, और इसके द्वारा उस प्रकार के रूप में और उसमें से रूपांतरित रूप से परिवर्तित हो जाएगा।

मेरा लक्ष्य यह है कि मुझे कक्षा की एक अवलोकन संपत्ति बनाने में सक्षम होना चाहिए, और एक और वर्ग (डब्ल्यूपीएफ नियंत्रण सहित) को पढ़ने और लिखने में सक्षम होना चाहिए जैसे कि यह एक नियमित स्ट्रिंग था। अन्य वर्ग इसे एक अवलोकन के रूप में संदर्भित कर सकते हैं, या इसे नए कार्यक्रम बनाने के बिना इसे अपनी संपत्ति के रूप में भी बेनकाब कर सकते हैं।

using System; 
using System.ComponentModel; 

namespace SATS.Utilities 
{ 
    public class Observable<T> 
    { 
     private T mValue; 

     public event EventHandler ValueChanged; 
     public event PropertyChangedEventHandler PropertyChanged; 

     private void NotifyValueChanged() 
     { 
      if (ValueChanged != null) 
      { 
       ValueChanged(this, new EventArgs()); 
      } 
      if (PropertyChanged != null) 
      { 
       PropertyChanged(this, new PropertyChangedEventArgs("Value")); 
      } 
     } 

     public T Value 
     { 
      get 
      { 
       return mValue; 
      } 
      set 
      { 
       SetValueSilently(value); 
       NotifyValueChanged(); 
      } 
     } 

     public void SetValueSilently(T value) 
     { 
      mValue = value; 
     } 

     public static implicit operator T(Observable<T> observable) 
     { 
      return observable.Value; 
     } 

     public static T operator =(Observable<T> observable, T value) // Doesn't compile! 
     { 
      observable.Value = value; 
      return value; 
     } 
    } 
} 

समस्या यह है कि "=" ऑपरेटर शिकायत कर रहा है कि यह अतिभारित नहीं किया जा सकता है:

यहाँ मैं अब तक है। मुझे लगता है कि यह समझ में आता है, क्योंकि यह अजीब व्यवहार के सभी प्रकार के लिए नेतृत्व कर सकता है। क्या मैं हासिल करने के लिए एक और तरीका है जिसके लिए मैं जा रहा हूं?

संपादित करें: यहां बताया गया है कि मैंने इसे लागू करने का निर्णय लिया है। अगर कोई बेहतर सुझाव हैं तो मुझे बताएं :)

मुझे एहसास हुआ कि इस मामले को वास्तव में उस संपत्ति द्वारा संभाला जाना चाहिए जो पर्यवेक्षी है।

public class A 
{ 
    private readonly Observable<string> _property; 

    public Observable<string> Property 
    { 
     get { return _property; } 
    } 

    public string Property 
    { 
     set { _property.Value = value; } 
    } 
} 

बेशक

, कि क्योंकि संपत्ति दो बार परिभाषित किया गया है संकलन नहीं करता है: यहाँ मैं करना चाहते हैं क्या का एक उदाहरण है। यहाँ कुछ हद तक hackish वैकल्पिक हल है कि मैं एक अंतर्निहित रूपांतरण अन्य तरीके से परिभाषित करने की सोच रहा हूँ (के रूप में आप में से कई का सुझाव दिया है) है:

public static implicit operator Observable<T>(T value) 
{ 
    var result = new Observable<T>(); 
    result.SetValueSilently(value); 
    return result; 
} 

और संपत्ति के सेटर कॉल करने के लिए उपयोग कर रहा है कि:

public Observable<string> Property 
{ 
    get { return _property; } 
    set { _property.Value = value.Value; } 
} 

Answer 1

आप implicit ऑपरेटर को अधिभारित कर सकते हैं।

public static operator implicit string(YourObject object) 

और दूसरी तरह के

public static operator implicit YourObject(string s) 

ध्यान रखें जाना है, हालांकि, इस बहुत खतरनाक है। इससे कक्षा के उपभोक्ताओं को कुछ चीजें करने के लिए प्रेरित किया जा सकता है जिन्हें आपने कभी नहीं सोचा था; और कुछ व्यवहार जो समझ में नहीं आता है।

Answer 2

, एक और निहित रूपांतरण जोड़ें इन पंक्तियों के साथ:

public static implicit operator Observable<T>(T value) 
{ 
    return new Observable<T>{Value = value}; 
} 

Answer 3

आप Overloadable Operators in C# को देखें, तो आपको लगता है कि यह दिखाई देगा:

असाइनमेंट ऑपरेटरों अतिभारित नहीं किया जा सकता है, लेकिन + =, के लिए उदाहरण, + का उपयोग करके मूल्यांकन किया जाता है, जिसे अधिभारित किया जा सकता है।

आप एक implicit operator Observable<T>(T value) कर सकते हैं, तथापि, जो आप परोक्ष T से Observable<T> में बदलने की अनुमति होगी।

कहा जा रहा है, मैं इसकी अनुशंसा नहीं करता।मैं असाइनमेंट को स्पष्ट कर दूंगा, क्योंकि इसे नयाObservable<T> प्रत्येक बार कॉल करने की आवश्यकता होगी, जो आपके ईवेंट हैंडलर के साथ समस्याएं पैदा कर रहा है, क्योंकि प्रत्येक असाइनमेंट एक नया ऑब्जेक्ट उदाहरण बनाएगा।