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.