Udp сендер пропускает пакеты на максимальной скорости передачи

        private CancellationTokenSource? _cts;
        int cnt;
        public MainWindow()
        {
            InitializeComponent();
            DataContext = this;
        }
        public int Cnt 
        {
            get => cnt;
            set => Set(ref cnt, value);
        }
 
        private async void Button_Click(object sender, RoutedEventArgs e)
        {
            var button = (Button)sender;
 
            _cts = new();
            using var udp = new UdpClient(1233);
 
            try { await ProcessMessages(udp, _cts.Token); }
            finally { }
        }
 
        private void Button_Click_1(object sender, RoutedEventArgs e)
        {
            _cts?.Cancel();
            _cts?.Dispose();
            _cts = null;
        }
        private async Task ProcessMessages(UdpClient udp, CancellationToken ct)
        {
            await foreach (var message in ReceiveMessages(udp, ct))
            {
            }
        }
 
        async IAsyncEnumerable<byte[]> ReceiveMessages(UdpClient udp, [EnumeratorCancellation] CancellationToken ct)
        {
            UdpReceiveResult result;
            while (!ct.IsCancellationRequested)
            {
                try { result = await udp.ReceiveAsync(ct); }
                catch (OperationCanceledException) { yield break; }
 
                Cnt++;
                yield return result.Buffer;
            }
        }

private CancellationTokenSource? _cts;
private readonly Channel<byte[]> write_channel = Channel.CreateUnbounded<byte[]>();
private readonly Channel<int> cnt_channel = Channel.CreateUnbounded<int>();
string directoryPath;
string filePath;
FileStream fs;
Task processMessagesTask;
Task recordTask;
Task cntUpdate;
int cnt;
public MainWindow()
{
    InitializeComponent();
    DataContext = this;
    directoryPath = Environment.GetFolderPath(Environment.SpecialFolder.Personal) + "//" + "Data";
    filePath = directoryPath + "//" + "" + DateTime.Now.ToString("HH_mm_ss") + ".bdi";
}
public int Cnt 
{
    get => cnt;
    set => Set(ref cnt, value);
}
 
private async void Button_Click(object sender, RoutedEventArgs e)
{
    var button = (Button)sender;
    fs = new FileStream(filePath, FileMode.Append, FileAccess.Write);
 
    _cts = new();
    using var udp = new UdpClient(1233);
 
    processMessagesTask = ProcessMessages(udp, _cts.Token);
    recordTask = Record();
 
    try 
    {
        await Task.WhenAll(processMessagesTask, recordTask);
    }
    finally {  }
}
 
private void Button_Click_1(object sender, RoutedEventArgs e)
{
    fs.Flush();
    fs.Close();
    _cts?.Cancel();
    _cts?.Dispose();
    _cts = null;
}
private async Task ProcessMessages(UdpClient udp, CancellationToken ct)
{
    ChannelWriter<byte[]> writer = write_channel.Writer;
    await foreach (var message in ReceiveMessages(udp, ct))
    {
        writer.TryWrite(message);
    }
}
 
async IAsyncEnumerable<byte[]> ReceiveMessages(UdpClient udp, [EnumeratorCancellation] CancellationToken ct)
{
    UdpReceiveResult result;
    while (!ct.IsCancellationRequested)
    {
        try { result = await udp.ReceiveAsync(ct); }
        catch (OperationCanceledException) { yield break; }
        //Cnt++;
        yield return result.Buffer;
    }
}
private async Task Record()
{
    try
    {
        ChannelReader<byte[]> reder = write_channel.Reader;
        while (true) 
        {
            byte[] data = await reder.ReadAsync();
            fs.Write(data, 0, data.Length);
        }
    }
    catch (Exception e)
    {
    }
}

private readonly Channel<int> cnt_channel = Channel.CreateUnbounded<int>();
int cnt;
 
public int Cnt 
{
    get => cnt;
    set => Set(ref cnt, value);
}
 
private async void Button_Click(object sender, RoutedEventArgs e)
{
 
    //...
 
    formUpdate = FormUpdate();
 
    try 
    {
        await Task.WhenAll(formUpdate);
    }
    finally { /*button.Enabled = true;*/ }
}
 
private async Task ProcessMessages(UdpClient udp, CancellationToken ct)
{
    ChannelWriter<int> cntWriter = cnt_channel.Writer;
    int cnt = 0;
    await foreach (var message in ReceiveMessages(udp, ct))
    {
        cnt++;
        cntWriter.TryWrite(cnt);
    }
}
 
async IAsyncEnumerable<byte[]> ReceiveMessages(UdpClient udp, [EnumeratorCancellation] CancellationToken ct)
{
    UdpReceiveResult result;
    while (!ct.IsCancellationRequested)
    {
        try { result = await udp.ReceiveAsync(ct); }
        catch (OperationCanceledException) { yield break; }
 
        yield return result.Buffer;
    }
}
private async Task FormUpdate() 
{
    ChannelReader<int> reder = cnt_channel.Reader;
    SynchronizationContext? sc = SynchronizationContext.Current;
    while (true) 
    {
        sc.Send(async x => Cnt = await reder.ReadAsync(), null);
    }
}

        public MainWindow()
        {
            ViewContext = SynchronizationContext.Current;
        }
        public SynchronizationContext? ViewContext { get; set; }
 
        private async void Button_Click(object sender, RoutedEventArgs e)
        {
            try 
            {
                processMessagesTask = ProcessMessages(udp, _cts.Token);
                recordTask = Record();
                formUpdate = FormUpdate();
 
                await Task.WhenAll(processMessagesTask, recordTask, formUpdate);
            }
            finally { /*button.Enabled = true;*/ }
        }
        private async Task FormUpdate()
        {
            ChannelReader<int> reder = cnt_channel.Reader;
            while (true)
            {
                ViewContext.Send(async _ => await reder.ReadAsync(), null);
            }
        }

ViewContext = SynchronizationContext.Current;

private void Window_Loaded(object sender, RoutedEventArgs e)
{
    IPPWorkHBWindowVM vm = (IPPWorkHBWindowVM)DataContext;
 
    vm.ViewContext = SynchronizationContext.Current;
}

        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            ViewContext = SynchronizationContext.Current;
        }

        formUpdate = FormUpdate();
 
        await Task.WhenAll(processMessagesTask, recordTask, formUpdate);
 
        private async Task FormUpdate()
        {
            ChannelReader<int> reder = cnt_channel.Reader;
            while (true)
            {
                vm.ViewContext.Send(async _ => await reder.ReadAsync(), null);
            }
        }

        private async Task FormUpdate()
        {
            ChannelReader<int> reder = cnt_channel.Reader;
            while (true)
            {
                int data = await reder.ReadAsync();
                vm.ViewContext.Send(_ => vm.Cnt = data, null);
            }
        }

        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
            => PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));