L1

C# PENTRU NCEPTORI
Florin Tudor Cristea Microsoft Student Partners

.NET FRAMEWORK
Microsoft .NET Framework reprezint un cadru
de dezvoltare software care poate fi instalat pe
mainile ce ruleaz familia de sisteme de operare
Microsoft Windows (exist ns n desfurare un
proiect open-source i cross-platform denumit
Mono ce promite un ecosistem mai larg pentru
aplicaiile din familia .NET). Acesta include o
bibliotec vast de soluii la cele mai comune
probleme de programare i o main virtual care
gestioneaz execuia 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 soluii
referitoare la interfaa cu utilizatorul, accesul la
fiiere i baze de date, criptografie, dezvoltarea
de aplicaii web, algoritmi numerici, comunicarea
n reea i nu numai. Este folosit de ctre
programatori, care o combin cu propriul lor cod
pentru a produce aplicaii software.
System, System.Collections, System.Diagnostics,
System.Globalization, System.IO, System.Net,

COMMON LANGUAGE
RUNTIME
Programele scrise pentru framework-ul .NET sunt
executate ntr-un mediu software care
gestioneaz cerinele programelor n timpul
rulrii. Acesta poart numele de Common
Language Runtime (CLR) i ofer
caracteristicile unei maini virtuale, fapt ce
permite programatorilor s creeze aplicaii fr 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,

COMMON LANGUAGE
INFRASTRUCTURE
Common Language Infrastructure (CLI) este
o specificaie deschis dezvoltat de ctre
Microsoft ce definete un mediu software care
permite ca multiple limbaje de nivel nalt s poat
fi folosite pe diferite platforme de operare fr 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),

CIL este un limbaj

de asamblare
orientat obiect,
bazat n ntregime
pe stack (stiv) n
ceea ce privete
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

DESPRE C#
C# este un limbaj de programare cu scop
general, puternic tipizat, orientat obiect.
Caracterizat prin simplitate, expresivitate i
performan, C# uureaz mult scrierea
diverselor aplicaii (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. Urmtoarea versiune propus, 4.0, se afl
n dezvoltare (beta din mai 2009).

DESPRE VISUAL
STUDIO
Microsoft Visual Studioeste un mediu integrat
de dezvoltare (IDE Integrated Development
Environment) produs de Microsoft. Poate fi folosit
att pentru a dezvolta aplicaii tip consol sau cu
interfa grafic (Windows Forms) ct i situri,
aplicaii i servicii web att n cod nativ ct i
n cod gestionat, pe toate platformele suportate
de ctre Microsoft Windows, Windows Mobile,
Windows CE, .NET Framework, .NET Compact
Framework i Microsoft Silverlight.
Versiunea 2008 Professional poate fi descrcat de pe

Crearea unui
proiect

Numele
proiectul
ui

Rularea unui proiect

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

ELEMENTE DE SINTAX
C#
Identificatori
Reprezint numele unui element n cod.

Pot ncepe cu Nu pot ncepe

_ i conine
cu o cifr sau
att minuscule un simbol i
ct i
sunt limitai la
majuscule.
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 cuvnt rezervat ca un identificator: string

@out;

Literali

Valori ntregi
octal
0365, 0[0..7]*
hexazecimal
0xF5, 0x[0..9, A..F, a..f]*
zecimal
245, [1..9][0..9]*
Valori n virgul mobil
23.5F, 23.5f; 1.72E3F, 1.72E3f,
float
1.72e3F, 1.72e3f
23.5, 23.5D, 23.5d; 1.72E3,
double
1.72E3D, ...
Caractere
char
'a', 'Z', '\u0231'
iruri
String
"Hello, world"
Secvene escape
\u urmat de codul hexazecimal
caractere Unicode
corespunztor
Tab
\t
Backspace
\b
Carriage return
\r
Form feed
\f
Backslash
\\
Single quote
\'
Double quote
\"
Line feed
\n

ELEMENTE DE SINTAX C#
int a, b; // declarare
multipl
int a = 2, b = 3; /*
declarare cu
iniializare multipl
*/

Declarare

int MyInt;

/* const vs. readonly */

class Foo
{
const int x1 = 1;
const int x2; // eroare
readonly int x3 = 3, x4, x5;

Variab
ile

Foo() // corect dei x5 nu e

ini.
{
x4 = 4; // corect
const int x6 = 6;
readonly int x7 = 7; //
eroare
}
} /* constantele const sunt
implicit statice */

/* Inferena de tip (type

inference) */
var MyChars = new char[]
{'A', ''}; /* sau char[]
MyChars = new char[]
{'A', ''}; */

int MyInt =
35;
Declarare cu iniializare

= identificatori
cu valori
asociate

int MyInt;
MyInt = 35;
Iniializare

ELEMENTE DE SINTAX C#
void foo()
{
int a;

static int void Main(string[] args)

{
return 0;
}

Metoda Main punctul de

int b;
a = 1;
namespace Foo
} // alt scope
{
class Bar
a = 2;
class Lol
b = 3; // eroare
class Cat
}
Domenii de cod
(scopes)

intrare al aplicaiei

{ ... }
{ ... }
{ ... }

Spaii de nume (namespaces)

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

Categorie operatori

/* termeni cheie: implicit

i explicit (construcia
operatorului de conversie
implicit sau explicit),
as (operatorul de conversie
tacit) */

/* signatura
suprancrcrii unui
operator binar */
public static Complex
operator +(Complex c1,
Complex c2) { ... }
using System;
public class Pointer
{
unsafe static void
Main()
{
int i = 5;
int* j = &i;
Console.WriteLine(*j);
}
} // Output: 5
/* compilatorul trebuie
invocat cu opiunea /unsafe
*/

Operatori

Operatori

Aritmetici

+ - * / %

Logici (booleeni i pe bii)

& | ^ ! ~ && || true false

Concatenare iruri

Incrementare,
decrementare
iftare
Relaionali

++ -<< >>
== != < > <= >=

De asignare

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

Accesul la membri
De indexare
De tipizare (cast)
Condiionali

.
[ ]
( )
? :

De concatenare, nlturare
+ a delegailor
Creare obiect
Informaie despre tip
Controlul excepiei de
overflow

new
as is sizeof typeof

Indirecie i acces

* -> [] &

checked unchecked

switch (pivot)
do
while (boolean)
if (boolean)
{
{
{
{
...
case 'A':
...
...
}
...
}
}
while (boolean)
break;
else if (boolean)
{
for (int i = 0; i < 10; i++)
case 'B':
...
{
case 'C':
}
...
...
else
}
break;
{
...
foreach (int i in intList)
default:
}
{
...
...
break;
Structuri
}
}
condiionale
Structuri iterative

try
{

start:
...
goto start;

/* instruciuni ce pot
arunca excepii */
...
}
catch (Exception ex)
{
/* excepia este prins
i tratat aici */
...
}
finally
{
/* instruciuni invariabil
executate ulterior */
...
}

Instruciuni de salt

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

Structuri de control

ELEMENTE DE PROGRAMARE
ORIENTAT OBIECT
Concepte fundamentale
Clas
Definete caracteristicile abstracte ale unui lucru (obiect), inclusiv
caracteristicile (atribute, cmpuri, proprieti) i comportamentul
(aciuni, metode, operaii) acestuia. Poat fi privit ca o schi
(blueprint) care descrie ceva. Spre exemplu, clasa Dog ar include
caracteristici comune tuturor cinilor, precum rasa i culoarea
blnii (caracteristici), precum i abilitatea de a ltra i edea
(comportamente). Clasele ofer astfel modularitate i structur
ntr-un program orientat obiect. De obicei conceptul implementat
de ctre o clas este recognoscibil inclusiv unui non-programator
familiar cu domeniul problemei, caracteristicile clasei pur i simplu
avnd sens n context. De asemenea, codul unui clase se
presupune a fi relativ independent (self-contained), utiliznd

ELEMENTE DE PROGRAMARE
ORIENTAT OBIECT
Obiect
O instan a unei clase. Clasa Dog definete toate tipurile posibile
de cini listnd caracteristicile i comportamentele pe care le pot
afia; obiectul Lassie este un cine particular, cu versiuni
particulare ale acestor trsturi. Un cine (Dog) are blana de o
culoare oarecare; Lassie n schimb are blana de culoare maro cu
alb, fiind un collie. Ansamblul valorilor proprietilor unui anumit
obiect definesc starea acestuia.

Metod
Abilitile unui obiect. n limbaj natural metodele (referite uneori i
drept funcii) sunt verbe. Lassie, fiind un cine (Dog), poate
ltra 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

using System;
namespace HelloWorld
{
class Dog
{
string breed, fur_color; // cmpuri
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();
}
}

Exemplu

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

ELEMENTE DE PROGRAMARE
ORIENTAT OBIECT
Motenire
Sub-clasele sunt versiuni mai specializate ale unei clase printe care
motenesc atributele i comportamentele acesteia, adugnd n acelai 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 subclasele sale (Collie, Chihuahua i GoldenRetriever) va moteni aceti
membri, ceea ce nseamn c programatorul trebuie s scrie codul pentru toate
acestea o singur dat. Fiecare sub-clas poate modifica caracteristicile
motenite. 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 ltrat 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 motenit metoda bark() normal din Dog. Tinkerbell ar
prezenta metoda tremble(), dar Lassie nu deoarece este un Collie, nu un

using System;

public new void bark()

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

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; }
}

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_col
+ " fur.");
Tinkerbell.bark();
}
}

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";
}
}

Exemplu

class Chihuahua : Dog

{
public Chihuahua(string fur_color) : base("chihuahua", fur_color)
Lassie is a collie with brown-and-pearl fur.
{
Woof! [HelloWorld.Collie]
// base.breed = "chihuahua";
Tinkerbell is a chihuahua with caramel fur.
// base.fur_color = fur_color;
Woof! [HelloWorld.Chihuahua]
}

ELEMENTE DE PROGRAMARE
ORIENTAT OBIECT
ncapsulare
ncapsularea ascunde detaliile funcionale 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 definete exact ce se ntmpl cnd
cinele 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 specificnd anume care
clase pot utiliza membrii unui obiect. Rezultatul este c fiecare
obiect expune oricrei clase o anumit interfa membrii
accesibili acelei clase. Motivaia din spatele ncapsulrii este
aceea de a mpiedica clienii unei interfee s depind de acele
pri ale implementrii care vor fi cel mai probabil supuse
schimbrilor n viitor ceea ce faciliteaz procesul de modificare
fr a afecta pe cineva. Membrii sunt specificai ca fiind public

ELEMENTE DE PROGRAMARE
ORIENTAT OBIECT
Polimorfism
Polimorfismul permite programatorilor s trateze membrii claselor
derivate exact la fel precum membrii claselor printe. Mai precis,
acesta reprezint abilitatea obiectelor de tipuri diferite s rspund
apelurilor unei metode specifice cu acelai nume, fiecare n maniera
dictat de felul su. O metod sau un operator precum +, - sau *
poate fi aplicat abstract n o multitudine de situaii. Dac se emite
comanda speak() unui obiect de tip Dog, va rezulta un apel ctre
metoda bark(). n schimb, un obiect de tip Pig va rspunde n aceeai
situaie cu un apel ctre metoda oink(). Amndoi motenesc speak()
din Animal, dar clasele lor derivate suprascriu (override) metodele din
clasa printe polimorfism de suprascriere. Polimorfismul de
suprancrcare (overload) constituie utilizarea unei signaturi
caracteristice a metodei sau folosirea unui operator pentru a efectua
diferite operaii n funcie de implementare. Operatorul +, de exemplu,
poate fi ntrebuinat pentru a executa adunarea unor ntregi sau

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 motenit
{
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;
}
}

