SlideShare a Scribd company logo
Introduction to C#
Anders Hejlsberg
Distinguished Engineer
Developer Division
Microsoft Corporation
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
 Preservation of investment
C# – The Big Ideas
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 header files, IDL, etc.
 Can be embedded in web pages
C# – The Big Ideas
Everything really is an object
 Traditional views
 C++, Java: Primitive types are “magic” and do
not interoperate with objects
 Smalltalk, Lisp: Primitive types are objects, but
at great performance cost
 C# unifies with no performance cost
 Deep simplicity throughout system
 Improved extensibility and reusability
 New primitive types: Decimal, SQL…
 Collections, etc., work for all types
C# – The Big Ideas
Robust and durable software
 Garbage collection
 No memory leaks and stray pointers
 Exceptions
 Error handling is not an afterthought
 Type-safety
 No uninitialized variables, unsafe casts
 Versioning
 Pervasive versioning considerations in
all aspects of language design
C# – The Big Ideas
Preservation of Investment
 C++ heritage
 Namespaces, enums, unsigned types, pointers
(in unsafe code), etc.
 No unnecessary sacrifices
 Interoperability
 What software is increasingly about
 MS C# implementation talks to XML, SOAP,
COM, DLLs, and any .NET language
 Millions of lines of C# code in .NET
 Short learning curve
 Increased productivity
Hello World
using System;
class Hello
{
static void Main() {
Console.WriteLine("Hello world");
}
}
C# Program Structure
 Namespaces
 Contain types and other namespaces
 Type declarations
 Classes, structs, interfaces, enums,
and delegates
 Members
 Constants, fields, methods, properties, indexers,
events, operators, constructors, destructors
 Organization
 No header files, code written “in-line”
 No declaration order dependence
C# 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;
}
}
}
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";
123
i
s "Hello world"
Type System
 Value types
 Primitives int i;
 Enums enum State { Off, On }
 Structs struct Point { int x, y; }
 Reference types
 Classes class Foo: Bar, IFoo {...}
 Interfaces interface IFoo: IBar {...}
 Arrays string[] a = new string[10];
 Delegates delegate void Empty();
Predefined Types
 C# predefined types
 Reference object, string
 Signed sbyte, short, int, long
 Unsigned byte, ushort, uint, ulong
 Character char
 Floating-point float, double, decimal
 Logical bool
 Predefined types are simply aliases
for system-provided types
 For example, int == System.Int32
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
Structs
 Like classes, except
 Stored in-line, not heap allocated
 Assignment copies data, not reference
 No inheritance
 Ideal for light weight objects
 Complex, point, rectangle, color
 int, float, double, etc., are all structs
 Benefits
 No heap allocation, less GC pressure
 More efficient use of memory
Classes And Structs
class CPoint { int x, y; ... }
struct SPoint { int x, y; ... }
CPoint cp = new CPoint(10, 20);
SPoint sp = new SPoint(10, 20);
10
20
sp
cp
10
20
CPoint
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) {...}
}
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,
}
Delegates
 Object oriented function pointers
 Multiple receivers
 Each delegate has an invocation list
 Thread-safe + and - operations
 Foundation for events
delegate void MouseEvent(int x, int y);
delegate double Func(double x);
Func func = new Func(Math.Sin);
double x = func(1.0);
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
Stream
MemoryStream FileStream
Hashtable double
int
object
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;
123
i
o
123
System.Int32
123
j
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);
Hashtable t = new Hashtable();
t.Add(0, "zero");
t.Add(1, "one");
t.Add(2, "two");
Component Development
 What defines a component?
 Properties, methods, events
 Integrated help and documentation
 Design-time information
 C# has first class support
 Not naming patterns, adapters, etc.
 Not external files
 Components are easy to build
and consume
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;
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]);
Events
Sourcing
 Define the event signature
 Define the event and firing logic
public delegate void EventHandler(object sender, EventArgs e);
public class Button
{
public event EventHandler Click;
protected void OnClick(EventArgs e) {
if (Click != null) Click(this, e);
}
}
Events
Handling
 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");
}
}
Attributes
 How do you associate information
