RCON.Net.Commands 1.1.1

RCON.Net.Commands

Generic command helpers and base types for building typed RCON commands.

Overview

RCON.Net.Commands provides the foundational abstractions for command building and response parsing:

• ICommand Interface - Abstract command implementation contract
• CommandBase - Base class for implementing custom commands
• Response Parsing - Generic type-safe response parsing framework
• Command Builders - Utilities for building command strings

Installation

Install via NuGet:

dotnet add package RCON.Net.Commands

Dependencies

• RCON.Net.Core - Core RCON client library

Key Components

ICommand Interface

The core abstraction for all command implementations.

public interface ICommand
{
    /// <summary>
    /// Builds the command string to send to the server.
    /// </summary>
    string Build();

    /// <summary>
    /// Parses a server response into a typed result.
    /// </summary>
    T? Parse<T>(string response) where T : class;
}

CommandBase

Base class for implementing custom commands with common functionality.

public abstract class CommandBase : ICommand
{
    public abstract string Build();
    
    public virtual T? Parse<T>(string response) where T : class
    {
        // Default parsing logic
        return response as T;
    }
}

Creating Custom Commands

Implement the ICommand interface or extend CommandBase:

public class CustomCommand : CommandBase
{
    private readonly string _argument;
    
    public CustomCommand(string argument)
    {
        _argument = argument ?? throw new ArgumentNullException(nameof(argument));
    }
    
    public override string Build()
    {
        return $"custom {_argument}";
    }
    
    public override T? Parse<T>(string response) where T : class
    {
        // Parse response and return typed result
        return null;
    }
}

Usage Pattern

using RCON.Core;
using RCON.Commands;

// Create client
var client = RconClientBuilder.Create()
    .WithHost("127.0.0.1")
    .WithPort(25575)
    .WithPassword("password")
    .Build();

await client.ConnectAsync();

// Create and execute command
var command = new CustomCommand("value");
var response = await client.ExecuteAsync(command.Build());
var result = command.Parse<CustomResult>(response);

await client.DisconnectAsync();

Response Parsing

Commands support type-safe response parsing:

public class ListCommand : CommandBase
{
    public override string Build() => "list";
    
    public override T? Parse<T>(string response) where T : class
    {
        if (typeof(T) == typeof(PlayerList))
        {
            var lines = response.Split('\n');
            var playerList = new PlayerList { Players = ParsePlayers(lines) };
            return playerList as T;
        }
        return null;
    }
}

Multi-Targeting

• .NET 8.0, .NET 9.0, .NET 10.0

Features

✅ Type-safe command building
✅ Generic response parsing
✅ Extensible architecture
✅ No external dependencies
✅ Simple, intuitive API

Related Packages

• RCON.Net - Core RCON client
• RCON.Net.Commands.Minecraft.Java - Minecraft Java Edition commands

License

MIT License - See LICENSE file for details.