Akses Pengubahsuai dalam C#

Artikel ini merangkumi konsep paling asas pengaturcaraan berorientasikan objek daripada perspektif bahasa pengaturcaraan C#. Konsep ini dikenali sebagai – Pengubahsuai Akses. Soalan pertama untuk dijawab ialah – Apakah itu Pengubahsuai Akses? Ringkasnya, pengubah akses mengawal objek/pembolehubah/pemalar/kaedah (secara praktikal semuanya) boleh diakses di bahagian mana kod. Pengubah suai akses memainkan peranan penting dalam membuktikan konsep Abstraksi dalam pengaturcaraan berorientasikan Objek. Mereka mengawal bahagian program yang sepatutnya dan tidak boleh dilihat oleh pengguna akhir. Sudah tentu, pengguna akhir kurang mengambil berat tentang pemalar dan pembolehubah yang terlibat dalam algoritma. Dia hanya mengambil berat tentang kaedah yang perlu dia gunakan untuk mendapatkan output.

Jenis Pengubahsuai Akses dalam C#

C# menyediakan kami dengan empat jenis pengubah suai akses:

• Persendirian (pengubah suai akses lalai, kecuali enum dan antara muka)
• Dilindungi (terhad sedikit)
• Awam (tidak terhad, pilihan lalai untuk enum dan antara muka)
• Dalaman (awam dalam perhimpunan yang sama)

Selain daripada empat pengubah suai akses ini, terdapat dua lagi kombinasi tahap akses–

• Dalaman Dilindungi
• Dilindungi Persendirian

Mari kita fahami setiap satu dengan contoh.

1. Persendirian

Persendirian ialah tahap akses yang paling terhad. Ia juga merupakan pengubah suai akses lalai untuk semua pemalar, pembolehubah, objek yang ditakrifkan pengguna, dsb. Hanya enum dan antara muka terbuka secara lalai. Jadi, jika anda tidak menentukan sebarang pengubah akses, C# memberikan pengubah lalai kepadanya.

Objek peribadi tidak boleh diakses di luar badan kelas atau struct, atau bahagian program di mana ia diisytiharkan. Sebarang percubaan untuk mengakses objek di luar skop badan di mana ia diisytiharkan menghasilkan ralat masa kompilasi.

Contoh #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);
}
}

Output:

Contoh #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);
}
}

Output:

2. Dilindungi

Penentukan akses Dilindungi mengehadkan objek untuk boleh diakses hanya daripada contoh terbitan kelas. Jadi, jika objek kelas kanak-kanak cuba mengakses objek dilindungi kelas induk, ia dibenarkan. Kelas bukan terbitan tidak boleh mengakses ahli yang dilindungi mana-mana kelas. Sudah tentu, objek yang dilindungi boleh diakses dengan kaedah kelas mereka sendiri.

Contoh:

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

Output:

3. Awam

Ini ialah pengubah suai akses paling kurang terhad. Objek awam boleh diakses secara praktikal oleh seluruh dunia luar, dengan itu menjadikannya pengubah akses yang dibenarkan tertinggi. Sudah tentu, ini memerlukan kos yang tinggi – kos perlindungan yang paling sedikit.

Mana-mana bahagian kod boleh mengakses ahli awam. Ini menjadikan mereka paling kurang selamat. Mana-mana logik kod boleh mengubah suai nilainya yang boleh membawa kepada tingkah laku yang tidak dijangka. Jadi, seseorang itu mesti berhati-hati sebelum membuat sebarang objek awam.

Dalam kelas Pekerja yang sama yang kami buat dalam contoh pengubah suai akses peribadi kami, jika kami menukar tahap akses awam, kami tidak memerlukan sebarang kaedah Getter dan Setter. Malah, amalan terbaik ialah menjadikan objek peribadi dan menggunakan sifat C# Getter dan Setter.

Contoh:

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

Output:

4. Dalaman

Objek dan kaedah dalaman hanya boleh diakses dalam pemasangan yang sama. Ini ialah pengubah suai akses yang sangat berguna apabila anda ingin membuat sebarang objek awam tetapi mahu menyekat aksesnya hanya kepada rangka kerja yang anda sedang pengekodan.

Jadi, pada dasarnya, semua objek dalaman boleh diakses oleh semua kawasan perhimpunan yang sama.

Mari kita cipta dua aplikasi konsol untuk memahami kerja ini.

Contoh:

Langkah 1: Buat Aplikasi Konsol C# dan letakkan kod di bawah di dalamnya:

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

Langkah 2: Bina penyelesaian untuk mendapatkan fail .dll daripada folder bin.

Langkah 3: Buat aplikasi konsol lain dan rujuk fail pemasangan daripada ConsoleApp1. Klik pada Tambah Rujukan dalam imej di bawah dan semak imbas ke lokasi fail .dll dari langkah 2. Ia mestilah serupa dengan ~/ConsoleApp1/bin/Debug/ConsoleApp1.dll.

Selepas menambah fail .dll, anda harus mencarinya di bawah Assemblies.

Step4: Place the below code in 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);
}
}
}

Step5: When you build ConsoleApp2, you will get a compile-time error indicating that ‘x’ from ConsoleApp1 cannot be accessed in other assemblies due to its protection level.

5. Protected Internal

This is a combination of both Protected and Internal access modifiers. An important concept to understand here is that Protected Internal means Protected OR Internal. It is a union of both access modifiers. It must never be thought to be an intersection.

So, Internal objects are not accessible outside the assembly, while Protected objects are accessible to any derived class in any assembly. What if I want to protect my object only in other assemblies and not in the same assembly? Simple solution – declare it as protected internal.

Example:

Step 1: Let us modify our ConsoleApp1 to reflect the code below. Notice we have changed the access level of our variable ‘x’ to protected internal.

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

Step 2: Build the solution again and replace the .dll in ConsoleApp2 with the updated one.

Step 3: Update the code in ConsoleApp2 as below:

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

Step 4: Run ConsoleApp2 to see the output.

6. Private Protected

This is a union combination of both Private and Protected access modifiers. Protected Internal means Protected OR Internal. So, Private objects are not accessible outside the code block in which it is declared, while Protected objects are accessible to any derived class in any assembly. What if I want to restrict my object’s access even in derived classes in other assemblies? Simple solution – declare it as protected internal.

Example:

Let us modify the access level of ‘x’ in ConsoleApp1 to 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();
}
}
}

Output:

Tabular Comparison

Following is a tabular comparison of Access Modifiers in C#:

Access Specifier	Same Assembly			Other Assembly
	Same Class	Derived Class	Non-Derived Class	Derived Class	Non-Derived Class
Private	Yes	No	No	No	No
Public	Yes	Yes	Yes	Yes	Yes
Protected	Yes	Yes	No	Yes	No
Internal	Yes	Yes	Yes	No	No
Protected Internal	Yes	Yes	Yes	Yes	No
Private Protected	Yes	Yes	No	No	No

Conclusion

We have seen in the above article that access modifiers control the access of everything in the project. Various combinations of access levels cover the needs of various kinds of accessibility. The developers must choose wisely, keeping in mind the security and the absolute necessity of the object to be accessible in a certain block of code.

Atas ialah kandungan terperinci Akses Pengubahsuai dalam C#. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!