Procedura: Pubblicare eventi conformi alle linee guida di .NET Framework (Guida per programmatori C#)How to: Publish Events that Conform to .NET Framework Guidelines (C# Programming Guide)

La procedura seguente illustra come aggiungere eventi che seguono lo schema .NET Framework standard a classi e struct.The following procedure demonstrates how to add events that follow the standard .NET Framework pattern to your classes and structs. Tutti gli eventi della libreria di classi .NET Framework si basano sul delegato EventHandler che è definito nel modo seguente:All events in the .NET Framework class library are based on the EventHandler delegate, which is defined as follows:

public delegate void EventHandler(object sender, EventArgs e);  

Nota

.NET Framework 2.0 introduce una versione generica di questo delegato, EventHandler<TEventArgs>.The .NET Framework 2.0 introduces a generic version of this delegate, EventHandler<TEventArgs>. Negli esempi seguenti viene illustrato l'uso di entrambe le versioni.The following examples show how to use both versions.

Anche se gli eventi nelle classi che vengono definite possono essere basati su qualsiasi tipo di delegato valido, inclusi i delegati che restituiscono un valore, è in genere consigliabile basare gli eventi sullo schema .NET Framework usando EventHandler, come illustrato nell'esempio riportato di seguito.Although events in classes that you define can be based on any valid delegate type, even delegates that return a value, it is generally recommended that you base your events on the .NET Framework pattern by using EventHandler, as shown in the following example.

Per pubblicare eventi basati sul modello EventHandlerTo publish events based on the EventHandler pattern

  1. Ignorare questo passaggio e andare al passaggio 3a se non è necessario inviare i dati personalizzati con l'evento. Dichiarare la classe per i dati personalizzati in un ambito che sia visibile sia per la classe dell'editore che per quella del sottoscrittore.(Skip this step and go to Step 3a if you do not have to send custom data with your event.) Declare the class for your custom data at a scope that is visible to both your publisher and subscriber classes. Aggiungere i membri necessari per contenere i dati di evento personalizzati.Then add the required members to hold your custom event data. In questo esempio viene restituita una semplice stringa.In this example, a simple string is returned.

    public class CustomEventArgs : EventArgs  
    {  
        public CustomEventArgs(string s)  
        {  
            msg = s;  
        }  
        private string msg;  
        public string Message  
        {  
            get { return msg; }  
        }   
    }  
    
  2. Ignorare questo passaggio se si sta usando la versione generica di EventHandler<TEventArgs>. Dichiarare un delegato nella classe di pubblicazione.(Skip this step if you are using the generic version of EventHandler<TEventArgs> .) Declare a delegate in your publishing class. Assegnargli un nome che termini con EventHandler.Give it a name that ends with EventHandler. Il secondo parametro specifica il tipo EventArgs personalizzato.The second parameter specifies your custom EventArgs type.

    public delegate void CustomEventHandler(object sender, CustomEventArgs a);  
    
  3. Dichiarare l'evento nella classe di pubblicazione usando uno dei passaggi seguenti.Declare the event in your publishing class by using one of the following steps.

    1. Se non si ha una classe EventArgs personalizzata, il tipo di evento sarà il delegato EventHandler non generico.If you have no custom EventArgs class, your Event type will be the non-generic EventHandler delegate. Non è necessario dichiarare il delegato perché è già dichiarato nello spazio dei nomi System, incluso quando si crea il progetto C#.You do not have to declare the delegate because it is already declared in the System namespace that is included when you create your C# project. Aggiungere il codice seguente alla classe dell'editore.Add the following code to your publisher class.

      public event EventHandler RaiseCustomEvent;  
      
    2. Se si usa la versione non generica di EventHandler e si ha una classe personalizzata derivata da EventArgs, dichiarare l'evento all'interno della classe di pubblicazione e usare il delegato del passaggio 2 come tipo.If you are using the non-generic version of EventHandler and you have a custom class derived from EventArgs, declare your event inside your publishing class and use your delegate from step 2 as the type.

      public event CustomEventHandler RaiseCustomEvent;  
      
    3. Se si usa la versione generica, non è necessario un delegato personalizzato.If you are using the generic version, you do not need a custom delegate. Al contrario, nella classe di pubblicazione specificare il tipo di evento come EventHandler<CustomEventArgs>, sostituendo il nome della classe racchiuso tra parentesi acute.Instead, in your publishing class, you specify your event type as EventHandler<CustomEventArgs>, substituting the name of your own class between the angle brackets.

      public event EventHandler<CustomEventArgs> RaiseCustomEvent;  
      

EsempioExample

L'esempio seguente illustra i passaggi precedenti usando una classe EventArgs personalizzata e EventHandler<TEventArgs> come tipo di evento.The following example demonstrates the previous steps by using a custom EventArgs class and EventHandler<TEventArgs> as the event type.

namespace DotNetEvents
{
    using System;
    using System.Collections.Generic;

    // Define a class to hold custom event info
    public class CustomEventArgs : EventArgs
    {
        public CustomEventArgs(string s)
        {
            message = s;
        }
        private string message;

        public string Message
        {
            get { return message; }
            set { message = value; }
        }
    }

    // Class that publishes an event
    class Publisher
    {

        // Declare the event using EventHandler<T>
        public event EventHandler<CustomEventArgs> RaiseCustomEvent;

        public void DoSomething()
        {
            // Write some code that does something useful here
            // then raise the event. You can also raise an event
            // before you execute a block of code.
            OnRaiseCustomEvent(new CustomEventArgs("Did something"));

        }

        // Wrap event invocations inside a protected virtual method
        // to allow derived classes to override the event invocation behavior
        protected virtual void OnRaiseCustomEvent(CustomEventArgs e)
        {
            // Make a temporary copy of the event to avoid possibility of
            // a race condition if the last subscriber unsubscribes
            // immediately after the null check and before the event is raised.
            EventHandler<CustomEventArgs> handler = RaiseCustomEvent;

            // Event will be null if there are no subscribers
            if (handler != null)
            {
                // Format the string to send inside the CustomEventArgs parameter
                e.Message += $" at {DateTime.Now}";

                // Use the () operator to raise the event.
                handler(this, e);
            }
        }
    }

    //Class that subscribes to an event
    class Subscriber
    {
        private string id;
        public Subscriber(string ID, Publisher pub)
        {
            id = ID;
            // Subscribe to the event using C# 2.0 syntax
            pub.RaiseCustomEvent += HandleCustomEvent;
        }

        // Define what actions to take when the event is raised.
        void HandleCustomEvent(object sender, CustomEventArgs e)
        {
            Console.WriteLine(id + " received this message: {0}", e.Message);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Publisher pub = new Publisher();
            Subscriber sub1 = new Subscriber("sub1", pub);
            Subscriber sub2 = new Subscriber("sub2", pub);

            // Call the method that raises the event.
            pub.DoSomething();

            // Keep the console window open
            Console.WriteLine("Press Enter to close this window.");
            Console.ReadLine();

        }
    }
}

Vedere ancheSee also