20 intro-to-csharp

University of VirginiaCSharp (© John Knight 2005) 1
What’s New In C#

C# Genealogy
Fortran Algol 68 C C++ C#
Cobol
Eiffel
JavaAda 95PL/I Pascal
Elementary
Procedural
Advanced
Procedural
Special
Procedural
Object
Oriented
Advanced
Object
Oriented
Ada 83

C# And .Net
 Languages like C# are not isolated entities
 They interoperate in two ways:
 By being part of a system written in more than one
language
 By accessing services and operating on a distributed
environment
 Requires support from run time:
 .Net and the Common Language Runtime
 .Net is many things, in particular binary object
access
 C# interoperates with .Net

The Simple Stuff
 Most of C# is pretty similar to languages you are
used to:
 Declarations
 Expressions
 Assignment and control statements
 Other elements are quite similar:
 Classes
 Functions
 Polymorphism

Major Topics To Discuss
 Identifier scope system—namespaces
 Type system
 Memory system and pointers
 Execution time environment
 Threads
 Exceptions
 Interfaces

Namespaces
Namespace CS415
Class A
Class B
Class C
 Permits isolation of names
 Can be nested
 Access via fully qualified
names
Namespace CS340
Class A
Class B
Class C
CS415.A…
CS340.A…

Type System
 Type should be consistent:
 Predefined and user-defined
 All C# types derive from System.Object
 Single rooted hierarchy
 Provides four standard methods:
 bool Equals
 int GetHashCode
 Type GetType
 String ToString
These don’t necessarily
mean what you think
Same object (ref) or same value (val)
Retrieve object type (reflection)
Retrieve object type (default)

Types Of Types
 Value types and reference types
 Value types:
 Program variables have a value
 Space allocated on stack
 Reference types:
 Program variable is just a reference
 Allocated space on stack
 Reference is a “type-safe” pointer
 Data space allocated on heap

Value vs. Reference
 Note the “special” status of primitive types
System.Int32 myInt = 42;
System.String myStr = “Hello World”;
Circle c;
c = new Circle(...);
42
address “Hello World”
Stack Heap
myStr
myInt
address Circle objectc
Be careful
with
deallocation
of the space

Boxing And Unboxing
 Conversion between value variable and
reference variable
System.Int32 myInt = 42;
object o = myInt;
int ymInt = (int)o;
42
o 42
Stack Heap
Boxed
myInt
object o
myInt

The Role Of A Type System
 What do we need from a type system?
 Types across languages:
 Consistency
 Compatibility
 Type safety:
 Checking for meaningful statements
 Add “speed” to “distance”?
 C# vs Ada

Memory Layout
Stack Heap
Garbage CollectorFunction Call & Return
Pointers
f() g() h() k()
f calls g, g calls h, h calls k
P*

C# Memory Management
 Static vs. dynamic
 Dynamic storage—stack and heap
 Stack (Dynamic):
 Managed algorithmically by implementation of
function calls
 Heap (Dynamic)
 Mostly managed by system
 Provision for management by programmer

C# Memory Management
 Allocation using new
 Deallocation by Garbage Collection
 Garbage collection:
 Tracks objects that are accessible
 Frees storage associated with objects that are
inaccessible
 Garbage collector is a system provided service that
runs periodically
 Deals with fragmentation

Garbage Collector Pros & Cons
 Pros:
 Programmer does not have to implement
 Memory management done right
 Cons:
 No guarantee when it runs, hence no control
 Takes processor resources
 Does not delete storage if it is still reachable even if
you don’t want it…
 Memory leaks can (and do) still occur

Some Specifics of C#
 Object destruction via Object.Finalize:
 Inherited from Object type
 Override to destroy object as desired
 Garbage collector available via GC class:
 Runs via separate thread
 Various methods available for access
 E.g., GC.collect()
 Pointers—yes, they are provided:
 Syntax like C++, code marked unsafe
 Objects managed by GC or user—pinned
Object
cannot be
moved

Traditional Compilation
Source
Program
Compiler
Object
Program
Linkage
Editor
Object
Program
Loader
Binary
Program
Machine
Instructions For
Specific Target
Object Code
Libraries
Relocatable
Relocatable
Not
Relocatable
Dynamic
Linking
Static
Linking

More Flexible Compilation
Source
Program
Compiler
Microsoft
Intermediate
Language (MSIL)
Program
TARGET
Run-time Support System
Machine
Instructions
For Multiple
Targets
TARGET
Run-time Support System
Interpreter Just-in-Time (JiT) Comp

Concurrency
 Threads vs. processes/tasks
 C# supports threads
Thread Thread Thread
Thread
Data
Communication
Who is
running
and when?
What exactly
are the
problems
here?

C# Threads
 System.Threading namespace
 Facilities include:
 Thread creation, destruction
 Child thread management, e.g. join()
 Thread scheduling, priority, timing
 Synchronization:
 Monitors
 Semphores (mutex class)
 Lock—serialization of statement block

Exceptions
 Why do we need exceptions?
 How should they be made available in programming
languages?
 What benefits do they provide?
 What problems could they cause for us?
 Throw raises an exception
 Catch defines a block that handles the exception
 Etc.

One Thing Is For Sure…
 Exceptions are NOT for dealing with errors
 They are a mechanism for changing the flow of
control from sequential to a branch if certain
conditions exist
 They always indicate expected circumstances.
Otherwise they could not possibly be
generated

20 intro-to-csharp

Related slideshows

More Related Content

20 intro-to-csharp