Events

Introduction

An event is a notification that something has occurred (such as a mouse click) or, in some cases, is about to occur (such as a price change).

Classes can define events and their instances (objects) may raise these events. For instance, a Button may contain a Click event that gets raised when a user has clicked it.

Event handlers are then methods that get called when their corresponding event is raised. A form may contain a Clicked event handler for every Button it contains, for instance.

Parameters

EventArgsT : The type that derives from EventArgs and contains the event parameters.
EventName : The name of the event.
HandlerName : The name of the event handler.
SenderObject : The object that’s invoking the event.
EventArguments : An instance of the EventArgsT type that contains the event parameters.|

Remarks

When raising an event:

Always check if the delegate is null. A null delegate means the event has no subscribers. Raising an event with no subscribers will result in a NullReferenceException.
Copy the delegate (e.g. EventName) to a local variable (e.g. eventName) before checking for null / raising the event. This avoids race conditions in multi-threaded environments:

Wrong:

if (Changed != null)      // Changed has 1 subscriber at this point
                             // In another thread, that one subscriber decided to unsubscribe
        Changed(this, args); // `Changed` is now null, `NullReferenceException` is thrown.

Right:

// Cache the "Changed" event as a local. If it is not null, then use
    // the LOCAL variable (handler) to raise the event, NOT the event itself.
    var handler = Changed;
    if(handler != null)
        handler(this, args);

Use the null-conditional operator (?.) for raising the method instead of null-checking the delegate for subscribers in an if statement: EventName?.Invoke(SenderObject, new EventArgsT());
When using Action<> to declare delegate types, the anonymous method / event handler signature must be the same as the declared anonymous delegate type in the event declaration.

Found a mistake? Have a question or improvement idea? Let me know.

Events:

* Events

* Declaring and Raising Events

* Creating cancelable event

* Event Properties

* Standard Event Declaration

* Anonymous Event Handler Declaration

* Non-Standard Event Declaration

* Creating custom EventArgs containing additional data

Table Of Contents

0 Getting Started With C#

1 Literals

2 Operators

3 Conditional Statements

4 Equality Operator

5 Equals and GetHashCode

6 Null-Coalescing Operator

7 Null-Conditional Operators

8 nameof Operator

9 Verbatim String

10 Common String Operations

11 String Format

12 String Concatenate

13 String Manipulation

14 String Interpolation

15 String Escape Sequences

16 StringBuilder

17 Regex

18 DateTime

19 Arrays

20 On Algorithm for circular rotation of an array

21 Enum

22 Tuples

23 Overview of C# collections

24 GUID

25 BigInteger

26 Collection Initializers

27 Looping

28 Iterators

29 IEnumerable

30 Value type vs Reference type

31 Built-in Types

32 Aliases of built-in types

33 Anonymous types

34 Dynamic type

35 Type Conversion

36 Casting

37 Nullable types

38 Constructors and Finalizers

39 Access Modifiers

40 Interfaces

41 Static Classes

42 Singleton Implementation

43 Dependency Injection

44 Partial class and methods

45 Object Initializers

46 Methods

47 Extension Methods

48 Named Arguments

49 Named And Optional Arguments

50 Data Annotation

51 Keywords

52 Recursion

53 Naming Conventions

54 XML Documentation Comments

55 Comments and regions

56 Inheritance

57 Generics

58 Using Statement

59 Using Directive

60 IDisposable interface

61 Reflection

62 IQueryable interface

63 LINQ to Objects

64 LINQ Queries

65 LINQ to XML

66 Parallel LINQ PLINQ

67 XmlDocument

68 XDocument

69 C# 7.0 Features

70 C# 6.0 Features

71 C# 5.0 Features

72 C# 4.0 Features

73 C# 3.0 Features

74 Exception Handling

75 NullReferenceException

76 Handling FormatException

77 Read and Understand Stack trackes

78 Diagnostics

79 Overflow

80 JSON handling

81 Using json.net

82 Lambda Expressions

83 Lambda expressions

84 Generic Lambda Query Builder

85 Properties

86 Initializing Properties

87 INotifyPropertyChanged interface

88 Events

89 Expression Trees

90 Overload Resolution

91 Preprocessor directives

92 Structs

93 Attributes

94 Delegates

95 File and Stream IO

96 Networking

97 Performing HTTP requests

98 Reading and writing .zip files

99 FileSystemWatcher

100 Asynchronous Socket

101 Action Filters

102 Polymorphism

103 Immutability

104 Indexer

105 Checked and Unchecked

106 Stream

107 Timers

108 Stopwatches

109 Threading

110 Async/Await, BackgroundWorker, Task and Thread examples

111 Async Await

112 Synchronization Context in Async/Await

113 BackgroundWorker

114 Task Parallel Library

115 Making a variable thread safe

116 Lock Statement

117 Yield Keyword

118 Task Parallel Library TPL Dataflow Constructs

119 Functional Programming

120 Func delegates

121 Function with multiple return values

122 Binary Serialization

123 ICloneable

124 IComparable

125 Accessing Databases

126 Using SQLite

127 Caching

128 Code Contracts

129 Code Contracts and Assertions

130 Structural Design Patterns

131 Creational Design Patterns

132 Implementing Decorating Design Pattern

133 Implementing Flyweight Design Pattern

134 System.Management.Automation

135 Pointers

136 Pointers and Unsafe Code

137 Simulating C Unions with C# Structs

138 Reactive Extensions Rx

139 AsseblyInfo.cs examples

140 Creating Console Application

141 CLSCompliantAttribute

142 ObservableCollection

143 Hash Functions

144 Generating Random Numbers

145 Cryptography

146 Unsafe Code in .NET

147 C# Script

148 Runtime Compile

149 Interoperability

150 .NET Compiler Platform Roslyn

151 Creating Own MessageBox in Windows Form Application

152 Including Font Resources

153 Garbage Collector

154 Windows Communication Foundation

155 Contributors