Florin Tudor Cristea · Microsoft Student Partners

C# PENTRU ÎNCEPĂTORI

L1

.NET FRAMEWORK

Microsoft .NET Framework reprezintă un cadru de dezvoltare software care poate fi instalat pe maşinile ce rulează familia de sisteme de operare Microsoft Windows (există însă în desfăşurare un proiect open-source şi cross-platform denumit Mono ce promite un ecosistem mai larg pentru aplicaţiile din familia .NET). Acesta include o bibliotecă vastă de soluţii la cele mai comune probleme de programare şi o maşină virtuală care gestionează execuţia programelor scrise specific pentru el.

BASE CLASS LIBRARY

Base Class Library (BCL) constituie o bibliotecă standard disponibilă tuturor limbajelor ce folosesc framework-ul .NET. Oferă o paletă largă de soluţii referitoare la interfaţa cu utilizatorul, accesul la fişiere şi baze de date, criptografie, dezvoltarea de aplicaţii web, algoritmi numerici, comunicarea în reţea şi nu numai. Este folosită de către programatori, care o combină cu propriul lor cod pentru a produce aplicaţii software.

System, System.Collections, System.Diagnostics, System.Globalization, System.IO, System.Net, System.Reflection, System.Runtime, System.Security, System.Text, System.Threading

COMMON LANGUAGE RUNTIME

Programele scrise pentru framework-ul .NET sunt executate într-un mediu software care gestionează cerinţele programelor în timpul rulării. Acesta poartă numele de Common Language Runtime (CLR) şi oferă caracteristicile unei maşini virtuale, fapt ce permite programatorilor să creeze aplicaţii fără să îşi facă probleme legate de arhitectura procesorului de pe care vor rula acestea. De asemenea, CLR-ul se ocupă şi de alte servicii importante precum managementul memoriei, securitate şi manipularea excepţiilor.

BCL + CLR = .NET Framework

COMMON LANGUAGE INFRASTRUCTURE

Common Language Infrastructure (CLI) este o specificaţie deschisă dezvoltată de către Microsoft ce defineşte un mediu software care permite ca multiple limbaje de nivel înalt să poată fi folosite pe diferite platforme de operare fără să fie necesar ca acestea să fie rescrise pentru arhitecturi specifice (.NET Framework, Mono, Portable.NET implementează aceste standarde).

Termeni cheie: Common Type System (CTS), Metadata, Common Language Specification (CLS), Virtual Execution System (VES)

CIL este un limbaj de asamblare orientat obiect, bazat în întregime pe stack (stivă) în ceea ce priveşte alocarea memoriei.

LIMBAJE CLI

C#, C++/CLI, F#, J#, IronPython, VB.NET, A#, Active Oberon, APLNext, AVR.NET, Boo, Cobra, Common Larceny, Component Pascal, Delphi.NET, Delta Forth .NET, DotLisp, dylan.NET, EiffelEnvision, Fortran.NET, Gardens Point Modula-2/CLR, Haskell for .NET, Hugs for .NET, IoNET, IronLisp, IronRuby, IronScheme, Ja.NET, JScript.NET, L#, Lexico, LOLCode.NET, Lua.NET, Managed Extensions for C++, Managed Jscript, Mercury on .NET, Mondrian, Nemerle, Net Express, NetCOBOL, Oxygene, OxygenScheme, P#, Phalanger, Phrogram, PL/IL, PowerBuilder, S#, sml.net, VBx, Wildcat Cobol, Windows PowerShell, X#, Zonnon, #S, #Smalltalk, ···

DESPRE C#

C# este un limbaj de programare cu scop general, puternic tipizat, orientat obiect. Caracterizat prin simplitate, expresivitate şi performanţă, C# uşurează mult scrierea diverselor aplicaţii (este optimizat pentru cadrul de dezvoltare .NET).

Cea mai recentă versiune a limbajului este 3.0, lansată concomitent cu .NET Framework 3.5 în 2007. Următoarea versiune propusă, 4.0, se află în dezvoltare (beta din mai 2009).

