Оптимизация производительности C#.NET (Алгоритм, Многопоточность, Debug, Release, .Net Core, Net Native) - C# - Ответ 10272255

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading.Tasks;
using System.Runtime.CompilerServices;
 
namespace NET_Core_netcoreapp
{
    //поиск переменных для решения уравнения x^3 + y^3 = z^3 - 1
    class Program
    {
        static TaskCompletionSource<object> source = new TaskCompletionSource<object>();
        static TaskScheduler scheduler = new CustomTaskScheduler();
 
        static long n;
        static long an;
        static long lim;
        static long[] a;
        static int threadsN = Environment.ProcessorCount; //задать количество потоков
        static List<Test> listTest = new List<Test>(100);
 
        static void Main(string[] args)
        {
                Console.WriteLine("Enter the maximum limit for variables, followed by <Enter>:\n");
                n = Convert.ToInt64(Console.ReadLine());
            
            for (int j = 0; j < 10; j++)
            {
                Stopwatch sw = Stopwatch.StartNew();
                an = n * n * n;
                a = new long[n + 1];
                lim = (long)Math.Round(Math.Pow((an - 1) / 2, 1d / 3d));
 
                for (long i = 1; i <= n; i++)
                    a[i] = i * i * i;
 
                var task = new Task[threadsN];
                for (int i = 2; i - 2 < threadsN; i++)
                {
                    int k = i;
                    task[k - 2] = Func(k);
                }
 
                Task.WaitAll(task);
                sw.Stop();
                Console.WriteLine((j + 1) + " " + sw.Elapsed.TotalSeconds);
            }
            Console.Write("\nPress any key to continue... ");
            Console.ReadKey();
        }
 
        static async Task Func(long start)
        => await Task.Run(() =>
        {
            long m = n;
            unsafe
            {
                fixed (long* a = Program.a)
                {
                    for (long x = start; x <= lim; x = x + threadsN)
                    {
                        long ax = a[x];
                        long r = an - ax - 1;
                        while (a[m] > r) m--;
                        long z = (long)(x * 1.2599);
 
                        for (long y = x; y <= m; y++)
                        {
                            long z3 = ax + a[y] + 1;
 
                            for (long az = a[z]; az <= z3; z++, az = a[z])
                            {
                                if (az == z3)
                                {
                                    //Console.WriteLine(x + "   " + y + "   " + z);
                                    Test test = new Test { Prop1 = x, Prop2 = y, Prop3 = z };
                                    listTest.Add(test);
                                }
                            }
                        }
                    }
                }
            }
        }).ConfigureScheduler(scheduler);
    }
 
    class Test
    {
        public double Prop1 { get; set; }
        public long Prop2 { get; set; }
        public long Prop3 { get; set; }
    }
 
    public struct CustomTaskAwaitable
    {
        CustomTaskAwaiter awaitable;
 
        public CustomTaskAwaitable(Task task, TaskScheduler scheduler)
        {
            awaitable = new CustomTaskAwaiter(task, scheduler);
        }
 
        public CustomTaskAwaiter GetAwaiter() { return awaitable; }
 
        public struct CustomTaskAwaiter : INotifyCompletion
        {
            Task task;
            TaskScheduler scheduler;
 
            public CustomTaskAwaiter(Task task, TaskScheduler scheduler)
            {
                this.task = task;
                this.scheduler = scheduler;
            }
 
            public void OnCompleted(Action continuation)
            {
                task.ContinueWith(x => continuation(), scheduler);
            }
 
            public bool IsCompleted { get { return task.IsCompleted; } }
            public void GetResult() { }
        }
    }
 
    public static class TaskExtension
    {
        public static CustomTaskAwaitable ConfigureScheduler(this Task task, TaskScheduler scheduler)
        {
            return new CustomTaskAwaitable(task, scheduler);
        }
    }
 
    public class CustomTaskScheduler : TaskScheduler
    {
        protected override IEnumerable<Task> GetScheduledTasks() { yield break; }
        protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued) { return false; }
        protected override void QueueTask(Task task)
        {
            TryExecuteTask(task);
        }
    }
}