Tôi có thể có sự an toàn và sự kiện ngoại lệ mạnh không?

Question

Giả sử tôi có một phương pháp mà thay đổi trạng thái của một đối tượng, và cháy một sự kiện để thông báo cho thính giả của sự thay đổi trạng thái này:

public class Example 
{ 
    public int Counter { get; private set; } 

    public void IncreaseCounter() 
    { 
     this.Counter = this.Counter + 1; 
     OnCounterChanged(EventArgs.Empty); 
    } 

    protected virtual void OnCounterChanged(EventArgs args) 
    { 
     if (CounterChanged != null) 
     CounterChanged(this,args); 
    } 

    public event EventHandler CounterChanged; 
} 

Việc xử lý sự kiện có thể ném một ngoại lệ ngay cả khi IncreaseCounter hoàn thành xuất sắc thay đổi trạng thái. Vì vậy, chúng tôi không có mạnh exception safety đây:

Việc bảo lãnh mạnh: đó là các hoạt động đã hoặc hoàn thành công hoặc ném một ngoại lệ, rời khỏi trạng thái chương trình chính xác như đó là trước khi phẫu thuật bắt đầu.

Có thể có sự an toàn ngoại lệ mạnh khi bạn cần tăng sự kiện không?

Answer 1

Để ngăn chặn một ngoại lệ trong một handler từ tuyên truyền đến các máy phát điện sự kiện, câu trả lời là tự gọi từng mục trong Đại biểu MultiCast (tức là trình xử lý sự kiện) bên trong của một thử-catch

Tất cả các trình xử lý sẽ được gọi và ngoại lệ w on't propagate.

public EventHandler<EventArgs> SomeEvent; 

protected void OnSomeEvent(EventArgs args) 
{ 
    var handler = SomeEvent; 
    if (handler != null) 
    { 
     foreach (EventHandler<EventArgs> item in handler.GetInvocationList()) 
     { 
      try 
      { 
       item(this, args); 
      } 
      catch (Exception e) 
      { 
       // handle/report/ignore exception 
      } 
     }     
    } 
} 

Điều gì còn lại để bạn thực hiện logic cho việc cần làm khi một hoặc nhiều người nhận sự kiện ném và những người khác thì không. Catch() có thể bắt một ngoại lệ cụ thể và quay trở lại bất kỳ thay đổi nào nếu đó là điều có ý nghĩa, cho phép người nhận sự kiện báo hiệu nguồn sự kiện xảy ra tình huống ngoại lệ.

Khi những người khác chỉ ra, sử dụng ngoại lệ vì luồng kiểm soát không được khuyến nghị. Nếu nó thực sự là một trường hợp ngoại lệ, thì bằng mọi cách sử dụng một ngoại lệ. Nếu bạn nhận được rất nhiều ngoại lệ, bạn có thể muốn sử dụng một cái gì đó khác.

Answer 2

Sẽ không đơn giản đổi thứ tự của hai dòng trong IncreaseCounter an toàn ngoại lệ thực thi cho bạn?

Hoặc nếu bạn cần để tăng Counter trước khi bạn nâng cao sự kiện:

public void IncreaseCounter() 
{ 
    this.Counter += 1; 

    try 
    { 
     OnCounterChanged(EventArgs.Empty); 
    } 
    catch 
    { 
     this.Counter -= 1; 

     throw; 
    } 
} 

Trong một tình huống mà bạn có thay đổi trạng thái phức tạp hơn (tác dụng phụ) xảy ra, sau đó nó trở nên khá phức tạp hơn (bạn có thể phải sao chép các đối tượng nhất định chẳng hạn), nhưng trong ví dụ này, nó có vẻ khá dễ dàng.

Answer 3

Các mô hình chung bạn sẽ thấy ô để làm khung là:

public class Example 
{ 
    public int Counter { get; private set; } 

    public void IncreaseCounter() 
    { 
     OnCounterChanging(EventArgs.Empty); 
     this.Counter = this.Counter + 1; 
     OnCounterChanged(EventArgs.Empty); 
    } 

    protected virtual void OnCounterChanged(EventArgs args) 
    { 
     if (CounterChanged != null) 
     CounterChanged(this, args); 
    } 

    protected virtual void OnCounterChanging(EventArgs args) 
    { 
     if (CounterChanging != null) 
     CounterChanging(this, args); 
    } 

    public event EventHandler<EventArgs> CounterChanging; 
    public event EventHandler<EventArgs> CounterChanged; 
} 

Nếu người dùng muốn ném một ngoại lệ để ngăn chặn sự thay đổi của giá trị thì họ nên làm việc đó trong OnCounterChanging() sự kiện thay vì của OnCounterChanged(). Theo định nghĩa của tên (quá khứ, hậu tố của -ed) ngụ ý giá trị đã được thay đổi.

Edit:

Lưu ý rằng bạn thường muốn tránh xa một lượng dư try..catch tắm/cuối cùng khối như xử lý ngoại lệ (bao gồm try..finally) rất tốn kém tùy thuộc vào việc thực hiện ngôn ngữ. tức là mô hình khung xếp chồng win32 hoặc mô hình ngoại lệ PC-ánh xạ đều có ưu điểm và nhược điểm của chúng, tuy nhiên nếu có quá nhiều khung thì cả hai sẽ tốn kém (cả trong không gian hoặc tốc độ thực thi). Chỉ cần một điều khác cần lưu ý khi tạo một khung công tác.

Answer 4

Trong trường hợp này, tôi nghĩ bạn nên thực hiện một gợi ý từ Workflow Foundation. Trong phương thức OnCounterChanged, bao quanh cuộc gọi đến đại biểu với một khối try-catch chung. Trong trình xử lý bắt, bạn sẽ phải thực hiện hành động bù trừ hiệu quả là gì - quay trở lại bộ đếm.

Answer 5

Vâng, bạn có thể bù đắp nếu nó là rất quan trọng:

public void IncreaseCounter() 
{ 
    int oldCounter = this.Counter; 
    try { 
     this.Counter = this.Counter + 1; 
     OnCounterChanged(EventArgs.Empty); 
    } catch { 
     this.Counter = oldCounter; 
     throw; 
    } 
} 

Rõ ràng đây sẽ là tốt hơn nếu bạn có thể nói chuyện với lĩnh vực này (kể từ khi gán một lĩnh vực sẽ không lỗi).Bạn cũng có thể quấn này trong bolierplate:

void SetField<T>(ref T field, T value, EventHandler handler) { 
    T oldValue = field; 
    try { 
     field = value; 
     if(handler != null) handler(this, EventArgs.Empty); 
    } catch { 
     field = oldField; 
     throw; 
    } 
} 

và gọi:

SetField(ref counter, counter + 1, CounterChanged); 

hoặc một cái gì đó tương tự ...