C#-interface

In deze tutorial leren we over de C#-interface aan de hand van voorbeelden.

In C# is een interface vergelijkbaar met een abstracte klasse. In tegenstelling tot abstracte klassen zijn alle methoden van een interface echter volledig abstract (methode zonder hoofdtekst).

We gebruiken de interface trefwoord om een ​​interface te maken. Bijvoorbeeld,

interface IPolygon {

  // method without body
  void calculateArea();
}

Hier,

• IPolygon is de naam van de interface.
• Volgens afspraak begint de interface met I, zodat we hem kunnen identificeren door alleen de naam te zien.
• We kunnen geen toegangsmodifiers gebruiken binnen een interface.
• Alle leden van een interface zijn standaard openbaar.
• Een interface staat geen velden toe.

Een interface implementeren

We kunnen geen objecten van een interface maken. Om een ​​interface te gebruiken, moeten andere klassen deze implementeren. Hetzelfde als in C# Inheritance, we gebruiken : symbool om een ​​interface te implementeren. Bijvoorbeeld,

using System;
namespace CsharpInterface {

  interface IPolygon {
    // method without body
    void calculateArea(int l, int b);

  }

  class Rectangle : IPolygon {

    // implementation of methods inside interface
    public void calculateArea(int l, int b) {

      int area = l * b;
      Console.WriteLine("Area of Rectangle: " + area);
    }
  }

  class Program {
    static void Main (string [] args) {

      Rectangle r1 = new Rectangle();
    
      r1.calculateArea(100, 200);

    }
  }
}

Uitvoer

Area of Rectangle: 20000

In het bovenstaande voorbeeld hebben we een interface gemaakt met de naam IPolygon . De interface bevat een methode calculateArea(int a, int b) zonder implementatie.

Hier, de Rechthoek class implementeert IPolygon . En, zorgt voor de implementatie van de calculateArea(int a, int b) methode.

Opmerking :We moeten zorgen voor de implementatie van alle interfacemethoden binnen de klasse die het implementeert.

Meerdere interfaces implementeren

In tegenstelling tot overerving kan een klasse meerdere interfaces implementeren. Bijvoorbeeld,

using System;
namespace CsharpInterface {

  interface IPolygon {
    // method without body
    void calculateArea(int a, int b);

  }

  interface IColor {

    void getColor();
  }
   
  // implements two interface
  class Rectangle : IPolygon, IColor {

    // implementation of IPolygon interface
    public void calculateArea(int a, int b) {

      int area = a * b;
      Console.WriteLine("Area of Rectangle: " + area);
    }

    // implementation of IColor interface
    public void getColor() {

      Console.WriteLine("Red Rectangle");
            
    }
  }

  class Program {
    static void Main (string [] args) {

      Rectangle r1 = new Rectangle();
    
      r1.calculateArea(100, 200);
      r1.getColor();
    }
  }
}

Uitvoer

Area of Rectangle: 20000
Red Rectangle

In het bovenstaande voorbeeld hebben we twee interfaces, IPolygon en IColor .

class Rectangle : IPolygon, IColor {
  …
}

We hebben beide interfaces geïmplementeerd in de Rechthoek klasse gescheiden door , .

Nu, Rectangle moet de methode van beide interfaces implementeren.

Referentievariabele van een interface gebruiken

We kunnen de referentievariabele van een interface gebruiken. Bijvoorbeeld,

using System;
namespace CsharpInterface {

  interface IPolygon {
    // method without body
    void calculateArea(int l, int b);

  }

  class Rectangle : IPolygon {

    // implementation of methods inside interface
    public void calculateArea(int l, int b) {

      int area = l * b;
      Console.WriteLine("Area of Rectangle: " + area);
    }
  }

  class Program {
    static void Main (string [] args) {
       
      // using reference variable of interface
      IPolygon r1 = new Rectangle();
    
      r1.calculateArea(100, 200);
    }
  }
}

Uitvoer

Area of Rectangle: 20000

In het bovenstaande voorbeeld hebben we een interface gemaakt met de naam IPolygon . De interface bevat een methode calculateArea(int l, int b) zonder implementatie.

IPolygon r1 = new Rectangle();

Merk op dat we de referentievariabele van interface IPolygon . hebben gebruikt . Het verwijst naar de klasse Rechthoek die het implementeert.

Hoewel we geen objecten van een interface kunnen maken, kunnen we nog steeds de referentievariabele van de interface gebruiken die verwijst naar de geïmplementeerde klasse.

Praktisch voorbeeld van interface

Laten we een meer praktisch voorbeeld van de C#-interface bekijken.

using System;
namespace CsharpInterface {

  interface IPolygon {
    // method without body
    void calculateArea();

  }   
  // implements interface
  class Rectangle : IPolygon {

    // implementation of IPolygon interface
    public void calculateArea() {
      
      int l = 30;
      int b = 90;
      int area = l * b;
      Console.WriteLine("Area of Rectangle: " + area);
    }
  }

  class Square : IPolygon {

    // implementation of IPolygon interface
    public void calculateArea() {
      
      int l = 30;
      int area = l * l;
      Console.WriteLine("Area of Square: " + area);
    }
  }

  class Program {
    static void Main (string [] args) {

      Rectangle r1 = new Rectangle();  
      r1.calculateArea();

      Square s1 = new Square();  
      s1.calculateArea();
    }
  }
}

Uitvoer

Area of Rectangle: 2700
Area of Square: 900

In het bovenstaande programma hebben we een interface gemaakt met de naam IPolygon . Het heeft een abstracte methode calculateArea() .

We hebben twee klassen Vierkant en Rechthoek die de IPolygon . implementeren koppel.

De regel voor het berekenen van de oppervlakte is voor elke veelhoek anders. Vandaar, calculateArea() is inbegrepen zonder implementatie.

Elke klasse die IPolygon . implementeert moet een implementatie van calculateArea() . bieden . Vandaar de implementatie van de methode in de klasse Rectangle is onafhankelijk van de methode in de klasse Square .

Voordelen van de C#-interface

Nu we weten wat interfaces zijn, gaan we eens kijken waarom interfaces worden gebruikt in C#.

• Net als bij abstracte klassen, helpen interfaces ons om abstractie in C# te bereiken .
  
  Hier de methode calculateArea() binnen de interface, heeft geen lichaam. Het verbergt dus de implementatiedetails van de methode.

• Interfaces bieden specificaties dat een klasse (die het implementeert) moet volgen.
  
  In ons vorige voorbeeld hebben we calculateArea() . gebruikt als een specificatie in de interface IPolygon . Dit is hetzelfde als het instellen van een regel dat we de oppervlakte van elke veelhoek moeten berekenen.
  
  Nu elke klasse die de IPolygon . implementeert interface moet een implementatie bieden voor de calculateArea() methode.

• Interfaces worden gebruikt om meervoudige overerving in C# te realiseren.

• Interfaces zorgen voor losse koppeling (geen of het minste effect hebben op andere delen van de code wanneer we een deel van een code wijzigen).
  
  Als we in ons vorige voorbeeld de implementatie van calculateArea() . wijzigen op het Vierkant klasse heeft dit geen invloed op de Rechthoek klas.