Johdatus pääsymuuntajaan C #: ssä

Tämä artikkeli kattaa alkeellisimman käsityksen olio-ohjelmoidusta ohjelmoinnista C # -kielen kannalta. Konsepti tunnetaan nimellä Access Modifiers. Aivan ensimmäinen vastattava kysymys on - mitkä ovat käyttöoikeuksien muokkaimet? Yksinkertaisesti sanottuna pääsynmuokkaimet hallitsevat, mihin esineisiin / muuttujiin / vakioihin / menetelmiin (käytännössä kaikki) pääsee mihin koodin osaan. Käyttöoikeuksien muuntajilla on tärkeä rooli todistamalla abstraktiokäsite olio-ohjelmoidussa ohjelmoinnissa. Ne hallitsevat, minkä osan ohjelmasta tulisi olla, eikä niiden pitäisi olla näkyviä loppukäyttäjälle. Tietysti loppukäyttäjä on vähiten huolissaan algoritmissa mukana olevista vakioista ja muuttujista. Hän on huolissaan vain siitä, mitä menetelmää hän tarvitsee käyttääkseen tuloksen saamiseksi.

Tyypit käyttömuuntajat C #: ssä

C # tarjoaa meille neljä tyyppiä pääsymuokkaimia:

  • Yksityinen (oletuksena pääsymuokkain, lukuun ottamatta enumeja ja käyttöliittymiä)
  • Suojattu (hieman rajoitettu)
  • Julkinen (rajoittamaton, enumien ja rajapintojen oletusvalinta)
  • Sisäinen (julkinen saman kokoonpanon sisällä)

Näiden neljän käyttöoikeuden muokkaimen lisäksi on vielä kaksi pääsytason yhdistelmää -

  • Suojattu sisäinen
  • Yksityinen suojattu

Ymmärtäkäämme kukin esimerkillä.

1. Yksityinen

Yksityinen on kaikkein rajattu pääsytaso. Se on myös kaikkien vakioiden, muuttujien, käyttäjän määrittelemien kohteiden jne. Oletuskäyttöoikeuden muokkain. Vain enumit ja rajapinnat ovat oletuksena julkisia. Joten, jos et määritä mitään pääsymuokkainta, C # määrittää sille oletusmuokkaimen.

Yksityisiä esineitä ei voida päästä sen luokan, rakenteen tai ohjelman osan ulkopuolelle, jossa ne on ilmoitettu. Jokainen yritys päästä esineeseen sen ruumiin ulkopuolella, jossa se on ilmoitettu, johtaa käännösajan virheeseen.

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

Lähtö 1:

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

Lähtö 2:

2. Suojattu

Suojattu pääsy -määrittely rajoittaa objektin saatavuuden vain luokan johdettujen esiintymien perusteella. Joten jos lasten luokkaobjekti yrittää päästä vanhemman luokan suojattuihin kohteisiin, se on sallittu. Johdannaisluokat eivät pääse minkään luokan suojattuihin jäseniin. Suojatut esineet ovat tietysti saatavissa oman luokan menetelmillä.

esimerkki

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

Lähtö 3:

3. Julkinen

Tämä on vähiten rajoitettu pääsymuokkain. Julkiset esineet ovat käytännössä koko ulkomaailman ulottuvilla, mikä tekee siitä suurimman sallitun pääsyn muuntajan. Tietysti tästä tulee kalliita kustannuksia - vähiten suojan kustannukset.

Julkisiin jäseniin pääsee millä tahansa koodin osalla. Tämä tekee heistä vähiten turvattuja. Mikä tahansa koodilogiikka voi muuttaa niiden arvoa, mikä voi johtaa odottamattomaan käyttäytymiseen. Joten on oltava varovainen ennen minkään esineen julkistamista.

Samassa Työntekijäluokassa, jonka loimme yksityisen käyttöoikeuden muokkausesimerkissä, jos muutamme käyttöoikeustasoa yleisölle, emme tarvitse Getter- ja Setter-menetelmiä. Itse asiassa paras tapa on tehdä objekti yksityiseksi ja käyttää C # Getter- ja Setter-ominaisuuksia.

esimerkki

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

Lähtö 4:

4. Sisäinen

Sisäisiin kohteisiin ja menetelmiin pääsee vain samassa kokoonpanossa. Tämä on erittäin hyödyllinen pääsymuokkain, kun haluat julkistaa minkä tahansa objektin, mutta haluat kuitenkin rajoittaa sen pääsyn vain koodaamaan kehykseen.

Joten pohjimmiltaan kaikkiin sisäisiin esineisiin pääsee saman kokoonpanon kaikilla alueilla.

Luokaamme kaksi konsoli-sovellusta tämän toiminnan ymmärtämiseksi.

esimerkki

