Protégé en C#

Dans cet article, nous verrons comment protected en c# peut être implémenté en détail. À l'aide de modificateurs d'accès, nous pouvons restreindre le niveau d'accessibilité des paramètres et des classes. Il existe les modificateurs d'accès suivants en C#

• Public
• Privé
• Protégé
• Interne

Modificateurs protégés en C#

En C#, nous pouvons utiliser le modificateur protected pour spécifier que l'accès est limité au type conteneur. Nous pouvons également l'utiliser pour les types dérivés de la classe conteneur. Le mot protégé signifie qu'il peut être accessible ou visible par lui-même ainsi que par les classes dérivées.

À l'aide de ce membre ou de ce type, vous ne pouvez accéder qu'au code utilisé dans la même classe ou utilisé dans la classe dérivée. Le mot-clé protected se situe entre les modificateurs private et public. C'est presque la même chose qu'un modificateur privé mais il permet au membre d'accéder aux classes dérivées. Nous utilisons principalement le mot-clé protégé lorsque nous souhaitons donner accès aux propriétés des enfants à leurs parents. Nous pouvons donc réutiliser la logique à l'aide d'un mot-clé protégé.

Exemple :

using System;
class Test
{
protected int _x; private int _y;
}
class Test1 : Test
{
public Test1 ()
{
// In this we can  access the variable protected int but we cannot access private int variable
Console.WriteLine(this._x);
}
}
class Program
{
static void Main()
{ Test1 b = new Test1 (); }
}

Considérez 2 classes, Test et Test1. La classe Test1 est dérivée de Test. Si nous regardons à l’intérieur de la classe Test, nous pouvons voir que deux champs int ont été déclarés. 1 protégé et 1 privé.

Dans la classe B Test1, nous pouvons accéder à l'int protégé, mais nous ne pouvons pas accéder à l'int privé. Le modificateur protected nous donne donc un accès supplémentaire à la classe dérivée. Ainsi, à l'aide du mot-clé protected, nous pouvons accéder aux champs protégés comprenant toutes les classes dérivées.

Une classe peut également être protégée. Ci-dessous l'exemple de la façon de le déclarer

Syntaxe :

public class Test
{
protected class Child
{
}
}

Uniquement dans la classe imbriquée, nous pouvons déclarer la classe comme protégée. Nous ne pouvons pas le définir dans un espace de noms.

Exemples d'implémentation de Protected en C#

Vous trouverez ci-dessous les exemples montrant comment nous pouvons implémenter protected en C# :

Exemple n°1 – Sans implémenter la classe enfant

Code :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ProtectedExample
{
class demo
{
// String Variable declared as protected
protected string name;
public void print()
{
Console.WriteLine("\name is " + name);
}
}
class Program
{
static void Main(string[] args)     // main method
{
demo d = new demo();
Console.Write("Enter your name:\t");
d.name = Console.ReadLine();
d.print();
Console.ReadLine();
}
}
}

Dans l'exemple ci-dessus, la chaîne est déclarée comme protégée. Ce programme générera une erreur car protected cachera ses membres aux autres classes. Il ne sera donc accessible qu'en classe enfant.

Exemple n°2 – Implémentation avec héritage

Code :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ProtectedExample
{
class Demo
{
protected string name = "Protected Keyword";
protected void Display(string val)
{
Console.WriteLine("This is " + val);
}
}
class Program : Demo   // inheritance
{
static void Main(string[] args)
{
Program program = new Program();
// Accessing protected variable
Console.WriteLine("This is " + program.name);
// Accessing protected function
program.Display("protected example");
Console.ReadLine();
}
}
}

Dans l'exemple ci-dessus, la classe Parent est composée de membres protégés. Protected est utilisé pour déclarer la chaîne. Désormais, la classe enfant est dérivée d'une classe parent et le concept d'héritage est utilisé pour accéder aux membres protégés.

Sortie :

Exemple #3

Code :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ProtectedExample
{
class Parent
{
private String Private = "My name is John";    // string declared as private
protected String Protected = "My name is Dan"; //  string declared as protected
}
class Child : Parent // inheritance
{
public void Show()
{
Console.WriteLine(Protected);
}
}
class Program
{
static int Main(string[] args)  // main method
{
Child child = new Child();    // child object
child.Show();
Console.ReadKey();
return 0;
}
}
}

Dans l'exemple ci-dessus, la classe parent contient des chaînes privées et protégées. La classe enfant est dérivée de la classe parent. Show() ne peut cependant pas accéder au privé, mais il peut accéder au protégé. Un objet de classe enfant est utilisé pour appeler la méthode. Protégé est utilisé pour protéger les membres contre tout accès en dehors de la classe.

Sortie :

Nous pouvons également déclarer le constructeur comme protégé. Ainsi, en déclarant n'importe quel constructeur comme protégé, nous pouvons l'appeler depuis une sous-classe.

Syntaxe :

public class TEst : Test1
{
public Test() : base() // here we can Call the protected base constructor
{
}
}

Nous ne pouvons pas appeler une méthode protégée. Nous pouvons appeler le constructeur protégé à partir de la classe dérivée.

Modificateur d'accès interne protégé

Avec l'aide de protected internal, nous pouvons spécifier que l'accès est limité aux types actuels qui sont dérivés des classes conteneurs. Cela garantit donc que le membre et le type sont accessibles par le code dans la même classe ou par la classe dérivée qui est écrite dans un autre assembly.

Exemple :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ProtectedExample
{
class Demo
{
protected internal string name;    // variable is declared as protected internal
public void print()
{
Console.WriteLine("name is " + name);
}
}
class Program
{
static void Main(string[] args) // main method
{
Demo d = new Demo();
Console.Write("Enter your name:\t");
// Accepting value in protected internal variable
d.name = Console.ReadLine();
d.print();
Console.ReadLine();
}
}
}

Sortie :

Importance de Protégé en C#

Le mot-clé protégé est utile car ce type de variable est accessible par le code qui est utilisé dans la même classe. C'est utile lorsque nous voulons donner l'autorité à la classe enfant afin qu'elle puisse accéder aux membres de la classe parent. Donc, en ce sens, c’est important pour parvenir à la réutilisabilité du code.

Conclusion

Nous pouvons donc utiliser protected avec des variables et y accéder en utilisant le concept d'héritage. Il peut être utilisé là où les membres sont accessibles par la classe elle-même ou la sous-classe.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!