Pag. 1 din 52 Arhitectura Framework .NET Ioan Asiminoaei email: [email protected]IOAN ASIMINOAEI Email: [email protected]Mod de adresare pentru e-mail : In subject veti scrie cine sunteti (Nume, prenume complet, anul si forma de studii, Tema abordarii) Evaluare (60 * puncte_laborator + 40 * puncte_test_scris) / 1000 Puncte_Laborator >= 60, maxim = 100 Puncte_test_scris >= 40, maxim = 100 Laboratoarele nu se pot recupera ! Fiecare student va respecta orarul grupei din care face parte ! Nu se da test partial. Evaluarea de la mijlocul semestrului este cea de la laborator.
Console.WriteLine("Hello world - VB") End Sub End Module // Hello world in C++/CLI #include "stdafx.h" using namespace System; int main(array<System::String ^> ^args) {
Console::WriteLine(L" Hello world - C++/CLI"); return 0;
}
Observatie:
1. Se foloseste acelasi spatiu de nume System. Este in topul ierarhiei.
2. Se foloseste aceeasi metoda statica WriteLine din clasa Console.
BCL – Base Class Library (FCL – Framework Class Library)
CLR si BCL permit dezvoltarea urmatoarelor tipuri de aplicatii:
XML Web services;
Serviciile Web sunt construite la un nivel superior protocoalelor HTTP, XML, SOAP,
protocoale ce permit componentelor sa comunice independent de sistemul pe care se afla.
Spatiul de nume System.Web.Services defineste tipurile ce asigura functionalitatea
serviciilor Web
Web Forms – aplicatii bazate pe HTML
ASP.NET furnizeaza un set complet de tipuri pentru dezvoltarea de aplicatii bazate pe Web.
Acesta ofera compilarea dinamica a paginilor Web, abilitatea de a scrie scripturi in mai multe
limbaje .NET si abilitatea de a reutiliza tipuri .NET din pagini Web. Clasele principale pentru
ASP.NET se gasesc in spatiul de nume System.Web.UI.Page.
Windows Forms
Spatiul de nume System.Windows.Forms al cadrului de lucru .NET furnizeaza tipuri ce
suporta crearea de aplicatii cu interfata grafica (GUI), aplicatii dezvoltate pentru sistemele de
operare Windows. Tipurile din aceast spatiu de nume sunt similare in functionalitate cu
clasele din MFC sau alte biblioteci de clase (wxWidget). Important este ca tipurile din .NET
pot fi utilizate de orice limbaj compatibil cu .NET.
Clasele ajutatoare pentru dezvoltarea aplicatiilor Windows se gasesc sub acest spatiu de
nume : clase pentru butoane, controale, dialoguri, combo boxuri, etc.
Windows Console Applications – aplicatii de tip consola (CUI – Console User Interface).
WPF – Windows Presentation Foundation – aplicatii cu interfata grafica – GUI.
Windows services – aplicatii controlate de Windows Service Control Manager folosind
.NET.
Component library – componente dezvoltate de utilizator ce pot fi folosite in alte aplicatii
sau componente.
Exemple de spatii de nume
Spatiu de nume Descriere System Contine tipurile de baza folosite de orice aplicatie; System.Collections Contine tipurile ce gestioneaza colectii de obiecte ; include
colectiile stive, cozi, tabele hash, etc. System.Drawing Tipuri pentru grafice. System.Globalization Tipuri pentru NLS - National Language Support –comparare
stringuri, formatare, calendar. System.IO Tratare fisiere. System.Net Tipuri ce permit comunicatia in retea. System.Management Folosit in WMI (Windows Management Instrumentation). System.Reflection Permite inspectia metadatei.
Tipurile numerice din .NET suporta proprietatile MinValue si MaxValue.
Tip valoare : variabila contine valoarea.
� Nu poate fi null (o variabila de tip value are intotdeauna o valoare) daca nu e declarat
“nullable”.
� Folosirea unei asemenea variabile ca argument al unei functii are ca efect pasarea
valorii. Modificarea valorii in cadrul functiei este locala.
Tipurile “nullable” sunt instante ale structurii System.Nullable<T>. Unui tip « nullable »
i se poate atribui o valoare conform tipului T sau valoarea null. Abilitatea de a atribui null
la tipuri numerice sau boolean este folositoare cand se lucreaza cu baze de date sau pentru a
marca faptul ca o variabila nu a fost initializata.
De exemplu un tip numeric intr-o tabela dintr-o baza de date poate avea o valoare sau poate fi
nedefinit (null).
Exemplu:
// se aloca 32 biti pentru nVarsta iar valoarea este 22 System.Int32 nVarsta = 22; // <=> int nVarsta = 32 ; // m este de tip int si nullable int ? m = null; // <=> Nullable<System.Int32> m = null ;
Pentru a determina valoarea unui asemenea tip se folosesc proprietatile HasValue si Value
ca in exemplul de mai jos :
class ExNullable { public static void Main() { int? m = null; if (m.HasValue == true) { System.Console.WriteLine("m = " + m.Value); } else { System.Console.WriteLine("m = Null"); } } }
De fiecare data cand declaram o variabila de un anumit tip, sistemul aloca numarul de octeti
asociati tipului respectiv si se poate lucra in mod direct cu memoria alocata.
Intrebare :
Un tip valoare poate contine tip referinta ?
Raspuns : DA.
Reamintim ca tipul struct este tip valoare.
Putem construi o structura ce contine ca data membru un tip referinta.
// definim un tip referinta public class Info { string HostName; public Info() { HostName = Environment.MachineName; } public void PrintHostName() { Console.WriteLine("Machine Name = {0}", HostName); } }
/// <summary> /// Definim un tip valoare ce contine un tip referinta /// </summary> public struct InfoStructure { // tip referinta public Info info; // tip referinta public string SystemDirectory; public int an; // tip valoare public InfoStructure(Info _info, string _sd) { info = _info; SystemDirectory = _sd; an = 2012; } public void PrintInfoStructure() { Console.WriteLine("PrintInfoStructure"); info.PrintHostName(); Console.WriteLine("System directory : {0}", SystemDirectory); Console.WriteLine("An = {0}", an); } }
In Main scriem urmatorul cod pentru testare
class Program { static void Main(string[] args) { Info info = new Info(); info.PrintHostName(); InfoStructure infoStr = new InfoStructure(info, Environment.SystemDirectory); infoStr.PrintInfoStructure(); // sau InfoStructure creat fara a folosi operatorul new InfoStructure infos;
atribut : Optional. Reprezinta un atribut (este o clasa derivata din System.Attribute). Vezi
cursul ce descrie atributele.
nivel_de_acces: stabileste "vizibilitatea" clasei. Valoarea implicita este internal - clasa
definita la nivel de namespace - sau private - clasa imbricata.
tip_clasa: Optional. In cazul cand se foloseste poate avea valorile:
abstract, new (folosit pentru clase imbricate), sealed, static.
Exemplu namespace Curs
{ class Persoana // echivalent internal class Persoana { // Date membru (campuri, variabile membru) public string nume; public int varsta; // ctor public Persoana(string nume, int varsta) { this.nume = nume; this.varsta = varsta; } // metoda a instantei public void Display() { Console.WriteLine("Nume: {0}, Varsta: {1}",
Un tip poate avea definiti mai multi ctori. Diferenta este data de numarul parametrilor si de
tipul acestora.
Modificator de acces in
C# pentru tipuri Descriere
public Membrul este accesibil din afara definitiei clasei si a ierarhiei
claselor derivate.
protected Membrul nu este vizibil in afara clasei si poate fi accesat
numai de clasele derivate.
private Membrul nu este vizibil in afara clasei si nici in clasele
derivate.
internal
Membrul este vizibil numai in interiorul unitatii curente de
compilare, numai din fisierele din acelasi assembly. Acest
modificator creaza un hibrid intre public si protected, totul
depinzind in ultima instanta de locul unde se afla codul. O
utilizare comuna a acestui modificator este in dezvoltarea
bazata pe componente pentru ca permite unui grup de
componente sa coopereze intr-un mod privat.
protected internal * Accesul este limitat la assembly-ul curent sau la tipurile
derivate din clasa continuta.
Observatie :
La nivel de namespace un tip are modificatorul de acces internal sau public.
Clasele « imbricate » (« nested ») pot avea oricare din modificatorii de acces de mai sus.
Ex : namespace Info { class Persoana { ...} // implicit este internal public class Client { ... }
// Clasa de baza ce poate fi extinsa in procesul de derivare. // Contine cel putin o metoda sau proprietate ce trebuie // implementata de clasa derivata. // Nu poate fi instantiata.
public class abstract BazaInfo { ... }
// Nu poate fi folosita in procesul de derivare. public sealed class ClasaFinala { ... } } namespace InfoNested { class Persoana
public class Client { private class Banca { ... } public class Adresa { ... } protected class Comanda { ... } } // contine numai metode / date statice public static class Print { ... }
}
Modificatori de acces pentru date membru (fields) :
Membru in Accesibilitate
implicita
Permite modificarea accesibilitatii
enum public -
class
(aici class
apare ca data
membru in alta
clasa)
private public
protected
internal
private
protected internal
interface public -
struct private public
internal
private
In C# trebuie sa indicam pentru fiecare data membru modificatorul de acces.
Constructori. Inlantuire constructori. Cuvantul cheie this. public class Persoana { int varsta; string nume; public Persoana() : this(0,””)
{} public Persoana (int varsta) : this(varsta, “”) {} public Persoana (string nume) : this (0, nume); // constructorul general public Perosna(int varsta, string nume) { this.varsta = varsta; this.nume = nume; }
Metodele statice nu pot lucra cu instante ale tipului. Se apeleaza furnizand numele clasei
urmat de . (punct) si apoi numele metodei.
public class Info { public static Print
{ Console.WtiteLine(“Metoda statica Print din clasa Info”); }
}
iar apelul este de forma
Info.Print() ;
Membri statici pot opera numai cu date statice si pot apela metode statice din tipul definit.
Campurile statice sunt create o singura data indiferent de cate instante ale tipului se vor crea.
Toate instantele create vor avea acceasi valoare pentru o data statica.
Intrebare :
Putem folosi un tip referinta ca fiind static in interiorul altui tip?
Raspunsul il gasim in urmatorul cod:
public class InfoStatic { public static Info info = new Info(); // metoda a instantei public void PrintInstanta() {
// in clasa Info de la exemplul anterior am declarat // HostName ca fiind public
Console.WriteLine("class InfoStatic. Metoda a instantei. Machine name = {0} ", info.HostName); info.PrintHostName(); } // metoda statica public static void PrintStatic() { Console.WriteLine("class InfoStatic. Metoda statica. {0} ",
info.HostName); } }
Testarea functionalitatii acestei clase se poate face astfel:
// test class InfoStatic, apel metoda statica
InfoStatic.PrintStatic(); // apel metoda a instantei InfoStatic infoStatic = new InfoStatic(); infoStatic.PrintInstanta();
Daca am definit o clasa ca fiind statica, aceasta nu poate fi instantiata cu operatorul new si
trebuie sa contina numai membri (date, metode) statici.
Totul se aloca pe stiva si ca urmare garbage collector nu are in vedere asemenea tipuri.
Unde sunt folosite ?
Vezi metodele extinse si nu numai.
Metodele extinse permit ca pentru tipurile compilate existente sa se adauge noi
functionalitati, fara a fi nevoiti sa rescriem tipul. Metodele extinse se aplica si pentru clasele
« sealed » (o clasa « sealed » nu poate fi utilizata in procesul de derivare).
Aceasta tehnica adauga noi metode pentru un tip in contextul aplicatiei curente.
Analizati cu atentie exemplul de mai jos.
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Reflection; namespace ExtensionMethod {
/// <summary> /// Metode extinse pentru tipul System.Int32 /// 1. Clasa trebuie sa fie statica /// 2. Metoda trebuie sa fie statica /// 3. Primul parametru al metodei this urmat de tipul pe care /// se va aplica metoda /// </summary>
public static class MetodeExtinse {
// Metoda permite unui obiect sa afiseze assembly // in care este definit
public static void AfisareAssemblyGazda(this object obj) { Console.WriteLine("{0} Este definit in:\n\t->{1}\n", obj.GetType().Name, Assembly.GetAssembly(obj.GetType())); } // Inverseaza cifrele unui numar intreg (Ex. 13 -> 31) // Metoda extinsa pentru tipul int public static int InversareIntreg(this System.Int32 i) { // Transform intregul in string si apoi
// iau toate caracterele char[] digits = i.ToString().ToCharArray(); // Inversez articolele in array Array.Reverse(digits);
// Construiesc un nou string string newDigits = new string(digits); // Conversie la intreg si return return int.Parse(newDigits); } // metoda extinsa pentru tipul int public static int Aduna(this System.Int32 n, int m) { return n + m; } } // Test class Program { static void Main(string[] args) { int Index = 12; int n = 13; // apel metoda extinsa int ns = n.InversareIntreg(); Console.WriteLine("Intreg initial = {0},
si inversat = {1}",n, ns); // apel metoda extinsa ce aduna doua numere intregi n = Index.Aduna(n); // n = n + Index Console.WriteLine("Adunare : " + n.ToString()); // apel metoda extinsa pe tipul object object o = n; o.AfisareAssemblyGazda(); } } }
Desi metodele AfisareAssemblyGazda, Aduna, InversareIntreg au fost definite ca
fiind statice in cadrul unei clase statice, ele se apeleaza pe o instanta a tipului. Analizati
prototipurile metodelor extinse si modul de apel.
Ce observati ?
Primul parametru al metodei extinse indica tipul pentru care se aplica acea metoda.
Metodele sunt totdeauna definite in interiorul clasei sau structurii.
Metodele pot fi:
• instance (apelata ca o instanta a tipului in interiorul caruia metoda a fost definita)
sau
• static, unde metoda este asociata cu tipul insusi.
Metodele pot fi declarate ca virtual, abstract sau sealed.
Metodele pot fi supraincarcate (overloaded), suprascrise (overriden) si/sau ascunse
(hidden – vezi operatorul new).
Metodele instantei sunt apelate pe instanta obiectului.
Metodele statice nu sunt apelate pe instanta clasei ci prin prefixarea numelui metodei cu
numele clasei unde este definita.
Exercitiu
Presupunem ca implementam un tip ce contine o data membru statica.
Este posibil sa folosim aceasta data membru statica intr-o metoda a instantei tipului ?
Cuvantul cheie base
Scenariu
Presupunem ca am construit o clasa ce poate fi mostenita si furnizeaza mai multi
ctori. Folosim aceasta clasa intr-un proces de derivare iar clasa derivata
implementeaza mai multi ctori.
Intrebare :
Ce constructor se va apela din clasa de baza in momentul cand instantiem clasa derivata ?
base este folosit pentru apelul constructorilor din clasa de baza. Acesta se va folosi in
constructorul clasei derivate pentru a indica ce constructor va fi apelat - din clasa de baza.
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace Exemplu { public class Baza { int n; string nume; public Baza(int _n) { Console.WriteLine("Baza ctor param int"); this.n = _n; } public Baza(int _n, string _str) :this(_n) {
membri pot fi declarati ca fiind abstract sau virtual sau static.
Tipul de data preconstruit (“intrinsec”) din CTS – tip VALOARE Tip Data in CTS VB .NET C# C++/CLI Keyword
System.Byte Byte byte unsigned char System.SByte SByte sbyte signed char System.Int16 Short short short System.Int32 Integer int int or long System.Int64 Long long __int64 System.UInt16 UShort ushort unsigned short System.UInt32 UInteger uint unsigned int or unsigned long System.UInt64 ULong ulong unsigned __int64 System.Single Single float Float System.Double Double double Double System.Object Object object Object^ System.Char Char char wchar_t System.String String string String^ System.Decimal Decimal decimal Decimal System.Boolean Boolean bool Bool
Metode cu si fara parametri
ref ca parametri ai metodei
Cuvantul cheie ref spune compilatorului C# ca argumentele pasate puncteaza la aceeasi
memorie ca si variabilele din codul apelant. Daca metoda apelata modifica valorile,
modificarile sunt vazute in codul apelant.
Restrictie:
Cand folosim ref, trebuie sa initializam argumentele inainte de a le folosi ca argumente ale
functiei. Exemplu:
class Color { public Color() { this.red = 0; this.green = 127; this.blue = 255; } protected int red; protected int green; protected int blue;
public void GetRGB( ref int red, ref int green, ref int blue) { red = this.red; green = this.green; blue = this.blue; } }
class TestRef { static void Main(string[] args) { Color c = new Color(); // Initializare int red = 0; int green = 0; int blue = 0; c.GetRGB(ref red, ref green, ref blue); Console.WriteLine("R={0}, G={1}, B={2}", red, green, blue); } }
out ca parametri ai metodei
Are acelasi efect ca si ref, dar diferenta principala este ca nu e necesara initializarea
parametrilor inainte de apel.
Parametrii prefixati cu out trebuiesc modificati in metoda apelata, iar parametrii prefixati cu
ref pot fi modificati.
Exemplu: class Color { public Color() { this.red = 0; this.green = 127; this.blue = 255; } protected int red; protected int green; protected int blue; public void GetRGB(out int red, out int green, out int blue) { red = this.red; green = this.green; blue = this.blue;
class TestOut { static void Main(string[] args) { Color c = new Color(); int red; int green; int blue; c.GetRGB(out red, out green, out blue); Console.WriteLine("R={0}, G={1}, B={2}", red, green, blue); } }
Pasarea unui tip referinta prin valoare (parametru al metodei)
Daca o variabila tip referinta este un argument al unei functii, atunci se poate modifica
continutul variabilei, adica starea obiectului dar nu si obiectul.
Intrebare :
Se poate modifica obiectul cand acesta este transmis ca parametru al unei functii?
vezi ex C1_2009 din d:\exenet
De comentat liniile ce contin apel prin referinta
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace C1_2009 { class Mate { public int Aduna(int x, int y) { return x + y; } public double Aduna(float x, float y) { return x + y; } public string Aduna(double x, double y, string text) { return " x + y = " + (x + y).ToString() +
" parametrul 3 este : " + text; } } class Persoana { public string nume; public int varsta; public Persoana(string nume, int varsta) { this.nume = nume; this.varsta = varsta; } public void Display() { Console.WriteLine("Nume: {0}, Varsta: {1}",
nume, varsta); } } class Program { static void Main(string[] args) { Mate m = new Mate();
Console.WriteLine(" 1 + 2 = {0} ", m.Aduna(1, 2)); Console.WriteLine(" 1.5 + 2.0 = {0}", m.Aduna(1.5F, 2.0F)); Console.WriteLine(" 1.5 + 2.0 = {0} ", m.Aduna(1.5, 2.0, "Aduna cu trei parametri")); Console.WriteLine("\n\nTest Persoana parametru prin valoare"); Persoana p = new Persoana("Elena", 21); p.Display(); TransmitePersoanaPrinValoare(p); p.Display(); Console.ReadLine(); } static void TransmitePersoanaPrinValoare(Persoana p) { // Schimbam varsta? p.varsta = 99; // Apelantul va vedea aceasta reatribuire? // Cream un obiect nou p = new Persoana("Vasile", 99); } } }
Ce se intampla?
Pasarea unui tip referinta prin referinta
vezi ex C1_2009 din d:\exenet
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace C1_2009 { class Mate { public int Aduna(int x, int y) { return x + y; } public double Aduna(float x, float y) { return x + y; } public string Aduna(double x, double y, string text) { return " x + y = " + (x + y).ToString() +
" parametrul 3 este : " + text; } } class Persoana { public string nume; public int varsta;
public Persoana(string nume, int varsta) { this.nume = nume; this.varsta = varsta; } public void Display() { Console.WriteLine("Nume: {0}, Varsta: {1}",
nume, varsta); } } // test class Program { static void Main(string[] args) { Mate m = new Mate(); Console.WriteLine(" 1 + 2 = {0} ", m.Aduna(1, 2)); Console.WriteLine(" 1.5 + 2.0 = {0}", m.Aduna(1.5F, 2.0F)); Console.WriteLine(" 1.5 + 2.0 = {0} ",
m.Aduna(1.5, 2.0, "Aduna cu trei parametri")); Console.WriteLine(
"\n\nTest Persoana parametru prin valoare"); Persoana p = new Persoana("Elena", 21); p.Display(); TransmitePersoanaPrinValoare(p); p.Display(); Console.WriteLine(
"\n\nTest Persoana parametru prin referinta"); p.varsta = 21; p.Display(); TransmitePersoanaPrinReferinta(ref p); p.Display(); Console.ReadLine(); } static void TransmitePersoanaPrinValoare(Persoana p) { // Schimbam varsta? p.varsta = 99; // Apelantul va vedea aceasta reatribuire? p = new Persoana("Vasile", 99); } static void TransmitePersoanaPrinReferinta(ref Persoana p) { // Schimbam varsta? p.varsta = 99; // Apelantul va vedea aceasta reatribuire? p = new Persoana("Vasile", 99); } } }
Boxing = conversia de la tip valoare la tip referinta.
Unboxing = conversia de la tip referinta la tip valoare.
Conversia din tip valoare la tip referinta (boxing)
Se creaza o copie noua a obiectului ce va fi supus conversiei. Exemplu int nVarsta = 22; // tip valoare object refVarsta = nVarsta; // nVarsta este convertit la refVarsta // nu e nevoie de o conversie explicita
1. se aloca memorie in heap, atat pentru a mentine valoarea obiectului cat si pentru a
mentine starea acestuia (metode, structuri interne, tabela de metode virtuale).
2. Se copie valoarea la noua adresa.
3. Adresa obiectului nou alocat este plasata pe stiva si acum puncteaza la un obiect
referinta.
Conversia din tip Referinta la tip valoare (unboxing)
Nu se creaza o noua copie a obiectului supus conversiei.
In acest caz conversia poate fi facuta la orice tip. Se aplica reguli stricte definite in CTS.
int nVarsta = 22; // tip valoare. object refVarsta = nVarsta; // (boxed) refVarsta puncteaza la nVarsta int nAlt = (int)refVarsta; // (Unboxed) inapoi la int. // este nevoie de o conversie explicita
Sa urmarim urmatorul cod si apoi sa vedem ce este in CIL. …
IL_0037: box [mscorlib]System.Int32 IL_003c: ldloc.1 IL_003d: call void [mscorlib]System.Console::WriteLine(string, object, object) IL_0042: call string [mscorlib]System.Console::ReadLine() IL_0047: pop IL_0048: ret } // end of method Test::Main
Mostenire si polimorfism
Mostenirea faciliteaza reutilizarea codului.
Reutilizarea codului poate fi facuta in doua moduri :
• mostenire clasica ce stabileste o relatie de « este un » - « is-a » ;
• containment / agregare ce stabileste o relatie de « are un » - « has-a ».
Cand stabilim o relatie « is-a » intre clase, construim de fapt o dependenta intre doua sau mai
multe clase. Ideea este ca noua clasa poate extinde functionalitatea clasei existente (clasa de
baza).
Daca o clasa este declarata « sealed » atunci aceasta nu poate fi folosita drept clasa de baza
pentru o alta clasa (clasa “sealed” nu poate fi extinsa prin procesul de mostenire).
In .NET exista mostenire simpla a claselor si mostenire multipla a interfetelor.
In cazul polimorfismului vom folosi cuvintele cheie virtual si override pentru metoda in
cauza.
• virtual se foloseste in clasa de baza.
• override se foloseste in clasa derivata.
Observatie Functia suprascrisa trebuie sa aiba acelasi nivel de acces ca si functia virtuala pe care o
suprascrie.
Un membru virtual nu poate fi declarat private.
Exemplu:
class Persoana { public string name; public Persoana(string name) { this.name = name; } public virtual void Calcul() { Console.WriteLine( "Persoana.Calcul apelata pentru {0}", name);
} } class ContractPersoana : Persoana { public ContractPersoana(string name) : base(name) { } public override void Calcul() { Console.WriteLine( "ContractPersoana.Calcul apelata pentru {0}", name); } } class Salariat : Persoana { public Salariat (string name) : base(name) { } public override void Calcul() { Console.WriteLine( "Salariat.Calcul apelata pentru {0}", name); } } class TestPolimorfism { protected Persoana[] persoane; public void LoadPersoane() { // Simulare incarcare din baza de date persoane = new Persoana[2]; persoane[0] = new ContractPersoana("ABBA"); persoane[1] = new Salariat("Evora"); } public void DoCalcul() { for (int i = 0; i < persoane.GetLength(0); i++) { persoane[i].Calcul(); } } static void Main(string[] args) { TestPolimorfism t = new TestPolimorfism(); t.LoadPersoane(); t.DoCalcul(); } }
Metode: combinatie new si virtual Putem combina new si virtual cand declaram o functie.
Pentru ca este new ea ascunde orice functie mostenita cu aceeasi semnatura.
Pentru ca este virtual ea poate fi suprascrisa in clasele derivate.
Exemplu class Persoana { public string name; public Persoana(string name) { this.name = name; } public virtual void Calcul() { Console.WriteLine( "Persoana.Calcul apelata pentru {0}", name); } } class Salariat : Persoana { public Salariat (string name) : base(name) { } public new virtual void Calcul() { Console.WriteLine( "Salariat.Calcul apelata pentru {0}", name); } } class ContractPersoana : Salariat { public ContractPersoana(string name) : base(name) { } public override void Calcul() { Console.WriteLine( "ContractPersoana.Calcul apelata pentru {0}", name); } } class Test { protected Persoana[] persoane; public void LoadPersoane()
{ persoane = new Persoana[2]; persoane[0] = new ContractPersoana("ABBA"); persoane[1] = new Salariat("Evora"); } public void DoCalcul() { for (int i = 0; i < persoane.GetLength(0); i++) { persoane[i].Calcul(); } } static void Main(string[] args) { Test t = new Test(); t.LoadPersoane(); t.DoCalcul(); } }
Rezultatul va fi:
?
Urmatoarele doua declaratii sunt identice: public new virtual void Calcul() //public virtual void Calcul()
Implementare polimorfism folosind clase abstracte
In acest caz in clasa de baza se declara metoda ca fiind abstract iar in clasa derivata
override.
Exemplu (Troelsen):
// Clasa de baza abstracta abstract class Shape {
public Shape() {} public Shape(string name = "NoName")
{ PetName = name; } public string PetName { get; set; } // Metoda abstracta. Se forteaza scrierea codului // in clasa derivata – in caz contrar clasa derivata // trebuie declarata abstracta public abstract void Draw();
public Circle(string name) : base(name) {} public override void Draw() {
Console.WriteLine("Drawing {0} the Circle", PetName); }
} class Hexagon : Shape {
public Hexagon() {} public Hexagon(string name) : base(name) {} public override void Draw() {
Console.WriteLine("Drawing {0} the Hexagon", PetName); }
}
in Main putem scrie codul: static void Main(string[] args) {
Console.WriteLine("***** Polymorphism *****\n"); // Construim un array de obiecte Shape compatibile. Shape[] myShapes = {
new Hexagon(), new Circle(), new Hexagon("H1"), new Circle("C"), new Hexagon("H2")};
// Iterare pe articolele din array si apelul metodei Draw(). foreach (Shape s in myShapes) {
s.Draw(); } Console.ReadLine();
}
Rezultatul va fi: ***** Polymorphism ***** Drawing NoName the Hexagon Drawing NoName the Circle Drawing H1 the Hexagon Drawing C the Circle Drawing H2 the Hexagon
Suprascrierea proprietatilor mostenite
Proprietatea trebuie specificata ca fiind virtual in clasa de baza pentru a o suprascrie, iar in
clasa derivata override..
using System; class FlatFile { public FlatFile(string fileName) { this.fileName = fileName; }
