/// <summary>
/// Registers a new routed event.
/// </summary>
/// <param name="name">The name of the routed event. The name must be unique within the owner type (base class included) and cannot be null or an empty string.</param>
/// <param name="routingStrategy">The routing strategy of the event as a value of the enumeration.</param>
/// <param name="ownerType">The owner class type of the routed event. This cannot be null.</param>
/// <returns>The identifier for the newly registered routed event.
/// This identifier object can now be stored as a static field in a class and then used as a parameter for methods that attach handlers to the event.
/// The routed event identifier is also used for other event system APIs.</returns>
/// <exception cref="ArgumentNullException"><paramref name="name"/> or <paramref name="ownerType"/> is null.</exception>
/// <exception cref="InvalidOperationException">This exception is thrown if a routed event of name <paramref name="name"/> already exists for type <paramref name="ownerType"/> and parents.
/// </exception>
public static RoutedEvent <T> RegisterRoutedEvent <T>(string name, RoutingStrategy routingStrategy, Type ownerType) where T : RoutedEventArgs
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (ownerType == null)
{
throw new ArgumentNullException(nameof(ownerType));
}
if (GetRoutedEvent(ownerType, name) != null)
{
throw new InvalidOperationException("A routed event named '" + name + "' already exists in provided owner type '" + ownerType + "' or base classes.");
}
var newRoutedEvent = new RoutedEvent <T> {
Name = name, OwnerType = ownerType, RoutingStrategy = routingStrategy,
};
lock (SyncRoot)
{
RoutedEvents.Add(newRoutedEvent);
if (!OwnerToEvents.ContainsKey(ownerType))
{
OwnerToEvents[ownerType] = new Dictionary <string, RoutedEvent>();
}
OwnerToEvents[ownerType][name] = newRoutedEvent;
}
return(newRoutedEvent);
}
/// <summary>
/// Finds all routed event identifiers for events that are registered with the provided owner type.
/// </summary>
/// <param name="ownerType">The type to start the search with. Base classes are included in the search.</param>
/// <returns>An array of matching routed event identifiers if any match is found; otherwise, null.</returns>
public static RoutedEvent[] GetRoutedEventsForOwner(Type ownerType)
{
var types = new List <Type>();
var currentType = ownerType;
while (currentType != null)
{
types.Add(currentType);
currentType = currentType.GetTypeInfo().BaseType;
}
return(types.Where(t => OwnerToEvents.ContainsKey(t)).SelectMany(t => OwnerToEvents[t].Values).ToArray());
}
/// <summary>
/// Finds the routed event identified by its name and owner.
/// </summary>
/// <param name="ownerType">The type to start the search with. Base classes are included in the search.</param>
/// <param name="eventName">The event name.</param>
/// <returns>The matching routed event identifier if any match is found; otherwise, null.</returns>
public static RoutedEvent GetRoutedEvent(Type ownerType, string eventName)
{
var currentType = ownerType;
while (currentType != null)
{
if (OwnerToEvents.ContainsKey(currentType) && OwnerToEvents[currentType].ContainsKey(eventName))
{
return(OwnerToEvents[currentType][eventName]);
}
currentType = currentType.GetTypeInfo().BaseType;
}
return(null);
}
/// <summary>
/// Finds the routed event identified by its name and owner.
/// </summary>
/// <param name="ownerType">The type to start the search with. Base classes are included in the search.</param>
/// <param name="eventName">The event name.</param>
/// <returns>The matching routed event identifier if any match is found; otherwise, null.</returns>
public static RoutedEvent GetRoutedEvent(Type ownerType, string eventName)
{
var currentType = ownerType;
while (currentType != null)
{
if (OwnerToEvents.TryGetValue(currentType, out var eventsMap) &&
eventsMap.TryGetValue(eventName, out var routedEvent))
{
return(routedEvent);
}
currentType = currentType.GetTypeInfo().BaseType;
}
return(null);
}