C＃-对象变量分配失败

Question

I'm having some trouble understanding why my variable has a null value.

Here's my class constructor:

private GraphNode current;
private GraphNode goal;
private GraphNode start;

private List<GraphNode> path;
private List<GraphNode> origin;

public Graph()
{
    current = new GraphNode(0, 0);
    goal = new GraphNode(0, 0);
    start = new GraphNode(0, 0);
    path = new List<GraphNode>();
    origin = new List<GraphNode>();
}

Defenition of method SetPathing:

public void SetPathing(int mouseX, int mouseY)
{
    if (Contains((int)mouseX / 32, (int)mouseY / 32))
    {
        goal = GetNode((int)mouseX / 32, (int)mouseY / 32);
        current = goal;
        path.Add(current);

        while ((current.X != start.X) && (current.X != start.X))
        {
            current = origin.Where(keyValuePair => (keyValuePair.Key.X == current.X) && (keyValuePair.Key.X == current.Y)).Select(keyValuePair => keyValuePair.Value).LastOrDefault();
            path.Add(current);
        }
    }
}

When I break on the start of the while-loop in SetPathing I see the following info in the locals screen:

current     null                    PathFinding.GraphNode
goal        {PathFinding.GraphNode} PathFinding.GraphNode
        X   0   int
        x   0   int
        Y   5   int
        y   5   int

How is that possible after having clearly assigned the reference value of goal to current ?

I'm probably missing something stupid here, but I haven't found it after looking for two hours. No asynchronous going on here.

EDIT : Didn't want to be overtly verbose with my initial question, here's some extra details, my apologies. Here are the details of Contains, GetNode and GetNodeIndex. Nothing fancy, I'm an amateur.

    public int GetNodeIndex(int x, int y)
    {
        // Find the node index in the list based on x and y
        // Return -1 if not found
        return nodes.FindIndex(n => (n.X == x) && (n.Y == y));
    }

    public GraphNode GetNode(int x, int y)
    {
        // Find the node in the list based on x and y
        // Return null if not in list
        int nodeIndex = GetNodeIndex(x, y);
        if (nodeIndex != -1)
        {
            return nodes[nodeIndex];
        }
        return null;
    }

    public bool Contains(int x, int y)
    {
        // Check if the returned value is not -1
        if (GetNodeIndex(x, y) != -1)
        {
            return true;
        }
    }

The usecase is litterally just along the lines of the following:

using System;

namespace Graphs
{
    class Program 
    {
        static void Main() 
        {
            Graph graph = new Graph(20, 20);
            graph.SetPathing(Mouse.GetState().X, Mouse.GetState().Y);
        }
    }
}

Answer 1

Let's dissect your code here.

goal = GetNode((int)mouseX / 32, (int)mouseY / 32);

Here, you've set the variable goal to point to a GraphNode object. So, for the sake of simplicity, we'll call it A. At this point your values look like this:

goal -> A
current -> null

Next, you do this:

current = goal;

And now, your values look like this:

goal -> A
current -> A

Later during your while loop, you call this:

current = origin.Where(keyValuePair => (keyValuePair.Key.X == current.X) && (keyValuePair.Key.X == current.Y)).Select(keyValuePair => keyValuePair.Value).LastOrDefault();

For the sake of simplicity, we'll call the result of this where clause B. So, now your values look like this:

goal -> A
current -> B

All that you have done here is change current to point to a new value.

Answer 2

You showed the code for the default Graph constructor,

public Graph()

not the one being used.

Graph graph = new Graph(20, 20);

Is there any difference between them?

Also, are you sure your code is in sync with the assembly? ie from your description it seems your break point is on this line

while ((current.X != start.X) && (current.X != start.X))

Are you sure when you were debugging, it was indeed executing only upto here when the debugger stopped, or it could have already executed the filtering code two lines down?

Answer 3

I'm not sure how this is possible, but the answer appears to be that this is in fact not the first iteration of the While-loop.

I had my break point set to the loop, and the results I posted above were from the first hit of that break point. However, after adding a variable that acted as an iteration counter it turned out this was in fact NOT the first iteration, but the third one. Following this discovery I went on to improve the code in the while loop to prevent current being set to null.

I'm not sure how this could happen. I'm using Visual Studio 2013 Express for Desktop. Never encountered anything like this before.