Modifikátory přístupu v C # - Typy modifikátorů přístupu v C #

• Úvod do modifikátorů přístupu v C #

Úvod do modifikátorů přístupu v C #

Tento článek se zabývá nejzákladnějším konceptem objektově orientovaného programování z pohledu programovacího jazyka C #. Koncept je známý jako - modifikátory přístupu. První otázka, na kterou je třeba odpovědět, je: Co jsou modifikátory přístupu? Jednoduše řečeno, modifikátory přístupu řídí, ke kterým objektům, proměnným / konstantám / metodám (prakticky vše) lze přistupovat, v které části kódu. Modifikátory přístupu hrají důležitou roli při ověřování koncepce abstrakce v objektově orientovaném programování. Řídí, jaká část programu by měla být a neměla by být viditelná pro konečného uživatele. Koncový uživatel se samozřejmě nejméně zajímá o konstanty a proměnné zapojené do algoritmu. Jde jen o to, jakou metodu musí vyvolat, aby získal výstup.

Typy modifikátorů přístupu v C #

C # nám poskytuje čtyři typy modifikátorů přístupu:

• Soukromé (výchozí modifikátor přístupu, kromě výčtů a rozhraní)
• Chráněno (mírně omezeno)
• Veřejné (neomezené, výchozí volba pro výčty a rozhraní)
• Interní (veřejnost ve stejném shromáždění)

Kromě těchto čtyř modifikátorů přístupu existují ještě dvě kombinace úrovně přístupu -

• Chráněné interní
• Soukromé chráněné

Rozumíme každému s příkladem.

1. Soukromé

Soukromý je nejoblíbenější úroveň přístupu. Je to také výchozí modifikátor přístupu pro všechny konstanty, proměnné, uživatelem definované objekty atd. Pouze výčty a rozhraní jsou ve výchozím nastavení veřejné. Pokud tedy nezadáte žádný modifikátor přístupu, C # mu přiřadí výchozí modifikátor.

Soukromé objekty nejsou přístupné mimo tělo třídy nebo struktury nebo programové sekce, ve které jsou deklarovány. Jakýkoli pokus o přístup k objektu mimo rozsah těla, ve kterém je deklarován, má za následek chybu kompilace.

Příklad č. 1

using System;
class Employee //private by default
(
string name; //private by default
public string GetName()
(
return name;
)
public void SetName(string name)
(
this.name = name;
)
)
public class Program
(
public static void Main()
(
Employee emp = new Employee();
emp.SetName("John");
Console.Write("Employee name is " + emp.GetName());
// compile time error - 'Employee.name' is inaccessible due to its protection level
// Console.Write("Employee name is " + emp.name);
)
)

Výstup 1:

Příklad č. 2

using System;
public class Program
(
public static void Main()
(
int x = 5; //private to the Main method, accessible inside nested code blocks in the Main method
if (true)
(
int y = 10; //private to the if block, not accessible outside if block
Console.WriteLine("x = " + x);
Console.WriteLine("y = " + y);
)
Console.WriteLine("x = " + x);
// compile-time error - The name 'y' does not exist in the current context.
// Console.WriteLine("y = " + y);
)
)

Výstup 2:

2. Chráněno

Specifikátor chráněného přístupu omezuje přístup k objektu pouze z odvozených instancí třídy. Pokud se tedy podřízený objekt třídy pokusí o přístup k chráněným objektům nadřazené třídy, je to povoleno. Nederivované třídy nemají přístup k chráněným členům žádné třídy. Chráněné objekty jsou samozřejmě přístupné metodám vlastní třídy.

Příklad

using System;
class Parent
(
protected string x;
public Parent()
(
x = "abc"; //accessible to own class methods
)
)
class Child : Parent // derived class
(
public static void Main()
(
var parentObj = new Parent();
var childObj = new Child();
Console.WriteLine(childObj.x); //accessible to derived class object instances
// compile-time error - Cannot access protected member 'Parent.x' via a qualifier of type 'Parent'; the qualifier must be of type 'Child' (or derived from it)
// Console.WriteLine(parentObj.x);
)
)

Výstup 3:

3. Veřejné

Toto je modifikátor přístupu s omezeným přístupem. Veřejné objekty jsou prakticky přístupné celému vnějšímu světu, což z něj činí nejvyšší přípustný modifikátor přístupu. To samozřejmě znamená vysoké náklady - náklady na minimální ochranu.

Veřejní členové mají přístup k libovolné části kódu. Díky tomu jsou nejméně bezpečné. Jakákoli logika kódu může změnit jejich hodnotu, což může vést k neočekávanému chování. Takže před zveřejněním jakéhokoli objektu musí být člověk velmi opatrný.

Ve stejné třídě Employee, kterou jsme vytvořili v našem příkladu modifikátoru soukromého přístupu, pokud změníme úroveň přístupu na veřejnost, nepotřebujeme žádné metody Getter a Setter. Ve skutečnosti je nejlepší postup učinit objekt soukromým a použít vlastnosti C # Getter a Setter.

Příklad

using System;
class Employee
(
public string name;
)
public class Program
(
public static void Main()
(
Employee emp = new Employee();
emp.name = "John";
Console.Write("Employee name is " + emp.name);
)
)

Výstup 4:

4. Interní

Interní objekty a metody jsou přístupné pouze ve stejné sestavě. Toto je velmi užitečný modifikátor přístupu, pokud chcete zveřejnit jakýkoli objekt a přesto chcete omezit jeho přístup pouze na rámec, který kódujete.

V podstatě jsou tedy všechny interní objekty přístupné ve všech oblastech stejné sestavy.

