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.
Descargar

Introduction to C#