Why is my C# class code in an infinite loop? What can I do to fix it?

Question

namespace Random_walk_2d
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Point C = new Point(2, 5);

            C.Move('n');
            Point.Print(C);
        }
    }

    public class Point
    {
        public int x;
        public int y;

        readonly public Dictionary<char, Point> directions = new Dictionary<char, Point>()
        {
            { 'e', new Point(1, 0) },
            { 'n', new Point(0, 1) },
            { 'w', new Point(-1, 0) },
            { 's', new Point(0, -1) },
        };

        public Point(int x, int y)
        {
            this.x = x;
            this.y = y;
        }

        public static Point operator +(Point A, Point B)
        {
            return new Point(A.x + B.x, A.y + B.y);
        }

        public static void Print(Point A)
        {
            Console.WriteLine($"({A.x}, {A.y})");
        }

        public void Move(char dir)
        {
            Point displacement = directions[dir];
            this.x += displacement.x;
            this.y += displacement.y;
        }

    }
}

I can see that the problem lies somewhere within the dictionary or the Move() method, but what I don't understand is what's actually going on under the hood? What's causing the infinite loop to occur?

And how can I solve the issue?

My friend suggested me to use arrays of 2 ints instead of Points in the dictionary, but... that kinda defeats the purpose of the whole class. Why use Points if I can just use 2 int arrays? I want a solution that doesn't do that.

If you have any other kind of advice, do let me know.

EDIT: I should've mentioned this right away, but when I run it, I get an infinite amount of at Random_walk_2d.Point..ctor(Int32, Int32) messages in the console.

EDIT2: I'm just experimenting with classes. For this project I wanted to create a random walk on a 2d grid. A 2d grid can be nicely modeled by a class with 2d point objects. I need the Move() method to move 1 unit to the right(east = 'e'), up(north = 'n') and so on.

Answer 1

the problem is stack overflow, this done here

public class Point {
    public int x;
    public int y;

    readonly public Dictionary<char, Point> directions = new Dictionary<char, Point>()
    {
        { 'e', new Point(1, 0) },
        { 'n', new Point(0, 1) },
        { 'w', new Point(-1, 0) },
        { 's', new Point(0, -1) },
    };

when you create a Point, that creates a 'directions' member, this in turn creates 4 new Points, each of those new Points creates its own 'directions' each one creates 4 Points .....

Its not clear what you are trying to do but this fixed it

public class Point {
    public int x;
    public int y;

    static readonly public Dictionary<char, Point> directions = new Dictionary<char, Point>()
    {
        { 'e', new Point(1, 0) },
        { 'n', new Point(0, 1) },
        { 'w', new Point(-1, 0) },
        { 's', new Point(0, -1) },
    };

By declaring 'directions' static there is only one for the whole Point class, maybe thats what you want

EDIT - yes this is what you want the 'directions' map is effectively a constant, so static works fine

Answer 2

You are recursively, indefinitely creating new objects of type Point, because upon creation of Point, you are creating a directions with 4 points, each of which have a dictionary with 4 more points, etc.

I'm unsure what exactly is that you're trying to achieve, because that's unclear from the question. so I can't help any further.

Answer 3

I recommend using static variables to hold your specific directions instead of a dictionary. I also recommend, not using classes but instead use a struct in order to ensure the data isn't changed my accident. A struct has value semantics, which means the pair of (x,y) go together always.

Instead of a dictionary, there is a function with a switch statement that returns the proper step. Then I am doing a trick and overwriting the this keyword in Move() to change the values of (x,y) in one go. If you already have the operator + defined, might as well use it.

static class Program
{
    static void Main(string[] args)
    {
        Point C = new Point(2, 5);
        C.Move('n');
        Console.WriteLine(C);
    }
}

public struct Point
{
    public readonly int x;
    public readonly int y;

    public Point(int x, int y)
    {
        this.x = x;
        this.y = y;
    }

    public static readonly Point North = new Point(0, 1);
    public static readonly Point South = new Point(0, -1);
    public static readonly Point East = new Point(1, 0);
    public static readonly Point West = new Point(-1, 0);

    public Point GetDirection(char dir)
    {
        switch (dir)
        {
            case 'n': return North;
            case 'e': return East;
            case 's': return South;
            case 'w': return West;
            default:
                throw new ArgumentException("Invalid Direction.", nameof(dir));
        }
    }

    public static Point operator +(Point a, Point b) => new Point(a.x + b.x, a.y + b.y);

    public void Move(char dir)
    {
        Point delta = GetDirection(dir);
        this += delta;
    }
    public override string ToString()
    {
        return $"( {x}, {y} )";
    }
}