Работоспобность Debug vs Release

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
using System.Diagnostics;
using System.Net;
using System.Net.Sockets;
using System.Xml.Serialization;
using System.IO;
 
namespace server
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Console.Write("Count of clients: ");
                var count = int.Parse(Console.ReadLine());
                var ip = GetLocalIPAddress();
                var listener = new Socket(ip.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
                listener.Bind(new IPEndPoint(ip, 11000));
                listener.Listen(count);
                Console.WriteLine($"Server was started with ip: "{ip}".");
                Console.WriteLine("Waiting for connection to all clients.");
                var clients = new List<Socket>();
                var stopwatch = new Stopwatch();
 
                while (clients.Count < count)
                {
                    clients.Add(listener.Accept());
                    Console.WriteLine($"Client[{clients.Count}] from "{clients.Last().RemoteEndPoint}" was connected.");
                }
 
                Console.WriteLine("All clients are connected. Started a cycle of job assignments.");
 
                while (true)
                {
                    var values = Console.ReadLine().Split(' ').Select(double.Parse).ToArray();
                    var clientTask = new ClientTask() { Start = values[0], End = values[1], Step = values[2], Clients = clients };
                    new Task(TaskHandler, clientTask).Start();
                }
            }
            catch (Exception e)
            {
                Console.Write(e.Message);
            }
            Console.ReadKey();
        }
 
        static void TaskHandler(object data)
        {
            var stopwatch = new Stopwatch();
            stopwatch.Start();
 
            var clientTask = (ClientTask)data;
            var results = new List<double>();
 
            for (var i = 0; i < clientTask.Clients.Count; i++, clientTask.Start += clientTask.ClientStep * i)
            {
                var sendArgs = new SocketAsyncEventArgs();
                var buff = clientTask.Serialize();
                sendArgs.SetBuffer(buff, 0, buff.Length);
                sendArgs.UserToken = results;
                sendArgs.AcceptSocket = clientTask.Clients[i];
                sendArgs.Completed += SendArgs_Completed;
                clientTask.Clients[i].SendAsync(sendArgs);
            }
 
            while (results.Count != clientTask.Clients.Count) ;
 
            var result = results.Sum();
            stopwatch.Stop();
            Console.WriteLine($"result: {result}; time: {stopwatch.ElapsedMilliseconds}");
        }
 
        static void SendArgs_Completed(object sender, SocketAsyncEventArgs e)
        {
            e.Completed -= SendArgs_Completed;
            e.Completed += ReceiveArgs_Completed;
            e.AcceptSocket.ReceiveAsync(e);
        }
 
        static void ReceiveArgs_Completed(object sender, SocketAsyncEventArgs e)
        {
            (e.UserToken as List<double>).Add(BitConverter.ToDouble(e.Buffer, 0));
        }
 
        static IPAddress GetLocalIPAddress()
        {
            var hostName = Dns.GetHostName();
            var ipHost = Dns.GetHostByName(hostName);
            return ipHost.AddressList[0];
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.Net;
using System.Net.Sockets;
 
namespace client
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Console.Write("ip: ");
                var ip = IPAddress.Parse(Console.ReadLine());
                var ep = new IPEndPoint(ip, 11000);
                var socket = new Socket(ep.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
                socket.Connect(ep);
                Console.WriteLine("Connected");
                var receiveArgs = new SocketAsyncEventArgs();
                receiveArgs.AcceptSocket = socket;
                receiveArgs.SetBuffer(new byte[256], 0, 256);
                receiveArgs.Completed += ReceiveArgs_Completed;
                socket.ReceiveAsync(receiveArgs);
            }
            catch (Exception e)
            {
                Console.Write(e.Message);
            }
            Console.ReadKey();
        }
 
        static void ReceiveArgs_Completed(object sender, SocketAsyncEventArgs e)
        {
            e.AcceptSocket.ReceiveAsync(e);
            var stopwatch = new Stopwatch();
            stopwatch.Start();
 
            var clientTask = ClientTask.Deserialize(e.Buffer);
            var steps = TheMethodOfTrapezoidsSteps(x => Math.Exp(-x), clientTask.Start, clientTask.End, clientTask.Step);
            var stepsParallel = steps.AsParallel().WithExecutionMode(ParallelExecutionMode.ForceParallelism)
                    .WithDegreeOfParallelism(Environment.ProcessorCount);
            var result = stepsParallel.Sum();
 
            stopwatch.Stop();
            Console.WriteLine($"result: {result}; time: {stopwatch.ElapsedMilliseconds}");
 
            e.AcceptSocket.Send(BitConverter.GetBytes(result));
        }
 
        static double TheMethodOfTrapezoids(Func<double, double> function, double x, double step)
        {
            return (function(x) + function(x + step)) * step / 2;
        }
 
        static IEnumerable<double> TheMethodOfTrapezoidsSteps(Func<double, double> function, double start, double end, double step)
        {
            for (double x = start; x <= end; x += step)
                yield return TheMethodOfTrapezoids(function, x, step);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.Net;
using System.Net.Sockets;
using System.Xml.Serialization;
using System.IO;
 
public struct ClientTask
{
    public static XmlSerializer Serializer { get; } = new XmlSerializer(typeof(ClientTask));
 
    public double Start { get; set; }
    public double End { get; set; }
    public double Step { get; set; }
    [XmlIgnore]
    public int StepCount { get { return (int)((End - Start) / Step); } }
    [XmlIgnore]
    public List<Socket> Clients { get; set; }
    [XmlIgnore]
    public int ClientStep { get { return (int)Math.Round(StepCount * Step / Clients.Count); } }
 
    public byte[] Serialize()
    {
        byte[] result = null;
 
        using (var stream = new MemoryStream())
        {
            Serializer.Serialize(stream, this);
            result = stream.ToArray();
        }
 
        return result;
    }
 
    public static ClientTask Deserialize(byte[] data)
    {
        using (var stream = new MemoryStream(data))
            return (ClientTask)Serializer.Deserialize(stream);
    }
}