Un'interface (interfaccia) è semplicemente una collezione di metodi astratti. Il punto chiave è che un'interface non implementa codice e quindi non può venire istanziata. E' una raccolta di proprietà, metodi, eventi, indicizzatori che definiscono un set invariante di comportamenti che una classe deve implementare.

In C# un'interface si definisce ad esempio così :

public interface IStringList
{
void Add(string s); // Un metodo
int Count {get; } // Una proprietà di sola lettura
event EventHandler Changed;// Un evento
string this[int index] {get; set;} // Un indicizzatore
}

Le interface non contengono nessun modificatore in quando essendo i loro metodi tutti pubblici e astratti, di fatto sono implicitamente virtuali.

La I con cui iniziano i nomi delle interfacce è solo una convenzione, non è obbligatoria.

La proprietà Count è fissata come read-only per abilitare la scrittura si può usare {get; set;}.

La forza delle interface giace nel fatto che che definiscono comportamenti, così ad esempio implementando l'interfaccia IComparable si ottiene un sistema per altre classi di comparare due istanze di una classe.

Una volta che si comprende il comportamento definito da una interfaccia, si sa come lavorare con tutte le classi che implementano quella interfaccia.

Capendo le interfacce definite nel .NET Framework, si possono controllare tutte le classi che implementano quelle interfacce, ed utilizzandole nel codice si integrano le proprie classi con le librerie di classi del Framework, rendendole più potenti.

Consideriamo ad esempio di voler definire un tipo' Point'. Questo tipo sarebbe derivato da System.Object e tutti gli oggetti 'Point' rispecchierebbero il normale comportamento di ogni oggetto. Ora supponiamo di voler creare un array di oggetti Point e di voler essere in grado di ordinari in base alla distanza dei punti che rappresentano dall'origine delle coordinate (0,0).

Per fare questo bisogna rendere gli oggetti Point comparabili l'uno con l'altro facendo in modo che Point implementi l'interfaccia System.Icomparable, definita nella libreria delle classi.

I tipi che implementano questa interface acquisiscono l'abilità di comparare le proprie istanze con altri oggetti:

using System;

class Point : IComparable {
   public Int32 x, y;

   public Point(Int32 x, Int32 y) {
      this.x = x;
      this.y = y;
   }

   // CompareTo è definita dall'interface IComparable
   public Int32 CompareTo(Object other) {
      Point p = (Point) other;

      Double thisDistanceFromOrigin = Math.Sqrt(x * x + y * y);
      Double otherDistanceFromOrigin = Math.Sqrt(p.x * p.x + p.y * p.y);

      return(Math.Sign(thisDistanceFromOrigin - otherDistanceFromOrigin));
   }

   public override String ToString() {
      return(String.Format("({0}, {1})", x, y));
   }
}


class App {
   static void Main() {
      Point[] points = new Point[5];
      points[0] = new Point(2, 2);
      points[1] = new Point(3, 2);
      points[2] = new Point(2, 3);
      points[3] = new Point(7, 8);
      points[4] = new Point(0, 1);

      Array.Sort(points);

      // Mostra tutti gli elementi dell'array
      for (Int32 i = 0; i < points.Length; i++) 
         Console.WriteLine("Point {0}: {1}", i, points[i]);

      Console.Write("Press Enter to close window...");
      Console.Read();
   }
}

Fonti:

Documentazione .NET Framework SDK

C# Developer

.::^top^::.