EventHandler 대리자

정의

이벤트 데이터가 없는 이벤트를 처리할 메서드를 나타냅니다.Represents the method that will handle an event that has no event data.

public delegate void EventHandler(System::Object ^ sender, EventArgs ^ e);
public delegate void EventHandler(object sender, EventArgs e);
public delegate void EventHandler(object? sender, EventArgs e);
[System.Serializable]
public delegate void EventHandler(object sender, EventArgs e);
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public delegate void EventHandler(object sender, EventArgs e);
type EventHandler = delegate of obj * EventArgs -> unit
[<System.Serializable>]
type EventHandler = delegate of obj * EventArgs -> unit
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type EventHandler = delegate of obj * EventArgs -> unit
Public Delegate Sub EventHandler(sender As Object, e As EventArgs)

매개 변수

sender
Object

이벤트 소스입니다.The source of the event.

e
EventArgs

이벤트 데이터가 포함되지 않은 개체입니다.An object that contains no event data.

상속
EventHandler
특성

예제

다음 예제에서는 대리자와 연결 된 이라는 이벤트를 보여 줍니다 ThresholdReached EventHandler .The following example shows an event named ThresholdReached that is associated with an EventHandler delegate. 대리자에 할당 된 메서드가 EventHandler 메서드에서 호출 됩니다 OnThresholdReached .The method assigned to the EventHandler delegate is called in the OnThresholdReached method.

using namespace System;

public ref class ThresholdReachedEventArgs : public EventArgs
{
   public:
      property int Threshold;
      property DateTime TimeReached;
};

public ref class Counter
{
   private:
      int threshold;
      int total;

   public:
      Counter() {};

      Counter(int passedThreshold)
      {
         threshold = passedThreshold;
      }

      void Add(int x)
      {
          total += x;
          if (total >= threshold) {
             ThresholdReachedEventArgs^ args = gcnew ThresholdReachedEventArgs();
             args->Threshold = threshold;
             args->TimeReached = DateTime::Now;
             OnThresholdReached(args);
          }
      }

      event EventHandler<ThresholdReachedEventArgs^>^ ThresholdReached;

   protected:
      virtual void OnThresholdReached(ThresholdReachedEventArgs^ e)
      {
         ThresholdReached(this, e);
      }
};

public ref class SampleHandler
{
   public:
      static void c_ThresholdReached(Object^ sender, ThresholdReachedEventArgs^ e)
      {
         Console::WriteLine("The threshold of {0} was reached at {1}.",
                            e->Threshold,  e->TimeReached);
         Environment::Exit(0);
      }
};

void main()
{
   Counter^ c = gcnew Counter((gcnew Random())->Next(10));
   c->ThresholdReached += gcnew EventHandler<ThresholdReachedEventArgs^>(SampleHandler::c_ThresholdReached);

   Console::WriteLine("press 'a' key to increase total");
   while (Console::ReadKey(true).KeyChar == 'a') {
      Console::WriteLine("adding one");
      c->Add(1);
   }
}
using System;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Counter c = new Counter(new Random().Next(10));
            c.ThresholdReached += c_ThresholdReached;

            Console.WriteLine("press 'a' key to increase total");
            while (Console.ReadKey(true).KeyChar == 'a')
            {
                Console.WriteLine("adding one");
                c.Add(1);
            }
        }

        static void c_ThresholdReached(object sender, ThresholdReachedEventArgs e)
        {
            Console.WriteLine("The threshold of {0} was reached at {1}.", e.Threshold,  e.TimeReached);
            Environment.Exit(0);
        }
    }

    class Counter
    {
        private int threshold;
        private int total;

        public Counter(int passedThreshold)
        {
            threshold = passedThreshold;
        }

        public void Add(int x)
        {
            total += x;
            if (total >= threshold)
            {
                ThresholdReachedEventArgs args = new ThresholdReachedEventArgs();
                args.Threshold = threshold;
                args.TimeReached = DateTime.Now;
                OnThresholdReached(args);
            }
        }

        protected virtual void OnThresholdReached(ThresholdReachedEventArgs e)
        {
            EventHandler<ThresholdReachedEventArgs> handler = ThresholdReached;
            if (handler != null)
            {
                handler(this, e);
            }
        }

        public event EventHandler<ThresholdReachedEventArgs> ThresholdReached;
    }

    public class ThresholdReachedEventArgs : EventArgs
    {
        public int Threshold { get; set; }
        public DateTime TimeReached { get; set; }
    }
}
Module Module1

    Sub Main()
        Dim c As Counter = New Counter(New Random().Next(10))
        AddHandler c.ThresholdReached, AddressOf c_ThresholdReached

        Console.WriteLine("press 'a' key to increase total")
        While Console.ReadKey(True).KeyChar = "a"
            Console.WriteLine("adding one")
            c.Add(1)
        End While
    End Sub

    Sub c_ThresholdReached(sender As Object, e As ThresholdReachedEventArgs)
        Console.WriteLine("The threshold of {0} was reached at {1}.", e.Threshold, e.TimeReached)
        Environment.Exit(0)
    End Sub
