Сервер отправляет объект не null, а клиент принимает null

private async void Callback_GiveJobAsync(object sender, GiveJobEventArgs e)
{
    try
    {
        if (e.Job == null)
            Debug.WriteLine("null value received!");
 
        await Task.Run(() => Calculate(e.Job));
        Dispatch(() => Jobs.Add(e.Job));
        await Proxy.SetResultAsync(e.Job);
    }
    catch (Exception ex)
    {
        Debug.WriteLine(ex.StackTrace);
        Disconnect(null);
    }
}
 
private void Calculate(ClientJob job)
{
    try
    {
        Results = new ConcurrentBag<double>();
        var threadCount = Environment.ProcessorCount;
        var threadStep = (job.Top - job.Bottom) / threadCount;
        var threads = new List<Thread>();
        var x = job.Bottom;
 
        for (var i = 0; i < threadCount; i++, x += threadStep + job.Step)
        {
            var threadTask = new ClientJob()
            {
                Bottom = x,
                Top = x + threadStep,
                Step = job.Step,
                CpuLoading = job.CpuLoading
            };
 
            var thread = new Thread(ThreadHandler);
            threads.Add(thread);
            thread.Start(threadTask);
        }
 
        threads.ForEach(t => t.Join());
        job.Result = Results.Sum();
    }
    catch (Exception e)
    {
        Debug.WriteLine(e.StackTrace);
    }
}

private void Connect(object param)
{
    try
    {                
        var callback = new ClientCallback();
        callback.GiveJob += Callback_GiveJobAsync;
        callback.ServerIsStopped += Callback_ServerIsStopped;
        var context = new InstanceContext(callback);
        Proxy = new JobServiceClient(context);
        Proxy.Endpoint.Address = new EndpointAddress($"net.tcp://{IP}:{Port}/JobService");
        Proxy.Connect();
        IsConnected = true;
    }
    catch (Exception e)
    {
        IsConnected = false;
        MessageBox.Show(e.Message, "Error!", MessageBoxButton.OK, MessageBoxImage.Error);
    }
}

public class ClientCallback : IJobServiceCallback
{
    public event EventHandler<GiveJobEventArgs> GiveJob;
 
    public event EventHandler ServerIsStopped;
 
    void IJobServiceCallback.OnGiveJob(ClientJob job) => GiveJob?.Invoke(this, new GiveJobEventArgs(job));
 
    void IJobServiceCallback.OnServerIsStopped() => ServerIsStopped?.Invoke(this, new EventArgs());
}

public async void BeginCalculationAsync(ClientJob job)
{
    if (job == null)
        Debug.WriteLine("BeginCalculationAsync: job == null");
 
    Job = job;
    Job.CpuLoading = CpuLoading;
    _Returned = false;
    _Timer.Enabled = true;
    _Stopwatch.Start();
 
    Debug.WriteLine($"Job = {Job}; Job.Bottom = {Job.Bottom}; Job.Top = {Job.Top}; Job.Step = {Job.Step}; Job.Result = {Job.Result}; Job.CpuLoading = {Job.CpuLoading}");
 
    try
    {
        await Task.Run(() => Callback.OnGiveJob(Job));
    }
    catch (Exception e)
    {
        Debug.WriteLine(e.Message);
        var args = new ClientAbortedEventArgs(e, Job);
        ClientAborted?.Invoke(this, args);
    }
}

