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.