I forum Ricerca FAQ
Fai una domanda
Ultimo messaggio 1 2
alev79
alev79
il 7 febbraio 2008 alle 11:05
15 messaggi dal 07 novembre 2007
Salve a tutti!
Ecco la mia domanda:
è possibile in c# implementare un'interfaccia in una classe che deriva da una superclasse?

Esempio:

interface Interfaccia
class abstract Superclasse:Interfaccia
class Classe1:Superclasse:Interfaccia
class Classe2:Superclasse:Interfaccia


Questo perchè non rischio di dimenticare l'override di alcuni metodi utilizzando l'interfaccia, ma con la Superclasse ottengo direttamente alcuni metodi di utilità generali.
Oltretutto, se un metodo è implementato nella superclasse, per l'interfaccia esiste anche nella sottoclasse?

Grazie per l'attenzione, Alessandro
RispondiQuoting
nostromo
nostromo
il 7 febbraio 2008 alle 11:14
14.823 messaggi dal 18 febbraio 2004
Contributi
www.soluzioni4d.it | Blog
è possibile, ma non mi è chiara l'ultima tua domanda:

Oltretutto, se un metodo è implementato nella superclasse, per l'interfaccia esiste anche nella sottoclasse?


ciao marco
Chi parla senza modestia troverà difficile rendere buone le proprie parole.
Confucio

http://nostromo.spaces.live.com/default.aspx
RispondiQuoting
alev79
alev79
il 7 febbraio 2008 alle 11:23
15 messaggi dal 07 novembre 2007
Grazie prima di tutto!
La sintassi è sempre con i due punti? bisogna mettere prima la superclasse o l'interfaccia?
Intendevo dire che se implemento uno dei metodi previsti dall'interfaccia nella superclasse che la utilizza e non lo metto poi nella sottoclasse che utilizza anche lei l'interfaccia, ottengo u'errore di compilazione perche la sottoclasse non rispetta il contratto o il compilatore trova comunque il metodo nella superclasse e lo deriva dandomi l'ok?
Ciao e grazie ancora
RispondiQuoting
nostromo
nostromo
il 7 febbraio 2008 alle 11:32
14.823 messaggi dal 18 febbraio 2004
Contributi
www.soluzioni4d.it | Blog
la sintassi è la segunete:

class abstract Superclasse:Interfaccia

class Classe1:Superclasse,Interfaccia

ecc ecc

ma in class1 non è necessario( è comunque corretto) aggiungere di nuovo l'interfaccia in quanto è già implementata dalla SuperClasse, che più che super, sarebbe secondo me, più corretto chiamare ClasseBase.

l'aggiungi solo se vorresti reimplementare i metodi o renderli visibili perche magari nella SuperClasse (ClasseBase) sono stati implementati in modo esplicito

per approfondire di consiglio di dare un occhiata alla guida su C# che trovi sul sito msdn.

ciao marco
Chi parla senza modestia troverà difficile rendere buone le proprie parole.
Confucio

http://nostromo.spaces.live.com/default.aspx
RispondiQuoting
m.casati
m.casati
il 7 febbraio 2008 alle 11:45
3.083 messaggi dal 13 giugno 2001
Contributi
mcasati.com | Blog
Non ho capito bene quello che chiedi ma mi pare tu abbia le idee un po' confuse per quanto riguarda interfacce, classi astratte e classi.
Cerco di chiarire qualche concetto base di OOP con un semplice esempio; supponiamo di avere la seguente interfaccia con 3 metodi:

public interface IMyInterface
{
 string Method1();
 string Method2();
 string Method3();
}


Ora supponiamo di avere la necessità di creare 2 classi che abbiano lo stesso comportamente (identica implementazione) del metodo 1, un comportamento predefinito (ma overridable) del metodo 2 e un'implementazione specifica del metodo 3 (l'esempio mi pare copra tutte le casistiche possibili, giusto?)
A questo punto l'ideale è creare una classe base astratta che:
- implementi in modo definitivo Method1
- implementi Method2 ma lo renda sovrascrivibile
- non implementi Method3 (abstract), lasciando l'implementazione alle classi concrete
La classe astratta sarà:
public abstract class MyBaseClass : IMyInterface
{
 public string Method1()
 {
  return "M1 from BaseClass";
  // (le classi per fare l'override dovranno usare "new")
 }
 public virtual string Method2()
 {
  return "M2 from BaseClass";
  // (è "virtual", per cui le classi potranno farne l'override)
 }
 public abstract string Method3();
 // (è "abstract ", per cui le classi dovranno farne l'override)
}


