Network Bindings

public class NetworkBinding : CommunicationBinding
{
    public static readonly DependencyProperty SourceEndpointProperty =
        DependencyProperty.Register(
            "SourceEndpoint",
            typeof(string),
            typeof(NetworkBinding),
            new CommunicationPropertyMetadata(
                null,
                OnSourceEndpointChanged
            )
        );

    public static readonly DependencyProperty UpdateTriggerProperty =
        DependencyProperty.Register(
            "UpdateTrigger",
            typeof(NetworkUpdateTrigger),
            typeof(NetworkBinding),
            new CommunicationPropertyMetadata(
                NetworkUpdateTrigger.PropertyChanged
            )
        );

    public string SourceEndpoint
    {
        get => (string)GetValue(SourceEndpointProperty);
        set => SetValue(SourceEndpointProperty, value);
    }

    public NetworkUpdateTrigger UpdateTrigger
    {
        get => (NetworkUpdateTrigger)GetValue(UpdateTriggerProperty);
        set => SetValue(UpdateTriggerProperty, value);
    }
}

<ServiceNode Name="DataProcessor">
    <!-- Bind to remote service state -->
    <ServiceNode.State>
        <NetworkBinding 
            SourceEndpoint="tcp://state.service:5000/processor/state"
            UpdateTrigger="PropertyChanged"
            Mode="TwoWay"/>
    </ServiceNode.State>

    <!-- Bind to remote service metrics -->
    <ServiceNode.Metrics>
        <NetworkBinding 
            SourceEndpoint="tcp://metrics.service:5001/processor/metrics"
            UpdateTrigger="Interval"
            UpdateInterval="00:00:05"/>
    </ServiceNode.Metrics>
</ServiceNode>

public class NetworkStateManager
{
    private readonly INetworkDispatcher _dispatcher;
    private readonly ConcurrentDictionary<string, NetworkBinding> _bindings;

    public async Task SynchronizeStateAsync(NetworkBinding binding)
    {
        var endpoint = binding.SourceEndpoint;
        var state = await _dispatcher.GetStateAsync(endpoint);
        
        binding.Value = state;
        _bindings.AddOrUpdate(endpoint, binding, (_, existing) => binding);

        // Subscribe to remote state changes
        await _dispatcher.SubscribeAsync(endpoint, async (update) =>
        {
            await UpdateBindingValueAsync(endpoint, update);
        });
    }

    private async Task UpdateBindingValueAsync(string endpoint, object newValue)
    {
        if (_bindings.TryGetValue(endpoint, out var binding))
        {
            await binding.UpdateValueAsync(newValue);
            await PropagateUpdateAsync(binding);
        }
    }

    private async Task PropagateUpdateAsync(NetworkBinding binding)
    {
        var dependents = GetDependentBindings(binding);
        foreach (var dependent in dependents)
        {
            await UpdateBindingValueAsync(dependent.SourceEndpoint, binding.Value);
        }
    }
}

public class NetworkUpdateTriggerManager
{
    private readonly INetworkDispatcher _dispatcher;
    private readonly Dictionary<NetworkBinding, IDisposable> _subscriptions;

    public IDisposable RegisterTrigger(NetworkBinding binding)
    {
        return binding.UpdateTrigger switch
        {
            NetworkUpdateTrigger.PropertyChanged => 
                RegisterPropertyChangedTrigger(binding),
                
            NetworkUpdateTrigger.Interval => 
                RegisterIntervalTrigger(binding),
                
            NetworkUpdateTrigger.Explicit => 
                RegisterExplicitTrigger(binding),
                
            _ => throw new NotSupportedException()
        };
    }

    private IDisposable RegisterPropertyChangedTrigger(NetworkBinding binding)
    {
        return Observable
            .FromEventPattern(binding, nameof(INotifyPropertyChanged.PropertyChanged))
            .Subscribe(async _ => await SynchronizeBindingAsync(binding));
    }

    private IDisposable RegisterIntervalTrigger(NetworkBinding binding)
    {
        return Observable
            .Interval(binding.UpdateInterval)
            .Subscribe(async _ => await SynchronizeBindingAsync(binding));
    }
}