How to do attached events properly

[mwpowellhtx]

I'm not sure this is quite the right place to ask, but I am having difficulty making Attached (Routed) Events work properly.

Just from a XAML design perspective, I am fairly certain that the class scaffold and declaration and supporting Add and Remove handler code is correctly presented, because designer knows when the Add or Remove code is not there and complains.

However, at runtime, trying to raise said event, it is not working. Deep in the WPF runtime, RoutedEvent is discovered as being null, which I'm sure cannot be correct, or I am missing something, there needs to be something else, unbeknownst to me, I need to do enabling the feature.

If I just following the learn guidance, it seems like every other detail is rather verbose on the subject of declaration and connecting the dots with XAML design, but is strangely silent on the subject of actually raising the event. Even to the point where a paragraph is devoted to "boilerplate" internal events, do not need to raise those; yes, I know that, and would expect nothing less than that, the internals should be raising its own events. This is just plain irrelevant to the topic at hand.

Okay, so my event and handler delegate delcared as follows:

public class BubblesRoutedEventArgs : RoutedEventArgs
{
    public int Bubbles { get; set; }

    internal BubblesRoutedEventArgs(int bubbles)
    {
        Bubbles = bubbles;
    }
}

public delegate void BubblingRoutedEventHandler(object source, BubblesRoutedEventArgs e);

The BubbleManager class members. The class itself does not need to be static, does it?

public static readonly RoutedEvent BubblingEvent = EventManager.RegisterRoutedEvent("Bubbling"
    , RoutingStrategy.Bubble, typeof(BubblingRoutedEventHandler), typeof(BubblesManager));

public static void AddBubblingHandler(DependencyObject dependencyObject, BubblingRoutedEventHandler handler)
{
    if (dependencyObject is UIElement uiElement)
    {
        Trace.WriteLine("Adding event");
        uiElement.AddHandler(BubblingEvent, handler);
        Trace.WriteLine("Event added");
    }
}

public static void RemoveBubblingHandler(DependencyObject dependencyObject, BubblingRoutedEventHandler handler)
{
    if (dependencyObject is UIElement uiElement)
    {
        Trace.WriteLine("Adding event");
        uiElement.RemoveHandler(BubblingEvent, handler);
        Trace.WriteLine("Event added");
    }
}

And methods supporting raising the event:

public static void RaiseEvent(UIElement source)
    => RaiseEvent(source, new Random().Next(1, 100));

public static void RaiseEvent(UIElement source, int bubbles)
{
    Trace.WriteLine($"Raising event bubbles {bubbles}");
    source.RaiseEvent(new BubblesRoutedEventArgs(bubbles));
    Trace.WriteLine($"Bubbles {bubbles} event raised");
}

The MainWindow.xaml:

<Window x:Class="BubblingAttachedEvents.MainWindow"
        xmlns:wpf="clr-namespace:WpfToolbox;assembly=WpfToolbox"
        wpf:BubblesManager.Bubbling="MainWindow_Bubbling"/>

<!-- ... -->

<Button Content="Blowing" Click="Button_Click" wpf:BubblesManager.Bubbling="Blowing_Button_Bubbling" />
<Button Grid.Row="1" Grid.Column="1" Content="Bubbles" Click="Button_Click" wpf:BubblesManager.Bubbling="Bubbles_Button_Bubbling"  />

And supporting code behind:

private void MainWindow_Bubbling(object source, BubblesRoutedEventArgs e)
{
    Trace.WriteLine($"MainWindow bubbling {e.Bubbles} bubbles");
}

private void Button_Click(object sender, RoutedEventArgs e)
{
    if (sender is Button button)
    {
        Trace.WriteLine($"{button.Content} button clicking");

        BubblesManager.RaiseEvent(button);

        var other = new OtherWindow() { Owner = this };
        other.Show();

        Trace.WriteLine($"{button.Content} button clicked");
    }
}

private void Blowing_Button_Bubbling(object source, RoutedEventArgs e)
{
    Trace.WriteLine("Blowing button bubbling");
}

private void Bubbles_Button_Bubbling(object source, RoutedEventArgs e)
{
    Trace.WriteLine("Bubbles button bubbling");
}

There is nothing outrageously fantastic about any of that, it does build, and run, but the runtime falls over during EventRoute.cs line 46 throwing the ArgumentNullException:

public EventRoute(RoutedEvent routedEvent)
{
    if (routedEvent == null)
    {
        throw new ArgumentNullException("routedEvent");
    }
    _routedEvent = routedEvent;
    _routeItemList = new FrugalStructList<RouteItem>(16);
    _sourceItemList = new FrugalStructList<SourceItem>(16);
}

Which taking the preceding code at face value, prima facie, there is no reason why routedEvent should be null here, correct? Unless there is some other thing we need to be doing in order to facilitate attached routed events being functional.

Don't know if this is an actual WPF bug, or we're just being dumb or ignorate of some other aspect. Any insight would be helpful.

[miloush]

If I am reading your code right, how would WPF know which event to raise? You need to tell it, i.e. new BubblesRoutedEventArgs(bubbles) { RoutedEvent = BubblingEvent }.

You can always see how WPF itself raises events. The first search result that comes up is:

wpf/src/Microsoft.DotNet.Wpf/src/PresentationCore/System/Windows/StylusOverProperty.cs

Lines 41 to 47 in 31d2558

	StylusEventArgs stylusEventArgs = new StylusEventArgs(Stylus.CurrentStylusDevice, Environment.TickCount);
	stylusEventArgs.RoutedEvent = oldValue ? Stylus.StylusLeaveEvent : Stylus.StylusEnterEvent;
	if (uie != null)
	{
	uie.RaiseEvent(stylusEventArgs);
	}

[mwpowellhtx]

I'm not sure what you're talking about.

// Defeats the whole purpose of wiring up the "dependency" or routed event.
stylusEventArgs.RoutedEvent = oldValue ? Stylus.StylusLeaveEvent : Stylus.StylusEnterEvent; 

That's the whole point of the XAML wiring, which is there, and the manager Add and Remove methods, which connect the dots with the specified DependencyObject, in this case, a Button or Window. Without having to do anything extra.

i.e. so we can do that, but then why do we need to Add or Remove anything?

public static void RaiseEvent(UIElement source, int bubbles)
{
    Trace.WriteLine($"Raising event bubbles {bubbles}");
    source.RaiseEvent(new BubblesRoutedEventArgs(bubbles) { RoutedEvent = BubblingEvent });
    //                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    Trace.WriteLine($"Bubbles {bubbles} event raised");
}

[miloush]

You are adding and removing handlers of an event. When the event is raised, it knows what to call. This is on the receiving side. It connects a DependencyObject on which an event can be raised with the method to be called when its raised.

But you on the raising side, you need to specify which event to raise. The type of event arguments itself is not enough, because several different events can be using the same event arguments (such as key down/key up, or as in the example, stylus leave/stylus enter).

[miloush]

In case you haven't seen, there is some reading:
https://learn.microsoft.com/en-us/dotnet/desktop/wpf/events/routed-events-overview
https://learn.microsoft.com/en-us/dotnet/desktop/wpf/events/how-to-create-a-custom-routed-event

[mwpowellhtx]

Appreciate the clarification. I see that now, and needed to work it through. Makes sense.