Antara muka C#

Antaramuka, dalam C#, ialah kata kunci, yang memegang sekumpulan kaedah dan sifat abstrak, yang akan dilaksanakan atau digunakan oleh kelas abstrak atau bukan abstrak. Mentakrifkan kaedah ialah sifat dalam antara muka yang menjadikannya awam dan abstrak secara lalai.

Dalam istilah yang paling mudah, Antaramuka adalah seperti Kontrak, di mana setiap ahli atau komponen yang termasuk dalam badan perlu mengikut kontrak, ia mentakrifkan apa yang mesti dilakukan. Antara muka tidak mengandungi sebarang medan dan sentiasa ditakrifkan oleh penggunaan kata kunci "antara muka".

Sintaks:

Sintaks bermula dengan kata kunci antara muka diikuti dengan nama untuk antara muka dan kemudian badan.

interface <name_for_interface>
{
//abstract methods
//abstract properties.
}

Seperti yang anda lihat, kami mempunyai sintaks standard kami untuk Antara Muka dalam C#, yang bermula dengan kata kunci 'antara muka' kemudian nama untuk antara muka dan kemudian kaedah dan sifat abstrak di dalam badan. Dalam C#, berbilang antara muka boleh dilaksanakan dan digunakan, di dalam kelas atau struct. Antara muka ini boleh menyimpan pelbagai kaedah, pengindeks, sifat dan juga acara sebagai ahli.

Mengapa kita memerlukan Antara Muka C#?

Pada asasnya kami telah memahami bahawa tiada fungsi khusus dalam antara muka, jika ya, maka mengapa kami memerlukan Antara Muka?

Bila hendak menggunakan Antara Muka?

• Keselamatan: Apabila kita perlu menyembunyikan beberapa ciri dan perlu menggunakannya kemudian. Adalah penting untuk menyembunyikan beberapa butiran sambil hanya menunjukkan butiran yang penting kepada pengguna.
• Warisan Berbilang: Dalam c#, satu kelas boleh mewarisi daripada kelas induk ringkas, mewarisi semua cirinya. Multiple Inheritance tidak disokong dalam C# atas sebab mudah untuk tidak menjadikan C# kompleks. Tetapi dengan penggunaan antara muka, berbilang antara muka boleh dilaksanakan ke dalam satu kelas.

Antara Muka C# biasanya mengandungi elemen berikut:

1. Pengisytiharan – Dalam C#, antara muka ialah kontrak yang mentakrifkan satu set tandatangan kaedah, sifat, peristiwa atau pengindeks. Ia tidak mengandungi pelaksanaan dan berfungsi sebagai pelan tindakan untuk dipatuhi oleh kelas. Kelas yang melaksanakan antara muka mesti menyediakan pelaksanaan konkrit untuk semua ahli yang diisytiharkan dalam antara muka.
2. Ahli – ahli antara muka ialah kaedah, sifat, peristiwa dan pengindeks yang diisytiharkan dalam antara muka. Mereka mentakrifkan kontrak yang mesti dipatuhi oleh kelas pelaksana, memastikan tingkah laku yang konsisten merentas pelbagai kelas. Kelas pelaksana mesti menyediakan pelaksanaan konkrit untuk ahli ini, menggalakkan ketekalan kod dan mendayakan polimorfisme dan penggunaan semula kod.
3. Pelaksanaan – Kelas yang melaksanakan antara muka mesti menyediakan pelaksanaan untuk semua ahli yang diisytiharkan dalam antara muka. Kelas boleh menentukan secara eksplisit bahawa ia melaksanakan antara muka menggunakan sintaks: interfaceName. Contohnya:

   public class MyClass : IMyInterface
   {
   public void Method1()
   {
   // Method implementation
   }public string Property1 { get; set; }
   
   public event EventHandler Event1;
   }

4. Warisan Berbilang : C# menyokong warisan berbilang melalui antara muka. Kelas boleh melaksanakan berbilang antara muka, membenarkannya mewarisi berbilang set tandatangan kaedah tanpa kerumitan yang dikaitkan dengan pewarisan berbilang pelaksanaan. Ini membolehkan lebih fleksibiliti dalam mereka bentuk kelas sambil mengelakkan masalah berlian yang wujud dalam warisan berbilang tradisional.
5. Warisan Antara Muka: Dalam C#, warisan antara muka membenarkan antara muka terbitan untuk mewarisi tandatangan kaedah yang ditakrifkan dalam satu atau lebih antara muka asas. Kelas yang melaksanakan antara muka terbitan mesti menyediakan pelaksanaan untuk semua kaedah yang diwarisi. Ini membolehkan penciptaan hierarki antara muka, menggalakkan penggunaan semula kod dan fleksibiliti dalam reka bentuk objek.

