मानक (ओब्जे प्रेषक, EventArgs args) हस्ताक्षर के साथ एक ईवेंट हैंडलर प्रतिनिधि बनाने के लिए यह कितना गलत है?

Question

मैं मानक एमएस इवेंट हैंडलर प्रतिनिधि हस्ताक्षर का उपयोग करने के लाभों को समझता हूं क्योंकि यह आपको पुरानी प्रतिनिधि हस्ताक्षर पर आधारित पुराने संबंधों को तोड़ने के साथ घटना के माध्यम से पारित जानकारी पर आसानी से विस्तार करने की अनुमति देता है।

जो मैं सोच रहा हूं वह इस अभ्यास में है कि लोग इस नियम का कितनी बार पालन करते हैं? मेरे पास कहने के इस तरह एक साधारण घटना

public event NameChangedHandler NameChanged; 
public delegate void NameChangedHandler(Object sender, string oldName, string newName); 

यह एक साधारण घटना है, और मैं लगभग सकारात्मक है कि केवल तर्क मैंने कभी जा रहा हूँ पता करने के लिए NameChanged घटना से वस्तु जिसका नाम बदल दिया है की जरूरत करने के लिए कर रहा हूँ, पुराना नाम, और नया नाम। तो क्या यह एक अलग NameChangedEventArgs वर्ग बनाने के लिए लायक है, या इस तरह की सरल घटनाओं के लिए सीधे प्रतिनिधियों के तर्कों के माध्यम से सीधे तर्कों को वापस करने के लिए स्वीकार्य है?

Answer 1

आप यदि आप केवल एक है जो इसे से निपटने के लिए है रहे हैं कुछ भी गलत तरीके से कर सकते हैं। लेकिन मानकों को सीखना और उनके साथ रहना बुरा विचार नहीं है ताकि जब आप दूसरों के साथ कोड पर काम कर रहे हों तो आप अच्छी आदतें रखें।

तो मैं आपको एक सौदा कर दूंगा। यदि आप इसे सही तरीके से करने का वादा करते हैं, तो मैं आपको एक कोड स्निपेट दूंगा जो इसे दर्द से बहुत कम कर देगा। \ विजुअल स्टूडियो 2008 \ कोड स्निपेट्स \ विजुअल C# \ मेरे कोड स्निपेट्स \
(या विजुअल स्टूडियो 2005 यदि लागू हो)

मेरे दस्तावेज़: बस इस एक .snippet फ़ाइल में डाल दिया, और उस फ़ाइल डाल और यहां स्निपेट है; ev2Generic टाइपिंग और टैब मारकर वी.एस. में इसका इस्तेमाल करते हैं:

