ढेर ओवरफ्लो अपवाद- क्यों?

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

आप ग्राहक निर्माणकर्ता में अपनी नई ग्राहक वस्तु बनाने के लिए बुला रहे हैं।

Answer 2

आप अपने ग्राहक वर्ग के निर्माता के भीतर एक सूची को तत्काल कर रहे हैं। यह एक अनंत लूप का कारण बन जाएगा और परिणाम एक ढेर ओवरफ्लो में होगा।

मुझे लगता है कि आपको अपने कोड को कई कक्षाओं में अलग करने का प्रयास करना चाहिए।

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 3

ग्राहक कन्स्ट्रक्टर में आप ग्राहक कन्स्ट्रक्टर को फिर से कॉल करते हैं, अनंत रिकर्सन बनाते हैं।

आप ग्राहकों की एक सूची के लिए और एक ही ग्राहक के लिए एक अलग वर्ग होना चाहिए:

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 4

आपका निर्माता ही बुला रहा है (नई ग्राहकों()), जिसकी वजह से यह कभी नहीं लौटने के लिए।

अंगूठे का एक अच्छा नियम, यदि आपको सी # में स्टैक ओवरफ़्लो मिलता है, तो रिकर्सन की तलाश करें जो कभी समाप्त नहीं होती है।

Answer 5

ग्राहकों के लिए आपका कन्स्ट्रक्टर स्वयं को कॉल करता है, जिससे अंतहीन पाश होता है।

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

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

फ़ंक्शन में अंतहीन रिकर्सिव कॉल स्टैक ओवर फ़्लो का कारण बनेंगे।

Answer 6

स्टैक ओवरफ़्लो त्रुटियां आमतौर पर अंतहीन लूप से नहीं होती हैं, लेकिन अंतहीन पुनरावृत्ति से (अच्छी तरह से, अभ्यास में वास्तव में अंतहीन नहीं है, यह स्टैक पूर्ण होने तक स्वयं को कॉल करना जारी रखता है और फिर अपवाद फेंक दिया जाता है)।

यदि आपके पास एक विधि है जो रिकर्सन का उपयोग करती है (यानी यह स्वयं को कॉल करती है) तो आपको यह सुनिश्चित करना होगा कि यह केवल सीमित संख्या में होता है। यदि आप ऐसा नहीं करते हैं, तो आपको एक विधि मिलती है जो स्वयं को एक विधि कॉल के साथ कॉल करती है जो स्वयं को एक विधि कॉल के साथ कॉल करती है जो स्वयं को कॉल करने वाली विधि कॉल के साथ कॉल करती है (स्टैक पूर्ण होने तक इसे कई बार जारी रखें)। ... ग्राहकों को कॉल करना() ग्राहकों को कॉल करना() ग्राहकों को कॉल करना() ग्राहकों को कॉल करना() ग्राहकों को कॉल करना() ग्राहकों को कॉल करना() ग्राहकों को कॉल करना() ग्राहकों को कॉल करना() .....