La surcharge de l'opérateur provoque un débordement de la pile

Question

J'ai commencé à programmer avec C# il y a quelques jours.

Maintenant, une erreur de confusion est apparue lors d'un jeu avec surcharge de l'opérateur.

Le code suivant produit un StackOverflowException lors de l'exécution:

using System; 

namespace OperatorOverloading 
{ 
    public class Operators 
    { 
     // Properties 
     public string text 
     { 
      get 
      { 
       return text; 
      } 

      set 
      { 
       if(value != null) 
        text = value; 
       else 
        text = ""; 
      } 
     } 

     // Constructors 
     public Operators() : this("") 
     { 
     } 

     public Operators(string text) 
     { 
      // Use "set" property. 
      this.text = text; 
     } 

     // Methods 
     public override string ToString() 
     { 
      return text; 
     } 

     // Operator Overloading 
     public static string operator +(Operators lhs, Operators rhs) 
     { 
      // Uses properties of the passed arguments. 
      return lhs.text + rhs.text; 
     } 

     public static void Main(string[] args) 
     { 
      Operators o1 = new Operators(); 
      Operators o2 = new Operators("a"); 
      Operators o3 = new Operators("b"); 

      Console.WriteLine("o1: " + o1); 
      Console.WriteLine("o2: " + o2); 
      Console.WriteLine("o3: " + o3); 

      Console.WriteLine(); 

      Console.WriteLine("o1 + o2: " + (o1 + o2)); 
      Console.WriteLine("o2 + o3: " + (o2 + o3)); 
     } 
    } 
} 

J'ai essayé d'écrire un propre exemple après avoir lu le chapitre sur operater surcharge du livre "Microsoft Visual C# 2008" de Dirk Louis et Shinja Strasser.

Peut-être que quelqu'un a une idée de ce qui ne va pas.

Merci.

Answer 1

Le get code-block dans votre classe a le problème et que est ce qui provoque l'exception StackOverFlow.

public string text 
    { 
     get 
     { 
      return text; 
     } 
    } 

Ici quand vous dites que return text; il ira et appeler le bloc get de la propriété text lui-même qui est à l'origine de la pile débordement. Enveloppez votre texte de propriété autour d'un champ de chaîne _txt privé et cela devrait fonctionner correctement.

Vous pouvez faire quelque chose comme ça ..

private string _txt; 
public string text 
{ 
    get 
    { 
     return _txt; 
    } 

    set 
    { 
     _txt = string.IsNullOrEmpty(value) ? string.Empty : value; 
    } 
} 

Answer 2

Eh bien, d'une part, la surcharge de l'opérateur ne brise pas votre code. Vous obtenez un StackOverflowException parce que votre getter de la propriété text essaie de se retourner.

Vous devez utiliser un champ de support pour votre propriété:

private string _text; 

public string Text 
{ 
    get { return _text; } 
    set 
    { 
     if (value != null) 
      _text = value; 
     else 
      _text = string.Empty; 
    } 
} 

Qu'est-ce que .NET ne sous les couvertures est de convertir votre propriété en un accesseur et un mutator - deux méthodes distinctes. Dans votre exemple original, votre code serait faire ce qui suit:

private string text; 

public string get_text() 
{ 
    return get_text(); // <-- StackOverflowException 
} 

public void set_text(string value) 
{ 
    this.text = value; 
} 

Alors que la version corrigée utilise le champ de support correctement:

private string text; 

public string get_text() 
{ 
    return this.text; // Happy :) 
} 

public void set_text(string value) 
{ 
    this.text = value; 
} 

Answer 3

Le problème est que le retour de proprty texte lui-même Vous devriez avoir un variab protégé ou privé le pour stocker le resut:

// Properties 
    private string _text 
    public string text 
    { 
     get 
     { 
      return _text; 
     } 

     set 
     { 
      if(value != null) 
       _text = value; 
      else 
       _text = ""; 
     } 
    }