Въведение в модификаторите за достъп в C #
Тази статия обхваща най-елементарната концепция за обектно-ориентирано програмиране от гледна точка на езика за програмиране на C #. Концепцията е известна като - Модификатори на достъпа. Първият въпрос, на който трябва да се отговори, е - Какво представляват модификаторите на достъп? Просто казано, модификаторите за достъп контролират кои обекти / променливи / константи / методи (практически всичко) могат да бъдат достъпни в коя част от кода. Модификаторите на достъп играят важна роля за доказване на концепцията за абстракция в обектно-ориентираното програмиране. Те контролират каква част от програмата трябва да бъде и не трябва да бъде видима за крайния потребител. Разбира се, крайният потребител е най-малко загрижен за константите и променливите, участващи в алгоритъма. Той е загрижен само какъв метод трябва да използва, за да получи резултата.
Видове модификатори на достъп в C #
C # ни предоставя четири типа модификатори на достъп:
- Частен (модификатор за достъп по подразбиране, с изключение на enums и интерфейси)
- Защитени (леко ограничени)
- Публичен (неограничен, избор по подразбиране за enums и интерфейси)
- Вътрешно (обществено в рамките на едно и също събрание)
Освен тези четири модификатора на достъп има още две комбинации от ниво на достъп -
- Защитени вътрешни
- Частно защитено
Нека разберем всеки с пример.
1. Частен
Частното е най-ограниченото ниво на достъп. Той също е модификатор на достъп по подразбиране за всички константи, променливи, дефинирани от потребителя обекти и т.н. По подразбиране са публично достояние само enums и интерфейси. Така че, ако не посочите модификатор на достъп, C # присвоява модификатора по подразбиране към него.
Частните обекти не са достъпни извън тялото на класа или структурата или секцията на програмата, в която са декларирани. Всеки опит за достъп до обекта извън обхвата на органа, в който е деклариран, води до грешка във време на компилиране.
Пример №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);
)
)
Резултат 1:
Пример №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);
)
)
Резултат 2:
2. Защитени
Спецификаторът за защитен достъп ограничава даден обект да бъде достъпен само от производни екземпляри от класа. Така че, ако обектът от клас деца се опита да получи достъп до защитените обекти на родителския клас, той е позволен. Неполучените класове не могат да имат достъп до защитени членове на който и да е клас. Разбира се, защитените обекти са достъпни за методи от собствен клас.
пример
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:
3. Публична
Това е най-малко ограниченият модификатор за достъп. Публичните обекти са практически достъпни за целия външен свят, като по този начин го правят най-допустимия модификатор на достъп. Разбира се, това идва с голяма цена - цената на най-малко защита.
Публичните членове могат да имат достъп от всяка част на кода. Това ги прави най-малко сигурни. Всяка логика на кода може да промени стойността им, което може да доведе до неочаквано поведение. Така че човек трябва да бъде много предпазлив, преди да направи публично достояние всеки обект.
В същия клас Служители, който създадохме в нашия пример за модифициране на частен достъп, ако променим нивото на достъп до обществен, няма да се нуждаем от методи на Getter и Setter. Всъщност най-добрата практика е да направите обекта частен и да използвате свойствата на C # Getter и Setter.
пример
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:
4. Вътрешен
Вътрешните обекти и методи са достъпни само в един и същи монтаж. Това е много полезен модификатор на достъп, когато искате да направите всеки обект публичен и въпреки това искате да ограничите достъпа му само до рамката, която кодирате.
Така че по същество всички вътрешни обекти са достъпни от всички области на един и същи монтаж.
Нека да създадем две конзолни приложения, за да разберем това работи.
пример
Стъпка 1: Създайте приложение за конзола C # и поставете кода по-долу в него:
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: Създайте решението, за да получите .dll файла от папката bin.
Стъпка 3: Създайте друго приложение за конзола и препратете сборния файл от ConsoleApp1. Кликнете върху Добавяне на справка в изображението по-долу и прегледайте местоположението на .dll файла от стъпка 2. Той трябва да е подобен на ~ / ConsoleApp1 / bin / Debug / ConsoleApp1.dll.
След като добавите .dll файла, трябва да го намерите в Асамблеи.
Стъпка 4: Поставете кода по-долу в 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);
)
)
)
Стъпка 5: Когато изграждате ConsoleApp2, ще получите грешка във времето за компилация, показваща, че 'x' от ConsoleApp1 не може да бъде достъпна в други монтажи поради нивото на защита.
5. Защитени вътрешни
Това е комбинация от модификатори за защитен и вътрешен достъп. Важна концепция, която трябва да разберем тук, е, че защитени вътрешни средства са защитени или вътрешни. Това е обединение и на два модификатора на достъп. Никога не трябва да се мисли, че е пресечка.
И така, вътрешните обекти не са достъпни извън монтажа, докато защитените обекти са достъпни за всеки производен клас във всеки сбор. Какво ще стане, ако искам да защитя обекта си само в други монтажи, а не в същия монтаж? Просто решение - декларирайте го като защитено вътрешно.
пример
Стъпка 1: Нека променим нашия ConsoleApp1, за да отразяваме кода по-долу. Забележете, че сме променили нивото на достъп на нашата променлива 'x' на защитен вътрешен.
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: Създайте отново решението и заменете .dll в ConsoleApp2 с актуализирания.
Стъпка 3: Актуализирайте кода в ConsoleApp2, както е по-долу:
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: Стартирайте ConsoleApp2, за да видите изхода.
6. Частно защитено
Това е съюзна комбинация от модификатори за частен и защитен достъп. Защитени вътрешни средства Защитени ИЛИ Вътрешни. Така че, Частните обекти не са достъпни извън кодовия блок, в който е деклариран, докато Защитените обекти са достъпни за всеки производен клас във всеки сбор. Какво ще стане, ако искам да огранича достъпа на моя обект дори в производни класове в други монтажи? Просто решение - декларирайте го като защитено вътрешно.
пример
Нека променим нивото на достъп на „x“ в ConsoleApp1 на 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();
)
)
)
изход:
Таблично сравнение
| Спецификатор за достъп | Същото събрание | Друго събрание | |||
| Същия клас | Получен клас | Клас без производни | Получен клас | Клас без производни | |
| частен | да | Не | Не | Не | Не |
| обществен | да | да | да | да | да |
| Защитена | да | да | Не | да | Не |
| вътрешен | да | да | да | Не | Не |
| Защитени вътрешни | да | да | да | да | Не |
| Частно защитено | да | да | Не | Не | Не |
заключение
В горната статия видяхме, че модификаторите на достъп контролират достъпа до всичко в проекта. Различни комбинации от нива на достъп покриват нуждите от различни видове достъпност. Разработчиците трябва да избират разумно, като имат предвид сигурността и абсолютната необходимост на обекта да бъде достъпен в определен блок от кодове.
Препоръчителни статии
Това е ръководство за модификаторите на достъп в C #. Тук сме обсъдили Въвеждащите типове модификатори на достъп в C #, заедно с примери и изходи. Можете също да прегледате и другите ни предложени статии, за да научите повече -
- C # Съставители
- Разрушител в C #
- Какво е TypeScript?
- Какво е ASP.Net Web Services?
- Достъп Модификатори в PHP
- Работа и топ 3 Enum методи в C #