Hozzáférés-módosítók a C # - -ben A hozzáférés-módosítók típusai a C # -ben

• Bevezetés a hozzáférés-módosítókba a C # -ben

Bevezetés a hozzáférés-módosítókba a C # -ben

Ez a cikk tárgya az objektum-orientált programozás legalapvetőbb fogalma a C # programozási nyelv szempontjából. A koncepció úgynevezett - Hozzáférés-módosítók. Az első kérdés, amelyet meg kell válaszolni: - Mik az hozzáférés-módosítók? Egyszerűen fogalmazva: a hozzáférés-módosítók ellenőrzik, hogy melyik objektumhoz / változóhoz / állandóhoz / módszerhez (gyakorlatilag mindent) lehet elérni a kód melyik részében. Az hozzáférés-módosítók fontos szerepet játszanak az absztrakció koncepciójának igazolásában az objektum-orientált programozásban. Ellenőrzik, hogy a program mely részének kell lennie, és a végfelhasználó számára nem szabad látniuk. Természetesen a végfelhasználót leginkább az algoritmusban részt vevő állandók és változók aggasztják. Csak attól tart, hogy milyen módszerrel kell eljárnia, hogy megkapja a kimenetet.

A hozzáférés-módosítók típusai a C # -ben

A C # négyféle hozzáférés-módosítót kínál nekünk:

• Privát (az alapértelmezett hozzáférés-módosító, kivéve az enumokat és az interfészeket)
• Védett (kissé korlátozott)
• Nyilvános (korlátlan, az alapok és az interfészek alapértelmezett választása)
• Belső (nyilvános ugyanabban az együttesben)

Ezen a négy hozzáférési módosítón kívül van még két hozzáférési szint kombináció -

• Védett belső
• Magánvédett

Megértjük mindegyiket egy példával.

1. Magán

A Privát a legkorlátozottabb hozzáférési szint. Ez az alapértelmezett hozzáférés-módosító minden állandóra, változóra, felhasználó által definiált objektumra stb. Alapértelmezés szerint csak az összegek és az interfészek nyilvánosak. Tehát, ha nem ad meg semmilyen hozzáférési módosítót, a C # hozzárendelte az alapértelmezett módosítót.

A magánobjektumok nem érhetők el az osztály, szerkezet vagy programszakasz azon testén kívül, amelyben deklarálták őket. Bármely kísérlet az objektumhoz való hozzáféréshez azon test hatókörén kívül, amelyben azt deklarálják, fordítási idő hibát eredményez.

1. példa

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);
)
)

1. kimenet:

2. példa

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);
)
)

2. kimenet:

2. Védett

A Védett hozzáférés-specifikátor korlátozza az objektum hozzáférését csak az osztály származtatott példányaiból. Tehát, ha egy gyermek osztályú objektum megpróbál hozzáférni egy szülő osztály védett objektumaihoz, akkor megengedett. A nem származtatott osztályok nem férhetnek hozzá egyetlen osztály védett tagjaihoz sem. A védett tárgyak természetesen hozzáférhetők a saját osztály módszereihez.

Példa

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);
)
)

3. output:

3. Nyilvános

Ez a legkevésbé korlátozott hozzáférés-módosító. A nyilvános tárgyak gyakorlatilag az egész külvilág számára hozzáférhetők, ezáltal a legmagasabb megengedhető hozzáférés-módosító. Természetesen ez drága költségekkel jár - a legkevesebb védelem költségeivel.

A nyilvánosság tagjai a kód bármely részével elérhetők. Ez teszi őket legkevésbé biztonságossá. Bármely kódlogika módosíthatja értékét, ami váratlan viselkedéshez vezethet. Tehát nagyon óvatosnak kell lennie, mielőtt bármilyen tárgyat nyilvánosságra hoz.

Ugyanebben a Munkavállalói osztályban, amelyet a magánhozzáférés-módosító példában készítettünk, ha a hozzáférési szintet a nyilvánosság számára megváltoztatjuk, akkor nincs szükségünk Getter és Setter módszerekre. Valójában a legjobb gyakorlat az objektum privátvá tétele, valamint a C # Getter és Setter tulajdonságok használata.

Példa

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);
)
)

4. kimenet:

4. Belső

A belső objektumok és módszerek csak ugyanabban az összeállításban érhetők el. Ez egy nagyon hasznos hozzáférés-módosító, ha bármilyen objektumot nyilvánosságra kíván hozni, és mégis csak annak a keretnek a korlátozására kívánja korlátozni, amelyet kódol.

Tehát lényegében az összes belső tárgy hozzáférhető ugyanazon szerelvény összes területén.

Hozzunk létre két konzol alkalmazást a működés megértéséhez.