Contoh Antara Muka C#

Sekarang kita telah memahami apa itu antara muka dan keperluannya. Mari tunjukkan contoh mudah kod C# dengan pelaksanaan antara muka.

Contoh #1

Program melaksanakan Antara Muka dan mencetak pernyataan ringkas.

Kod:

using System;
namespace MyApplication {
interface SampleInterface {
void InterfaceMethod();
}
class Int_Example : SampleInterface
{
public void InterfaceMethod() {
Console.WriteLine("\nThis is simple example of Interface in C#.");
}
}
class Program {
static void Main(string[] args) {
Int_Example myInterface = new Int_Example();
myInterface.InterfaceMethod();
Console.Read();
}
}
}

Tafsiran Kod: Bermula dengan penggunaan dan ruang nama, antara muka asas dijana sebagai SampleInterface yang mempunyai satu kaedah dalam badannya. Kaedah ini di dalam antara muka tidak mempunyai badan tertentu. Kemudian kami mempunyai kelas baharu kami iaitu untuk melaksanakan antara muka yang kami buat. Dibuat dengan, kata kunci kelas diikuti dengan nama kelas dan kemudian melaksanakan antara muka dengan simbol kolon diikuti dengan nama antara muka. Di dalam kelas Int_Example kami, kami mempunyai kaedah antara muka yang dibuat sebelum ini, yang pada masa itu tidak berbadan, kini kami telah menambah pernyataan cetakan mudah, yang mengatakan, "Ini adalah contoh mudah Antara Muka dalam C#."

Then begins our mail class, namely Program, with the static void main statement. Inside our main class, we have created a new object for our Int_Example class which inherits interface. The new object is created and to the next line, our method created earlier is called up. Finally, our newly created object will call the earlier created method and the body inside that method will be executed here. With Console.Read(); the program will wait for user input before exiting.

Output:

Upon successful compilation and execution, the program must simply print the statement: “This is a simple example of Interface in C#.”

Example #2

Arithmetic operations using the interface.

Code:

using System;
namespace arth_interface {
public interface SampleInterface {
void sam_add(int a, int b);
void sam_sub(int a, int b);
void display();
}
class interface_class : SampleInterface {
int x, y;
public void sam_add(int a, int b) {
int m, n;
m = a;
n = b;
x = m + n;
}
public void sam_sub(int a, int b) {
int m, n;
m = a;
n = b;
y = a - b;
}
public void display() {
Console.WriteLine("Added Value is:" + x);
Console.WriteLine("Subtracted value is:" + y);
}
}
class arth_interface {
static void Main(string[] args) {
interface_class obj_interface_class = new interface_class();
int fnumber, snumber;
Console.WriteLine("Please Enter 1st Number to perform Addition and Subtraction:");
fnumber = Convert.ToInt16(Console.ReadLine());
Console.WriteLine("Now 2nd Number to perform Addition and Subtraction:");
snumber = Convert.ToInt16(Console.ReadLine());
obj_interface_class.sam_add(fnumber, snumber);
obj_interface_class.sam_sub(fnumber, snumber);
obj_interface_class.display();
Console.ReadKey();
}
}
}

Code Interpretation: Similar to our first example, we have used and namespace statements, followed by the interface and its body with methods. We have two basic methods for addition and subtraction with void as return type, two integers inside every method, respectively. Next, we have our class which implements our interface.

We’ve declared two integers and then we have our first method to calculate addition. Here is the operation that needs to be done for addition and the same is for the subtraction. Then we have our display method, which consists of two print statements, printing addition and subtraction values of the numbers passed.

Finally, we have our class with the main method, where we initially created an object for our interface. Then the program prints “Please Enter the 1st Number to perform Addition and Subtraction:”, where the user inputs a first number and the later second number, for the purpose of calculations. With the object created earlier, the program calls the add and sub-methods from the interface and the same operations are done. At last, we have our display method, which displays our results as defined in the display method and ReadKey(); method holds up our program until any key is pressed.

Output:

Advantages

Below are some of the advantages given.

• One of the major advantages of Interface in C# is a better alternative to implement multiple inheritances.
• The interface enables the plug-and-play method.
• Complete Abstraction can be achieved by the implementation of Interface.
• Along with making our code easy to maintain, concept loose coupling can be achieved.

Conclusion

We have understood what Interface in C# is. The proper syntax for an interface along with an explanation. To wrap it up, Interfaces in C# are a way to fill the emptiness of multiple inheritances in the language. Later we learned why do we actually need the interface in C# followed by the examples to demonstrate the understanding of the interfaces. The first example was to demonstrate simple use of interface while with the second example we implemented arithmetic operations, followed by Code Interpretation and output screenshot.

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