Implementing A* with Heap tree

In A* implementations, this method is commonly completely unneeded, as you maintain an "open list", which is the minheap (note minheap vs maxheap here). Instead of finding out if a node is contained in the frontier, you maintain a list called something like "costSoFar", which maintains a list of the smallest cost for any one node, and check for the node in this. Note that this could be handled inside of the node itself, in your case by adding a bool OnOpenList { get; set; }, a bool OnClosedList { get; set; }, as well as a float (or int) costSoFar { get; set; }. This would allow you to check if the node is contained in the minheap without actually checking. A sample loop would be as follows: (I use Vector2's to store positions here, but you could very well use two integers or floats.)

private static Foo FindPathReversed(Vector2 start, Vector2 end)
{
    var world = GetWorld();

    MinHeap<Foo> openList = new MinHeap<Foo>(); // The frontier
    Foo[,] nodeWorld = new Foo[(int)world.size.x, (int)world.size.y];
    Foo node;
    Vector2 temp;
    int cost;
    int diff;

    Foo current = new Foo(startPosition);
    current.cost = 0;

    Foo finish = new Foo(end);
    nodeWorld[(int)current.position.x, (int)current.position.y] = current;
    openList.Insert(current);

    while (openList.Count > 0)
    {
        //Find best item and switch it to the 'closedList'
        current = openList.RemoveRoot();
        current.onClosedList = true;

        //Find neighbours
        for (int i = 0; i < surrounding.Length; i++)
        {
            temp = new Vector2(current.position.x + surrounding[i].x, current.position.y + surrounding[i].y);
            if (world.TileIsPassable((int)temp.x, (int)temp.y)) // You must define this method
            {
                //Check if we've already examined a neighbour, if not create a new node for it.
                if (nodeWorld[(int)temp.x, (int)temp.y] == null)
                {
                    node = new Foo(temp);
                    nodeWorld[(int)temp.x, (int)temp.y] = node;
                }
                else
                {
                    node = brWorld[(int)temp.x, (int)temp.y];
                }

                //If the node is not on the 'closedList' check it's new score, keep the best
                if (!node.onClosedList)
                {
                    diff = 0;
                    if (current.position.x != node.position.x)
                    {
                        diff += 1;
                    }
                    if (current.position.y != node.position.y)
                    {
                        diff += 1;
                    }

                    // These functions are not part of the standard library but probably have equivalents.
                    int distance = (int)Mathf.Pow(Mathf.Max(Mathf.Abs(end.x - node.position.x), Mathf.Abs(end.y - node.position.y)), 2);
                    //int distance1 = (int)Mathf.Pow(Vector2.Distance(new Vector2(node.position.x, node.position.y), new Vector2(end.x, end.y)), 2);
                    cost = current.cost + diff + distance;
                    //cost = current.cost + diff + (int)Mathf.Pow(Vector2.Distance(node.position, end), 2);


                    if (cost < node.cost)
                    {
                        node.cost = cost;
                        node.next = current;
                    }

                    //If the node wasn't on the openList yet, Insert it 
                    if (!node.onOpenList)
                    {
                        //Check to see if we're done
                        if (node.Equals(finish))
                        {
                            node.next = current;
                            return node;
                        }
                        node.onOpenList = true;
                        openList.Insert(node);
                    }
                }
            }
        }
    }
    return null; //no path found
}

Note that this code should be taken at face value: as a sample. I have written this code from memory, so it may very well be not completely accurate. I also have more infrastructure surrounding this; if you have some basic implementation or structure questions don't be scared to leave a comment.