DESPRE VISUAL STUDIO

Microsoft Visual Studio este un mediu integrat de dezvoltare (IDE — Integrated Development Environment) produs de Microsoft. Poate fi folosit atât pentru a dezvolta aplicaţii tip consolă sau cu interfaţă grafică (Windows Forms) cât şi situri, aplicaţii şi servicii web — atât în cod nativ cât şi în cod gestionat, pe toate platformele suportate de către Microsoft Windows, Windows Mobile, Windows CE, .NET Framework, .NET Compact Framework şi Microsoft Silverlight.

Versiunea 2008 Professional poate fi descărcată de pe MSDNAA (msdn.info.uaic.ro) sau DreamSpark (dreamspark.com).

Numele proiectului

Crearea unui proiect

using System;

namespace HelloWorld{ class Program { static void Main(string[] args) { Console.WriteLine("Hello, world!"); } }}

Rularea unui proiect

ELEMENTE DE SINTAXĂ C#

IdentificatoriReprezintă numele unui element în cod.

Pot începe cu “_” şi conţine atât

minuscule cât şi majuscule.

Nu pot începe cu o cifră sau un simbol şi sunt limitaţi la 511

caractere.

ELEMENTE DE SINTAXĂ C#

Cuvinte rezervate: abstract, as, base, bool, break, by, byte, case, catch, char, checked, class, const, continue, decimal, default, delegate, do, double, descending, explicit, event, extern, else, enum, false, finally, fixed, float, for, foreach, from, goto, group, if, implicit, in, int, interface, internal, into, is, lock, long, new, null, namespace, object, operator, out, override, orderby, params, private, protected, public, readonly, ref, return, switch, struct, sbyte, sealed, short, sizeof, stackalloc, static, string, select, this, throw, true, try, typeof, uint, ulong, unchecked, unsafe, ushort, using, var, virtual, volatile, void, while, where, yield

Utilizarea unui cuvânt rezervat ca un identificator: string @out;

Valori întregioctal 0365, 0[0..7]*

hexazecimal 0xF5, 0x[0..9, A..F, a..f]*zecimal 245, [1..9][0..9]*

Valori în virgulă mobilă

float23.5F, 23.5f; 1.72E3F, 1.72E3f, 1.72e3F, 1.72e3f

double 23.5, 23.5D, 23.5d; 1.72E3, 1.72E3D, ...Caractere

char 'a', 'Z', '\u0231'Şiruri

String "Hello, world"Secvenţe escape

caractere Unicode \u urmat de codul hexazecimal corespunzător

Tab \tBackspace \b

Carriage return \rForm feed \fBackslash \\

Single quote \'Double quote \"

Line feed \nLiterali

ELEMENTE DE SINTAXĂ C#

Variabile

int MyInt;

int MyInt;MyInt = 35;int MyInt = 35;

Declarare

IniţializareDeclarare cu iniţializare

= identificatori cu valori asociate

int a, b; // declarare multiplăint a = 2, b = 3; /* declarare cu iniţializare multiplă *//* Inferenţa de tip (type inference) */var MyChars = new char[] {'A', 'Ö'}; /* sau char[] MyChars = new char[] {'A', 'Ö'}; */