Ora le classi, derivando da MyBaseClass implementeranno di conseguenza anche l'interfaccia IMyInterface:
public class MyClass1 : MyBaseClass 
{
 public override string Method3()
 {
  return "M3 from Class1";
 }
}



public class MyClass2 : MyBaseClass 
{
 public override string Method2()
 {
  return "M2 from Class2";
 }
 public override string Method3()
 {
  return "M3 from Class2";
 }
}


Supponiamo di volere in una terza classe reimplementare anche Method1:

public class MyClass3 : MyBaseClass
{
 public new string Method1()
 {
  return "M1 from Class3";
 }
 public override string Method2()
 {
  return "M2 from Class3";
 }
 public override string Method3()
 {
  return "M3 from Class3";
 }
}


Detto questo possiamo avere:

MyClass1 c1 = new MyClass1();            
Console.WriteLine(c1.Method1());
Console.WriteLine(c1.Method2());
Console.WriteLine(c1.Method3());


Che produrrà:

M1 from BaseClass
M2 from BaseClass
M3 from Class1


Oppure:

MyClass2 c2 = new MyClass2();            
Console.WriteLine(c2.Method1());
Console.WriteLine(c2.Method2());
Console.WriteLine(c2.Method3());


Che produrrà:

M1 from BaseClass
M2 from Class2
M3 from Class2


E ancora:

MyClass3 c3 = new MyClass3();            
Console.WriteLine(c3.Method1());
Console.WriteLine(c3.Method2());
Console.WriteLine(c3.Method3());


Che produrrà:

M1 from Class3
M2 from Class3
M3 from Class3


Si noti però che:

IMyInterface c = new MyClass3();            
Console.WriteLine(c.Method1());
Console.WriteLine(c.Method2());
Console.WriteLine(c.Method3());


Produrrà:

M1 from BaseClass
M2 from Class3
M3 from Class3


HTH
Matteo Casati
GURU4.net
RispondiQuoting
alev79
alev79
il 7 febbraio 2008 alle 11:57
15 messaggi dal 07 novembre 2007
Grazie a tutti, adesso è tutto + chiaro, soprattutto l'override forzato del metodo con abstract che mi era sfuggito!
RispondiQuoting
nostromo
nostromo
il 7 febbraio 2008 alle 12:28
14.823 messaggi dal 18 febbraio 2004
Contributi
www.soluzioni4d.it | Blog
aggiungo un altro esempio all'esaurientissima risposta di Matteo
la seguente classe inplementa l'interfaccia in modo esplicito, ovvero i suoi

metodi saranno richiamabili solo eseguendo un cast
public class ShyClass : IMyInterface
{
    protected string _string1 = "1";
    protected string _string2 = "2";
    protected string _string3 = "3";

    #region IMyInterface Members
    
    string IMyInterface.Method1()
    {
        return _string1;
    }

    string IMyInterface.Method2()
    {
        return _string2;
    }

    string IMyInterface.Method3()
    {
        return _string3;
    }

    #endregion
}

mettiamo ti venga annoia di fare tutte le volte un cast, o magari sono cambiati l'ambiti d'utilizzo:

public class ExtrovertClass : ShyClass, IMyInterface
{

    #region IMyInterface Members

    public string Method1()
    {
        return _string1;
    }

    public string Method2()
    {
        return _string2;
    }

    public string Method3()
    {
        return _string3;
    }

    #endregion
}


nella precedente classe i membri sono "subito" visibili, ecco un esempio dell'utlizzo:

((IMyInterface)_shyClass).Method1()


_extrovertClass.Method1()


ciao marco
Modificato da nostromo il 07 febbraio 2008 12.30 -
Chi parla senza modestia troverà difficile rendere buone le proprie parole.
Confucio

http://nostromo.spaces.live.com/default.aspx
RispondiQuoting
m.casati
m.casati
il 7 febbraio 2008 alle 14:06
3.083 messaggi dal 13 giugno 2001
Contributi
mcasati.com | Blog
nostromo ha scritto:
aggiungo un altro esempio


Ecco, qualcosa me l'ero dimenticato: l'implementazione esplicita!
Ora il primo capitolo del libro "Introducing OOP" scritto a 4 mani da me e Marco è pronto
Matteo Casati
GURU4.net
RispondiQuoting
1 2

Torna al forum | Feed RSS

ASPItalia.com non è responsabile per il contenuto dei messaggi presenti su questo servizio, non avendo nessun controllo sui messaggi postati nei propri forum, che rappresentano l'espressione del pensiero degli autori.