with types and members?
 Documentation URL for a class
 Transaction context for a method
 XML persistence mapping
 Traditional solutions
 Add keywords or pragmas to language
 Use external files, e.g., .IDL, .DEF
 C# solution: Attributes
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 {...}
Attributes
 Attributes can be
 Attached to types and members
 Examined at run-time using reflection
 Completely extensible
 Simply a class that inherits from
System.Attribute
 Type-safe
 Arguments checked at compile-time
 Extensive use in .NET Framework
 XML, Web Services, security, serialization,
component model, COM and P/Invoke interop,
code configuration…
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) {
...
}
}
Statements And
Expressions
 High C++ fidelity
 If, while, do require bool condition
 goto can’t jump into blocks
 Switch statement
 No fall-through, “goto case” or “goto default”
 foreach statement
 Checked and unchecked statements
 Expression statements must do work
void Foo() {
i == 1; // error
}
foreach Statement
 Iteration of arrays
 Iteration of user-defined collections
foreach (Customer c in customers.OrderBy("name")) {
if (c.Orders.Count != 0) {
...
}
}
public static void Main(string[] args) {
foreach (string s in args) Console.WriteLine(s);
}
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);
Operator Overloading
 First class user-defined data types
 Used in base class library
 Decimal, DateTime, TimeSpan
 Used in UI library
 Unit, Point, Rectangle
 Used in SQL integration
 SQLString, SQLInt16, SQLInt32,
SQLInt64, SQLBool, SQLMoney,
SQLNumeric, SQLFloat…
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;
Versioning
 Problem in most languages
 C++ and Java produce fragile base classes
 Users unable to express versioning intent
 C# allows intent to be expressed
 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)
Versioning
class Derived: Base // version 1
{
public virtual void Foo() {
Console.WriteLine("Derived.Foo");
}
}
class Derived: Base // version 2a
{
new public virtual void Foo() {
Console.WriteLine("Derived.Foo");
}
}
class Derived: Base // version 2b
{
public override void Foo() {
base.Foo();
Console.WriteLine("Derived.Foo");
}
}
class Base // version 1
{
}
class Base // version 2
{
public virtual void Foo() {
Console.WriteLine("Base.Foo");
}
}
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);
}
}
}
Unsafe Code
 Platform interoperability covers most cases
 Unsafe code
 Low-level code “within the box”
 Enables unsafe casts, pointer arithmetic
 Declarative pinning
 Fixed statement
 Basically “inline C”
unsafe void Foo() {
char* buf = stackalloc char[256];
for (char* p = buf; p < buf + 256; p++) *p = 0;
...
}
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);
}
More Information
http://msdn.microsoft.com/net
 Download .NET SDK and documentation
http://msdn.microsoft.com/events/pdc
 Slides and info from .NET PDC
news://msnews.microsoft.com
 microsoft.public.dotnet.csharp.general

More Related Content

Similar to Introduction-to-Csharp programacion orientada a objetos (20)

PDF
Introduction to c#
singhadarsh
 
PPT
Introduction to csharp
voegtu
 
PPT
Introduction to csharp
voegtu
 
PPT
Introduction to csharp
hmanjarawala
 
PPTX
PERTEMUAN 1 - MENGENAL ENVIRONTMENT PROGRAM VISUAL C#.pptx
TriSandhikaJaya
 
PPT
Introduction-to-Csharpppppppppppppppp.ppt
kamalsmail1
 
PPT
C#
Joni
 
PPT
Introduction to c_sharp
Jorge Antonio Contre Vargas
 
PDF
1204csharp
g_hemanth17
 
PPTX
OOC MODULE1.pptx
1HK19CS090MOHAMMEDSA
 
PDF
C++ Interview Questions and Answers PDF By ScholarHat
Scholarhat
 
PPTX
Introduction to c_plus_plus
Sayed Ahmed
 
PPTX
Introduction to c_plus_plus (6)
Sayed Ahmed
 
PPT
IntroductionToCSharp.ppt
ReemaAsker1
 
PPT
IntroductionToCSharp.ppt
ReemaAsker1
 
