getter et setter pour la classe dans la classe c#

En supposant que nous avons une classe InnerClass avec les attributs et les getter/setter. Nous avons aussi une classe OuterClass contenant le InnerClass.

par exemple

class InnerClass
{
    private int m_a;
    private int m_b;

    public int M_A
    {
        get
        {
             return m_a;
        }
        set
        {
             m_a = value;
        }
     }
}

class OuterClass
{
    private InnerClass innerClass
}

Comment pourrais-je mettre en œuvre un bon getter et setter pour la innerClass membre de OuterClass?

Merci d'avance!

"ensemble" doit être {m_a = valeur;}
vous avez la rep pour corriger cela, vous le savez 😉

OriginalL'auteur | 2009-05-11

c#class getter member setter

26

La syntaxe ne serait pas différent. Juste...
```
public InnerClass InnerClass
{
    get { return innerClass; }
    set { innerClass = value; }
}
```
Par ailleurs, si vous êtes en utilisant le langage C# dans .NET 3.5, vous pouvez utiliser la fonction de génération automatique des biens si tout ce que vous avez est une propriété simple que juste de lit et écrit sur un support de sauvegarde (comme vous avez ci-dessus). Le sytax est similaire à celle d'un résumé de la propriété:
```
public InnerClass InnerClass { get; set; }
```
Cela génère automatiquement un membre privé pour le stockage, puis lit dans le get et écrit dans le set.

OriginalL'auteur Adam Robinson

La façon la plus élégante de le faire est d'utiliser implicite des getters et setters:

class InnerClass
{
  public int a{ get; set; }
  public int b{ get; set; }
}

class OuterClass
{
  public InnerClass innerClass{ get; set; }
}

C'est implicitement la même chose que:

class InnerClass
{
    private int _a;
    public int a
    {
        get
        {
            return _a;
        }
        set
        {
            _a = value;
        }
    }

    private int _b;
    public int b
    {
        get
        {
            return _b;
        }
        set
        {
            _b = value;
        }
    }
}

class OuterClass
{
    private InnerClass _innerClass;
    public InnerClass innerClass
    {
        get
        {
            return _innerClass;
        }
        set
        {
            _innerClass = value;
        }
    }
}

Ces deux définitions sont implicitement le même - moins quelques frappes. Dans le premier exemple, le compilateur va mettre en œuvre le nécessaire privé les champs, derrière les scènes de sorte que vous n'avez pas à. La seconde, cependant vous donne plus de contrôle sur ce qui se passe.

+1 pour implicite des getters et les setters
...Comment est-ce différent de ma réponse?
Aussi, il ne donne aucune indication de la version de C#/.NET qu'il utilise. Implicite les propriétés sont une partie de .NET 3.5/C# 3.0.
désolé, quand j'ai posté ma réponse, je n'ai pas vu le vôtre. Je suppose que vous avez posté comme je l'écrivais ma réponse.
salut @BenAlabaster, pourquoi ne pas déclarer class InnerClass { public int a; public int b; } Sans getters et setters? Conventions? (je suis nouveau sur csharp)

OriginalL'auteur BenAlabaster

public InnerClass InnerClass
    {
        get
        {
             return innerClass;
        }
        set
        {
             innerClass = value;
        }
     }

OriginalL'auteur edosoft

0

Il dépend de la façon dont l'intérieur de la classe devrait fonctionner. L'extérieur de la classe pourriez avoir besoin de "posséder" l'intérieur de la classe, auquel cas:
```
public InnerClass InnerClass{
  get{ return innerClass; }
  set{ innerClass.CopyFrom(value); /* Pseudo method call */ }
}
```
En le faisant de cette façon, vous prévenir à l'extérieur de code à partir de la manipulation de l'instance, sauf si explicitement par OuterClass..

Pas vraiment, puisque vous êtes de retour à l'instance dans les getter. La seule véritable façon de faire (et de cette approche est un peu puant...) serait d'utiliser la même CopyFrom méthode pour renvoyer une nouvelle instance de la lecture.
Je pense que vous avez mal compris. Le point est que vous pouvez modifier l'exemple, mais vous devez le faire de manière explicite par le biais de l'instance de OuterClass. Exemple OuterClass.InnerClass foo = new OuterClass.InnerClass(); foo.M_A = 1; outerInstance.InnerClass = foo; //outerInstance.InnerClass.M_A est égal à 1 foo.SomeProperty = 2; // outerInstance.InnerClass.M_A toujours égale à 1 outerInstance.InnerClass = foo; //outerInstance.InnerClass.M_A est égal à 2

OriginalL'auteur James
0

Si tu parles de l'accès interne aux membres de la classe sans s'exposer à l'intérieur de la classe elle-même, vous pouvez utiliser le code suivant. Si vous voulez juste pour exposer this.innerClass, il n'y a pas de différence à la façon dont vous exposer les champs de InnerClass.
```
class OuterClass
{
    private InnerClass innerClass

    public int M_A
    {
        get
        {
            if (this.innerClass != null)
            {
                 return this.innerClass.M_A;
            }
            else
            {
                throw new InvalidOperationException();
            }
        }
        set
        {
            if (this.innerClass != null)
            {
                 this.innerClass.M_A = value;
            }
            else
            {
                throw new InvalidOperationException();
            }
        }
    }
}
```
Je ne suis pas sûr de savoir comment cela s'applique à moins que j'ai raté une partie de la question...est-ce qu'il demandait?
Juste curieux - pourquoi voulez-vous lancer une opération non valide exception sur le getter? Je comprends pourquoi tu le ferais dans l'incubateur, mais ne serait pas normalement, vous assumez la lecture passive?
J'ai lu la question "[...] les méthodes getter et setter pour la innerClass membre de OuterClass?" avec un "s" supplémentaire "[...] innerClass membres de OuterClass?", mais regonized que seulement après la fin de ma réponse.
Que feriez-vous de retour si innerClass est nulle? Dans un scénario réel, il pourrait être une bonne valeur par défaut, mais je ne sais pas à partir de sa question. Et il n'est pas rare d'obtenir une exception à partir d'un getter.

OriginalL'auteur Daniel Brückner

Vous devez vous connecter pour publier un commentaire.