Introduction to C#
Download
Report
Transcript Introduction to C#
Introduction to .Net/C#
By Oliver
Feb 23, 2011
Outline
Introduction to .NET
Introduction to C#
Data Type
Array
Property
Flow control
Exception handler
Hello world and debug
Microsoft .NET
.NET initiative
Introduced by Microsoft (June 2000)
• Vision for embracing the Internet in software development
Independence from specific language or platform
• Applications developed in any .NET-compatible language
• Visual Basic.NET, Visual C++.NET, C# and more
• Supports portability and interoperability
Architecture capable of existing on multiple
platforms
• Supports portability
Microsoft .NET
Key components of .NET
Web services
• Applications used over the Internet
Software reusability
• Web services provide solutions for variety of companies
• Cheaper than one-time solutions that can’t be reused
• Single applications perform all operations for a company
via various Web services
• Manage taxes, bills, investments and more
• Pre-packaged components using Visual Programming
•
(buttons, text boxes, scroll bars)
• Make application development quicker and easier
Microsoft .NET
Keys to interaction
XML (Extreme Markup Language) and
SOAP (Simple Object Access Protocol)
• “Glue” that combines various Web services
to form applications
• XML gives meaning to data
• SOAP allows communication to occur easily
Microsoft .NET
RTM:
2002(v1.0)
2003 (v1.1)
2005 (v2.0)
2006 (v3.0)
2007 (v3.5)
2010 (v4.0)
…
.NET Framework
.NET Framework
Heart of .NET strategy
• Manages and executes applications and Web services
• Provides security, memory management and other
programming capabilities
Includes Framework Class Library (FCL)
• Pre-packaged classes ready for reuse
• Used by any .NET language
Details contained in Common Language Specification (CLS)
• Submitted to European Computer Manufacturers Association
to make the framework easily converted to other platforms
Executes programs by Common Language Runtime (CLR)
Common Language
Runtime (CLR)
Managed Executable
Legacy
Software
(unmanaged code)
Reusable
Managed Components
Common Language Runtime
(JIT compilation, memory management, etc.)
Windows
(or other operating oystem)
Common Language
Runtime (CLR)
Why two compilations?
Platform independence
• .NET Framework can be installed on different platforms
• Execute .NET programs without any modifications to code
• .NET compliant program translated into platform independent
MSIL
Language independence
•
•
•
•
MSIL form of .NET programs not tied to particular language
Programs may consist of several .NET-compliant languages
Old and new components can be integrated
MSIL translated into platform-specific code
Other advantages of CLR
Execution-management features
• Manages memory, security and other features
• Relieves programmer of many responsibilities
• More concentration on program logic
Compilation And Execution
Compilation
Source
Code
Language
Compiler
Native
Code
JIT Compiler
Execution
Code (IL)
Assembly
Metadata
At installation or
the first time each
method is called
JIT
All managed code runs in native machine
language
However, all managed code is made up of IL
and metadata
The CLR JIT-compiles the IL and metadata
At execution time
Executed directly by CPU
Allows for the best of both worlds
Code management features
Performance of full-speed execution
Garbage Collector
GC is a most important part of CLR
It manages many objects lifetime.
Instead of allocate/delete keywords in C++, objects
are automatically deleted when the application no
longer needs them.
It’s Important to build a efficiently application.
Garbage Collector
string s;
StraighLine line;
s = "dog";
line = new StraightLine(0.5, 2.5);
0.5
"dog"
2.5
line
s
Stack
Heap
Garbage Collector
CLR will run GC automatically to
free all unreachable objects in heap
memory which no references
remained.
Garbage Collector
Free space
object6
object5
object4
object3
x
…
…
a
…
…
Stack
b
banana
object2
object1
…
allocated
Managed Heap
Garbage Collector
Free space
object6
x
…
…
object5
…
…
Stack
object3
a
b
object1
…
allocated
Managed Heap
Garbage Collector
GC demo, show GC collect and
different result in debug and release
mode.
Garbage Collector
GC manages all objects in Heap, but
not any objects been allocated on
Heap, like: Unmanaged resource,
windows handler, DB connection, file
handler…therefore, we need use the
Dispose pattern to clean up the
memory.
Garbage Collector
FileStream fs = new FileStream("Temp.dat",
FileMode.Create);
try
{
fs.Write(bytesToWrite, 0, bytesToWrite.Length);
}
finally
{
if (fs != null)
((IDisposable)fs).Dispose();
}
Garbage Collector
GC events notification have been
added in .Net 4.0.
Summary
CLR will run GC automatically to free all unreachable
objects in heap memory which no references remained.
The GC is only called by the CLR when heap memory
becomes scarce.
The GC only can collect manage resources, all
unmanaged resources need to be collected by
programmer.
The GC will reduce memory leak, but not disappeared.
The .NET Framework Library
Sit on top of the CLR
Reusable types that tightly integrate with the
CLR
Object oriented – inheritance, polymorphism,
etc.
Provide functionality for ASP.NET, XML Web
Services, ADO.NET, Windows Forms, basic
system functionality (IO, XML, etc.)
The .NET Framework Library
System.Web
Services
Description
Discovery
Protocols
System.Windows.Forms
Design
UI
ComponentModel
HtmlControls
WebControls
System.Drawing
Caching
Security
Drawing2D
Printing
Configuration
SessionState
Imaging
Text
System.Data
System.Xml
OleDb
SqlClient
XSLT
Common
SQLTypes
XPath
Serialization
System
Collections
IO
Security
Configuration
Net
ServiceProcess
Diagnostics
Reflection
Text
Runtime
InteropServices
Remoting
Globalization
Resources
Threading
Serialization
Base Framework
Collections
Security
Configuration
ServiceProcess
Diagnostics
Text
Globalization
Threading
IO
Runtime
Net
InteropServices
Reflection
Remoting
Resources
Serialization
Summary
.NET Framework is a code execution platform
.NET Framework consists of two primary parts: .NET
Class Libraries, Common Language Runtime
All CLR-compliant compilers support the common
type system
Managed code is object oriented
Managed code is compiled to and assembly (MSIL)
by language specific compiler
Assemblies are compiled to native code by JIT
compiler
.NET and C#
.NET platform
Web-based applications can be distributed to variety of
devices and desktops
C#
Developed specifically for .NET
Enable programmers to migrate from C/C++ and Java easily
Event-driven, fully OO, visual programming language
Has IDE
Process of rapidly creating an application using an IDE is
called Rapid Application Development (RAD)
C#
Language interoperability
Can interact via internet, using industry
standards (SOAP and XML)
Can interact with software components written in
different languages or with old packaged software
written in C/C++
Simple Object Access Protocol - Helps to share
program “chunks” over the internet
Accommodates a new style of reusable
programming in which applications are created
from building blocks
Data Types/Arrays
System-defined types
Object
User-defined types
String
Array
Primitive types
Boolean
Single
Byte
Double
Int16
Decimal
Int32
DateTime
Int64
TimeSpan
Char
Guid
ValueType
Exception
Delegate
Class1
Enum
Structure1
Multicast
Delegate
Class2
Delegate1
Class3
Enum1
Mapping C# to CTS
Keyword
Description
Special format for literals
bool
Boolean
true false
char
16 bit Unicode character
'A' '\x0041' '\u0041'
sbyte
8 bit signed integer
none
byte
8 bit unsigned integer
none
short
16 bit signed integer
none
ushort
16 bit unsigned integer
none
int
32 bit signed integer
none
uint
32 bit unsigned integer
U suffix
long
64 bit signed integer
L or l suffix
ulong
64 bit unsigned integer
U/u and L/l suffix
float
32 bit floating point
F or f suffix
double
64 bit floating point
no suffix
decimal
128 bit high precision
M or m suffix
string
character sequence
"hello",
@"C:\dir\file.txt"
Value & Reference Types
ctor
Value type always have a default value
Reference type can be null
x =0
obj is null
int x;
MyClass obj;
Value & Reference Types
Memory allocation
Reference type always allocate in heap
Value type always be allocated in a place
where its been declared
Allocate a variable on stack
int x;
Allocate a variable on stack
MyClass obj;
Allocate the object on heap
obj = new MyClass();
Value & Reference Types
0.5
2.5
obj
x
Stack
Heap
Value & Reference Types
Copy
int x;
MyClass obj;
obj = new MyClass();
deep copy
Int y = x;
shallow copy
MyClass objCopy = obj;
Value & Reference Types
Memory Disposal
Once the method has finished running, its local stack-allocated
variable, x, obj, will disappear from scope and be “popped” off the
stack.
GC will automatically deallocate it from the heap some times later.
GC will know to delete it, because the object has no valid referee
(one whose chain of reference originates back to a stack-allocated
object).
C++ programmers may be a bit uncomfortable with this and may
want to delete the object anyway (just to be sure!) but in fact there
is no way to delete the object explicitly. We have to rely on the
CLR for memory disposal—and indeed, the whole .NET framework
does just that!
Type Example
An example of using types in C#
declare before you use (compiler enforced)
initialize before you use (compiler enforced)
declarations
decl + initializer
public class App
{
public static void Main()
{
int width, height;
width = 2;
height = 4;
int area = width * height;
error, x not set
int x;
int y = x * 2;
...
}
}
Type conversion
Some automatic type conversions available
from smaller to larger types
Otherwise you need a cast or an explicit conversion…
typecast syntax is type name inside parentheses
conversion based on System.Convert class
Type conversion
int
double
string
implicit conversion
typecast required
conversion required
i = 5;
d = 3.2;
s = "496";
d = i;
i = (int) d;
i = System.Convert.ToInt32(s);
Boxing and Unboxing
Boxing
Automatic conversion of a value-type in a
reference-type
Object o = 25;
Like:
Unboxing
Conversion of a reference-type into a valuetype
int i= (int)o;
Like:
Boxing and Unboxing
Boxing
Memory is allocated from the
managed heap.
The value type’s fields are copied to
the newly allocated heap memory
The address of the object is returned.
This address is now a reference to an
object
Boxing and Unboxing
Performance
If boxing occurs frequently, it will
wastes memory and hurts
performance.
Because many small objects will be
created on heap, and waiting be clean
up by GC
Instead, we often use generics
method or delegate.
String
How to create a string object.
String’s performance
StringBuilder object
String encoding
String
Create
string s = "496";
String ss = “adasdc”;
String object is immutable. That is, once created, a string
can never get longer, get shorter, or have any of its
characters changed.
String
Bad performance
string s = "496";
String ss = “adasdc”;
String text = s + ” and ” +
ss + “ and …”;
because it creates multiple string objects on the garbagecollected heap.
String
StringBuilder sbText= new stringBuilder();
sbText.append(s);
sbText.append(“ and ”);
sbText.append(ss);
sbText.append(“ and… ”);
string text = sbText.ToString();
String
OR:
string text = String.Format(“{0} and {1}
and…”, s, ss);
Because String.Format() method be implemented by
StringBuilder operations.
String
Encoding
Demo
Collections
Array
Queue
Stack
HashTable
List<T>
Dictionary<Tkey,Tvalue>
…
Arrays
Arrays are reference types
assigned default values (0 for numeric, null for
references, etc.)
create
element access
number of elements
int[] a;
a = new int[5];
a[0] = 17;
a[1] = 32;
int x = a[0] + a[1] + a[4];
int l = a.Length;
Queue
Use Queue to implement a First-In, First-Out type (FIFO)
type of collection:
create
insert an element
pop an element
Queue myQ = new Queue();
myQ.Enqueue( new Robin( 8 ) );
myQ.Enqueue( new BlueJay( 14 ) );
((Bird)myQ.Dequeue()).Speak();
((Bird)myQ.Dequeue()).Speak();
Stack
Use Stack to implement a Last-In, First-Out type (LIFO) type
of collection:
create
insert an element
pop an element
Stack myStack = new Stack();
myStack.Push( new Robin( 8 ) );
myStack.Push( new BlueJay( 14 ) );
((Bird)myStack.Pop()).Speak();
((Bird)myStack.Pop()).Speak();
HashTable
Use Hashtable to implement a dictionary type of collection:
create
insert an element
use an element
Hashtable myHT = new Hashtable();
myHT["Robin"] = new Robin( 8 );
myHT["BlueJay"] = new BlueJay( 14 );
((Bird)myHT["BlueJay"]).Speak();
List<T>
It’s the most commonly collection type, use List<T> to
implement a Robin collection :
create
insert an element
use an element
List<Robin> myList= new List<Robin> ();
myList.Add( new Robin ( 8 );
myList.Add( new Robin ( 10 );
foreach (Robin obj in myList)
{
obj.Speak();
}
Dictionary<Tkey,Tvalue>
It’s the most commonly collection type, use List<T> to
implement a Robin Dictionary:
create
Dictionary<string,Robin> myDic= new
Dictionary<string,Robin>();
string sarah = " Sarah ";
string harold= " harold ";
insert an element
use an element
myDic.Add(sarah , new Robin ( 8 );
myDic.Add(harold , new Robin ( 10 );
if (myDic.ContainsKey(sarah))
{
myDic[sarah].Speak();
}
Dictionary VS Hashtable
Dictionary<K,V> is used in signal threaded application.
Hashtable is a thread safe type, it also can be used in
multi-threaded application.
Hashtable table=Hashtable.Synchronized(new
Hashtable());
Properties
Instead expose a field, in C#, we usually use get/set to
expose a property of class. Like:
Define a Property
Get method block
Set method block
using System;
class MyClassk
{
int _integer;
public int Integer
{
get {return _integer;}
set {_integer = value;}
}
}
Properties
After compilation, we can got the following code from IL
Get method
Set method
class MyClassk
{
int _integer;
public int get_Integer()
{
return _integer;
}
public void set_Integer( int value)
{
_integer = value;
}
}
Properties
To avoid the data be destroyed, we can make a read only
property :
Define a Property
Get method block
using System;
class MyClassk
{
int _integer;
public int Integer
{
get {return _integer;}
}
}
Properties
Property has all features of method
define a virtual Property
get method block
access modifiers
using System;
class MyClassk
{
int _integer;
public virtual int Integer
{
get {return _integer;}
protected set {_integer = value;}
}
}
Properties
Enhanced features of Interface, more componentoriented
define an interface
define a Property
using System;
Interface INameValuePair
{
string Name
{
get;
}
Object Value
{
get;
set;
}
}
Properties Summary
More component-oriented
Accommodate the changes of the feature
JIT often use code inline to speed up application
Code snippet let coding properties more easy.
Iteration & Flow Control
Iteration Constructs
Flow Control
Iteration Constructs
Loop over data
for
foreach
while
do while
Iteration Constructs: for
for (int index = 0; index < int.MaxValue; index++)
{
//just do it...
}
Iteration Constructs: foreach
List<Robin> myList= new List<Robin> ();
myList.Add( new Robin ( 8 );
myList.Add( new Robin ( 10 );
foreach (Robin obj in myList)
{
obj.Speak();
}
Iteration Constructs: while
check first before running
int index = 0;
while (index < int.MaxValue)
{
//just do it...
index++;
}
Iteration Constructs: do while
check after the running
first pass always executed
int index = 0;
Do
{
//just do it...
index++;
} while (index < int.MaxValue);
Flow Control
Flow control statements
if
switch
Flow Control: IF
if ("" == string.Empty)
{
Console.WriteLine("equal");
}
else
{
Console.WriteLine(“not equal");
}
Flow Control: IF
if (string.Empty == “”)
{
Console.WriteLine("equal");
}
else if (string.Empty == null)
{
Console.WriteLine(“equal N");
}
else
{
Console.WriteLine(“not equal");
}
Flow Control: switch
Numeric and string types are allowed
Switch(variable)
{
case a:
//code
break;
case b:
//code
break;
default:
//default code or exception
}
Exception Handling
No matter which kind of programming
languages, exception handling is
always a necessary features.
Try-catch
Finally
Coding practice
Performance
Exception Handling
Try-catch
Place the sections of code that might throw exceptions in a
try block and place code that handles exceptions in a catch
block
try
{
//remote access.
catch
}
catch (InvalidOperationException )
{
throw;
}
Exception Handling
It throws the same exception object that it caught and
causes the CLR to reset its starting point for the
exception:
try
{
//InvalidOperationException
}
catch (InvalidOperationException ex)
{
throw ex;
Incorrect
}
Exception Handling
finally
When an exception occurs, execution stops and control is
given to the closest exception handler. This often means
that lines of code you expect to always be called are not
executed. Some resource cleanup, such as closing a file,
must always be executed even if an exception is thrown. To
accomplish this, you can use a finally block. A finally block
is always executed, regardless of whether an exception is
thrown.
Exception Handling
FileStream fs = null;
try {
try
fs = new FileStream(@"C:\temp\data.txt", FileMode.Open);
StreamReader sr = new StreamReader(fs);
string line;
line = sr.ReadLine();
Console.WriteLine(line);
}
catch
catch
finally
catch (FileNotFoundException e)
{
throw new NameNotFoundException(@"[data.txt not in
c:\temp directory]",e); }
catch (IOException e)
{
throw new NameNotFoundException(@"[data.txt not in
c:\temp directory]",e); }
finally
{
if (fs != null) fs.Close();
}
Exception Handling
User-defined exception
public class EmployeeListNotFoundException: Exception
{
public EmployeeListNotFoundException() { }
public EmployeeListNotFoundException(string message)
: base(message) { }
public EmployeeListNotFoundException(string message,
Exception inner) : base(message, inner) { }
}
Exception Handling
Best Practice
add more friendly information to an
exception when thrown, like parameters…
Never throw an Exception type error, use a
more meaningful exception type instead.
Don’t catch everything
Never ignore any exception
Exception Handling
Incorrect
try {
// try to execute code that the programmer
knows might fail...
}
catch (Exception) {
...
}
This code indicates that it was expecting any and all
exceptions and knows how to recover
from any and all situations. How can this possibly be?
Exception Handling
FileStream fs = new FileStream("Temp.dat", FileMode.Create);
try
{
fs.Write(bytesToWrite, 0, bytesToWrite.Length);
}
finally
{
if (fs != null)
((IDisposable)fs).Dispose();
}
Exception Handling
Using
using (FileStream fs = new FileStream("Temp.dat", FileMode.Create))
{
fs.Write(bytesToWrite, 0, bytesToWrite.Length);
}
Exception Handling
Performance
If an exception occurs frequently,
performance hit of throwing and
catching the exceptions was taking a
large toll on the application’s overall
performance.
Exception Handling
Debugging
Run the DEMO and show how to
debugging exception in Visual studio
2010.
Exception Handling
What’s the result?
static void Main(string[] args)
{
try
{
InternalMethod();
}
catch (InvalidOperationException ex)
{
Console.WriteLine(ex.Message);
}
}
static void InternalMethod()
{
try
{
throw new InvalidOperationException ("try");
}
finally
{
Console.WriteLine("exception finally");
}
}
Hello world
Create a DEMO and debug