[C#] Implementare una interfaccia

[Roby_72]

Salve come si fa ad implementare una classe di una interfaccia?
Spiego meglio, nella creazione di una classe di una interfaccia devo implementare determinati metodi ma gli altri dovrei lasciarli così come sono.
Come faccio a richiamare dei metodi senza "toccarli"?

Possibile avere un esempio?

Roby

[rsdpzed]

non deve essere un interfaccia ma una classe base con metodi virtual, altrimenti non puoi farlo.
Per esempo in questo caso puoi sceglere di non implementare pluto.

public class A
{
    public virtual void pippo()
    {}
    public virtual void pluto()
    {}
}

public class B : A
{
    public override void pippo()
    {
        //implementi
    }

    //posso anche non implementare pluto
}

Ma se quelli fossero stati metodi abstract invece che virtual allora saresti stato costretto ad implementarli tutti, stesso dicasi se A fosse stata una interfaccia.

[frank2tek]

Ovviamene come prima cosa devi creare l'inerfaccia
Faccio un esempio : crea nel tuo progetto un file di nome IMyInterface.cs ( o dai un nome a piacere) e crea i metodi

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

/// <summary>
/// Summary description for MyInterface
/// </summary>
public interface IMyInterface
{
    string HelloWorld(string message);
    int Somma(int x, int y);
}

Una volta fatto questo creare un nuovo file di nome ImplementInterface ( ( o dai un nome a piacere).
A questo punto ti trovi in questa condizione e cioè con una classe vuota :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

public class ImplementInterface
{
	
}

Adesso estendi la classe con la tua interfaccia in questo modo

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

public class ImplementInterface : IMyInterface
{
	
}

Adesso ti basta evidenziare con il mous la parola IMyInterface e premendo il tasto destro
del mouse ti compare un menù. In alto dovresti trovare una voce "Implement Interface".
Clicca e magicamente vedrai i metodi da implementare nella tua classe. Ti troverai quindi in questa situazione :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

/// <summary>
/// Summary description for ImplementInterface
/// </summary>
public class ImplementInterface : IMyInterface
{
	public ImplementInterface()
	{
		
	}

    public string HelloWorld(string message)
    {
        throw new NotImplementedException();
    }

    public int Somma(int x, int y)
    {
        throw new NotImplementedException();
    }
}

Come puoi notare ora nella classe hai i metodi pronti per essere implementati
Un esempio di implementazione :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

/// <summary>
/// Summary description for ImplementInterface
/// </summary>
public class ImplementInterface : IMyInterface
{
	public ImplementInterface()
	{
		
	}

    public string HelloWorld(string message)
    {
        return message;
    }

    public int Somma(int x, int y)
    {
        int somma = x + y;
        return somma;
    }
}

[Roby_72]

Grazie, utilissimo (poi spiegherò a che mi serve... )
E' possibile inserire nuove funzioni non previste dall’interfaccia? Se si come?

Roby

[Gluck74]

ciao a tutti,
come richesto da Roby_72, la necessità è di "implementare" solo alcuni metodi;
viene da tradurre con "riscrivere" solo alcuni metodi e lasciare come sono gli altri.

quindi potrebbe essere giusta la soluzione di rsdpzed, che definisce una classe base virtual, dove vengono implementati subito i metodi, ed è possibile "riscriverne" alcuni in un'altra classe che implementa/astrae/specializza la classe base.

Usando una interfaccia invecie, che per definizione contiene solo la definizione, non è possibile implementare solo alcuni metodi ed altri no, vanno implementati tutti.
Quindi potrebbe essere una buona soluzione creare una classe base che implementa l'interfaccia, quindi "riscrivere" secondo necessità creando una classe specifica che eredita dall'implementazione base.
La soluzione di frank2tek è più complessa, ma sicuramente più malleabile per il futuro.
Per l'occasione consiglio di dare una piccola lettura ai Pattern "strutturali"

Tutto dipende quindi dalla complessita e dal target finale del tuo progetto.
ciao

[frank2tek]

Originariamente inviato da Roby_72
Grazie, utilissimo (poi spiegherò a che mi serve... )
E' possibile inserire nuove funzioni non previste dall’interfaccia? Se si come?

Roby

Ovviamente ti riferisci di inserire nuove funzioni nella classe che implementa l'interfaccia.
Certo che si può. Oltre ai metodi implementati per l'interfaccia puoi aggiungere tutti i metodi che vuoi. Le interfacce hanno prorpio lo scopo di aiutare ad estendere le classi oltre ai metodi che già implementano da se.
Riprendendo l'esempio che ti avevo fatto per esempio puoi aggiungere questa funzione :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

/// <summary>
/// Summary description for ImplementInterface
/// </summary>
public class ImplementInterface : IMyInterface
{
   // Costruttore vuoto
   public ImplementInterface()
   {
		
   }

    // Implementazione metodo HelloWorld dell'interfaccia
    public string HelloWorld(string message)
    {
        return message;
    }

    // Implementazione metodo Somma dell'interfaccia
    public int Somma(int x, int y)
    {
        int somma = x + y;
        return somma;
    }

    // Metodo che appartiene solo alla classe ma non all'interfaccia
    public string MetodoClasse()
    {
          return "Sono un metodo della sola classe";
    }
}

Come puo notare il metodo "MetodoClasse()" non è dichiarata nell'interfaccia. Qundi nela tua classe ch estende l'interfaccia puoi aggiungere tutti i metodi che vuoi , oltre a quelli previsti appunto dall'interfaccia.

[djciko]

Per completezza Roby, diciamo anche che in genere si dice che implementare una interfaccia è come stipulare un contratto.

Questo articolo:
http://www.informaticando.net/post/D...nterfacce.aspx (spostato non si sa dove)

...spiega abbastanza chiaramente anche la sottile differenza fra Interfacce e Classi astratte in questo modo:

Quando usare le classi astratte e quando le Interfacce

Come abbiamo visto, sia le classi astratte che le interfacce rappresentano un modello, un contratto che la classe derivata deve rispettare implementando i metodi e le proprietà definite nel tipo base, ma allora al di là delle piccole differenze di sintassi qual'è la sostanziale differenza tra classi astratte pure ed interfacce, come capire quando usare l'una e quando le altre? La risposta migliore è a seconda del tipo di contratto che la classe derivata deve implementare col tipo base, le classi astratte pure definiscono un legame più forte con la classe derivata poichè ne rappresentano il tipo base definendone il comportamento comune (vedi l'es. della classe mammifero). Mentre le interfacce possono essere usate per definire un modello generico, che implementa un comportamento comune a classi di vario genere e natura, ad esempio il metodo calc dell'iiterfaccia ICalc potrebbe essere comune sia ad un'istanza di una classe calcolatrice che a quello di un'istanza punto geometrico.

Se mi permettete una definizione personale, direi che le classi astratte pure definiscono un contratto di tipo verticale (dedicato) con le instanze delle classi figlie, mentre le interfacce rappresentano di più un contratto di tipo orizzontale (generico) con gli oggetti che le implementeranno.

[Gluck74]

a parte la definizione vericale e orizzontale, che non riesco a "visualizzare",
mi pare una definizione precisa e facila da capire,

complimenti all'autore

[djciko]

Forse visualizza una "discendenza" in caso di astrazione. Mammifero > Uomo, da qui "verticale"

[Gluck74]

ok, ora ho visualizzato...