Question

我不断得到堆栈溢出异常。我已经把它缩小到这个类来试图弄清楚出了什么问题，但我根本不知道为什么我一直收到这个错误信息？最初我在另一个类中有用户界面，但只是为了消除其他一切，比如我的调用方法中的问题，我将基本要素移到这个类中，试图弄清楚出了什么问题。我以为这可能是我的财产？也许这对其他人来说很明显，但我根本不理解。

由于我对编程很陌生，所以我会对我做错了什么有所帮助。根据我的理解，当你有无限循环之类的东西时会出现这个问题吗？

namespace MyNameSpace
{
    public class Customers
    {
        private List<Customers> customers; 

        public Customers()
        {
            customers = new List<Customers>();

            AddCustomer(new Customers() 
            { 
            Name = "A", Telephone="1" 
            });
        }

        public string Name
        {
            get;
            set;
        }
        public string Telephone
        {
            get;
            set;
        }

        public void RunTest()
        {

            Console.WriteLine();
            Console.WriteLine("****** VIDEOSTORE ******");
            Console.WriteLine();
            Console.WriteLine("1. Show Customers");
            Console.WriteLine("6. Quit");

            string userChoice = Console.ReadLine();

            switch (userChoice)
            {
                case "1": 
                    View();
                    break;         

                    break;
                case "2":
                    break;
            }
        }

        public void View()
        {
            foreach (Customers c in customers)
            {
                Console.WriteLine();
                Console.WriteLine(c.Name);
                Console.WriteLine(c.Telephone);
                Console.WriteLine();
            }
        }

        public void AddCustomer(Customers custom)                           
        {
            customers.Add(custom);          
        }
    }
}

Answer 1

在Customers构造函数中，再次调用Customers构造函数，创建无限递归。

对于客户列表和单个客户，您应该有一个单独的类：

namespace MyNameSpace
{
    public class Customer
    {
        public string Name
        {
            get;
            set;
        }
        public string Telephone
        {
            get;
            set;
        }
    }

    public class Customers
    {
        private List<Customer> customers; 

        public Customers()
        {
            customers = new List<Customer>();

            AddCustomer(new Customer() 
            { 
            Name = "A", Telephone="1" 
            });
        }


        public void RunTest()
        {

            Console.WriteLine();
            Console.WriteLine("****** VIDEOSTORE ******");
            Console.WriteLine();
            Console.WriteLine("1. Show Customers");
            Console.WriteLine("6. Quit");

            string userChoice = Console.ReadLine();

            switch (userChoice)
            {
                case "1": 
                    View();
                    break;         

                    break;
                case "2":
                    break;
            }
        }

        public void View()
        {
            foreach (Customer c in customers)
            {
                Console.WriteLine();
                Console.WriteLine(c.Name);
                Console.WriteLine(c.Telephone);
                Console.WriteLine();
            }
        }

        public void AddCustomer(Customer customer)                           
        {
            customers.Add(customer);          
        }
    }
}

Answer 2

您正在调用您在Customers构造函数中创建一个新的Customers对象。

Answer 3

您的构造函数调用自身，导致无限循环。

public Customers()
{
    customers = new List<Customers>();

    AddCustomer(new Customers() // <- Here
    { 
    Name = "A", Telephone="1" 
    });
}

对函数的无休止递归调用将导致StackOverFlow。

Answer 4

您正在Customers类的构造函数中实例化List。这将导致无限循环并导致堆栈溢出。

我认为您应该尝试将代码分成多个类。

public class Customer
{
    public string Name { get; set; }
    public string Telephone { get; set; }
}

public class Program
{
    private List<Customer> _customers = new List<Customer();

    public Program()
    {
        _customers.Add(new Customer() 
        { 
            Name = "A", Telephone="1" 
        });
    }

    // your other methods here - like View()
}

Answer 5

你的构造函数正在调用它自己（new Customers（）），这会导致它永远不会返回。

一个好的经验法则，如果在C＃中出现堆栈溢出，请查找永不终止的递归。

Answer 6

堆栈溢出错误通常不是来自无限循环，而是来自无休止的递归（好吧，在实践中并不是真的无穷无尽，它会继续调用自己直到堆栈已满，然后抛出异常）。

如果你有一个使用递归的方法（即它自己调用），你必须确保这只发生有限次数。如果你不这样做，你会得到一个方法，它通过一个方法调用来调用自身，该方法调用通过一个调用自身的方法调用来调用自身（继续这么多次，直到堆栈已满）。 ...像Customers（）调用Customers（）调用Customers（）调用Customers（）调用Customers（）调用Customers（）调用Customers（）调用Customers（）.....

堆栈溢出异常 - 为什么？

6 个答案: