C# 인터페이스

인터페이스는 C#에서 추상 또는 비추상 클래스에 의해 구현되거나 사용되는 추상 메서드 및 속성 그룹을 보유하는 키워드입니다. 메소드 정의는 기본적으로 메소드를 공개 및 추상화하는 인터페이스 내부의 속성입니다.

간단히 말하면 인터페이스는 본문에 포함된 모든 멤버나 구성 요소가 계약을 따라야 하는 계약과 유사하며 수행해야 할 작업을 정의합니다. 인터페이스는 필드를 포함하지 않으며 항상 "인터페이스"라는 키워드를 사용하여 정의됩니다.

구문:

구문은 인터페이스 키워드로 시작하고 그 뒤에 인터페이스 이름, 본문이 옵니다.

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

보시다시피 C#에는 인터페이스에 대한 표준 구문이 있습니다. 이 구문은 '인터페이스' 키워드로 시작하고 인터페이스 이름, 본문 내부의 추상 메서드 및 속성으로 구성됩니다. C#에서는 클래스 또는 구조체 내에서 여러 인터페이스를 구현하고 사용할 수 있습니다. 이러한 인터페이스는 다양한 메소드, 인덱서, 속성 및 이벤트를 멤버로 보유할 수 있습니다.

C# 인터페이스는 왜 필요한가요?

기본적으로 우리는 인터페이스 내부에 특정한 기능이 없다는 것을 이해했습니다. 그렇다면 인터페이스가 왜 필요한가요?

인터페이스는 언제 사용하나요?

• 보안: 일부 기능을 단순히 숨기고 나중에 사용해야 하는 경우. 사용자에게 중요한 세부정보만 표시하면서 몇 가지 세부정보를 숨기는 것이 중요합니다.
• 다중 상속: C#에서는 하나의 클래스가 간단한 상위 클래스에서 상속되어 해당 클래스의 모든 기능을 상속받을 수 있습니다. C#을 복잡하게 만들지 않기 위한 단순한 이유 때문에 C#에서는 다중 상속이 지원되지 않습니다. 그러나 인터페이스를 사용하면 여러 인터페이스를 단일 클래스로 구현할 수 있습니다.

C# 인터페이스에는 일반적으로 다음 요소가 포함됩니다.

1. 선언 – C#에서 인터페이스는 메서드 서명, 속성, 이벤트 또는 인덱서 집합을 정의하는 계약입니다. 구현이 포함되어 있지 않으며 클래스가 준수해야 할 청사진 역할을 합니다. 인터페이스를 구현하는 클래스는 인터페이스에 선언된 모든 멤버에 대해 구체적인 구현을 제공해야 합니다.
2. 멤버 – 인터페이스 멤버는 인터페이스 내에 선언된 메서드, 속성, 이벤트 및 인덱서입니다. 이는 구현 클래스가 준수해야 하는 계약을 정의하여 다양한 클래스에서 일관된 동작을 보장합니다. 클래스 구현은 이러한 멤버에 대한 구체적인 구현을 제공하고, 코드 일관성을 촉진하고, 다형성 및 코드 재사용을 가능하게 해야 합니다.
3. 구현 – 인터페이스를 구현하는 클래스는 인터페이스에 선언된 모든 멤버에 대한 구현을 제공해야 합니다. 클래스는 :interfaceName 구문을 사용하여 인터페이스를 구현하도록 명시적으로 지정할 수 있습니다. 예를 들어:

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

4. 다중 상속: C#은 인터페이스를 통한 다중 상속을 지원합니다. 클래스는 여러 인터페이스를 구현할 수 있으므로 구현의 다중 상속과 관련된 복잡성 없이 여러 메서드 시그니처 세트를 상속할 수 있습니다. 이를 통해 기존 다중 상속에 내재된 다이아몬드 문제를 피하면서 클래스 설계의 유연성을 높일 수 있습니다.
5. 인터페이스 상속: C#에서 인터페이스 상속을 사용하면 파생 인터페이스가 하나 이상의 기본 인터페이스에 정의된 메서드 시그니처를 상속할 수 있습니다. 파생 인터페이스를 구현하는 클래스는 상속된 모든 메서드에 대한 구현을 제공해야 합니다. 이를 통해 인터페이스 계층을 생성하고 코드 재사용을 촉진하며 객체 디자인의 유연성을 높일 수 있습니다.

C# 인터페이스의 예

이제 인터페이스가 무엇이고 그 필요성을 이해했습니다. 인터페이스 구현이 포함된 C# 코드의 간단한 예를 살펴보겠습니다.

예시 #1

인터페이스를 구현하고 간단한 문장을 출력하는 프로그램입니다.

코드:

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

코드 해석: use와 네임스페이스부터 시작하여 기본 인터페이스는 본문에 단일 메소드를 갖는 SampleInterface로 생성됩니다. 인터페이스 내부의 이 메서드에는 특정 본문이 없습니다. 그런 다음 우리가 만든 인터페이스를 구현하는 새 클래스가 있습니다. 클래스 키워드 뒤에 클래스 이름을 입력하고 콜론 기호 뒤에 인터페이스 이름을 사용하여 인터페이스를 구현합니다. Int_Example 클래스 안에는 이전에 생성된 인터페이스 메서드가 있는데, 그 당시에는 몸체가 없었습니다. 이제 "이것은 C# 인터페이스의 간단한 예입니다."라고 말하는 간단한 print 문을 추가했습니다.

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.

위 내용은 C# 인터페이스의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!