Vytvořme dvě konzolové aplikace, abychom tomu porozuměli.

Příklad

Krok 1: Vytvořte aplikaci konzoly C # a do ní vložte následující kód:

using System;
namespace ConsoleApp1
(
public class Parent
(
internal int x;
public Parent()
(
x = 10;
)
)
public class Program
(
public static void Main()
(
var parentObj = new Parent();
// accessible within the same assembly
Console.Write("The value of x = " + parentObj.x);
)
)
)

Krok 2: Vytvořte řešení a získejte soubor DLL ze složky bin.

Krok 3: Vytvořte další aplikaci konzoly a odkazujte na soubor sestavy z ConsoleApp1. Klikněte na Přidat odkaz na obrázku níže a vyhledejte umístění souboru .dll z kroku 2. Musí to být podobné ~ / ConsoleApp1 / bin / Debug / ConsoleApp1.dll.

Po přidání souboru DLL byste jej měli najít v části Sestavy.

Krok 4: Umístěte níže uvedený kód do ConsoleApp2.

using System;
using ConsoleApp1; //referencing the first assembly
namespace ConsoleApp2
(
class Program
(
static void Main(string() args)
(
var parentObj = new Parent();
//not accessible outside the assembly
Console.Write(parentObj.x);
)
)
)

Krok 5: Když vytvoříte ConsoleApp2, dostanete chybu kompilace, která ukazuje, že 'x' z ConsoleApp1 nelze získat přístup v jiných sestavách kvůli její úrovni ochrany.

5. Chráněné interní

Jedná se o kombinaci modifikátorů chráněného a interního přístupu. Důležitým pojmem, kterému je třeba rozumět, je, že chráněné interní znamená chráněné nebo interní. Je to spojení obou modifikátorů přístupu. Nikdy to nesmí být považováno za křižovatku.

Vnitřní objekty tedy nejsou přístupné mimo sestavu, zatímco chráněné objekty jsou přístupné jakékoli odvozené třídě v jakékoli sestavě. Co když chci chránit svůj objekt pouze v jiných sestavách, nikoli ve stejné sestavě? Jednoduché řešení - deklarujte to jako chráněné interní.

Příklad

Krok 1: Upravme náš ConsoleApp1 tak, aby odrážel níže uvedený kód. Všimněte si, že jsme změnili úroveň přístupu naší proměnné 'x' na chráněnou interní.

using System;
namespace ConsoleApp1
(
public class Parent
(
protected internal int x;
public Parent()
(
x = 10;
)
)
public class Program
(
public static void Main()
(
var parentObj = new Parent();
// accessible within the same assembly
Console.Write("The value of x = " + parentObj.x);
)
)
)

Krok 2: Vytvořte řešení znovu a nahraďte DLL v ConsoleApp2 aktualizovaným.

Krok 3: Aktualizujte kód v ConsoleApp2 takto:

using System;
using ConsoleApp1; //referencing the first assembly
namespace ConsoleApp2
(
class Program: Parent
(
static void Main(string() args)
(
var progObj = new Program();
//accessible only via an object of the derived class.
Console.Write(progObj.x);
Console.Read();
)
)
)

Krok 4: Spusťte ConsoleApp2 a podívejte se na výstup.

6. Soukromé chráněné

Toto je odborová kombinace modifikátorů soukromého i chráněného přístupu. Chráněné interní znamená Chráněné NEBO Interní. Soukromé objekty tedy nejsou přístupné mimo kódový blok, ve kterém jsou deklarovány, zatímco chráněné objekty jsou přístupné jakékoli odvozené třídě v jakékoli sestavě. Co když chci omezit přístup svého objektu i v odvozených třídách v jiných sestavách? Jednoduché řešení - deklarujte to jako chráněné interní.

Příklad

Upravme úroveň přístupu 'x' v ConsoleApp1 na Private Protected.

using System;
namespace ConsoleApp1
(
public class Parent
(
private protected int x;
public Parent()
(
x = 10;
)
)
public class Child: Parent (
public void DisplayX() (
// accessible only via derived class objects
Console.Write("Value of x = " + x);
)
)
public class Program
(
public static void Main()
(
var childObj = new Child();
childObj.DisplayX();
Console.Read();
)
)
)

Výstup:

Tabelární srovnání

Přístup ke specifikátoru	Stejné shromáždění			Jiné shromáždění
	Stejná třída	Odvozená třída	Nederivovaná třída	Odvozená třída	Nederivovaná třída
Soukromé	Ano	Ne	Ne	Ne	Ne
Veřejnost	Ano	Ano	Ano	Ano	Ano
Chráněný	Ano	Ano	Ne	Ano	Ne
Vnitřní	Ano	Ano	Ano	Ne	Ne
Chráněné interní	Ano	Ano	Ano	Ano	Ne
Soukromé chráněné	Ano	Ano	Ne	Ne	Ne

Závěr

Ve výše uvedeném článku jsme viděli, že modifikátory přístupu řídí přístup ke všemu v projektu. Různé kombinace úrovní přístupu pokrývají potřeby různých druhů přístupnosti. Vývojáři se musí rozhodnout moudře a mít na paměti bezpečnost a absolutní nutnost přístupu objektu v určitém bloku kódu.

Doporučené články

Toto je průvodce modifikátory přístupu v C #. Zde jsme diskutovali Úvodní typy modifikátorů přístupu v C # spolu s příklady a výstupy. Další informace naleznete také v dalších navrhovaných článcích -

1. C # Kompilátory
2. Destruktor v C #
3. Co je TypeScript?
4. Co jsou ASP.Net webové služby?
5. Přístup modifikátory v PHP
6. Pracovní a top 3 metody výčtu v C #