PPT
IntroductionToCSharp.ppt
RishikaRuhela
 
PPT
Introduction toc sharp
SDFG5
 
PPT
IntroductionToCSharppppppppppppppppppp.ppt
kamalsmail1
 
PPT
Understanding linq
Anand Kumar Rajana
 
Introduction to c#
singhadarsh
 
Introduction to csharp
voegtu
 
Introduction to csharp
voegtu
 
Introduction to csharp
hmanjarawala
 
PERTEMUAN 1 - MENGENAL ENVIRONTMENT PROGRAM VISUAL C#.pptx
TriSandhikaJaya
 
Introduction-to-Csharpppppppppppppppp.ppt
kamalsmail1
 
C#
Joni
 
Introduction to c_sharp
Jorge Antonio Contre Vargas
 
1204csharp
g_hemanth17
 
OOC MODULE1.pptx
1HK19CS090MOHAMMEDSA
 
C++ Interview Questions and Answers PDF By ScholarHat
Scholarhat
 
Introduction to c_plus_plus
Sayed Ahmed
 
Introduction to c_plus_plus (6)
Sayed Ahmed
 
IntroductionToCSharp.ppt
ReemaAsker1
 
IntroductionToCSharp.ppt
ReemaAsker1
 
IntroductionToCSharp.ppt
RishikaRuhela
 
Introduction toc sharp
SDFG5
 
IntroductionToCSharppppppppppppppppppp.ppt
kamalsmail1
 
Understanding linq
Anand Kumar Rajana
 

More from KilbertChusiHuamani (20)

PPTX
LOS ARREGLOS base de datos relacionales
KilbertChusiHuamani
 
PPTX
Funciones en MYSQL - base de datos relacionales
KilbertChusiHuamani
 
PPTX
Normalización EN BASE DE DATOS - Ejemplos
KilbertChusiHuamani
 
PPTX
practicanueva ejercicio practico programacion
KilbertChusiHuamani
 
PPTX
Estructuras de control ---- Programacion
KilbertChusiHuamani
 
PPTX
Introduccion a .net y C# Programacion visual II
KilbertChusiHuamani
 
PPTX
Estructuras de Control fundamentos de programacion
KilbertChusiHuamani
 
PPTX
FUNDAMENTOS DE PROGRAMACIÓN curso de fundamentos de programacion
KilbertChusiHuamani
 
PPTX
Ejemplo Normalización en una Base de Datos
KilbertChusiHuamani
 
PPTX
Estructuras de Control en una Base de Datos
KilbertChusiHuamani
 
PPTX
Formularios en HTML5 curso de programacion web
KilbertChusiHuamani
 
PPTX
1-HTML.pptx_6 introduccion a html de web
KilbertChusiHuamani
 
PPTX
PROGRAMACION VISUAL II - Introduccion a C#
KilbertChusiHuamani
 
PPTX
Listas en html5 - introducciona diseño web
KilbertChusiHuamani
 
PPTX
CAPIV_ASPECTOSADMINISTRATIVOS metodologia de la investigacion
KilbertChusiHuamani
 
PPTX
Diseños Experimentales -metodologia de la investigacion
KilbertChusiHuamani
 
PPTX
Marco Teorico - METODOLOGIA DE LA INVESTIGACIÓN
KilbertChusiHuamani
 
PPTX
Introduccion a HTML5 - lenguaje de marcado
KilbertChusiHuamani
 
PPTX
metodo cuadratura de gauss - metodos numericos
KilbertChusiHuamani
 
PPTX
Metodo de Gauss - seidel - metodos numericos
KilbertChusiHuamani
 
LOS ARREGLOS base de datos relacionales
KilbertChusiHuamani
 
Funciones en MYSQL - base de datos relacionales
KilbertChusiHuamani
 
Normalización EN BASE DE DATOS - Ejemplos
KilbertChusiHuamani
 
practicanueva ejercicio practico programacion
KilbertChusiHuamani
 
Estructuras de control ---- Programacion
KilbertChusiHuamani
 
Introduccion a .net y C# Programacion visual II
KilbertChusiHuamani
 
