C # olayları eşzamanlı mı?

Bu sorunun iki bölümü var:

1. Bir olayın yükseltilmesi iş parçacığını engelliyor mu , yoksa EventHandlers'ın eşzamansız olarak yürütülmesini mi başlatıyor ve iş parçacığı aynı anda devam ediyor mu?

2. Are bireysel EventHandlers eşzamanlı arkaya çalıştırın (olayına abone) ya da başkalarının aynı anda çalışan olmadığını hiçbir garantisi ile uyumsuz çalışacak mı?

Sorularınızı cevaplamak için:

1. Olay işleyicilerinin tümü eşzamanlı olarak uygulanıyorsa, bir olayın başlatılması iş parçacığını engeller.
2. Olay işleyicileri, olaya abone oldukları sırada birbiri ardına yürütülür.

Ben de iç mekanizması eventve bununla ilgili işlemleri merak ediyordum . Bu yüzden basit bir program yazdım ildasmve uygulanmasının etrafından dolaşıyordum.

Kısa cevap

• olaylara abone olma veya olayları çağırma ile ilgili hiçbir zaman uyumsuz işlem yoktur.
• olay, aynı delege türündeki bir destek delege alanıyla uygulanır
• abone olmak ile yapılır Delegate.Combine()
• abonelik iptali ile yapılır Delegate.Remove()
• Çağırma, yalnızca son birleşik delegeyi çağırarak yapılır.

İşte yaptığım şey. Kullandığım program:

public class Foo
{
    // cool, it can return a value! which value it returns if there're multiple 
    // subscribers? answer (by trying): the last subscriber.
    public event Func<int, string> OnCall;
    private int val = 1;

    public void Do()
    {
        if (OnCall != null) 
        {
            var res = OnCall(val++);
            Console.WriteLine($"publisher got back a {res}");
        }
    }
}

public class Program
{
    static void Main(string[] args)
    {
        var foo = new Foo();

        foo.OnCall += i =>
        {
            Console.WriteLine($"sub2: I've got a {i}");
            return "sub2";
        };

        foo.OnCall += i =>
        {
            Console.WriteLine($"sub1: I've got a {i}");
            return "sub1";
        };

        foo.Do();
        foo.Do();
    }
}

İşte Foo'nun uygulaması:

Bir alan OnCall ve bir olay olduğunu unutmayın OnCall . Alan OnCall, kesinlikle destekleyici mülktür. Ve bu sadece bir Func<int, string>, burada süslü değil.

Şimdi ilginç kısımlar:

• add_OnCall(Func<int, string>)
• remove_OnCall(Func<int, string>)
• ve nasıl OnCallçağrılırDo()

Abone Olma ve Aboneliği İptal Etme Nasıl Uygulanır?

İşte add_OnCallCIL'deki kısaltılmış uygulama. İlginç olan kısım, Delegate.Combineiki delegeyi birleştirmek için kullanmasıdır .

.method public hidebysig specialname instance void 
        add_OnCall(class [mscorlib]System.Func`2<int32,string> 'value') cil managed
{
  // ...
  .locals init (class [mscorlib]System.Func`2<int32,string> V_0,
           class [mscorlib]System.Func`2<int32,string> V_1,
           class [mscorlib]System.Func`2<int32,string> V_2)
  IL_0000:  ldarg.0
  IL_0001:  ldfld      class [mscorlib]System.Func`2<int32,string> ConsoleApp1.Foo::OnCall
  // ...
  IL_000b:  call       class [mscorlib]System.Delegate [mscorlib]System.Delegate::Combine(class [mscorlib]System.Delegate,
                                                                                          class [mscorlib]System.Delegate)
  // ...
} // end of method Foo::add_OnCall

Aynı şekilde Delegate.Removekullanılır remove_OnCall.

Bir olay nasıl başlatılır?

Çağırmak OnCalliçin Do(), arg'yi yükledikten sonra son birleştirilmiş temsilciyi çağırır:

IL_0026:  callvirt   instance !1 class [mscorlib]System.Func`2<int32,string>::Invoke(!0)

Bir abone bir etkinliğe tam olarak nasıl abone olur?

Ve son olarak, Mainşaşırtıcı bir şekilde, OnCallolaya abone olmak add_OnCall, Fooörnek üzerinde yöntem çağırarak yapılır .

Bu genel bir cevaptır ve varsayılan davranışı yansıtır:

1. Evet, olaya abone olan yöntemler zaman uyumsuz değilse, iş parçacığını engeller.
2. Birbiri ardına idam edilirler. Bunun başka bir dönüşü vardır: Bir olay işleyicisi bir istisna atarsa, henüz yürütülmemiş olay işleyicileri çalıştırılmayacaktır.

Bununla birlikte, olayları sağlayan her sınıf, olayını eşzamansız olarak uygulamayı seçebilir. IDesign , EventsHelperbunu basitleştiren bir sınıf sağlar .

[Not] bu bağlantı, EventsHelper sınıfını indirmek için bir e-posta adresi sağlamanızı gerektirir. (Ben hiçbir şekilde bağlı değilim)

Etkinliğe abone olan delegeler, eklendikleri sırayla eşzamanlı olarak çağrılır. Delegelerden birinin bir istisna atarsa, olanları aşağıdaki olmaz çağrılabilir.

Olaylar çok noktaya yayın delegeleri ile tanımlandığından, kendi ateşleme mekanizmanızı yazabilirsiniz.

Delegate.GetInvocationList();

ve temsilcileri eşzamansız olarak çağırmak;

Olaylar yalnızca temsilcilerden oluşan dizilerdir. Temsilci çağrısı eşzamanlı olduğu sürece, olaylar da eşzamanlıdır.

Genel olarak olaylar eşzamanlıdır. Bununla birlikte, boşsa System.Timers.Timer.Elapsedbir ThreadPooliş parçacığında ortaya çıkan olay gibi bazı istisnalar vardır SyncronisingObject.

Dokümanlar: http://msdn.microsoft.com/en-us/library/system.timers.timer.elapsed.aspx

C # 'teki olaylar, ikinci bir iş parçacığını manuel olarak başlatmadığınız sürece eşzamanlı olarak çalışır (her iki durumda da).

Olaylar eşzamanlıdır. Olay yaşam döngüsünün olduğu gibi çalışmasının nedeni budur. Başlatma yüklemelerden önce gerçekleşir, yüklemeler işlemeden önce gerçekleşir vb.

Bir olay için hiçbir işleyici belirtilmezse, döngü sadece parlar. Birden fazla işleyici belirtilirse, sırayla çağrılırlar ve biri diğeri tamamen bitene kadar devam edemez.

Eşzamansız aramalar bile bir dereceye kadar eşzamanlıdır. Başlangıç ​​tamamlanmadan sonu çağırmak imkansızdır.