Через память передавать координаты и размер окружности с родительского процесса в дочерний

class Sender : IDisposable
{
    private readonly MemoryMappedFile _mmf;
    private readonly Semaphore _readSemaphore;
    private readonly Semaphore _writeSemaphore;
    
    public Sender(string id)
    {
        if (string.IsNullOrWhiteSpace(id))
        {
            throw new ArgumentException(nameof(id));
        }
        _mmf = MemoryMappedFile.CreateOrOpen(id, sizeof(float) * 3);
        _readSemaphore = new Semaphore(0, 1, id + "read");
        _writeSemaphore = new Semaphore(1, 1, id + "write");
    }
    
    public void Send(float x, float y, float r)
    {
        using (var view = _mmf.CreateViewStream())
        {
            using (var writer = new BinaryWriter(view))
            {
                _writeSemaphore.WaitOne();
                writer.Write(x);
                writer.Write(y);
                writer.Write(r);
                _readSemaphore.Release();
            }
        }
    }
    
    public void Dispose()
    {
        _readSemaphore.Dispose();
        _writeSemaphore.Dispose();
        _mmf.Dispose();
    }
}
 
class Reciever : IDisposable
{
    private readonly Semaphore _readSemaphore;
    private readonly Semaphore _writeSemaphore;
    private readonly MemoryMappedFile _mmf;
    private readonly Thread _worker;
    
    public Reciever(string id)
    {
        if (string.IsNullOrWhiteSpace(nameof(id)))
        {
            throw new ArgumentException(nameof(id));
        }
        _readSemaphore = Semaphore.OpenExisting(id + "read");
        _writeSemaphore = Semaphore.OpenExisting(id + "write");
        _mmf = MemoryMappedFile.OpenExisting(id);
        _worker = new Thread(Run);
    }
    
    public void StartRecieving()
    {
        _worker.Start();
    }
    
    private void Run()
    {
        try
        {
            while (true)
            {
                _readSemaphore.WaitOne();
 
                using (var view = _mmf.CreateViewStream())
                {
                    using (var reader = new BinaryReader(view))
                    {
                        float x = reader.ReadSingle();
                        float y = reader.ReadSingle();
                        float r = reader.ReadSingle();
                        Recieved?.Invoke(this, new RecieveEventArgs(x, y, r));
                    }
                }
 
                _writeSemaphore.Release();
            }
        }
        catch (ThreadInterruptedException)
        {
            return;
        }
    }
    
    public event EventHandler<RecieveEventArgs> Recieved;
    
    public void Dispose()
    {
        _readSemaphore.Dispose();
        _writeSemaphore.Dispose();
        _mmf.Dispose();
        if (_worker.IsAlive)
        {
            _worker.Interrupt();
            _worker.Join();
        }
    }
}
 
class RecieveEventArgs : EventArgs
{
    public float X { get; }
    public float Y { get; }
    public float R { get; }
    
    public RecieveEventArgs(float x, float y, float r)
    {
        X = x;
        Y = y;
        R = r;
    }
}
 
class MainForm : Form
{
    private readonly NumericUpDown _nudX;
    private readonly NumericUpDown _nudY;
    private readonly NumericUpDown _nudR;
    private readonly Sender _sender = new Sender("MyApp");
    bool started;
    
    public MainForm()
    {
        _nudX = new NumericUpDown { Parent = this };
        _nudY = new NumericUpDown { Parent = this, Top = _nudX.Bottom };
        _nudR = new NumericUpDown { Parent = this, Top = _nudY.Bottom };
        var btnRun = new Button { Parent = this, Text = "Run", Top = _nudR.Bottom };
        btnRun.Click += Run;
    }
    
    private void Run(object sender, EventArgs e)
    {
        _sender.Send((float)_nudX.Value, (float)_nudY.Value, (float)_nudR.Value);
 
        if (!started)
        {
            started = true;
            var clientForm = new ClientForm();
            clientForm.FormClosed += (_, __) => started = false;
            clientForm.Show();
        }
    }
 
    protected override void Dispose(bool disposing)
    {
        if (disposing)
        {
            _sender?.Dispose(); 
        }
        base.Dispose(disposing);
    }
}
 
class ClientForm : Form
{
    private float _x;
    private float _y;
    private float _r;
    
    private readonly object _locker;
    private bool _recieved;
    private readonly Reciever _reciever;
    
    public ClientForm()
    {
        _locker = new object();
        _reciever = new Reciever("MyApp");
        _reciever.Recieved += Recieved;
        _reciever.StartRecieving();
    }
    
    private void Recieved(object sender, RecieveEventArgs e)
    {
        lock (_locker)
        {
            _x = e.X;
            _y = e.Y;
            _r = e.R;
            _recieved = true;
            Invalidate();
        }
    }
    
    protected override void OnPaint(PaintEventArgs e)
    {
        lock (_locker)
        {
            if (_recieved)
            {
                e.Graphics.DrawEllipse(Pens.Red, _x - _r, _y - _r, _r * 2, _r * 2);
            }
        }
    }
    
    protected override void Dispose(bool disposing)
    {
        if (disposing)
        {
            _reciever.Dispose();
        }
        base.Dispose(disposing);
    }
}
 
void Main()
{
    Application.Run(new MainForm());
}