<?xml version="1.0" encoding="utf-8" ?> 
<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet"> 
    <CodeSnippet Format="1.0.0"> 
    <Header> 
     <Title>Generic event with two types/arguments.</Title> 
     <Shortcut>ev2Generic</Shortcut> 
     <Description>Code snippet for event handler and On method</Description> 
     <Author>Kyralessa</Author> 
     <SnippetTypes> 
     <SnippetType>Expansion</SnippetType> 
     </SnippetTypes> 
    </Header> 
    <Snippet> 
     <Declarations> 
     <Literal> 
      <ID>type1</ID> 
      <ToolTip>Type of the first property in the EventArgs subclass.</ToolTip> 
      <Default>propertyType1</Default> 
     </Literal> 
     <Literal> 
      <ID>arg1Name</ID> 
      <ToolTip>Name of the first argument in the EventArgs subclass constructor.</ToolTip> 
      <Default>property1Name</Default> 
     </Literal> 
     <Literal> 
      <ID>property1Name</ID> 
      <ToolTip>Name of the first property in the EventArgs subclass.</ToolTip> 
      <Default>Property1Name</Default> 
     </Literal> 
     <Literal> 
      <ID>type2</ID> 
      <ToolTip>Type of the second property in the EventArgs subclass.</ToolTip> 
      <Default>propertyType2</Default> 
     </Literal> 
     <Literal> 
      <ID>arg2Name</ID> 
      <ToolTip>Name of the second argument in the EventArgs subclass constructor.</ToolTip> 
      <Default>property2Name</Default> 
     </Literal> 
     <Literal> 
      <ID>property2Name</ID> 
      <ToolTip>Name of the second property in the EventArgs subclass.</ToolTip> 
      <Default>Property2Name</Default> 
     </Literal> 
     <Literal> 
      <ID>eventName</ID> 
      <ToolTip>Name of the event</ToolTip> 
      <Default>NameOfEvent</Default> 
     </Literal> 
     </Declarations> 
     <Code Language="CSharp"> 
     <![CDATA[public class $eventName$EventArgs : System.EventArgs 
     { 
     public $eventName$EventArgs($type1$ $arg1Name$, $type2$ $arg2Name$) 
     { 
      this.$property1Name$ = $arg1Name$; 
      this.$property2Name$ = $arg2Name$; 
     } 

     public $type1$ $property1Name$ { get; private set; } 
     public $type2$ $property2Name$ { get; private set; } 
     } 

     public event EventHandler<$eventName$EventArgs> $eventName$; 
      protected virtual void On$eventName$($eventName$EventArgs e) 
      { 
       var handler = $eventName$; 
       if (handler != null) 
        handler(this, e); 
      }]]> 
     </Code> 
    </Snippet> 
    </CodeSnippet> 
</CodeSnippets> 

Answer 2

अपने ईवेंट के लिए EventHandler<T> जेनेरिक प्रतिनिधि का उपयोग करें और अपना ईवेंट डेटा रखने के लिए EventArgs से प्राप्त एक प्रकार का निर्माण करें। तो दूसरे शब्दों में, हमेशा। यह ऐसा कुछ है जिसे आप हमेशा जानते हैं कि जब आप इसे पार करते हैं तो यह कैसे काम करता है क्योंकि यह अन्यथा कभी नहीं किया जाता है।

संपादित करें:

कोड विश्लेषण CA1003: Use generic event handler instances
कोड विश्लेषण CA1009: Declare event handlers correctly

Answer 3

व्यवहार में कितनी बार लोग [नहीं उपयोग EventArgs व्युत्पन्न वर्ग] है।

मुझे कभी ऐसा समय नहीं मिला है जब EventArgs व्युत्पन्न कक्षाओं का उपयोग नहीं किया गया है। जैसा कि आप स्वयं कहते हैं, यह बाद में आपके कोड को बदलने की आपकी क्षमता को बढ़ाता है। मैं यह भी तर्क दूंगा कि पठनीयता में सुधार हुआ है, क्योंकि यह देखना आसान है कि यह एक ईवेंट हैंडलर है।

यह इसे इस तरह सरल घटनाओं के लिए एक अलग NameChangedEventArgs वर्ग बनाने के लिए, या लायक है यह स्वीकार्य सिर्फ प्रतिनिधि तर्क के माध्यम से सीधे तर्क वापस जाने के लिए है?

आप ऐसा कह रहे हैं कि आप इवेंट हैंडल के लिए ईवेंट पैरागर्स के लिए अधिक पैरा के साथ ईवेंट का उपयोग करेंगे और इस तरह के उदाहरणों के लिए इसका उपयोग नहीं करेंगे। ईमानदारी से, सी # में प्रोग्रामिंग करते समय यह एक विकल्प नहीं है।संगठनात्मकता जरूरी है, विशेष रूप से इस तरह की फोरम की दुनिया की दुनिया में, ओपन सोर्स प्रोजेक्ट इत्यादि, जहां इसे खोना आसान है। निश्चित रूप से यदि आप इसे एक चट्टान के नीचे प्रोग्रामिंग कर रहे हैं, तो आप जो भी चाहें कर सकते हैं, लेकिन अधिक सी # समुदाय निम्नलिखित मानकों के लिए आपको धन्यवाद देगा और विशेष रूप से आपके कोड में स्थिरता का उपयोग करेगा।