Network Routing Strategies

public static class RoutingProperties
{
    // Strategy Property
    public static readonly DependencyProperty StrategyProperty = 
        DependencyProperty.RegisterAttached(
            "Strategy",
            typeof(RoutingStrategy),
            typeof(RoutingProperties),
            new PropertyMetadata(RoutingStrategy.Default)
        );

    public static RoutingStrategy GetStrategy(DependencyObject obj)
        => (RoutingStrategy)obj.GetValue(StrategyProperty);

    public static void SetStrategy(DependencyObject obj, RoutingStrategy value)
        => obj.SetValue(StrategyProperty, value);

    // Priority Property for Network Message Ordering
    public static readonly DependencyProperty PriorityProperty = 
        DependencyProperty.RegisterAttached(
            "Priority",
            typeof(int),
            typeof(RoutingProperties),
            new PropertyMetadata(0)
        );

    public static int GetPriority(DependencyObject obj)
        => (int)obj.GetValue(PriorityProperty);

    public static void SetPriority(DependencyObject obj, int value)
        => obj.SetValue(PriorityProperty, value);
}

<CommunicationTree>
    <ServiceNode local:RoutingProperties.Strategy="Bubble"
                 local:RoutingProperties.Priority="1">
        <EndpointNode local:RoutingProperties.Strategy="Tunnel"
                      local:RoutingProperties.Priority="2"/>
    </ServiceNode>
</CommunicationTree>

public class RoutingEventArgs : RoutedEventArgs
{
    public RoutingStrategy Strategy { get; }
    public int Priority { get; }
    public NetworkEndpoint Source { get; }
    public NetworkEndpoint Target { get; }
    
    public RoutingEventArgs(
        RoutedEvent routedEvent,
        object source,
        RoutingStrategy strategy,
        int priority,
        NetworkEndpoint sourceEndpoint,
        NetworkEndpoint targetEndpoint) : base(routedEvent, source)
    {
        Strategy = strategy;
        Priority = priority;
        Source = sourceEndpoint;
        Target = targetEndpoint;
    }
}

public class NetworkEventRouter
{
    private readonly CommunicationElement _element;
    private readonly INetworkDispatcher _dispatcher;
    
    public NetworkEventRouter(CommunicationElement element, INetworkDispatcher dispatcher)
    {
        _element = element;
        _dispatcher = dispatcher;
    }
    
    public async Task RouteAsync(RoutingEventArgs args)
    {
        switch (RoutingProperties.GetStrategy(_element))
        {
            case RoutingStrategy.Bubble:
                await RouteBubblingAsync(args);
                break;
            case RoutingStrategy.Tunnel:
                await RouteTunnelingAsync(args);
                break;
            default:
                await RouteDefaultAsync(args);
                break;
        }
    }
    
    private async Task RouteBubblingAsync(RoutingEventArgs args)
    {
        var current = _element;
        while (current != null)
        {
            await _dispatcher.DispatchEventAsync(current, args);
            current = ServiceTreeHelper.GetParent(current) as CommunicationElement;
        }
    }
    
    private async Task RouteTunnelingAsync(RoutingEventArgs args)
    {
        var path = new Stack<CommunicationElement>();
        var current = _element;
        
        while (current != null)
        {
            path.Push(current);
            current = ServiceTreeHelper.GetParent(current) as CommunicationElement;
        }
        
        while (path.Count > 0)
        {
            await _dispatcher.DispatchEventAsync(path.Pop(), args);
        }
    }
}

public class NetworkRoutingAdapter : IRoutingStrategy
{
    private readonly NetworkEventRouter _router;
    private readonly IServiceDiscovery _discovery;
    
    public NetworkRoutingAdapter(CommunicationElement element, IServiceDiscovery discovery)
    {
        _router = new NetworkEventRouter(element, new NetworkDispatcher());
        _discovery = discovery;
    }
    
    public async Task RouteEventAsync(INetworkEvent evt)
    {
        var targetEndpoint = await _discovery.ResolveEndpointAsync(evt.TargetService);
        
        var args = new RoutingEventArgs(
            NetworkEvents.ServiceEvent,
            _router,
            ConvertStrategy(evt.Strategy),
            evt.Priority,
            evt.SourceEndpoint,
            targetEndpoint
        );
        
        await _router.RouteAsync(args);
    }
    
    private static RoutingStrategy ConvertStrategy(NetworkStrategy strategy)
    {
        return strategy switch
        {
            NetworkStrategy.Bubble => RoutingStrategy.Bubble,
            NetworkStrategy.Tunnel => RoutingStrategy.Tunnel,
            _ => RoutingStrategy.Default
        };
    }
}