Multi-threading with TPL - Access Internal Class Properties I am using the TPL library to parallelize a 2D grid operation. I have extracted a simple example from my actual code to illustrate what I am doing. I am getting the desired results I want and my computation times are sped up by the number of processors on my laptop (12).

I would love to get some advice or opinions on my code as far as how my properties are declared. Again, it works as expected, but wonder if the design could be better. Thank you in advance.

My simplified code:

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Gridding
{


    public abstract class Base
    {
        /// &lt;summary&gt;
        /// Values representing the mesh values where each node in the gridis assigned som value. 
        /// &lt;/summary&gt;
        public float[,] Values { get; set; }
        public abstract void Compute();
    }


    public class Derived : Base
    {

        /// &lt;summary&gt;
        /// Make the mesh readonly.  Is this necessary?
        /// &lt;/summary&gt;
        readonly Mesh MyMesh;

        Derived(Mesh mesh)
        {
            MyMesh = mesh;
        }


        public override void Compute()
        {
            Values = new float[MyMesh.NX, MyMesh.NY];

            double[] xn = MyMesh.GetXNodes();
            double[] yn = MyMesh.GetYNodes();

            /// Paralellize the threads along the columns of the grid using the Task Paralllel Library (TPL).
            Parallel.For(0, MyMesh.NX, i =&gt;
            {
                Run(i, xn, yn);
            });
        }


        private void Run(int i, double[] xn, double[] yn)
        {
            /// Some long operation that parallelizes along the columns of a mesh/grid
            double x = xn[i];
            for (int j = 0; j &lt; MyMesh.NY; j++)
            {

                /// Again, longer operation here
                double y = yn[j];

                double someValue = Math.Sqrt(x * y); 
                Values[i, j] = (float)someValue;
            }
        }


        static void Main(string[] args)
        {
            int nx = 100;
            int ny = 120;
            double x0 = 0.0;
            double y0 = 0.0;
            double width = 100;
            double height = 120;

            Mesh mesh = new Mesh(nx, ny, x0, y0, width, height);

            Base tplTest = new Derived(mesh);
            tplTest.Compute();

            float[,] values = tplTest.Values;

            Console.Read();


        }

        /// &lt;summary&gt;
        /// A simple North-South oriented grid.
        /// &lt;/summary&gt;
        class Mesh
        {
            public int NX { get; } = 100;
            public int NY { get; set; } = 150;
            public double XOrigin { get; set; } = 0.0;
            public double YOrigin { get; set; } = 0.0;
            public double Width { get; set; } = 100.0;
            public double Height { get; set; } = 150.0;
            public double DX { get; }
            public double DY { get; }

            public Mesh(int nx, int ny, double xOrigin, double yOrigin, double width, double height)
            {
                NX = nx;
                NY = ny;
                XOrigin = xOrigin;
                YOrigin = yOrigin;
                Width = width;
                Height = height;
                DX = Width / (NX - 1);
                DY = Height / (NY - 1);
            }

            public double[] GetYNodes()
            {
                double[] yNodeLocs = new double[NY];
                for (int i = 0; i &lt; NY; i++)
                {
                    yNodeLocs[i] = YOrigin + i * DY;
                }
                return yNodeLocs;
            }

            public double[] GetXNodes()
            {
                double[] xNodeLocs = new double[NX];
                for (int i = 0; i &lt; NX; i++)
                {
                    xNodeLocs[i] = XOrigin + i * DX;
                }
                return xNodeLocs;
            }
        }
    }
}
Values of the Base class should have protected set;.

In Mesh there is inconsistency with properties. Most are not readonly while some are.

Depending of whether or not those properties should be readonly you may remove Values initialization as well as xn and yn computation from Compute.

Furthermore, regardless of previous points, depending on whether or not Compute is called a lot in your application you might want to have a run context with array as a field so that a closure is not created.
And then you can even turn lambda in Parallel.For into a method pointer to a private method.
What this will allow you to do is allocate memory for 2 less object in Compute, which again based on frequency of usage can give you a performance boost.

Why? Firstly, allocation of memory is a slow operation. Secondly, garbage collection freezes all threads while is works. So less objects to collect - better.