CodeWF.NetWeaver is the serialization core for network packets.

CodeWF.NetWrapper builds on top of it and provides TCP/UDP helper classes, command dispatching, and file transfer / file management capabilities.

Chinese version: README.zh-CN.md

Install only the packet serializer:

dotnet add package CodeWF.NetWeaver

Install the socket helper layer when you need TCP/UDP command dispatching, file transfer, or file management:

dotnet add package CodeWF.NetWrapper

Package Manager Console is also supported:

NuGet\Install-Package CodeWF.NetWeaver

• Development SDK: .NET 11 preview, pinned through global.json
• Package management: centralized with Directory.Packages.props
• Core libraries: CodeWF.NetWeaver and CodeWF.NetWrapper
• Sample UI stack: Avalonia 12.0.2, Semi.Avalonia 12.0.1, ReactiveUI.Avalonia 12.0.1
• Free-only policy: Prism.DryIoc.Avalonia remains pinned to 8.1.97.11073
• Grid migration: the sample applications now use CodeWF.AvaloniaControls.ProDataGrid instead of the old free Avalonia.Controls.DataGrid line

Restore, build, and test the whole solution:

dotnet restore CodeWF.NetWeaver.slnx
dotnet build CodeWF.NetWeaver.slnx -c Debug
dotnet test CodeWF.NetWeaver.slnx -c Debug --no-build

Pack the NuGet libraries:

pack.bat

Publish the runnable samples:

publish_all.bat

Run the server sample first, then the client sample:

dotnet run --project src/SocketTest.Server/SocketTest.Server.csproj -f net11.0-windows
dotnet run --project src/SocketTest.Client/SocketTest.Client.csproj -f net11.0-windows

Each packet contains a fixed header plus the serialized object body:

Header
- BufferLen: int
- SystemId: long
- ObjectId: ushort
- ObjectVersion: byte
- UnixTimeMilliseconds: long

Body
- Serialized object payload

Mark a DTO with NetHead so the serializer can identify it on the wire:

using CodeWF.NetWeaver.Base;

[NetHead(10, 1)]
public class ResponseProcessList : INetObject
{
    public int TaskId { get; set; }

    public int TotalSize { get; set; }

    public List<ProcessItem>? Processes { get; set; }
}

public record ProcessItem
{
    public int Pid { get; set; }

    public string? Name { get; set; }
}

Serialize:

var netObject = new ResponseProcessList
{
    TaskId = 3,
    TotalSize = 2,
    Processes =
    [
        new ProcessItem { Pid = 1, Name = "CodeWF.NetWeaver" },
        new ProcessItem { Pid = 2, Name = "CodeWF.NetWrapper" }
    ]
};

var buffer = netObject.Serialize(systemId: 32);
Console.WriteLine($"Packet bytes: {buffer.Length}");

Deserialize:

var deserialized = buffer.Deserialize<ResponseProcessList>();

Console.WriteLine($"Process count: {deserialized.Processes?.Count ?? 0}");

CodeWF.NetWrapper handles TCP/UDP communication and converts raw packets into typed commands:

using CodeWF.EventBus;
using CodeWF.NetWrapper.Commands;
using CodeWF.NetWrapper.Helpers;

var server = new TcpSocketServer();
await server.StartAsync("Server", "0.0.0.0", 8888);

EventBus.Default.Subscribe<SocketCommand>(async (sender, command) =>
{
    // Non-file-management commands can be processed here.
    await Task.CompletedTask;
});

TcpSocketClient and TcpSocketServer now expose a clearer file management API:

Every request/response-style communication object carries a TaskId. The same TaskId is propagated through request, response, chunk data, chunk acknowledgement, reject, and complete messages so callers can correlate a full transfer flow reliably.

await client.BrowseFileSystemAsync("/");
await client.CreateDirectoryAsync("uploads");
await client.DeletePathAsync("old-folder", true);
await client.DeletePathAsync("uploads/old.bin", false);
await client.UploadFileAsync(@"D:\local\demo.zip", "uploads/demo.zip");
await client.DownloadFileAsync("uploads/demo.zip", @"D:\downloads");

var server = new TcpSocketServer
{
    // All browse/create/delete/upload/download operations are restricted to this root.
    FileSaveDirectory = @"D:\ServerFiles"
};

server.FileTransferProgress += (sender, args) =>
{
    Console.WriteLine($"{args.FileName}: {args.Progress:F2}%");
};

When FileSaveDirectory is set:

• Browsing, creating, deleting, uploading, and downloading are restricted to that root directory.
• Relative paths such as "uploads/demo.zip" are resolved under the managed root.
• Attempts to escape the root with paths like "..\\outside.txt" are rejected by the server.

• Transfers use 64 KB blocks.
• Upload and download both support resume by offset.
• Completed files are verified with SHA-256.
• FileTransferProgress is raised on both client and server sides.

The file management feature now uses the cleaned-up names below:

The file transfer pipeline now uses these names:

The repository includes integration-style tests for the wrapper file pipeline:

• upload into the managed server root
• download into the requested local directory
• reject path traversal outside FileSaveDirectory

Run them with:

dotnet test src\CodeWF.NetWrapper.Tests\CodeWF.NetWrapper.Tests.csproj

The design note document is available here:

CodeWF-NetWeaver-Design-Principles.md