/* const vs. readonly */class Foo{ const int x1 = 1; const int x2; // eroare readonly int x3 = 3, x4, x5; Foo() // corect deşi x5 nu e iniţ. { x4 = 4; // corect const int x6 = 6; readonly int x7 = 7; // eroare }} /* constantele const sunt implicit statice */

ELEMENTE DE SINTAXĂ C#

void foo(){ int a; { int b; a = 1; } // alt ‘scope’ a = 2; b = 3; // eroare}

Domenii de cod (scopes)

static int void Main(string[] args){ return 0;}

Metoda Main – punctul de intrare al aplicaţiei

namespace Foo{ class Bar { ... } class Lol { ... } class Cat { ... }}

Spaţii de nume (namespaces)

using System;using DirInfo = System.IO.DirectoryInfo;

Directiva using

Categorie operatori Operatori

Aritmetici + - * / %

Logici (booleeni şi pe biţi) & | ^ ! ~ && || true false

Concatenare şiruri +

Incrementare, decrementare ++ --

Şiftare << >>Relaţionali == != < > <= >=

De asignare = += -= *= /= %= &= |= ^= <<= >>=

Accesul la membri .De indexare [ ]De tipizare (cast) ( )Condiţionali ?  :

De concatenare, înlăturare a delegaţilor + -

Creare obiect newInformaţie despre tip as is sizeof typeof

Controlul excepţiei de overflow checked unchecked

Indirecţie şi acces * -> [] &Operatori

using System;public class Pointer{ unsafe static void Main() { int i = 5; int* j = &i; Console.WriteLine(*j); }} // Output: 5

/* compilatorul trebuie invocat cu opţiunea /unsafe */

/* signatura supraîncărcării unui operator binar */public static Complex operator +(Complex c1, Complex c2) { ... }

/* termeni cheie: implicit şi explicit (construcţia operatorului de conversie implicită sau explicită), as (operatorul de conversie tacită) */

switch (pivot){ case 'A': ... break; case 'B': case 'C': ... break; default: ... break;}

if (boolean){ ...}else if (boolean){ ...}else{ ...}

Structuri condiţionale

while (boolean){ ...}

do{ ...}while (boolean)

for (int i = 0; i < 10; i++){ ...}

foreach (int i in intList){ ...}

Structuri iterative

start: ... goto start;

for (int i = 0; i < 10; i++){ if (i == 5) { break; } Console.Write(i + “ “);} // 0 1 2 3 4

for (int i = 0; i < 10; i++){ if (i % 2 == 0) { continue; } Console.Write(i + “ “);} // 1 3 5 7 9

Instrucţiuni de salt

try{ /* instrucţiuni ce pot arunca excepţii */ ...}catch (Exception ex){ /* excepţia este prinsă şi tratată aici */ ...}finally{ /* instrucţiuni invariabil executate ulterior */ ...}

Structuri de control

ELEMENTE DE PROGRAMARE ORIENTATĂ OBIECT

Concepte fundamentaleClasăDefineşte caracteristicile abstracte ale unui lucru (obiect), inclusiv caracteristicile (atribute, câmpuri, proprietăţi) şi comportamentul (acţiuni, metode, operaţii) acestuia. Poată fi privită ca o schiţă (blueprint) care descrie ceva. Spre exemplu, clasa Dog ar include caracteristici comune tuturor câinilor, precum rasa şi culoarea blănii (caracteristici), precum şi abilitatea de a lătra şi şedea (comportamente). Clasele oferă astfel modularitate şi structură într-un program orientat obiect. De obicei conceptul implementat de către o clasă este recognoscibil inclusiv unui non-programator familiar cu domeniul problemei, caracteristicile clasei pur şi simplu având sens în context. De asemenea, codul unui clase se presupune a fi relativ independent (self-contained), utilizând principiul încapsulării (encapsulation). Colectiv, proprietăţile şi metodele unei clase se numesc membri.

ELEMENTE DE PROGRAMARE ORIENTATĂ OBIECT

ObiectO instanţă a unei clase. Clasa Dog defineşte toate tipurile posibile de câini listând caracteristicile şi comportamentele pe care le pot afişa; obiectul Lassie este un câine particular, cu versiuni particulare ale acestor trăsături. Un câine (Dog) are blana de o culoare oarecare; Lassie în schimb are blana de culoare maro cu alb, fiind un collie. Ansamblul valorilor proprietăţilor unui anumit obiect definesc starea acestuia.

MetodăAbilităţile unui obiect. În limbaj natural metodele (referite uneori şi drept “funcţii”) sunt verbe. Lassie, fiind un câine (Dog), poate lătra – deci bark() este una din metodele sale. Mai poate prezenta desigur şi alte metode, precum sit() sau eat() sau walk() sau save_timmy(). De obicei utilizarea unei metode în program afectează numai un obiect vizat; toţi câinii (Dog-s) pot lătra, dar ne interesează ca numai unul oarecare să facă aceasta.

using System;

namespace HelloWorld{ class Dog { string breed, fur_color; // câmpuri

public Dog(string breed, string fur_color) // constructor { this.breed = breed; this.fur_color = fur_color; }

public string Breed // accesor { get { return this.breed; } set { this.breed = value; } } public string Fur_color // <prop> + <TAB> { get { return this.fur_color; } set { this.fur_color = value; } }

public void bark() { Console.WriteLine("Woof!"); Console.Beep(); } }

class Program { static void Main(string[] args) { Dog Lassie = new Dog("collie", "brown-and-white"); // crearea unei instanţe a clasei Dog Lassie.Fur_color = "brown-and-pearl"; Console.WriteLine("Lassie is a " + Lassie.Breed + " with " + Lassie.Fur_color + " fur."); Lassie.bark(); } }}

Exemplu Lassie is a collie with brown-and-pearl fur.Woof!

ELEMENTE DE PROGRAMARE ORIENTATĂ OBIECT

Moştenire“Sub-clasele” sunt versiuni mai specializate ale unei clase părinte care moştenesc atributele şi comportamentele acesteia, adăugând în acelaşi timp un subset propriu. Spre exemplu, clasa Dog poate avea sub-clasele denumite Collie, Chihuahua şi GoldenRetriever. În acest caz, obiectul Lassie ar fi o instanţă a sub-clasei Collie. Să presupunem că în clasa Dog sunt definite o metodă denumită bark() şi o proprietate denumită furColor. Fiecare din sub-clasele sale (Collie, Chihuahua şi GoldenRetriever) va moşteni aceşti membri, ceea ce înseamnă că programatorul trebuie să scrie codul pentru toate acestea o singură dată. Fiecare sub-clasă poate modifica caracteristicile moştenite. Spre exemplu, clasa Collie poate specifica o valoare predefinită pentru furColor, maro cu alb. Clasa Chihuahua poate utiliza o tonalitate mai înaltă la generarea unui lătrat via metoda bark(). Sub-clasele pot de asemenea să adauge noi membri – Chihuahua poate prezenta o metodă denumită tremble(). Deci o instanţă individuală de tip Chihuahua, fie aceasta Tinkerbell, ar folosi metoda bark() cu tonalitate înaltă din sub-clasă, care mai departe a moştenit metoda bark() normală din Dog. Tinkerbell ar prezenta metoda tremble(), dar Lassie nu – deoarece este un Collie, nu un Chihuahua. De fapt, moştenirea este o relaţie de tip “un… este un” între clase, în timp ce instanţierea este o relaţie de tip “este un” între un obiect şi o clasă: un Collie este un Dog, dar Lassie este un Collie. Deci obiectul numit Lassie are metodele din ambele clase Collie şi Dog.

using System;

namespace HelloWorld{ class Dog { protected string breed, fur_color;

// public Dog() // { // }

public Dog(string breed, string fur_color) { this.breed = breed; this.fur_color = fur_color; }

public string Breed { get { return this.breed; } set { this.breed = value; } } public string Fur_color { get { return this.fur_color; } set { this.fur_color = value; } }

public void bark() { Console.WriteLine("Woof! [" + this.GetType() + "]"); Console.Beep(); } }

class Collie : Dog { public Collie() : base("collie", "brown-and-white") { // base.breed = "collie"; // base.fur_color = "brown-and-white"; } }

class Chihuahua : Dog { public Chihuahua(string fur_color) : base("chihuahua", fur_color) { // base.breed = "chihuahua"; // base.fur_color = fur_color; }

public new void bark() { Console.WriteLine("Woof! [" + this.GetType() + "]"); Console.Beep(1500, 250); } }

class Program { static void Main(string[] args) { Collie Lassie = new Collie(); Lassie.Fur_color = "brown-and-pearl"; Console.WriteLine("Lassie is a " + Lassie.Breed + " with " + Lassie.Fur_color + " fur."); Lassie.bark(); Chihuahua Tinkerbell = new Chihuahua("caramel"); Console.WriteLine("Tinkerbell is a " + Tinkerbell.Breed + " with " + Tinkerbell.Fur_color + " fur."); Tinkerbell.bark(); } }}

Lassie is a collie with brown-and-pearl fur.Woof! [HelloWorld.Collie]Tinkerbell is a chihuahua with caramel fur.Woof! [HelloWorld.Chihuahua]

Exemplu

ELEMENTE DE PROGRAMARE ORIENTATĂ OBIECT

ÎncapsulareÎncapsularea ascunde detaliile funcţionale ale unei clase de obiectele care îi transmit mesaje (pasează date sau invocă o metodă). Spre exemplu, clasa Dog are o metodă bark(). Codul pentru această metodă defineşte exact ce se întâmplă când câinele latră (inhale() apoi exhale() la o anumită tonalitate şi volum). Însă Timmy, prietenul lui Lassie, nu are nevoie să ştie aceste detalii. Încapsularea este realizată specificând anume care clase pot utiliza membrii unui obiect. Rezultatul este că fiecare obiect expune oricărei clase o anumită interfaţă – membrii accesibili acelei clase. Motivaţia din spatele încapsulării este aceea de a împiedica clienţii unei interfeţe să depindă de acele părţi ale implementării care vor fi cel mai probabil supuse schimbărilor în viitor – ceea ce facilitează procesul de modificare fără a afecta pe cineva. Membrii sunt specificaţi ca fiind public (publici), protected (protejaţi) , private (privaţi) sau internal (interni), determinând astfel dacă sunt accesibili tuturor claselor, sub-claselor, clasei ce îi defineşte sau numai claselor din acelaşi assembly (default = private).

ELEMENTE DE PROGRAMARE ORIENTATĂ OBIECT

PolimorfismPolimorfismul permite programatorilor să trateze membrii claselor derivate exact la fel precum membrii claselor părinte. Mai precis, acesta reprezintă abilitatea obiectelor de tipuri diferite să răspundă apelurilor unei metode specifice cu acelaşi nume, fiecare în maniera dictată de felul său. O metodă – sau un operator precum +, - sau * – poate fi aplicat abstract în o multitudine de situaţii. Dacă se emite comanda speak() unui obiect de tip Dog, va rezulta un apel către metoda bark(). În schimb, un obiect de tip Pig va răspunde în aceeaşi situaţie cu un apel către metoda oink(). Amândoi moştenesc speak() din Animal, dar clasele lor derivate suprascriu (override) metodele din clasa părinte – polimorfism de suprascriere. Polimorfismul de supraîncărcare (overload) constituie utilizarea unei signaturi caracteristice a metodei sau folosirea unui operator pentru a efectua diferite operaţii în funcţie de implementare. Operatorul +, de exemplu, poate fi întrebuinţat pentru a executa adunarea unor întregi sau numere în virgulă mobilă sau concatenarea şirurilor. Oricare două sub-clase ale Number – precum Integer şi Double – trebuie să fie capabile să facă o sumă de termeni fără probleme, deci operatorul de adiţie, +, trebuie supraîncărcat corespunzător.

using System;

namespace HelloWorld{ class Employee { public string name; protected decimal basepay;

public Employee(string name, decimal basepay) { this.name = name; this.basepay = basepay; }

public virtual decimal CalculatePay() { return basepay; } }

sealed class FieldEmployee : Employee // sealed = clasa nu mai poate fi moştenită { private decimal fieldbonus;

public FieldEmployee(string name, decimal basepay, decimal fieldbonus) : base(name, basepay) { this.fieldbonus = fieldbonus; } public FieldEmployee(string name, decimal basepay) // overload : base(name, basepay) { this.fieldbonus = 0; }

public override decimal CalculatePay() // override { return basepay + fieldbonus; } }

class Program { static void Main(string[] args) { FieldEmployee employee1 = new FieldEmployee("The Cheshire Cat", 1000, 500); Employee employee2 = new Employee("Alice", 1200); Console.WriteLine(employee1.name + " earned: " + employee1.CalculatePay()); Console.WriteLine(employee2.name + " earned: " + employee2.CalculatePay()); } }}

The Cheshire Cat earned: 1500Alice earned: 1200

Exemplu

using System;

namespace HelloWorld{ class Parent { public virtual void Foo() { Console.WriteLine("Parent > Foo()"); } public void Bar() { Console.WriteLine("Parent > Bar()"); } }

class Child : Parent { public override void Foo() // overriding { Console.WriteLine("Child > Foo()"); } public new void Bar() // hiding { Console.WriteLine("Child > Bar()"); } }

class Program { static void Main(string[] args) { Parent parent = new Parent(); Child child = new Child(); parent.Foo(); parent.Bar(); child.Foo(); child.Bar(); parent = child; parent.Foo(); // metoda apelată ţine de tipul instanţei parent.Bar(); // metoda apelată ţine de tipul variabilei } }}

Parent > Foo()Parent > Bar()Child > Foo()Child > Bar()Child > Foo()Parent > Bar()

Exemplu

ALTE PARTICULARITĂŢI

System.Object este clasa părinte a tuturor celorlalte clase din BCL (rădăcina ierarhiei de tipuri). Implicit, principalele metode (virtuale) moştenite sunt Equals (suportă compararea a două obiecte), Finalize (destructorul default, se ocupă de curăţenie înainte ca obiectul să fie rechiziţionat automat de către garbage collector), GetHashCode (generează un număr corespunzător stării unui obiect pentru a face posibilă utilizarea tabelelor hash), ToString (returnează un şir lizibil uman referitor la instanţa unei clase).

Clasele sunt tipuri referinţă şi structurile sunt tipuri valoare. O structură este alocată pe stivă atunci când este declarată şi variabila corespunzătoare este direct referită prin adresa sa. Clasele sunt diferite prin aceea că memoria este alocată pe heap şi variabila în acest caz se comportă ca un pointer gestionat plasat pe stack ce indirectează către obiect (este o referinţă).

using System;

namespace HelloWorld{ class Point // clasa Point este derivată din System.Object { public int x, y;

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

public override bool Equals(object obj) { if (obj.GetType() != this.GetType()) return false; // this şi obj sunt de acelaşi tip? Point other = (Point)obj; return (this.x == other.x) && (this.y == other.y); // câmpurile x şi y se potrivesc? }

public override int GetHashCode() { return x ^ y; // ^ = XOR }

public override String ToString() // valoarea punctului ca un şir { return String.Format("({0}, {1})", x, y); }

public Point Copy() // returnează o copie superficială a acestui obiect { return (Point)this.MemberwiseClone(); } }

class Program { static void Main(string[] args) { Point p1 = new Point(1, 2); // un nou obiect de tip Point Point p2 = p1.Copy(); // un alt obiect de tip Point care îl copiază pe primul Point p3 = p1; // o altă variabilă care referenţiază primul obiect de tip Point Console.WriteLine(Object.ReferenceEquals(p1, p2)); // p1 şi p2 se referă la două obiecte diferite Console.WriteLine(Object.Equals(p1, p2)); // p1 şi p2 se referă la două obiecte diferite cu ac. valoare Console.WriteLine(Object.ReferenceEquals(p1, p3)); // p1 şi p3 se referă la acelaşi obiect Console.WriteLine("p1's value is: {0}", p1.ToString()); } }}

FalseTrueTruep1's value is: (1, 2)

Exemplu

using System;

namespace HelloWorld{ class aClass { public int x; }

struct aStruct { public int x; }

class Program { static void doClass(aClass c) { c.x = 5; }

static void doStruct(aStruct s) { s.x = 5; }

static void Main(string[] args) { aClass c = new aClass(); c.x = 1; Console.WriteLine("c.x = " + c.x); aStruct s = new aStruct(); s.x = 1; Console.WriteLine("s.x = " + s.x); doClass(c); // o referinţă către clasă este pasată metodei Console.WriteLine("c.x = " + c.x); doStruct(s); // o copie a structurii este pasată metodei Console.WriteLine("s.x = " + s.x); } }}

c.x = 1s.x = 1c.x = 5s.x = 1

class RefExample{ static void Method(ref int i) { i = 1; } static void Main() { int val = 0; // ! Method(ref val); // val = 1 }}

class OutExample{ static void Method(out int i) { i = 1; } static void Main() { int val; Method(out val); // val = 1 }}

Exemplu

using System;

namespace HelloWorld{ partial class Point // Point1.cs { public double X { get; set; } public double Y { get; set; }

public Point(double x, double y) { X = x; Y = y; } }

partial class Point // Point2.cs { public override string ToString() { return String.Format("({0};{1})", X, Y); } }

class OuterClass // default = internal { private int x; public OuterClass(int x) { this.x = x; } public class InnerClass { OuterClass o; public InnerClass(OuterClass o) { this.o = o; } public override string ToString() { return String.Format("{0}", this.o.x); } public static void doOuterClass(OuterClass o) { Console.WriteLine(o.x); } } }

class Program { static void Main(string[] args) { Point p = new Point(1.5, 2.0); Console.WriteLine(p.ToString()); OuterClass o = new OuterClass(1); OuterClass.InnerClass i = new OuterClass.InnerClass(o); Console.WriteLine(i.ToString()); OuterClass.InnerClass.doOuterClass(o); } }}

Exemplu

/* modificatori */abstract, const, event, extern, internal, override, private, protected, public, readonly, sealed, static, unsafe, virtual, volatile

assembly – colecţie de tipuri şi resurse ce formează o unitate logică de funcţionalitate

Clase Membri

public da da

private da da

protected

nu da

internal da da

/* variabile de clasă vs. variabile de instanţă */

using System;

namespace HelloWorld{ class aClass { public static double defaultRadius = 1; public const double PI = 3.14159265; // implicit static public static double CircleArea(double radius) { return aClass.PI * Math.Pow(radius, 2); } }

class Program { static void Main(string[] args) { Console.WriteLine(aClass.CircleArea(aClass.defaultRadius)); aClass.defaultRadius = 2; Console.WriteLine(aClass.CircleArea(aClass.defaultRadius)); } }}

(1,5;2,0)11

3,1415926512,5663706

/* cod nativ */[DllImportAttribute("Kernel32.dll")]private static extern bool SetConsoleTextAttribute(IntPtr hConsoleOutput, int wAttributes);

Clasele abstracte sunt clase ce servesc numai drept şabloane – pot fi doar moştenite, nu şi instanţiate. Pot exista şi membri abstracţi în cadrul acestora, fără implementări, care trebuie neapărat suprascrişi după o derivare.

using System;

namespace HelloWorld{ abstract class Cat { public string Name { get; set; } public override string ToString() { return Name; } public abstract void meow(); }

class CheshireCat : Cat { public CheshireCat() { this.Name = "The Cheshire Cat"; } public override void meow() // ! { Console.WriteLine(this.ToString() + " - We're all mad here! I'm mad. You're mad."); } }

class Program { static void Main(string[] args) { CheshireCat cc = new CheshireCat(); cc.meow(); } }}

The Cheshire Cat - We're all mad here! I'm mad. You're mad.

Data viitoare: interfeţe vs. clase abstracte

Pe data viitoare! http://students.info.uaic.ro/~florin.cristea/cspi