コード例 #1
0
        /// <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);
        }
コード例 #2
0
        /// <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());
        }
コード例 #3
0
        /// <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);
        }
コード例 #4
0
        /// <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);
        }