1 Välkommen till Sommarkollo

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” index int[] 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 Indexerare private 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 Box int Push Utan Generics object int Unbox int Pop 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 är generisk typparameter { T[] items; public void Push(T item){...} public T Pop(){...} } Med generiska klasser Stack integerStack = new Stack (); integerStack.Push(1); Stack stringStack = new Stack (); stringStack.Push("Hello, World!");

Flera typer vid definition (”arity”) Använda aliaser Begränsningar public class Point {...} Point point = null; Detaljer… using IntegerPoint = Point ; IntegerPoint point = null; public class Stack where T: IComparable {...} public class Node where T: new() { private T item = new T(); }

Kan bara konvertera typparametrar till ”interface” Ärva från en generisk klass class MyClass { void SomeMethod(T t) { ISomeInterface something = (ISomeInterface)t; SomeClass somethingElse = (SomeClass)t; // Fel! } Mer detaljer… public class BaseClass {...} public class ChildClass: BaseClass {...}

Generiska metoder public class MyClass { public void MyMethod (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 IEnumerator

”Nullable Types” Nullable löser del utmaningar java.util.Date är en referenstyp (null) System.DateTime är en värdetyp Nullable 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 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

Exceptions

Minneshantering

Asynkron programmering