Calculating distance with Euclidean, Manhattan, and Chebyshev in C#
Let's start with some housekeeping. You're not using these using so they should be removed:

using System.Collections.Generic;
using System.Linq;
using System.Text;




Your namespace is far too generic - it's much better than ConsoleApplication1 but you should use something like &lt;Company&gt;.&lt;Product&gt;.&lt;Feature&gt; in your real app.



Your method names should be verb phrases ManhattanDistance should be CalculateManhattanDistance (and likewise for the others).



Why does your ChebyshevDistance take different parameters to the others? That seems unfriendly in the API design.



You should add documentation comments rather than simple comments to explain what a method does.

e.g. 

/// &lt;summary&gt;
/// Calculates the Manhattan distance between the two points.
/// &lt;/summary&gt;
/// &lt;param name="x1"&gt;The first x coordinate.&lt;/param&gt;
/// &lt;param name="x2"&gt;The second x coordinate.&lt;/param&gt;
/// &lt;param name="y1"&gt;The first y coordinate.&lt;/param&gt;
/// &lt;param name="y2"&gt;The second y coordinate.&lt;/param&gt;
/// &lt;returns&gt;The Manhattan distance between (x1, y1) and (x2, y2)&lt;/returns&gt;
public static int CalculateManhattanDistance(int x1, int x2, int y1, int y2)
{
    return Math.Abs(x1 - x2) + Math.Abs(y1 - y2);
}


I'd also consider swapping the order of the parameters so you specify x1, y1, x2, y2 or using Point and PointF instead.



Now that's out of the way... ManhattanDistance looks correct.



EuclideanDistance is missing the final square root. The article you've linked to explains why that's bad:


  I’ve seen several A* web pages recommend that you avoid the expensive square root in the Euclidean distance by just using distance-squared
  [snipped pseudocode]
  Do not do this! This definitely runs into the scale problem. The scale of g and h need to match, because you’re adding them together to form f. When A* computes f(n) = g(n) + h(n), the square of distance will be much higher than the cost g and you will end up with an overestimating heuristic. For longer distances, this will approach the extreme of g(n) not contributing to f(n), and A* will degrade into Greedy Best-First-Search.




According to the Chebyshev distance Wikipedia article, in the Cartesian plane it's simply:

max(|x2 - x1|, |y2 - y1|)


Making it:

public static int CalculateChebyshevDistance(int x1, int x2, int y1, int y2)
{
    return Math.Max(Math.Abs(x2 - x1), Math.Abs(y2 - y1));
}


Although, following the article you linked your result should be:

public static int CalculateChebyshevDistance(int x1, int x2, int y1, int y2)
{
    var dx = Math.Abs(x2 - x1);
    var dy = Math.Abs(y2 - y1);
    return (dx + dy) - Math.Min(dx, dy);
}


I can't see how to prove that they're equivalent... If anyone can, I'd be interested to see it!

They are obviously equivalent... If you add the dx and dy together and then subtract the smaller of the two you are obviously left with just the bigger value i.e. the max of dx and dy.