public async void BeginCalculationAsync(ClientJob job)
        {
            if (job == null)
            {
                Debug.WriteLine("BeginCalculationAsync: job == null");
                //Тут стоит прервать выполнение! Ато null на клиент попадёт :)
            }
 
            Job = job;

private bool TryGiveJob(ClientViewModel client)

if (Jobs.Count > 0)
            {

var job = LockingCall.Invoke(() => Jobs.Dequeue(), client);

Clients.AsParallel().ForAll(c => TryGiveJob(c));

IEnumerable<string> data = new List<string>() { "sdaasd", "asdasdasd" };
data.ToList().ForEach(line => line += line);

public class MainViewModel : ViewModelBase
{
    #region Fields
 
    private JobService ServiceInstance;
 
    private ServiceHost ServiceHost;
 
    private Queue<ClientJob> Jobs = new Queue<ClientJob>();
 
    private int JobCount;
 
    private List<double> Results = new List<double>();
 
    private bool _IsRunning = false;
 
    private bool _IsWorking = false;
 
    private double _ProgressValue = 0.0;
 
    private long _TimeLost = 0;
 
    private double? _ResultValue = null;
 
    #endregion
 
    #region Properties
 
    public bool IsRunning
    {
        get { return _IsRunning; }
        private set { Set(nameof(IsRunning), ref _IsRunning, value); }
    }
 
    public bool IsWorking
    {
        get { return _IsWorking; }
        private set { Set(nameof(IsWorking), ref _IsWorking, value); }
    }
 
    [Range(0, 10000)]
    public double BottomValue { get; set; } = 0;
 
    [Range(0, 10000)]
    public double TopValue { get; set; } = 100.0;
 
    [Range(0, 10000)]
    public double StepValue { get; set; } = 0.000001;
 
    public double ProgressValue
    {
        get { return _ProgressValue; }
        set { Set(nameof(ProgressValue), ref _ProgressValue, value); }
    }
 
    public long TimeLost
    {
        get { return _TimeLost; }
        set { Set(nameof(TimeLost), ref _TimeLost, value); }
    }
 
    public double? ResultValue
    {
        get { return _ResultValue; }
        set { Set(nameof(ResultValue), ref _ResultValue, value); }        
    }
 
    public ObservableCollection<ClientViewModel> Clients { get; } = new ObservableCollection<ClientViewModel>();
 
    #endregion
 
    #region Commands
 
    public ICommand ChangeStateCommand { get; }
 
    public ICommand SolveCommand { get; }
 
    public ICommand StopServerCommand { get; }
 
    #endregion
 
    public MainViewModel()
    {
        Application.Current.Dispatcher.UnhandledException += Dispatcher_UnhandledException;
        ChangeStateCommand = new RelayCommand(ChangeStateAsync);
        SolveCommand = new RelayCommand(SolveAsync, o => IsRunning && !IsWorking && !HasValidationErrors);
        StopServerCommand = new RelayCommand(StopServer, o => IsRunning);
    }
 
    private async void ChangeStateAsync(object param) => await Task.Run(() => ChangeState(param));
 
    private void ChangeState(object param)
    {         
        if (IsRunning && IsWorking)
        {
            Jobs.Clear();
            IsWorking = false;
        }            
 
        if (!IsRunning)
            StartServer(null);
        else
            StopServer(null);
 
        ProgressValue = 0.0;
    }
 
    private void StartServer(object param)
    {
        IsRunning = true;
        ServiceInstance = new JobService();
        ServiceInstance.ClientConnected += ClientConnected;
        ServiceInstance.ClientDisconnected += ClientDisconnected;
        ServiceInstance.ClientCalculated += ClientCalculated;
        ServiceHost = new ServiceHost(ServiceInstance);
        ServiceHost.Open();
    }
 
    private void StopServer(object param)
    {
        IsRunning = false;
        Clients.AsParallel().ForAll(c => c.DisconnectAsync());            
        ServiceHost.Close();
        Dispatch(() => Clients.Clear());
        ProgressValue = 0.0;
        TimeLost = 0;
        ResultValue = null;
    }
 
    private async void SolveAsync(object param) => await Task.Run(() => Solve(param));
 
    private void Solve(object param)
    {
        IsWorking = true;
        TimeLost = 0;
        ResultValue = null;
 
        foreach (var job in ClientJob.Distribute(BottomValue, TopValue, 1.0))
        {
            job.Step = StepValue;
            Jobs.Enqueue(job);
        }
 
        JobCount = Jobs.Count;
        Clients.AsParallel().ForAll(c => TryGiveJob(c));
 
        while (LockingCall.Invoke(() => Results.Count != JobCount, JobCount)) ;
 
        ResultValue = Results.Sum();
        Results.Clear();
 
        IsWorking = false;
    }
 
    private void ClientConnected(object sender, ClientChangeStateEventArgs e)
    {
        var client = new ClientViewModel(e.Callback, e.Address);
        client.ClientAborted += ClientAborted;
        Dispatch(() => Clients.Add(client));
        TryGiveJob(client);
    }
 
    private void ClientDisconnected(object sender, ClientChangeStateEventArgs e)
    {
        var client = Clients.First(c => c.Callback == e.Callback);
        RemoveClient(client);
    }
 
    private void ClientAborted(object sender, ClientAbortedEventArgs e)
    {
        var client = sender as ClientViewModel;
        RemoveClient(client);
    }
 
    private void ClientCalculated(object sender, ClientCalculatedEventArgs e)
    {
        var client = Clients.First(c => c.Callback == e.Callback);
        client.EndCalculationAsync();
        ProgressValue = (JobCount - Jobs.Count) * 100 / JobCount;
        TimeLost = client.LastDuation * Jobs.Count;
        LockingCall.Invoke(() => Results.Add(e.Job.Result), sender);
        TryGiveJob(client);
    }
 
    private bool TryGiveJob(ClientViewModel client)
    {
        if (LockingCall.Invoke(() => Jobs.Count > 0, client))
        {
            if (LockingCall.Invoke(() => Jobs.Peek() == null, client))
                Debugger.Launch();
 
            var job = LockingCall.Invoke(() => Jobs.Dequeue(), client);
            client.BeginCalculationAsync(job);
            return true;
        }
        else
            return false;
    }
 
    private void RemoveClient(ClientViewModel client)
    {
        if (client.IsCalculating)
            LockingCall.Invoke(() => Jobs.Enqueue(client.Job), JobCount);
 
        Dispatch(() => Clients.Remove(client));
    }
 
    private void Dispatch(Action action) => Application.Current.Dispatcher.Invoke(action);
 
    private void Dispatcher_UnhandledException(object sender, System.Windows.Threading.DispatcherUnhandledExceptionEventArgs e)
    {
        e.Handled = true;
        MessageBox.Show(e.Exception.Message, "Error!", MessageBoxButton.OK, MessageBoxImage.Error);
    }
}