LeetCode: Sort The Matrix Diagonally C#
Few tips

For code quality, consider to give variables/fields more understandeable names.
For immutable Cell fields add readonly, it may affect the performance.
If you know how many items will be put in the collection, construct it with capacity new List&lt;Cell&gt;(count), capacity means initial size for the underlying storage not max items limit.
FirstOrDefault == null can be replaced with !Any.
You may add items directly to listValues i guess, and optimize out tempList or vice-versa. Then Sort by field with Linq, or custom comparer, or implement IComparable for Cell.
Cell can be struct? If yes, you can try to take an advantage of stack allocations (for small amount of data) instead of heap using Span&lt;T&gt;-related optimizations.

For 5th tip, this code (as far as I got the idea)
var listValues = new List&lt;int&gt;();
foreach (var item in tempList)
{
    listValues.Add(item.v);
}
listValues.Sort();
for (int i = 0; i &lt; tempList.Count; i++)
{
    mat[tempList[i].r][tempList[i].c] = listValues[i];
}

Can be optimized as
int i = 0;
foreach (var item in tempList.OrderBy(x =&gt; x.v))
{
    mat[tempList[i].r][tempList[i].c] = item.v;
    i++;
}

Btw, I've tested various optimizations from listed above and more but got only insignificant performance boost. The slowest point is here FirstOrDefault(x =&gt; x.r == newR &amp;&amp; x.c == newC). I have no idea how to improve it without moving the solution to different approach.
Ok, let's do it.
public int[][] DiagonalSort(int[][] mat)
{
    int width = mat[0].Length;
    int height = mat.Length;
    List&lt;int&gt; values = new List&lt;int&gt;(height);
    for (int j = 2 - height; j &lt; width - 1; j++)
    {
        for (int i = 0; i &lt; height; i++)
        {
            int offset = j + i;
            if (offset &gt;= 0 &amp;&amp; offset &lt; width)
                values.Add(mat[i][offset]);
        }
        values.Sort();
        for (int i = 0, count = 0; i &lt; height; i++)
        {
            int offset = j + i;
            if (offset &gt;= 0 &amp;&amp; offset &lt; width)
                mat[i][offset] = values[count++];
        }
        values.Clear();
    }
    return mat;
}

~15% faster than initial solution.