INTERFACE
Le interface in c sharp sono come le classi dei reference types. Le interface o interfacce sono simili alle classi astratte ossia contengono la definizione di metodi, property e altri membri che non sono però implementati. Il C# non supporta l’ereditarietà multipla come altri linguaggi come ad esempio Pyton, C++ ma si può derivare solo una classe. Tuttavia il linguaggio ci consente di implementare più interface.
IMPLEMENTARE UNA INTERFACCIA
Ma cosa significa implementare una interfaccia? Una classe che dichiara di implementare una interface è tenuta obbligatoriamente ad implementare tutti i membri, property,metodi ed eventi che sono stati definiti in essa. E’ come se si stabilisse una sorta di contratto tra la classe che implementa l’interfaccia e l’interfaccia stessa. Le interfacce supportano l’ereditarietà multipla. Si può ottenere un reference alla interface partendo dalla classe che la implementa usando l’operatore as.
DICHIARARE UNA INTERFACE
using System;
namespace Interface
{
class Program
{
static void Main(string[] args)
{
}
}
public interface IMyInterface1
{
void MyMethod1();
string MyProperty1 {get;set;}
}
public interface IMyInterface2
{
void MyMethod2();
string MyProperty2 {get;set;}
}
public class MyClassA : IMyInterface1
{
public void MyMethod1()
{
Console.WriteLine("Sto implmentando MyMethod1() dell 'interfaccia IMyInteface1.");
}
public string MyProperty1{get;set;}
}
public class MyClassB
{
public void MyMethod()
{
Console.WriteLine("Sto eseguendo MyMethod() di MyClassB.");
}
}
}
Come vedi la dichiarazione di una interface in c sharp è simile alla dichiarazione di una classe solo che al posto della keyword class va messa la keyword interface. Per convenzione il nome di una interface inizia con la lettera maiuscola I. Tutti i membri di una interface sono per definizione public, non si possono dichiarare metodi abstract. La classe che implementa l’interfaccia MyClassA è tenuta a fornire una implementazione concreta dei membri definiti in essa. Una classe può derivare da una sola superclasse, e da una o più interfacce, la dichiarazione della Superclasse deve essere la prima, eventuali implementazioni di interface devono essere separate con la virgola. Vediamo un esempio di codice.
using System;
namespace Interface
{
class Program
{
static void Main(string[] args)
{
MyClassA a = new MyClassA();
a.MyMethod();
a.MyMethod1();
a.MyProperty2 = "Corso C#.";
Console.WriteLine(a.MyProperty2);
}
}
public interface IMyInterface1
{
void MyMethod1();
string MyProperty1 {get;set;}
}
public interface IMyInterface2
{
void MyMethod2();
string MyProperty2 {get;set;}
}
public class MyClassA : MyClassB, IMyInterface1, IMyInterface2
{
public void MyMethod1()
{
Console.WriteLine("Sto implmentando MyMethod1() dell 'interfaccia IMyInteface1");
}
public string MyProperty1{get;set;}
public void MyMethod2()
{
Console.WriteLine("Sto implmentando MyMethod2() dell 'interfaccia IMyInteface2.");
}
public string MyProperty2{get;set;}
}
public class MyClassB
{
public void MyMethod()
{
Console.WriteLine("Sto eseguendo MyMethod() di MyClassB.");
}
}
}
UTILIZZARE LE INTERFACE
using System;
namespace Interface
{
class Program
{
static void Main(string[] args)
{
MyClassA a = new MyClassA();
IMyInterface i = a as IMyInterface;
((MyClassA)i).MyMethod2();//PER INVOCARE I METODI APPARTENENTI SOLO
//A MyClassA OCCORRE FARE IL CASTING.
MyClassB.MyMethod(i);
}
}
public interface IMyInterface
{
void MyMethod();
}
public class MyClassA : IMyInterface
{
public void MyMethod()
{
Console.WriteLine("MyMethod() di MyClassA.");
}
public void MyMethod2()
{
Console.WriteLine("MyMethod2() di MyClassA.");
}
}
public class MyClassB
{
public static void MyMethod(IMyInterface myInterface)
{
myInterface.MyMethod();
}
}
}
Abbiamo detto che si può ottenere un reference alle interface partendo dalle classi che la implementano. Questo lo si può fare in quanto MyClassA implementa l’interfaccia IMyInterface. Un’altra importante implicazione ci consente di disaccoppiare fortemente le classi nel codice, in questo caso MyClassB non contiene riferimenti a MyClassA in quanto viene usata l’interfaccia come parametro del metodo.
IN SINTESI LE CLASSI ASTRATTE
A questo punto può sorgere una domanda: quando usare le interfacce e quando, invece, utilizzare le classi astratte? Abbiamo detto che entrambe definiscono un contratto per le classi alle quali sono associate, dato che, internamente, non contengono implementazioni, ma solo dichiarazioni. Peraltro le classi astratte pure forniscono un tipo di contratto “più forte”, in quanto, oltre a definire i comportamenti per le classi associate, ne rappresentano anche il tipo base.
IN SINTESI LE INTERFACE
Diversamente le interfacce permettono una maggiore flessibilità, in quanto sono tipi indipendenti e trasversali rispetto alla gerarchia delle classi definita tramite i legami di ereditarietà. L’uso delle interfacce è quindi da preferire nel caso in cui vogliamo definire contratti di natura generale, che possano essere usati indipendentemente dai legami di ereditarietà e che non impongano comportamenti specifici ed esclusivi. I tipi come le interfacce e le classi astratte, che hanno una valenza soprattutto dichiarativa, vengono genericamente identificati come tipi astratti, in contrapposizione alle classi che contengono le implementazioni vere e proprie, che vengono denotate come tipi concreti.
APPROFONDIMENTO SULLE INTERFACE
In C#, un’interfaccia è un contratto che definisce un gruppo di metodi, proprietà, eventi o indicizzatori che una classe o una struct deve implementare. Le interfacce non contengono implementazioni di metodi (fino a C# 8.0), ma solo le firme dei metodi.
Ecco alcuni punti chiave sulle interfacce in C#:
1. Definizione di un’interfaccia:
Le interfacce vengono definite utilizzando la parola chiave interface. Ecco un esempio di come definire un’interfaccia:
public interface IVehicle
{
void StartEngine();
void StopEngine();
int Wheels { get; }
}
2. Implementazione di un’interfaccia:
Una classe che implementa un’interfaccia deve fornire l’implementazione per tutti i membri dell’interfaccia. Ecco un esempio:
public class Car : IVehicle
{
public int Wheels { get; private set; }
public Car()
{
Wheels = 4;
}
public void StartEngine()
{
Console.WriteLine(“Engine started“);
}
public void StopEngine()
{
Console.WriteLine(“Engine stopped“);
}
}
3. Ereditarietà delle interfacce:
Un’interfaccia può ereditare da una o più interfacce. Ecco un esempio:
public interface IElectricVehicle : IVehicle
{
void ChargeBattery();
}
4. Utilizzo delle interfacce:
Le interfacce sono spesso utilizzate per la dipendenza e l’iniezione di dipendenze, la programmazione orientata agli oggetti e il polymorphism. Ecco un esempio di come utilizzare un’interfaccia:
public class Garage
{
private IVehicle _vehicle;
public Garage(IVehicle vehicle)
{
_vehicle = vehicle;
}
public void ServiceVehicle()
{
_vehicle.StartEngine();
// Perform service
_vehicle.StopEngine();
}
}
IVehicle myCar = new Car();
Garage myGarage = new Garage(myCar);
myGarage.ServiceVehicle();
Lascia un commento