Példa

1. lépés: Hozzon létre egy C # konzol alkalmazást, és helyezze bele az alábbi kódot:

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);
)
)
)

2. lépés: Készítse el a megoldást, hogy a .dll fájlt a bin mappából kapja meg.

3. lépés: Hozzon létre egy másik konzolalkalmazást, és hivatkozzon az összeszerelési fájlra a ConsoleApp1 fájlból. Kattintson a Referencia hozzáadása elemre az alábbi képen, és keresse meg a .dll fájl helyét a 2. lépéstől. Ennek hasonlónak kell lennie a ~ / ConsoleApp1 / bin / Debug / ConsoleApp1.dll fájlhoz.

A .dll fájl hozzáadása után megtalálhatja azt az Összeállítások alatt.

4. lépés: Helyezze az alábbi kódot a ConsoleApp2-be.

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);
)
)
)

5. lépés: A ConsoleApp2 összeállításakor fordítási idő hibát kap, amely azt jelzi, hogy a ConsoleApp1 alkalmazásból származó „x” nem érhető el más összeállításokban a védettségi szintje miatt.

5. Védett belső

Ez a védett és a belső hozzáférés-módosítók kombinációja. Fontos fogalom, amelyet itt meg kell érteni, hogy a Védett Belső védett VAGY Belső. Ez mindkét hozzáférés-módosító egységét alkotja. Soha nem szabad azt gondolni, hogy kereszteződés.

Tehát a belső objektumok nem érhetők el az egységen kívül, míg a védett objektumok hozzáférhetők bármely származtatott osztályhoz, az összes egységben. Mi van, ha csak más részegységekben akarom megvédeni a tárgyam, nem ugyanabban az egységben? Egyszerű megoldás - nyilvánítsa védett belsőként.

Példa

1. lépés: Módosítsuk a ConsoleApp1-et, hogy az tükrözze az alábbi kódot. Figyelem: az x változó hozzáférési szintjét védett belsőre változtattuk.

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);
)
)
)

2. lépés: Készítse el újra a megoldást, és cserélje ki a .dll fájlt a ConsoleApp2-ben a frissített változatra.

3. lépés: Frissítse a kódot a ConsoleApp2-ben az alábbiak szerint:

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();
)
)
)

4. lépés: Futtassa a ConsoleApp2 szoftvert a kimenet megtekintéséhez.

6. Magánvédett

Ez a magán és a védett hozzáférés-módosítók univerzális kombinációja. Védett belső eszközök Védett vagy belső. Tehát a magánobjektumok nem érhetők el azon a kódblokkon kívül, amelyben deklarálják, míg a védett objektumok hozzáférhetők bármely származtatott osztályhoz, az összes csoportban. Mi van, ha korlátozni akarom az objektum hozzáférését más származtatott osztályok származtatott osztályaiban is? Egyszerű megoldás - nyilvánítsa védett belsőként.

Példa

Módosítsuk a 'x' hozzáférési szintjét a ConsoleApp1-ben a Private Protected-re.

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();
)
)
)

Kimenet:

Táblázat összehasonlítás

Hozzáférési specifikátor	Ugyanaz a közgyűlés			Egyéb közgyűlés
	Ugyanabba az osztályba	Származtatott osztály	Nem származtatott osztály	Származtatott osztály	Nem származtatott osztály
Magán	Igen	Nem	Nem	Nem	Nem
Nyilvános	Igen	Igen	Igen	Igen	Igen
Védett	Igen	Igen	Nem	Igen	Nem
Belső	Igen	Igen	Igen	Nem	Nem
Védett belső	Igen	Igen	Igen	Igen	Nem
Magánvédett	Igen	Igen	Nem	Nem	Nem

Következtetés

A fenti cikkben láttuk, hogy a hozzáférés-módosítók ellenőrzik a projekt mindent. A hozzáférési szintek különféle kombinációi fedezik a különféle akadálymentesség igényeit. A fejlesztőknek okosan kell választaniuk, szem előtt tartva az objektum biztonságát és abszolút szükségességét, hogy egy bizonyos kódblokkban elérhető legyen.

Ajánlott cikkek

Ez egy útmutató a hozzáférési módosítókhoz a C # -ben. Itt tárgyaltuk a C # bevezető hozzáférés-módosítók típusait, példákat és kimeneteket. A további javasolt cikkeken keresztül további információkat is megtudhat -

1. C # Összeállítók
2. Romboló C # -ben
3. Mi a TypeScript?
4. Mi az ASP.Net webszolgáltatások?
5. Hozzáférés-módosítók a PHP-ben
6. Munka és a 3 legfontosabb Enum módszer a C # -ben.