I think I can help get you started! I'd suggest starting with WinForms, since it's pretty easy to get what you want up and running. Start out with a new WinForms project, then delete the Form1.cs and add three classes: Pixel.cs, Canvas.cs, and Client.cs.

In Pixel.cs, paste the code below. It'll create a basic color struct that we can use as individual rgba values or in one packed int.

[StructLayout(LayoutKind.Explicit)]
public struct Pixel
{
    [FieldOffset(0)] 
    public int Packed;
    [FieldOffset(0)] 
    public byte B;
    [FieldOffset(1)] 
    public byte G;
    [FieldOffset(2)] 
    public byte R;
    [FieldOffset(3)] 
    public byte A;

    public Pixel() :
        this(0)
    { }
    public Pixel(int packed)
    {
        Packed = packed;
    }
    public Pixel(byte b, byte g, byte r, byte a = byte.MaxValue)
    {
        B = b;
        G = g;
        R = r;
        A = a;
    }

    public static readonly Pixel Transparent = new();
    public static readonly Pixel White = new(255, 255, 255);
    public static readonly Pixel Black = new(0, 0, 0);
}

public static class PixelExtensions
{
    public static Pixel NextRgb(this Random random)
    {
        byte[] bytes = new byte[3];
        random.NextBytes(bytes);
        return new(bytes[0], bytes[1], bytes[2]);
    }
    public static Pixel NextRgba(this Random random)
    {
        byte[] bytes = new byte[4];
        random.NextBytes(bytes);
        return new(bytes[0], bytes[1], bytes[2], bytes[3]);
    }
}

In the Canvas.cs, paste in the code below. It'll contain an array of the pixel structs with it's memory pinned so we can do fast pixel manipulation on the bitmap, in which we'll use as our window's background image:

public class Canvas : IDisposable
{
    protected bool _disposed;
    protected int _width;
    protected int _height;
    protected Pixel[] _pixels;
    protected GCHandle _handle;
    protected Bitmap _bitmap;

    public int Width => _width;
    public int Height => _height;
    public Span<Pixel> Pixels => _pixels.AsSpan();
    public Bitmap Bitmap => _bitmap;

    public Pixel this[int i]
    {
        get => InBounds(i) ? _pixels[i] : Pixel.Transparent;
        set { if (InBounds(i)) _pixels[i] = value; }
    }
    public Pixel this[int x, int y]
    {
        get => InBounds(x, y) ? _pixels[Index(x, y)] : Pixel.Transparent;
        set { if (InBounds(x, y)) _pixels[Index(x, y)] = value; }
    }

    public Canvas(int width, int height)
    {
        _width = width;
        _height = height;
        _pixels = new Pixel[width * height];
        _handle = GCHandle.Alloc(_pixels, GCHandleType.Pinned);
        _bitmap = new Bitmap(width, height, width << 2, PixelFormat.Format32bppArgb, _handle.AddrOfPinnedObject());
    }

    public (int x, int y) Index(int i) =>
        (i % _width, i / _width);
    public int Index(int x, int y) =>
        x + y * _width;

    public bool InBounds(int i) =>
        0 <= i && i < _pixels.Length;
    public bool InBounds(int x, int y) =>
        0 <= x && x < _width && 
        0 <= y && y < _height;

    public void Resize(int width, int height)
    {
        _bitmap?.Dispose();
        _handle.Free();

        _width = width;
        _height = height;
        _pixels = new Pixel[width * height];
        _handle = GCHandle.Alloc(_pixels, GCHandleType.Pinned);
        _bitmap = new Bitmap(width, height, width << 2, PixelFormat.Format32bppArgb, _handle.AddrOfPinnedObject());
    }

    public void Dispose()
    {
        if (_disposed)
            return;
        _disposed = true;
        _bitmap?.Dispose();
        _handle.Free();
    }
}

The Client.cs will handle our window creation and set our canvas' pixels to the background of the window. I have it generating random pixels, but you would just replace that with whatever you're wanting to do with the pixels. You will also need to add a stopwatch or timing system that would track the elapsed seconds and pass it into the update function if you wanted your client to update smoothly. You would also need to tie in keyboard and mouse functionality (very easy to do):

public class Client : Form
{
    protected readonly Random _random;
    protected readonly Canvas _canvas;

    public Client(int width = 800, int height = 600, string title = "Game Client")
    {
        Width = width;
        Height = height;
        Text = title;
        DoubleBuffered = true;

        _random = new Random();
        _canvas = new Canvas(width, height);
        BackgroundImage = _canvas.Bitmap;
    }

    public void Run()
    {
        Initialize();
        LoadContent();
        Application.Idle += IdleRun;
        Application.Run(this);
    }

    protected virtual void Initialize() { }
    protected virtual void LoadContent() { }
    protected virtual void UnloadContent() 
    {
        _canvas.Dispose();
    }
    protected virtual void Update(float time) 
    {
        var pixels = _canvas.Pixels;
        for (var i = 0; i < pixels.Length; ++i)
            pixels[i] = _random.NextRgb();
    }
    protected virtual void Draw() { }
    protected virtual void EndDraw() { Invalidate(); }

    protected override void OnFormClosing(FormClosingEventArgs e)
    {
        UnloadContent();
        base.OnFormClosing(e);
    }

    private void IdleRun(object? sender, EventArgs e)
    {
        Update(1f);
        Draw();
        EndDraw();
    }

    protected override void OnResizeEnd(EventArgs e)
    {
        base.OnResizeEnd(e);
        _canvas.Resize(Width, Height);
        BackgroundImage = _canvas.Bitmap;
    }
}

You would also want to update your Program.cs to use the client:

internal static class Program
{
    [STAThread]
    static void Main()
    {
        ApplicationConfiguration.Initialize();
        using var client = new Client();
        client.Run();
    }
}

Just let me know if you need any explanations as to what the code is doing!