End Module

Class Counter
    Private threshold As Integer
    Private total As Integer

    Public Sub New(passedThreshold As Integer)
        threshold = passedThreshold
    End Sub

    Public Sub Add(x As Integer)
        total = total + x
        If (total >= threshold) Then
            Dim args As ThresholdReachedEventArgs = New ThresholdReachedEventArgs()
            args.Threshold = threshold
            args.TimeReached = DateTime.Now
            OnThresholdReached(args)
        End If
    End Sub

    Protected Overridable Sub OnThresholdReached(e As ThresholdReachedEventArgs)
        RaiseEvent ThresholdReached(Me, e)
    End Sub

    Public Event ThresholdReached As EventHandler(Of ThresholdReachedEventArgs)
End Class

Class ThresholdReachedEventArgs
    Inherits EventArgs

    Public Property Threshold As Integer
    Public Property TimeReached As DateTime
End Class

설명

.NET Framework의 이벤트 모델은 이벤트를 처리기와 연결 하는 이벤트 대리자가 있는지를 기반으로 합니다.The event model in the .NET Framework is based on having an event delegate that connects an event with its handler. 이벤트를 발생 시키려면 다음과 같은 두 가지 요소가 필요 합니다.To raise an event, two elements are needed:

  • 이벤트에 대 한 응답을 제공 하는 메서드를 식별 하는 대리자입니다.A delegate that identifies the method that provides the response to the event.

  • 이벤트에서 데이터를 제공 하는 경우 이벤트 데이터를 보관 하는 클래스 (옵션).Optionally, a class that holds the event data, if the event provides data.

대리자는 메서드에 대 한 반환 값 형식 및 매개 변수 목록 형식을 정의 하는 형식입니다.The delegate is a type that defines a signature, that is, the return value type and parameter list types for a method. 대리자 형식을 사용 하 여 대리자와 동일한 시그니처를 가진 메서드를 참조할 수 있는 변수를 선언할 수 있습니다.You can use the delegate type to declare a variable that can refer to any method with the same signature as the delegate.

이벤트 처리기 대리자의 표준 서명에서 값을 반환 하지 않는 메서드를 정의 합니다.The standard signature of an event handler delegate defines a method that does not return a value. 이 메서드의 첫 번째 매개 변수는 형식이 Object 며 이벤트를 발생 시키는 인스턴스를 참조 합니다.This method's first parameter is of type Object and refers to the instance that raises the event. 두 번째 매개 변수는 형식에서 파생 되며 EventArgs 이벤트 데이터를 포함 합니다.Its second parameter is derived from type EventArgs and holds the event data. 이벤트가 이벤트 데이터를 생성 하지 않는 경우 두 번째 매개 변수는 단순히 필드의 값입니다 EventArgs.Empty .If the event does not generate event data, the second parameter is simply the value of the EventArgs.Empty field. 그렇지 않으면 두 번째 매개 변수는에서 파생 된 형식이 EventArgs 고 이벤트 데이터를 저장 하는 데 필요한 모든 필드 또는 속성을 제공 합니다.Otherwise, the second parameter is a type derived from EventArgs and supplies any fields or properties needed to hold the event data.

EventHandler대리자는 데이터를 생성 하지 않는 이벤트에 대 한 이벤트 처리기 메서드를 구체적으로 나타내는 미리 정의 된 대리자입니다.The EventHandler delegate is a predefined delegate that specifically represents an event handler method for an event that does not generate data. 이벤트에서 데이터를 생성 하는 경우 제네릭 대리자 클래스를 사용 해야 합니다 EventHandler<TEventArgs> .If your event does generate data, you must use the generic EventHandler<TEventArgs> delegate class.

이벤트를 처리할 메서드에 이벤트를 연결 하려면 대리자의 인스턴스를 이벤트에 추가 합니다.To associate the event with the method that will handle the event, add an instance of the delegate to the event. 대리자를 제거하지 않는 경우 이벤트가 발생할 때마다 이벤트 처리기가 호출됩니다.The event handler is called whenever the event occurs, unless you remove the delegate.

이벤트 처리기 대리자에 대 한 자세한 내용은 참조 하세요. 이벤트 처리 및 발생합니다.For more information about event handler delegates, see Handling and Raising Events.

확장 메서드

GetMethodInfo(Delegate)

지정된 대리자가 나타내는 메서드를 나타내는 개체를 가져옵니다.Gets an object that represents the method represented by the specified delegate.

적용 대상

추가 정보