[C#] C #의 이벤트 및 이벤트 핸들러 이해

C #은 두 용어를 알고, delegate하고 event. 첫 번째부터 시작하겠습니다.

대리자

A delegate는 방법에 대한 참조입니다. 인스턴스에 대한 참조를 만들 수있는 것처럼

MyClass instance = myFactory.GetInstance();

델리게이트를 사용하여 메소드에 대한 참조를 작성할 수 있습니다.

Action myMethod = myFactory.GetInstance;

메소드에 대한이 참조가 있으므로 참조를 통해 메소드를 호출 할 수 있습니다.

MyClass instance = myMethod();

근데 왜? myFactory.GetInstance()직접 전화 할 수도 있습니다. 이 경우 가능합니다. 그러나 나머지 응용 프로그램에서 지식을 얻 myFactory거나 myFactory.GetInstance()직접 호출 하지 않으려는 경우에 대해 생각해야 할 경우가 많습니다 .

당신이 대체 할 수 있도록하려면 명백한 일입니다 myFactory.GetInstance()으로 myOfflineFakeFactory.GetInstance()하나 개의 중앙 위치 (일명에서 팩토리 메소드 패턴 ).

팩토리 메소드 패턴

따라서 TheOtherClass클래스가 있고를 사용해야 myFactory.GetInstance()하는 경우 코드가 대리자없이 표시 TheOtherClass되는 방식입니다 (의 유형에 대해 알려야 함 myFactory).

TheOtherClass toc;
//...
toc.SetFactory(myFactory);


class TheOtherClass
{
   public void SetFactory(MyFactory factory)
   {
      // set here
   }

}

대리자를 사용하는 경우 내 공장 유형을 공개하지 않아도됩니다.

TheOtherClass toc;
//...
Action factoryMethod = myFactory.GetInstance;
toc.SetFactoryMethod(factoryMethod);


class TheOtherClass
{
   public void SetFactoryMethod(Action factoryMethod)
   {
      // set here
   }

}

따라서 유형을 노출시키지 않고 다른 클래스에 대리자를 사용할 수 있습니다. 노출하는 유일한 방법은 메소드의 서명입니다 (당신이 가진 매개 변수 수 등).

“나의 방법의 서명”, 전에는 어디서 들었습니까? 예, 인터페이스 !!! 인터페이스는 전체 클래스의 서명을 설명합니다. 델리게이트는 한 가지 방법의 서명 만 설명하는 것으로 생각하십시오!

인터페이스와 델리게이트의 또 다른 큰 차이점은 클래스를 작성할 때 “이 메소드는 해당 유형의 델리게이트를 구현합니다”라고 말할 필요가 없다는 것입니다. 인터페이스를 사용하면 “이 클래스는 해당 유형의 인터페이스를 구현합니다”라고 말해야합니다.

또한 대리자 참조는 (일부 제한 사항이 있지만 아래 참조) 여러 메서드 ()를 참조 할 수 있습니다 MulticastDelegate. 이것은 델리게이트를 호출 할 때 명시 적으로 연결된 여러 메소드가 실행됨을 의미합니다. 객체 참조는 항상 하나의 객체 만 참조 할 수 있습니다.

A에 대한 제한은 MulticastDelegate제 (방법 / 대리인) 서명이있는 반환 값 (이없는 것이 있습니다 void) 및 키워드 out와 ref서명에 사용되지 않습니다. 분명히 숫자를 반환하고 같은 숫자를 반환 할 것으로 예상되는 두 가지 메서드를 호출 할 수 없습니다. 서명이 준수되면 대리인은 자동으로 MulticastDelegate입니다.

행사

이벤트는 다른 객체에서 델리게이트에 대한 구독을 표시하는 속성 (예 : get; set; 속성을 인스턴스 필드로)과 같습니다. 그러나 이러한 속성은 get; set;을 지원하지 않습니다. 대신에 그들은 add를 지원합니다; 없애다;

그래서 당신은 가질 수 있습니다 :

    Action myField;

    public event Action MyProperty
    {
        add { myField += value; }
        remove { myField -= value; }
    }

UI에서의 사용법 (WinForms, WPF, UWP 등)

이제 델리게이트는 메소드에 대한 참조이며, 델리게이트에서 참조 할 메소드를 제공 할 수 있고 UI 버튼이라는 것을 전세계에 알리는 이벤트를 가질 수 있습니다. 클릭 여부에 관심이있는 모든 사람에게 (우리가 노출 된 이벤트를 통해) 당사에 방법을 등록하도록 요청할 수 있습니다. 우리는 우리에게 주어진 모든 방법을 사용하고 대리인이 참조 할 수 있습니다. 그리고 기다렸다가 기다립니다 …. 사용자가 와서 해당 버튼을 클릭 할 때까지 델리게이트를 호출 할 충분한 이유가 있습니다. 그리고 대리인은 우리에게 주어진 모든 방법을 참조하기 때문에 모든 방법이 호출됩니다. 우리는 그 메소드가 무엇을하는지, 어떤 클래스가 그 메소드를 구현하는지 모릅니다. 우리가 관심을 갖는 것은 누군가 클릭에 관심이 있다는 것입니다.

자바

Java와 같은 언어에는 대리자가 없습니다. 대신 인터페이스를 사용합니다. 그들이하는 방법은 ‘우리의 클릭’에 관심이있는 사람에게 특정 인터페이스 (우리가 호출 할 수있는 특정 방법으로)를 구현하도록 요청한 다음 인터페이스를 구현하는 전체 인스턴스를 제공하는 것입니다. 우리는이 인터페이스를 구현하는 모든 객체의 목록을 유지하며 클릭 할 때마다 ‘호출 할 수있는 확실한 메소드’를 호출 할 수 있습니다.

답변

public class Foo
{
    public event EventHandler MyEvent;
}

Foo foo = new Foo();
foo.MyEvent += new EventHandler(this.OnMyEvent);

private void OnMyEvent(object sender, EventArgs e)
{
    MessageBox.Show("MyEvent fired!");
}

using System;
using System.Collections.Generic;
using System.Text;

namespace Event_Example
{
  // First we have to define a delegate that acts as a signature for the
  // function that is ultimately called when the event is triggered.
  // You will notice that the second parameter is of MyEventArgs type.
  // This object will contain information about the triggered event.

  public delegate void MyEventHandler(object source, MyEventArgs e);

  // This is a class which describes the event to the class that receives it.
  // An EventArgs class must always derive from System.EventArgs.

  public class MyEventArgs : EventArgs
  {
    private string EventInfo;

    public MyEventArgs(string Text) {
      EventInfo = Text;
    }

    public string GetInfo() {
      return EventInfo;
    }
  }

  // This next class is the one which contains an event and triggers it
  // once an action is performed. For example, lets trigger this event
  // once a variable is incremented over a particular value. Notice the
  // event uses the MyEventHandler delegate to create a signature
  // for the called function.

  public class MyClass
  {
    public event MyEventHandler OnMaximum;

    private int i;
    private int Maximum = 10;

    public int MyValue
    {
      get { return i; }
      set
      {
        if(value <= Maximum) {
          i = value;
        }
        else
        {
          // To make sure we only trigger the event if a handler is present
          // we check the event to make sure it's not null.
          if(OnMaximum != null) {
            OnMaximum(this, new MyEventArgs("You've entered " +
              value.ToString() +
              ", but the maximum is " +
              Maximum.ToString()));
          }
        }
      }
    }
  }

  class Program
  {
    // This is the actual method that will be assigned to the event handler
    // within the above class. This is where we perform an action once the
    // event has been triggered.

    static void MaximumReached(object source, MyEventArgs e) {
      Console.WriteLine(e.GetInfo());
    }

    static void Main(string[] args) {
      // Now lets test the event contained in the above class.
      MyClass MyObject = new MyClass();
      MyObject.OnMaximum += new MyEventHandler(MaximumReached);
      for(int x = 0; x <= 15; x++) {
        MyObject.MyValue = x;
      }
      Console.ReadLine();
    }
  }
}

myObj.SomethingHappened += HandleSomethingHappened;

myObj.SomethingHappened += new MyEventHandler(HandleSomethingHappened);

// -= removes the handler from the event's list of "listeners":
myObj.SomethingHappened -= HandleSomethingHappened;

//Firing the event is done by simply providing the arguments to the event:
var handler = SomethingHappened; // thread-local copy of the event
if (handler != null) // the event is null if there are no listeners!
{
    handler("Hi there!");
}

SomethingHappened?.Invoke("Hi there!");

using System;

namespace test{
    class MyTestApp{
        //The Event Handler declaration
        public delegate void EventHandler();

        //The Event declaration
        public event EventHandler MyHandler;

        //The method to call
        public void Hello(){
            Console.WriteLine("Hello World of events!");
        }

        public static void Main(){
            MyTestApp TestApp = new MyTestApp();

            //Assign the method to be called when the event is fired
            TestApp.MyHandler = new EventHandler(TestApp.Hello);

            //Firing the event
            if (TestApp.MyHandler != null){
                TestApp.MyHandler();
            }
        }

    }

}