Interfejs w C# z przykładami
W tym artykule omówię jedno z najważniejszych pojęć, tj. Interfejs w C# z przykładami. Przeczytaj nasz poprzedni artykuł, w którym omówiliśmy klasy abstrakcyjne i metody abstrakcyjne w C# z przykładami. Jestem pewien, że na końcu tego artykułu zrozumiesz, czym jest interfejs, dlaczego potrzebujemy interfejsu i jak używać interfejsu w C# z przykładami.
Interfejs w C#
Do tej pory uczymy się zajęć. Czym więc jest klasa? Klasa to typ danych zdefiniowany przez użytkownika. Czym więc jest interfejs? Interfejs jest również typem danych zdefiniowanym przez użytkownika. Więc jaka jest między nimi różnica? Pozwól nam to najpierw zrozumieć.
Różnice między klasą, klasą abstrakcyjną i interfejsem w C#:
Klasa może zawierać tylko te metody, które zawierają treść metody. Czy mamy metodę bez ciała? Tak, mamy metody bez ciała i to się nazywa metodami abstrakcyjnymi. Tak więc po prostu możemy powiedzieć, że klasa zawiera metodę z treścią metody lub możemy powiedzieć, że metody nie są abstrakcyjne. Klasa abstrakcyjna zawiera zarówno metody abstrakcyjne, jak i nieabstrakcyjne, a interfejs zawiera tylko metody abstrakcyjne.
- Klasa: Zawiera tylko metody nieabstrakcyjne (metody z treścią metody).
- Klasa abstrakcyjna: Zawiera zarówno metody nieabstrakcyjne (metody z treścią metody), jak i metody abstrakcyjne (metody bez treści metody).
- Interfejs: Zawierają tylko metody abstrakcyjne (metody bez treści metody).
Co to są metody abstrakcyjne, dlaczego potrzebujemy metod abstrakcyjnych i jak implementować metody abstrakcyjne, omówiliśmy to już w naszych Klasach abstrakcyjnych i metodach abstrakcyjnych artykuł. Przeczytaj to artykuł, jeśli chcesz dowiedzieć się więcej o tych rzeczach.
Uwaga: Każda abstrakcyjna metoda interfejsu powinna być bezbłędnie zaimplementowana przez klasę podrzędną interfejsu (obowiązkowe).
W Dziedziczeniu , dowiedzieliśmy się już, że klasa dziedziczy z innej klasy, a klasa potomna zużywa członków klasy Parent. Proszę zwrócić uwagę na poniższy schemat. Tutaj mamy klasę A ze zbiorem elementów, a klasa B dziedziczy po klasie A. I istnieje między nimi relacja zwana relacją rodzic/dziecko. A po ustanowieniu relacji Rodzic/Dziecko, członkowie klasy A mogą być konsumowani w ramach klasy B. Oto, czego nauczyliśmy się w Dziedziczeniu.
Teraz, tak jak klasa ma inną klasę jako Rodzic, klasa może mieć również Interfejs jako Rodzic. A jeśli klasa ma interfejs jako Rodzic, odpowiada za implementację wszystkich abstrakcyjnych metod interfejsu. Aby lepiej zrozumieć, spójrz na poniższy diagram.
Mówiąc prosto, interfejs rodzica nakłada ograniczenia na klasy podrzędne. Jakie ograniczenia? Ograniczenia polegają na zaimplementowaniu każdej metody interfejsu w klasie potomnej.
Ogólnie rzecz biorąc, klasa dziedziczy z innej klasy, aby korzystać z elementów swojego elementu nadrzędnego. Z drugiej strony, jeśli klasa dziedziczy po interfejsie, ma zaimplementować członków swojego rodzica (interfejsu), a nie do użytku.
Uwaga: Klasa może jednocześnie dziedziczyć po klasie i interfejsach.
Jak zdefiniować interfejs w C#?
Sposób, w jaki definiujemy klasę, w ten sam sposób musimy zdefiniować interfejs. W deklaracji klasy musimy użyć słowa kluczowego class, natomiast w deklaracji interfejsu musimy użyć słowa kluczowego interface. Co więcej, w interfejsie możemy deklarować tylko składowe abstrakcyjne. Aby lepiej zrozumieć, spójrz na poniższy diagram.
Dla lepszego zrozumienia spójrz na poniższy przykład. Tutaj stworzyliśmy jeden interfejs o nazwie ITestInterface za pomocą słowa kluczowego interface.
interface ITestInterface
{
//Abstract Member Declarations
} Pracując z interfejsem musimy pamiętać o kilku regułach. Omówmy te zasady jeden po drugim z przykładami.
Punkt1: Pierwszą kwestią, o której musisz pamiętać, jest to, że domyślny zakres elementów interfejsu jest publiczny, podczas gdy w przypadku klasy jest prywatny.
Jak zdefiniować metody abstrakcyjne w interfejsie w C#?
W klasie (tj. Klasa abstrakcyjna) zazwyczaj używamy słowa kluczowego abstract do definiowania metod abstrakcyjnych w następujący sposób.
public abstract void Add(int num1, int num2);
Jeśli chcesz napisać powyższą metodę abstrakcyjną w interfejsie, nie potrzebujesz publicznych i abstrakcyjnych słów kluczowych w podpisie metody w następujący sposób:
void Dodaj(int num1, int num2);
Punkt2: Drugą kwestią, o której musisz pamiętać, jest to, że domyślnie każdy element interfejsu jest abstrakcyjny, więc nie musimy ponownie używać na nim modyfikatora abstract, tak jak to robimy w przypadku klasy abstrakcyjnej. Aby lepiej zrozumieć, spójrz na poniższy przykład. Domyślnie metoda Add będzie publiczna i abstrakcyjna.
interface ITestInterface
{
//By default, the following method is public and abstract
void Add(int num1, int num2);
}
Punkt3: Trzecią kwestią, o której musisz pamiętać, jest to, że nie możemy deklarować pól/zmiennych w interfejsie w C#.
Proszę spojrzeć na poniższy kod. Tutaj próbujemy zadeklarować zmienną i gdy tylko zadeklarujemy, otrzymujemy jeden błąd w czasie kompilacji, tj. Interfejsy nie mogą zawierać pól jak pokazano na poniższym obrazku.
Jakich członków możemy, a których nie możemy zdefiniować w interfejsie w C#?
Interfejs może zawierać
- Metody abstrakcyjne
- Właściwości
- Indeksy
- Wydarzenia
Interfejs nie może zawierać
- Funkcje nieabstrakcyjne
- Pola danych
- Konstruktorzy
- Destruktory
Punkt4: Czwartą kwestią, o której musisz pamiętać, jest to, czy wymaganie, aby interfejs mógł dziedziczyć z innego interfejsu w C#, tak jak klasa dziedziczy z innej klasy.
Aby lepiej zrozumieć, spójrz na poniższy kod. Tutaj mamy dwa interfejsy tj. Interface1 i Interface2. Interface2 jest dziedziczony z Interface1 i teraz interface2 ma dwie abstrakcyjne metody, tj. Add (z interfejsu 1) i Sub.
Teraz klasa Child, która dziedziczy po Interface1 musi zaimplementować jedną metodę, tj. Add, a klasa potomna, która dziedziczy po Interface2, musi zaimplementować dwie metody, tj. Add i Sub.
Możesz mieć teraz jedno pytanie, dlaczego potrzebujemy dwóch oddzielnych interfejsów, a dlaczego nie jednego? Tak, możesz używać jednego interfejsu i definiować wszystkie metody, o ile są one powiązane z jednym zadaniem. Jeśli umieścisz niepowiązane metody w jednym interfejsie, jest to sprzeczne z SOLID – zasadą segregacji interfejsów. Jeśli chcesz poznać SOLID – zasadę segregacji interfejsów proszę kliknąć tutaj .
Punkt5: Piąty punkt, o którym należy pamiętać, że każdy element interfejsu powinien być zaimplementowany pod klasą potomną (obowiązkowe), ale podczas implementacji nie wymagamy użycia modyfikatora override, tak jak to zrobiliśmy w przypadku klasa abstrakcyjna.
Aby lepiej zrozumieć, spójrz na poniższy kod. Tutaj mamy dwa interfejsy i dwie klasy implementacyjne. Interface2 jest dziedziczony po interfejsie Interface1 i dlatego ma dwie abstrakcyjne metody. ImplementationClass1 dziedziczy z Interface1 i dlatego implementuje tylko metodę Add. ImplementationClass2 dziedziczy z Interface1 i Interface2 dziedziczy z Interface1 i dlatego ta klasa musi zaimplementować obie metody abstrakcyjne. To właśnie możesz zobaczyć w poniższym kodzie.
interface ITestInterface1
{
void Add(int num1, int num2);
}
interface ITestInterface2 : ITestInterface1
{
void Sub(int num1, int num2);
}
public class ImplementationClass1 : ITestInterface1
{
//Implement only the Add method
public void Add(int num1, int num2)
{
Console.WriteLine($"Sum of {num1} and {num2} is {num1 + num2}");
}
}
public class ImplementationClass2 : ITestInterface2
{
//Implement Both Add and Sub method
public void Add(int num1, int num2)
{
Console.WriteLine($"Sum of {num1} and {num2} is {num1 + num2}");
}
public void Sub(int num1, int num2)
{
Console.WriteLine($"Divison of {num1} and {num2} is {num1 - num2}");
}
}
W powyższym przykładzie widać, że implementując metodę używamy modyfikatora public i jest to wymagane. Jeśli nie używasz public, metoda będzie traktowana jako prywatna i otrzymasz błąd kompilatora „ImplementationClass1” nie implementuje elementu interfejsu „ITestInterface1.Add(int, int)”. „ImplementationClass1.Add(int, int)” nie może zaimplementować elementu interfejsu, ponieważ nie jest publiczny. jak pokazano na poniższym obrazku.
Przykład zrozumienia interfejsu w C#:
Cokolwiek omówiliśmy do tej pory, umieściliśmy to wszystko w poniższym przykładzie. Proszę przejść przez wiersze komentarza.
using System;
namespace AbstractClassMethods
{
class Program
{
static void Main()
{
ImplementationClass1 obj1 = new ImplementationClass1();
//Using obj1 we can only call Add method
obj1.Add(10, 20);
//We cannot call Sun method
//obj1.Sub(100, 20);
ImplementationClass2 obj2 = new ImplementationClass2();
//Using obj2 we can call both Add and Sub method
obj2.Add(10, 20);
obj2.Sub(100, 20);
Console.ReadKey();
}
}
interface ITestInterface1
{
void Add(int num1, int num2);
}
interface ITestInterface2 : ITestInterface1
{
void Sub(int num1, int num2);
}
public class ImplementationClass1 : ITestInterface1
{
//Implement only the Add method
public void Add(int num1, int num2)
{
Console.WriteLine($"Sum of {num1} and {num2} is {num1 + num2}");
}
}
public class ImplementationClass2 : ITestInterface2
{
//Implement Both Add and Sub method
public void Add(int num1, int num2)
{
Console.WriteLine($"Sum of {num1} and {num2} is {num1 + num2}");
}
public void Sub(int num1, int num2)
{
Console.WriteLine($"Divison of {num1} and {num2} is {num1 - num2}");
}
}
}
Wyjście:
Tworzenie odniesienia do interfejsu w C#
Punkt6: Nie możemy stworzyć instancji interfejsu, ale możemy stworzyć referencję do interfejsu. Odwołanie do interfejsu będzie przechowywać instancję klasy podrzędnej. Używając referencji do interfejsu, możemy wywoływać tylko metody, które są zadeklarowane w interfejsie.
Aby lepiej zrozumieć, spójrz na poniższy przykład. W poniższym przykładzie ITestInterface1 zadeklarował jedną metodę abstrakcyjną, tj. Add. Ten interfejs jest następnie implementowany przez ImplementationClass i ta klasa zapewnia implementację metody interfejsu Add. Ponownie w tej klasie zdefiniowaliśmy nową metodę, tj. Sub. Następnie wewnątrz metody Main tworzymy referencję do interfejsu, który wskazuje na instancję klasy potomnej. Korzystając z tego odwołania, możemy wywołać tylko metodę Add i nie możemy wywołać metody Sub. Dzieje się tak, ponieważ sygnatura metody Add znajduje się wewnątrz interfejsu, ale sygnatury metody Sub nie ma w interfejsie.
Przykład zrozumienia odniesień do interfejsu w C#:
using System;
namespace AbstractClassMethods
{
class Program
{
static void Main()
{
//Creating Reference of an Interface point to the
//child class instance
ITestInterface1 obj = new ImplementationClass();
//Add method signature declared in ITestInterface1, so we can
//Invoke the Add method
obj.Add(10, 20);
//Sub method signature is not declared in ITestInterface1,
//so, we cannot Invoke the Sub method
//obj.Sub(100, 20);
Console.ReadKey();
}
}
interface ITestInterface1
{
void Add(int num1, int num2);
}
public class ImplementationClass : ITestInterface1
{
//Interface Method Implementation
public void Add(int num1, int num2)
{
Console.WriteLine($"Sum of {num1} and {num2} is {num1 + num2}");
}
//This method purely belongs to ImplementationClass
public void Sub(int num1, int num2)
{
Console.WriteLine($"Divison of {num1} and {num2} is {num1 - num2}");
}
}
}
Jasna implementacja interfejsu w C#
Kiedy każda metoda interfejsu jest implementowana oddzielnie w ramach klasy podrzędnej poprzez podanie nazwy metody wraz z nazwą interfejsu, wówczas nazywa się to Jawną implementacją interfejsu. Ale w tym przypadku, wywołując metodę, powinniśmy obowiązkowo użyć referencji interfejsu, która jest tworzona za pomocą obiektu klasy lub typu, rzutuje obiekt na odpowiedni typ interfejsu.
Możesz również zaimplementować interfejs w inny sposób, bez użycia modyfikatora dostępu publicznego. W takim przypadku musimy określić nazwę interfejsu przed nazwą metody za pomocą operatora kropki, jak pokazano w poniższym kodzie. Nazywa się to Jawną implementacją metod interfejsu.
Jak widać w powyższym kodzie, metoda Add jest implementowana przy użyciu specyfikatora dostępu publicznego, a Sub jest implementowana przy użyciu nazwy interfejsu. Metoda Sub należy do interfejsu Interface2 i dlatego poprzedzamy metodę Sub przedrostkiem Interface2, po którym następuje operator kropki. Tutaj, jeśli chcesz zaimplementować metodę Add w sposób jawny, musisz poprzedzić metodę Add przedrostkiem Interface1, ponieważ metoda Add należy do Interface1.
W tym przypadku, gdy używamy nazwy interfejsu podczas implementacji metody interfejsu, nie musimy już używać specyfikatora dostępu publicznego. Powodem jest to, że bardzo jasne jest, że elementy interfejsu są publiczne i dlatego nie wymagamy używania specyfikatora dostępu publicznego. Oto dwa sposoby implementacji elementów interfejsu w C#.
Teraz, jeśli metoda jest zaimplementowana przy użyciu specyfikatora dostępu publicznego, możesz utworzyć obiekt i wywołać go bezpośrednio. Ale jeśli metoda jest zaimplementowana przy użyciu nazwy interfejsu, to podczas wywoływania metody musimy rzutować obiekt na typ interfejsu lub możesz utworzyć referencję do interfejsu i wywołać metodę. Tak więc w naszym przypadku wywołujemy metodę Add bezpośrednio za pomocą obj1, ale podczas wywoływania metody Sub musimy dodać czcionkę obj1 do typu Interface2, ponieważ jest to instancja ImplementationClass lub możesz wywołać bezpośrednio przy użyciu zmiennej referencyjnej obj2, jak pokazano na poniższym obrazku .
Przykład implementacji jawnego interfejsu w C#
using System;
namespace AbstractClassMethods
{
class Program
{
static void Main()
{
ImplementationClass obj1 = new ImplementationClass();
//Using obj1 we can call the Add method directly because
//It is implemented using public access specifier
obj1.Add(10, 20);
//We need to typecast obj1 to ITestInterface1 to call the Sub
//method because Sub method is implemented using Interface name
((ITestInterface1)obj1).Sub(100, 20);
//We can call the method directly using the interface reference
//Typecasting is not required in this case
ITestInterface1 obj2 = new ImplementationClass();
obj2.Add(200, 50);
obj2.Sub(200, 50);
Console.ReadKey();
}
}
interface ITestInterface1
{
void Add(int num1, int num2);
void Sub(int num1, int num2);
}
public class ImplementationClass : ITestInterface1
{
//Interface Method Implementation
public void Add(int num1, int num2)
{
Console.WriteLine($"Sum of {num1} and {num2} is {num1 + num2}");
}
//This method purely belongs to ImplementationClass
void ITestInterface1.Sub(int num1, int num2)
{
Console.WriteLine($"Divison of {num1} and {num2} is {num1 - num2}");
}
}
}
Wyjście:
Najczęściej zadawane pytania podczas rozmowy kwalifikacyjnej
Co to jest interfejs w C#?
Interfejs w C# to w pełni niezaimplementowana klasa służy do deklarowania zbioru operacji obiektu. Możemy więc zdefiniować interfejs jako czystą klasę abstrakcyjną, która pozwala nam definiować tylko metody abstrakcyjne. Metoda abstrakcyjna oznacza metodę bez treści i implementacji.
Interfejs w C# to projekt klasy. Jest jak klasa abstrakcyjna, ponieważ wszystkie metody interfejsu są deklarowane jako metody abstrakcyjne. Nie może mieć treści metody i nie można jej utworzyć.
Służy do uzyskania wielu dziedziczeń, których nie można osiągnąć przez klasę. Jest używany do osiągnięcia pełnej abstrakcji, ponieważ nie może mieć treści metody.
Jego implementację musi dostarczyć klasa lub struktura. Klasa lub struktura, która implementuje interfejs, musi zapewniać implementację wszystkich metod zadeklarowanych wewnątrz interfejsu.
Jakie są różne typy dziedziczenia obsługiwane przez C#?
Klasa może być dziedziczona z innej klasy lub również z interfejsu. Dziedziczenie można więc podzielić na dwie kategorie
- Dziedziczenie implementacji
- Dziedziczenie interfejsu
Jeśli klasa dziedziczy z innej klasy, nazywamy to dziedziczeniem implementacji, a główną koncepcją dziedziczenia implementacji jest to, że klasy potomne mogą wykorzystywać członków swojej klasy nadrzędnej.
Z drugiej strony, jeśli klasa dziedziczy po interfejsie, nazywamy to dziedziczeniem interfejsu, ale dziedziczenie interfejsu nie zapewnia możliwości ponownego wykorzystania, ponieważ tutaj nie zużywamy elementów składowych rodzic pod dzieckiem. Dziecko wdraża tylko członków rodzica.
Dlaczego potrzebujemy interfejsu w C#?
Znamy koncepcję wielokrotnego dziedziczenia, w której jedna klasa pochodzi z więcej niż jednej nadklasy. Na przykład definicja taka jak
Ale ta koncepcja nie jest obsługiwana przez .NET z klasami. Ponieważ duża liczba aplikacji czasu rzeczywistego wymaga użycia wielu dziedziczeń, gdzie dziedziczymy właściwości i zachowania z kilku różnych klas. Właśnie dlatego .NET zapewnia alternatywne podejście znane jako interfejs do obsługi koncepcji wielokrotnych dziedziczeń.
Czy mogę używać publicznych specyfikatorów dostępu do metod interfejsu w C#?
Metody interfejsu .NET są domyślnie niejawnie publiczne, nawet jeśli należą do interfejsów zagnieżdżonych. Modyfikatory niepubliczne nie są prawidłowe dla metod interfejsu. Tak więc kompilator zawiedzie i ostrzeże Cię w takim przypadku. Zagnieżdżone interfejsy mogą być zadeklarowane jako chronione lub prywatne, ale nie metody interfejsu. Tak więc, jeśli spróbujesz zadeklarować metodę jako publiczny specyfikator dostępu, otrzymasz następujący błąd.
Czy interfejs może implementować klasę abstrakcyjną w C#?
Nie. W .NET interfejs nie może implementować klasy abstrakcyjnej. Interfejs może jedynie rozszerzać superinterfejs. Jednak klasa abstrakcyjna może implementować interfejs, ponieważ klasa abstrakcyjna może zawierać zarówno metody abstrakcyjne, jak i metody konkretne. Jeśli spróbujesz zaimplementować interfejs, otrzymasz następujący błąd podczas kompilacji.
Czy interfejs można zadeklarować jako zapieczętowany w C#?
Nie, nie wolno deklarować interfejsu jako zapieczętowanego; spowoduje to błąd kompilacji. Jest to decyzja dotycząca projektowania języka .NET. Typy interfejsów są przeznaczone do implementacji i mogą być rozszerzane bez ograniczeń. Jeśli spróbujesz zadeklarować interfejs jako zapieczętowany, otrzymasz następujący błąd.
Czy więcej niż jeden interfejs może zaimplementować klasę w C#?
Tak, klasa może implementować wiele interfejsów; jest to skuteczny sposób na osiągnięcie wielu dziedziczeń w C#. Ale klasa może rozszerzyć tylko jedną superklasę. Aby lepiej zrozumieć, spójrz na poniższy przykład.
Czy konieczne jest zaimplementowanie wszystkich metod interfejsu w C#?
Nie jest konieczne, aby klasa implementująca interfejs implementowała wszystkie swoje metody, ale w tym przypadku klasa musi być zadeklarowana jako abstrakcyjna. Aby lepiej zrozumieć, spójrz na poniższy kod.
Czym interfejs różni się od klasy w C#?
Interfejs różni się od klasy w następujący sposób:
- Nie możemy utworzyć instancji interfejsu.
- Interfejs nie zawiera żadnych konstruktorów, pól danych ani destruktorów itp.
- Wszystkie metody interfejsu są domyślnie abstrakcyjne i publiczne.
- Interfejs nie jest rozszerzony o klasę; jest implementowany przez klasę.
- Interfejs może rozszerzać wiele interfejsów.
Jakie są podobieństwa między interfejsem a klasą abstrakcyjną w C#?
Interfejs jest podobny do klasy abstrakcyjnej w następujący sposób
- Nie można utworzyć instancji zarówno interfejsu, jak i klasy abstrakcyjnej, co oznacza, że nie możemy utworzyć obiektu.
- Ale możemy utworzyć zmienną referencyjną zarówno dla interfejsu, jak i klasy abstrakcyjnej.
- Podklasa powinna implementować wszystkie metody abstrakcyjne.
- Oba nie mogą zostać zadeklarowane jako zapieczętowane.
Jaka jest główna różnica między interfejsem a klasą abstrakcyjną w C#?
Główna różnica, na którą należy odpowiedzieć podczas wywiadu, jest następująca. Interfejs jest w pełni niezaimplementowaną klasą służącą do deklarowania zbioru operacji obiektu. Klasa abstrakcyjna jest klasą częściowo zaimplementowaną. Realizuje niektóre operacje obiektu. Te zaimplementowane operacje są wspólne dla wszystkich podklas następnego poziomu. Pozostałe operacje są implementowane przez podklasy następnego poziomu zgodnie z ich wymaganiami.
Interfejs pozwala nam na tworzenie wielu dziedziczeń. Dlatego musimy rozpocząć projektowanie obiektu od interfejsu, podczas gdy klasa abstrakcyjna nie obsługuje wielu dziedziczeń, więc zawsze pojawia się obok interfejsu w procesie tworzenia obiektu.
Klasa abstrakcyjna:
- Jest to częściowo zaimplementowana klasa. Pozwala nam zdefiniować zarówno konkretne, jak i abstrakcyjne metody.
- Powinna być zadeklarowana jako abstrakcyjna przy użyciu słowa kluczowego abstract, metody abstrakcyjne również powinny zawierać słowo kluczowe abstract.
- Domyślny modyfikator dostępności jego członka jest prywatny i można go zmienić na dowolny inny modyfikator dostępności.
- Możliwe jest zadeklarowanie pól danych w klasie abstrakcyjnej.
- Klasa abstrakcyjna może zawierać funkcję nieabstrakcyjną.
- Klasa abstrakcyjna może dziedziczyć z innej klasy abstrakcyjnej lub z interfejsu.
- Klasa abstrakcyjna nie może być używana do implementacji wielu dziedziczeń.
- Członkowie klasy abstrakcyjnej mogą mieć specyfikatory dostępu.
Interfejs:
- Jest to klasa w pełni niezaimplementowana. Pozwala nam to na zdefiniowanie tylko abstrakcyjnych metod.
- Należy go utworzyć za pomocą interfejsu słów kluczowych. Zadeklarowanie jego metod jako abstrakcyjnych jest opcjonalne, ponieważ domyślnie metody interfejsu są abstrakcyjne. Kompilator umieszcza abstrakcyjne słowa kluczowe w czasie kompilacji programu.
- Domyślny modyfikator dostępności członka jest publiczny i nie można go zmienić.
- Nie można zadeklarować żadnych pól danych w interfejsie.
- Interfejs nie może zawierać funkcji nieabstrakcyjnych.
- Interfejs może dziedziczyć tylko z innych interfejsów, ale nie może dziedziczyć z klasy abstrakcyjnej.
- Interfejs może być użyty do implementacji wielu dziedziczeń.
- Członkowie interfejsu nie mogą mieć specyfikatorów dostępu.
Jakie są zalety korzystania z interfejsu w C#?
Oto zalety korzystania z interfejsu w aplikacji C#.
- Służy do uzyskania luźnego połączenia.
- Służy do osiągnięcia całkowitej abstrakcji.
- Aby osiągnąć programowanie oparte na komponentach
- Aby osiągnąć wielokrotne dziedziczenie i abstrakcję.
- Interfejsy dodają do aplikacji architekturę typu plug-and-play.
W następnym artykule omówię dziedziczenie wielokrotne w C# z przykładami. W tym artykule staram się wyjaśnić Interfejs w C# z przykładami. Mam nadzieję, że ten artykuł pomoże Ci w Twojej potrzebie. Chciałbym otrzymać twoją opinię. Prześlij swoją opinię, pytanie lub komentarze dotyczące tego interfejsu w języku C# w artykule Przykłady.