Exemplu
}

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: 1500
}
Alice earned: 1200

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()");
}
}

Exemplu

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 instanei
parent.Bar(); // metoda apelat ine de tipul variabilei
}
}
}

Parent > Foo()

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

ALTE PARTICULARITI
System.Object este clasa printe a tuturor celorlalte clase
din BCL (rdcina ierarhiei de tipuri). Implicit, principalele
metode (virtuale) motenite sunt Equals (suport
compararea a dou obiecte), Finalize (destructorul default,
se ocup de curenie nainte ca obiectul s fie rechiziionat
automat de ctre garbage collector), GetHashCode
(genereaz un numr corespunztor strii unui obiect pentru
a face posibil utilizarea tabelelor hash), ToString
(returneaz un ir lizibil uman referitor la instana unei clase).
Clasele sunt tipuri referin i structurile sunt tipuri valoare. O
structur este alocat pe stiv atunci cnd este declarat i
variabila corespunztoare este direct referit prin adresa sa.
Clasele sunt diferite prin aceea c memoria este alocat pe

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

False
True
True
p1's value is: (1, 2)

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 acelai tip?
Point other = (Point)obj;
return (this.x == other.x) && (this.y == other.y); // cmpurile 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();
}
}

Exemplu

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 refereniaz 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 acelai obiect
Console.WriteLine("p1's value is: {0}", p1.ToString());
}

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;
}

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
}
}

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 ctre 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);
}

Exemplu

}
}

c.x
s.x
c.x
s.x

=
=
=
=

1
1
5
1

using System;

class Program
{
(1,5;2,0)
namespace HelloWorld
static void Main(string[] args)
1
{
{
1
partial class Point // Point1.cs
Point p = new Point(1.5, 2.0);
{
Console.WriteLine(p.ToString());
public double X { get; set; }
OuterClass o = new OuterClass(1);
public double Y { get; set; }
OuterClass.InnerClass i = new OuterClass.InnerClass(o)
Console.WriteLine(i.ToString());
public Point(double x, double y)
OuterClass.InnerClass.doOuterClass(o);
{
}
X = x;
}
Y = y;
}
}
}
/* variabile de clas vs. variabile de instan */

/* cod nativ */
[DllImportAttribut
e("Kernel32.dll")]
private static
extern bool
SetConsoleTextAttr
ibute(IntPtr
hConsoleOutput,
int wAttributes);
assembly colecie
de tipuri i resurse ce
formeaz o unitate
logic de
funcionalitate
/* modificatori */
abstract, const,
event, extern,
internal, override,
private, protected,
public, readonly,
sealed, static,
unsafe, virtual,
volatile

Exemplu

partial class Point // Point2.cs

{
public override string ToString()
{
return String.Format("({0};{1})", X, Y);
}
}

using System;

3,14159265
12,5663706

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 OuterClass // default = internal

{
private int x;
class Program
public OuterClass(int x)
{
static void Main(string[] args)
{
{
this.x = x;
Console.WriteLine(aClass.CircleArea(aClass.defaultRadius));
}
aClass.defaultRadius = 2;
Console.WriteLine(aClass.CircleArea(aClass.defaultRadius));
public class InnerClass
}
{
}
}
OuterClass o;
public InnerClass(OuterClass o)
{
this.o = o;
}
public override string ToString()
{
return String.Format("{0}", this.o.x);
Clase
Membri
}
public static void doOuterClass(OuterClass o)
{
public
da
da
Console.WriteLine(o.x);
private
da
da
}
}
protecte
nu
da
}
d

using System;

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

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
}
}

Data viitoare:
interfee vs.
clase abstracte

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

Clasele abstracte sunt clase ce servesc numai drept abloane pot fi doar motenite, nu i
instaniate. Pot exista i membri abstraci n cadrul acestora, fr implementri, care trebuie
neaprat suprascrii dup o derivare.

Pe data viitoare!

http://students.info.uaic.ro/~florin.cristea/cs