Vaihe 1: Luo C # -konsolisovellus ja laita alla oleva koodi siihen:

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

Vaihe 2: Luo ratkaisu, jotta saat .dll-tiedoston bin-kansiosta.

Vaihe 3: Luo toinen konsolisovellus ja viita kokoonpanotiedosto ConsoleApp1: stä. Napsauta Lisää viite alla olevassa kuvassa ja selaa .dll-tiedoston sijainti vaiheesta 2. Sen on oltava samanlainen kuin ~ / ConsoleApp1 / bin / Debug / ConsoleApp1.dll.

Kun olet lisännyt .dll-tiedoston, sinun pitäisi löytää se Kokoonpanot-kohdasta.

Vaihe 4: Aseta alla oleva koodi ConsoleApp2: een.

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

Vaihe 5 : Kun rakennat ConsoleApp2: ta, saat käännösajan virheen, joka osoittaa, että ConsoleApp1: n "x": ta ei voida käyttää muissa kokoonpanoissa sen suojaustason vuoksi.

5. Suojattu sisäinen

Tämä on yhdistelmä sekä suojattuja että sisäisiä käyttöoikeuksien muuntajia. Tärkeä käsite ymmärtää tässä on, että suojattu sisäinen tarkoittaa suojattua tai sisäistä. Se on molempien pääsyn muuntajien liitto. Sitä ei saa koskaan ajatella olevan risteys.

Joten sisäisiin esineisiin ei voida päästä kokoonpanon ulkopuolella, kun taas Suojattuihin kohteisiin voi päästä mistä tahansa johdetusta luokasta missä tahansa kokoonpanossa. Entä jos haluan suojata esineeni vain muissa kokoonpanoissa eikä samassa kokoonpanossa? Yksinkertainen ratkaisu - julista se suojatuksi sisäiseksi.

esimerkki

Vaihe 1: Muutetaan ConsoleApp1 -sovellusta alla olevan koodin mukaiseksi. Huomaa, että muutimme muuttujamme 'x' käyttöoikeustasoa suojattuun sisäiseen.

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

Vaihe 2: Luo ratkaisu uudelleen ja korvaa ConsoleApp2: n dll päivitetyllä.

Vaihe 3: Päivitä koodi ConsoleApp2: ssä seuraavasti:

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

Vaihe 4: Suorita ConsoleApp2 nähdäksesi tulosteen.

6. Yksityinen suojattu

Tämä on yhdistelmä sekä yksityisiä että suojattuja käyttöoikeuksien muuntajia. Suojattu sisäinen tarkoittaa suojattua TAI sisäistä. Joten yksityisiin objekteihin ei voida päästä sen koodilohkon ulkopuolella, jossa se on ilmoitettu, kun taas Suojattuihin objekteihin pääsee mistä tahansa johdetusta luokasta missä tahansa kokoonpanossa. Entä jos haluan rajoittaa esineeni pääsyä jopa johdettuihin luokkiin muissa kokoonpanoissa? Yksinkertainen ratkaisu - julista se suojatuksi sisäiseksi.

esimerkki

Olkaamme muokata ConsoleApp1: n 'x' käyttöoikeustasoksi Yksityinen suojattu.

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

lähtö:

Taulukkovertailu

Pääsymäärittely Sama kokoonpano Muu kokous
Sama luokkaJohdettu luokkaJohdettu luokkaJohdettu luokkaJohdettu luokka
yksityinenJooEiEiEiEi
JulkinenJooJooJooJooJoo
suojattuJooJooEiJooEi
sisäinenJooJooJooEiEi
Suojattu sisäinenJooJooJooJooEi
Yksityinen suojattuJooJooEiEiEi

johtopäätös

Yllä olevassa artikkelissa olemme nähneet, että pääsyn muokkaimet hallitsevat projektin kaiken pääsyä. Eri pääsytasojen yhdistelmät kattavat erityyppisten saavutettavuuksien tarpeet. Kehittäjien on valittava viisaasti pitäen mielessä esineen turvallisuus ja ehdoton välttämättömyys päästä käsiksi tietyssä koodilohossa.

Suositellut artikkelit

Tämä on opas C # -sovelluksen Access Modifiers -sovellukseen. Täällä olemme keskustelleet C # -muodossa olevista pääsymuuntajien esittelytyypeistä sekä esimerkkeistä ja tuotoksista. Voit myös käydä läpi muiden ehdotettujen artikkeleidemme saadaksesi lisätietoja -

  1. C # Kääntäjät
  2. Tuhoaja C #: ssä
  3. Mikä on TypeScript?
  4. Mikä on ASP.Net Web Services?
  5. Pääsy muokkaimet PHP
  6. Työskentely ja 3 suosituinta enumimenetelmää C #: ssä