Introduction to C#
Raimonds Rudmanis
Senior Consultant
Microsoft Baltic
Session Prerequisites
This session assumes that you
understand the fundamentals of
Object oriented programming
This is a Level 200 Session
What Will Be Covered Today
Brief introduction to the
.NET framework
C# language overview
Agenda
Hello World
The .NET Framework
Design Goals of C#
Language Features
Hello World
DEMO 1: Hello World
using System;
class Hello
{
static void Main() {
Console.WriteLine("Hello world");
}
}
Agenda
Hello World
The .NET Framework
Design Goals of C#
Language Features
The .NET Framework
Overview
VB
C++
C#
JScript
…
ASP.NET: Web Services
And Web Forms
Windows
forms
ADO.NET: Data and XML
Base Class Library
Common Language Runtime
Visual Studio.NET
Common Language Specification
The .NET Framework
Common Language Runtime
VB
C++
C#
JScript
…
ASP.NET: Web Services
and Web Forms
Windows
Forms
ADO.NET: Data and XML
Base Class Library
Common Language Runtime
Visual Studio.NET
Common Language Specification
The .NET Framework
Common Language Runtime
New Runtime Environment – Common
Language Runtime
Language Interoperability
Common Classes for all Languages
Common Types for all Languages
Runtime Controls Compilation to Machine
Code
Assemblies
Application Domains
The .NET Framework
Common Language Runtime
Simplified development
XCOPY deployment
Scalability
Rich Web clients and safe Web hosting
Potentially multi-platform
Multiple languages (cross inheritance)
Increases productivity
Robust and secure execution environment
.NET Framework and CLR
CLR Execution Model
Source
code
Managed
code
VB
C#
C++
Compiler
Compiler
Compiler
Assembly
IL Code
Assembly
IL Code
Assembly
IL Code
Common Language Runtime
JIT Compiler
Native Code
Operating System Services
Unmanaged
Component
The .NET Framework
.NET Framework Services
VB
C++
C#
JScript
…
ASP.NET: Web Services
and Web Forms
Windows
Forms
ADO.NET: Data and XML
Base Class Library
Common Language Runtime
Visual Studio.NET
Common Language Specification
The .NET Framework
.NET Framework Services
ASP.NET
Windows® Forms
Framework for building rich clients
ADO.NET, Evolution of ADO
Separation of code and presentation
Compiled
Web Forms
Web Services
New objects (e.g., DataSets)
XML support throughout
Agenda
Hello World
The .NET Framework
Design Goals of C#
Language Features
Design Goals of C#
The Big Ideas
The first “Component Oriented”
language in the C/C++ family
Everything really is an object
Next generation robust and
durable software
Preserving your investment
Design Goals of C#
A Component Oriented Language
C# is the first “Component Oriented”
language in the C/C++ family
Component concepts are first class
Properties, methods, events
Design-time and run-time attributes
Integrated documentation using XML
Enables one-stop programming
No external files like header files, IDL, etc.
Can be embedded in ASP pages
Design Goals of C#
Everything Really Is an Object
Traditional views
C# unifies with no performance cost
C++, Java™: Primitive types are “magic”
and do not interoperate with objects
Smalltalk, Lisp: Primitive types are
objects, but at great performance cost
Deep simplicity throughout system
Improved extensibility and reusability
New primitive types: Decimal, SQL…
Collections, etc., work for all types
Design Goals of C#
Robust and Durable Software
Garbage collection
Exceptions
Error handling is not an afterthought
Type-safety
No memory leaks and stray pointers
No uninitialized variables, unsafe casts
Versioning
Pervasive versioning considerations in all
aspects of language design
Design Goals of C#
Preserving Your Investment
C++ Heritage
Real-world useful constructs
Namespaces, enums, pointers (in unsafe
code), unsigned types, etc.
No unnecessary sacrifices
foreach, using, switch on string
decimal type for financial applications
ref and out parameters
Millions of lines of C# code in .NET
Short learning curve
Increased productivity
Design Goals of C#
Interoperability
.NET Languages
XML/SOAP
VB.NET
MC++
JScript
...
C#
COM
OLE Automation
P/Invoke and unsafe code
Dynamic Link Libraries
Agenda
Hello World
The .NET Framework
Design Goals of C#
Language Features
Language Features
Program Structure
Namespaces
Type declarations
Classes, structs, interfaces, enums,
and delegates
Members
Contain types and other namespaces
Constants, fields, methods, properties, indexers,
events, operators, constructors, destructors
Organization
No header files, code written “in-line”
No declaration order dependence
Language Features
Program Structure
using System;
namespace System.Collections
{
public class Stack
{
Entry top;
public void Push(object data) {
top = new Entry(top, data);
}
public object Pop() {
if (top == null) throw new InvalidOperationException();
object result = top.data;
top = top.next;
return result;
}
}
}
Language Features
Type System
Value types
Directly contain data
Cannot be null
Reference types
Contain references to objects
May be null
int i = 123;
string s = "Hello world";
i
s
123
"Hello world"
Language Features
Type System
Value types
Primitives
Enums
Structs
int i;
enum State { Off, On }
struct Point { int x, y; }
Reference types
Classes
Interfaces
Arrays
Delegates
class Foo: Bar, IFoo {...}
interface IFoo: IBar {...}
string[] a = new string[10];
delegate void Empty();
Language Features
Predefined Types
C# predefined types
Reference
Signed
Unsigned
Character
Floating-point
Logical
object, string
sbyte, short, int, long
byte, ushort, uint, ulong
char
float, double, decimal
bool
Predefined types are simply aliases for
system-provided types
For example, int = System.Int32
Language Features
Classes
Single inheritance
Multiple interface implementation
Class members
Constants, fields, methods,
properties, indexers, events,
operators, constructors, destructors
Static and instance members
Nested types
Member access
Public, protected, internal, private
Language Features
Structs
Like classes, except
Ideal for light weight objects
Stored in-line, not heap allocated
Assignment copies data, not reference
No inheritance
Complex, point, rectangle, color
int, float, double, etc., are all structs
Benefits
No heap allocation, less GC pressure
More efficient use of memory
Language Features
Classes and Structs
struct SPoint { int x, y; ... }
class CPoint { int x, y; ... }
SPoint sp = new SPoint(10, 20);
CPoint cp = new CPoint(10, 20);
sp
10
20
cp
CPoint
10
20
Language Features
Interfaces
Multiple inheritance
Can contain methods, properties,
indexers and events
Private interface implementations
interface IDataBound
{
void Bind(IDataBinder binder);
}
class EditBox: Control, IDataBound
{
void IDataBound.Bind(IDataBinder binder) {...}
}
Language Features
Enums
Strongly typed
No implicit conversions to/from int
Operators: +, -, ++, --, &, |, ^, ~
Can specify underlying type
Byte, short, int, long
enum Color: byte
{
Red
= 1,
Green = 2,
Blue = 4,
Black = 0,
White = Red | Green | Blue,
}
Language Features
Delegates
Object oriented function pointers
Multiple receivers
Each delegate has an invocation list
Thread-safe + and - operations
Foundation for framework events
delegate void MouseEvent(int x, int y);
delegate double Func(double x);
Func func = new Func(Math.Sin);
double x = func(1.0);
Language Features
Unified Type System
Everything is an object
All types ultimately inherit from object
Any piece of data can be stored,
transported, and manipulated with no
extra work
object
Stream
MemoryStream
Hashtable
FileStream
int
double
Language Features
Unified Type System
Boxing
Allocates box, copies value into it
Unboxing
Checks type of box, copies value out
int i = 123;
object o = i;
int j = (int)o;
i
123
System.Int32
o
j
123
123
Language Features
Unified Type System
Benefits
Eliminates “wrapper classes”
Collection classes work with all types
Replaces OLE Automation's Variant
Lots of examples in .NET framework
string s = string.Format(
"Your total was {0} on {1}", total, date);
ArrayList al = new ArrayList();
al.Add( new Customer() );
al.Add( 1 );
al.Add( "test" );
Language Features
Component Development
What defines a component?
C# has first class support
Properties, methods, events
Integrated help and documentation
Design-time information
Not naming patterns, adapters, etc.
Not external files
Components are easy to build and
to consume
Language Features
Properties
Properties Are “Smart Fields”
Natural syntax, accessors, inlining
public class Button: Control
{
private string caption;
public string Caption {
get {
return caption;
}
set {
caption = value;
Repaint();
}
}
}
Button b = new Button();
b.Caption = "OK";
String s = b.Caption;
Language Features
Indexers
Indexers are “smart arrays”
Can be overloaded
public class ListBox: Control
{
private string[] items;
public string this[int
index] {
get {
return items[index];
}
set {
items[index] = value;
Repaint();
}
}
}
ListBox listBox = new
ListBox();
listBox[0] = "hello";
Console.WriteLine(listBox[0]);
Language Features
Creating and Firing an Event
Define the Event signature
public delegate void EventHandler(object sender,
EventArgs e);
Define the Event and firing logic
public class Button
{
public event EventHandler Click;
protected void OnClick(EventArgs e) {
if (Click != null) Click(this, e);
}
}
Language Features
Handling an Event
Define and register Event Handler
public class MyForm: Form
{
Button okButton;
public MyForm() {
okButton = new Button(...);
okButton.Caption = "OK";
okButton.Click += new EventHandler(OkButtonClick);
}
void OkButtonClick(object sender, EventArgs e) {
ShowMessage("You pressed the OK button");
}
}
Language Features
DEMO 2: Creating an Event Handler
Define an Event Handler for a button in a
Windows Forms application
Language Features
Attributes
Associate information with types
and members
Traditional solutions
Documentation URL for a class
Transaction context for a method
XML persistence mapping
Add keywords or pragmas to language
Use external files, e.g., .IDL, .DEF
C# solution: Attributes
Language Features
Attributes
public class OrderProcessor
{
[WebMethod]
public void SubmitOrder(PurchaseOrder order) {...}
}
[XmlRoot("Order", Namespace="urn:acme.b2b-schema.v1")]
public class PurchaseOrder
{
[XmlElement("shipTo")] public Address ShipTo;
[XmlElement("billTo")] public Address BillTo;
[XmlElement("comment")] public string Comment;
[XmlElement("items")]
public Item[] Items;
[XmlAttribute("date")] public DateTime OrderDate;
}
public class Address {...}
public class Item {...}
Language Features
Attributes
Attributes can be
Completely extensible
Simply a class that inherits from System.Attribute
Type-safe
Attached to types and members
Examined at run-time using reflection
Arguments checked at compile-time
Extensive use in .NET framework
XML, Web Services, security, serialization,
component model, COM and P/Invoke interop,
code configuration…
What Is A Web Service?
HTML
= user-to-machine
XML/SOAP = machine-to-machine
Leveraging the Web
Same
infrastructure
Same programming model
Anyone can play
Truly
scalable distributed applications
Stateless
and loosely coupled
Both Internet and intranet
How Does It Work?
Find a Service
http://www.uddi.org
Link to DISCO or WSDL document
UDDI
Discovery
Web
Service
Consumer
http://myservice.com
HTML or XML with link to WSDL
How do we talk? (WSDL)
http://myservice.com?wsdl
XML with service descriptions
Let’s talk (SOAP)
http://myservice.com/svc1
XML/SOAP BODY
Web
Service
Web Services With .NET
The .NET framework provides
a bi-directional mapping
Application
Concepts
Web
Programs
Data
XML
Objects
Schema
XSD
Classes
Services
WSDL
Methods
Invocation
SOAP
Calls
Web Services With .NET
public class OrderProcessor
{
[WebMethod]
public
void SubmitOrder(PurchaseOrder
<?xml version="1.0"
encoding="utf-8"?>order) {...}
} <soap:Envelope>
<soap:Body>
[XmlRoot("Order",
Namespace="urn:acme.b2b-schema.v1")]
<SubmitOrder>
public class
PurchaseOrder
<Order
date=“20010703">
{
<shipTo>Anders Hejlsberg</shipTo>
public
[XmlElement("shipTo")]
string
ShipTo; Gates</billTo>
public string ShipTo;
<billTo>Bill
public
[XmlElement("billTo")]
string
BillTo;
public
string BillTo;
<comment>Overnight
delivery</comment>
public
[XmlElement("comment")]
string
Comment; public string Comment;
<items>
PurchaseOrder
poItems;
= new PurchaseOrder();
public
[XmlElement("items")]
Item[]
public Item[] Items;
<productId>17748933</productId>
po.ShipTo
=
“Anders
Hejlsberg";
public
[XmlAttribute("date")]
DateTime
OrderDate;
public
DateTime OrderDate;
<description>Dom
Perignon</description>
“Bill Gates";
} po.BillTo =</items>
po.OrderDate
= DateTime.Today;
</Order>
…
</SubmitOrder>
OrderProcessor.SubmitOrder(po);
</soap:Body>
</soap:Envelope>
Language Features
DEMO 3: Attributes
Create a Web service by using the
[WebMethod] attribute
Language Features
XML Comments
class XmlElement
{
/// <summary>
///
Returns the attribute with the given name and
///
namespace</summary>
/// <param name="name">
///
The name of the attribute</param>
/// <param name="ns">
///
The namespace of the attribute, or null if
///
the attribute has no namespace</param>
/// <return>
///
The attribute value, or null if the attribute
///
does not exist</return>
/// <seealso cref="GetAttr(string)"/>
///
public string GetAttr(string name, string ns) {
...
}
}
Language Features
DEMO 4: XML Comments
Show how the compiler can auto generate
documentation from the source code using
XML comments
Language Features
Statements and Expressions
High C++ fidelity
if, while, do require bool condition
Switch statement
goto in_label;
No fall-through, “goto case” or “goto
default”
switch( argwhile
)
( i<100 )
Goto can’t jumpstatic
into {blocks
short x = {32767; // Max short
static short
casey0:
= in_label:
32767;
Foreach statement
int i;
case 1:
i++;
Console.WriteLine(“Low”);
}
Checked and try
case
i )goto
break;
//
2:error
case 2;
unchecked foreachif{((string
word
in (myArray.words
ifz(=case
i>0
checked((short)(x
Console.WriteLine(“Med”);
)2:
while
i<100+ )y)); )
statements {
}
break;
Console.WriteLine(“Med”);
{
FileClass
(OverflowException
void
default:
Foo()
break;
file;
if
{ ( j>50e)) word)
Expression } catchConsole.WriteLine(“{0}”,
{ default:
Console.WriteLine(“High”);
i == 1;
goto
// error
out_label;
statements
ifConsole.WriteLine(e.ToString());
}( file
Console.WriteLine(“High”);
i =+ OpenFile()
j;
}
// )error
// error
must do work
if}}( (file = out_label:
OpenFile()) != NULL )
Language Features
For Each Statement
Iteration of arrays
public static void Main(string[] args) {
foreach (string s in args) Console.WriteLine(s);
}
Iteration of user-defined collections
foreach (Customer c in customers.OrderBy("name")) {
if (c.Orders.Count != 0) {
...
}
}
Language Features
Parameter Arrays
Can write “printf” style methods
Type-safe, unlike C++
void printf(string fmt, params object[] args) {
foreach (object x in args) {
...
}
}
printf("%s %i %i", str, int1, int2);
object[] args = new object[3];
args[0] = str;
args[1] = int1;
Args[2] = int2;
printf("%s %i %i", args);
Language Features
Operator Overloading
First class user-defined data types
Used in base class library
Used in the framework
Decimal, DateTime, TimeSpan
Unit, point, rectangle
Used in SQL integration
SQLString, SQLInt16, SQLInt32,
SQLInt64, SQLBool, SQLMoney,
SQLNumeric, SQLFloat…
Language Features
Operator Overloading
public struct DBInt
{
public static readonly DBInt Null = new DBInt();
private int value;
private bool defined;
public bool IsNull { get { return !defined; } }
public static DBInt operator +(DBInt x, DBInt y)
{...}
public static implicit operator DBInt(int x) {...}
public static explicit operator int(DBInt x) {...}
}
DBInt x = 123;
DBInt y = DBInt.Null;
DBInt z = x + y;
Language Features
Versioning
Overlooked in most languages
C# allows intent to be expressed
C++ and Java produce fragile base classes
Users unable to express versioning intent
Methods are not virtual by default
C# keywords “virtual”, “override” and
“new” provide context
C# can't guarantee versioning
Can enable (e.g., explicit override)
Can encourage (e.g., smart defaults)
Language Features
Versioning
class
Base
// version
version2 1
class Base
//
{
} public virtual void Foo() {
Console.WriteLine("Base.Foo");
}
}
class Derived: Base
// version 1
2a
2b
{
virtual
void
Foo()
{{ {
new public
public
override
virtual
void
void
Foo()
Foo()
Console.WriteLine("Derived.Foo");
base.Foo();
} Console.WriteLine("Derived.Foo");
} }
}
Language Features
Conditional Compilation
#define, #undef
#if, #elif, #else, #endif
Simple boolean logic
Conditional methods
public class Debug
{
[Conditional("Debug")]
public static void Assert(bool cond, String s) {
if (!cond) {
throw new AssertionException(s);
}
}
}
Language Features
Unsafe Code
COM integration, P/invoke cover most cases
Unsafe code
Declarative pinning
Low-level code without leaving the box
Enables unsafe casts, pointer arithmetic
Fixed statement
Basically “inline C”
unsafe void Foo() {
char* buf = stackalloc char[256];
for (char* p = buf; p < buf + 256; p++) *p = 0;
...
}
Language Features
Unsafe Code
class FileStream: Stream
{
int handle;
public unsafe int Read(byte[] buffer, int index, int
count) {
int n = 0;
fixed (byte* p = buffer) {
ReadFile(handle, p + index, count, &n, null);
}
return n;
}
[dllimport("kernel32", SetLastError=true)]
static extern unsafe bool ReadFile(int hFile,
void* lpBuffer, int nBytesToRead,
int* nBytesRead, Overlapped* lpOverlapped);
}
Language Features
COM Support
.Net framework provides great
COM support
TLBIMP imports existing COM classes
TLBEXP exports .NET types
Most users will have a
seamless experience
Language Features
COM Support
Sometimes you need more control
Methods with complicated structures
as arguments
Large TLB – only using a few classes
System.Runtime.Interopservices
COM object identification
Parameter and return value marshalling
HRESULT behavior
Language Features
DEMO 5: COM and C#
Call a COM component from C#
Language Features
DEMO 6: Visual Studio .NET
Windows programming with C#
C# And CLI Standardization
Work
begun in September 2000
Submitted to ECMA (www.ecma.ch)
Active involvement by Intel, HP, IBM,
Fujitsu, Plum Hall, …
Since December 2001
“C#
Language Specification”
“Common Language Infrastructure (CLI)”
C# Books
C# Customers
More Resources
http://msdn.microsoft.com/
C# language specification
C# newsgroups
microsoft.public.dotnet.languages.csharp
Questions?
© 2001 Microsoft Corporation. All rights reserved.
© Copyright 2024 ExpyDoc
