1

Välkommen till Sommarkollo

2006

2006

Johan Lindfors.NET Framework 2.0

Mål med presentationen Rekommendationer och tips

Delegater Resurshantering

Nyheter i CLR och språken Generics Anonyma metoder Iteratorer Delade klasser

Nyheter i ramverket

Men först lite tips! Externa verktyg

IL Disassembler - CTRL+K+Q Reflector - CTRL+K+T

En klass att känna till Stopwatch

Annat i Visual Studio Starta flera projekt Snippets

CodePlex

Metodik för att hantera kod som genomgår evolution

Visual Studio 2005 levereras med stöd för refactoring-processen Promote Extract Encapsulate Rename

Ytterligare förbättringar...

”Refactoring”

Datatyper Primitiva

System.Int32 = int System.Boolean = bool Försök att använda .TryParse(...)

Värdetyper Lever på stacken

Referenstyper Lever i ”heapen” med pekare i stacken Operatorn == jämför referenser

Undantaget är string

Strängar Strängar är ”immutable”

När de väl är skapade kan inte innehållet förändras

StringBuilder Sammanfogar

StringComparer Jämför

Arrayer Rekommendation:

Returnera alltid en array med 0 element istället för null!

Om du vill skapa ”icke-noll” indexint[] lowerBounds = { 2000, 1 };

int[] lengths = { 6, 4 };

Decimal[,] revenue = (Decimal[,]) Array.CreateInstance( typeof(Decimal), lengths, lowerBounds);

Person[] people = GetPeople();for (int i = 0; i < people.Length; i++){ ... }

Egenskaper (1/2) ”Vanlig” egenskap

Olika åtkomstnivåer möjligt

private int myProperty;public int MyProperty{ get { return myProperty; } set { myProperty = value; }}

private int myProperty;public int MyProperty{ get { return myProperty; } protected set { myProperty = value; }}

Egenskaper (2/2) Händelser

Indexerareprivate string[] items = null;public string this[int i]{ get { return items[i]; } set { items[i] = value; }}

private EventHandler myEvent;public event EventHandler MyEvent{ add { myEvent += value; } remove { myEvent-= value; }}

En samlingsklass för olika typer

Lagra instanser i strukturen

Hämta instanser

public class Stack{ object[] items; public void Push(object item){…} public object Pop(){…}}

Lite om generiska klasser

Stack stack = new Stack();int i;string s = null;stack.Push(i);stack.Push(s); // Inkonsekvens i typer!

string s = (string)stack.Pop(); // Prestandaförlust

object int

object int

object int

object int

Boxint

Push

Utan Generics

object int

Unboxint

Pop

int

int

int

int

Push

Med Generics

int

Pop

Stack med och utan Generics

Hur kul är det här egentligen?public class IntegerStack{ int[] items; public void Push(int item){…} public int Pop(){…}}

Utan generiska klasser

public class StringStack{ string[] items; public void Push(string item){…} public string Pop(){…}}

Mallen

Användningen

public class Stack<T> //T är generisk typparameter{ T[] items; public void Push(T item){...} public T Pop(){...}}

Med generiska klasser

Stack<int> integerStack = new Stack<int>(); integerStack.Push(1);

Stack<string> stringStack = new Stack<string>();stringStack.Push("Hello, World!");

Flera typer vid definition (”arity”)

Använda aliaser

Begränsningar

public class Point<X,Y>{...}

Point<int,int> point = null;

Detaljer…

using IntegerPoint = Point<int,int>;IntegerPoint point = null;

public class Stack<T> where T: IComparable<T> {...}

public class Node<T> where T: new() { private T item = new T();}

Kan bara konvertera typparametrar till ”interface”

Ärva från en generisk klass