Estructuras de Control fundamentos de programacion
KilbertChusiHuamani
 
FUNDAMENTOS DE PROGRAMACIÓN curso de fundamentos de programacion
KilbertChusiHuamani
 
Ejemplo Normalización en una Base de Datos
KilbertChusiHuamani
 
Estructuras de Control en una Base de Datos
KilbertChusiHuamani
 
Formularios en HTML5 curso de programacion web
KilbertChusiHuamani
 
1-HTML.pptx_6 introduccion a html de web
KilbertChusiHuamani
 
PROGRAMACION VISUAL II - Introduccion a C#
KilbertChusiHuamani
 
Listas en html5 - introducciona diseño web
KilbertChusiHuamani
 
CAPIV_ASPECTOSADMINISTRATIVOS metodologia de la investigacion
KilbertChusiHuamani
 
Diseños Experimentales -metodologia de la investigacion
KilbertChusiHuamani
 
Marco Teorico - METODOLOGIA DE LA INVESTIGACIÓN
KilbertChusiHuamani
 
Introduccion a HTML5 - lenguaje de marcado
KilbertChusiHuamani
 
metodo cuadratura de gauss - metodos numericos
KilbertChusiHuamani
 
Metodo de Gauss - seidel - metodos numericos
KilbertChusiHuamani
 
Ad

Recently uploaded (20)

PPTX
Lecture 1 Shell and Tube Heat exchanger-1.pptx
mailforillegalwork
 
PPTX
美国电子版毕业证南卡罗莱纳大学上州分校水印成绩单USC学费发票定做学位证书编号怎么查
Taqyea
 
PDF
Reasons for the succes of MENARD PRESSUREMETER.pdf
majdiamz
 
PPTX
Introduction to Design of Machine Elements
PradeepKumarS27
 
PPTX
VITEEE 2026 Exam Details , Important Dates
SonaliSingh127098
 
PDF
Electrical Machines and Their Protection.pdf
Nabajyoti Banik
 
PDF
AN EMPIRICAL STUDY ON THE USAGE OF SOCIAL MEDIA IN GERMAN B2C-ONLINE STORES
ijait
 
PDF
20ES1152 Programming for Problem Solving Lab Manual VRSEC.pdf
Ashutosh Satapathy
 
PPTX
Arduino Based Gas Leakage Detector Project
CircuitDigest
 
PPTX
Water Resources Engineering (CVE 728)--Slide 4.pptx
mohammedado3
 
PPT
Footbinding.pptmnmkjkjkknmnnjkkkkkkkkkkkkkk
mamadoundiaye42742
 
PPTX
Element 11. ELECTRICITY safety and hazards
merrandomohandas
 
PDF
Data structures notes for unit 2 in computer science.pdf
sshubhamsingh265
 
PPT
New_school_Engineering_presentation_011707.ppt
VinayKumar304579
 
PPTX
Damage of stability of a ship and how its change .pptx
ehamadulhaque
 
PPTX
Mechanical Design of shell and tube heat exchangers as per ASME Sec VIII Divi...
shahveer210504
 
PDF
Biomechanics of Gait: Engineering Solutions for Rehabilitation (www.kiu.ac.ug)
publication11
 
PDF
MAD Unit - 1 Introduction of Android IT Department
JappanMavani
 
DOC
MRRS Strength and Durability of Concrete
CivilMythili
 
PPTX
Introduction to Internal Combustion Engines - Types, Working and Camparison.pptx
UtkarshPatil98
 
Lecture 1 Shell and Tube Heat exchanger-1.pptx
mailforillegalwork
 
美国电子版毕业证南卡罗莱纳大学上州分校水印成绩单USC学费发票定做学位证书编号怎么查
Taqyea
 
Reasons for the succes of MENARD PRESSUREMETER.pdf
majdiamz
 
Introduction to Design of Machine Elements
PradeepKumarS27
 
VITEEE 2026 Exam Details , Important Dates
SonaliSingh127098
 
Electrical Machines and Their Protection.pdf
Nabajyoti Banik
 
AN EMPIRICAL STUDY ON THE USAGE OF SOCIAL MEDIA IN GERMAN B2C-ONLINE STORES
ijait
 
