Die Webentwicklung ist mit Visual Studio eigentlich recht einfach – man startet ein neues Webprojekt und kann es über F5 direkt testen und seine Anwendung debuggen. Dabei nutzt VS im Standardfall den ASP.NET Development Server "Cassini". Da dieser allerdings nicht immer genau das Verhalten zeigt wie ein richtiger IIS (und auch noch dazu recht langsam ist), gibt es eine einfache Einstellung das zu ändern.
Sicherlich ist es bereits vielen bekannt, allerdings muss ich zugeben, bin ich erst seit "kurzem" darauf gestoßen und es zu den kleinen netten Gimmicks von Visual Studio gehört, die man nicht sofort findet und überhaupt nicht in Visual Studio vermuten würde.
Aufgabenmanagement in Visual Studio?
Seine Aufgaben kann man auf verschiedenste Weise managen: Im Outlook, als Work Items im Team Foundation Server oder in einer beliebigen anderen Applikation. In kleineren oder privaten Projekten habe ich aber z.B. nicht immer ein TFS und das Outlook dafür zu nehmen ist auch ungünstig, weil mir der Bezug zum direkten Code fehlt.
Im Visual Studio 2008 kann man kleinere Sachen oder "Randnotizen" bequem als Kommentar machen und sie werden vom Visual Studio entsprechend darstellt. Dazu muss man unter "View -> Task List" das kleine Fensterchen aktivieren:
Dann hat man im Regelfall ( + 2 kleine ToDos von mir) so eine Ansicht:
Mit einem Doppelklick auf den Task komm ich direkt an die entsprechende Stelle:
Alles was man dafür tun muss: "ToDo: …"
Eigene Tokens anlegen
In den Visual Studio Optionen kann man zudem auch eigene Tokens anlegen:
Das ganze funktioniert Projektübergreifend (ich hab gehört, dass es im Visual Studio 2005 nicht so toll funktionieren soll) und ist recht einfach in der Handhabung.
In größeren Projekten sollte man natürlich für große Aufgaben ein richtiges "Work Item" Tool nehmen (TFS z.B.) – aber kleinere Infos oder ToDos kann man wunderbar darin verwalten und in einem privaten Umfeld ist es sehr nett einzusetzen.
(Nett dass "HACK" bereits schon vordefiniert im Visual Studio ist 
).
Wie bereits viele andere geschrieben haben, ist nun das Service Pack 1 von Visual Studio und dem .NET Framework 3.5 erhältlich.
Hier gehts zu den Downloads.
Dazu bietet Microsoft noch zwei Training Kits an:
Insbesondere beim dem letzten Training Kit sind viele neue Sachen kurz und recht gut dargestellt um ein Gefühl zu bekommen, was das eigentlich nun ist.
Für das Community-Projekt “ReadYou” habe ich nun ein Codeplex Projekt angelegt. Ich werde demnächst ein größeren ReadYou Post bringen – dies ist zur Vorbereitung 
Das HowTo soll nur Anlaufinformationen zu dem ohnehin einfachen Registrierprozess darstellen (falls jemand anderes auch das Interesse hegt, bei Codeplex ein Projekt anzulegen) :
Nachdem wir angemeldet sind, können wir einfach auf der rechten Seite ein neues Projekt anlegen:
Die wichtigsten Daten angeben:
Den Codeplex User Agreements noch zustimmen:
Und da ist unser Projekt:
Nächster Schritt (bzw. hat man Zeit bis zum Releasen) :
Der Wahl einer Softwarelizenz. Es gibt bei Codeplex einige Open Source Lizenzen zur Auswahl, darunter die GPL, Apache Licence oder auch die MS-PL. Welche die richtige ist, ist momentan für mich auch ein Rätsel 
Frist: 30 Tage bis zum Löschen!
Wie bereits oben in dem Screenshot zu sehen ist, gibt es beim Anlegen eine Deadline von 30 Tagen – in dieser Zeit muss das Projekt gepublished werden (ist das überhaupt ein Wort? ) – keiner mag leere Projekte, daher dieser Filter.
Wie verbinde ich mich nun mit dem Projekt?
Ich werde den TFS Team Explorer nehmen, es gibt allerdings noch andere Clients.
Interessant: Continuous Integration mit CruiseControl.NET ist es mit Codeplex möglich – siehe hier. Vielleicht ist das für später ganz interessant.
Die eigentlichen Verbindungsdetails lassen sich über den Reiter “Source Control” abrufen:
Das ganze tippen wir mal in unser Visual Studio über den Team Explorer ein:
Und siehe da – unser leeres Projekt:
Jetzt können wir anfangen Work Items/Source Code hochzuladen – wie genau und was da die Best Practices sind, versuche ich in ein paar HowTos bzw. einem größeren ReadYou Post zu veranschaulichen.
Weitere Informationen findet man auf der Codeplex Seite selbst.
Einführung
Das Konzept der UnitTests (es gibt noch ein paar weitere Formen) ist bereits seit etlichen Jahren (oder Jahrzehnten?) bekannt. Es gibt viele Testframeworks für fast jede Sprache.
Im Visual Studio 2008 (jedenfalls der Professional/Team System Edition) sind UnitTests sehr einfach zu erstellen – und trotzdem hab ich erst vor kurzem die UnitTests für mich entdeckt. Trotz der Gründe für UnitTests und der Einfachheit kenn ich etliche Projekte, wo diese nicht existieren oder angewendet werden.
Die meisten Entwickler denken, dass UnitTests ziemlich komplex sind und eigentlich unnötig.
Die Gründe der Entwickler sind vielfältig (auch ich hab früher so oder so ähnlich gedacht ) :
Ich bin kein Experte in UnitTests, allerdings haben sie mich bereits nach wenigen Minuten begeistert
UnitTests sind sehr schnell gemacht
(Achtung: Diese Aussage nicht auf die Goldwaage legen. Gute und durchdachte UnitTests sind keine leichte Aufgabe – darum gibt es ja z.B. auch eine extra Test Edition von Visual Studio wo sich)
Aber für den Anfang wollen wir die Behauptung mal so stehen lassen – Einfache Tests können sehr schnell durchgeführt werden)
Im Visual Studio 2008 wurde ein extra Template für Tests bereitgestellt:
Zudem kann man direkt in einem Projekt per Kontextmenü auf eine Klasse/Methode ein UnitTest erstellen:
Aber erst mal zur Grundfrage:
Warum sollte ich Tests machen?
Jeder Entwickler will (hoffentlich) gute und funktionstüchtige Software schreiben, die möglichst fehlerfrei ihren Dienst tut.
In der Zeit wo die Software entwickelt wird, werden sicherlich an vielen Ecken (oder Software-Schichten) Änderungen eingepflegt oder die Applikation muss erweitert werden. Insbesondere in einem Team oder wenn eine größere Umstellung ansteht (Datenbasis wechselt, Logik muss abgeändert werden) wird es kritisch: Laufen alle Komponenten noch wie erhofft?
Je größer die Anwendung, desto größer wird der Aufwand der Betrieben muss, um sicherzustellen, dass alles noch läuft.
Ein Test im UserInterface ist zwar machbar, ist allerdings meist sehr anstrengend und zeit intensiv (sollte natürlich auch gemacht werden).
Es wäre doch viel schöner, wenn die Tests automatisch erfolgen könnten – ohne viel Zeit mit Klicken zu verlieren – auch das die Tests jederzeit ausgeführt werden können wäre doch nett, oder?
Hier kommen die UnitTests: Genau sowas machen UnitTests (und noch mehr ).
Stellen wir uns mal vor…
… dass wir eine nicht ganz triviale Software haben, welche verschiedene Layer (Data/Business etc.) hat. Die Software funktioniert gut – der Kunde ist zufrieden und als Entwickler fühlt man sich wohl.
Wie es meistens ist: Der Kunde möchte eine Änderung. Ein neues Attribut soll hier und da angefügt werden, eine Abfragelogik verändert werden und die Validation der Daten soll anders verlaufen.
Das Problem: Die Änderungen können viele Bereiche betreffen, sodass es leicht passieren kann, dass plötzlich garnichts mehr geht. Aber wo genau hakt es denn? Erstmal überall den Debugger ansetzen und nachverfolgen… hoffentlich übersicht man kein Fehler.
Ergebnis: An dieser Stelle ist es meist für den Entwickler ein etwas mulmiges Gefühl – wird die Software noch genauso funktionieren wie vorher (natürlich mit den Änderungen)?
… nun mal mit Tests vorstellen (ein Gedankenspiel) :
Die verschiedenen Methoden wurden während der Entwicklung der Version 1 bereits mit UnitTests getestet. Daten eintragen, löschen, verändern, laden, validieren, Fehler abfangen usw. – alle Aspekte die wichtig sind, wurden als Test hinterlegt.
Nun kommen die Änderungen: Es werden einige kritische Bereiche verändert, aber nach jeder Veränderung kann man automatisch alle Tests abspielen – schlägt der Test fehl, weiß man, wo Handlungsbedarf besteht. Die eben gemachte Änderung war wohl anscheinend nicht so gut.
Nach einer ganzen Weile: Die Tests werden wieder bestanden – das Herz des Entwicklers schlägt höher. Es können zwar immer noch Fehler auftreten (vielleicht muss ein neuer Test für einen neuen Aspekt noch hinzugefügt werden), aber die Grundzüge der Applikation stimmen noch.
Klingt doch eigentlich gut, aber wie sieht das in der Praxis aus:
Ein sehr (zugegeben) doofes Beispiel:
public class DataManager
{
public bool ConnectToData()
{
return true;
}
public List<int> GetData()
{
return new List<int>() { 1, 2, 3, 4, 5, 6, 7 };
}
}
Unser DataManager kann sich zu einer beliebigen Datenquelle verbinden – in unserem Fall sagen wir einfach mal, dass die Verbindung geklappt hat.
Die GetData Methode gibt Daten zurück – in unserem Beispiel ein paar statische Daten.
Da sich die Datenabfrage-Logik ja ändern könnte und da auch die Datenquelle vielleicht sich noch ändert, implementieren wir lieber einen Test dafür:
Create Unit Test…
Methoden auswählen, welche man testen möchte (beide in unserem Fall)…
Name eingeben…
Ein TestProjekt ist entstanden:
Generierter Test (dort steht eigentlich bereits das wichtigste drin) :
Visual Studio nutzt MSTest – das Test-Framework von Microsoft. Es ist ähnlich zu nUnit und co.
using DoNot.Fear.UnitTests.Data;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Collections.Generic;
namespace DoNot.Fear.UnitTests.Test
{
/// <summary>
///This is a test class for DataManagerTest and is intended
///to contain all DataManagerTest Unit Tests
///</summary>
[TestClass()]
public class DataManagerTest
{
private TestContext testContextInstance;
/// <summary>
///Gets or sets the test context which provides
///information about and functionality for the current test run.
///</summary>
public TestContext TestContext
{
get
{
return testContextInstance;
}
set
{
testContextInstance = value;
}
}
#region Additional test attributes
//
//You can use the following additional attributes as you write your tests:
//
//Use ClassInitialize to run code before running the first test in the class
//[ClassInitialize()]
//public static void MyClassInitialize(TestContext testContext)
//{
//}
//
//Use ClassCleanup to run code after all tests in a class have run
//[ClassCleanup()]
//public static void MyClassCleanup()
//{
//}
//
//Use TestInitialize to run code before running each test
//[TestInitialize()]
//public void MyTestInitialize()
//{
//}
//
//Use TestCleanup to run code after each test has run
//[TestCleanup()]
//public void MyTestCleanup()
//{
//}
//
#endregion
/// <summary>
///A test for GetData
///</summary>
[TestMethod()]
public void GetDataTest()
{
DataManager target = new DataManager(); // TODO: Initialize to an appropriate value
List<int> expected = null; // TODO: Initialize to an appropriate value
List<int> actual;
actual = target.GetData();
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
/// <summary>
///A test for ConnectToData
///</summary>
[TestMethod()]
public void ConnectToDataTest()
{
DataManager target = new DataManager(); // TODO: Initialize to an appropriate value
bool expected = false; // TODO: Initialize to an appropriate value
bool actual;
actual = target.ConnectToData();
Assert.AreEqual(expected, actual);
Assert.Inconclusive("Verify the correctness of this test method.");
}
}
}
Die Kommentare und auch den TestContext kann man l̦schen Рich hab ihn bisher nicht gebraucht
Achtung: Ich bin kein Experte in den Unit Tests – sondern ist nur eine Art Erfahrungsbericht
Machen wir doch erstmal einen einfachen Test ob die Verbindung klappt:
[TestMethod()]
public void DataManager_ConnectToData_IsTrue()
{
DataManager man = new DataManager();
Assert.IsTrue(man.ConnectToData());
}
Sehr schlicht, aber genau das was ich wissen muss. Der Name des Tests sollte ungefähr das beschreiben was er macht – damit man sich später noch zurechtfindet. In diesem Fall prüfe ich einfach, ob die Verbindung zustande kommt.
Die Assert-Klasse hat mehrere Methoden:
Jetzt können wir diesen Test durchlaufen und sehen:
Jetzt prüfen wir noch die andere Methode:
[TestMethod()]
public void DataManager_GetData_IsNotNull()
{
DataManager man = new DataManager();
Assert.IsNotNull(man.GetData());
}
[TestMethod()]
public void DataManager_GetData_CheckForZero()
{
DataManager man = new DataManager();
List<int> result = man.GetData();
foreach (int number in result)
{
Assert.AreNotEqual(0, number);
}
}
Die erste Methode prüft, ob überhaupt Werte zurückkommen. Mit dem zweiten Test wollte ich nur mal eine primitive Business-Logik Test machen (”kein Element darf 0 sein”).
Jetzt kann man alle Abspielen:
Ergebnis:
Schön, oder?
Ein Gedankenspiel:
Angenommen in unseren Daten schleicht sich tatsächlich eine 0 ein (Datenabfrage könnte zum Beispiel falsch sein oder es wurden falsche Daten eingetragen), dann schauen wir mal was passiert:
Ergebnis:
Fail!
Idealerweise sollten Tests möglich häufig (sie können sogar automatisch nach jedem Build laufen!) machen – um die Fehlerquelle einzugrenzen.
Angenommen wir haben bei uns einen Fehler in der Abfragelogik oder die Methode (die bei uns nicht existiert, aber existieren könnte) die Daten schreibt, war fehlerhaft oder die Validation fehlgeschlagen ist… (es kann ja viele Quelle geben).
Wir beheben also diesen Fehler (den wir vielleicht sonst nur sehr schlecht gefunden hätten), bis wir wieder das sehen:
Resultat beim Entwickler (& beim zufriedenen Kunden) :
Der Testcode:
[TestMethod()]
public void DataManager_ConnectToData_IsTrue()
{
DataManager man = new DataManager();
Assert.IsTrue(man.ConnectToData());
}
[TestMethod()]
public void DataManager_GetData_IsNotNull()
{
DataManager man = new DataManager();
Assert.IsNotNull(man.GetData());
}
[TestMethod()]
public void DataManager_GetData_CheckForZero()
{
DataManager man = new DataManager();
List<int> result = man.GetData();
foreach (int number in result)
{
Assert.AreNotEqual(0, number);
}
}
Ergebnis:
Die Vorteile von UnitTests werden sicherlich erst nach und nach bei einem Projekt sichtbar, aber wenn man dies stetig fortführt, reduziert sich die Fehleranfälligkeit erheblich.
Das was ich hier gezeigt habe, ist sicherlich nicht das Ende der Fahnenstange – es gibt neben Unit Tests auch noch andere Tests. Das ist auf der MSDN Testing Seite recht gut beschrieben.
Test Driven Development (TDD) :
TDD beschreibt ein Entwicklungsstil, wo auf Tests besonders viel Wert gelegt wird. Hier werden die Tests immer vor der eigentlichen Implementation geschrieben. Man trifft seine Annahmen und da die Methode (oder die zu testende Komponente) ja noch keine Logik enthält, wird der Test erst fehlschlagen.
Nun geht es darum, den Test erfolgreich zu bestehen. Sobald dies geschafft ist, kann man die Implementation hinterher nochmal überarbeiten. (Refactoring). Nun kann man immer wieder prüfen, ob der Test noch funktioniert oder nicht – wenn er nicht mehr stimmt, dann haben wir wohl was falsch gemacht.
Am Ende haben wir (in der Theorie) jede Methode / Komponente mit Tests ausgestattet.
Unit Tests in ASP.NET MVC, Silverlight & co.:
Eine Klassenbibliothek lässt sich relativ leicht testen. In ASP.NET (WebForms) ist dies allerdings nicht ganz so leicht. In ASP.NET MVC wurde darauf ein besonderer Augenmerk gelegt.
Auch in Silverlight 2 wurde das Thema angegangen.
Weitere Links:
Wer nun etwas neugierig geworden ist, der kann sich auch diese Links anschauen:
Download:
Für alle die, die sich für “Spieleentwicklung” interessieren gibt es nun ein neu Version (CTP) vom XNA Game Studio:
Es integriert sich in Visual Studio 2008 – von der Express bis zu den Prof. und bietet .NET 3.5 Unterstützung.
Hier die komplette Ankündigung von Microsoft und der Download Link.
TDD, Unit-Tests & XNA \o/
In diesem HowTo geht es um den Einstieg in das Thema "Databinding" mit der Windows Presentation Foundation (was so eigentlich auch in Silverlight 2 geht).
Wer Databinding aus ASP.NET her kennt, wird sich in die WPF Databinding Möglichkeiten sicherlich verlieben.
Doch erstmal langsam – was ist eigentlich "Databinding"?
Jeder Entwickler kennt es: Im Code häuft man sich irgendwelche Daten an und versucht diese dann in das Frontend zu bekommen. Wenn nun der Nutzer die entsprechenden Felder im Frontend verändert, muss man ein händisches Mapping zwischen den UI Daten und den eigentlichen Daten vornehmen, damit die Änderungen auch gespeichert werden.
Das ist meist ein sehr mühseeliger Prozess, insbesondere da meist auch noch eine Validation gewünscht ist – darf in dem Feld jetzt ein String stehen? In dem Feld sollte nur eine Postleitzahl stehen etc.
Typische Szenarien – im Web ist dies durch das "zustandslose" HTTP schwierig umzusetzen – in ASP.NET wurde es versucht, allerdings meiner Meinung nach nur mit mäßigem Erfolg. In Windows (oder Silverlight) Applikationen sollte dies doch leichter möglich sein.
Genau darum dreht sich Databinding. Insbesondere in WPF gibt es einige Möglichkeiten und ich will hier nur mal den ersten Eindruck vermitteln.
Schritt 1: WPF Projekt anlegen
Als erstes legen wir ein WPF Projekt an:
Notiz am Rande: Das ganze kann man auch mit Expression Blend machen, allerdings werde ich mich hier erstmal nur auf Visual Studio 2008 konzentrieren.
Folgende Projektstruktur wird automatisch angelegt:
Wir halten uns vornehmlich in der "Window1.xaml" auf.
Schritt 2: Klassen anlegen
Damit wir in unserem Beispiel etwas machen können, benötigen wir 2 kleine Klassen:
"Person"
"Title"
Schritt 3: XAML Binding
Um das ganze Thema etwas zu verstehen, legen wir mal ein Binding direkt in der Window1.xaml an. So sieht das Ergebnis aus:
Und so der Code dazu:
Das sieht erstmal recht komplex aus – aber gehen wir Schritt für Schritt durch.
Wir wollen (in einem StackPanel) ein Label befüllen. Dazu befüllen wir es mit dem Binding Element. Über "Source" greifen wir auf eine "StaticResource" auf unser Element namens "MyTitleElement" zu.
Dabei holen wir uns den Wert des Feldes "Value" ab – was ich aber auch BlaBlub nennen hätte können.
Direkt im "Window.Resources" legen wir ein .NET Objekt der Klasse "Title" an (die wir im vorherigen Schritt angelegt haben) und geben ihm über x:Key einen Namen und über die Property "Value" (wie gesagt, hätte auch BlaBlub heißen können) das was wir rein haben wollen.
Der "Path" in dem Binding Element gibt am Ende die eigentliche Quelle an.
Damit wir im XAML solche .NET Objekte anlegen können, müssen wir einen xml Namespace hinzufügen. Über "clr-namespace:…" fügt man .NET Namespaces hinzu.
Um es nochmal hervorzuhebe: Das ganze ohne eine Zeile in der Codebehinde geschrieben zu haben.
Schritt 4: ListBox zur Anzeige von dynamischen Inhalten nehmen.
Um ein etwas komplexeres Beispiel zu zeigen, wollen wir nun mal mehrere "Person" Objekte in einer ListBox anzeigen.
So wird es hinterher aussehen:
Ich hatte jetzt keine große Lust mich erst mit der Formatierung rumzuschlagen Primär gehts hier erstmal um Databinding. In einem anderen HowTo machen wir auch "schöne" Sachen.
Hier der Code dazu:
Wir legen wieder einen Namen an – damit wir im Codebehinde Zugriff darauf haben – und machen unser ItemTemplate – ein "DataTemplate".
Im Codebehinde reicht dann nur wenige Zeile:
Schlussbemerkung
Das ganze Thema Databinding ist natürlich noch um einiges Größer – doch vorerst mach ich hier erstmal Schluss. Das nächste HowTo wird sich dann um das richtige Databinding drehen – mit Dataupdates etc.
Natürlich könnt ihr auch in der MSDN oder hier nachschauen. Für jeden der sich interssiert, würde ich auch die Demos von der VSOne empfehlen.
PS: Ich arbeite mich selber erst in diese Themen ein, daher muss nicht unbedingt alles 100% stimmen. Es hilft mir zum Teil auch, dass ich dies mal aufgeschrieben habe. "Best Practices" sind es also (noch) nicht
Neben dem IE8 wurden heute folgende weitere Sachen zum Download oder Anschauen freigegeben:
ASP.NET MVC
Silverlight 2
Expression Studio
Anderes
Robert hatte vor einiger Zeit eine Lochkarte bekommen. Wie sich herraustellte war das Teil des ARGs The Final Mill und sollte Werbung für das Visual Studio 2008 machen.
Mehr Infos unter:
Vor einige Zeit hatte ich ein Silverlight HowTo geschrieben, in dem es um den bekannten "Spiegeleffekt" ging.
Im Prinzip habe ich das "Hauptobjekt" geklont und entsprechend verändert, damit ein Spiegelungseffekt auftritt. Allerdings bietet WPF noch eine andere Möglichkeit (vielleicht sogar noch mehr…) und zwar über den "VisualBrush".
Wer noch nicht so bewandert mit WPF ist: Ein Brush repräsentiert den "Anstrich" eines Objektes. Es gibt verschiedene Brushs, aber dazu sollte man lieber die MSDN kontaktieren.
Schritt 1: Fangen wir mal langsam an: WPF Projekt & Bild suchen
Wir wollen eine einfache Spiegelung eines Bildes (im meinem Fall ein Windows Standardbild) in einer WPF Anwendung.
Dazu legen wir ein WPF Projekt an – ich mach dies in diesem Fall mit Expression Blend, theoretisch geht es natürlich auch in Visual Studio):
… und holen uns noch ein entsprechendes Bild:
Schritt 2: Das Spiegel vorbereiten
Am Anfang haben wir ein weiße Arbeitsfläche vor uns – diese wollen wir nun mit dem Bild befüllen:
In dem "Grid" wird noch ein "StackPanel" geschrieben, welches ein "Border"-Element mit einem "Image" beinhaltet.
Ergebnis:
Schritt 3: Das Bild duplizieren
Jetzt kommt das große Geheimnis – der Einsatz des VisualBrush:
Der rosa umrahmte Teil wird zur Spiegelung. Über die Background Property setzen wir den Visual Brush auf unser originales Bild. Das ganze kann man dem Themengebiet Databinding zuordnen.
Ergebnis:
Schritt 4: Das Bild spiegeln
Das tatsächliche spiegeln erreichen wir über ein "ScaleTransform":
Ergebnis:
Schritt 5: Durchsichtigkeit in der Spiegelung
Eine Spiegelung setzt immer eine gewisse "durchsichtigkeit" im Verlauf voraus – ansonsten hat man diesen Effekt nicht.
Dies ist über die "Opacity" Property & "Opacity" Mask möglich:
Ergebnis:
Fertig
Wenn man nun noch für den Hintergrund einen netten Farbverlauf einspielt, bekommt man sowas:
Das ganze könnt ihr natürlich ganz unten downloaden.
Quellen
Ich geb zu – in diesem Fall war ich wenig kreativ. Ich habe diesen Blogeintrag gefunden, welcher im Prinzip genau dasselbe macht. Ich hab einige Verlinkungen bei mir hinzugefügt und es einfach mal selber ausprobiert
In der MSDN gibt es auch noch ein anderes Beispiel, allerdings war mir dies zu komplex, zeigt aber, was der VisualBrush alles kann: How to: Create a Reflection
Wer über die Performance nachdenkt, insbesondere in 3D Anwendungen, sollte diese beiden Seiten durchlesen:
Der erste Tag der VSone ist vorbei und ich werde einfach mal ein kurzes Review geben. Vom organisatorischen her, ist es bis jetzt sehr gut verlaufen. Im großen IMAX zu sitzen, kostenlos Popcorn zu bekommen und dabei auf der großen Leinwand eine WPF Entwicklung zu sehen, ist schon sehr cool – auch wenn das für Normalsterbliche sicherlich ein seltsamer Anblick ist
Die Verpflegung ist spitze (und kostenlos) und die Leute sind allesamt recht nett, auch wenn ich teilweise den Altersdurchschnitt etwas senke (wobei Andere ihn wiederrum steigern).
Die Sprecher sind allesamt sehr nett und kann man auch mal leicht etwas über sein Kummer und Leid erzählen.
Nun kurz zu den Themen, die ich heute besucht hatte – es gab pro Track noch mehrere andere Vorträge parallel – interessierte sollten die Blogs von den Sprechern im Auge behalten:
Erstes Vortrag: XAML, WPF & Expression Blend
Ein sehr praktischer Vortrag von Markus Egger – wie frischt man eine einfache “UI” mit WPF auf. Ausführlich wurde dort Expression Blend vorgestellt, was ich zwar schon kannte, allerdings waren mir einige Funktionen noch nicht bekannt. Wie schnell man aus einer langweiligen UI eine schicke Anwendung bastelt (natürlich nur mit dem “Glass Effekt”, hat mich doch etwas angespornt, dort mehr Zeit zu investieren.
Eine andere Sache, die mir dabei ins Auge fiel: In Expression Blend gibt es eine coole “Commandsuche”, man konnte die Menüs ähnlich wie in Vista einfach so durchsuchen und es wurde jeweils das richtige angezeigt – bin mal gespannt, wann das in Office zu finden ist.
Nächster Vortrag: WPF Datenbindung
Ebenfalls sehr praxisbezogen – was versteht man unter Datenbindung, was kann diese und wie sieht das aus. Was spielen “Dependancy Properties” und was sind die “INotification…” Schnittstellen (z.B. INotifyPropertyChanged) – dies waren unter anderem Hauptthemen. Vorgetragen war dies von Christian Nagel. Zusammen mit dem ersten Vortrag, in dem es mehr um das Design ging, hat dieser Vortrag mich besonders als Entwickler begeistert – und wird sicherlich mal den ein oder anderen Blogpost Wert sein.
Nächster Vortrag: Microsoft Sync Framework
Das Microsoft Sync Framework ist noch nicht allzu alt, jedoch bereits in VS 2008 zu finden. In dem Vortrag von Alexander Duggleby ging es nur um dieses Thema. Mich persönlich hat dieses Thema doch recht interessiert und war auch gut vorgetragen. An praktischen Anwendungsfällen fehlt es mir momentan noch, vor allem da mir es noch nicht 100% klar war, wie man die einzelnen Provider (es gibt von MS einige wenige vorgefertige Provider, z.B. einen Fileprovider, um Files zu synchronisieren) einsetzt – aber man stelle sich folgendes vor: Ich lege Bilder in meinen “Eigene Bilder” Ordner und es wird auf mein Flickr, MySpace etc. Profil geladen – und wenn ich mich auf einen anderen Rechner einlogge, kann dies ebenfalls wieder syncronisiert werden. Theoretisch sollte dies gehen. Das wäre mal ein nettes Projekt
Nächster Vortrag: Parallele Programmierung
Zum Anfang war ich hier recht skeptisch, weil viel Zeit mit “nicht .NET Themen” verging – jedoch ergab es hinterher ein sehr rundes Bild, vorgetragen von Bernd Marquardt. Es standen 3 Hauptthemen an – “OpenMP“, was für C++ oder Fortran gedacht ist, “SIMD“, welches ein anderes Modell fährt als “OpenMP” und “LINQ Parallel“, was direkt für C#/.NET momentan als CTP verfügbar ist.
Grundgedanke von “OpenMP”: Leicht mehrere Prozessoren nutzen. Bei einer Schleife von “0-999″ macht Prozessor 1 “0-499″ und Prozessor 2 “500-999″. Dies wurde recht anschaulich demonstriert und vor allen ist der gebrauch recht einfach.
Als zweites kam “SIMD”, was mehr auf die Hardware geht und Prozessoreigenschaften nutzt. Es werden Daten in einem Array in einem Schritt bearbeitet – anstatt einzeln. Das ist zwar auch schick, weil Threads nicht eingesetzt werden, ist aber noch mehr an die Prozessoren gebunden (und der Aufruf ist hässlich) das geht beides nur in C++ (oder OpenMP in managed C++).
“Parallel LINQ” geht einen ähnlichen Weg wie “OpenMP”, allerdings zum Teil mit einem eigenen Syntax. Primär werden hier anonyme Methoden genutzt und wer Lamda Expressions verstanden hat, der kann hier einiges an Performance rausholen. Allerdings momentan alles alpha, aber das ist sicherlich in nächster Zeit ein sehr wichtiges Thema.
Nächster Vortrag: Was kommt nach ASP.NET?
Ein sehr humorvoller Vortrag von Hannes Preishuber. Auch wenn er versprochen hat, dass man nichts davon mitnimmt, hab ich doch die ein oder andere Sache aufgeschnappt. Mir waren die ASP.NET Futures, Silverlight, ASP.NET 3.5 Extensions usw. zwar schon ein begriff, allerdings hatte ich nie das Media Control ausprobiert oder Dynamic Data Pages ausprobiert (was sehr cool ist) und auch LINQ to SQL nutzt.
Letzter Vortrag für heute: LINQ to SQL
Christoph Wille stellt LINQ to SQL vor. Zwar hatte ich selber damit schon rumgespielt, allerdings war es interessant zu wissen, wo bestimmte Sachen “schwierig” umzusetzen sind oder schlicht und einfach langsam. Als generellen Tipp habe ich mitgenommen, den SQL Server Profiler laufen zu lassen, damit man sieht, was LINQ eigentlich am SQL Server veranstaltet. Den Blog von Scott Guthrie und Mike Toulty sollte man zudem ebenfalls besuchen. Morgen (oder heute wenn sie diesen Post lesen werden), wird das ADO.NET Entity Framework vorgestellt – und die Unterschiede zu LINQ to SQL ebenfalls dargestellt.
Einige Stichpunkte noch kurz am Rande erwähnt: Die Integration von Stored Procedures (gibt auf dem Blog von Scott und Mike noch wesentlich mehr Informationen), “CompiledQuerys” für performance Gewinn, das nachträgliche Laden von Kindelementen und die damit verbundenen Probleme (DataLoad Options erlaubt nur die nächste Ebene – man kann wohl keine 2 Ebenen übergehen – wenn man danach sucht, findet man was ich meine ).
Zwischenfazit
Sehr schicke Veranstaltung.Ich werde in den nächsten Tagen/Wochen die Themen zum großen Teil aufgreifen.
Den Tag zwei werde ich sicherlich auch noch niederschreiben
ASP.NET 2.0 führte ein so genanntes “Membership” System ein – darunter sind allgemeine Benutzerregistrier-, Benutzerprofil- und Benutzerrollensystem gebündelt.
Insbesondere das Profilsystem hat mich heute etwas beschäftigt (auch wenn es etwas älter ist). Mit dem Profilsystem kann man einfach Benutzern bestimmte Attribute zuordnen, z.B. Name, Alter, Wohnort oder andere Verweise zu bestimmten Daten innerhalb der Applikation.
Das kann man natürlich auch selber in seiner DB zusammenbasteln – aber das ASP.NET Profile System bietet eine strenge Typsierung, sodass man in der Web.config folgendes anlegen kann:
<profile>
<properties>
<add name="PostalCode" />
</properties>
</profile>
Und im Code hinter so aufrufen kann “Profile.PostalCode” – man kann auch direkt typen angeben, sodass man direkt festlegen kann, welcher Typ eine Profileigenschaft hat:
<?xml version="1.0"?> <configuration xmlns="http://schemas.microsoft.com/.NetConfiguration/v2.0"> <system.web> <profile> <properties> <add name="BirthDate" type="DateTime"/> <add name="FavoriteNumber" type="int"/> <add name="Comment" type="string"/> <add name="FavoriteColor" type="string" defaultValue="Blue"/> <add name="FavoriteAlbums" type="System.Collections.Specialized.StringCollection" serializeAs="Xml"/> </properties> </profile> </system.web> </configuration>
Das ganze wird zudem mit der Membership Datenbank synchronisiert – dort gibt es direkt eine “Profile” Tabelle in dem diese Werte reingeschrieben werden:
Das ganze kann man nun noch beliebig erweitern oder eigene Profil-Provider schreiben – hier ein anderer guter Artikel.
Doch wie ruft man denn nun eigentlich die Profileigenschaften ab? Das was auf den MSDN Seiten immer “Profile.[PROPERTY]” verwendet wird, ist schlecht dokumentiert.
Jedenfalls erstellt VS im Hintergrund automatisch eine “ProfileCommon” Klasse die überall erreichbar ist (* hier kommt noch eine Anmerkung!)
So kommt man an die Profile Eigenschaften (System.Web.Profile Namespace):
ProfileCommon profile = HttpContext.Current.Profile
as ProfileCommon;
Danach kann man über “profile.” seine Properties aufrufen.
* – die Anmerkung
Das ganze funktioniert aber nur mit dem “Web Site” Modell (hier z.B. ein Beispiel von Scott) – in Web Applications wird die ProfileCommon nicht automatisch erstellt.
Scott Guthrie schrieb auf einer sehr alten Seite (ganz unten) seine Lösung: WebProfile Generator (Alternative: Die Klasse manuell erstellen)
Problem hier: Das ganze läuft unter Visual Studio 2008 bisher nicht (daher manuell erstellen 
) – wird aber hoffentlich bald kommen. Auf der Codeplex Seite habe ich bereits einen Kommentar gefunden, kann daher wohl nicht mehr lange dauern.
Anmerkung gernell
Es gibt sicherlich noch die ein oder andere M̦glichkeit auf die Profildaten zuzugreifen, aber extra wegen dieser streng-typisierten und leichten Variante habe ich das einer Eigenentwicklung vorgezogen Рschauen wir mal, wann ich dies bereuen werde
Eine optische Verbesserung (jedenfalls für mich) stellt in Vista der so genannte Glass Effekt dar. Wer nun mit WPF arbeitet, wird vielleicht denken, dass solch ein Effekt direkt mit geliefert wird (immerhin ist .NET 3.0 in Vista fest integriert) – jedoch geht dies nicht so einfach.
Im Internet bin ich auf diesen Blogpost gestoßen – da das nicht schwierig aussah und auch schick war, ich aber nach einem simplen Beispiel suchte, habe ich mir schnell selber etwas zusammengetippt.
Hier das Ergebnis mal als Screenshot:
Ein Standard WPF Window:
Das Aero Window:
Was muss man dafür machen:
Wie in dem Blogartikel oben erwähnt, legt man folgende Klasse mit dem Source Code an:
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Runtime.InteropServices; using System.Windows.Media; using System.Windows; using System.Windows.Interop; namespace WPFAero { public class GlassHelper { public static bool ExtendGlassFrame(Window window, Thickness margin) { if (!DwmIsCompositionEnabled()) return false; IntPtr hwnd = new WindowInteropHelper(window).Handle; if (hwnd == IntPtr.Zero) throw new InvalidOperationException("The Window must be shown before extending glass."); // Set the background to transparent from both the WPF and Win32 perspectives window.Background = Brushes.Transparent; HwndSource.FromHwnd(hwnd).CompositionTarget.BackgroundColor = Colors.Transparent; MARGINS margins = new MARGINS(margin); DwmExtendFrameIntoClientArea(hwnd, ref margins); return true; } [DllImport("dwmapi.dll", PreserveSig = false)] static extern void DwmExtendFrameIntoClientArea(IntPtr hwnd, ref MARGINS margins); [DllImport("dwmapi.dll", PreserveSig = false)] static extern bool DwmIsCompositionEnabled(); } struct MARGINS { public MARGINS(Thickness t) { Left = (int)t.Left; Right = (int)t.Right; Top = (int)t.Top; Bottom = (int)t.Bottom; } public int Left; public int Right; public int Top; public int Bottom; } }
Aero wird über die “dwmapi.dll” gebildet – am Ende ruft man eine einzelne statische Methode auf, welche man das Window übergibt.
Auf Codeproject habe ich dann noch eine andere Erweiterung dafür gefunden: Glass Effekt als Attached Property (Adding Glass Effect to WPF using Attached Properties)
Somit wäre es möglich, einem Window im Xaml direkt den Glass Effekt zuzuweisen:
<Window x:Class="GlassEffectDemo.MainWindow" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:src="clr-namespace: GlassEffectDemo" src:GlassEffect.IsEnabled="True" Title="GlassEffect demo" Height="300" Width="300"> <Grid> </Grid> </Window>
Wichtiger Hinweis: Aero gibt es nur auf Vistabasis und auch nur bei aktivierem Aero (sollte klar sein)
Wäre interessant zu erfahren, ob es bei diesem aktivieren Aero zu irgendwelchen WPF Schwierigkeiten kommen kann – getestet habe ich es noch nicht
Das Demoprojekt k̦nnt ihr wie immer Downloaden РVisual Studio 2008 & Vista ist aber Voraussetzung.
Bereits in dem gestriegen Post habe ich bereits den Release des .NET Frameworks 3.5 samt VS 2008 mit angeschrieben.
Heute möchte ich gleich auf den Post von Scott Guthrie verweisen, welcher offiziel das .NET 3.5 und VS 2008 veröffentlicht hat. Mit inklusive in diesem doch recht langen Post sind alle neuen Features und ein interessantes HowTos zu LINQ.
Zudem stellt Microsoft ein Tranings-Kit mit verschiedenen Präsentationen / Hand-on-labs etc. im Microsoft Downloadbereich zur Verfügung.
[ .NET Framework Direktdownload ] [ Visual Studio Express Editions Download ] [ Visual Studio Team Foundation Trial ]
Deutsch
Englisch