class MyClass<T>{ void SomeMethod(T t) { ISomeInterface something = (ISomeInterface)t; SomeClass somethingElse = (SomeClass)t; // Fel! }}

Mer detaljer…

public class BaseClass<T>{...}

public class ChildClass: BaseClass<string> {...}

Generiska metoderpublic class MyClass{ public void MyMethod<T>(T t) { ... }}

MyClass instance = new MyClass();instance.MyMethod(3);instance.MyMethod("Hello, World!");

Mer detaljer…

Enumeratorer Det är vanligt att iterera genom

samlingar foreach bygger på ett känt mönster. I C# 1.x implementerar vi själva

mönstret. Omständigt och repetetivt om man

vill ha hårdtypning.

public interface IEnumerable { IEnumerator GetEnumerator();}

public interface IEnumerator{ object Current { get; } bool MoveNext(); void Reset();}

Iteratorer Kompilatormagi för att slippa

implementera IEnumerable-mönstret Nya nyckelord

yield return – producerar nästa element yield break – indekerar avslutad iteration

Implementeras som metod/egenskap IEnumerable IEnumerator IEnumerable< T > IEnumerator< T >

”Nullable Types” Nullable<T> löser del utmaningar

java.util.Date är en referenstyp (null) System.DateTime är en värdetyp Nullable<DateTime> kan användas

C# har lite ”enklare” syntax

Tänk på: Boxing/unboxing kan såra

prestandan!

int? nInt = null;

int i = nInt ?? -1;// int i = nInt.HasValue() ? n.Value : -1;

Delade typer Implementera en typ i flera filer

Klasser, strukturer (och gränssnitt i C#) Deklareras med nya nyckelordet partial

En hel del fördelar Stora implementationer kan delas upp Användarkod kan separeras Flera utvecklare kan jobba samtidigt Möjliggör “code-beside” vs “code-

behind” Kan underlätta underhåll och

källkodshantering

Delegater Ett objekt för händelser och

”callback”internal delegate int GetLength(string msg);

internal class GetLength : System.MulticastDelegate{ // Konstruktor internal GetLength(Object obj, IntPtr method); // Metod med samma signatur som källkoden public virtual int Invoke(string msg); // Asynkront mönster public virtual IAsyncResult BeingInvoke( string msg, AsyncCallback callback, Object obj); public virtual int EndInvoke(IAsyncResult result);}

Anonyma Metoder Viss kod anropas bara av

delegater Händelsehanterare och “callback”

Anonyma metoder är en lösning Kod för delegater kan skrivas “in-

line” Kan användas istället för en delegat Påminner om Lisp och Python Kräver kompatibla parametrar och

returvärden

XML WebServices WS-I Basic Profile Stöd för SOAP 1.1 och 1.2 Hanterar generiska typer Egenskaper istället för fält vid proxy Händelsebaserad asynkron

hantering WSDL.EXE

/serverInterface /shareTypes /fields för 1.1 uppträdande

System.Net.NetworkInformation

ADO.NET Förbättringar på DataSet

Binärserialisering DataTable

DataSet för enbart en tabell Ladda och spara som XML

”Factory”-klasser Generiska dataklasser

Batchning

WinForms Nya kontroller

“ToolBar” och menyer (“ToolStrip”) Webbläsare Paneler för ”layout” “Splitter Container” “MaskedEdit”

Nya verktyg för hantering av data Datakontroller

DataGridView (ny Grid Control) DataContainer (nu DataConnector)

ClickOnce Driftsättningsteknik för smarta klienter Paralleller till webbapplikationer

Enkelt för användaren att installera Flexibelt för utvecklaren att uppdatera Applikationer är “isolerade” per användare Kan exekveras med minsta lokala

rättigheter Installeras och exekveras lokalt

Automatisk installation via en länk Kan ske helt utan frågor till användaren

.NET Remoting IPC som kommunikationskanal

ipc://portNamn/objektNamn Säker kommunikation över TCP

<channel ref=”tcp” secure=”true”/> Versionshantering vid serialisering

[OptionalField] Attribut som används vid serialisering

Stöd för Generics och IPv6

Säkerhetsuppdateringar SecureString

Använder DPAPI SecurityContext klass System.Security.AccessControl System.Security.Cryptography

DPAPI Kod och bevisbaserad säkerhet

Bevis för installerad i GAC

Andra förbättringar i FX 2.0 Egenskaper på trådar Semaforer Komprimering av strömmar Konsoluppdateringar HttpListener Seriella portar FTP klasser Debuggningsattribut

www.microsoft.se/partner/education

http://blogs.msdn.com/johanljohan.lindfors@microsoft.com

Exceptions

Minneshantering

Asynkron programmering