Service Component

<CommunicationControl x:Class="Matrix.Network.Controls.ServiceComponent"
                     xmlns="http://schemas.matrix.com/network/2024"
                     xmlns:x="http://schemas.matrix.com/network/2024/xaml"
                     xmlns:local="clr-namespace:Matrix.Network.Controls">
    <NetworkGrid>
        <NetworkGrid.Endpoints>
            <Endpoint Path="status" />
            <Endpoint Path="command" />
            <Endpoint Path="state" />
        </NetworkGrid.Endpoints>
        
        <!-- Service Identity -->
        <ServiceIdentity Grid.Row="0" 
                        Name="{Binding ServiceName}" 
                        Type="Stateful"/>
        
        <!-- Service State -->
        <StateManager Grid.Row="1" 
                     Orientation="Distributed">
            <TextBlock Text="State: "/>
            <StateIndicator State="{Binding ServiceState}"/>
        </StateManager>
        
        <!-- Command Interface -->
        <CommandInterface Grid.Row="2" 
                         Commands="{Binding AvailableCommands}"/>
    </NetworkGrid>
</CommunicationControl>

public partial class ServiceComponent : CommunicationControl
{
    // Network Properties
    public static readonly DependencyProperty ServiceNameProperty = 
        DependencyProperty.Register(
            "ServiceName", 
            typeof(string), 
            typeof(ServiceComponent));
            
    public static readonly DependencyProperty ServiceStateProperty = 
        DependencyProperty.Register(
            "ServiceState", 
            typeof(ServiceState), 
            typeof(ServiceComponent));
            
    public static readonly DependencyProperty CommandsProperty = 
        DependencyProperty.Register(
            "AvailableCommands", 
            typeof(IEnumerable<ServiceCommand>), 
            typeof(ServiceComponent));

    // Properties
    public string ServiceName
    {
        get => (string)GetValue(ServiceNameProperty);
        set => SetValue(ServiceNameProperty, value);
    }
    
    public ServiceState ServiceState
    {
        get => (ServiceState)GetValue(ServiceStateProperty);
        set => SetValue(ServiceStateProperty, value);
    }
    
    public IEnumerable<ServiceCommand> AvailableCommands
    {
        get => (IEnumerable<ServiceCommand>)GetValue(CommandsProperty);
        set => SetValue(CommandsProperty, value);
    }

    public ServiceComponent()
    {
        InitializeComponent();
        InitializeNetworkEndpoints();
    }

    private void InitializeNetworkEndpoints()
    {
        RegisterEndpoint("status", HandleStatusRequest);
        RegisterEndpoint("command", HandleCommandRequest);
        RegisterEndpoint("state", HandleStateChange);
    }

    private async Task HandleStatusRequest(NetworkMessage message)
    {
        await SendResponse(new ServiceStatus
        {
            Name = ServiceName,
            State = ServiceState,
            Commands = AvailableCommands
        });
    }

    private async Task HandleCommandRequest(NetworkMessage message)
    {
        var command = message.GetContent<ServiceCommand>();
        await ExecuteCommand(command);
    }

    private async Task HandleStateChange(NetworkMessage message)
    {
        var newState = message.GetContent<ServiceState>();
        ServiceState = newState;
        await BroadcastStateChange(newState);
    }
}

<!-- Basic Usage -->
<local:ServiceComponent 
    ServiceName="DataProcessor" 
    ServiceState="Active" />

<!-- With Command Interface -->
<local:ServiceComponent 
    ServiceName="AnalyticsEngine" 
    ServiceState="Standby">
    <local:ServiceComponent.AvailableCommands>
        <ServiceCommand Name="StartAnalysis" Endpoint="/api/analyze"/>
        <ServiceCommand Name="StopAnalysis" Endpoint="/api/stop"/>
    </local:ServiceComponent.AvailableCommands>
</local:ServiceComponent>

public class ServiceComponentNetworkAdapter
{
    private readonly ServiceComponent _component;
    private readonly INetworkDispatcher _dispatcher;
    
    public ServiceComponentNetworkAdapter(
        ServiceComponent component, 
        INetworkDispatcher dispatcher)
    {
        _component = component;
        _dispatcher = dispatcher;
        
        // Subscribe to network events
        _dispatcher.StateChanged += OnServiceStateChanged;
        _dispatcher.CommandReceived += OnCommandReceived;
    }
    
    private async Task OnServiceStateChanged(object sender, ServiceStateEventArgs e)
    {
        await _component.HandleStateChange(new NetworkMessage
        {
            Type = MessageType.StateChange,
            Content = e.NewState
        });
    }
    
    private async Task OnCommandReceived(object sender, CommandEventArgs e)
    {
        await _component.HandleCommandRequest(new NetworkMessage
        {
            Type = MessageType.Command,
            Content = e.Command
        });
    }
}