C # 'da anonim yöntemden çıkma

Anonim bir yöntemi bir etkinlikten iptal etmek mümkün mü?

Böyle bir etkinliğe abone olursam:

void MyMethod()
{
    Console.WriteLine("I did it!");
}

MyEvent += MyMethod;

Bunun gibi abone olabilirim:

MyEvent -= MyMethod;

Ama anonim bir yöntem kullanarak abone olursam:

MyEvent += delegate(){Console.WriteLine("I did it!");};

Bu anonim yöntemin aboneliğini iptal etmek mümkün mü? Öyleyse nasıl?

Action myDelegate = delegate(){Console.WriteLine("I did it!");};

MyEvent += myDelegate;


// .... later

MyEvent -= myDelegate;

Etraftaki delege referans verin.

Bir teknik, daha sonra anonim yöntemin içinde mevcut olacak anonim yöntemi tutacak bir değişken bildirmektir. Bu benim için çalıştı çünkü olay ele alındıktan sonra istenen davranış aboneliği iptal etmekti.

Misal:

MyEventHandler foo = null;
foo = delegate(object s, MyEventArgs ev)
    {
        Console.WriteLine("I did it!");
        MyEvent -= foo;
    };
MyEvent += foo;

Bellekten, anonim yöntemlerle oluşturulan delegelerin denkliği söz konusu olduğunda, spesifikasyon davranışı her iki şekilde de açıkça garanti etmez.

Abonelikten çıkmanız gerekirse, "normal" bir yöntem kullanmanız veya temsilci başka bir yerde tutmanız gerekir; böylece abone olduğunuzda kullandığınız temsilci ile tam olarak aboneliğinizi iptal edebilirsiniz.

3.0'da kısaltılabilir:

MyHandler myDelegate = ()=>Console.WriteLine("I did it!");
MyEvent += myDelegate;
...
MyEvent -= myDelegate;

Yana C # 7.0 yerel fonksiyonları özelliği serbest bırakıldı, yaklaşım önerdi tarafından J c gerçekten temiz hale gelir.

void foo(object s, MyEventArgs ev)
{
    Console.WriteLine("I did it!");
    MyEvent -= foo;
};
MyEvent += foo;

Yani, dürüst olmak gerekirse, burada değişken olarak anonim bir fonksiyonunuz yok. Ama bence bunu kullanma motivasyonunuz da yerel işlevlere uygulanabilir.

Herhangi bir delege için bir referans tutmak yerine, etkinliğin çağrı listesini arayan kişiye geri vermek için sınıfınızı düzenleyebilirsiniz. Temel olarak böyle bir şey yazabilirsiniz (MyEvent'in MyClass içinde beyan edildiği varsayılarak):

public class MyClass 
{
  public event EventHandler MyEvent;

  public IEnumerable<EventHandler> GetMyEventHandlers()  
  {  
      return from d in MyEvent.GetInvocationList()  
             select (EventHandler)d;  
  }  
}

Böylece tüm çağrı listesine MyClass'ın dışından erişebilir ve istediğiniz herhangi bir işleyicinin aboneliğini iptal edebilirsiniz. Örneğin:

myClass.MyEvent -= myClass.GetMyEventHandlers().Last();

Burada bu teknikle ilgili tam bir yazı yazdım .

Bir tür topal yaklaşım:

public class SomeClass
{
  private readonly IList<Action> _eventList = new List<Action>();

  ...

  public event Action OnDoSomething
  {
    add {
      _eventList.Add(value);
    }
    remove {
      _eventList.Remove(value);
    }
  }
}

1. Olay ekleme / kaldırma yöntemlerini geçersiz kılın.
2. Bu olay işleyicilerin bir listesini tutun.
3. Gerektiğinde, hepsini temizleyin ve diğerlerini tekrar ekleyin.

Bu işe yaramayabilir veya en etkili yöntem olabilir, ancak işi halletmek gerekir.

Aboneliği iptal etmek istiyorsanız, kabul ettiğiniz yanıtta belirtilen rotaya gitmeniz gerekir. Ancak, abone sınıfınız kapsam dışına çıktığında referansları temizlemekten endişe ediyorsanız, zayıf referansların kullanılmasını içeren başka bir (biraz kıvrık) çözüm vardır. Bu konuyla ilgili yeni bir soru ve cevap gönderdim .

Basit bir çözüm:

eventhandle değişkenini parametre olarak kendisine iletmeniz yeterlidir. Olay, birden çok iş parçacığı nedeniyle oluşturulan özgün değişkene erişememeniz durumunda aşağıdakini kullanabilirsiniz:

MyEventHandler foo = null;
foo = (s, ev, mehi) => MyMethod(s, ev, foo);
MyEvent += foo;

void MyMethod(object s, MyEventArgs ev, MyEventHandler myEventHandlerInstance)
{
    MyEvent -= myEventHandlerInstance;
    Console.WriteLine("I did it!");
}

Bu temsilci ile bazı nesnelere başvurmak istiyorsanız, Delegate.CreateDelegate (Tür, Nesne hedefi, MethodInfo methodInfo) .net kullanabilirsiniz delegate hedef ve methodInfo göre eşittir düşünün

En iyi yol, abone olunan eventHandler üzerinde bir referans tutmaksa, bu bir Sözlük kullanılarak gerçekleştirilebilir.

Bu örnekte, DataGridViews kümesi için mergeColumn parametresini dahil etmek için anonim bir yöntem kullanmam gerekiyor.

Enable parametresi true olarak ayarlanmışken MergeColumn yönteminin kullanılması, olayı false ile kullanırken etkinleştirme özelliğini devre dışı bırakır.

static Dictionary<DataGridView, PaintEventHandler> subscriptions = new Dictionary<DataGridView, PaintEventHandler>();

public static void MergeColumns(this DataGridView dg, bool enable, params ColumnGroup[] mergedColumns) {

    if(enable) {
        subscriptions[dg] = (s, e) => Dg_Paint(s, e, mergedColumns);
        dg.Paint += subscriptions[dg];
    }
    else {
        if(subscriptions.ContainsKey(dg)) {
            dg.Paint -= subscriptions[dg];
            subscriptions.Remove(dg);
        }
    }
}