Erreur de dépassement de pile en C#, mais comment le résoudre?

J'ai couru dans une très intéressante d'exécution d'un bug qui génère un voyou de débordement de pile.

J'ai défini une structure comme suit:

public enum EnumDataType { Raspberry, Orange, Pear, Apple };

public class DataRequest
{
    public long DataSize 
    { 
        get { return 0; } 
        set { DataSize = value; } 
    }

    public EnumDataType DataType  
    { 
        get { return EnumDataType.Apple; } 
        set { DataType = value; } 
    }
}

Les lignes suivantes fonctionnent parfaitement:

DataRequest request = new DataRequest();
request.DataSize = 60;

Cependant, quand je marche sur la ligne suivante dans le code, il génère un débordement de pile:

request.DataType = EnumDataType.Raspberry;

Bien sûr, je peux le résoudre en supprimant les valeurs par défaut, ou l'utilisation de l'auto get/set, mais j'en ai besoin pour être à la fois lisible et inscriptible, et de retourner une valeur par défaut - des idées?

Je m'attends à ce invoquant de ces organismes de normalisation pour provoquer un débordement de pile, quelle que soit la valeur que vous avez fournies. Vous pourriez peut-être offrir une courte mais complète du programme est de démontrer le premier "[le travail]ing parfaitement" ?
Je pense que tout le monde à un certain point l'a fait 🙂
J'ai toujours trouvé Stackoverflow erreurs pour être tout à fait amusant erreurs quand elles surviennent, depuis le peu de fois où je les ai vus, ils comportent généralement de deux ou plusieurs méthodes qui sont magnifiquement nommé inverses les uns des autres. Au lieu de contenir tout le code fonctionnel, ils font référence les uns aux autres, ce qui serait tellement merveilleux si cela a fonctionné, mais nope. L'avenir est encore à venir.

OriginalL'auteur Contango | 2010-10-27

c#stack-overflow

12

Comme d'autres l'ont dit, le dépassement de pile se produit parce que votre propriété setter est juste d'appeler lui-même. Il peut être plus simple à comprendre si vous pensez à elle comme à une méthode:
```
//This obviously recurses until it blows up
public void SetDataType(long value)
{
    SetDataType(value);
}
```
Si je comprends bien, vous essayez de créer normal propriétés, mais avec une valeur par défaut, à droite?

Dans ce cas, vous avez besoin de la sauvegarde des variables qui sont définies par les setters et les getters doit le retour de ces variables. C'est le variables qui devrait obtenir les valeurs par défaut:
```
private long dataSize = 0;
public long DataSize {
  get { return dataSize; }
  set { dataSize = value; }
}

private EnumDataType dataType = EnumDataType.Apple;
public EnumDataType DataType { 
  get { return dataType; }
  set { dataType = value; }
}
```
Alternativement, l'utilisation automatique des propriétés, mais de définir les paramètres par défaut de votre constructeur:
```
public long DataSize { get; set; }
public EnumDataType DataType { get; set; }

public DataRequest()
{
    DataSize = 0; //Not really required; default anyway
    DataType = EnumDataType.Apple;
}
```
Ardman battre vous Skeet... Fois-a-changin'
Merci - super réponse. Je comprends exactement ce qui se passe maintenant. Nous ne sommes pas traiter avec des propriétés, nous avons affaire à des méthodes, comme son objet. La raison de ma question initiale était de savoir comment définir les valeurs par défaut qui sont retournés, et votre réponse couvre ce. p.s. Apprécié votre discours à Londres au début de cette année - votre présentation était vraiment intéressant, et pas seulement à cause de la chaussette marionnettes 🙂

OriginalL'auteur Jon Skeet
19
```
public long DataSize { get { return 0; } set { DataSize = value; } } 
```
Vous êtes constamment à la définition de la valeur de DataSize. Vous avez besoin de créer une variable locale et de l'utiliser à la place. par exemple,
```
private long dataSize;

public long DataSize
{
    get { return this.dataSize; }
    set { this.dataSize = value; }
}
```
MODIFIER
J'ai écrit DataSize mais le même s'applique à DataType

+8 mais aucune explication des raisons pour lesquelles le dépassement de pile se produit?
-1: Ce sera encore toujours return 0 au lieu de juste faire 0 par défaut valeur. Certes, la question n'est pas claire, mais je ne pense pas que c'est ce que l'on entend.
Nicolas: C'est parce que le programme cherche à mettre en données. datasize avec données. datasize, qui à son tour veut c'est données. datasize avec données. datasize, qui permettra de définir une données. datasize avec données. datasize. Et puis il va le mettre de l'données. datasize avec données. datasize, après qu'il fixera la données. datasize avec données. datasize... Ouf, mindblowing; et je ne suis même pas à mi-chemin là!
Je sais pourquoi 😉 l'original le demandeur ne s'est pas 😉
Merci - super réponse. Je comprends exactement ce qui se passe maintenant. Nous ne sommes pas traiter avec des propriétés, nous avons affaire à des méthodes, comme son objet.

OriginalL'auteur Neil Knight
4

débordement de pile se produit parce que dans le setter vous êtes à la définition de la propriété à une valeur (c'est à dire que vous essayez de trouver quelque chose à régler lui-même à quelque chose ... ce qui provoque une boucle infinie) ... ce qui signifie qu'il essaie de définir lui-même une valeur qui signifie que sa tente de définir lui-même une valeur jusqu'à ce boom

vos propriétés ne seront jamais obtenir les valeurs de réglage parce qu'ils retournent toujours la même valeur (et non la valeur stockée)
```
public enum EnumDataType { Raspberry, Orange, Pear, Apple }; 

public class DataRequest 
{ 
private long _dataSize = 0;
private EnumDataType _dataType = EnumDataType.Apple;

public long DataSize { get { return _dataSize ; } set { _dataSixe= value; } } 
public EnumDataType DataType  { get { return _dataType; } set { _dataType= value; } } 
} 
```
est ce que tu voulais vraiment

OriginalL'auteur John Nicholas
3

vous avez à implemet avec un magasin de sauvegarde:
```
private EnumDataType dataType;
public EnumDataType DataType  { get { return EnumDataType.Apple; } set { dataType = value; } }
```
}

Vous devez le faire à tout moment vous de faire de l'acion dans les accesseurs et des mutateurs. Par ailleurs, pourquoi pouvez vous même définir les variables? vous ne pouvez pas les lire, vous obtenez toujours EnumDataType.Apple. Si vous voulez une valeur de départ, vous pouvez le faire comme ceci:
```
private EnumDataType dataType = EnumDataType.Apple;
public EnumDataType
{
   get
   {
       return dataType;
   }
   set
   {
       dataType = value;
   }
 }
```
Qui ne compile pas - EnumDataType est un non nullable type de valeur.

OriginalL'auteur Tokk

Je ne comprends pas comment la première ligne:
demande.Données. datasize = 60;

Ne pas provoquer un débordement de pile - mon conseil serait d'utiliser la sauvegarde de propriétés:

public class DataRequest
{
    protected int dataSize = 0;
    protected EnumDataType enumDataType;
    public long DataSize { get { return 0; } set { dataSize = value; } }
    public EnumDataType DataType  { get { return EnumDataType.Apple; } set { enumDataType = value;} 
}

OriginalL'auteur Dave Bish

Vous devez vous connecter pour publier un commentaire.