20ES1152 Programming for Problem Solving Lab Manual VRSEC.pdf
Ashutosh Satapathy
 
Arduino Based Gas Leakage Detector Project
CircuitDigest
 
Water Resources Engineering (CVE 728)--Slide 4.pptx
mohammedado3
 
Footbinding.pptmnmkjkjkknmnnjkkkkkkkkkkkkkk
mamadoundiaye42742
 
Element 11. ELECTRICITY safety and hazards
merrandomohandas
 
Data structures notes for unit 2 in computer science.pdf
sshubhamsingh265
 
New_school_Engineering_presentation_011707.ppt
VinayKumar304579
 
Damage of stability of a ship and how its change .pptx
ehamadulhaque
 
Mechanical Design of shell and tube heat exchangers as per ASME Sec VIII Divi...
shahveer210504
 
Biomechanics of Gait: Engineering Solutions for Rehabilitation (www.kiu.ac.ug)
publication11
 
MAD Unit - 1 Introduction of Android IT Department
JappanMavani
 
MRRS Strength and Durability of Concrete
CivilMythili
 
Introduction to Internal Combustion Engines - Types, Working and Camparison.pptx
UtkarshPatil98
 
Ad

Introduction-to-Csharp programacion orientada a objetos

  • 1. Introduction to C# Anders Hejlsberg Distinguished Engineer Developer Division Microsoft Corporation
  • 2. 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  Preservation of investment
  • 3. C# – The Big Ideas 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 header files, IDL, etc.  Can be embedded in web pages
  • 4. C# – The Big Ideas Everything really is an object  Traditional views  C++, Java: Primitive types are “magic” and do not interoperate with objects  Smalltalk, Lisp: Primitive types are objects, but at great performance cost  C# unifies with no performance cost  Deep simplicity throughout system  Improved extensibility and reusability  New primitive types: Decimal, SQL…  Collections, etc., work for all types
  • 5. C# – The Big Ideas Robust and durable software  Garbage collection  No memory leaks and stray pointers  Exceptions  Error handling is not an afterthought  Type-safety  No uninitialized variables, unsafe casts  Versioning  Pervasive versioning considerations in all aspects of language design
  • 6. C# – The Big Ideas Preservation of Investment  C++ heritage  Namespaces, enums, unsigned types, pointers (in unsafe code), etc.  No unnecessary sacrifices  Interoperability  What software is increasingly about  MS C# implementation talks to XML, SOAP, COM, DLLs, and any .NET language  Millions of lines of C# code in .NET  Short learning curve  Increased productivity
  • 7. Hello World using System; class Hello { static void Main() { Console.WriteLine("Hello world"); } }
  • 8. C# Program Structure  Namespaces  Contain types and other namespaces  Type declarations  Classes, structs, interfaces, enums, and delegates  Members  Constants, fields, methods, properties, indexers, events, operators, constructors, destructors  Organization  No header files, code written “in-line”  No declaration order dependence
  • 9. C# 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; } } }
  • 10. 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"; 123 i s "Hello world"
  • 11. Type System  Value types  Primitives int i;  Enums enum State { Off, On }  Structs struct Point { int x, y; }  Reference types  Classes class Foo: Bar, IFoo {...}  Interfaces interface IFoo: IBar {...}  Arrays string[] a = new string[10];  Delegates delegate void Empty();
  • 12. Predefined Types  C# predefined types  Reference object, string  Signed sbyte, short, int, long  Unsigned byte, ushort, uint, ulong  Character char  Floating-point float, double, decimal  Logical bool  Predefined types are simply aliases for system-provided types  For example, int == System.Int32
  • 13. 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
  • 14. Structs  Like classes, except  Stored in-line, not heap allocated  Assignment copies data, not reference  No inheritance  Ideal for light weight objects  Complex, point, rectangle, color  int, float, double, etc., are all structs  Benefits  No heap allocation, less GC pressure  More efficient use of memory
  • 15. Classes And Structs class CPoint { int x, y; ... } struct SPoint { int x, y; ... } CPoint cp = new CPoint(10, 20); SPoint sp = new SPoint(10, 20); 10 20 sp cp 10 20 CPoint
  • 16. 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) {...} }
  • 17. 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, }
  • 18. Delegates  Object oriented function pointers  Multiple receivers  Each delegate has an invocation list  Thread-safe + and - operations  Foundation for events delegate void MouseEvent(int x, int y); delegate double Func(double x); Func func = new Func(Math.Sin); double x = func(1.0);
  • 19. 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 Stream MemoryStream FileStream Hashtable double int object
  • 20. 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; 123 i o 123 System.Int32 123 j
  • 21. 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); Hashtable t = new Hashtable(); t.Add(0, "zero"); t.Add(1, "one"); t.Add(2, "two");
  • 22. Component Development  What defines a component?  Properties, methods, events  Integrated help and documentation  Design-time information  C# has first class support  Not naming patterns, adapters, etc.  Not external files  Components are easy to build and consume
  • 23. 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;
  • 24. 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]);
  • 25. Events Sourcing  Define the event signature  Define the event and firing logic public delegate void EventHandler(object sender, EventArgs e); public class Button { public event EventHandler Click; protected void OnClick(EventArgs e) { if (Click != null) Click(this, e); } }
  • 26. Events Handling  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"); } }
  • 27. Attributes  How do you associate information with types and members?  Documentation URL for a class  Transaction context for a method  XML persistence mapping  Traditional solutions  Add keywords or pragmas to language  Use external files, e.g., .IDL, .DEF  C# solution: Attributes
  • 28. 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 {...}
  • 29. Attributes  Attributes can be  Attached to types and members  Examined at run-time using reflection  Completely extensible  Simply a class that inherits from System.Attribute  Type-safe  Arguments checked at compile-time  Extensive use in .NET Framework  XML, Web Services, security, serialization, component model, COM and P/Invoke interop, code configuration…
  • 30. 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) { ... } }
  • 31. Statements And Expressions  High C++ fidelity  If, while, do require bool condition  goto can’t jump into blocks  Switch statement  No fall-through, “goto case” or “goto default”  foreach statement  Checked and unchecked statements  Expression statements must do work void Foo() { i == 1; // error }
  • 32. foreach Statement  Iteration of arrays  Iteration of user-defined collections foreach (Customer c in customers.OrderBy("name")) { if (c.Orders.Count != 0) { ... } } public static void Main(string[] args) { foreach (string s in args) Console.WriteLine(s); }
  • 33. 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);
  • 34. Operator Overloading  First class user-defined data types  Used in base class library  Decimal, DateTime, TimeSpan  Used in UI library  Unit, Point, Rectangle  Used in SQL integration  SQLString, SQLInt16, SQLInt32, SQLInt64, SQLBool, SQLMoney, SQLNumeric, SQLFloat…
  • 35. 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;
  • 36. Versioning  Problem in most languages  C++ and Java produce fragile base classes  Users unable to express versioning intent  C# allows intent to be expressed  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)
  • 37. Versioning class Derived: Base // version 1 { public virtual void Foo() { Console.WriteLine("Derived.Foo"); } } class Derived: Base // version 2a { new public virtual void Foo() { Console.WriteLine("Derived.Foo"); } } class Derived: Base // version 2b { public override void Foo() { base.Foo(); Console.WriteLine("Derived.Foo"); } } class Base // version 1 { } class Base // version 2 { public virtual void Foo() { Console.WriteLine("Base.Foo"); } }
  • 38. 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); } } }
  • 39. Unsafe Code  Platform interoperability covers most cases  Unsafe code  Low-level code “within the box”  Enables unsafe casts, pointer arithmetic  Declarative pinning  Fixed statement  Basically “inline C” unsafe void Foo() { char* buf = stackalloc char[256]; for (char* p = buf; p < buf + 256; p++) *p = 0; ... }
  • 40. 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); }
  • 41. More Information http://msdn.microsoft.com/net  Download .NET SDK and documentation http://msdn.microsoft.com/events/pdc  Slides and info from .NET PDC news://msnews.microsoft.com  microsoft.public.dotnet.csharp.general