Tipps und Tricks



Frage (343) zu C#.NET 3.0 (VS 2008), C#.NET 4.0 (VS 2010)

Was war neu in den Versionen in den Versionen des Visual Studios, dem Framework und den Programmiersprachen?

Antwort:

Die Versionen des Visual Studios, des Frameworks und der Compiler können so zusammengefasst werden:

VS2002 - C#1.0 - VB7.0 - FW1.0 - CLR1.0

VS2003 - C#1.1 - VB7.1 - FW1.1 - CLR1.1

VS2005 - C#2.0 - VB8.0 - FW2.0 - CLR2.0

VS2005+extensions - C#2.0 - VB8.0 - FW2.0, 3.0 - CLR2.0

VS2008 - C#3.0 - VB9.0 - FW2.0, 3.0, 3.5 - CLR2.0

voraussichtlich

(VS2010 - C#4.0 - VB10.0 - FW4.0 - CLR4.0)

In C# 2.0 war insbesondere neu:

- generische Typen

- anonyme Methoden: myObject.Event = delegate {mySub};

- Iteratoren: yield

In C# 3.0 war insbesondere neu:

- LINQ: from c on Liste where c.x = "y" select c.y

- LINQ to Objects, DataSets, SQL, Entities, XML

- Type inference: var a = ...

- ildasm für IL-Code anschauen

- Objekt Initialisierer: var p = new C1 {A = "x", B = "x"};

- Anonyme Typen: var p = new { A = "x", B = 0.05f };

- Lambda Ausdrücke: c => c.Ort == "Berlin"; wobei c der Parameter ist

- var x = cust .where (c=>c.City =="x") . select(c=> new{c.name, c.Phone})

- Extension Methods

In VB.NET 10.0 war insbesondere neu:

- automatische Eigenschaften (autoimplemented properties)

- Auflistungsinitialisierer

- integrierte Zeilenfortführung

- Lambda Ausdrücke

- VSTO Softwareverteilung jetzt ohne PIA möglich

- Nutzung der dynamischen Laufzeitumgebung (DLR)

- Co und Contravarianz

In C#.NET 4.0 war insbesondere neu:

- benannte und optionale Argumente

- Com Aufrufe ohne das Schlüsselwort ref

- VSTO Softwareverteilung jetzt ohne PIA möglich

- Unterstützung der späten Bindung (late binding)

- Nutzung der dynamischen Laufzeitumgebung (DLR)

- Co und Contravarianz

In VS2010 ist u.a. neu:

aktualisierte IDE

Komplett neue Oberfläche basierend auf WPF

Zoom Möglichkeiten des Codefensters

Nutzung mehrerer Bildschirme

WPF Designer verbessert (insbes. Unterstützung für Datenbindung)

Unterstützung für mehrere Monitore (Multi-Monitor Support)

Test Driven Development (Test First)

Editor erweiterbar mit eigenen Ansichten & Werkzeuge. (Beispiel: Editor so erweitern, das er XML Kommentare anders anzeigt)

Einfache Installation von Erweiterungen durch Visual StudioExtension Directory (Copy&Paste. Keine Reg!), basiert auf Managed Extensiblity Framework (MEF)

Baum der Codereferenzen

Hervorhebung Codereferenzen

Hervorhebung Klammernpaare

Historical Debugger (Rückwärtsdebugging von einem Halte-/Fehlerpunkt)

Debugging mit Fehlerdump

effizientere Webentwicklung

Verwaltung des Lebenszyklus der Entwicklung, u.a. Architecture Explorer

neue Elemente zur Steigerung der Entwicklungsproduktivität, insbesondere für Web-, Windows 7-, Office-Anwendungen

Windows Azure Tools for Microsoft Visual Studio, insbesonder für Cloud-Anwendungen

für Web-Anwendungen: Intellisense für JavaScript, ClickOnce, Silverlight

Unterstützung der Parallelverarbeitung, PLinQ, Erkennung von Konkurrenzbedingungen

Die Metamorphose des delegates in C# kann mit dem folgenden Beispiel gezeigt werden:

[c#]

using System;

namespace ConsoleApplication1

{

class Program

{

delegate void TestDelegate(string s);

static void M(string s) { Console.WriteLine(s); }

static void Main(string[] args)

{

// Originale delegate Syntax

// mit Initialisierung mit benannter Methode

TestDelegate del1 = new TestDelegate(M);

// C# 2.0: Initialisierung eines delegate mit

// inline code, eine sog. "anonymen Methode".

// Als Eingabeparameter wird ein string genommen.

TestDelegate del2 = delegate(string s) { Console.WriteLine(s); };

// C# 3.0. Initialisierung eines delegate mit einem Lambda Ausdruck.

// Der Lambda Ausdruck nimmt einen String als Eingabeparameter (x).

// Der Typ von x wird durch den Compiler ermittelt (inference).

TestDelegate del3 = (x) => { Console.WriteLine(x); };

// Invoke the delegates.

del1("Hallo. Hier ist M, der Zeilen ausgibt:-).");

del2("Und hier wird anonym gearbeitet.");

del3("Zum Schluss ein Lambda Ausdruck.");

Console.ReadLine();

}

}

}

[/c#]

Der Weg zu LinQ als Demo in einer Konsolenanwendung:

[c#]

using System;

using System.Collections.Generic;

using System.Linq;

//using System.Text;

namespace ConsoleApplication2

{

class Program

{

static void Main(string[] args)

{

// 1. Schritt - Type Inference

var s = "Ich bin ein String";

Console.WriteLine("1. Type Inference: \"{0}\" ist vom Typ \"{1}\"", s, s.GetType());

// 2. Schritt - Objektinitialisierung

Artikel art1 = new Artikel

{

Nummer = "Artikel01",

Bezeichnung = "Artikel 01",

Preis = 110.11m

};

// dasselbe mit Listen

Console.WriteLine("2. Artikelliste");

List<Artikel> listOfArticles = new List<Artikel>()

{ new Artikel(){ Nummer="Artikel02", Bezeichnung="Artikel 02", Preis=55.55m},

new Artikel(){ Nummer="Artikel03", Bezeichnung="Artikel 03", Preis=66.66m},

art1 };

foreach (var art in listOfArticles)

{

Console.WriteLine(" {0}", art.Bezeichnung);

}

// 3. Schritt - Schleife mit Bedingung

Console.WriteLine("3. Artikelliste, eingeschränkt, althergebracht");

foreach (var art in listOfArticles)

{

if (art.Preis > 60m)

Console.WriteLine(" {0,12}, Preis: {1,6} EUR", art.Bezeichnung, art.Preis);

}

// 4. Schritt - Nutzung von Extensions

Console.WriteLine("4. Artikelliste, eingeschränkt, über Extensions");

var res4 = listOfArticles.Where<Artikel>(a => a.Preis > 60m);

foreach (var art in res4)

{

Console.WriteLine(" {0,12}, Preis: {1,7} EUR", art.Bezeichnung, art.Preis);

}

// 5. Schritt - eigene Extensions

Console.WriteLine("5. Artikelliste, eingeschränkt, über eigene Extension");

var res5 = listOfArticles.Where<Artikel>(a => a.Brutto() > 60m);

foreach (var art in res5)

{

Console.WriteLine(" {0,12}, Preis: {1,8:#0.00} EUR", art.Bezeichnung, art.Brutto());

}

// 6. Schritt - LinQ

Console.WriteLine("6. Artikelliste, eingeschränkt, über LinQ");

var res6 = from a in listOfArticles where a.Brutto() > 70m select a;

Console.WriteLine(" Typ des Ergebnisses: {0}", res4.GetType());

foreach (var art in res6)

{

Console.WriteLine(" {0,12}, Preis: {1,9:#0.00} EUR", art.Bezeichnung, art.Brutto());

}

// 7. Schritt - Linq sortiert

Console.WriteLine("7. Artikelliste, eingeschränkt, über LinQ, sortiert");

var res7 = from a in listOfArticles

where a.Brutto() > 70m

orderby a.Bezeichnung

select a;

foreach (var art in res7)

{

Console.WriteLine(" {0,13}, Preis: {1,9:#0.00} EUR", art.Bezeichnung, art.Brutto());

}

// 8. Schritt - Linq mit anonymen Objekten

Console.WriteLine("8. anonyme Objekte, von LinQ erstellt");

var res8 = from a in listOfArticles

where a.Brutto() > 70m

orderby a.Bezeichnung

select new { Artikel = a.Bezeichnung, Bruttopreis = a.Brutto() };

foreach (var art in res8)

{

Console.WriteLine(" {0,14}, Preis: {1,9:#0.00} EUR", art.Artikel, art.Bruttopreis);

}

Console.ReadLine();

}

}

internal class Artikel

{

// Speicherung in BackingField's

// anzuschauen der exe mit ildasm.exe

public string Nummer { get; set; }

public string Bezeichnung { get; set; }

public decimal Preis { get; set; }

}

internal static class MyExtensionForArtikel

{

public static decimal Brutto(this Artikel a)

{

return a.Preis * 1.19m;

}

}

}

[/c#]

Stand des Beitrages: 25.06.11 03:54, zuletzt geändert: 25.06.11 11:54



Bitte wählen sie den Themenbereich aus
Bitte geben sie einen Suchbegriff ein

Die hier dargestellten Tipps und Tricks sind das Ergebnis selbst ersteller Lösungsvarianten, die für Projekte und Schulungen erarbeitet wurden.