using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Threading;

using System.Diagnostics;

​

public class TraingulateModel

{

    public int PolygonId { get; set; }

    public List<Point3D> Points3D { get; set; }

    public TraingulateModel()

    {

        Points3D = new List<Point3D>();

    }

}

public class Point

{

    public decimal X { get; set; }

    public decimal Y { get; set; }

}

public class Point3D

{

    public decimal X { get; set; }

    public decimal Y { get; set; }

    public decimal Z { get; set; }

}

public class Polygon

{

    public int ID { get; set; }

    public List<Point> Points { get; set; }

    public List<Point3D> Points3D { get; set; }

}

public class Program

{

    private static List<Polygon> GetPolygons()

    {

        var polygons = new List<Polygon>();

        polygons.Add(new Polygon()

        {

            ID = 1,

            Points = new List<Point> { new Point() { X = 10, Y = 15 }, new Point() { X = 20, Y = 15 }, new Point() { X = 30, Y = 15 } },

        });

        polygons.Add(new Polygon()

        {

            ID = 2,

            Points = new List<Point> { new Point() { X = 10, Y = 15 }, new Point() { X = 20, Y = 15 }, new Point() { X = 30, Y = 15 } },

        });

        polygons.Add(new Polygon()

        {

            ID = 3,

            Points = new List<Point> { new Point() { X = 10, Y = 15 }, new Point() { X = 20, Y = 15 }, new Point() { X = 30, Y = 15 } },

        });

        return polygons;

    }

    private static void RunTriangulation(List<Polygon> polygons)

    {

        foreach (var polygon in polygons)

        {

            var triangulateModel = Triangulate(polygon);

            SavePolygonTraingulations(triangulateModel);

        }

    }

    private static async Task RunTriangulationAsyc(List<Polygon> polygons)

    {

        foreach (var polygon in polygons)

        {

            var triangulateModel = await Task.Run(() => Triangulate(polygon));

            SavePolygonTraingulations(triangulateModel);

        }

    }

    private static async Task RunTriangulationParallelAsyc(List<Polygon> polygons)

    {

        List<Task<TraingulateModel>> model = new List<Task<TraingulateModel>>();

        foreach (var polygon in polygons)

        {

            model.Add(Task.Run(() => Triangulate(polygon)));

        }

        var result = await Task.WhenAll(model);

        foreach (var item in result)

        {

            SavePolygonTraingulations(item);  

        }    

    }

    private static TraingulateModel Triangulate(Polygon polygon)

    {

        var triangulateModel = new TraingulateModel();

        Thread.Sleep(2000);

        triangulateModel.PolygonId = polygon.ID;

        return triangulateModel;

    }

    private static void SavePolygonTraingulations(TraingulateModel triangulateModel)

    {

        Console.WriteLine(" polygon {0} is saved", triangulateModel.PolygonId);

    }

    private static async void RunTask()

    {

        var watch = new Stopwatch();

        watch.Start();

​

        var polygons = GetPolygons();

        await RunTriangulationParallelAsyc(polygons);

​

        watch.Stop();

        Console.WriteLine("Total Time Taken = {0}",watch.ElapsedMilliseconds);

    }

    public static void Main()

    {

        RunTask();

​

        Console.WriteLine("Main Thread End");

        Console.ReadKey();

    }

}