Tipps und Tricks

Themenbereich: C#.NET
C#.NET 4.0 (VS 2010)
Allgemein - DataView - Grid - LinQ - Nintex - Settings - SharePoint - Silverlight - Text - TextBox - Webanwendung - WebService - WPF

Frage (343) zu C#.NET
geprüft mit: 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 Haupt-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.