programmazione orientata agli oggetti con c# e vb.net nel.net framework silvano coriani...
TRANSCRIPT
Programmazione orientata Programmazione orientata agli oggetti con C# e agli oggetti con C# e
VB.NET nel .NET FrameworkVB.NET nel .NET Framework
Silvano Coriani Silvano Coriani ([email protected])([email protected])
Academic Developer EvangelistAcademic Developer EvangelistDeveloper & Platform EvangelismDeveloper & Platform EvangelismMicrosoftMicrosoft
MMicrosoft icrosoft CCertified ertified TTrainerrainer
MMicrosoft icrosoft CCertified ertified SSolution olution DDevelopereveloper
MMicrosoft icrosoft CCertified ertified AApplication pplication DDevelopereveloper
MMicrosoft icrosoft CCertified ertified SSystem ystem EEngineer + ngineer + IInternetnternet
MMicrosoft icrosoft CCertified ertified DDataataBBase ase AAdministratordministrator
AgendaAgenda• I concetti fondamentaliI concetti fondamentali
• EreditarietàEreditarietà• PolimorfismoPolimorfismo• IncapsulamentoIncapsulamento• AggregazioneAggregazione
• L’implementazione nel .NET FrameworkL’implementazione nel .NET Framework• Classi base e derivateClassi base e derivate• I metodi virtualiI metodi virtuali• Classi astratte e interfacceClassi astratte e interfacce• Le keyword di C# e VB.NETLe keyword di C# e VB.NET
Object Oriented ProgrammingObject Oriented Programming• In un ambiente OOP deve essere possibile In un ambiente OOP deve essere possibile
applicare i seguenti concetti: applicare i seguenti concetti: • AstrazioneAstrazione
• Sviluppare unSviluppare un’’applicazione racchiudendone la complessità applicazione racchiudendone la complessità allall’’interno di moduli di classe, che ne implementano il interno di moduli di classe, che ne implementano il significatosignificato
• IncapsulamentoIncapsulamento• Proibire ad altri oggetti di manipolare direttamente dati, o Proibire ad altri oggetti di manipolare direttamente dati, o
procedure, implementate allprocedure, implementate all’’interno dellinterno dell’’oggetto stessooggetto stesso• Classe come Classe come ““scatola nerascatola nera”” per l per l’’utilizzatoreutilizzatore
• PolimorfismoPolimorfismo• Possibilità per classi diverse di implementare lo stesso Possibilità per classi diverse di implementare lo stesso ““comportamentocomportamento”” sotto forma di metodi e di interfacce sotto forma di metodi e di interfacce comuni a diverse classicomuni a diverse classi
• EreditarietàEreditarietà• Possibilità di riutilizzare il codice già implementato in una Possibilità di riutilizzare il codice già implementato in una
classe base, e di specializzarne il funzionamento nella classe base, e di specializzarne il funzionamento nella derivataderivata
EreditarietàEreditarietà• Una classe può ereditare il Una classe può ereditare il
comportamento di un’altra già esistentecomportamento di un’altra già esistente• Classe baseClasse base
• La classe base contiene il codice La classe base contiene il codice comune alle due classi definitecomune alle due classi definite
• La classe derivata definisce le La classe derivata definisce le specializzazioni della nuova classe specializzazioni della nuova classe rispetto alla baserispetto alla base
EreditarietàEreditarietà• La derivazione individua la relazione “è La derivazione individua la relazione “è
un”un”
Animale
Cane Gatto
Terranova Bassotto Siamese Selvatico
PolimorfismoPolimorfismo• Permette a un entità di comportarsi in Permette a un entità di comportarsi in
modi differentimodi differenti• Implementata dai metodi virtualiImplementata dai metodi virtuali• Es. Animale.MangiaEs. Animale.Mangia
• Un Gatto implementa Mangia in modo Un Gatto implementa Mangia in modo diverso da un Canediverso da un Cane
• Cane e Gatto derivano da AnimaleCane e Gatto derivano da Animale• Animale.Mangia richiamerà il metodo Animale.Mangia richiamerà il metodo
specifico dell’istanza correntespecifico dell’istanza corrente
IncapsulamentoIncapsulamento• Principio secondo cui si “nascondono” i Principio secondo cui si “nascondono” i
dettagli interni della classedettagli interni della classe• Ogni elemento ha un criterio di visibilitàOgni elemento ha un criterio di visibilità• Si rendono visibili all’esterno (pubblici) Si rendono visibili all’esterno (pubblici)
solo l’interfaccia verso il mondo esternosolo l’interfaccia verso il mondo esterno• Futuri cambiamenti interni alla classe Futuri cambiamenti interni alla classe
non si propagano al codice che la non si propagano al codice che la utilizzautilizza
AggregazioneAggregazione• L’aggregazione individua la relazione L’aggregazione individua la relazione
“ha un”“ha un”
AutomobileAutomobile
MotoreMotore RuotaRuota
RuotaRuota
RuotaRuota
RuotaRuotaVolanteVolante
PistonePistonePistonePistone
CilindroCilindroCilindroCilindro Centralina
.NET Framework e OOP.NET Framework e OOP
• Vantaggi per lo sviluppatore:Vantaggi per lo sviluppatore:• Codice potenzialmente più leggibileCodice potenzialmente più leggibile• Manutenibilà delle applicazione e dei Manutenibilà delle applicazione e dei
sistemi sistemi • Modularità del codiceModularità del codice• Applicazioni “componentizzate”Applicazioni “componentizzate”
Il Type SystemIl Type System
Ereditarietà nel .NET FrameworkEreditarietà nel .NET Framework
• Ogni classe deriva sempre dalla classe Ogni classe deriva sempre dalla classe base System.Objectbase System.Object• .class private auto ansi beforefieldinit Simple.class private auto ansi beforefieldinit Simple
extends [mscorlib]System.Objectextends [mscorlib]System.Object
• Una classe può essere derivata da una e Una classe può essere derivata da una e una sola classe baseuna sola classe base
• Una classe può implementare Una classe può implementare nn interfacceinterfacce
• Una interfaccia può ereditare da Una interfaccia può ereditare da nn altre altre interfacceinterfacce
EreditarietàEreditarietà• Il costruttore chiama sempre un costruttore Il costruttore chiama sempre un costruttore
della classe basedella classe base• Implicito: chiama il costruttore di defaultImplicito: chiama il costruttore di default• Esplicito: si usa la keyword Esplicito: si usa la keyword basebase• Si può chiamare un altro costruttore della stessa Si può chiamare un altro costruttore della stessa
classe con la keyword classe con la keyword thisthis
class NuovaClasse : class NuovaClasse : ClasseBaseClasseBase { { NuovaClasse() { // Chiamata implicita a costruttore defaultNuovaClasse() { // Chiamata implicita a costruttore default }}
// Chiama costruttore successivo assegnando x=0// Chiama costruttore successivo assegnando x=0 NuovaClasse( string s ) : NuovaClasse( string s ) : thisthis( s, 0 ) {( s, 0 ) { }}
// Chiama costruttore classe base con s// Chiama costruttore classe base con s NuovaClasse( string s, int x ) : NuovaClasse( string s, int x ) : basebase( s ) {( s ) { // Dovrebbe elaborare x...// Dovrebbe elaborare x... }}}}
Ereditarietà (Es. C#)Ereditarietà (Es. C#)
abstract class Payment {
Payment() {…}
public bool Pay() {…}
public abstract bool Authorize {…}
}
public class CreditCard : Payment {
CreditCard() {…}
public override bool Authorize {…}
}
public class Visa : CreditCard {
Visa() {…}
public new int Authorize {…}
}
public class AmEx : CreditCard {
AmEx() {…}
public new int Authorize {…}
}
Visa : CreditCardVisa : CreditCardcustom.ctor() + base.ctor()custom.ctor() + base.ctor()
CreditCard : PaymentCreditCard : Paymentcustom.ctor() + base.ctor()custom.ctor() + base.ctor()
Payment (abstract)Payment (abstract)custom.ctor() + base.ctor()custom.ctor() + base.ctor()
Ereditarietà a run-timeEreditarietà a run-time
System.ObjectSystem.Object
.ctor().ctor()
public class MyApp
{
public static void Main()
{
Visa vi = new Visa();
CreditCard cc;
Payment pp;
vi.Authorize();
cc = (CreditCard) vi;
cc.Authorize();
pp = (Payment) cc;
pp.Authorize();
}
}
EreditarietàEreditarietà• Una classe derivata può estendere o Una classe derivata può estendere o
meno i membri della classe base a meno i membri della classe base a seconda di come è stata definitaseconda di come è stata definita• SealedSealed evita che la tua classe sia evita che la tua classe sia
ereditabileereditabile• AbstractAbstract forza il fatto che la classe venga forza il fatto che la classe venga
ereditata perchè non è ereditata perchè non è possibile possibile utilizzarla utilizzarla direttamentedirettamente
EreditarietàEreditarietà• Ogni metodo che deve essere sovrascritto Ogni metodo che deve essere sovrascritto
(override) da una classe derivata deve (override) da una classe derivata deve essere dichiarato come virtual nella classe essere dichiarato come virtual nella classe basebase• La classe derivatà dovrà specificare la keyword La classe derivatà dovrà specificare la keyword
override durante l’implementazione del metodooverride durante l’implementazione del metodo
• In .NET è consentita l’ereditarietà da una In .NET è consentita l’ereditarietà da una sola classe base (single inheritance)sola classe base (single inheritance)• Ma è possibile implementare più intefaccie in una Ma è possibile implementare più intefaccie in una
singola classesingola classe
• Tutti i membri non privati di una classe Tutti i membri non privati di una classe vengono ereditati di defaultvengono ereditati di default
• Tutti i membri privati vengono nascosti alla Tutti i membri privati vengono nascosti alla classe derivataclasse derivata
EreditarietàEreditarietà• Tutti i membri protected vengono visti dalla Tutti i membri protected vengono visti dalla
classe base e dalla derivataclasse base e dalla derivata• La classe derivata può utilizzare la keyword La classe derivata può utilizzare la keyword
basebase per fare riferimento ai membri della per fare riferimento ai membri della classe baseclasse base
• Le interfaccie implementate dalla classe base Le interfaccie implementate dalla classe base vengono ereditate dalla derivatavengono ereditate dalla derivata
• Tutti le forme di visibilità di un membro Tutti le forme di visibilità di un membro (public, private, internal, ecc.) vengono (public, private, internal, ecc.) vengono ereditati di default a meno che non siano ereditati di default a meno che non siano forzati nella classe derivataforzati nella classe derivata
• Oggetti che siano compatibili (che Oggetti che siano compatibili (che implementano la stessa interfaccia) possono implementano la stessa interfaccia) possono essere utilizzati al posto della classe base essere utilizzati al posto della classe base dove richiestodove richiesto
Classi base e derivateClassi base e derivate
EreditarietàEreditarietà• Classi base e derivate possono Classi base e derivate possono
implementare gli stessi metodiimplementare gli stessi metodi• Normalmente viene chiamato sempre il Normalmente viene chiamato sempre il
metodo implementato nella classe derivata metodo implementato nella classe derivata più vicina al tipo che si stà realmente più vicina al tipo che si stà realmente utilizzandoutilizzando
• Se questo non esiste si passa alla classe Se questo non esiste si passa alla classe base precedente e così viabase precedente e così via
• Esistono regole e vincoli di precedenza Esistono regole e vincoli di precedenza ben precisi per gestire l’ordine ben precisi per gestire l’ordine dell’esecuzione dei metodi nelle classi dell’esecuzione dei metodi nelle classi derivate e basederivate e base
Ereditarietà e precedenzeEreditarietà e precedenze
Ereditarietà : AvvertenzeEreditarietà : Avvertenze• L’uso eccessivo dell’ereditarietà può L’uso eccessivo dell’ereditarietà può
avere effetti collateraliavere effetti collaterali• Overhead nell’esecuzione del codiceOverhead nell’esecuzione del codice• ComplessitàComplessità
• OverloadingOverloading• ShadowingShadowing• PrecedenzePrecedenze
• Spesso è da prendere in considerazione Spesso è da prendere in considerazione l’utilizzo di interfacce multiplel’utilizzo di interfacce multiple
Classi e metodi sealedClassi e metodi sealedusing System;
public class CreditCard {
public CreditCard() {Console.WriteLine("CreditCard:.ctor()");}
public virtual bool Authorize() {Console.WriteLine("CreditCard:Authorize()");return true;}
}
public sealed class Visa : CreditCard {
public Visa() {Console.WriteLine("Visa:.ctor()");}
public override bool Authorize() {Console.WriteLine("Visa:Authorize()");return true;}
}
public sealed class AmEx : CreditCard {
public AmEx() {Console.WriteLine("Visa:.ctor()");}
public override bool Authorize() {Console.WriteLine("AmEx:Authorize()");return true;}
}
public sealed class TryToInherit : Visa {
public AmEx() {Console.WriteLine("Visa:.ctor()");}
public override bool Authorize() {Console.WriteLine("AmEx:Authorize()");return true;}
}
public class MyApp
{
public static void Main()
{
TryToInherit tti = new TryToInherit();
CreditCard cc;
cc = (CreditCard) tti;
cc.Authorize();
}
}
Metodi VirtualiMetodi Virtuali• Se implemento un metodo in una classe base, il codice Se implemento un metodo in una classe base, il codice
in quel metodo verrà eseguito alla chiamata del metodo in quel metodo verrà eseguito alla chiamata del metodo in una istanza della classe base o in una istanza di una in una istanza della classe base o in una istanza di una classe ereditataclasse ereditata
• Se implemento un metodo in una classe derivata con lo Se implemento un metodo in una classe derivata con lo stesso nome e formato dei parametri di uno della classe stesso nome e formato dei parametri di uno della classe base ricevo un warning di compilazionebase ricevo un warning di compilazione
• Posso implementare un metodo nella classe derivata Posso implementare un metodo nella classe derivata con nome e parametri uguali a quello nella classe base, con nome e parametri uguali a quello nella classe base, ma implementato diversamente, solo se uso la parola ma implementato diversamente, solo se uso la parola chiave chiave newnew
• Se implemento un metodo nella classe base marcato Se implemento un metodo nella classe base marcato come come virtualvirtual posso crearne uno uguale nella classe posso crearne uno uguale nella classe derivataderivata• Sarà il tipo a run-time sul quale è invocato il metodo a Sarà il tipo a run-time sul quale è invocato il metodo a
determinare quale implementazione è eseguitadeterminare quale implementazione è eseguita
Metodi VirtualiMetodi Virtuali• Una funzione virtuale viene risolta in base al Una funzione virtuale viene risolta in base al
tipo dell’istanza su cui viene richiamata, non al tipo dell’istanza su cui viene richiamata, non al tipo di riferimentotipo di riferimento
• Keyword:Keyword:• virtualvirtual definisce una funzione virtuale definisce una funzione virtuale
in una classe basein una classe base• overrideoverride definisce una funzione virtuale definisce una funzione virtuale
in classi derivatein classi derivate• newnew nasconde un membro ereditato nasconde un membro ereditato
da una classe baseda una classe base• Non si può usare new con overrideNon si può usare new con override• Si può usare new con virtualSi può usare new con virtual• Utilizzato soprattutto per le problematiche di versioningUtilizzato soprattutto per le problematiche di versioning
Metodi virtualiMetodi virtualiusing System;
public class CreditCard {
public CreditCard() {Console.WriteLine("CreditCard:.ctor()");}
public bool Pay() {Console.WriteLine("CreditCard:Pay()");return true;}
public virtual bool Authorize() {Console.WriteLine("CreditCard:Authorize()");return true;}
}
public class Visa : CreditCard {
public Visa() {Console.WriteLine("Visa:.ctor()");}
public override bool Authorize() {Console.WriteLine("Visa:Authorize()");return true;}
}
public class AmEx : CreditCard {
public AmEx() {Console.WriteLine("Visa:.ctor()");}
public override bool Authorize() {Console.WriteLine("AmEx:Authorize()");return true;}
}
public class MyApp
{
public static void Main() {
Visa vi = new Visa();
CreditCard cc = new CreditCard();
CreditCard vcc;
vcc = (CreditCard) vi;
cc.Authorize();
vcc.Authorize();
vi.Authorize();
cc.Pay();
vi.Pay();
}}
VersioningVersioning
class Derived: Baseclass Derived: Base // version 1// version 1{{ public public virtualvirtual void Foo() { void Foo() { Console.WriteLine("Derived.Foo"); Console.WriteLine("Derived.Foo"); }}}}
class Baseclass Base // version 1// version 1{{}}
VersioningVersioning
class Derived: Baseclass Derived: Base // version 1// version 1{{ public virtual void Foo() {public virtual void Foo() { Console.WriteLine("Derived.Foo"); Console.WriteLine("Derived.Foo"); }}}}
class Derived: Baseclass Derived: Base // version 2a// version 2a{{ newnew public public virtualvirtual void Foo() { void Foo() { Console.WriteLine("Derived.Foo"); Console.WriteLine("Derived.Foo"); }}}}
class Baseclass Base // version 1// version 1{{}}
class Base class Base // version 2 // version 2 {{ public public virtualvirtual void Foo() { void Foo() { Console.WriteLine("Base.Foo"); Console.WriteLine("Base.Foo"); }}}}
VersioningVersioning
class Derived: Baseclass Derived: Base // version 1// version 1{{ public virtual void Foo() {public virtual void Foo() { Console.WriteLine("Derived.Foo"); Console.WriteLine("Derived.Foo"); }}}}
class Derived: Baseclass Derived: Base // version 2a// version 2a{{ newnew public public virtualvirtual void Foo() { void Foo() { Console.WriteLine("Derived.Foo"); Console.WriteLine("Derived.Foo"); }}}}
class Baseclass Base // version 1// version 1{{}}
class Base class Base // version 2 // version 2 {{ public public virtualvirtual void Foo() { void Foo() { Console.WriteLine("Base.Foo"); Console.WriteLine("Base.Foo"); }}}}
class Derived: Baseclass Derived: Base // version 2b// version 2b{{ public public overrideoverride void Foo() { void Foo() { base.Foo();base.Foo(); Console.WriteLine("Derived.Foo"); Console.WriteLine("Derived.Foo"); }}}}
InterfacceInterfacce
• Una interfaccia è un tipo astrattoUna interfaccia è un tipo astratto• Definisce un Definisce un contrattocontratto con l’utilizzatore del con l’utilizzatore del
tipo che la implementatipo che la implementa• Definisce un Definisce un comportamento comunecomportamento comune a tutte a tutte
le classi che la implementanole classi che la implementano
• Una classe deve implementare tutti i Una classe deve implementare tutti i membri dichiarati in una interfacciamembri dichiarati in una interfaccia
• Un client della classe può accedere ai Un client della classe può accedere ai metodi implementati direttamente, o metodi implementati direttamente, o attraverso un casting su una variabile attraverso un casting su una variabile dichiarata di tipo uguale all’interfaccia dichiarata di tipo uguale all’interfaccia implementataimplementata
InterfacceInterfacceinterface ICDPlayer
{
void Play(short playTrackNum);
void Pause();
void Skip(short numTracks);
short CurrentTrack { get; set; }
}
public class Device : ICDPlayer
{
public Device() {...}
public string DeviceName { get {...} set {...}}
public short CurrentTrack { get {...} set {...}}
public void Play(short playTrackNum) {Console.WriteLine("Now Playing");}
public void Pause() {Console.WriteLine("Now Paused");}
public void Skip(short numTracks) {Console.WriteLine("Skipped");}
}
public class MainClass
{
public static void Main()
{
Device Device1 = new Device();
ICDPlayer CD1 = (ICDPlayer) Device1;
CD1.Play(1);
}
}
Classi e interfacceClassi e interfacce• Le classi vengono utilizzate per definire Le classi vengono utilizzate per definire
gli oggetti in memoriagli oggetti in memoria• Una interfaccia definisce un “elenco” di Una interfaccia definisce un “elenco” di
funzioni che una classe può esporrefunzioni che una classe può esporre• Una classe determina quali interfacce Una classe determina quali interfacce
supportasupporta• Le interfacce che una classe supporta si Le interfacce che una classe supporta si
applicano a tutte le istanze di quella applicano a tutte le istanze di quella classeclasse
• Un oggetto è type-compatible con Un oggetto è type-compatible con ll ’’interfaccia A se e solo se la classe interfaccia A se e solo se la classe delldell’’oggetto supporta quella interfacciaoggetto supporta quella interfaccia
Classi e interfacceClassi e interfacce• Le interfacce vengono utilizzate per Le interfacce vengono utilizzate per
esprimere la compatibilità a livello di esprimere la compatibilità a livello di tipi tra classi diversetipi tra classi diverse• Esprimono un comportamento comune tra le Esprimono un comportamento comune tra le
classiclassi• Individuano un subset di oggetti con Individuano un subset di oggetti con
caratteristiche comunicaratteristiche comuni• Permettono di riferirsi ad un oggetto Permettono di riferirsi ad un oggetto
attraverso una interfaccia supportataattraverso una interfaccia supportata• Permettono un reale polimorfismo nel CLRPermettono un reale polimorfismo nel CLR
• Vincolano il tipo di oggetto al quale una Vincolano il tipo di oggetto al quale una variabile/parametro/field può fare variabile/parametro/field può fare riferimentoriferimento
Classi astratte e interfacceClassi astratte e interfacce• Una classe astratta denota Una classe astratta denota
normalmente una implementazione normalmente una implementazione ““parzialeparziale”” o non completa di un o non completa di un determinata funzionalitàdeterminata funzionalità
• Una classe astratta non può essere Una classe astratta non può essere instanziata direttamente, ma deve instanziata direttamente, ma deve essere ereditata da una classe derivataessere ereditata da una classe derivata
• Una classe astratta può contenere sia Una classe astratta può contenere sia metodi realmente implementati che altri metodi realmente implementati che altri solamente definitisolamente definiti• Saranno implementati nelle classi derivateSaranno implementati nelle classi derivate
Classi astratte e interfacceClassi astratte e interfacce• Una classe astratta solitamente Una classe astratta solitamente incapsulaincapsula
funzionalita comuni a tutte le classi funzionalita comuni a tutte le classi derivatederivate
• Una interfaccia definisce un Una interfaccia definisce un comportamentocomportamento, che dovrà essere , che dovrà essere implementato dalla classe che la implementato dalla classe che la implementaimplementa
• Sia le classi astratte che le interfacce Sia le classi astratte che le interfacce sono molto utili per realizzare anche il sono molto utili per realizzare anche il polimorfismopolimorfismo• Es. scrivere metodi che accettano come Es. scrivere metodi che accettano come
parametro oggetti di tipo diverso, o oggetti parametro oggetti di tipo diverso, o oggetti che implementano le stesse che implementano le stesse interfacce/comportamentiinterfacce/comportamenti
Classi e interfacceClassi e interfacce
public class AmericanPerson{}
public class CanadianPerson{}
public class Car {}
void OperateAndTransfuse(Object patient)
{
// what if patient is a Car?
}
public interface IPatient {}
public class AmericanPerson : IPatient {}
public class CanadianPerson : IPatient {}
public class Car {}
void OperateAndTransfuse(IPatient patient)
{
// accetps only a person object
}
public class MyClassName : MyItf1, MyItf2, MyItf3{ // member definitions go here}
Lista delle interfaccie supportate
Implementazione di Implementazione di interfacceinterfacce
public interface IPatient { }public interface IBillee { }public class AmericanPatient : IPatient, IBillee {}public class CanadianPatient : IPatient {}public class CanadianGovernment : IBillee {}
// American patient acceptable for both parametersvoid OperateAndTransfuseBlood(IPatient patient, IBillee moneySrc) {}
Interfacce MultipleInterfacce Multiple
System.Object
IBillee
IPatient
AmericanPerson CanadianPerson
Canada
Interfaccie MultipleInterfaccie Multiple
Interface discoveryInterface discovery
• È possibile determinare se un tipo È possibile determinare se un tipo implementa una certa interfacciaimplementa una certa interfaccia
• C# prevede tre possibilitàC# prevede tre possibilità• casting (e relativa eccezione in caso di non casting (e relativa eccezione in caso di non
supporto)supporto)• ASAS• ISIS
public interface IPatient{}public interface IPatient{}public interface IBillee{}public interface IBillee{}public interface ISelfFoundedPatient : IPatient,IBillee {}public interface ISelfFoundedPatient : IPatient,IBillee {}public class InsuredPatient : IPatient,IBillee {}public class InsuredPatient : IPatient,IBillee {}public class WhealtyPatient : ISelfFoundedPatient {}public class WhealtyPatient : ISelfFoundedPatient {}
void OperateAndTransfuseBlood(ISelfFoundedPatient patient)void OperateAndTransfuseBlood(ISelfFoundedPatient patient){{
IBillee moneysrc = (IBillee)patient;IBillee moneysrc = (IBillee)patient;ISelfFoundedPatient sfp = patient as ISelfFoundedPatient;ISelfFoundedPatient sfp = patient as ISelfFoundedPatient;if (sfp!=null)if (sfp!=null){{
Debug.Assert (patient is IBillee)Debug.Assert (patient is IBillee)}}
}}
Interfacce e metodiInterfacce e metodi• All’interno di una classe è possibile implementare i All’interno di una classe è possibile implementare i
metodi di una interfaccia in due modimetodi di una interfaccia in due modi• Come metodi publiciCome metodi publici• Come metodi dell’interfacciaCome metodi dell’interfaccia
• Sono accessibili solo attraverso un riferimento all’interfaccia Sono accessibili solo attraverso un riferimento all’interfaccia stessastessa
• Vengono nascosti dalla “firma” publica della classeVengono nascosti dalla “firma” publica della classepublic interface IPatientpublic interface IPatient{{
void Transfuse();void Transfuse();void Operate();void Operate();
}}public class AmericanPatient : IPatientpublic class AmericanPatient : IPatient{{
public void Transfuse{};public void Transfuse{};public void IPatient.Operate{};public void IPatient.Operate{};
}}
void Main()void Main(){{
AmericanPatient ap = new AmericanPatient();AmericanPatient ap = new AmericanPatient();ap.Trasfuse(); // legalap.Trasfuse(); // legalap.Operate(); // illegalap.Operate(); // illegal
IPatient patient = ap;IPatient patient = ap;patient.Operate(); // legal, calls ApericanPatient.IPatient.Operatepatient.Operate(); // legal, calls ApericanPatient.IPatient.Operate
}}
Interfacce e ereditarietàInterfacce e ereditarietà• Una classe può implementare interfacce base Una classe può implementare interfacce base
o derivate da altre interfaccieo derivate da altre interfaccie• Oggetti che implementano le interfacce derivate Oggetti che implementano le interfacce derivate
sono type-compatible con ognuna delle interfacce sono type-compatible con ognuna delle interfacce base dalle quali derivanobase dalle quali derivano
public interface IPatient{}public interface IPatient{}public interface IBillee{}public interface IBillee{}public interface ISelfFoundedPatient : IPatient,IBillee {}public interface ISelfFoundedPatient : IPatient,IBillee {}public class InsuredPatient : IPatient,IBillee {}public class InsuredPatient : IPatient,IBillee {}public class WhealtyPatient : ISelfFoundedPatient {}public class WhealtyPatient : ISelfFoundedPatient {}
void OperateAndTransfuseBlood(ISelfFoundedPatient patient)void OperateAndTransfuseBlood(ISelfFoundedPatient patient){{
// accepts only WhealtyPatient objects// accepts only WhealtyPatient objects}}
C# vs. VB.NETC# vs. VB.NET
• Le keyword nei due linguaggiLe keyword nei due linguaggi
TipologiaTipologia C#C# VB.NETVB.NET
Classe astrattaClasse astratta abstractabstract MustInheritMustInherit
Classe non Classe non ereditabileereditabile
sealedsealed NotInheritableNotInheritable
EreditarietàEreditarietà Derivata : BaseDerivata : Base Derivata : Inherits Derivata : Inherits BaseBase
Impl. InterfacceImpl. Interfacce Classe : InterfacciaClasse : Interfaccia Implements Implements InterfacciaInterfaccia
Modificatori di Modificatori di accessoaccesso
publicpublic PublicPublic
internalinternal FriendFriend
protectedprotected ProtectedProtected
privateprivate PrivatePrivate
virtualvirtual N/AN/A
PolimorfismoPolimorfismo
using System;
public class CreditCard {
public CreditCard() {Console.WriteLine("CreditCard:.ctor()");}
public virtual bool Authorize()
{Console.WriteLine("CreditCard:Authorize()");return true;}
}
public class Visa : CreditCard {
public Visa() {Console.WriteLine("Visa:.ctor()");}
public override bool Authorize()
{Console.WriteLine("Visa:Authorize()");return true;}
}
public class AmEx : CreditCard {
public AmEx() {Console.WriteLine("Visa:.ctor()");}
public override bool Authorize()
{Console.WriteLine("AmEx:Authorize()");return true;}
}
PolimorfismoPolimorfismopublic class MyApp
{
public static void Main()
{
Visa myVisa = new Visa();
AmEx myAmEx = new AmEx();
DoPayment(myVisa);
DoPayment(myAmEx);
}
public bool DoPayment(CreditCard mycard)
{ // scrivo un metodo assolutamente generico…
if (mycard.Authorize())
{
// Payment ok
}
}
}
Considerazioni finaliConsiderazioni finali• Il .NET Framework è un ambiente di programmazione Il .NET Framework è un ambiente di programmazione
completamente orientato agli oggetticompletamente orientato agli oggetti• Comprendere e familiarizzare con questo paradigma di Comprendere e familiarizzare con questo paradigma di
progettazione e sviluppo del codice permette di progettazione e sviluppo del codice permette di aumentare la manutenibilità, modularità e leggibilità aumentare la manutenibilità, modularità e leggibilità del codice, anche in applicazioni di grandi dimensionidel codice, anche in applicazioni di grandi dimensioni
• Le librerie del .NET Framework sono un esempio molto Le librerie del .NET Framework sono un esempio molto interessante di realizzazione OOP realeinteressante di realizzazione OOP reale
• L’utilizzo delle interfacce solitamente è sottovalutato L’utilizzo delle interfacce solitamente è sottovalutato dagli sviluppatoridagli sviluppatori• Oltre a consentire lo sviluppo di codice polimorfico, spesso Oltre a consentire lo sviluppo di codice polimorfico, spesso
è una alternativa interessante alla ereditarietà multiplaè una alternativa interessante alla ereditarietà multipla
• Attenzione alle controindicazioni che un utilizzo Attenzione alle controindicazioni che un utilizzo eccessivo dell’ereditarietà può creare nelle nostre eccessivo dell’ereditarietà può creare nelle nostre applicazioniapplicazioni
Link utiliLink utili• MSDN Academic AllicanceMSDN Academic Allicance
• http://www.msdnaa.net • MSDN StudentiMSDN Studenti
• http://www.microsoft.com/italy/msdn/studenti • MSDN OnlineMSDN Online
• http://msdn.microsoft.com• GotDotNETGotDotNET
• http://www.gotdotnet.com• ASP.NETASP.NET
• http://www.asp.net• Windows FormsWindows Forms
• http://www.windowsforms.net• DevLeapDevLeap
• http://www.devleap.it• UgiDotNetUgiDotNet
• http://www.ugidotnet.org
© 2003-2004 Microsoft Corporation. All rights reserved.This presentation is for informational purposes only. Microsoft makes no warranties, express or implied, in this summary.