C# Quand utiliser "Ce" Mot-clé

Question

Possible en double:
When do you use the “this” keyword?

Bonjour, Je comprends que le mot-clé This est utilisé pour faire référence à une instance de la classe, mais , supposons que j'ai une classe appelée Life, qui définit deux champs, la personne (leur nom) et leur partenaire (leur nom) :

class Life 
{ 
    //Fields 
    private string _person; 
    private string _partner; 

    //Properties 
    public string Person 
    { 
     get { return _person; } 
     set { _person = value; } 
    } 

    public string Partner 
    { 
     get { return _partner; } 
     set { _partner = value; } 
    } 

    //Constructor 1 
    public Life() 
    { 
     _person = "Dave"; 
     _partner = "Sarah"; 

     MessageBox.Show("Life Constructor Called"); 
    } 

    //Constructor 2 
    public Life() 
    { 
     this._person = "Dave"; 
     this._partner = "Sarah"; 

     MessageBox.Show("Life Constructor Called"); 
    } 
} 

Existe-t-il une différence entre le constructeur 1 et le constructeur 2 !? Ou est-ce juste une meilleure pratique de codage pour utiliser le mot-clé "This"?

Observe

Answer 1

Les constructeurs sont les mêmes. La raison pour laquelle je préférerais la seconde est qu'elle vous permettra de supprimer les traits de soulignement de vos noms de variables privées et de conserver le contexte (amélioration de la compréhensibilité). Je m'entraîne à toujours utiliser this en référence aux variables d'instance et aux propriétés.

Je n'utilise plus le mot-clé this de cette manière après avoir déménagé dans une autre société avec des normes différentes. Je me suis habitué et maintenant je ne l'utilise plus du tout en référence aux membres de l'instance. Je recommande toujours d'utiliser des propriétés (évidemment).

Ma version de votre classe:

class Life 
{ 
    //Fields 
    private string person; 
    private string partner; 

    //Properties 
    public string Person 
    { 
     get { return this.person; } 
     set { this.person = value; } 
    } 

    public string Partner 
    { 
     get { return this.partner; } 
     set { this.partner = value; } 
    } 


    public Life() 
    { 
     this.person = "Dave"; 
     this.partner = "Sarah"; 

     MessageBox.Show("Life Constructor Called"); 
    } 
} 

ou, encore mieux, mais pas aussi clair sur l'utilisation des this avec des champs.

class Life 
{ 

    //Properties 
    public string Person { get; set; } 
    public string Partner { get; set; } 

    public Life() 
    { 
     this.Person = "Dave"; 
     this.Partner = "Sarah"; 

     MessageBox.Show("Life Constructor Called"); 
    } 
} 

Answer 2

Already discussed

When do you use the "this" keyword?

Answer 3

Vous pouvez l'utiliser pour la différence entre une variable locale nommée X et un champ de niveau de classe/propriété du même nom.

Answer 4

Il n'y a pas de différence dans les deux déclarations ...

//These are exactly the same. 

this._person 

//and 

_person 

La référence à « ce » est implicite dans le cas de _person. Je ne dirais pas que c'est forcément «meilleur» pratique de codage, je dirais que c'est juste une préférence.

Answer 5

Vous ne devriez pas utiliser les variables privées _person et _parter. C'est le but de vos getters et setters.

En ce qui concerne les constructions, il n'y a pas de réelle différence entre elles. Cela étant dit, je préfère toujours utiliser le mot-clé This comme il se prête à la lisibilité.

Answer 6

Étant donné que vous utilisez des traits de soulignement, il n'y a pas de conflit entre les noms; donc le "this." est redondant et peut être omis. L'IL ne sera pas affecté.Tant qu'il n'y a pas d'ambiguïté entre un champ et une variable/pararètre, il n'y a qu'un seul scénario dans lequel le mot clé this (dans le contexte de la signification de l'instance actuelle - pas ctor-chaining) est strictement nécessaire - invoquant un procédé d'extension qui est défini séparément:

this.SomeExtensionMethod(); // works 
SomeExtensionMethod(); // fails 

Answer 7

"this" est également utilisé dans Net 3.5 avec les méthodes d'extension:

public static class MyExtensions 
{  
    public static string Extend(this string text) 
    { 
     return text + " world"; 
    } 
} 

pourrait étendre la classe de chaînes

var text = "Hello"; 
text.Extend(); 

Pour répondre à votre question: non, il n'y a pas de différence entre vos deux constructeurs. Imo, le "ceci" encombre le code et ne doit être utilisé que lorsque cela est nécessaire, par ex. lorsque les paramètres et les variables de champ ont les mêmes noms.

Il existe également un cas où la classe implémente explicitement une interface. Si vous avez besoin d'appeler les méthodes d'interface de vous de votre classe doivent lancer ce à l'interface:

class Impl : IFace 
{ 

    public void DoStuff() 
    { 
     ((IFace)this).SomeMethod(); 
    } 

    void IFace.SomeMethod() 
    { 
    } 
} 

Answer 8

Les deux constructeurs font la même chose de toute façon dans le second le this est redondant