.NET-Blogs Archiv August 2008

• Bisher in dieser Serie:

• DDD – Eine Einführung,

• DDD – Allgegenwärtige / Universelle Sprache

In meinem Artikel “DDD – Eine Einführung” hatte ich versucht einen Überblick über Domain Driven Design und seine Auswirkungen zu geben. Leider fehlte dabei eine genaue Definition. Dies ist allerdings nicht einfach und ich bezweifle, ob es derzeit eine komplette und exakte Definition von DDD gibt. Die Beschreibungen auf Wikipedia scheinen mir unvollständig, da sie zu sehr auf den Aspekt des Objekt-Design abzielen. Auch im Buch selbst wird eher schwammig in das Thema eingeführt: Man bekommt schnell ein Gefühl für DDD und, mit Blick auf das Inhaltsverzeichnis, auch für den Umfang. Trotzdem fehlt eine präzise, umfassende Definition. Daher ist dieser Artikel sicherlich zunächst nur ein Versuch – ich maße mir keine Vollständigkeit an.

Der Grund dafür liegt, meiner Meinung nach, in der Tatsache begründet, dass DDD eigentlich vor allem eines ist: ein philosophischer Ansatz, wie Problemdomänen in Software implementiert werden sollten:

• Das Modell, und damit die Domäne, sind im Herzen unserer Software

Und "drumherum" bildet DDD damit eine Entwurfsmuster-Sprache, die uns ermöglicht darüber zu kommunizieren. Dies würde ich als eine Definition von Domain Driven Design und dessen Kern bezeichnen wollen (siehe auch David Laribee's Artikel dazu).

Worin liegt dies begründet und welche Auswirkungen hat dieser Ansatz für uns? Gehen wir also zurück zum Anfang. Zunächst dreht sich bei der Erstellung von Software alles um Modelle und Abstraktionen. Haben wir eine gegebene Domäne, so bauen wir zu einer Teilmenge daraus ein Modell, eine Abstraktion der Domäne. Die gesamte Domäne (wie eigentlich alles auf der Welt) ist natürlich zu groß, um sie vollständig zu modellieren. Wenn wir Software entwickeln, bauen wir also primär ein Modell einer Domäne.

Derzeit besteht unsere bester Weg zu Modularisierung und Abstraktion in der Nutzung von Objekt Orientierung. Damit liegt die Idee nahe, unser Modelle durch “nakte” Objekte zu implementieren - wie wir es in der Uni gelernt haben bevor wir über Datenbanken, Transaktionen und Infrastruktur nachdachten. Idealer weise gibt es zwischen Quelltext und Modell keine Unterschiede, also keine Übersetzungen. Im Artikel “DDD – Allgegenwärtige / Universelle Sprache” bin ich bereits darauf eingegangen, warum Eric Evans Übersetzungen als kritisch ansieht. Unser Modell ist also von der Domäne gesteuert.

Wenn wir nun ein Modell der Domäne erstellen, ergibt sich direkt die Frage: Wer kennt die Domäne? Die Architekten? Oder Software Analysten? Oder Entwickler? Wohl kaum. Erstere denken wohl eher an Entwicklung im großen Rahmen, letztere im sehr kleinen und Software-Analysten können wohl analysieren, aber kennen wohl nicht jede Problem-Domäne. Diejenigen, die eine Domäne am besten kennen sind aber direkt vor unseren Nasen: Der Kunde und seine Experten. Diese Idee sehen wir auch in anderen Bereichen, zB in den Agilen Prozessen. Im eXtreme Programming heißt das ganze “Customer On Site”. Da das Modell also keine verborgene Magie innerhalb der Software ist, sondern eine – für alle sichtbare – Abstraktion, ergibt sich die Grundlage des Domain Driven Design:

• Das Modell, und damit die Domäne, sind im Herzen unserer Software

Dies hat weitreichende Konsequenzen auf alle Bereiche, wie Anforderungen an die Architektur, Auswirkungen auf Objekt-Design, das Team, seine Prozesse, etc. Weil wir zum Beispiel dieses Modell kommunizieren müssen, sowohl intern als auch extern, liegt die Idee nahe, eine gemeinsame Sprache in allen Beriechen zu nutzen: angefangen bei der Kommunikation, über Dokumentation, Diagrammen bis hin zum Quelltext. Ideal ist es also, wenn sich die Sprache und damit das Modell im Quelltext manifestiert. Dann könnte man nur durch das Lesen des Quelltextes im Domänen-Modul eine Menge über die Domäne selbst lernen.

Zusammenfassend kann man also sagen, dass Domain Driven Design ein Ansatz zur Software-Entwicklung ist, der das Modell einer Problemdomäne ins Zentrum stellt. Kritik und Erweiterungen sind willkommen!

Nachtrag: Definitions-Absatz erweitert um die Idee der Pattern-Language.

Ein Vergleich der Patterns Table Module (DataSets,..), Transaction Scripts und Domain Model

Abseits meiner Beiträge zum Thema Domain Driven Design möchte ich hier die drei Ansätze zur Handhabung von Komplexität in Geschäftslogik aus Martin Fowler’s Buch “Patterns of Enterprise Application Architecture” vergleichen. Alle drei stellen Wege dar, eine Domäne zu modellieren, wenn auch die beiden ersten Ansätze stark zu prozeduraler Programmierung tendieren:

• Table Module Pattern (auch bekannt als DataSets in .NET)
• Transaction Scripts
• Domain Model Pattern

Fowler hat zum Vergleich eine ähnliche Grafik wie die folgende verwendet.

In der Grafik ist Komplexität gegenüber Aufwand gestellt. Die rote Linie steht für das Table Module Pattern, die blaue Linie steht für Transaction Scripts und die grüne Linie steht für das Domain Model Pattern. Die Idee der Grafik ist es zu zeigen, wie die drei Ansätze mit erhöhter Komplexität skalieren. Dabei kommt es nicht so sehr auf den exakten Verlauf an. Wichtiger ist es zu sehen, dass die Grafik recht gut dem gefühlten “Aufwand” entspricht, bei der Arbeit mit den Ansätzen: der Aufwand bei Transactions Scripts und Table Module (in .NET also DataSets) steigt rasant und macht zunehmende Komplexität kaum noch handhabbar. Aber auch das Domain Model Pattern lässt sich nicht unendlich lange nutzen, ohne ans eine Grenzen zu stoßen. Trotzdem liegt diese Grenze bedeutend höher, was das Pattern so attraktiv für komplexe Domänen macht. Zu große Komplexität kann durch Zerteilen der Domäne in verschiedene Modelle begegnet werden. Diese müssen dann aber genau abgegrenzt und integriert werden müssen – andernfalls wird man weniger Nutzen davon haben. Die passenden Stichwörter wären hier Bounded Context, Context Map und Core Domain [/End buzzword dropping].

Die Große Frage am Vergleich der 3 Ansätze ist natürlich: Wo liegen die Grenzen auf der Achse der Komplexität? Dazu müssten wir aber zunächst einmal Komplexität messen – dies können wir aber kaum. Pragmatisch gesehen muss hier die Erfahrung des Teams herhalten. Praktisch gesehen lohnt sich ein Domain Model sicherlich nicht für eine reine CRUD-Anwendung mit nur sehr simpler Validierung. Trotzdem greift wohl auch diese Einordnung zu kurz. Niemand kann schließlich genau vorhersagen, wie sich das Geschäft des Kunden weiterentwickelt oder ob aus einer kleinen Anwendung nicht plötzlich eine große wird – dafür scheinen zu viele “Prototypen” bisher immer noch am Leben. Es besteht somit die Gefahr eine Entscheidung zu früh zu treffen, obwohl man die Notwendigkeit für das Domain Model Pattern erst später begründen können wird. Es besteht aber auch die Gefahr, sich mit der Wahl von Transaction Scripts oder Table Modul die Möglichkeit zu verbauen, jemals zu einem reichhaltigen Domänenmodell zu gelangen. Denn laut Fowler ist genau dieser Übergang extrem aufwending und teuer – obwohl die Alternative (kein Redesign) keine wirkliche Alternative ist. Interessant wäre wohl zu experimentieren, ob ein Redesign vom Domain Model Pattern hin zu Transaction Scripts gut funktioniert. Mein Tipp wäre, dass sich dies wohl leichter realisieren lässt, als der Weg anders herum; schließlich sehen wir heute viele Prozedurale Implementierungen mit einem anemischen Domänenmodell.

Klar ist, dass das Table Module Pattern gerade wegen seiner breiten Werkzeug-Unterstützung im .NET Bereich eine sehr geringe Hürde für den Einstieg hat. Table Module und Transactions Scripts zerlegen die Domäne in ein prozedurales Modell und bestechen durch ihre Einfachheit - für einfache Kontexte! Leider ist dieser Umstand bisher wenig bis gar nicht kommuniziert worden. Offensichtlich ist aber die Idee des simplen Drag&Drop / RAD / … für die meisten gescheitert. Beim Table Module Pattern gibt es in der Regel ein Objekt, dass die Logik und Kommunikation für eine Datenbank-Tabelle übernimmt. Transaction Scripts manifestieren sich in der Regel in einem “dicken” Application / Service Layer (Fowler). Für jede Transaktion haben wir dann eine Service-Operation. Hiermit sollte dann auch klar sein, warum beide Ansätze Probleme mit duplizierter Logik, Copy&Paste-Smells und vor allem Seperation of Concerns haben. Beim Einsatz eines Domain Models ist die Service Schicht hingegen sehr dünn. Sie koordiniert nur verschiedene Aktionen auf dem Domänenmodell. Vor allem aber eignet sich die Service Schicht zur Beschreibung der Session- und Transaction-Scopes zur Datenbank-Verbindung (mehr dazu später in der DDD Serie).

Transaction Scripts und Table Module haben sicherlich geringere Anforderungen an die Erfahrung und das Abstraktionsvermögen eines Entwicklers. Domänenmodelle bieten dafür weitaus mehr Modularisierung und können so auch zu mehr Wiederverwendung führen. Je komplexer ein Modell wird, umso mehr scheint der Vorteil gegeben über Transaction Scripts und Table Module zu wiegen. Sicheres Einsatzgebiet sind somit auf jeden Fall jene Domänen, bei denen von Anfang an klar ist, dass die Komplexität jenseits von einfacherer Validierung (zB isolierte Validierung pro Feld) und CRUD liegt.

Am Schluss möchte ich noch zu Bedenken geben, dass vollständige Modularisierung mit OOP nicht möglich ist (siehe “Tyranny of the dominant decomposition”). Egal nach welchen Kriterien die Dekomposition der Anwendung von statten geht – es wird immer orthogonale, übergreifende Belange geben. Nach derzeitigem Stand der Forschung erreichen wir damit noch bessere Modularisierung nur durch den Einsatz von Aspekt-Orientierung. Meines Wissens ist aber weiterhin unklar, ob wir damit den “heiligen Gral” der Modularisierung erreichen. Vielleicht ist es am Ende auch egal und nur eine Frage des nötigen Pragmatismus.

In diesem Beitrag werden zwei LINQ-Abfragen (LINQ-Queries) vergliechen, das gleiche Resultat zurück liefern aber unterschiedlich auf die Daten zugreifen. "Viele Wege führen nach Rom."

Das folgende Beispiel basiert auf SQL Server 2005 und AdventureWorks-Datenbank (Database). Für die Daten werden die Datenbanktabellen Contact und Employee eingesetzt.
 
Die Datenbanktabellen Employee und Contact sind über die Felder Employee.ContactID und Contact.ContactID miteinander verknüpft. Mithilfe dieser Verknüpfung können wir von einem Employee-Record aus den Contact-Record ermitteln und diese ausgeben.

Das LINQ to SQL-Designer Tool erkennt die Verknüpfung automatisch, wenn wir die beiden Tabelle mittels Drag & Drop auf die Designer-Oberfläche ziehen. Die Verknüpfung zwischen den beiden Tabellen wird von dem LINQ to SQL-Designer Tool generierten Code (siehe AdventureWorks.designer.cs-File) wie folgt dargestellt:

[Association(Name="Contact_Employee", Storage="_Contact", ThisKey="ContactID", OtherKey="ContactID", IsForeignKey=true)]
public Contact Contact
{
    get
    {
        return this._Contact.Entity;
    }
    set
    {
        ...
    }
}

using System;
using System.Linq;

namespace LinqToSqlRecursiveSample0010
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            var db = new AdventureWorksDataContext();
            var qry = from emp in db.Employees
                      select new {emp};

            Console.WriteLine(String.Format("{0, 10}", "EmployeeID") + "|" +
                              String.Format("{0, 10}", "ContactID") + "|" +
                              String.Format("{0, -30}", "Title") + "|" +
                              String.Format("{0, -15}", "FirstName") + "|" +
                              String.Format("{0, -10}", "MiddleName") + "|" +
                              String.Format("{0, -15}", "LastName"));

            foreach (var item in qry)
            {
                Console.WriteLine(String.Format("{0, 10}", item.emp.EmployeeID) + "|" +
                                  String.Format("{0, 10}", item.emp.ContactID) + "|" +
                                  String.Format("{0, -30}", item.emp.Title) + "|" +
                                  String.Format("{0, -15}", item.emp.Contact.FirstName) + "|" +
                                  String.Format("{0, -10}", item.emp.Contact.MiddleName) + "|" +
                                  String.Format("{0, -15}", item.emp.Contact.LastName));
            }
        }
    }
}

Als Resultat erhalten wir die folgende Liste.  
Wenn wir aber im Hintergrund die Datenbankzugriffe auswerten, stellen wir fest, dass die Applikation für jeden Contact-Record auf die Datenbank zugreift und die Daten aus der Datenbank ermittelt. Die Analyse mit dem SQL Server Profiler-Tool zeigt die Zugriffe wie folgt: Alle Employee-Daten werden mit einem SELECT-Statement aus der Datenbank (Database) gelesen.

SELECT [t0].[EmployeeID],
       [t0].[NationalIDNumber],
       [t0].[ContactID],
       [t0].[LoginID],
       [t0].[ManagerID],
       [t0].[Title],
       [t0].[BirthDate],
       [t0].[MaritalStatus],
       [t0].[Gender],
       [t0].[HireDate],
       [t0].[SalariedFlag],
       [t0].[VacationHours],
       [t0].[SickLeaveHours],
       [t0].[CurrentFlag],
       [t0].[rowguid],
       [t0].[ModifiedDate]
FROM [HumanResources].[Employee] AS [t0]

exec sp_executesql N'SELECT [t0].[ContactID],
                            [t0].[NameStyle],
                            [t0].[Title],
                            [t0].[FirstName],
                            [t0].[MiddleName],
                            [t0].[LastName],
                            [t0].[Suffix],
                            [t0].[EmailAddress],
                            [t0].[EmailPromotion],
                            [t0].[Phone],
                            [t0].[PasswordHash],
                            [t0].[PasswordSalt],
                            [t0].[AdditionalContactInfo],
                            [t0].[rowguid],
                            [t0].[ModifiedDate]
FROM [Person].[Contact] AS [t0]
WHERE [t0].[ContactID] = @p0',N'@p0 int',@p0=1209

using System;
using System.Linq;

namespace LinqToSqlRecursiveSample0010
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            var db = new AdventureWorksDataContext();
            var qry = from emp in db.Employees
                      join con in db.Contacts on emp.ContactID equals con.ContactID
                      select new {emp, con};

            Console.WriteLine(String.Format("{0, 10}", "EmployeeID") + "|" +
                              String.Format("{0, 10}", "ContactID") + "|" +
                              String.Format("{0, -30}", "Title") + "|" +
                              String.Format("{0, -15}", "FirstName") + "|" +
                              String.Format("{0, -10}", "MiddleName") + "|" +
                              String.Format("{0, -15}", "LastName"));

            foreach (var item in qry)
            {
                Console.WriteLine(String.Format("{0, 10}", item.emp.EmployeeID) + "|" +
                                  String.Format("{0, 10}", item.emp.ContactID) + "|" +
                                  String.Format("{0, -30}", item.emp.Title) + "|" +
                                  String.Format("{0, -15}", item.con.FirstName) + "|" +
                                  String.Format("{0, -10}", item.con.MiddleName) + "|" +
                                  String.Format("{0, -15}", item.con.LastName));
            }
        }
    }
}

 

Und im SQL Server Profiler-Tool sehen wir, dass die Contact-Daten nicht mehr einzeln ermittelt werden:

Vom LINQ to SQL generierte SQL-Statement sieht wie folgt aus:

SELECT [t0].[EmployeeID],
       [t0].[NationalIDNumber],
       [t0].[ContactID],
       [t0].[LoginID],
       [t0].[ManagerID],
       [t0].[Title],
       [t0].[BirthDate],
       [t0].[MaritalStatus],
       [t0].[Gender],
       [t0].[HireDate],
       [t0].[SalariedFlag],
       [t0].[VacationHours],
       [t0].[SickLeaveHours],
       [t0].[CurrentFlag],
       [t0].[rowguid],
       [t0].[ModifiedDate],
       [t1].[ContactID] AS [ContactID2],
       [t1].[NameStyle],
       [t1].[Title] AS [Title2],
       [t1].[FirstName],
       [t1].[MiddleName],
       [t1].[LastName],
       [t1].[Suffix],
       [t1].[EmailAddress],
       [t1].[EmailPromotion],
       [t1].[Phone],
       [t1].[PasswordHash],
       [t1].[PasswordSalt],
       [t1].[AdditionalContactInfo],
       [t1].[rowguid] AS [rowguid2],
       [t1].[ModifiedDate] AS [ModifiedDate2]
FROM       [HumanResources].[Employee] AS [t0]
INNER JOIN [Person].[Contact]          AS [t1] ON [t0].[ContactID] = [t1].[ContactID]

Eine Webseite verursacht Probleme mit der aktuellen Internet Explorer 8 Beta 2?
Melden Sie es mit diesem Add-on: Melden Sie ein Webseitenproblem

Dieses Add-Inn für den Internet Explorer installiert im Internet Explorer einen Toolbar-Button 'Report a Webpage Problem...' im Menü 'Extras" oder in der Toolbar.
Wenn Sie diesen Button klicken, wir ein Report inkl. Screenshot erstellt, von der Seite die Sie gerade sich angeschaut haben. Eine neue Registerkarte wird somit entsprechend geöffnet und alle für den Report wichtigen Informationen werden dargestellt. Sie können hier noch zusätzliche Informationen hinzufügen und auch entscheiden, ob der Screenshot der gemacht wurde, mitgesendet werden sollte.

In dem Report enthalten sind zudem:

• Die URL der Webseite
• Der Webseiten-'Document mode'

Für weitere Informationen schauen Sie bitte hier: Privacy Statement

Download: Report a Webpage Problem Internet Explorer 8.0 Beta Add-On

Screenshots:

This post is powered by www.Giza-Blog.de |
Visit:  MSDN Online | Kostenfreie MSDN Service-Hotline für Entwickler
Daily News on MSDN:   MSDN Aktuell
© Copyright 2006-2008 Kay Giza. All rights reserved. Legal

Wer auf seiner Webseite Web Slices (technische Info) anbietet, der möchte ggf. pro aktiv seine User auf dieses Web-Gadget per Icon aufmerksam machen:
So ist es standardmäßig so, dass man erst mit einem Maus-Over eine Web Slices-Symbol angezeigt bekommt, so wie hier auf www.my-msdn.de beispielsweise:

und der Internet Explorer dieses Web Slices in einer Browser-Leiste erkennt und sichtbar macht:

Möchte man dieses Icon gerne dauerhaft einbinden, der finden hier nun Guidelines sowie das offizielle Logo in verschiedenen Formaten:

• WebSlice_Icon.zip (108,29 KB)
• WebSlice_Icon_Guidelines.pdf (25,75 KB)

This post is powered by www.Giza-Blog.de |
Visit:  MSDN Online | Kostenfreie MSDN Service-Hotline für Entwickler
Daily News on MSDN:   MSDN Aktuell
© Copyright 2006-2008 Kay Giza. All rights reserved. Legal

Seit heute Nacht ist die deutschsprachige Version der Visual Studio Team System Web Access 2008 SP1 Power Tool  veröffentlicht worden.

Download und weitere Informationen: Visual Studio Team System Web Access 2008 SP1 Power Tool

This post is powered by www.Giza-Blog.de |
Visit:  MSDN Online | Kostenfreie MSDN Service-Hotline für Entwickler
Daily News on MSDN:   MSDN Aktuell
© Copyright 2006-2008 Kay Giza. All rights reserved. Legal

Das ASP.NET MVC Team hat die Preview 5 nun auf Codeplex zur Verfügung gestellt.

Einige Bugs wurden entfernt und einige nette Sachen wurden mit eingebaut:

• Helper wurden erweitert
• ASP.NET AJAX Extensions wurden in einen anderen Namespace verschoben (damit man es später austauschen kann)
• Controller und Filter wurden erweitert, so kann man nun noch festlegen, dass bestimmte Actions nur per GET oder POST aufgerufen werden können.

Alles interessante findet ihr auf Codeplex und in den dazugehörigen Release Notes.

ShareThis

Vom 21.-24. August fand die Games Convention 2008 in Leipzig statt.  Ich war am Wochenende dabei und habe ein paar Videos darüber gemacht. 

In diesem Video spreche ich mit Georg Backer, Audio Associate Producer von Lionhead Studios über das Action-Role-Playing-Spiel Fable 2.  Fable 2 ist der Nachfolger von Fable 1 und Georg erzählt mir, was für Neuerungen es in dem Spiel gibt. 

Auf der Games Convention dieses Jahr hatten 5555 Xbox Live Gold Mitglieder die Möglichkeit in dem Backstage-Bereich, Fable 2 selbst auszuprobieren.  Fable 2 wird am 24. Oktober im Europa in den Laden zu kaufen sein.

Mit einem spannenden Thema geht der MSDN TechTalk nach der Sommerpause im September wieder auf Tour. Mein Kollege Dirk Primbs, seines Zeichens Developer Evangelist Team Lead, zeigt dann am Beispiel der Windows Presentation Foundation (WPF), wie moderne Applikations-User Interfaces konzipiert und realisiert werden und welche Rolle WPF heute bei der Entwicklung von Benutzeroberflächen spielt.

Wann und wo Sie die kostenlosen TechTalk-Vorträge erleben können, erfahren Sie in der Event-Rubrik von MSDN Online. Am besten gleich anmelden!

Für ein privates Projekt suche ich gerade nach einem geeigneten Hostingangebot. Da ich gerne immer mal mit neuen Technologien rumspiele, wäre es toll, als Betriebssystem Windows Server 2008 zu haben - mit Adminrechten auf dem Server (und RDP Zugang etc.)
Bei vielen Hostern waren “nur” MySQL DBs dabei - SQL Server Express könnte man zwar nach installieren, aber vielleicht gibt es ja ein Angebot wo eine “richtiger” SQL Server DB dabei ist.

In kurz zusammengefasst:
+ Betriebssystem Windows Server 2008
+ Adminrechte (RDP)
+ MS SQL Datenbanken (gerne natürlich auch SQL Server 2008 ;))
+ Im Prinzip wie sowas, nur mit Windows Server 2008
+ Traffic / Platz ähnlich dem HostEurope Angebot
+ Budget bis 100 Euro

Wer kennt sowas?

ShareThis

Vielleicht haben bereits viele das E-Mail von Lutz Roeder zum Thema .NET Reflector und RedGate erhalten.

Ich möchte in diesem Beitrag für die Leser, die das Tool noch nicht kennen oder das E-Mail nicht erhalten haben, kurz beschreiben,wie es mit diesem Tool weitergeht.

Gemäss E-Mail von Lutz Roeder (Entwickler .NET Reflector Tool), wird das berühmte .NET Reflector Tool in Zukunft von der Firma RedGate vertrieben.

Siehe Homepage für .NET Reflector™

Eine kleine Beschreibung des Tools aus der RedGate .NET Reflector Homepage:

.NET Reflector enables you to easily view, navigate, and search through the class hierarchies of .NET assemblies even if you don't have the code for them. With it, you can decompile and analyze .NET assemblies in C#, Visual Basic and IL.

Use Reflector if you need to:

• Explore .NET assemblies in an easy-to-understand, natural way
• Understand the relationships between classes and methods
• Find where types are instantiated and exposed
• Check that your code has been correctly obfuscated before release

Für mein Blog wollte ich ein Beispiel mit LINQ to SQL und Geo-Daten schreiben und dabei den SQL Server 2008 einsetzen und den neuen Datentyp "geography" verwenden.

Leider wurde meine Arbeit durch die folgende Fehlermeldung unterbrochen, nach dem ich die Address-Tabelle-Table der AdventureWorks-Datenbank-Database auf die LINQ to SQL Designer-Oberfläche gezogen habe: One or more selected items contain a data type that is not supported by the designer.

Den SP 1 - Service Pack 1 für Visual Studio 2008 habe ich bereits installiert gehabt. Nach einer kurze recherche im Internet habe ich kein Eintrag zu diesem Thema gefunden.

Nach einem Post an das LINQ to SQL-Forum hat Damien Guard (Microsoft) folgenden Antwort zurück geschrieben:

A number of SQL Server features are not supported by LINQ to SQL even with SP1 installed - this includes geography and hierarchy types.

Auf meine Frage, ob Sie die neuen Datentypen unterstützen werden, bekam ich folgende Antwort zurück:

Supporting the missing types are on our list of features we'd like to add to the next release but I can't confirm what will make it at this point in time.

Den Forum-Eintrag findet ihr unter: LINQ to SQL Designer and SQL Server 2008 "geography" Data Type

Ich werde euch am laufenden halten, sobald ich Neuigkeiten zu diesem Thema habe.

Im folgenden Beispiel wird gezeigt, wie wir ein CSV-File mit LINQ erstellen können. Als Datenbank wird die SQL Server 2005 AdventureWorks-Datenbank verwendet.

Die Erstellung des CSV-Files erfolgt in drei Schritten:

Schritt 1: Die Daten aus der Datenbank ermitteln.

string conStr =
    @"Data Source=IBM-E6A5BAE860C\SQL2K5;Initial Catalog=AdventureWorks;Integrated Security=True";

var db = new AdventureWorksDataContext(conStr);

IQueryable<ProductCategory> qry = from pc in db.ProductCategories
                                  select pc;

Schritt 2: Die Felder für den Export in das CSV-File bestimmen.

int[] field1 = qry.Select(f => f.ProductCategoryID).ToArray();
string[] field2 = qry.Select(f => f.Name).ToArray();
Guid[] field3 = qry.Select(f => f.rowguid).ToArray();

In diesem Schritt werden die Werte der einzelnen Felder in einem Array-Objekt gespeichert. Der Select-Operator hilft uns dabei, die Wert zu ermitteln.

Schritt 3: Die Daten in das CSV-File schreiben.

TextWriter txtWrt = new StreamWriter(@"C:\ProductCategories.csv");

for (int i = 0; i < field1.Length; i++)
{
    txtWrt.Write(field1[i] + ";");
    txtWrt.Write(field2[i] + ";");
    txtWrt.Write(field3[i].ToString());

    txtWrt.WriteLine();
}

txtWrt.Close();

Den vollständigen Code findet ihr unten:

using System;
using System.IO;
using System.Linq;

namespace LinqCsvSamples0010
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            string conStr =
                @"Data Source=IBM-E6A5BAE860C\SQL2K5;Initial Catalog=AdventureWorks;Integrated Security=True";

            var db = new AdventureWorksDataContext(conStr);

            IQueryable<ProductCategory> qry = from pc in db.ProductCategories
                                              select pc;

            int[] field1 = qry.Select(f => f.ProductCategoryID).ToArray();
            string[] field2 = qry.Select(f => f.Name).ToArray();
            Guid[] field3 = qry.Select(f => f.rowguid).ToArray();

            TextWriter txtWrt = new StreamWriter(@"C:\ProductCategories.csv");

            for (int i = 0; i < field1.Length; i++)
            {
                txtWrt.Write(field1[i] + ";");
                txtWrt.Write(field2[i] + ";");
                txtWrt.Write(field3[i].ToString());

                txtWrt.WriteLine();
            }

            txtWrt.Close();

            Console.ReadLine();
        }
    }
}

Ein ZIP-File für den Download findet ihr unter: LinqCsvSamples0010

Unter CodeProject findet ihr zu diesem Thema folgenden Artikel: LINQ to CSV library

Viel Spass...

This post is powered by www.Giza-Blog.de |
Visit:  MSDN Online | Kostenfreie MSDN Service-Hotline für Entwickler
Daily News on MSDN:   MSDN Aktuell
© Copyright 2006-2008 Kay Giza. All rights reserved. Legal

Das AJAX-Programmiermodell in IE8 ist einfacher und noch leistungsfähiger als jemals vor: XMLHttpRequest-Verbesserungen in Internet Explorer 8

This post is powered by www.Giza-Blog.de |
Visit:  MSDN Online | Kostenfreie MSDN Service-Hotline für Entwickler
Daily News on MSDN:   MSDN Aktuell
© Copyright 2006-2008 Kay Giza. All rights reserved. Legal

This post is powered by www.Giza-Blog.de |
Visit:  MSDN Online | Kostenfreie MSDN Service-Hotline für Entwickler
Daily News on MSDN:   MSDN Aktuell
© Copyright 2006-2008 Kay Giza. All rights reserved. Legal

This post is powered by www.Giza-Blog.de |
Visit:  MSDN Online | Kostenfreie MSDN Service-Hotline für Entwickler
Daily News on MSDN:   MSDN Aktuell
© Copyright 2006-2008 Kay Giza. All rights reserved. Legal

Internet Explorer 8 stellt verbesserte Entwicklertools bereit um Ihnen bei der Untersuchung und Lösung von Problemen zu helfen und verwendet HTML, Cascading Stylesheets (CSS) und Javascript.
Mehr Infos: Entdecken der Internet Explorer 8-Entwicklertools

This post is powered by www.Giza-Blog.de |
Visit:  MSDN Online | Kostenfreie MSDN Service-Hotline für Entwickler
Daily News on MSDN:   MSDN Aktuell
© Copyright 2006-2008 Kay Giza. All rights reserved. Legal

Web Slice basiert auf dem hAtom-Microformat mit einigen zusätzlichen Eigenschaften. Für Entwickler sicherlich interessant: Abonnieren von Inhalten mit Web Slices
Auch sehr interessant: Web Slice Style Guide Samples

This post is powered by www.Giza-Blog.de |
Visit:  MSDN Online | Kostenfreie MSDN Service-Hotline für Entwickler
Daily News on MSDN:   MSDN Aktuell
© Copyright 2006-2008 Kay Giza. All rights reserved. Legal

IE8 Activities oder auch Aktivitäten, für Entwickler sicherlich sehr interessant. In diesem Artikel wird beschrieben, wie XML-basierte Beschleuniger definiert und bereitgestellt werden.
Weitere Informationen: OpenService-Format sowie Entwicklerhandbuch zu Aktivitäten

This post is powered by www.Giza-Blog.de |
Visit:  MSDN Online | Kostenfreie MSDN Service-Hotline für Entwickler
Daily News on MSDN:   MSDN Aktuell
© Copyright 2006-2008 Kay Giza. All rights reserved. Legal

Der Schwerpunkt der Suchverbesserungen in Internet Explorer 8 Beta 2 liegt auf einer deutlichen Verbesserung des Dropdownmenüs des Suchfelds der Symbolleiste und der Unterstützung von Suchvorschlägen.
Wer sich hierfür interessiert: Suchanbietererweiterbarkeit in Internet Explorer

This post is powered by www.Giza-Blog.de |
Visit:  MSDN Online | Kostenfreie MSDN Service-Hotline für Entwickler
Daily News on MSDN:   MSDN Aktuell
© Copyright 2006-2008 Kay Giza. All rights reserved. Legal

Erfahren Sie mehr über Windows Internet Explorer 8 Beta 2: Internet Explorer 8 Beta 2: Technologieübersicht

This post is powered by www.Giza-Blog.de |
Visit:  MSDN Online | Kostenfreie MSDN Service-Hotline für Entwickler
Daily News on MSDN:   MSDN Aktuell
© Copyright 2006-2008 Kay Giza. All rights reserved. Legal

Mit dem zunehmenden Einsatz von Internet Explorer 8 durch die soeben erschienene zweite Betaversion des Browsers rückt auch für bestehende Webseiten und IE-basierende Software der Tag der Wahrheit näher, da der neue Browser im Unterschied zu seinen Vorgängern vollkommen standardkompatibel arbeitet. Somit können Webseiten und Software, die für ältere Versionen von Internet Explorer speziell angepasst wurden, in einigen Fällen einer Überarbeitung bedürfen. Das Internet Explorer 8 Readiness Toolkit unterstützt Sie bei der Anpassung Ihrer Webseiten und Anwendungen für Internet Explorer 8.

This post is powered by www.Giza-Blog.de |
Visit:  MSDN Online | Kostenfreie MSDN Service-Hotline für Entwickler
Daily News on MSDN:   MSDN Aktuell
© Copyright 2006-2008 Kay Giza. All rights reserved. Legal

This post is powered by www.Giza-Blog.de |
Visit:  MSDN Online | Kostenfreie MSDN Service-Hotline für Entwickler
Daily News on MSDN:   MSDN Aktuell
© Copyright 2006-2008 Kay Giza. All rights reserved. Legal

I've been trying to create a simple and lightweight wrapper around List<T> and List<T>.Enumerator. The only thing I needed was the ability to enumerate over the items of the list. The list is supposed to be enumerated very(!) often, so I wanted the enumerator to be struct instead of a class. Using a value type enumerator avoids any heap allocation during enumerator. List<T>.Enumerator is a value type just because of the same reason.

So here's my first approach:

 /// <summary>

 /// A wrapper around an <see cref="List{T}"/> that only allows enumeration. 

 /// </summary>

 public struct ReadOnlyList<T> {

   private readonly List<T> items;

   /// <summary>

   /// Initializes a new instance of the <see cref="ReadOnlyList{T}"/> struct.

   /// </summary>

   /// <param name="list">The list.</param>

   public ReadOnlyList(List<T> list) {

     items = list;

   }

   /// <summary>

   /// Gets the enumerator.

   /// </summary>

   /// <returns></returns>

   public Enumerator GetEnumerator() {

     return new Enumerator(items);

   }

   #region Nested type: Enumerator

   /// <summary>

   /// A light weight enumerator for <see cref="ReadOnlyList{T}"/>

   /// </summary>

   public struct Enumerator {

     private readonly List<T>.Enumerator enumerator;

     /// <summary>

     /// Initializes a new instance of the <see cref="ReadOnlyList&lt;T&gt;.Enumerator"/> struct.

     /// </summary>

     /// <param name="items">The items.</param>

     public Enumerator(List<T> items) {

       enumerator = items.GetEnumerator();

     }

     /// <summary>

     /// Gets the current item.

     /// </summary>

     /// <value>The current item.</value>

     public T Current {

       get { return enumerator.Current; }

     }

     /// <summary>

     /// Moves to the next element in the enumeration.

     /// </summary>

     /// <returns></returns>

     public bool MoveNext() {

       return enumerator.MoveNext();

     }

   }

   #endregion

 }

This looks perfectly reasonable if you ask me. Here's a unit test to check that the enumerator works:

 [Test]

 public void Enumerator_CanEnumerateList() {

   var list = new List<int> {0, 1, 2, 3};

   var enumerator = new ReadOnlyList<int>.Enumerator(list);

   var expected = 0;

   while(enumerator.MoveNext()) {

     Assert.AreEqual(expected, enumerator.Current);

     expected++;

   }

   Assert.AreEqual(list.Count, expected);

 }

The test should pass, right? After all the Enumerator struct is a mere wrapper aroung List<T>.Enumerator. Funny thing is: it fails! Do you see why? As a hint, here's what fails: the second time the loop runs enumerator.Current is 0 although enumerator.MoveNext() has returned true. But why? It has taken me quite a while to find the reason.

To the Bat Mobile Debugger!

Of course, first thing I did was to debug the code. List<T>.Enumerator.MoveNext() looks something like this:

 public bool MoveNext() {

     List<T> list = this.list;

     if ((this.version == list._version) && (this.index < list._size)) {

         this.current = list._items[this.index];

         this.index++;

         return true;

     }

     return this.MoveNextRare();

 }

MoveNextRare() is not important here, but what is important is that when the method returns true, index should have been increased. However, according to the debugger, the value of enumerator.enumerator.index doesn't change after the call to MoveNext(), although it returned true. Weird, huh? Somehow the fields did not get updated.

So I dug deep into the code. I opened ReadOnlyList<T>.Enumerator.MoveNext() in Reflector and here's what I got:

 .method public hidebysig instance bool MoveNext() cil managed

 {

     .maxstack 1

     .locals init (

         [0] valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<!T> CS$0$0000)

     L_0000: ldarg.0 

     L_0001: ldfld valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<!0> Moonbow.Util.ReadOnlyList`1/Enumerator<!T>::enumerator

     L_0006: stloc.0 

     L_0007: ldloca.s CS$0$0000

     L_0009: call instance bool [mscorlib]System.Collections.Generic.List`1/Enumerator<!T>::MoveNext()

     L_000e: ret 

 }

Now it became clear that my MoveNext() method created a local copy of the enumerator field and called MoveNext on the copy. This of course meant that the original fields of the List<T>.Enumerator wouldn't get updated. And now you might see where my mistake was? Right: ReadOnlyList<T>.Enumerator.enumerator is marked as readonly! My idea was that the enumerator object will not be reassigned in any method of my Enumerator, so I could as well make the field readonly. After removing the readonly modifier the IL of my MoveNext() method was much more like I expected:

 .method public hidebysig instance bool MoveNext() cil managed

 {

     .maxstack 8

     L_0000: ldarg.0 

     L_0001: ldflda valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<!0> Moonbow.Util.ReadOnlyList`1/Enumerator<!T>::enumerator

     L_0006: call instance bool [mscorlib]System.Collections.Generic.List`1/Enumerator<!T>::MoveNext()

     L_000b: ret 

 }

The conclusion

Here's the moral of the story:

If you declare a value type field as readonly, every call made to this field is actually made to a local copy. Any changes made in those calls are not stored in the readonly field. This is different from reference type fields where calls will be made on the field itself, potentially causing changes in the referenced object.

If this has been obvious for you: kudos, I didn't know that. Rreadonly fields are "really" readonly for value types, it means more than prohibiting assignments to the field. I did not find a word about that in the specification. The MSDN only mentions that assignments to readonly fields are only allowed in the declartion or in the constructor:

The readonly keyword is a modifier that you can use on fields. When a field declaration includes a readonly modifier, assignments to the fields introduced by the declaration can only occur as part of the declaration or in a constructor in the same class.

There is however a bug report that deals with this issue. Is has been closed as "By Design", though. It references the part in the specs that defines this behaviour: it's in section 7.4.4, function member invocation, bullet list 2, item 2, subitem 2.

If E is not classified as a variable, then a temporary local variable of E’s type is created and the value of E is assigned to that variable. E is then reclassified as a reference to that temporary local variable. The temporary variable is accessible as this within M, but not in any other way. Thus, only when E is a true variable is it possible for the caller to observe the changes that M makes to this.

By the way: it does not matter whether the type that declares the readonly value type fiels is a struct or a class by itself.

This post is powered by www.Giza-Blog.de |
Visit:  MSDN Online | Kostenfreie MSDN Service-Hotline für Entwickler
Daily News on MSDN:   MSDN Aktuell
© Copyright 2006-2008 Kay Giza. All rights reserved. Legal

This post is powered by www.Giza-Blog.de |
Visit:  MSDN Online | Kostenfreie MSDN Service-Hotline für Entwickler
Daily News on MSDN:   MSDN Aktuell
© Copyright 2006-2008 Kay Giza. All rights reserved. Legal

Wir (das heißt Oliver und ich) haben uns zum Ziel gesetzt eine .NET User Group in Dresden zu etablieren. Unser erstes Treffen wir in den Gebäuden der T-Systems-MMS am 03.09 18:00 bis 20:00 Uhr stattfinden.

Alle Details findet ihr auf http://www.dd-dotnet.de/ - wer also Dresdner .NET Kollegen kennt (oder kennen lernen will), ist herzlich eingeladen

ShareThis

Wie im letzten Beitrag angekündigt gibt es ein paar großartige Neuigkeiten zum sharpcms und dem sharpcms Projekt.

Ab jetzt wird die Leitung des Projektes von Thomas Huber (www.klickflupp.ch, http://www.aspnetzone.de/blogs/thomashuber/) aus der Schweiz und von mir geführt.

Die offizielle Adresse der sharpcms Website ist jetzt http://www.sharpcms.org/. Die alten Domains (sharpcms.de, sharpcms.ch und sharpcms.dk) werden noch umgeleitet.

Ab jetzt wird der Quell-Code von sharpcms auf Microsofts Open Source Projekt-Hosting Website „Codeplex“ bereitgestellt (http://www.codeplex.de/).
Die URL des Projektes auf Codeplex ist http://www.codeplex.com/sharpcms.
Codeplex beinhaltet ein Diskussionsforum (http://www.codeplex.com/sharpcms/Thread/List.aspx). Alle weiteren Diskussionen sollten in  diesem Forum gestartet und geführt werden. Die deutsche Google Gruppe wird in den nächsten Monaten geschlossen. Die englische Gruppe wird als Archiv offen bleiben.
Codeplex beinhaltet außerdem ein Issue-Tracking (http://www.codeplex.com/sharpcms/WorkItem/List.aspx). Bitte meldet alle Fehler und Wünsche bitte unter dieser URL.

Neue Releases von sharpcms können unter folgender Adresse gefunden werden: http://www.codeplex.com/sharpcms/Release/ProjectReleases.aspx
Die Quell-Codes unter folgender Adresse heruntergeladen werden: http://www.codeplex.com/sharpcms/SourceControl/ListDownloadableCommits.aspx

Sharpcms wird weiterhin unter der GPL v2 veröffentlicht (http://www.codeplex.com/sharpcms/license).

This morning I got an e-mail from Lutz Roeder, creator of the marvelous .NET Reflector in which he announces that he handed development of .NET Reflector over to Red Gate Software. Red Gate is known for their .NET profiler ANTS and has also acquired the PInvoke.net plugin (originally developed by PInvoke.net)some time ago.

What's probably important for many of us is that Red Gates promises to provide a free version of Reflector:

We will continue to maintain a free version for the benefit of the community.

On the one hand this opens a big opportunity for the future of .NET Reflector. Red Gate is certainly capable of adding a lot of functionality to Reflector. On the other hand, I see the potential danger that Red Gate might neglect the development of a free community version in the course of time in favour of a commercial license.

I can totally understand Lutz when he says that after eight years of development he's striving for new objectives. And I can also understand that by handing Reflector over to Red Gate he can get the financial reward that he deserves. It would of course have been awesome if he made Reflector open source, but he chose not to, and I respect this choice. Let's just cross fingers that Red Gate decides to put as much effort into a free community version as in a commercial version.

To Lutz, all the best for future projects. Thanks for having made such a great piece of software.

To Red Gate, good luck with the further development of Reflector. You're in the responsibility of keeping the spirit of a great product alive.

On a Windows Server 2003 machine I needed sound to be enabled during remote desktop connections. Here's what I had to do to bring the sound to the client machine.

1. Install audio drivers on the server, of course
2. Enable the Windows Audio service on the server.
   1. Open Administrative Tools => Services
   2. Locate the service named Windows Audio
   3. Set the start mode to "Automatic" and start the service
      
3. Enable RDP-Tcp Audio Mapping
   1. Open Administrative Tools => Terminal Services Configuration
   2. Select the "Connections" node on the left side
   3. Right click on RDP-Tcp on the right side and select "Properties" (or double click RDP-Tcp)
   4. On the "Client Settings" tab, uncheck "Audio mapping"  (checked items are disabled)
      
4. In the Remote Desktop Connection window (client side), enable audio playback on client computer
   1. Show options by clicking "Options >>"
   2. On the "Local Resources" tab, select "Bring to this computer" in the combo box under "Remote computer sound"
      
5. Connect to the remote server and you should have sound.

Note: you should only enable sound on the server if you have a good reason, e.g. I edit my DVB-T recordings on the server. Otherwise, leave audio off for stability and security reasons.

Kommenden Donnerstag, den 28. August 2008 haben wir ab 19:00 Uhr Jens von der Microsoft Deutschland GmbH bei unserer .NET User Group in Koblenz zu Gast. Wer also zwischen 19:00 und 21:00 Uhr noch nichts vor hat und sich für den SQL Server 2008 interessiert, ist herzlich eingeladen.

Nach Möglichkeit bitte vorher über Xing anmelden, kurzentschlossene sind natürlich auch spontan willkommen.

Genau: leuchtende Kundenaugen :-)

Diese durfte ich kürzlich wieder sehen. Einer meiner Kunden behalf sich nämlich Jahre lang mit "schmutzigen" Workarrounds um das Feuern von Update-Triggern bei Massenupdates zu vermeiden.

Glücklicherweise ist es jedoch unter dem SQL Server möglich, Trigger bedarfsweise zu deaktiveren / aktivieren.

Für alle, die mit dem selben Problem kämpfen hier zur Referenz:

T-SQL bietet keine Möglichkeit die Vorkommnisse eines Zeichens innerhalb einer Zeichenkette zu zählen.

Richtig! Nun ja, zumindest fast. Zwar gibt es keine eingebaute Funktion, mit folgendem Konstrukt lässt sich die Anforderung jedoch trotzdem erfüllen:

Im gewählten Beispiel, welches übrigens auf der Northwind Datenbank ausprobiert werden kann, werden die Anzahl der 't' innerhalb des Felds CompanyName gezählt.

Die Funktionsweise ist recht einfach:

Zuerst wird in Zeile 4 die Länge des Namens ermittelt. Im Beispiel von 'Alfreds Futterkiste' wäre dies 19. Anschließend werden alle 't' innerhalb von 'Alfreds Futterkiste' durch einen leeren Character ersetzt und die Länge von 16 Zeichen ermittelt. Als letztes wird der zweite Wert vom ersten subtrahiert, so dass wir auf unser Ergebnis von 3 kommen.

Eigentlich ganz einfach, oder :-)

Wie ich letzte Woche geschrieben habe, hat Microsoft Live Labs eine neue Version von Photosynth gelauncht.  Photosynth ist ein kostenloser Service, um Fotos in einem 3D-Umfeld zu erleben und auszutauschen. 

Um selbst ein Synth (3D-Model mit Fotos) zu bauen, braucht Ihr eine Kollektion von Fotos von einem Objekt oder einem Ort – am besten 20-300 Fotos mit Überlappung und verschieden Blickwinkel.  Mit der Hilfe des Photosynth-Tools könnt Ihr dann ein 3D-Model aus den Fotos erstellen. 

Die besten Synths beginnen mit den richtigen Fotos.  Um besser zu verstehen wie man ein Synth selbst baut, habe ich das „Photosynth – How To“-Video auf Deutsch synchronisiert.  Schau das Video an, um zu lernen, wie man Fotos macht, um ein gutes Synth zu bauen. 

Es gibt auch eine Anleitung zur Photosynth-Fotografie.  Diese Anleitung zeigt, welche Art von Fotos für Photosynth besonders geeignet ist.  Die Anleitung hilft Ihr zu vermeiden, mehrere hundert Fotos zu machen und dann später festzustellen, dass Photosynth sie nicht so zusammenstellt, wie erwartet.  Dieser Anleitung zur Photosynth-Fotografie könnt Ihr hier herunterladen.

am 08.09.2008 findet bei der .Net Developergroup Ulm ein 'Cool Tipps' Wettbewerb statt. Idee hinter diesem Wettbrewerb ist, einen stärkeren Austausch innerhalb der Community zu erreichen. Mit diesem besonderen Event wollen wir auch das 2-jähriges Bestehen unserer Usergroup und hoffentlich auch das 200. Mitglied feiern.

Jeder Entwickler hat seine kleinen Tricks um bestimmte Aufgaben schnell, effizient und elegant zu erledigen.
Unser Ziel ist ein Austausch dieses Wissens. Aus diesem Grunde wollen wir am 08. September einen ganz besonderen Wettbewerb veranstalten. Die Mitglieder der .net Developergroup Ulm sind aufgerufen, ihr Knoff-Hoff in einer Kurzpräsentation vorzustellen. Das vorgestellte Thema kann aus einem weiten Bereich gewählt werden. Egal ob es sich um ein Code-Snippet handelt, um ein Tool, eine spezielle Methode oder ein Designpattern. Alles was mit der .Net Programmierung zu tun hat ist von Interesse. Und jeder Teilnehmer kann wertvolle Sachpreise gewinnen. Mitmachen lohnt sich!

Hier die Rahmenbedingungen für den Wettbewerb:

• Teilnahmeberechtigt sind alle Mitglieder der .net Developergroup Ulm  
• Jeder Teilnehmer erhält 10 Min. für seinen Beitrag  
• Alle Beiträge müssen in einem Zusammenhang mit der Programmierung unter .Net stehen.  
• Die Besucher der Veranstaltung wählen am Ende die besten Beiträge, die mit wertvollen Sachpreisen belohnt werden.  
• Themenvorschläge sind bis spätestens 31.08. per E-Mail einzureichen unter info@dotnet-ulm.de

Sachpreise:

1 Enterprise Studio-Lizenz (Wert 1100$) von
2 RadControl-Lizenzen (Wert je 1299$) von
1 ReSharper-Lizenz (Wert 140€) von
3 Jahres Abos (Wert je 76,50€)von
5 Buchgutscheine (a 60 €) von

Bereits angemeldet Themen:

• Lokalisiertes Property-Grid  
• Vista Gadgets programmieren  
• Broadcast Messages mit Controls  
• Zeitspar-Tools für TFS  
• Object Cloner  
• Data Sets per WCF übertragen  
• PDF- und Excel-Export aus ASP.Net mit Bordmitteln  
• Generische Fehlerklasse
• Beliebige Datenformate per Serialisierung erzeugen und lesen

Wer noch Interesse hat, am Wettbewerb teilzunehmen, kann gerne noch einen Vortrag an info@dotnet-ulm.de einrichen. Und natürlich sind alle interessierten gerne als Zuhörer willkommen. Und vielleicht schaffen wir es ja doch noch bis zum 08.09 die fehlenden 7 Mitglieder zu gewinnen, um die 200 voll zumachen.

Auf der offiziellen ASP.NET MVC Seite gibt es nun 15 neue Videos zu bestaunen:
- 10 HowDoI Videos
- 5 Pair Programming Videos mit dem Entwickler von NUnit

In den HowDoI Videos wird auf die Testbarkeit, sowie das generelle Konzept eingegangen - Routing, MVC usw.

Wer sich dafür interessiert, sollte mal einen Blick draufwerfen

ShareThis

Ist es Zufall, ein Fall von “Murphys Law”, oder ist das CardSpace UI tatsächlich bei angeschlossenem Beamer viel langsamer als sonst?

Das Anmelden mit CardSpace an meinem Blog hat gerade mal wieder nur 2-3 Sekunden gedauert. So ziemlich jedes Mal, wenn ich den gleichen Vorgang während einer Präsentation zeige, dauert es furchtbar lange, bis endlich die CardSpace-Oberfläche erscheint. Jedes mal. Mindestens 10 Sekunden. Oft auch noch länger. Das hilft natürlich ungemein, das Publikum von CardSpace zu überzeugen…

Dieser Beitrag beschreibt, wie wir die Share Services Provider Komponente des MOSS 2007 Server konfigurieren können.

Zuerst SharePoint Central Administration Seite starten: Start - Programs - Microsoft Office Server - SharePoint 3.0 Central Administration

Application Management Tab auswählen.

Anschliessend unter Office SharePoint Server Share Services - Create or configure this farm's share services klicken.

New SSP-Button klicken.

Für eine neue Web Application für unser Share Services Provider - Create a new Web application klicken.

IIS Web Site: In diesem Schritt, die Option Create a new IIS web site auswählen. Bei Bedarf kann der Description-Wert und Port-Nummer geändert werden.

Security Configuration: Die Option für Authentication provider soll als NTLM definieren, wenn ihre Umgebung Negotiate (Kerberos) nicht unterstützt.

Die Option Allow Anonymous als No definieren.

Die Option Use Secure Sockets Layer (SSL) je nach Bedarf als Yes oder No definieren. In diesem Beispiel verwenden wir kein SSL, aus diesem Grund  wird die Option als No definiert.

Load Balanced URL: Wenn kein Load Balancing vorhanden, die Einstellung mit Default-Wert lassen.

Application Pool: Bei Option Application Pool - Create new application auswählen. Zusätzlich einen Domain-User eingeben (Bsp. DOMAIN\User). Bei dieser Stelle warnt Microsoft auf seiner Technet Page, dass dieser User keine Administrative Rechte besitzen soll (siehe unter Configure the primary Shared Services Provider Punkt 10).

Reset Internet Information Services: Die Option Reset Internet Information Services als Restart IIS Manually definieren. Mit dieser Option wird festgelegt, ob die IIS nach der Erstellung der Web application automatisch gestartet werden soll.

Database Name and Authentication: Bei Database Name and Authentication Einstellungen müssen wir einen Datenbank-Server angeben, auf dem die WSS_Content-Datenbank für die neuen Web application erstellt wird. Als Default wird ein Datenbankname mit einer GUID vorgeschlagen. Den Namen der Datenbank soll geändert werden. So wird die Identifizierung der Datenbank in einem späteren Zeitpunkt vereinfacht. In diesem Beispiel wird die Datenbank als WSS_Content_SSP_01 benannt. Die Einstellung Database authentication soll als Windows authentication bleiben.

Anschliessend können wir die neuen Web application mit OK-Button erstellen lassen.

SSP Name: Als Nächstes definieren wir den Namen unseren Share Service Providers (SSP Name). SharedServices1 wird als Default-Wert vorgeschlagen. Wenn in der Auswahlliste Web application noch kein Wert selektiert ist, dann hier die neu erstellte Web application selektieren.

Die URL für die Share Service Providers Administration Page wird hier angezeigt (SSP Administration Site URL). Auf dieser Administration Page können wir auch über die Central Administration zugreifen.

My Site Location: Die Einstellungen für My Site Location können wir wie vorgeschlagen übernehmen.

SSP Service Credentials: Hier benötigen wir einen Domain User (DOMAIN\User). Auch hier empfiehlt Microsoft auf seiner Technet Seite einen User ohnen Administrative Rechte.

SSP Database: Für spezifischen Daten der Shared Services Provider-Komponente benötigen wir eine Datenbank. Auch hier wird empfohlen, die Einstellung für Database authentication als Windows authentication zu definieren.

Search Database: Als Nächstes definieren wir den Datenbank Server für unseren Search Datenbank-Search Database.

Index Server: Anschliessend müssen wir einen Index Server auswählen. Für die Einrichtung einer Shared Services Provider-Komponente wird ein Index Server vorausgesetzt. In diesem Beispiel läuft der Index Server auf dem gleichen Server. In der Praxis und grösseren Umgebung wird emfohlen, für die Indexierung einen separaten Server zu verwenden, weil der Index Server viel Ressourcen benötigt.

SSL for Web Services: Als Schluss definieren wir, ob die SSL-Verschlüsselung für die Web Services benötigt werden. In diesem Beispiel verwenden wir keine SSL-Verschlüsselung. Aber in der Praxis wird empfohlen, SSL-Verschlüsselung zu verwenden.

Mit dem OK-Button können wir unseren Shared Services Provider-Komponente erstellen lassen.

Die folgende Warnung ist für die Praxis sehr wichtig. Es wird empfohlen, für die SSP administration und My Sites unterschiedliche Web applications zu verwenden, damit man die Daten voneinander unabhängig restoren kann.

Die Meldung mit OK-Button bestätigen.

Am Schluss erscheint die folgende Seite als Bestätigung, dass die Shared Services Provider-Komponente erfolgreich eingerichtet wurde.

Vie Spass...

Heute mal etwas Eigenwerbung. (Wird nicht oft vorkommen, versprochen!!)

Wie aus dem Titel zu entnehmen ist, wird sich in den nächsten Tagen in Sachen sharpcms einiges tun. Viel wird jetzt noch nicht verraten, außer das es personelle und strukturelle Änderungen im sharpcms Projekt gibt und das Projekt in ein neues Repository umzieht (welches verrate ich noch nicht *g*)

sharpcms selber wird natürlich weiterhin Open Source bleiben.

Weitere Informationen wird es dann hier, auf der sharpcms Website, in den beiden Google Groups (deutsch, englisch) und auf meinem persönlichem Blog geben.

Für alle die bis dahin weitere Infos und News gezwitschert bekommen möchten, habe ich einen Twitter Account eingerichtet: http://twitter.com/sharpcms.

Eins der neuen Features im .NET Framework 3.5 SP1 sind die ADO.NET Data Services, diese sind auch unter dem Namen Astoria bekannt.

Wer die Data Services nutzen möchte und den Internet Explorer verwendet, sollte die folgende Einstellung vornehmen:

Extras -->Internetoptionen --> Inhalte --> Feeds --> Einstellungen --> Feedleseanzeige einschalten --> deaktivieren

Mit Hilfe dieser Einstellung werden die XML Daten vom Internet Explorer nicht als RSS Feed angezeigt.
Das Ergebnis ist deutlich besser lesbar ;-)

Auf die Gefahr hin, dass ich doch nie weitere Teile bloggen werde, habe ich riskiert einen Blogeintrag mit “(Teil 1)” im Titel zu schreiben. Statt wie sonst über reine Technologie/Code zu bloggen, möchte ich zur Abwechslung über meine Erfahrungen mit einem Vorgehensmodell – in diesem Fall Scrum – bloggen. Eine Warnung vorweg: Da es um mein erstes Projekt mit Scrum geht muss nicht alles unbedingt 100%ig korrekt sein, was ich hier zu Scrum blogge.

Im Moment arbeite ich als Trainer/Entwickler/Architekt/Berater (im Prinzip ein klein wenig von Allem :-) ) in einem Webentwicklungsprojekt hier in Paderborn. Das ist eine nette Abwechslung zu den vielen Trainings in den letzten Monaten. So ein “echtes” Projekt ist halt doch immer etwas anderes als reine Technologiedemos zu schreiben.

Unser Team besteht aus 7 Entwicklern, wobei viele davon zum ersten Mal zusammenarbeiten. Bisher gab es in der Firma deshalb auch noch keinen richtigen Entwicklungsprozess für solche Projekte. Ich habe am Anfang länger hin und her überlegt, welche Vorgehensweise wir am besten einsetzen sollten. Da das Team sowieso in der Form noch nicht zusammengearbeitet hat und noch nicht alle Teammitglieder richtig viel Erfahrung in .NET haben sollte es nicht zu kompliziert und umfangreich werden. Eine neue Technologie, ein neues Team, und dann auch noch eine komplizierte neue Vorgehensweise, das wäre sicher zuviel auf einmal. Es sollte also etwas kleines, agiles sein, dass keine größere Einarbeitung und komplizierte Prozesse und Dokumente erfordert.

Ich bin schon sehr früh dabei auf Scrum gekommen, habe aber dann doch eine Weile gebraucht, um mich dafür zu entscheiden. Wir haben nicht die Möglichkeit, es wirklich “wie im Lehrbuch” umzusetzen, deshalb hatte ich erst noch weiter nach Alternativen gesucht. Mangels geeigneterer Alternativen habe ich mich dann doch für Scrum entschieden, bzw. dafür, das aus Scrum zu verwenden, was mir für unser Projekt sinnvoll erscheint.

Scrum ist eine agile Projektmanagement-Methode. Im Vergleich zu anderen, vor allem im Vergleich zu nicht agilen Vorgehensweisen wie Unified Process, V-Modell usw. ist es sehr simpel und einfach und besteht im Prinzip nur aus wenigen einfachen Regeln. Da Alexander – der mir am Anfang netterweise meine ersten Fragen zu Scrum beantwortet hat – auf seiner Seite Scrum-Master.de Scrum sehr schön erklärt, verweise ich einfach mal auf seine Scrum-Einführung für eine ausführlichere Erklärung.

Um das Team aufeinander einzustimmen und quasi zum “warm werden” haben wir nicht gleich mit dem “echten” Projekt angefangen, sondern als Testlauf zunächst eine Software entwickelt, die wir intern zur Erfassung unserer Arbeitszeiten nutzen möchten. Dabei setzen wir nach und nach immer mehr Techniken aus Scrum ein. Eine davon möchte ich heute erklären: Sprints.

Bei Scrum wird die Software in mehreren Iterationen, sogenannten Sprints entwickelt. In einem Sprint wird ein Teil der Anforderungen an die Software (bei uns definiert durch User Stories) vollständig umgesetzt. Die einzelnen Stories sind also komplett implementiert, und vor allem auch getestet und dokumentiert, quasi so, dass die Software danach schon (mit den bis dahin implementierten Anforderungen) ausgeliefert und verwendet werden könnte.

Das hat verschiedene Vorteile: Bei anderen Vorgehensweisen kommt z.B. die Testphase erst am Schluss, und auch andere “unangenehme” Aufgaben wie Dokumentation oder Aufräumen/Refactorn des Codes wird gerne mal aufgeschoben. Plötzlich ist dann das Projektende erreicht, und die für die aufgeschobene Arbeit nicht mehr genug Zeit übrig, um z.B. wirklich gründlich zu testen. Entweder bekommt der Kunde dann schlecht getestete Software, es werden schon halb implementiere Features wieder gestrichen oder der Zeitplan muss verlängert werden.

Da man bei Scrum aber schon am Ende eines Sprints einen quasi fertigen Stand der Software erreicht, ist das Risiko dass es zu solchen Problemen kommt viel geringer. Außerdem erhält man schon sehr früh Software, die zumindest schon einen Teil der geplanten Anforderungen umsetzt und damit auch schon eingesetzt werden könnte.

In unserem Testprojekt dauert ein Sprint genau zwei Wochen. Das Ergebnis des 1. Sprints wird inzwischen von uns schon “richtig” genutzt, um unsere Arbeitszeiten zu protokollieren. Die Qualität unserer Software erscheint mir – insbesondere für so ein neues Team – schon sehr hoch. Wir haben viele Unit Tests mit annehmbarer Code Coverage, der Code ist fast zu 100% kommentiert, und die Software macht einen “runden” Eindruck.

Das war jetzt eigentlich schon zuviel für einen einzelnen Blogeintrag ;-). Auch wenn ich noch lange nicht alles zu Scrum geschrieben habe was ich gerne dazu schreiben würde höre ich deshalb für heute damit auf – mehr dazu dann hoffentlich später.

Wie sind eure Erfahrungen mit Scrum? Habt ihr es schon eingesetzt? Was für Methoden/Vorgehensweisen setzt ihr ansonsten in euren Projekten ein?

Seit kurzem gibt es die neue Version 1.2 des artiso WorkItem Managers für VS Team System zum Download. Grund genug für mich, einmal einen kleinen Erfahrungsbericht zum WorkItem Manager zu schreiben.

Bevor ich nun ein Loblied anstimme und die vielen coolen Features aufzähle, allem voran das hierarchische und leichte Anordnen von Work Items, verweise ich lieber auf den Post von Alexander Zeitler, der den WorkItem Manager ausführlich vorgestellt hat. Der geübte Leser merkt es sofort, ich bin wirklich sehr begeistert von dem Tool! :-)

Ich habe den WorkItem Manager in zwei größeren Projekten verwendet und kann sagen, dass die Projekte effizienter waren als vorher - einfach nur, weil alle Beteiligten einen schnelleren Überblick gewinnen konnten. Allein das zum Kunden fahren und dort die Anforderungen aufnehmen, diese dann per Knopfdruck in Team System importieren und dann hierarchisch anordnen, ist schon eine sehr zeitsparende Angelegenheit. Danach noch schnell und einfach die Abhängigkeiten der einzelnen Arbeitsschritte/-pakete erkennen und diese zu einer logischen Abfolge zusammen "klicken" und fertig ist die Planung. ;-) Naja, soo einfach ist es natürlich nicht ganz, aber es fühlt sich fast so an!

Die nächste Arbeitserleichterung ist das automatische Generieren des Pflichtenhefts. Wie Thomas in seinem Vortrag gezeigt hat, kann man das alles so "customizien", dass am Ende ein fertiges Angebot herauskommt.

Zum Schluss noch ein paar Infos zu den Neuerungen in der Version 1.2:

• Mehrfachverknüpfung (Abbildung von Work Items in mehreren Hierarchien der Baumstruktur)
  
  
• Performanceoptimierungen (bei >5000 Work Item wurde die Performance verbessert, aber ich finde man merkt dies auch schon bei kleineren Projekten)
• Installation (ClickOnce hat nun ein echtes Zertifikat)

Ende August soll auch schon die Version 1.3 rauskommen. Weitere Informationen zu beiden Versionen findet man hier.

Link:

• artiso WorkItem Manager

Seit kurzem gibt es die neue Version 1.2 des artiso WorkItem Managers für VS Team System zum Download. Grund genug für mich, einmal einen kleinen Erfahrungsbericht zum WorkItem Manager zu schreiben.

Bevor ich nun ein Loblied anstimme und die vielen coolen Features aufzähle, allem voran das hierarchische und leichte Anordnen von Work Items, verweise ich lieber auf den Post von Alexander Zeitler, der den WorkItem Manager ausführlich vorgestellt hat. Der geübte Leser merkt es sofort, ich bin wirklich sehr begeistert von dem Tool! :-)

Ich habe den WorkItem Manager in zwei größeren Projekten verwendet und kann sagen, dass die Projekte effizienter waren als vorher - einfach nur, weil alle Beteiligten einen schnelleren Überblick gewinnen konnten. Allein das zum Kunden fahren und dort die Anforderungen aufnehmen, diese dann per Knopfdruck in Team System importieren und dann hierarchisch anordnen, ist schon eine sehr zeitsparende Angelegenheit. Danach noch schnell und einfach die Abhängigkeiten der einzelnen Arbeitsschritte/-pakete erkennen und diese zu einer logischen Abfolge zusammen "klicken" und fertig ist die Planung. ;-) Naja, soo einfach ist es natürlich nicht ganz, aber es fühlt sich fast so an!

Die nächste Arbeitserleichterung ist das automatische Generieren des Pflichtenhefts. Wie Thomas in seinem Vortrag gezeigt hat, kann man das alles so "customizien", dass am Ende ein fertiges Angebot herauskommt.

Zum Schluss noch ein paar Infos zu den Neuerungen in der Version 1.2:

• Mehrfachverknüpfung (Abbildung von Work Items in mehreren Hierarchien der Baumstruktur)
  
  
• Performanceoptimierungen (bei >5000 Work Item wurde die Performance verbessert, aber ich finde man merkt dies auch schon bei kleineren Projekten)
• Installation (ClickOnce hat nun ein echtes Zertifikat)

Ende August soll auch schon die Version 1.3 rauskommen. Weitere Informationen zu beiden Versionen findet man hier.

Link:

• artiso WorkItem Manager

Mit Styling kann man das Aussehen von Controls relativ einfach anpassen. Jedes Control hat eine Vielzahl von Eigenschaften über die man die Erscheinung verändern etwas verändern kann.
Möchte man allerdings ein grundlegendes anderes Äußeres für sein Control haben, das auch aus anderen Elementen zusammengesetzt ist und so von den Standardcontrols nicht vorgesehen ist, dann kommt man am Templating nicht vorbei.
Dieses Video zeigt, wie man seinen Controls ein vollständig frei definierbares Äußeres geben.

Silverlight 2 Codeclip: Templating

Seit kurzem gibt es die neue Version 1.2 des artiso WorkItem Managers für VS Team System zum Download. Grund genug für mich, einmal einen kleinen Erfahrungsbericht zum WorkItem Manager zu schreiben.

Bevor ich nun ein Loblied anstimme und die vielen coolen Features aufzähle, allem voran das hierarchische und leichte Anordnen von Work Items, verweise ich lieber auf den Post von Alexander Zeitler, der den WorkItem Manager ausführlich vorgestellt hat. Der geübte Leser merkt es sofort, ich bin wirklich sehr begeistert von dem Tool! :-)

Ich habe den WorkItem Manager in zwei größeren Projekten verwendet und kann sagen, dass die Projekte effizienter waren als vorher - einfach nur, weil alle Beteiligten einen schnelleren Überblick gewinnen konnten. Allein das zum Kunden fahren und dort die Anforderungen aufnehmen, diese dann per Knopfdruck in Team System importieren und dann hierarchisch anordnen, ist schon eine sehr zeitsparende Angelegenheit. Danach noch schnell und einfach die Abhängigkeiten der einzelnen Arbeitsschritte/-pakete erkennen und diese zu einer logischen Abfolge zusammen "klicken" und fertig ist die Planung. ;-) Naja, soo einfach ist es natürlich nicht ganz, aber es fühlt sich fast so an!

Die nächste Arbeitserleichterung ist das automatische Generieren des Pflichtenhefts. Wie Thomas in seinem Vortrag gezeigt hat, kann man das alles so "customizien", dass am Ende ein fertiges Angebot herauskommt.

Zum Schluss noch ein paar Infos zu den Neuerungen in der Version 1.2:

• Mehrfachverknüpfung (Abbildung von Work Items in mehreren Hierarchien der Baumstruktur)
  
  
• Performanceoptimierungen (bei >5000 Work Item wurde die Performance verbessert, aber ich finde man merkt dies auch schon bei kleineren Projekten)
• Installation (ClickOnce hat nun ein echtes Zertifikat)

Ende August soll auch schon die Version 1.3 rauskommen. Weitere Informationen zu beiden Versionen findet man hier.

Link:

• artiso WorkItem Manager

Microsoft hat seine “Photosynth” Software nun für die Webwelt geöffnet- die tollen Effekte die man hier bereits sehen konnte, kann man nun, wenn man möchte, auch mit eigenen Bildern bewerkstelligen:

Ausprobieren lässt sich das ganze unter dieser Adresse (Active X Plugin vorausgesetzt).

ShareThis

Heute Morgen ist die neue Version von Photosynth gelauncht worden. Photosynth ist einer fantastischen neuen Art, Fotos in einem 3D-Umfeld auszutauschen und zu erleben. Die Webseite findet Ihr unter: http://photosynth.com

Photosynth ist eine kostenlose Service von Microsoft Live Labs. Photosynth nimmt eine Kollektion von Fotos von einem Objekt oder Ort und analysiert jedes Foto auf Ähnlichkeiten mit den anderen. Die Applikation dann ermittelt, wo das Bild aufgenommen wurde und baut eine 3D-Model raus. Die Fotos werden im richtigen Platz auf der 3D-Model platziert und Du hast die Möglichkeit durch das 3D-Model zu bewegen. Es ist ein echt cooles Erlebnis!

Mit dieser neuen Version von Photosynth hat man jetzt die Chance selbst Synths zu erstellen. Das Photosynth-Tool um Synths zu erstellen ist einfach zu bedienen aber um ein gutes Synth zu bauen braucht man viele Fotos und ein bisschen Übung. Ich benutze Photosynth seit ein paar Wochen und ich muss sagen, dass auch die Übung mit Photosynth Spaß macht. In den nächsten Tagen werde ich ein Video veröffentlichen, wie man gute Synths erstellt.  

Ich habe inzwischen viele Synths gebaut aber meine Lieblings-Synths sind von Angkor Wat und Marienplatz. Vor ein paar Wochen war ich im Urlaub im Kambodscha und ich habe viele Fotos von Angkor Wat gemacht. Vor ein paar Tage habe ich ein sehr schönes Synth von Marienplatz im München erstellt. Um die Synths anzuschauen, klicke auf der Link unten und installiere das Photosynth-Plugin. Photosynth funktioniert momentan nur auf Windows aber eine Mac Version sollte bald verfügbar sein. Als Browser sollte Ihr Internet Explorer 7, FireFox 2, oder FireFox 3 haben.

Probiere Photosynth aus! Es macht Spaß!

Angkor Wat:

http://photosynth.net/view.aspx?cid=cb64297b-da37-4b8b-b419-fe9d923775d9&i=0:0:20&z=661.2708268188&g=0&p=0:0&m=false&c=-3.41602:4.92284:0.0802998&d=-0.469951:1.82681:2.02749

Marienplatz:

http://photosynth.net/view.aspx?cid=e39d32d2-d4ff-4670-ad7b-4f068bbc12a3&i=0:0:388&z=682.0243749348001&g=0&p=0:0&m=false&c=-20.6324:17.497:-0.146251&d=-0.553121:1.62791:1.99979

Dieser Beitrag beschreibt mit einer Step-by-Step Einleitung die Erstellung eines Entity Models mit Visual Studio 2008 und SQL Server 2008.

Für das folgende Beispielprojekt wird Visual Studio 2008 mit SP1 (Service Pack 1) und SQL Server 2008 mit Adventure Works-Datenbank benötigt.

Schritt 1: Als Erstes erstellen wir ein neues Projekt:

Im Visual Studio 2008 - File - New - Project auswählen. Als Projekttyp wählen wir Console Application. Projektname-Projectname EntityFrameworkSample0010 definieren.

Schritt 2: Als Nächstes benötigen wir ein Entity Model-File. Project - Add New Item auswählen.

Schritt 2a: Und anschliessend ADO.NET Entity Data Model auswählen und AdventureWorks.edmx als Filename eingeben. Es ist üblich, dass der Datenbankname als Entity Data Model-Name verwendet wird.

Schritt 2c: Nach dem wir Add-Button geklickt haben, wir der Entity Data Model Wizard. In diesem Wizard können wir auswählen, ob wir aus einer bestehenden Datenbank unser Entity Data Model erstellen möchten (Generate from database) oder ob wir ein leeres Entity Data Model-File benötigen (Empty Model).

Für unser Beispiel selektieren wir Generate from database und dann mit Next-Button weitermachen.

Schritt 2d: Damit der Wizard die Metadaten-Meta Data für unser Entity Data Model aus der Datenbank lesen kann, benötigen wir eine Datenbankverbindung-Database Connection. In der Auswahlliste werden die Datenbankverbindungen angezeigt, die im Server Explorer-Fenster auch aufgelistet werden.

Für eine neue Datenbankverbindung New Connection-Button klicken oder die Datenbankverbindung für AdventureWorks-Datenbank auswählen.

Schritt 2e: Wenn wir mit New Connection weitermachen, dann erscheint ein Dialog (Choose Data Source), in dem wir den Data Provider auswählen können.

Schritt 2f: In diesem Dialog benötigen wir die Angaben zum SQL Server und Datenbank.

Als Server name müssen wir den Instanznamen-Instance name unseren SQL Server 2008 angeben. Zusätzlich müssen wir definieren, ob wir Windows Authentication oder SQL Server Authentication für die Anmeldung an SQL Server verwenden möchten. Nach dem wir Instanznamen und Authentication-Angaben definiert haben, können wir die Datenbank auswählen.

Schritt 2g: Nach dem wir die Informationen über unser Datenbankserver und Datenbank definiert haben, werden die Angaben nochmals im folgenden Dialog angezeigt.

Im Feld Entity connection string sehen wir die Entity Data Model Spezifisches Information, die ich in einem späteren Blog-Eintrag im Detail erklären werde. In dem unteren Feld sehen wir den Namen des App.Config Eintrages.

Als Nächstes müssen wir den Inhalt unseren Entity Data Models definieren.

Schritt 3: In diesem Schritt wählen wir die Datenbanktabelle für unser Entity Data Model aus. Für das aktuelle Beispiel-Projekt benötigen wir nur drei Tabellen (Product, ProductCategory, ProductSubCategory).

Anschliessend mit Finish-Button können wir unseren Wizard beenden.

Als Resultat erhalten wir unseren Entity Data Model mit drei Entities (ProductCategory > ProductSubCategory > Product).

Nach dem wir unseren Entity Data Model erstellt haben, können wir die Daten aus der Datenbank lesen und ausgeben.

Schritt 4: Wir ergänzen den bereits erstellten Console Application-Code wie folgt:

Der folgende Beispielcode listet alle Produkt-Kategorien (Product categories), die Sub-Kategorien (Product sub categories) und die Produkten (Products) auf.

using System;
using System.Linq;

namespace EntityFrameworkSample0010
{
   class Program
   {
       static void Main(string[] args)
       {
           using (AdventureWorks2008Entities db = new AdventureWorks2008Entities())
           {
               foreach(ProductCategory pc in db.ProductCategory)
               {
                   Console.WriteLine("ProductCategory: " + pc.Name);

                   foreach(ProductSubcategory psc in db.ProductSubcategory.Where(p => p.ProductCategory.ProductCategoryID == pc.ProductCategoryID))
                   {
                       Console.WriteLine("ProductSubCategory: " + psc.Name);

                       foreach (Product p in db.Product.Where(pp => pp.ProductSubcategory.ProductSubcategoryID == psc.ProductSubcategoryID))
                       {
                           Console.WriteLine("Product: " + p.Name);
                       }

                       Console.WriteLine();
                   }

                   Console.WriteLine();
               }

               Console.ReadLine();
           }
       }
   }
}

foreach(ProductSubcategory psc in db.ProductSubcategory.Where(p => p.ProductCategory.ProductCategoryID == pc.ProductCategoryID))
{
   Console.WriteLine("ProductSubCategory: " + psc.Name);

   ...
}

Für Fragen zu diesem Thema bin ich für Euch über die Kommentar-Funktionalität erreichbar.

Viel Spass...

Da ich mich ja nun die letzte Zeit viel mit Tests beschäftige und vor allem mit BDD habe ich mir gedacht, ich kann ma l eine kurze Auflistung der bisherigen Resourcen machen, bei denen ich mich so von Zeit zu Zeit rein lese oder austeste:

• Englische Artikel
  • http://behaviour-driven.org/
  • http://dannorth.net/introducing-bdd
  • http://dannorth.net/whats-in-a-story
• Tools
  • http://nbehave.org/
  • http://codeplex.com/storyq

Dazu gesellen sich dann noch diverse Beiträge zu Domain Driven Design (DDD) und Domain Specific Language (DSL), die ich in nächster Zeit mal nachreichen werde.

Gute Nacht.

Da ich mir zur Zeit die verschiedenen Testframeworks anschaue, die ganzen Enterprise Patterns so langsam und allmählich nach und nach lerne und Anfang September eine Neuentwicklung ansteht, mache ich mich auch noch rund um das UI-Testing gedanken.

Das Thema ist nicht erst seit gestern aktuell. Schon unter C++ habe ich vor 8 Jahren erste Gehversuche unternommen. Das hatte damals schon recht schön geklappt. Nun habe ich einfach vergangene Woche zwei Hinweise auf Frameworks unter .NET bekommen, denen ich mal nachgegangen bin.

• NUnitForms
• WatiN
• Selenium
• UI Automation von MS

Alle drei waren mir vom Namen schon bekannt. Mit WatiN habe ich mich auch schon auf Glatteis gewagt. Bis auf ein paar kleine Ausnahmen (PopUps) hatte das ganze schon gut funktioniert. Ich wußte nun aber, dass es weit mehr als nur diese drei Frameworks gibt, das diese Art des Testens schon lange in Mode ist. Auf Wikipedia bin ich über einen Eintrag zur Test Automation gestolpert, der mich unweigerlich zu anderen Frameworks brachte.

Ohne große Worte und Evaluierung, hier der JumpStart für weitere Recherchen:

• White
• NUnitForms
• Test Automation FX
• Selenium
• UI Automation Framework von MS
• Webcast - Der Erste Schritt zum Record and Play
• Webcast - UI Tests automatisieren
• WatiN
• WatiN Test Recorder (Nimmt vom IE oder Firefox auf )
• WaX (WatiN mit Excel automatisieren)
• MSTest
• WET
• Ranorex
• SWAT
• WASP
• NUnitAsp
  

Einige sind mir wie gesagt bereits bekannt. Wer Informationen, Erfahrungsberichte und Anregungen hat bitte einen Kommentar hinterlassen.

Das Designer-Marketing-Team bei Microsoft in München sucht ab sofort für sechs Monate oder länger einen Praktikanten (m/w). Potentielle Kandidaten sollten Ahnung von gängigen Trends im Web haben, selbständig, selbstbewusst und kommunikationsfreudig sein und bereits Erfahrungen im Bereich Marketing oder PR haben. Vorkenntnisse im Bereich Webdesign oder zu Expression Studio und Silverlight sind nicht notwendig, aber hilfreich (abgeschlossenes Grundstudium steht zwar in der Beschreibung, ist aber nicht zwingend notwendig).

Wer Microsoft von innen kennen lernen will, sollte jetzt seine Online-Bewerbung ausfüllen: http://www.microsoft.com/germany/careers/positionen/detail.mspx?id=DE204C90-D842-40CF-BB51-50F44FEDF57B

Weitere Infos zum Thema Designer Marketing im Blog von Designer Marketing Manager Steffen Ritter: http://blogs.msdn.com/steffenr

Auch RIA-Entwickler und –Designer machen mal Urlaub (habe ich mir jedenfalls sagen lassen); und da ich das „Konzept Urlaub“ voll unterstütze verschenke ich drei schnieke aufblasbare Silverlight-Sessel. Wer einen davon haben will möge mir bitte eine E-Mail schicken und kurz darin begründen warum sie oder er den Sessel haben möchte (Anschrift nicht vergessen). Wie gesagt, es sind nur drei Stück, wer zuerst (überzeugend) schreibt, schwimmt zuerst...

Ach ja, die Auswahl ist subjektiv willkürlich und spontan, humorvolle Mails haben bessere Chancen :)

Bei der Neuinstallation eines Entwicklungsrechners dauert es immer ewig, bis man sich die ganzen nützlichen Helferlein zusammengesucht hat, die man im Laufe der Zeit zu schätzen gelernt hat. Deshalb habe ich mir gedacht, ich schreibe mir mal eine Liste, die ich dann immer wieder ergänzen kann. Und vielleicht ist für den einen oder anderen da auch noch was interessantes dabei. Also so könnte ein Entwicklungsrechner aussehen:

Betriebsystem / Standardanwendungen:

• Windows Vista Ultimate
• Office 2007
• SQL-Server 2005 Express
• SQL-Server 2005 Management Studio

Entwicklungsumgebung:

• Visual Studio 2008 Team Edition Team Suite 
• Visual Studio Team Explorer
  http://www.microsoft.com/downloads/details.aspx?familyid=0ED12659-3D41-4420-BBB0-A46E51BFCA86&displaylang=en
• Microsoft Team Foundation Server Power Tools mit zusätzlichen Tools zum TFS
  http://msdn2.microsoft.com/en-us/tfs2008/bb980963.aspx
• GostDoc um XML-Kommentare zu erstellen (Free)
  http://www.roland-weigelt.de/ghostdoc/
• Infragistics Netadvantage Suite eine sehr gute GUI Bibliothek, aktuelle Hotfixes unbedingt installieren
  http://www.infragistics.com/dotnet/netadvantage.aspx#Overview
• Internet Explorer Developer Toolbar zum untersuchen von Web-Seiten im IE (Free)
  http://www.microsoft.com/downloads/details.aspx?familyid=E59C3964-672D-4511-BB3E-2D5E1DB91038&displaylang=en
• LINQ to SQL Debug Visualizer (Free)
  http://weblogs.asp.net/scottgu/archive/2007/07/31/linq-to-sql-debug-visualizer.aspx
• Lutz Roeders Reflector for .Net um Assemblies zu im Quellcode anzuzeigen (Free)
  http://www.aisto.com/roeder/dotnet/
• Microsoft Chart Controls for Microsoft .NET Framework 3.5 (Free)
  http://www.microsoft.com/downloads/details.aspx?familyid=130F7986-BF49-4FE5-9CA8-910AE6EA442C&displaylang=en
• Microsoft PEX zum automatischen Gerenrieren von Unit-Tests (Free)
  http://research.microsoft.com/pex
• Power Commands for Visual Studio 2008 (Free)
  http://code.msdn.microsoft.com/Release/ProjectReleases.aspx?ProjectName=PowerCommands&ReleaseId=559
• Snippet Designer zum Erstellen von Code-Snippets (Free)
  http://www.codeplex.com/SnippetDesigner

Tools

• Acronis True Image 10 Home um Images der lokalen Platte auf ein USB-Device zu sichern
  http://www.acronis.de/homecomputing/products/trueimage/
• Acrobat Reader 9 (Free)
  http://www.adobe.com/products/acrobat/readstep2.html
• artiso WorkitemManager
  http://www.artiso.com/?Page=90
• AusLogics Disk Defrag zum Festplatten defragmentieren (Free)
  http://www.auslogics.com/disk-defrag/index.php
• Avira AntiVir Workstation als Virenscanner
  http://www.avira.de/de/produkte/avira_antivir_workstation.html
• Axialis Icon Workshop um Icons zu erstellen und zu bearbeiten
  http://www.axialis.com/iconworkshop/
• Cube Desctop für virtuelle Desktops
  http://www.cubedesktop.com/
• Daemon Tools um ISO-Images direkt zu lesen (Free)
  http://www.daemon-tools.cc/dtcc/download.php?mode=ViewCategory&catid=5
• FreeDownloadManager (Free)
  http://www.freedownloadmanager.org/
• IEeee ist ein Plugin für den IE mit dem einfach und schnell Bug-Workitems im TFS generiert werden können (Free)
  http://www.codeplex.com/UKVSTS
• Microsoft Shared View um Desktop über eine einfache Internetverbindung zu sharen (Beta)
  http://www.microsoft.com/downloads/details.aspx?familyid=95AF94BA-755E-4039-9038-63005EE9D33A&displaylang=en
• Mind Manager 7 Pro
  http://www.mindmanager.de
• Notepad++ ein echt cooler Editor für praktisch alle Textformate (Free)
  http://notepad-plus.sourceforge.net/de/site.htm
• Office 2007 Save as PDF or XPS Add-In (Free mit gültigem Office 2007)
  http://www.microsoft.com/downloads/details.aspx?FamilyId=4D951911-3E7E-4AE6-B059-A2E79ED87041&displaylang=en
• Paint .Net, ein sehr gutes Grafik-Programm (Free)
  http://getpaint.net/index.html
• Paint .Net PhotoshopFilter, ein Plugin das das Öffnen und Speichern von Photoshop-Dateien mit Paint .Net ermöglicht (Free)
  http://frankblumenberg.de/doku/doku.php?id=paintnet:psdplugin
• Skype zur Kommunikation über das Internet (Free)
  http://www.skype.de/intl/de/
• Synergy um mein Notebook mit der Tastatur / Maus meines Hauptrechners zu steuer (Free)
  http://synergy2.sourceforge.net/
• Team Foundation Server Administration Tool
  http://www.codeplex.com/Wiki/View.aspx?ProjectName=TFSAdmin
• TPG Setholidays zum Eintragen von Feiertagen in Project und Outlook (Free)
  http://www.theprojectgroup.com/D/produkte/produkte_setholidays.html
• VMWare Workstation um Testumgebungen virtuell ablaufen zu lassen
  http://www.vmware.com/products/ws/
• Windows Live Toolbar mit sinnvollen Tools für den IE, z.B. Blog this (Free)
  http://toolbar.live.com/?mkt=de-at
• Windows Live Writer zum bloggen (Free)
  http://www.live-writer.de/project/WindowsLiveWriterDownload.aspx
• XML Notepad zum Anzeigen und Bearbeiten von XML-Dateien (Free)
  http://www.microsoft.com/downloads/details.aspx?FamilyID=72D6AA49-787D-4118-BA5F-4F30FE913628&displaylang=en
• ZoomIt zum Zoomen und Zeichnen auf dem Desktop - sehr praktisch für Präsentationen (Free)
  http://download.sysinternals.com/Files/ZoomIt.zip
  

Stand 30.10.2008
To be continued...

Auf dotnet-snippets.de gibt es wieder etwas zu gewinnen!

Vom 18. August bis zum 1.September läuft auf dotnet-snippets.de ein QuickContest. Zu gewinnen gibt es  3 Amazon Gutscheine, jeweils in Wert von 20€.

Was ist ein QuickContest?

Ein QuickContest ist ein Snippet Wettbewerb für ungeduldige :-).
Er zeichnet sich durch mehrere Eigenschaften aus:

- kurze Ankündigungszeit
- kurze Laufzeit
- schnelle Auswahl der Gewinner durch ein kleines Team
- schnelle Zustellung der Preise

Beim ersten und zweiten Wettbewerb habe ich mehrere Rückmeldungen bekommen, dass der Wettbewerbszeitraum zu lang war und das die Jury zu lange gebraucht hat, um die Gewinner zu ermitteln.
Ich bin gespannt, wie das neue  Konzept bei der Community ankommt. Über Feedback würde ich mich sehr freuen.

This post is powered by www.Giza-Blog.de |
Visit:  MSDN Online | Kostenfreie MSDN Service-Hotline für Entwickler
Daily News on MSDN:   MSDN Aktuell
© Copyright 2006-2008 Kay Giza. All rights reserved. Legal

E-Mails aus BizTalk-Server dynamisch versenden, Daten aus Dynamics CRM auslesen, Nachrichtenschemata mit BizTalk Editor bearbeiten, den SharePoint Services Adapter Send-Windows einsetzen - dies stellt nur eine kleine Auswahl der aktuellsten Themen für Enterprise-Entwickler in den MSDN Webcasts und MSDN Solve CodeClips dar. Nicht minder finden auch Profis, Fortgeschrittene und sogar Einsteiger in den kostenlos angebotenen audiovisuellen Kursen Hilfe, Unterstützung und die Fortbildung, die sie regelmäßig mit kleinem Aufwand und auf der Höhe der Zeit hält. Der folgende Link verweist auf den RSS-Feed, den Sie in Outlook 2007 oder andere Feedreader eintragen können, um künftig keine der kostenlosen Fortbildungsangebote zu verpassen.

RSS-Feed: MSDN Webcasts & CodeClips – RSS-Feed für Ihre kostenlose Fortbildung

This post is powered by www.Giza-Blog.de |
Visit:  MSDN Online | Kostenfreie MSDN Service-Hotline für Entwickler
Daily News on MSDN:   MSDN Aktuell
© Copyright 2006-2008 Kay Giza. All rights reserved. Legal

We are drowning in a sea of information overload.  Every day, television channels, email, books and music assault our senses with far too much content.  The volume of content on the internet and generated by applications is literally exploding.  Not only traditional media but millions of individual users are putting their own content on the web.  The massive popularity of YouTube is just one example of this phenomenon.  In this flood, how do you distinguish between content that matters to you from all the rest?  How can you easily discover information, multimedia content and entertainment that matches your interests or preferences?  How do you deal with this crisis of choice?

Well, Software Engineers at the European Microsoft Innovation Center (EMIC) are working on a project that allows for the quick creation of prototype solutions that help people solve this crisis of choice.

In this video, Ron Mevissen, Lead Developer of the EMIC Home team, gives an introduction to the topic of information overload and the project that he and colleagues are working on.  He also demonstrates the Media Center recommender prototype that helps you find interesting TV programs.  After that, Stefan Hirtbach shows a recommender for Outlook that helps you decide the importance of email - which email should I read now, which one can wait.  Rich Hanbidge shows a recommender for Xbox Live that helps you find interesting items such as downloadable videos, games, etc. offered by Xbox Live.  Rene Hülswitt demos the Virtual Earth recommender that helps find interesting POI (points of interests) such as restaurants or tourist attractions near you.

The EMIC in Aachen, Germany was founded in 2003 and is a Microsoft Research & Development facility.  The German lab is unique to Microsoft in its focus on collaborative applied research in Europe.  EMIC works in the context of development programs sponsored by the European Commission and the German Ministry of Education and Research (BMBF). Its research is focused on enterprise, mobility, home, security, software verification and embedded systems.

For more information on EMIC research, projects and partners, visit:
http://www.microsoft.com/EMIC

To find out more about projects at EMIC, check out these videos over on Channel 9…
EMIC - Specialized Workflow Foundation Activity
http://channel9.msdn.com/posts/Lori/EMIC-Specialized-Workflow-Foundation-Activity/
EMIC - Delegation Framework
http://channel9.msdn.com/posts/Lori/EMIC-Delegation-Framework/

Dieser Beitrag beschreibt mit einer Step-by-Step Anleitung die Entwicklung eines "Hello World WebParts" mit Visual Studio 2005 und Visual Studio 2005 extensions for Windows SharePoint Services 3.0 Version 1.1.

Für das folgende Beispielprojekt benötigt ihr eine Windows SharePoint Services 3.0 (WSS 3.0) oder Office SharePoint Server 2007 (MOSS 2007) Installation mit Visual Studio 2005 mit Visual Studio 2005 extensions for Windows SharePoint Services 3.0.

Schritt 1: File - New - Project auswählen

Schritt 2: Visual C# - Web Part Template auswählen und HelloWorldWebPart als Projektname-Projectname definieren. Anschliessend OK-Button klicken.

Im Visual Studio 2005 wird folgender Code automatisch erstellt.

Schritt 3: In diesem Schritt erweitern wir den Code. Im Render-Ereignis wird der Text "Hello World WebPart" mithilfe der Write-Methode ausgegeben. Und im OnPreRender-Ereignis definieren wir den Title-Eigenschaft-Property unseren WebParts.

using System;
using System.Runtime.InteropServices;
using System.Web.UI;
using System.Web.UI.WebControls.WebParts;
using System.Xml.Serialization;

using Microsoft.SharePoint;
using Microsoft.SharePoint.WebControls;
using Microsoft.SharePoint.WebPartPages;

namespace HelloWorldWebPart
{
   [Guid("9aadb963-b0b0-4c99-8b93-d32b8dbbf717")]
   public class HelloWorldWebPart : System.Web.UI.WebControls.WebParts.WebPart
   {
       public HelloWorldWebPart()
       {
           this.ExportMode = WebPartExportMode.All;
       }

       protected override void Render(HtmlTextWriter writer)
       {
           // TODO: add custom rendering code here.
            writer.Write("Hello World WebPart");
       }

       protected override void OnPreRender(EventArgs e)
       {
           this.Title = "Hello World";
       }
   }
}

Schritt 4: Im nächsten Schritt werden wir die Projekt-Eigenschaften ändern. Project - HelloWorldWebPart Properties auswählen.

Schritt 5: Wenn wir unseren WebPart direkt vom Visual Studio aus verteilen möchten, dann müssen wir angeben, wie unser Server heisst, auf dem wir unser WebPart verteilen möchten. In meinem Beispiel hat mein SharePoint Server 2007 den Namen SRV-031.

Schritt 6: In diesem Schritt werden wir unseren HelloWorldWebPart kompilieren. Build - Build HelloWorldWebPart auswählen.

Schritt 7a: Nach einer fehlerfreien Kompilierung können wir jetzt unseren WebPart verteilen. Build - Deploy HelloWorldWebPart auswählen.

Schritt 7b: Die Fehlermeldung-Error Message No SharePoint Site exists at the speicifed URL.

Dieser Meldung haben wir erhalten, weil wir im Projekt-Eigenschaften-Dialog - Project Properties Dialog nur den Servernamen definiert aber keine SiteCollection angegeben haben.

Schritt 7c: Nochmals den Projekt-Eigenschaft - Project Properties Dialog aufrufen und die URL mit SiteCollection ergänzen. In meinem Beispiel heisst meiner SiteCollection SiteCol001.

Jetzt können wir nochmals versuchen, unseren WebPart zu verteilen.Build - Deploy HelloWorldWebPart auswählen.

Schritt 7d: Wenn der angemeldeter Benutzer nicht genügend Recte auf dieser SiteCollection besitzt, dann kann der WebPart nicht verteilt werden. Visual Studio meldet sich dann mit der Meldung Attempted to perform an unauthorized operation.

Schritt 7e: SiteColleciton aufrufen und dann Site Actions - Site Settings aufrufen.

Unter Users and Permissions - Site Collection administrators können wir unseren User als Site Collection Adminisitrator hinzufügen.

Ihr Login eintragen und mit OK bestätigen.

Schritt 7f: Build - Deploy HelloWorldWebPart auswählen. Wenn ihr unten die Meldung Deploy succeeded sieht, dann bedeutet dies, dass die Verteilung erfolgreich war.

Schritt 8: Als nächstes können wir kontrollieren, ob unser HelloWorldWebPart in unser SiteCollection zur Verfügung steht. Nochmals SiteCollection aufrufen und dann Site Actions - Site Settings. Anschliessend Galleries - Web Parts auswählen.

In der Liste finden wir unseren HelloWorldWebPart. Jetzt können wir unseren neuen WebPart verwenden.

Schritt 9: Nochmals SiteCollection öffnen und diesmal unter Site Actions - Edit Page auswählen. Mit Edit Page können wir die Seite umgestaltet und auch neuen WebPart hinzufügen.

Anschlissend wird der Ansicht wie folgt aussehen:

Hier Add a WebPart klicken und unseren WebPart HelloWorldWebPart auswählen. Anschliessend den Add-Button klicken.

Unseren WebPart konnten wir so auf unser Seite platzieren. Der Titel Hello World und Text Hello World WebPart werden angezeigt.

Viel Spass...

Win32-APIManchmal benötigt man die Information wo denn die Datei eines bestimmten Prozess liegt. Das .NET Framework bietet zwar einiges an Möglichkeiten mit Prozessen umzugehen, jedoch keine um den Pfad der Datei eines bestimmten Prozess zu ermitteln. Zumindest ist mir keine bekannt. Bevor jetzt begonnen wird auf gut Glück die Verzeichnisse der Laufwerke zu durchsuchen oder etwa in der Windows Registrierung gestöbert wird, lohnt sich ein Blick in die Win32-API. Gerade was die Prozess-Verwaltung angeht, wird hier viel geboten. Mit der Funktion GetProcessImageFileName bietet die Win32-API genau das was benötigt wird. Diese Funktion gibt den Namen mitsamt komplettem Pfad eines bestimmten Prozess zurück. Der Aufruf der Funktion aus der psapi.dll (Process Status API) ist nicht weiter tragisch. Lediglich im DllImportAttribute muss das Feld CharSet mit dem Wert Unicode der CharSet-Enumerationbelegt werden, da sonst evtl. nur Zeichen-Salat zurückgegeben wird.

Wie zu sehen ist, benötigt der erste Parameter ein Prozess-Handle um den Pfad ermitteln zu können. Um das Handle eines bestimmten Prozess zu erhalten, wird die Funktion OpenProcess verwendet.

Diese Funktion erwartet als letzten Parameter eine ProzessID. Der erste Parameter dwDesiredAccess ist ein Wert der ein Prozess spezifisches Zugriffsrecht darstellt. Für meinen Anwendungsfall reicht hier das Recht PROCESS_QUERY_INFORMATION vollkommen aus, da nur der Pfad ermittelt werden soll. Wer mehr darüber erfahren will, kann sich diesen Artikel über Prozess-Sicherheit und Zugriffsrechte durchlesen.

Da geöffnete Handle so bald als möglich wieder geschlossen werden sollten, ist anzuraten auch gleich die Funktion CloseHandle zu implementieren.

Der von der Funktion GetProcessImageFileName zurückgegebene Pfad erscheint allerdings nicht ganz in dem Format in dem wir es gewohnt sind. Windows verwendet intern keine Laufwerksbuchstaben, sondern die Gerätekennung eines Laufwerks. Für uns Anwender werden diesen Gerätekennungen dann Buchstaben zugewiesen, welche wir als Laufwerksbuchstaben kennen. Der Rückgabewert von GetProcessImageFileName für die Datei test.exe könnte also in etwa so aussehen:

 \Device\Harddisk0\Partition1\Program Files\test.exe

Jetzt muss noch ein Weg gefunden werden, diesen Gerätepfad in einen Laufwerkspfad zu übersetzen. Die einzige mir bekannte Funktion der Win32-API die ähnliches bietet, ist die Funktion QueryDosDevice. Beim Import der Funktion muss unbedingt darauf geachtet werden, welche Funktion implementiert wird, da die gleiche Funktion einmal für Ansi und einmal für den Unicode-Zeichensatz vorhanden ist. Ich verwende in C# wenn möglich immer Implementierungen die mit dem Ansi-Zeichensatz arbeiten. Das Unterscheidungsmerkmal der beiden Funktionen ist das A für Ansi und W für den Unicode-Zeichensatz am Ende des Funktionsnamen.

Mit ihr kann zwar nicht direkt der Laufwerksbuchstabe eines Gerätes abgefragt werden, jedoch kann über die Angabe eines Laufwerksbuchstaben der Namen des zugrundeliegenden Gerätes ermittelt werden. Das ist der Ansatz den ich verwendet habe. Im folgenden Screenshot des Überwachen Fensters einer Debugsitzung ist das Auflösen eines Gerätepfad in einen Laufwerkspfad sehr schön zu sehen:

Damit der ganze Artikel nicht zu theoretisch bleibt, möchte ich zum Schluss noch eine real verwendete Methode zeigen, die auf der beschriebenen Implementierung basiert. Als Basis zum verwenden von Laufwerksbuchstaben habe ich ein Zeichenfolgen-Array mit dem Alphabet verwendet. Vielleicht gibt es dafür ja einen besseren oder eleganteren Weg. Hier nun die Methode, von der auch der obige Screenshot stammt.

Wie bereits im Kommentar der Methode beschrieben, können mit dieser Methode nicht die Pfade zu Prozessen ermittelt werden die als Dienst gestartet wurden.

Neulich habe ich mit Stephan Fasshauer (Marketing Manager bei Microsoft Deutschland) über Office, Office Live und Office Online gesprochen.  Er hat mir die Unterschiede zwischen die verschiedenen Produkte erklärt und mir ein paar Tipps zu den Office Produkte gegeben. Stephan hat mir auch sein Lieblingsfeature (SmartArt) und ein Schnellstartleiste Add-in für Office 2007 gezeigt.  Dieses Add-in erweitert die Multifunktionsleiste (Ribbon) mit einem neuen Menüpunkt, das ermöglicht man schnell auf wichtige Hilfe und Anleitungen, Tipps & Tricks Ressourcen zuzugreifen und macht den Einstieg in Office 2007 einfacher.  Auch interessant für Leute, die auf Office 2007 umgestiegen sind, ist ein Tool, um Funktionen in Office 2003 und 2007 zu vergleichen.  Es ist ein interaktives Referenzhandbuch, um Funktionen in der neuen Menüführung zu finden.

Weitere Tipps und Information zu Office Produkte findet man auf Stephans Blog:

http://stephan-at-work.spaces.live.com/

oder auf diesen weiteren Webseiten:

Office Online

http://office.microsoft.com/de-de/default.aspx

Die Office Produkte in der Übersicht

http://office.microsoft.com/de-de/products/FX100487411031.aspx?pid=CL100571081031

Vergleichstabelle der Office Suiten

http://office.microsoft.com/de-de/products/FX101635841031.aspx

Office Live Workspace

http://workspace.officelive.com/

Office Live Small Business

http://smallbusiness.officelive.com/

Schnellstartleiste für Office 2007

http://stephan-at-work.spaces.live.com/blog/cns!102220505F300E88!213.entry

Funktionen vergleichen in Office 2003 und 2007

http://stephan-at-work.spaces.live.com/blog/cns!102220505F300E88!151.entry

Visual Studio erweitern ist mittlerweile mit dem SDK ein leichtes geworden. Der einzige Faktor ist die Zeit, sich das Wissen anzueignen. Gute Quellen gibt es zu genüge. Hier nun zu meinen bisher genannten, neue Links, die ich entdeckt oder so noch nicht erwähnt habe.

• http://dotneteers.net/blogs/divedeeper/ von Istvan Novak  (der Mann, der die DeepDives produziert, siehe zweiter Punkt)
• VSXtra, ein Managed Framework um das VS SDK herum (ein paralleles Projeckt zu den DeepDives aus LearnVSXNow)
• Visual Studio Extensibility User Education (bisher kaum Einträge in dem Blog, aber dennoch als Quelle zu erwähnen)

Wer eine Visual Studio 2008 Standard Edition oder höher sein Eigen nennt, kann sich jetzt kostenlos einen Icon-Editor herunterladen.

Axialis Software - IconWorkshop™ Lite Download

Mein kleines Projekt “ReadYou” kommt in winzigen Schritten vorwärts - allerdings mehr auch nicht. Grund hierfür ist meist, dass wenn man sich in ein Thema mal versucht einzulesen, man sofort auf zwei neue interessante Sachen stößt. So z.B. die Mockinggeschichte um meine UnitTests besser zu gestalten.

Architekturumgestaltung

Meine Grundsätzliche Architektur war so aufgebaut wie in diesem Blogpost beschrieben.

Durch das gute Feedback zu dem 3-Schichten Architektur Blogpost habe ich es nun grob so eingeteilt:

Mein Model liegt nun nicht mehr im Data rum, sondern ist theoretisch auf allen Schichten erreichbar und daher in einer eigenen DLL zu finden. Das Model besteht aus einfachen POCOs - die nichts anderes machen außer Daten halten.

Da ich möglichst flexibel bin und auch alles fein säuberlich testen kann, ist jede Schicht aufgeteilt in:

Bei Data ist natürlich genau dasselbe vorzufinden: Die Trennung zwischen den Interfaces und der eigentlichen Implementierung die ich vorgenommen habe.

Response & Request bei den Services

Als ich mein Interface für den BookService vorbereitet habe, habe ich überlegt, was ich alles für “Aufrufe” brauche:

    public interface IBookService
    {
        IList<Book> GetBooks();
        IList<Book> GetBooksByAuthor(Author author);
        IList<Book> GetBooksByUser(User user);
        IList<Book> GetBooksByTag(Tag tag);
        IList<Book> GetBooksByCategory(Category cat);
       ....

    }

Allerdings ist das nicht wirklich schön - mein Service hätte äußerst viele Methoden um Bücher ranzuholen. Einmal anhand des Autors, einmal nach Kategorie etc.
Komplexer wären noch Sachen wie: “GetBooksByCategoryAndUser” - heiei… für jeden Fall eine Methode zu schreiben, erscheint mir nicht sinnvoll.

Meine Lösung: Request & Response

Wie ein “WebService” geben meine Services auch Responses zurück und verlangen ein Request Objekt:

Diese Objekte habe ich in ReadYou.Service.Model hinterlegt - da sie nur im Service vorkommen, ich allerdings diese Definitionen und die Logik in seperaten DLLs trennen wollte:

Dabei leitet der “GetBooksRequest” von “BaseRequest” ab und beim Response genauso.

Durch dieses Objekt kann ich später genau mein “GetBooksRequest” definieren:

    public class GetBooksRequest : BaseRequest
    {
        public Tag Tag { get; set; }
        public Category Category { get; set; }
        public User User { get; set; }
        public Author Author { get; set; }
    }

Jetzt könnte ich mir sowas wie “Gib mir alle Bücher vom Autor XYZ, des Users ABC mit der Kategory “Krimi”" - das erlaubt mir einige Freiheiten und sollte erweiterbar sein, falls mir wieder was neues einfällt.

Wie sieht das im Projekt aus?

Alles ist aufgeteilt - dabei fehlen allerdings noch UnitTests für den “Data” Teil und für die WebApp (die hier noch nicht zu sehen ist). Unter “Common” befinden sich nur ein paar Extensions die mir das leben erleichtern

Mit dieser Ordnung bin ich gerade recht zufrieden - alles ist soweit getrennt und alles was Logik hat, hat auch ein Interface. Späße wie Dependency Injection und co. steht auch nichts im Wege.
Durch die Response / Request Sache bin ich später recht flexibel - auch wenn es etwas mehr Schreibaufwand ist.

Das wichtigste ist allerdings:

Wie seht ihr das? Ist die Idee mit den Response/Request Objekten vielleicht doch nicht so toll? Gebt einfach euer Feedback ab - den Code (sobald ich noch etwas weiter bin), werde ich auf Codeplex zur Verfügung stellen. Momentan ist diese Version noch nicht hochgeladen.

ShareThis

Wie ich schon hier und hier berichtet habe, geht meine kleine User Group Tour weiter! :)

• Am 30.10.08 besuche ich die DNUG Franken
• Am 06.11.08 die DNUG Berlin Brandenburg
• Am 26.11.08 die DNUG Koblenz

Vortragsthema bei allen drei Terminen ist VSTO (Visual Studio Tools for Office)

Ich freue mich! :)

Microsoft Research ist Microsofts Forschungsabteilung, welche durch recht “coole” Sache auf sich aufmerksam machen - einige Ideen/Konzepte kann man später auch in richtigen Produkten wiederfinden: Surface oder Deepzoom.

Heute bin ich bei Tim Heuers Blog mal wieder auf Photosynth aufmerksam geworden:

Auch interessant ist das Projekt “Unwrap Mosaics” - Videobearbeitung leicht gemacht

ShareThis

Die .NET Developer Group Braunschweig trifft sich zu ihrem 23 User Group Treffen am 19.08.08 um 19:00 im Restaurant Kilian's Raffinerie.

Dieses Mal gibt es 2 Vorträge:

Net Webseiten lesen lassen – HTML elegant geparst mit dem Html-Agility-Pack
Referent: Werner Mager
Webservices sind mittlerweile der Standard zur Kommunikation über das Internet für Applikationen. Leider steht nicht immer ein Webservice zur Verfügung, so dass einem nichts anderes übrig bleibt, als aus der eigenen Applikation heraus dynamische Html-Seiten zu lesen. Diese sind jedoch in den seltensten Fällen zur programmatischen Auswertung geeignet. Wohlgeformtes XML ist hier nicht zu finden. Mit der Open Source Bibliothek Html-Agility-Pack wird diese Lücke geschlossen. In dem Vortrag von Werner Mager wird die Bibliothek kurz vorgestellt und in praktischen Beispielen gezeigt, wie Daten von verschiedenen Webseiten (Google.de, dotnet-braunschweig.de …) abgefragt und per XPath-Query verarbeitet werden können. Ergänzend wird ein Hilfstool vorgestellt, mit dem die XPath-Abfragen getestet und visualisiert werden können.

VSTO 3.0 - Was gibt es neues in der Office Entwicklung?
Referent: Lars Keller
Die mit Visual Studio 2008 ausgelieferte VSTO 3.0 Komponente und die frisch erschienenen VSTO Power Tools bringen zahlreiche Neuerungen für die Office Entwicklung mit sich. Ein wichtiges neues Feature in Office 2007 ist die Ribbon UI. Aber wie kann man diese anpassen? Was kann der neue Ribbon-Designer in VS 2008? Kann WPF in Office angewendet werden und wie passt LINQ dazu? Diese und weitere Fragen werden in dem Vortrag von Lars Keller behandelt. Die Theorie wird dabei durch viele kleine Live-Coding Beispiele abgerundet

Weitere Informationen gibt es auf www.dotnet-braunschweig.de

Wie immer ist jeder herzlich willkommen!

Dieses lustige Video "Activating a Custom Tab on the Ribbon When a Document Is Opened" von Harry Miller geht der Frage nach, ob man ein Ribbon Tab selektieren kann, wenn ein Dokument geöffnet wird.

Antwort: Nein, das ist "made by design".

Der .NET Open Space 2008 läuft vom 17.10.2008 19 Uhr bis 19.10.2008 19 Uhr und besteht derzeit aus den drei parallelen Themenfeldern:

    * ALT.NET
    * Mobile Computing
    * Soft Skills

Welche Inhalte in den einzelnen Themenfeldern bearbeitet werden, bestimmst du vor Ort, denn die Veranstaltung ist Open Space! Die Teilnahme ist kostenlos. Die Teilnehmer gestalten das Programm selbst. Erfahrungsaustausch ist das A und O und steht im Vordergrund. Mehr Informationen und die Registrierung gibt es auf der Webseite.

Ich freue mich sehr auf den Event, weil diese Konferenz ganz im Sinne des Austausches untereinander steht.

Man sieht sich da! :) Es sind noch ein paar Plätze frei!

Wie ich schon hier und hier berichtet habe, geht meine kleine User Group Tour weiter! :)

• Am 30.10.08 besuche ich die DNUG Franken
• Am 06.11.08 die DNUG Berlin Brandenburg
• Am 26.11.08 die DNUG Koblenz

Vortragsthema bei allen drei Terminen ist VSTO (Visual Studio Tools for Office)

Ich freue mich! :)

Die .NET Developer Group Braunschweig trifft sich zu ihrem 23 User Group Treffen am 19.08.08 um 19:00 im Restaurant Kilian's Raffinerie.

Dieses Mal gibt es 2 Vorträge:

Net Webseiten lesen lassen – HTML elegant geparst mit dem Html-Agility-Pack
Referent: Werner Mager
Webservices sind mittlerweile der Standard zur Kommunikation über das Internet für Applikationen. Leider steht nicht immer ein Webservice zur Verfügung, so dass einem nichts anderes übrig bleibt, als aus der eigenen Applikation heraus dynamische Html-Seiten zu lesen. Diese sind jedoch in den seltensten Fällen zur programmatischen Auswertung geeignet. Wohlgeformtes XML ist hier nicht zu finden. Mit der Open Source Bibliothek Html-Agility-Pack wird diese Lücke geschlossen. In dem Vortrag von Werner Mager wird die Bibliothek kurz vorgestellt und in praktischen Beispielen gezeigt, wie Daten von verschiedenen Webseiten (Google.de, dotnet-braunschweig.de …) abgefragt und per XPath-Query verarbeitet werden können. Ergänzend wird ein Hilfstool vorgestellt, mit dem die XPath-Abfragen getestet und visualisiert werden können.

VSTO 3.0 - Was gibt es neues in der Office Entwicklung?
Referent: Lars Keller
Die mit Visual Studio 2008 ausgelieferte VSTO 3.0 Komponente und die frisch erschienenen VSTO Power Tools bringen zahlreiche Neuerungen für die Office Entwicklung mit sich. Ein wichtiges neues Feature in Office 2007 ist die Ribbon UI. Aber wie kann man diese anpassen? Was kann der neue Ribbon-Designer in VS 2008? Kann WPF in Office angewendet werden und wie passt LINQ dazu? Diese und weitere Fragen werden in dem Vortrag von Lars Keller behandelt. Die Theorie wird dabei durch viele kleine Live-Coding Beispiele abgerundet

Weitere Informationen gibt es auf www.dotnet-braunschweig.de

Wie immer ist jeder herzlich willkommen!

Der .NET Open Space 2008 läuft vom 17.10.2008 19 Uhr bis 19.10.2008 19 Uhr und besteht derzeit aus den drei parallelen Themenfeldern:

    * ALT.NET
    * Mobile Computing
    * Soft Skills

Welche Inhalte in den einzelnen Themenfeldern bearbeitet werden, bestimmst du vor Ort, denn die Veranstaltung ist Open Space! Die Teilnahme ist kostenlos. Die Teilnehmer gestalten das Programm selbst. Erfahrungsaustausch ist das A und O und steht im Vordergrund. Mehr Informationen und die Registrierung gibt es auf der Webseite.

Ich freue mich sehr auf den Event, weil diese Konferenz ganz im Sinne des Austausches untereinander steht.

Man sieht sich da! :) Es sind noch ein paar Plätze frei!

• Die Post-Frequenz der durchwegs bekannten Blogger hat in den letzten Monaten sehr stark abgenommen (außer bei ein paar wenigen).
• Viele der altbekannten Blogger schreiben überhaupt keine Beiträge mehr.
• Längere Artikel zu einem Thema sind mittlerweile kaum mehr zu finden. Meist handelt es sich um kurze Beiträge, Links auf tatsächliche Artikel.

Meine Kollegin Lori war vor einigen Tagen in Aachen und hat unser EMIC (European Microsoft Innovation Center) besucht. Natürlich nicht ohne Kamera :-)

Die Videos die sie dabei produziert hat sind auf Channel 9 zu sehen.

http://channel9.msdn.com/posts/Lori/European-Microsoft-Innovation-Center-in-Aachen-Germany/

http://channel9.msdn.com/posts/Lori/EMIC-Framework-to-Build-Prototype-Solutions-for-Crisis-of-Choice/

http://channel9.msdn.com/posts/Lori/EMIC-Specialized-Workflow-Foundation-Activity/

http://channel9.msdn.com/posts/Lori/EMIC-Delegation-Framework/

Dieses lustige Video "Activating a Custom Tab on the Ribbon When a Document Is Opened" von Harry Miller geht der Frage nach, ob man ein Ribbon Tab selektieren kann, wenn ein Dokument geöffnet wird.

Antwort: Nein, das ist "made by design".

Wie ich schon hier und hier berichtet habe, geht meine kleine User Group Tour weiter! :)

• Am 30.10.08 besuche ich die DNUG Franken
• Am 06.11.08 die DNUG Berlin Brandenburg
• Am 26.11.08 die DNUG Koblenz

Vortragsthema bei allen drei Terminen ist VSTO (Visual Studio Tools for Office)

Ich freue mich! :)

Die .NET Developer Group Braunschweig trifft sich zu ihrem 23 User Group Treffen am 19.08.08 um 19:00 im Restaurant Kilian's Raffinerie.

Dieses Mal gibt es 2 Vorträge:

Net Webseiten lesen lassen – HTML elegant geparst mit dem Html-Agility-Pack
Referent: Werner Mager
Webservices sind mittlerweile der Standard zur Kommunikation über das Internet für Applikationen. Leider steht nicht immer ein Webservice zur Verfügung, so dass einem nichts anderes übrig bleibt, als aus der eigenen Applikation heraus dynamische Html-Seiten zu lesen. Diese sind jedoch in den seltensten Fällen zur programmatischen Auswertung geeignet. Wohlgeformtes XML ist hier nicht zu finden. Mit der Open Source Bibliothek Html-Agility-Pack wird diese Lücke geschlossen. In dem Vortrag von Werner Mager wird die Bibliothek kurz vorgestellt und in praktischen Beispielen gezeigt, wie Daten von verschiedenen Webseiten (Google.de, dotnet-braunschweig.de …) abgefragt und per XPath-Query verarbeitet werden können. Ergänzend wird ein Hilfstool vorgestellt, mit dem die XPath-Abfragen getestet und visualisiert werden können.

VSTO 3.0 - Was gibt es neues in der Office Entwicklung?
Referent: Lars Keller
Die mit Visual Studio 2008 ausgelieferte VSTO 3.0 Komponente und die frisch erschienenen VSTO Power Tools bringen zahlreiche Neuerungen für die Office Entwicklung mit sich. Ein wichtiges neues Feature in Office 2007 ist die Ribbon UI. Aber wie kann man diese anpassen? Was kann der neue Ribbon-Designer in VS 2008? Kann WPF in Office angewendet werden und wie passt LINQ dazu? Diese und weitere Fragen werden in dem Vortrag von Lars Keller behandelt. Die Theorie wird dabei durch viele kleine Live-Coding Beispiele abgerundet

Weitere Informationen gibt es auf www.dotnet-braunschweig.de

Wie immer ist jeder herzlich willkommen!

Der .NET Open Space 2008 läuft vom 17.10.2008 19 Uhr bis 19.10.2008 19 Uhr und besteht derzeit aus den drei parallelen Themenfeldern:

    * ALT.NET
    * Mobile Computing
    * Soft Skills

Welche Inhalte in den einzelnen Themenfeldern bearbeitet werden, bestimmst du vor Ort, denn die Veranstaltung ist Open Space! Die Teilnahme ist kostenlos. Die Teilnehmer gestalten das Programm selbst. Erfahrungsaustausch ist das A und O und steht im Vordergrund. Mehr Informationen und die Registrierung gibt es auf der Webseite.

Ich freue mich sehr auf den Event, weil diese Konferenz ganz im Sinne des Austausches untereinander steht.

Man sieht sich da! :) Es sind noch ein paar Plätze frei!

Vor ein paar Tagen habe ich bereits über den Podcast von Scott Hanselman und Saqib Shaikh geschrieben, heute habe ich auf Channel 9 ein Videointerview mit den Beiden (und Dan Fernandez) gefunden:

Saqib Shaikh and Scott Hanselman: Designing for Accessibility

ShareThis

John. hat im Forum darauf hingewiesen, dass sich nach der Installation des SP1 für Visual Studio 2008, ein neues Plugin mit dem Namen "Microsoft .NET Framework Assistent" im Firefox befindet. Das Plugin dient der ClickOnce Unterstützung im Firefox, außerdem kann es die Framework-Version an den entsprechenden Webserver senden. Letzteres kann über die Einstellungen deaktiviert werden.

Mehr über die Neuerungen durch das SP1 ist bei Scott Guthrie unter Visual Studio 2008 and .NET Framework 3.5 Service Pack 1 Beta zu lesen.

In einem HowTo ging es darum, was Interface eigentlich sind und wo man sowas einsetzen könnte. In vielen OOP Büchern wird immer wieder hervorgehoben, warum es so wichtig ist, “auf eine Schnittstelle zu programmieren” und nicht “auf eine konkrete Klasse“. Bis vor kurzem war es mir selber noch nicht ganz klar, wozu dieser Aufriss mit den ganzen Schnittstellen, bis ich mit “Test Driven Development” angefangen habe.

Häufige Argumentation für Interfaces:

Wenn man sich etwas mit den Interfaces beschäftigt, dann kommt man immer wieder zum Datenbankbeispiel. “Stellen wir uns doch mal vor, die Datenquelle wechselt!”

Wie könnte ein Interface an dieser Stelle helfen?

An dieser Stelle können Interface helfen, indem sie wie eine Art “Vertrag” wirken:

interface IDataProvider
{
	List<string> GetData();
}

class OracleDataProvider : IDataProvider
{
	List<string> GetData()
	{
	// Oracle Zeugs
	}
}

class SqlDataProvider : IDataProvider
{
	List<string> GetData()
	{
	//MS Sql Zeugs
	}
}

Clients die diesen Code nutzen möchten brauchen, ähnlich wie beim ersten HowTo um Schnittstellen, nur noch das Interface nutzen:

class ClientCode
{
	public IDataProvider provider;
}

Dadurch kann man theoretisch die Datenbank nun wechseln so oft man möchte - unser ClientCode benötigt keine Änderung.

Allerdings…

ist dieses Beispiel meiner Meinung nach sehr “dürftig”. Zwar kann man es daran sehr gut erklären, aber bei wie vielen Applikationen wird sowas überhaupt mit betrachtet? Bei vielen Projekten steht fest, welche DB genommen werden soll/genommen wird - die Datenbank wird sich sicherlich nicht ändern (und wenn doch, wird dies halt ein riesiger Change Request ).

Was viele nicht betrachten ist, dass durch den Einsatz von Interfaces auch die Testbarkeit einer Applikation steigert.

Beispielanwendung:

Unser “Data” gibt Daten an den Service, dieser verarbeitet diese und reicht die weiter (3-Tier). Wie hier zu sehen ist, gibt es nur die konkrete Klasse “PersonService” (unser Service) und “Person” (unser Model) - alles andere sind Schnittstellen:

public class PersonService : IPersonService
    {
        private IAuthenticationService authentication;
        private IPersonDataProvider personProvider;

        public PersonService(IAuthenticationService authSrv, IPersonDataProvider provider)
        {
            authentication = authSrv;
            personProvider = provider;
        }

        public List<Person> GetPersons()
        {
            if (authentication.IsAuthenticated())
            {
                return personProvider.GetPersons();
            }

            return null;
        }

        public void AddPerson(Person p)
        {
            if (authentication.IsAuthenticated())
            {
                personProvider.AddPerson(p);
            }
        }

    }

Unser Service kennt nur die Interface vom AuthenticationServie und vom DataProvider - diese werden im Konstruktor mit übergeben.
Anmerkung: Diese Form der Übergabe von den “Abhängigkeiten” ist dem Feld der “Dependency Injection” zuzuordnen und werde ich in einem anderen HowTo genauer definieren.

Unser Service kann die Daten nur ausgeben, wenn wir authentifiziert sind.

Szenario:

Wenn wir nun ein größeres Projekt angehen und der Authentifizierungsmechanismus nicht so einfach ist und auch Fremdsysteme mit einbezieht, dann wäre es ja nett, wenn man während der Entwicklung eine Art “Fake” aufsetzen kann. Durch die Interface ist es sehr einfach, sowas zu machen:

In meinem UnitTest Projekt will ich meinen Service testen - und nur diesen(!). dafür habe ich mit ein “TestPersonDataProvider” erstellt, der “IPersonDataProvider” implementiert und jeweils ein AuthenticationService, welcher mir sagt, dass ich authentifiziert bin, oder nicht.

Mein Testcode:

    [TestClass]
    public class PersonServiceUnitTest
    {
        [TestMethod]
        public void PersonService_ReturnPersons_Work_With_Authentication()
        {
            TestPersonDataProvider provider = new TestPersonDataProvider();
            PersonService srv = new PersonService(new TrueTestAuthenticationService(), provider);
            Assert.AreEqual(provider.InMemoryPersonCollection.Count, srv.GetPersons().Count);
        }

        [TestMethod]
        public void PersonService_Should_Return_Null_Without_Authentication()
        {
            TestPersonDataProvider provider = new TestPersonDataProvider();
            PersonService srv = new PersonService(new FalseTestAuthenticationService(), provider);
            Assert.IsNull(srv.GetPersons());
        }
    }

In meinem Testcode kann ich nun einfach die jeweiligen “Fakes” übergeben - ohne den Clientcode ändern zu müssen.

Fazit:

Durch den Einsatz von Interfaces kann man sehr erweiterbare Systeme machen - ein Beispiel ist z.B. das MVC Framework von Microsoft. Der Nebeneffekt ist natürlich auch, dass man die Datenquelle wechseln kann oder dass man einfache Fakes in den Tests, aber auch im Produktionscode verwenden kann (jedenfalls bevor auf “Release” gedrückt wird ;)).

Schnittstellen erlauben erweiterbare und testbare Software!

[ Download Democode ]

ShareThis

Über das Erscheinen des .Net Framework 3.5 SP1 haben ja bereits genügen Leute berichtet, da muss ich jetzt nicht noch einen draufsetzen. Wer möchte, kann sich den recht ausführlichen Blog-Beitrag von Dariusz anschauen.

Ich habe natürlich auch sofort das SP installiert. Die letzten 3 Std. habe ich damit zugebrach einen Fehler zu finden. Und was soll ich sagen, das Problem liegt am SP.

Folgende Situation. Ich arbeite an einem Projekt, das intensiv ASP.Net AJAX nutzt. Dort habe ich an verschiedenen Stellen die Übergabe von Daten aus dem CodeBehind an Javascript. Diese löse ich, indem ich im Code behind folgenden Code verwende:

ScriptManager scriptManager = ScriptManager.GetCurrent(Page);
scriptManager.RegisterDataItem(this, "StringToTransfer");

In Javascript kann ich dann auf diese Werte zugreifen:

function EndRequestHandler(sender,
args) { if (sender._dataItems != null)
{ if (sender._dataItems.__Page != null)
{ if (sender._dataItems.__Page == 'StringToTransfer')
{ fnShowSizedPopup('../../Web/Search/CopyProducts.aspx',
500, 400); } } } }

Das hat bisher problemlos funktioniert. Nach der Installation des SP1 war allerdings sender._dataItems immer null. Nachdem ich das SP1 deinstalliert habe, funktioniert es wieder wunderbar. Na ich werde jetzt wohl erst mal ohne SP1 leben und mir bei Gelegenheit mal anschauen, wie ich das Problem umgehe. Oder hat vielleicht jemand eine Idee, woran das liegen könnte?

Nachtrag:

Dank Hannes habe ich eine Lösung gefunden. Im obigen Beispiel muss man sender._dataItems mit args.get_dataItems() ersetzen, dann klappt's auch mit dem SP1

Was Microsoft hier so salopp als "Richer JavaScript support" bezeichnet, scheint die annähernd komplette Unterstützung von JavaScript im Visual Studio zu sein. Unter anderem gibt es jetzt eine Automatische Code Formatierung für JavaScript

Durch Zufall bin ich drauf gestoßen, als ich eben ein Semikolon am Ende eines unschön formatierten JavaScript Statements machte. Das Tastenkürzel [Strg][ K] + [Strg][ D] funktioniert ebenfalls um die ganze Datei zu formatieren.

Mehr über die Neuerungen durch das SP1 ist bei Scott Guthrie unter Visual Studio 2008 and .NET Framework 3.5 Service Pack 1 Beta zu lesen.

Seit gestern ist es verfügbar und überall ist die Meldung zu lesen: ServicePack1 für Visual Studio 2008 und .NET Framework 3.5 sind veröffentlicht. Unter anderem auch für die Express Edition. Also schnell mal das 877.8 MB große ISO-Image geladen, auf DVD gebrannt und die Installation gestartet. Als erstes habe ich den Visual Web Developer zur Installation ausgewählt, weil der SQL Server 2008 Express mit installiert werden kann. Also den SQL Server 2008 Express als optionale Komponente ausgewählt und die Installation gestartet. Die Aktualisierungen der CLR und des Visual WebDeveloper liefen sauber durch. Anschließend wurden noch die Aktualisierungen von Microsoft-Update geladen und installiert. Dann sollte nach einem Neustart die Installation des SQL Server 2008 Express beginnen. Also einem Neustart zugestimmt. Nach dem Neustart lief auch brav die Installation wieder an. Die Systemprüfung lief durch; und Peng! da war er. Der fette rote Punkt und die lapidare Meldung: SQL Server Installation fehlgeschlagen. Oops! Na gut dachte ich mir, das kann nach der Installation von C# 2008 Express noch genauer unter die Lupe genommen werden. Also Visual C# 2008 Express SP1 zur Installation ausgewählt. Erfreulicherweise war in der Auswahl der zu installierenden Komponenten wieder der SQL Server 2008 Express zu sehen, der ja seit Visual C# 2008 nicht mehr direkt unterstützt wurde. Statt dessen wurde einem der SQL Server Compact mehr oder weniger aufs Auge gedrückt. Also Installation gestartet und abwarten was passiert. Zunächst nichts besonderes. Die Installation der Komponenten lief sauber durch. Als der SQL Server 2008 Express wieder an der Reihe war das selbe Spiel wie vorher. Nur eine lapidare, nichts aussagende Fehlermeldung. Also begann ich die Log's zu durchsuchen. Irgendwo musste ja eine detaillierte, aussagekräftige Fehlerbeschreibung zu finden sein. Und tatsächlich. Im Verzeichnis C:\Program Files\Microsoft SQL Server\100\Setup Bootstrap\Log\VSExpress_9.0\ in der Datei Summary_HP-DV7_VSExpress_9.0.txt, HP-DV7 ist der Hostname meines Computers, wurde ich fündig. Hier die Fehlerbeschreibung:

Overall summary:
  Final result:                  Fehler: Ausführliche Informationen finden Sie unten
  Exit code (Decimal):           -2067922414
  Exit facility code:            1214
  Exit error code:               530
  Exit message:                  Die angegebene Editionsaktualisierung wird nicht unterstützt. Informationen über unterstützte Aktualisierungspfade finden Sie in der Onlinedokumentation in der Aktualisierungsmatrix für SQL Server 2008-Versionen und -Editionen.
  Start time:                    2008-08-12 14:52:49
  End time:                      2008-08-12 14:53:27
  Requested action:              Upgrade

Das soll also heißen: Da mit dem Express Setup nur der SQL Server 2008 Express verfügbar ist und ich die Version SQL Server 2005 Express with Advanced Features installiert habe kann kein Upgrade ausgeführt werden. Kein Problem. Also zu Microsoft auf die Seite des SQL Server Express um die passende Version herunter zu laden. Was lächelt mich da an? Wieder eine nette Meldung:

SQL Server 2008 Express will be available for download at the end of August 2008.

Until then, try the 180-day SQL Server 2008 Enterprise Evaluation.

Was soll man da sagen? Nichts und den SQL Server 2005 Express with advanced Features weiter verwenden.

P.S. Wer Sarkasmus findet, darf ihn behalten.

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:

• Visual Studio 2008 and .NET Framework 3.5
• .NET Framework 3.5 Enhancements

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.

ShareThis

Microsoft hat die Service Packs 1 (SP1) von .NET Framework 3.5 und Visual Studio 2008 zur Produktion freigegeben. Sie enthalten zahlreiche neue Funktionen, unter anderem für die Entwicklung von Windows- und Datenbank-Anwendungen auf aktuellen Microsoft-Plattformen. Zusätzlich erleichtern Neuerungen in ASP.NET die Erstellung dynamisch erzeugter Webseiten. Damit lassen sich einfacher branchenspezifische, individuell angepasste Applikationen für Unternehmen aller Branchen und Größen entwickeln. Viele der neuen Funktionen stehen auch für die kostenfreie Alternative 'Visual Studio 2008 Express' bereit. Alle Downloads übersichtlich zusammengefasst finden Sie im MSDN Download-Center. Mehr über die neuen Service Packs erfahren Sie hier.

Laut IEBlog soll noch im August die zweite Beta des Internet Explorers 8 erscheinen. Diese Beta ist öffentlich, das heißt,  jeder kann sich als Betatester bewerben. Bei der Entwicklung der  8. Version stand maximale Konformität mit Webstandards im Vordergrund. Was bedeutet das?
Mit dem IE8 sehen Webseiten teilweise "anders" aus als man es vom Firefox oder dem IE7 kennt. Anders bedeutet in diesem Fall, das Webseiten nicht immer so dargestellt werden, wie es sich der Webdesigner einst vorgestellt hat. Das standardkonforme Verhalten kann sogar so weit führen, dass Webseiten die für ältere Browserversionen optimiert wurden, nicht mehr funktionieren.
Microsoft nimmt also keine Rücksicht darauf, wenn mit dem IE8 in einem Internetshop keine Bestellvorgänge getätigt werden können  oder ob eine Firmenwebseite total verschoben und falsch dargestellt wird.
Ein gutes Beispiel für eine unbrauchbare Webseite, ist die Seite die-opelgalerie.de. Diese Webseite hatte ich vor ungefähr einem Jahr, mit allen, damals gängigen, Browsern erfolgreich  getestet.

Diese Seite ist mit dem IE8 nicht zu gebrauchen.

Jeder Webseitenbetreiber bzw.  Webmaster steht in der Verantwortung, seine Seite(n) mit den Beta Versionen des IE8 zu testen und ggf. nachzubessern.
Um seine Webseite mit der Beta 1 zu testen, ist es empfehlenswert das VPC Image von Microsoft herunter zu laden. Das Image beinhaltet ein Windows XP mit IE8 Beta1.

Was kann der Webmaster tun, wenn die Seite nicht ordnungsgemäß angezeigt wird?

Es gibt zwei Möglichkeiten:

1. Webserver konfigurieren
Hat man administrativen Zugriff auf den Webserver, kann man den HTTP Header "X-UA-Compatible: IE=EmulateIE7" für die Webseite hinzufügen. Damit wird sichergestellt, dass der Internet Explorer 8 automatisch umschaltet und die gesamte Seite wie im IE7 richtig darstellt.
Hier sind einige weiterführende Links zum Hinzufügen des HTTP Headers:

Eigene HTTP Response Header im IIS7
Das HTTP Headers Tab im IIS6

Apache Module mod_headers in der Version 2.2
Apache Module mod_headers in der Version 2.0
Apache Module mod_headers in der Version 1.3

2. Metatag hinzufügen
Oft hat man keinen Zugriff auf den Webserver oder möchte nur einzelne Seiten im IE7 Mode rendern lassen. In diesem Fall kann man das Umschalten auf den IE7 Mode durch ein Metatag erzwingen der in den Head-Bereich der Webseite eingebaut wird.
<meta http-equiv="X-UA-Compatible" content="IE=EmulateIE7" />

Was kann der Anwender tun, wenn er auf Seiten stößt, die im Internet Explorer 8 nicht richtig angezeigt werden?

Im IE8 befindet sich dazu ein Button "Emulate IE7" in der Menüleiste:

Sollte eine Webseite für eine ältere Browserversion optimiert worden sein und wird deshalb nicht richtig angezeigt, kann der Anwender die Renderengine mit einem Knopfdruck umstellen.

Wer sich in Sachen IE8 auf dem Laufenden halten möchte sollte den Blog vom IE-Team und von Daniel Melanchton verfolgen.

Microsoft hat Service Pack 1 für .NET Framework 3.5 und Service Pack 1 für Visual Studio 2008 veröffentlicht.

Ein kleiner Auszug aus den neuen Features und Verbesserungen in .NET Framework 3.5 Service Pack 1 lassen sich wie folgt auflisten:

• - ASP.NET Dynamic Data als umfangreiches Framework für die Entwicklung von datengestützten Applikationen ohne Code
• - ASP.NET AJAX bietet eine Ergänzung für die Verwaltung des Browser Verlaufs (Back-Button unterstützung)
• - Anwendungsstart wurde verbessert
• - Leistungsverbesserungen im Bereich Windows Presentation Foundation und das neue WebBrowser Steuerlement
• - Entity Framework mit Unterstützung der neuen SQL Server 2008-Typen
• - LINQ to SQL unterstützt die neuen Funktionen in SQL Server 2008 für Datum und Streams
• - .NET Data Provider für SQL Server 2008 (SqlClient) unterstützt die neuen SQL Server 2008 Funktionen

.NET Framework 3.5 Service Pack 1 findet ihr unter folgende URL:

Microsoft .NET Framework 3.5 Service Pack 1 (English)

Microsoft .NET Framework 3.5 Service Pack 1 (Deutsch)

Visual Studio 2008 Service Pack 1 findet ihr unter folgende URL:

Microsoft Visual Studio 2008 Service Pack 1 (exe) (English)

Microsoft Visual Studio 2008 Service Pack 1 (exe) (Deutsch)

Auf der Downloadseite findet ihr die folgende Meldung unter dem Abschnitt Wichtig:

Wenn Sie bereits einen Visual Studio 2008-Hotfix installiert haben, müssen Sie vor der Installation von Visual Studio 2008 SP1 das Dienstprogramm zur Hotfixentfernung ausführen. Weitere Informationen finden Sie unter Visual Studio 2008 Hotfix Cleanup Utility for Installing Visual Studio 2008 SP1.

Eine detailierte Information über die beiden Service Packs finder ihr unter:

Visual Studio 2008 Service Pack 1 and .NET Framework 3.5 Service Pack 1

Wie man im MSDN nachlesen kann, ist das Visual Studio Service Pack 1 und das .NET Framework 3.5 Service Pack 1 erschienen.

Juhu! Endlich weniger Abstürze beim WPF entwickeln ;)

Links:

• VS 2008 SP1 Online Installer
• .NET Framework 3.5 SP1 Online Installer
• Release Notes VS 2008 SP1
• Weitere Informationen zu den Service Packs

Wie man im MSDN nachlesen kann, ist das Visual Studio Service Pack 1 und das .NET Framework 3.5 Service Pack 1 erschienen.

Juhu! Endlich weniger Abstürze beim WPF entwickeln ;)

Links:

• VS 2008 SP1 Online Installer
• .NET Framework 3.5 SP1 Online Installer
• Release Notes VS 2008 SP1
• Weitere Informationen zu den Service Packs

Microsot hat über das Technet-Portal ein Dokument zum Thema Sicherheit für Office SharePoint Server 2007 - Security for Office SharePoint Server 2007 zur Verfügung gestellt.

Die Themen sind wie folgt:

• Plan site and content security
  • This guide describes the permissions that control access to your sites and the content in your sites. It also discusses security related to implementing Excel Services, search features, and Shared Services Providers (SSPs).
• Plan for authentication
  • This guide describes the authentication methods that are supported by Office SharePoint Server 2007, discusses the authentication configuration settings that need to be planned for individual Web applications, and includes sample configuration settings for several common forms authentication and Web single sign-on (SSO) authentication providers.
• Logical architecture design sample
  • This guide describes a secure logical architecture design that incorporates the most common types of sites and the most common classes of users. The design incorporates secure recommendations for authentication, SSPs, Internet Information Services (IIS) application pools, Web applications, zones, and zone policies.
• Deploying Office SharePoint Server 2007 in a secure manner
  • This guide describes practical secure configurations for specific server roles. The guidance for each server role includes recommended secure settings for the network, the operating system, and the applications that are installed, including IIS, the Microsoft.NET Framework, and Microsoft SQL Server database software.
  • Part 4 also addresses security requirements and recommendations for planning for security roles, for configuring administrative and service accounts, and for implementing SSO for access to external data systems.

Das Word-Dokument findet ihr unter folgende URL: Office SharePoint Server Security oder Downloadable book: Security for Office SharePoint Server 2007

Microsot hat über das Technet-Portal ein Dokument zum Thema Sicherheit für Windows SharePoint Services 3.0 - Security for Windows SharePoint Services 3.0 zur Verfügung gestellt.

Die Themen sind wie folgt:

• Plan site and content security
  • This guide describes the permissions that control access to your sites and the content in your sites. It also discusses security related to implementing search.
    
• Plan for authentication
  • This guide describes the authentication methods that are supported by Windows SharePoint Services 3.0, discusses the authentication configuration settings that need to be planned for individual Web applications, and includes sample configuration settings for several common forms authentication and Web single sign-on (SSO) authentication providers.
    
• Deploying Windows SharePoint Services 3.0 in a secure manner
  • This guide describes practical secure configurations for specific server roles. The guidance for each server role includes recommended secure settings for the network, the operating system, and the applications that are installed, including Internet Information Services (IIS), the Microsoft.NET Framework, and Microsoft SQL Server database software. Part 3 also addresses security requirements and recommendations for planning for security roles and for configuring administrative and service accounts.

Das Word-Dokument findet ihr unter folgende URL: Windows SharePoint Services Security oder Downloadable book: Security for Windows SharePoint Services 3.0

Wie man im MSDN nachlesen kann, ist das Visual Studio Service Pack 1 und das .NET Framework 3.5 Service Pack 1 erschienen.

Juhu! Endlich weniger Abstürze beim WPF entwickeln ;)

Links:

• VS 2008 SP1 Online Installer
• .NET Framework 3.5 SP1 Online Installer
• Release Notes VS 2008 SP1
• Weitere Informationen zu den Service Packs

Die .NET Bibliothek SpeedFanConnector, die ich in diesem Artikel vorgestellt habe, liegt in einer überarbeiteten Version vor. Nachdem Jan Welker aus dem .NET Forum.de so freundlich war mir beim testen zu helfen, stießen wir auf diverse Probleme unter Vista 64. Das ging soweit, dass zum Teil komplett falsche Werte aus dem Shared Memory Segment geliefert wurden. Ein Fehler beim Marshalling konnte weitestgehend ausgeschlossen werden, da andere Werte aus dem Shared Memory Segment bei ein und dem selben Marshalling korrekt sind und am richtigen Index vorliegen. Ob das Problem während des Schreibens des Segments von SpeedFan in den Speicher auftritt oder eine Änderung der Struktur von SpeedFan vorliegt konnte noch nicht geklärt werden. Um hier jetzt eine definitive Aussagen zu treffen, liegen im Moment einfach zu wenige Informationen vor.

Um die Problematik unter 64bit Systemen vom Benutzer fern zu halten, wird jetzt jeder Wert aus dem Shared Memory Segment auf seinen korrekten Größe geprüft und gegebenenfalls korrigiert. Dabei muss ich sagen, dass die fehlerhaften Werte nicht die Messwerte der Sensoren betreffen, sondern meist die Anzahl der vorhandenen Sensoren falsch zurückgegeben wird. Da per Definition der SpeedFan Struktur maximal 32 Werte pro Sensor, also z.B. maximal 32 Ventilatoren-Werte, zurückgegeben werden, darf der Wert aus dem Shared Memory Segment 32 nicht überschreiten. Sollte dies doch der Fall sein, wird der Wert auf 32 begrenzt.

Da wie bereits erwähnt diese Problematik bis jetzt ausschließlich auf 64bit Systemen aufgetreten ist, dürfte die Anzahl der betroffenen Benutzer deutlich kleiner sein als die der nicht betroffenen.

Des weiteren wurde eine neue Überladung des Konstruktors hinzugefügt mit der festgelegt werden kann, dass nur Werte größer 0 (Zero) in den öffentlichen Eigenschaften erscheinen. Kann für jene ganz nützlich sein auf deren Maschinen SpeedFan zwar Sensoren erkennt, diese Sensoren aber keine Werte liefern.

Falls bereits jemand die vorherige Version heruntergeladen hat, sollte er diese durch die aktuelle Version 0.3.5.142 ersetzen.

Da ich nur über begrenzte Ressourcen zum testen verfüge, unter anderem kein 64bit System, bin ich auf Feedback und Kritik angewiesen.

SpeedFanConnector

Seit einigen Wochen gab es im dotnet-forum.de tägliche mehrere Anmeldungen mit merkwürdigen Benutzernamen. Die Emailadressen dieser User endeten mit .ru oder .in.
Rainer hatte mich auf die  Internet Spam Datenbank Stop Forum Spam aufmerksam gemacht, in der solche Spam User gesammelt werden. Darauf hin habe ich mir diese Webseite einmal genauer angesehen. Mir war aufgefallen, dass es dort eine einfache API gab, mit der die Emailadressen kontrolliert werden können. Für einige PHP Foren gab es schon passende Erweiterungen um Spam User zu identifizieren. Thomas Freudenberg und ich, haben kurzerhand eine Erweiterung für den CommunityServer 2007 geschrieben, welche im Abstand von 15 Minuten alle neuangemeldeten User mit Hilfe dieser API kontrolliert.
Wurde ein User als Span User identifiziert, wird er verbannt. Das bedeutet, der User existiert weiterhin im Forum, jedoch kann er sich nicht mehr anmelden und somit keinen Schaden anrichten.
Im Event log des Forums kann man gut beobachten, wann sich der User registriert hat und wann er verbannt wurde:

Wer das Modul im CommunityServer nutzen möchte, kann es sich kostenlos herunterladen. Die Installation ist sehr einfach. Es müssen nur 2 config Dateien editiert und eine DLL kopiert werden. Eine Installationsanleitung ist im Download enthalten.

Download Stop Forum Spam Modul für CommunityServer 2007

Wer regelmäßig .NET Blogs liest – insbesondere englischsprachige .NET Blogs – wird in letzter Zeit früher oder später auf den Begriff ALT.NET gestossen sein. Mir ist der Begriff jedenfalls in den letzten Monaten immer häufiger begegnet, und irgendwann habe ich dann angefangen, mich näher mit dem Thema zu beschäftigen.

Was ist denn nun ALT.NET? Faul wie ich bin kopiere ich einfach Mal die Erklärung dazu von der deutschen ALT.NET Community altdotnet.de:

Klingt zunächst einmal sinnvoll und interessant. Allerdings gibt es auch einige kritische Meinungen dazu (einige sind auf der englischsprachigen ALT.NET Seite verlinkt). So wirken z.B. einige der aktiveren ALT.NET Community-Mitglieder auf andere Blogger elitär und arrogant, und teilweise wird ALT.NET als Anti-Microsoft Bewegung gesehen, die alles ablehnt, was von Microsoft kommt, egal ob die alternativen Lösungen nun tatsächlich besser sind oder nicht. Insbesondere in englischsprachigen Blogs sind mir einige Blogbeiträge begegnet, die in diese Richtung gehen (tatsächlich war einer dieser Beiträge sogar mein erster Kontakt mit ALT.NET). In der deutschen Community habe ich zumindest bisher noch nichts negatives darüber gelesen.

Prinzipiell finde ich es gut, sich mit alternativen Tools zu beschäftigen. Nach neuen und besseren Lösungen suche ich sowieso ständig. Für mich persönlich heisst das aber nicht, dass ich unbedingt gleich für alles Alternativen zum “Mainstream von Microsoft” suchen muss. Auch wenn es für manche Bereiche gute Alternativen gibt (z.B. NHibernate als Alternative zu LINQ to SQL) entscheide ich mich trotzdem oft für die Microsoft Lösung.

Ich bin freiberuflicher Trainer und Entwickler. Als Trainer muss ich mich mit den Technologien auskennen, die am meisten nachgefragt werden. Bisher hatte ich noch keine einzige Anfrage zu NHibernate, Castle Windsor, Monorails oder irgendwelchen anderen Alternativen Technologien, aber zu den “Mainstream” Technologien von Microsoft bekomme ich mehr Anfragen als ich annehmen kann. Würde ich anfangen, alle Mainstream Technologien durch ihre “ALT.NET Alternativen” zu ersetzen, dann könnte ich solche Anfragen bald nicht mehr annehmen, weil mir dann die praktische Erfahrung mit den Mainstream Produkten fehlen würde. Als Entwickler habe ich das Problem, das ich quasi für jedes Projekt in eine neue Firma komme und mit neuen Leuten zusammenarbeite, und dann mit den Technologien arbeiten muss, die beim jeweiligen Kunden eingesetzt werden – und das sind nun mal in der Regel die “Mainstream Technologien” von Microsoft. Ausnahmen gibt es da höchstens beim Team Foundation Server – der ist gerade für kleinere Firmen einfach oft zu teuer, so dass dann Alternativen wie Subversion, Cruisecontrol.NET usw. eingesetzt werden.

Bin ich also nun ein “ALT.NETter” oder eher ein “Mainstream” Entwickler? Ich setzte zwar hauptsächlich Tools von Microsoft ein, aber wenn man sich die ALT.NET Definition oben mal genauer anschaut steht dort nirgendwo, dass das ein Widerspruch sein muss. Unter den für mich gegebenen Rahmenbedingungen setze ich die Tools ein, die für mich am besten geeignet sind. Das sind nun mal in meinem Fall sehr oft – aber nicht immer – die Microsoft Tools. Teilweise sind es aber auch “ALT.NET Tools”, z.B. xUnity und RhinoMocks. Insofern würde ich mich weder als “typischen ALT.NET Entwickler” noch als “typischen Microsoft Mainstream Entwickler” sehen.

Im Oktober findet übrigens die erste deutsprachige ALT.NET Konferenz statt: http://netopenspace.de. Wenn nichts dazwischen kommt werde ich auf jeden Fall daran teilnehmen, das wird sicher eine spannende Abwechslung zu den klassischen Konferenzen.

Mit Windows Vista hielt auch das IP-Protokoll in der Version 6 Einzug in die heimischen Netzwerke. Während unter Windows XP das TCP/IP Protokoll in der Version 6 erst zusätzlich installiert werden muss, verwendet Windows Vista standardmäßig beide Protokolle und bindet sie an die verfügbaren Netzwerkadapter. Nicht weiter schlimm, sollte man meinen. Es können dabei aber auch nette Seiteneffekte auftreten. Auf einen dieser Seiteneffekte hat mich Windows Live OneCare bei der wöchentlichen Sicherung aufmerksam gemacht als plötzlich ein PC aus der OneCare-Gruppe meldete, die Firewall des PC's an dem das zentrale Speichergerät angeschlossen ist befindet sich in einer öffentlichen Zone. Oops! Ein Blick in das Netzwerk und Freigabecenter bestätigte dies. Wie man in folgendem Screenshot wunderschön sehen kann, gab es da tatsächlich ein nicht identifiziertes öffentliches Netzwerk.

Nach einem Blick in die Eigenschaften des Netzwerkadapters war schnell klar woher dieses Netzwerk kam.

Da das IP-Protokoll in der Version 6 zusätzlich zum IP-Protokoll der Version 4 an den Netzwerkadapter gebunden war, wurde auch eine zweite Verbindung zum WLAN-Accesspoint aufgebaut. Doch da mein Accesspoint nur das IP-Protokoll in der Version 4 unterstützt, konnte die Netzwerkkennung nicht ermittelt werden und Vista ordnete diese Verbindung einem öffentlichen Netzwerk zu. In einem öffentlichen Netzwerk werden standardmäßig die Freigabe von Dateien unterbunden und somit konnte OneCare nicht auf das zentrale Speichergerät zugreifen. Diese Verhalten ist ja eigentlich richtig, doch für meinen Verwendungszweck nicht erwünscht. Also was tun? Hier stehen zwei Möglichkeiten zur Auswahl. Als erste Alternative könnte der Standort in den Netzwerkeinstellungen für dieses Netzwerk von öffentlich auf privat geändert werden damit die Netzfreigaben aktiviert werden. Die zweite Möglichkeit währe das deaktivieren des IP V6 Protokolls in den Eigenschaften des Netzwerkadapters. Da in meinem Netz alles vor und hinter dem Accesspoint noch auf dem IP V4 Protokoll beruht kam für mich nur die zweite Lösung in Betracht. Nach dem deaktivieren des IP V6 Protokolls und dem damit verbundenen De- und Reaktivieren des Netzwerkadapters war im Netzwerk- und Freigabecenter auch das öffentliche Netzwerk verschwunden.

Wenn also jemand irgend ein merkwürdiges Verhalten oder plötzlich seltsame Geister-Netzwerke auftauchen, sollte er zuerst die TCP/IP-Protokolle in den Eigenschaften seines Netzwerkadapters überprüfen und für sich entscheiden ob er das IP V6 Protokoll wirklich benötigt. In Zukunft werden wir alle sicher auf IPv6 umstellen. Doch im Moment, da noch mehr Geräte mit IPv4- als mit IPv6-Adaptern in Gebrauch sind, kann es das Leben nur unnötig schwer machen.

Jetzt ist es raus. Unsere Give Aways für die XTOPIA 08 stehen fest.

Jeder zahlende Teilnehmer der Xtopia 08 erhält auch dieses Jahr ein wertvolles Give-Away-Paket:

• Eine Vollversion von ComponentOne Studio for Silverlight inkl. 6-monatiger Subscription
• Eine Trainings-DVD: Anwendungsentwicklung für Silverlight 2 – Verstehen, Verwenden, Programmieren und Gestalten
• Ein thematisch passendes Buch von Microsoft Press Deutschland zur Auswahl
• Einen Rabatt beim Kauf einer Expression Professional Subscription

... ist  nicht gerade einfach, besonders deshalb weil man quasi sein ganzes Leben lang dafür trainieren müsste.

Aber dankt Popfly und Silverlight kann sich jeder mit seinen Freunden in einigen olympischen Disziplinen messen.

Try to light all 14 torches by clicking on them!  Watch out, they’re fast!

To Play:

http://popfly.com/users/team/light%20the%20torches

To Embed:

<iframe style='width:500px; height:375px;' src='http://www.popfly.com/users/team/Light%20the%20Torches.small' frameborder='no' allowtransparency='true'></iframe>

GOOAAAL!!!

Pick countries to go head-to-head in this game of Foosball Soccer!

To Play:

http://popfly.com/users/team/soccer

To Embed:

<iframe style='width:500px; height:375px;' src='http://www.popfly.com/users/team/Soccer.small' frameborder='no' allowtransparency='true'></iframe>

Ready… Set… Go!  It’s the 100-meter dash, pick your country and hurdle across the Finish Line to Victory!

To Play:

http://popfly.com/users/team/track%20and%20field

To Embed:

<iframe style='width:500px; height:375px;' src='http://www.popfly.com/users/team/Track%20and%20Field.small' frameborder='no' allowtransparency='true'></iframe>

Pick your targets carefully, aim, and fire your arrows in this addicting game of Archery!

To Play:

http://popfly.com/users/team/archery

To Embed:

<iframe style='width:500px; height:375px;' src='http://www.popfly.com/users/team/Archery.small' frameborder='no' allowtransparency='true'></iframe>

Help Rocket Chicken score his longest Long Jump and win a Gold Medal!

To Play:

http://popfly.com/users/team/long%20jump

To Embed:

<iframe style='width:500px; height:375px;' src='http://www.popfly.com/users/team/Long%20Jump.small' frameborder='no' allowtransparency='true'></iframe>

Test your ‘Strength’ by keeping the barbell off the floor and trying not to turn red in the face!

To Play:

http://popfly.com/users/team/weightlifting

To Embed:

<iframe style='width:500px; height:375px;' src='http://www.popfly.com/users/team/Weightlifting.small' frameborder='no' allowtransparency='true'></iframe>

Forget Tyson vs. Holyfield, this is the real Boxing match of the century: my Xbox versus your Playstation.  It’s Battle of the Game Consoles!

To Play:

http://popfly.com/users/team/boxing

To Embed:

<iframe style='width:500px; height:375px;' src='http://www.popfly.com/users/team/Boxing.small' frameborder='no' allowtransparency='true'></iframe>

Spin, jump and twirl through the air without ever leaving your chair!

To Play:

http://www.popfly.com/users/Team/Gymnastics

To Embed:

<iframe style='width:500px; height:375px;' src='http://www.popfly.com/users/Team/Gymnastics.small' frameborder='no' allowtransparency='true'></iframe>

Dive through the water and hit the target – harder than it looks!

To Play:

http://www.popfly.com/users/Team/Diving

To Embed:

<iframe style='width:500px; height:375px;' src='http://www.popfly.com/users/Team/Diving.small' frameborder='no' allowtransparency='true'></iframe>

Mirror your teammates movements with this synchronized swimming game!

To Play:

http://www.popfly.com/users/Team/Synchronized%20Swimming

To Embed:

<iframe style='width:500px; height:375px;' src='http://www.popfly.com/users/Team/Synchronized%20Swimming.small' frameborder='no' allowtransparency='true'></iframe>

Seit gestern sind die XXIX. Olympischen Spiele in Peking eröffnet. Microsoft und NBC Sports haben sich zusammengetan um eine bisher nie dagewesene Übertragung eines solchen Events im Internet zu produzieren.

NBC und Microsoft werden 3500 Stunden der Olympischen Spiele Millionen von Zuschauern im Internet präsentieren.

Das gesamte Erlebnis basiert auf Silverlight und einer Streaming-Infrastruktur die darauf ausgelegt ist 2,3 Terabytes/Sekunde an Übertragungstraffic zu liefern.

Mehr Informationen gibt es hier: http://www.nbcolympics.com/video

Was interessiert mich als Entwickler wirklich, wenn ich testen will? Als blutiger Anfänger stehst du erst einmal da. Du hörst die ganze Zeit TDD... zuerst Tests erstellen ... dann programmieren... aber so wirklich weißt du gar nicht, wo du anfangen sollst.

Für mich hatten sich damals am Anfang folgende Fragen gestellt. Ich weiß also das ich Testen muss aber:

• wie fange ich an?
• wie benenne ich meinen Test sinnvoll?
• was kommt denn überhaupt in den Test rein?
• wie viel darf ich Testen?

Schnell hatte ich mitbekommen, dass Tests klein gehalten werden sollen. Dazu bedarf es keiner großen Nachforschung. Spätestens nach dem 10 Testlauf schreibst du kleine Test, wenn der Durchlauf Ewigkeiten dauert. Aber mir war noch immer nicht klar, wie meine genannten Fragen richtig beantwortet werden können.

Vor einiger Zeit bin ich über einen Artikel von Dan North über BDD (Behaviour Driven Design) gestoßen, den ich aber zu diesem Zeitpunkt nicht so wirklich wahr genommen habe, zumal ich nicht wusste, was er denn mit Behaviour meint. In der ALTNETDE Usergroup bin ich heute nun wieder über das Thema gestolpert und habe mich prompt an diesen Artikel erinnern müssen. Also gleich darauf hin in die Vollen ... ich habe ihn nochmal durchgelesen. Und er erfüllt genau den Zweck, den ein Neuling wissen sollte, wenn er mit UnitTesting anfängt. Alle mir noch offenen Fragen haben sich damit beantwortet.

Dazu gibt es folgendes Entwurfsmuster, dass einem sagt, wie der Test aufgebaut wird:

Gegeben sei ein bestimmter Kontext
Wenn ein bestimmtes Ereigniss auftritt,
Soll ein bestimmtes Ergebniss sichergestellt werden.

Wer sich an dieses Muster hältt, wird feststellen, wie leicht Testing sein kann. Und in diesem Zuge können wir uns gleich von der Bezeichnung Test verabschieden. Viele sehen das als Hürde und Hinderniss an, solche Tests zu etablieren. Immer wieder gern gehörte Kommentare sind:

• Ein Test ändert sich, wenn wir neue Funktionen hinzufügen.
• Wenn sich der Code ändert, müssen wir den Test ändern
• das kann dann wieder Fehler produzieren
• wir müssen noch mehr Bugfixen

Also ihr seht schon, wo das hinführt? Aber wenn wir nun von Spezifikationen sprechen, dann hört sich das doch gleich anders an. Und vor allem, wenn wir von dokumentierenden Spezifikationen sprechen. Es wird nicht nur getestet. Es wird auch dokumentiert. Und wenn sich ein "Behaviour" (Verhalten) ändert, und nicht mehr in der Spezifikation enthalten ist... ja was dann? Dann streichen wir das Verhalten einfach raus. Wer von euch würde auf die Idee kommen, einen UnitTest einfach so riguros zu löschen? Mal ganz ehrlich!

Also lautet mein Credo: Vom klassischen UnitTesting verabschieden. Hin zu "Behaviours".

Das Microsoft Research Team rund um Pex hat eine neue Version von Pex released wie Nikolai Tillmann in seinem Blog berichtet.

• 64 Bit Unterstützung
  Pex kann auf einem 64 bit System installiert werden, läuft aber nur im 32bit Modus.
• UI Änderungen
• Neue Funktionen
  Code-Update Preview Dialog.
  Quick-Actions: Debug, Send To... Mail, Text-file, Clipboard.
• Fehler korrigiert
• Weitere änderungen:
• Die Qualität des generierten Codes
• Bessere/schönere Methoden Namen
• Bessere/schönere Namen für Lokals
• WPF Problem: API restriction: '...WindowsBase.dll' has already loaded from a different location Pex may break your WPF applications. Bei Problemen soll Pex deinstalliert werden. Das Team arbeitet an einem Workaround.

Hier gehts jeweils zu den Seiten.

• Download
• Release Notes

Der neue Podcast von Scott Hanselman dreht sich diesmal um Barrierefreiheit in Web und Rich Application.
Als Gast hat Scott Saqib Sheikh, ein Entwickler von Microsoft Consulting Services UK geladen, welcher blind ist. Er spricht über seine Erfahrungen als Blinder mit dem Web und aus einer Entwicklersicht. Allerdings muss ich zugeben, dass ich mir nicht ganz vorstellen kann, wie ein Blinder mit Visual Studio zurechtkommen kann - daher habe ich etwas weiter rumgeforscht und geschaut, was dieses “Jaws” ist (wird im Podcast mehrmals erwähnt).
Daraufhin hab ich auch den “Blind Geek Zone” Blog gefunden.

Microsoft hat auch für Entwickler entsprechende Informationen parat, wie man seine Anwendungen Barrierefrei gestalten kann - im Podcast werden verschiedene Techniken erwähnt.

Wer sich von diesen Screenreader mal ein Bild machen möchte, sollte mal bei YouTube nach “Screenreader” oder “Jaws” etc. suchen.
Manche Designentscheidungen treffen Sehbehinderte Menschen besonders hart, z.B. der Einsatz von Captchas.

Wer sich ebenfalls für das Thema interessiert, sollte sich den Podcast von Scott Hanselman anhören.

ShareThis

In letzter Zeit kommt es immer häufiger vor, dass ich nicht schlafen kann, weil es zu warm ist. Programmieren ist nicht mehr drinnen. Dafür bin ich nicht mehr auf der Höhe. Aber zum Lesen bleibt allemal noch Energie.

Ich beschäftige mich ja nun seit einiger Zeit neben meinem immer wieder aktuellen Thema Dokumentation mit weiterführenden Techniken und Tools rund um die Komponentenorientierung, als da wären UnitTesting, TypeMocking und Container-Frameworks ala Windsor, Unity, Autofac etc. (siehe vorherige Posts).

Ein Kritikpunkt auf den ich auch unter Kollegen und Skeptikern dabei immer wieder stoße ist die Frage bzw. Aussage: Das dauert doch viel zu lang, das ist unperformant... Reflection dauert doch zu lange. Was die guten Herren dabei vergessen, ist die Tatsache, dass alle Produktiven Container (also die sich als solche bezeichnen) mit hoch optimierten Techniken IL direkt erzeugen. Nun was soll ich dazu sagen, es ist einfach nur schnell, auch wenn sich mal ein-, zweihundert Komponenten in dem Framework tummeln.

Ich habe über das ServiceLocator und Dependency Injection Framework einen schönen Artikel gelesen, der meine bisherigen Erfahrungen und Vermutung bestärkt. Ganz unten in den Kommentaren ist von Oren Eini - oder besser bekannt als Ayende Rahien - folgendes Zitat zu lesen:

1. An object’s consumer shouldn’t need to know that X That is right, this is why you use an IoC.The one place that needs to know about the container is the infrastructure, everything else is constructed by the container.

2. When using property injection you generally need to mark your dependencies as public Use ctor injection, that is the preferred mode.

3. Reflection: all IoC containers use a heavily optimized approaches, down to generating IL at runtime. I have not seen production ready container that had perf problems because of that.

4/ Large object chains create lot of objects. Who _cares_ ? It takes 0.00000006 ms to create an object in .NET. This is absolutely insignificant number.

Die signifikante Stelle habe ich hier mal fett markiert. Also soll uns das wirklich stören? Und Oren ist jetzt nicht gerade jemand, von dem man behaupten könne, er kennt sich auf dem Gebiet nicht aus.

Das Material zu meinem gestrigen Vortrag "Visual Studio nutzen, anpassen und erweitern" bei der .NET Developer-Group Ulm steht nun zum Download bereit:

• Folien (PPTX)
• Folien (PPT)
• Beispiele

Live Mesh, welches momentan nur eine Tech Preview ist und noch nicht allen verfügbar ist, ist Microsoft neuste “Live” Entwicklung. Ich hab bereits einmal über die evtl. APIs geschrieben - für uns Entwickler ist also auch was dabei :). Hier kann man sich auch Bewerben um an das SDK ranzukommen - mal sehn ob ich Glück hab
Ein Video über die Möglichkeiten befindet sich hier.

Was ist Live Mesh?

Wie bereits auf der Startseite geschrieben geht es im Prinzip darum, seine Daten überall synchronisiert und jederzeit abrufbereit zu haben. Dazu baut man sich ein sogenanntes “Mesh” (Netz) :

In diesem “Mesh” kann man nun seine PCs, Macs, Handies etc. einbinden und diese entsprechend synchronisieren lassen. Die Anmeldung erfolgt mit einer Windows Live ID.

Dabei kann man genau bestimmen, welches Gerät mit welchem anderen Gerät synchronisiert werden soll und natürlich kann man sein “Mesh” auch mit anderen teilen. Auf diesen Gedanken komme ich später bei einer kritischen Hinterfragung nochmal zurück.

Wie sieht Live Mesh aus?

Damit sich jeder was drunter vorstellen kann, möchte ich mal ein paar Screenshots präsentieren:

Das Management erfolgt über die mesh.com Website:

Wobei man sich zu jedem einzelnen Device connecten kann.

Der “Live Desktop” ist die Online Ausgabe dieses Dienstes, gehostet bei Microsoft (momentan ist die Grenze bei 5GB). Dabei wurde so ziemlich der Windows Desktop nachgebildet:

Rechts sieht man die “News”, d.h. alles was hinzugefügt wurde oder was sich verändert hat:

Wenn man auf einen solchen “Mesh Folder” klickt, sieht man eine Art Windows Explorer:

In diesem “Explorer” kann man Files hochladen, ändern, anschauen, löschen usw.

Wobei man bei “Media View” eine momentan recht einfach gestrickte Silverlight-Applikation vorfindet, die ähnlich wie beim Media Player die Bilder anzeigt oder Musik/Videos abspielt:

Auf der rechten Seite kann man in dem Menü die Synchronisierungsoptionen ändern (Synchronisier dich nur mit Device XYZ) oder auch andere Leute einladen:

Das wäre es erstmal im großen und ganzen von der Website. Für Vista/XP gibt es natürlich noch eine Desktopversion - für Handy und Mac soll sowas auch noch folgen.

Zu der Desktopversion:

Diese sieht eigentlich genauso aus, wie die Web-Version:

Durch den Client kann man nun auch sehr einfach andere Ordner zu “Mesh Folders” hinzufügen:

Wenn man nun in diesen Ordner wechselt, bekommt man wieder ein Zusatzmenü angezeigt wie auf der Website:

Sobald der Client merkt, dass in den “Mesh” Ordnern was geändert hat, startet er automatisch den Upload:

Wobei dieser relativ clever ist: Wenn Bilder in den Ordnern verschiebt, dann muss er nicht sofort alle Bilder neu hochladen, sondern schickt die neue Struktur hoch - was bereits oben ist, muss nicht nochmal hochgeladen werden. Jedenfalls hatte ich dies bei meinem Test so beobachtet

Weiteres Feature: Remote Desktop

Wenn ein PC im Mesh aktiviert und angemeldet ist, dann kann man sich auch von jeder beliebigen Stelle (auch im Browser) auf den PC per Remote Desktop verbinden. Das klappt allerdings nur im Internet Explorer und ist irgendein finsteres ActiveX Control - aber die Idee ist nett

Die “kritische Frage”: Ist es nur eine gigantische Filesharing Plattform?

Nüchtern betrachtet ist es momentan nur eine Plattform um Dateien zu synchronisieren - mehr nicht. Im Prinzip eine Art Emule - nur vom Microsoft. Ich könnte mir vorstellen, dass man hierbei einige nicht ganz legale Sachen machen könnte - und das gehostet von Microsoft.
Allerdings ist das sicherlich nur der erste Schritt - wer weiß wie man da noch Applikationen etc. einbinden kann.

Ich bin gespannt und finde es schon recht gelungen

ShareThis

Gerade gefunden: Stefan Dobrev hat ein AddIn erstellt mit dem Blend Intellisense bekommt. Yeah das Rockt! :) Dieses Feature vermisst wohl jeder Entwickler der ernsthaft mit Blend arbeitet.

Das AddIn ist mit Sourcecode in codeplex gehostet. Der Projektname lautet: Kaxaml

Hier geht es zu weiteren Infos: http://blogs.telerik.com/StefanDobrev/Posts/08-08-04/IntelliSense_for_Expression_Blend.aspx

Ich bin gespannt in welcher Version Microsoft Intellisense in Blend einbaut, in der aktuellen Version (Blend 2.5 CTP) ist das Feature noch nicht enthalten

Gerade gefunden: Stefan Dobrev hat ein AddIn erstellt mit dem Blend Intellisense bekommt. Yeah das Rockt! :) Dieses Feature vermisst wohl jeder Entwickler der ernsthaft mit Blend arbeitet.

Das AddIn ist mit Sourcecode in codeplex gehostet. Der Projektname lautet: Kaxaml

Hier geht es zu weiteren Infos: http://blogs.telerik.com/StefanDobrev/Posts/08-08-04/IntelliSense_for_Expression_Blend.aspx

Ich bin gespannt in welcher Version Microsoft Intellisense in Blend einbaut, in der aktuellen Version (Blend 2.5 CTP) ist das Feature noch nicht enthalten

Gerade gefunden: Stefan Dobrev hat ein AddIn erstellt mit dem Blend Intellisense bekommt. Yeah das Rockt! :) Dieses Feature vermisst wohl jeder Entwickler der ernsthaft mit Blend arbeitet.

Das AddIn ist mit Sourcecode in codeplex gehostet. Der Projektname lautet: Kaxaml

Hier geht es zu weiteren Infos: http://blogs.telerik.com/StefanDobrev/Posts/08-08-04/IntelliSense_for_Expression_Blend.aspx

Ich bin gespannt in welcher Version Microsoft Intellisense in Blend einbaut, in der aktuellen Version (Blend 2.5 CTP) ist das Feature noch nicht enthalten

Die vorherigen Artikel über Shared Memory in verwaltetem Code waren alle sehr abstrakt gehalten um mit jedem möglichen .NET Objekt umgehen zu können. Heute will ich eine praktische Anwendung zeigen die genau diese Technologie, aber weniger abstrakt, nutzt. Manche unter euch kennen und nutzen SpeedFan zum überwachen der diversen Sensoren des jeweiligen Computers. Wie ich schon in einem der früheren Artikel über shared Memory erwähnt habe, wird in der nicht verwalteten Welt reger Gebrauch von gemeinsam genutzten Speicher gemacht. SpeedFan stellt eben so ein Segment mit den relevanten Daten zur Verfügung. Das wirklich schwierige am verarbeiten eines solchen shared Memory Segment ist eine verlässliche Dokumentation in welcher Form die Daten im shared Memory Segment denn vorliegen. Im Falle von SpeedFan wird eine Strukture, bestehend aus verschiedenen unsigned short int Werten sowie einigen signed int[32] Arrays verwendet. In diesem Forenpost wird die Nutzung dieser Struktur diskutiert. Hier das Listing der von SpeedFan verwendeten Struktur:

/////////////////////////////////////////////////
/// SpeedFan specific declarations
/// Thanks to : Alfredo Milani Comparetti
// Shared memory name and handles
TCHAR szName[]=TEXT("SFSharedMemory_ALM");
HANDLE hMapFile;
LPCTSTR pBuf;
bool isOk = false;
// Strucure of the shared block
#pragma pack(push, 1)
typedef struct TSharedMem_
{
unsigned short int version;
unsigned short int flags;
signed int MemSize;
HANDLE handle;
unsigned short int NumTemps;
unsigned short int NumFans;
unsigned short int NumVolts;
signed int temps[32];
signed int fans[32];
signed int volts[32];
}TSharedMem;
#pragma pack(pop)

Wie immer liegt hier der Teufel im Detail. Sehr wichtig, und bestimmt gerne überlesen, ist die Anweisung: #pragma pack(push, 1). Wer sie gleich von Anfang an beachtet, erspart sich fiel Ärger. Doch dazu später mehr. Als erstes wird die C++ Struktur in verwaltetem Code nachgebildet. Hier vorab das Listing der Struktur:

[StructLayout(LayoutKind.Sequential, Pack = 1)]
internal struct SFData
{
    public ushort version;
    public ushort flags;
    public int memSize;
    public IntPtr handle;
    public ushort numTemps;
    public ushort numFans;
    public ushort numVolts;

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
    public int[] temps;

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
    public int[] fans;

    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 32)]
    public int[] volts;
}

Wie im obigen Listing zu sehen ist, wird im StructLayoutAttribute das Feld Pack mit dem Wert 1 verwendet um die gleiche Komprimierung und Ausrichtung im Speicher zu verwenden mit der die Struktur von SpeedFan erstellt wurde. Ohne diese Compileranweisung im C++ Code würde z.B. der VC++ Compiler standardmäßig den Wert 8 verwenden. Wenn diese Information fehlt, würden die Werte nach dem Marshalling in der verwalteten Struktur nicht den Werten entsprechen die ursprünglich in die C++ Struktur geschrieben wurden. Umständliche Umrechnungen oder gar falsche Daten währen die Folge. Zu beachten ist unbedingt auch die Länge der Integer Arrays aus der C++ Struktur. Beim Marshalling der Arrays muss unbedingt das Feld SizeConst mit dem Wert aus der C++ Struktur, in diesem Fall 32, belegt werden. Wie schon eingangs erwähnt, eine verlässliche und vollständige Dokumentation ist meist das schwierigste beim verarbeiten von fremd generierten Daten. Nachdem die Struktur erstellt wurde, kann das lesen aus dem shared Memory Segment in die erzeugte Struktur beginnen. Das ist dieses mal wesentlich einfacher, schon fast trivial, als bei den abstrakten shared Memory Operationen. Da aus der Dokumentation der Namen des shared Memory Segment bekannt ist, kann einfach mit OpenFileMapping ein Handle zum benannten FileMapping Objekt erzeugt werden. Mit diesem Handle wird mittels MapViewOfFile ein Zeiger auf das shared Memory Segment erzeugt. Da die Struktur im Speicher bekannt ist und auch ein Zeiger auf diese vorliegt, kann nun einfach mit der Marshal.PtrToStructure-Methode der Speicherinhalt in die Struktur kopiert werden. Hier die Umsetzung in Code:

public SFData GetData()
{
    if (this.sharedMemoryPointer == IntPtr.Zero)
    {
        throw new SharedMemoryException(
            "Auf das shared Memory Segment kann nicht zugegriffen werden.");
    }

    return (SFData)Marshal.PtrToStructure(
					this.sharedMemoryPointer,
					typeof(SFData));
}

Nachdem die Daten jetzt in einer verwalteten Struktur vorliegen, kann mit ihnen wie gewohnt verfahren werden.

Der Gedanke hinter der Umsetzung dieses Projekts war eine freie Bibliothek für alle möglichen Anwendungen zu schaffen. Ich weis dass schon einige Gadgets erstellt haben die das Shared Memory Segment von SpeedFan nutzen. Diese Gadgets oder Anwendungen unterliegen meist einem Copyright und machen damit eigene Anpassungen nahezu unmöglich. Meine Interessen liegen nicht beim erstellen von grafischen Anwendungen. Außerdem habe habe kein Händchen für das Oberflächendesign. Doch was ich bis jetzt so an Gadgets und grafischen Tools gesehen habe, gibt es anscheinend genug Leute die Spaß daran haben grafische Oberflächen zu bauen. Genau diese Leute will ich mit dieser, und vielleicht noch weiteren Bibliotheken, ansprechen. Sowohl die Bibliothek als auch der Quellcode unterliegen der MIT-Lizenz und sind somit fast uneingeschränkt nutzbar. Lediglich ein Verweis auf den Original Code muss vorhanden sein.

Gerade um die Bibliothek in Gadgets zu verwenden ist die Klasse, welche die Werte aus dem Shared Memory Segment liefert, für COM sichtbar und dadurch mit JavaScript zu verwenden.

[ComVisible(true),
Guid("8a31250b-7c0f-469e-b874-5f53c81728f7"),
ProgId("SpeedFanConnector.SFConnector"),
ClassInterface(ClassInterfaceType.None)]
public partial class SFConnector : IDisposable

Eine Dokumentation der API ist als chm-Datei vorhanden. Zum Testen der Bibliothek auf dem eigenen Computer liegt eine Konsolenanwendung bei die, einfach vorab ausgeführt, schon mögliche Probleme oder die einwandfreie Funktion zeigen kann. Hier zwei Screen-Shots. Einmal von der Konsolenanwendung und zum anderen von SpeedFan um die Funktion der Bibliothek zu zeigen.

Wie hier zu sehen ist, sollten alle Werte die im SpeedFan Dialog zu sehen sind auch in der Konsolenanwendung in der richtigen Reihenfolge gezeigt werden. Es wird vorausgesetzt das SpeedFan Installiert ist und ausgeführt wird. ich habe mit Absicht darauf verzichtet SpeedFan aus der Bibliothek zu starten. Unter XP ginge das ja noch einwandfrei, doch unter Vista könnte es Probleme mit der UAC geben. Statt dessen habe ich die zwei statischen Eigenschaften SpeedFanAlreadyRunning und SpeedFanPath eingebaut. Sie sind deshalb statisch um bereits vor der Initialisierung prüfen zu können ob SpeedFan überhaupt installiert ist, bzw. gerade ausgeführt wird. Sollte eine Initialisierung der Klasse SFConnector erfolgen ohne das SpeedFan ausgeführt wird, führt dies unweigerlich zu einer SharedMemoryException da das shared Memory Segment von SpeedFan nicht verfügbar ist.

Die Eigenschaft SpeedFanPath sucht in der Registrierung das Installationsverzeichnis von SpeedFan und prüft anschließend ob die Datei speedfan.exe im angegebenen Verzeichnis vorhanden ist. Wird sie gefunden wird der komplette Pfad zurück gegeben. Wird entweder der Pfad in der Registrierung oder die Datei nicht gefunden, wird null zurückgegeben. Die Eigenschaft SpeedFanAlreadyRunning prüft ob der Prozess ausgeführt wird. Ist dies der Fall wird true zurückgegeben, anderenfalls false. Es wird allerdings auch false zurückgegeben falls keine ausreichende Berechtigung vorliegt um die laufenden Prozesse abzufragen, da eine evtl. auftretende SecurityException intern behandelt wird.

Wer Interesse hat, kann sich die Bibliothek herunterladen. Außer der Konsolenanwendung ist noch die Komplette Dokumentation der API enthalten. Zum besseren Verständnis der Arbeitsweise, habe ich auch alle privaten Member sowie alle internen Klassen dokumentiert. Über Rückmeldungen würde ich mich freuen. Kritik ist ausdrücklich erwünscht.

SpeedFanConnector

Sollte Interesse bestehen, kann ich auch gerne den Quellcode bereitstellen. Einfach kurze Mail senden.

Nachdem Stefan Lieser in Blog und Maillingliste bereits grob berichtet hat, folgen hier nun noch die visuelle “Nachverfolgung” des ersten ALT.NET Treffens in Deutschland überhaupt.

Stattgefunden hat das ganze in der Teba in Köln, wo auch die Treffen der DNUG Köln ihre Heimat haben. Themen waren unter anderem:

• Mitarbeiter Motivation / Coaching in ALT.Net
• Messaging statt RPC, Publish Subscriber
• PostSharp erfüllt Obliviousness nicht
• Parallelität

Speziell zum Thema PostSharp und AOP-Obliviousness möchte ich noch den folgenden Link zum entsprechenden Paper nachreichen: Robert Filman, Daniel Friedman: “AOP is Quantification & Obliviousness”.

Nun ist es also raus: am 18. und 19. Oktober 2008 findet die .NET Open Space in Leipzig statt. Dabei bildet ALT.NET eines der drei Themenfelder und verspricht spannende Sessions. Ort der Veransaltung ist der Mediencampus Villa Ida. Ich werde auf jeden Fall teilnehmen und habe mich bereits registiert. Vielleicht kommt ja auch eine Session zu DDD oder AOSD zustande – ich würde mich drauf freuen ;-)

Do you the feeling when you know exactly what you mean, but you can't find a succinct way to express it? The guy that posted this classic piece of code to the forum surely does:

 if (flag == false)

   flag = true;

 else if (flag == true)

   flag = false;

Hint: flag = !flag

Sorry for not posting anything of greater importance. I'm rather tired :-)

In dem letzten UnitTest HowTo haben wir den ersten Schritt in Richtung “bessere Software” getan.

Was bei Unit Tests beachtet werden sollte: Ein Unit Test soll genau eine Sache testen - abgeschottet von allen anderen Sachen.
Phil Haack hat einen sehr guten Blogpost darüber geschrieben (und noch einen anderen ) - der auch mich etwas “wachgerüttelt” hat.

Was bedeutet das:
Wenn wir angenommen eine 3-Schichten Architektur haben und unseren Service Layer testen möchten, sollten wir tunlichst vermeiden über den Data Access Layer zu gehen und so direkt zur DB zu reden. Die DB kann sich verändern!

Warum?
Wenn man direkt mit der DB redet, muss man sich auf bestimmte Daten verlassen - d.h. statische Daten laden in den Tests. Falls die Daten in der DB mal verloren gehen, gehen leider die UnitTests nicht mehr (selber in einem Projekt soeben bemerkt ).

Ich mach eine Testdatenbank!
Man kann natürlich eine direkte Testdatenbank habe - allerdings ist es dann trotzdem recht schwierig eine “valides” Umfeld bei jedem einzelnen Test zu haben. Oder man resettet nach jedem Test die TestDB - allerdings laufen dann die Unit-Tests sehr zäh ab und es ist auch recht schwierig zu managen.

Mein Idealbild:
Bei jedem Unit Test möchte ich meine Umgebung exakt auf den Testfall konstruieren - sodass ich genau das Verhalten testen und daraufhin implementieren kann.

Das Zauberwort: Mocking
Durch den Einsatz von Schnittstellen usw. kann man natürlich überall Fake / Dummy Klassen erstellen - wie z.B. ich es hier getan hab mit den statischen Daten. Darunter kann man schonmal grob Mocking verstehen.

Allerdings ist es ziemlich umständlich für alles und jeden Test die Umgebung entsprechend durch solche Fake-Implementationen komplett zu mimen. Zudem fehlt etwas die Verbindung zwischen der Mockklasse und dem tatsächlichen Einsatzort.

Die Magie der Frameworks
Wie für fast jedes Problem, gibt es auch hier kleine Helferlein, welche durch Magie (es ähnelt Magie ) dir den kompletten Implementationsaufwand der einzelnen konkreten Klassen abnehmen.
Es gibt in der .NET Welt einige Mocking Frameworks: Moq, Rhino.Mocks, TypeMock usw.
Ich bezieh mich nun auf Rhino.Mocks.

In die Praxis:
Wir haben wieder den ähnlichen Aufbau wie die letzten Male:

Wer genauer hinschaut, sieht, dass es keine konkrete Implementation von IPersonRepository zu sehen ist - keine DummyRepository, auch nicht im Test.

Der Aufbau:
In unserem “PersonFilter” haben wir diesmal nur den “WithAge” Filter. Unser “IPersonRepository” hat eine “GetPersons” Methode.

Den PersonService haben wir nun so implementiert:

namespace RhinoMocks.Services
{
    public class PersonService
    {
        private IPersonRepository PersonRep { get; set; }

        public PersonService(IPersonRepository rep)
        {
            this.PersonRep = rep;
        }

        public IList<Person> GetPersonsByAge(int age)
        {
            return this.PersonRep.GetPersons().WithAge(age).ToList();
        }
    }
}

Im Konstruktur übergeben wir unser PersonRepository und in der GetPersonsByAge Methode fragen wir quasi über unseren Filter das entsprechende Repository ab.

Ich benutze die Rhino.Mocks Version 3.5 - welche die aktuellste ist. Diese einfach referenzieren.

Im Test möchten wir nun genau diese eine Methode testen:

        [TestMethod]
        public void PersonService_GetPersonByAge_Works()
        {
            MockRepository mock = new MockRepository();
            IPersonRepository rep = mock.StrictMock<IPersonRepository>();

            using (mock.Record())
            {
                List<Person> returnValues = new List<Person>()
                {
                    new Person() { Age = 11, Name = "Bob" },
                    new Person() { Age = 22, Name = "Alice" },
                    new Person() { Age = 20, Name = "Robert" },
                    new Person() { Age = 40, Name = "Hans" },
                    new Person() { Age = 20, Name = "Peter" },
                    new Person() { Age = 20, Name = "Oli" },
                };
                Expect.Call(rep.GetPersons()).Return(returnValues.AsQueryable());
            }
            using (mock.Playback())
            {
                PersonService service = new PersonService(rep);
                List<Person> serviceResults = service.GetPersonsByAge(20).ToList();

                Assert.AreNotEqual(0, serviceResults.Count);

                foreach (Person result in serviceResults)
                {
                    Assert.AreEqual(20, result.Age);
                }
            }
        }

Achtung: Wie es genau funktioniert wieß ich auch noch nicht - allerdings tut es

Schauen wir es uns mal genauer an:

            MockRepository mock = new MockRepository();
            IPersonRepository rep = mock.StrictMock<IPersonRepository>();

Dieser Codeschnipsel erstellt uns dynamisch ein Objekt vom Typ “IPersonRepository”.

Jetzt kommt der “Record” Mode:

using (mock.Record())
            {
                List<Person> returnValues = new List<Person>()
                {
                    new Person() { Age = 11, Name = "Bob" },
                    new Person() { Age = 22, Name = "Alice" },
                    new Person() { Age = 20, Name = "Robert" },
                    new Person() { Age = 40, Name = "Hans" },
                    new Person() { Age = 20, Name = "Peter" },
                    new Person() { Age = 20, Name = "Oli" },
                };
                Expect.Call(rep.GetPersons()).Return(returnValues.AsQueryable());
            }

Alles was innerhalb von diesem Using ist, wird “aufgezeichnet”. Als erstes erstelle ich mir meine PersonCollection (mein Umfeld in dem in den Test laufen lassen möchte).
In “Expect.Call” geb ich die Methode an, die aufgerufen wird und was dabei als Returnvalue zurückgegeben wird (in meinem Fall meine PersonCollection).

Im letzten “Playback” Abschnitt:

using (mock.Playback())
            {
                PersonService service = new PersonService(rep);
                List<Person> serviceResults = service.GetPersonsByAge(20).ToList();

                Assert.AreNotEqual(0, serviceResults.Count);

                foreach (Person result in serviceResults)
                {
                    Assert.AreEqual(20, result.Age);
                }
            }

Hier wird das, was wir vorher definiert haben bei den entsprechenden Calls “abgespielt”.
Wie die Magie direkt funktioniert, weiß ich nicht, allerdings wird dynamisch zur Laufzeit dieser Typ generiert:

Ergebnis:
Der Test läuft durch und ich hab durch diesen Mock genau nur eine Sache getestet - ob der Service läuft oder nicht. Ob die DB verrückt spielt ist mir an dieser Stelle egal

Andere Beispiele:

Ich hab am Anfang ein einfaches “Hello World” Beispiel gefunden. Einige Screencasts findet man hier und ein kleines Wiki hat auch noch ein paar Artikel darüber.

Wenn mein Beispiel komplett falsch ist (oder ich eine falsche Erklärung hab), dann einfach melden - ich arbeite mich erst in diese Materie ein

[ Download Democode ]

ShareThis

APIs (egal ob sie nur für interne Zwecke da sind oder auch an externe Entwicklern geht) sollten möglichst einfach und intuitiv zu bedienen sein.
Seit kurzem lese ich immer häufiger von “Fluent Interfaces“.

Was ist das denn?
Schauen wir uns einfach mal das Wikipedia Beispiel an:

public class ExampleProgram
    {
        [STAThread]
        public static void Main(string[] args)
        {
            //Standard Example
            IConfiguration config = new Configuration();
            config.SetColor("blue");
            config.SetHeight(1);
            config.SetLength(2);
            config.SetDepth(3);
            //FluentExample
            IConfigurationFluent config =
                  new ConfigurationFluent().SetColor("blue")
                                           .SetHeight(1)
                                           .SetLength(2)
                                           .SetDepth(3);
        }

Anstatt nur einzelne Methodenaufrufe zu haben, ist es doch viel angenehmer diese in “einem Satz” niederzuschreiben. Diese Technik findet auch in diversen Javascript-Bibliotheken Einsatz (z.b: jQuery)

Sieht nicht schlecht aus - wie macht man sowas?
Es gibt (wie in dem Wikipedia Beispiel) sicherlich ein paar Tricks wie man sowas machen kann - durch Rob Conerys Storefront Projekt bin ich konkret auf das “Pipes and Filters” Pattern gekommen.

Die Idee (in der Rob Conery Version )
Wir haben einen großen Datenhaufen (unser Repository), wo wir über Filter bestimmte Sachen einfach uns abzapfen können, wie wir es brauchen.

Das tolle nun daran: Man kann nicht nur ein Filter nehmen, sondern kann diese auch zusammenschließen um seine Ergebnisse noch weiter einzuengen:

Rob Conery hat dies auch in einem Screencast recht gut erklärt.

Die Umsetzung in .NET mit C# 3.0:
Als “Daten” haben wir in unserem Beispiel einfach eine simple Person Klasse:

    public class Person
    {
        public int Age { get; set; }
        public string Name { get; set; }
    }

Der Aufbau ist ähnlich empfunden wie bei diesem Blogpost - allerdings etwas vereinfacht (und sollte so nicht verwendet werden (Schnittstellen einbauen!))

Unser DummyPersonRepository hat nur eine Methode, welche statisch ein paar Objekte erzeugt:

    public class DummyPersonRepository
    {
        public IQueryable<Person> GetPersons()
        {
            List<Person> returnValues = new List<Person>()
                {
                    new Person() { Age = 11, Name = "Bob" },
                    new Person() { Age = 22, Name = "Alice" },
                    new Person() { Age = 20, Name = "Robert" },
                    new Person() { Age = 40, Name = "Hans" },
                    new Person() { Age = 20, Name = "Peter" },
                    new Person() { Age = 20, Name = "Oli" },
                };

            return returnValues.AsQueryable();
        }
    }

Nun kommen unsere Filter ins Spiel - die nicht direkt ins Repository kommen! Diese werden über “Extension Methods” in einer seperaten Klasse implementiert:

    public static class PersonFilters
    {
        public static IQueryable<Person> WithAge(this IQueryable<Person> qry, int age)
        {
            return (from x in qry
                    where x.Age == age
                    select x);
        }

        public static IQueryable<Person> NameStartsWith(this IQueryable<Person> qry, string start)
        {
            return (from x in qry
                    where x.Name.StartsWith(start)
                    select x);
        }
    }

Hier fragen wir einmal nach dem Alter und ob der Name mit was bestimmten beginnt - beides als “Extension Method”.

In unserem Service können wir nun so eine Methode bereitstellen:

        public IList<Person> GetPersons(int age, string startsWith)
        {
            return this.PersonRep.GetPersons().WithAge(age).NameStartsWith(startsWith).ToList();
        }

Sehr einfach und effektiv

Ergebnis:
Am Ende können wir einfach in einer Konsolenapplikation sowas aufrufen:

static void Main(string[] args)
        {
            PersonService srv = new PersonService();
            List<Person> resultList = srv.GetPersons(20, "R").ToList();
            foreach (Person result in resultList)
            {
                Console.WriteLine("Name {0} - Age {1}", result.Name, result.Age);
            }

            Console.Read();
        }

Die Projektstruktur:

Natürlich ist das nur ein simples Beispiel, allerdings konnte ich dies bereits effektiv in einem Projekt einsetzen.

Neben Rob Conerys Storefront kann man sich auch diesen Democode von Mike Bosch anschauen (Teil 1 & 2) - auch er findet diese Idee sehr cool

Insgesamt erlaubt ein solcher Programmierstil deutlich schickeren Code - wie bereits das Wikipedia Beispiel am Anfang gezeigt haben sollte.

[ Download Democode ]

ShareThis

Nach längerer Pause gibt es mal wieder was neues auf dem Blog.
Fangen wir an mit einem kleinen schicken Gewinnspiel, bei dem es 2 kostenfreie Eintrittskarten für den Technical Summit und ein Visual Studio 2008 zu gewinnen gibt!
Sendet dazu einfach die Lösungen im Zeitraum vom 06.08.08 bis 10.09.2008 zu den nachfolgenden Fragen an meine Email Adresse: robert(dot)muehsig(at)code-developer(dot)de

Was ist das Technical Summit?
Das Microsoft Technical Summit findet immer dann statt, wenn es viel Neues für professionelle Entwickler, Architekten, Entwicklungsleiter, IT-Projektleiter und IT-Projektmanager zu berichten gibt. Dieses Jahr sind die Highlights die Produkte und Services von morgen, die ganz aktuell auf der PDC 2008 bekannt gegeben und erstmalig auf dem Microsoft Technical Summit in Deutschland (genauer gesagt im schönen Berlin) vorgestellt werden. Bis zum 19.09. läuft noch der Early-Bird-Preis. Anmeldung und zusätzliche Infos unter: www.technical-summit.de

Fragen:

• 1) Frage: Wie lautet das Motto des 2008 Microsoft Technical Summit?
• Antwortmöglichkeiten:
• a) Developer, Developer, Developer!
• b) Technologien von morgen, schon heute!
• c) Microsoft, Microsoft, Microsoft!
• d) Alles für Entwickler!
• Lösungslink: http://go.microsoft.com/?linkid=9298430
• 2) Frage: Wie heißt die aktuelle Visual Studio Version?
• Antwortmöglichkeiten:
• a) Visual Studio 2008
• b) Visual Studio 2007
• c) Visual Studio 2006
• d) Visual Studio 2005
• Lösungslink: http://go.microsoft.com/?linkid=9298431
• 3) Frage: Bis wann läuft die Early-Bird-Promotion des Microsoft Technical Summits?
• Antwortmöglichkeiten:
• a) 19.09.2008
• b) 10.09.2008
• c) 19.10.2008
• d) 24.12.2008
• Lösungslink: http://go.microsoft.com/?linkid=9298432
• 4) Frage: Wann wurden die ersten Vortragsthemen und Sprecher publiziert?
• Antwortmöglichkeiten:
• a) 19.05.2008
• b) 11.06.2008
• c) 23.06.2008
• d) 07.07.2008
• Lösungslink: http://go.microsoft.com/?linkid=9298433

Viel Spaß beim Rätseln

PS: Wenn alles gut geht, werde ich sicherlich auch auf dem Technical Summit dabei sein

ShareThis

Ich habe bei mir in der Firma interne, wiederkehrende Workshops organisiert, die sich in kleinen Teams selbst verwalten. Themenschwerpunkte sind bestehende und alternative Technologien. Ziel ist es diese Technologien zu evaluieren sie bei einem gewinnbringenden Ergebnis in den Firmen- und Entwicklungsprozess einzubinden.

Die Kernthemen in den ersten zwei Gruppen sind

• AJAX, alles rund um die Client-Server Kommunikation, sowie der notwendigen Infrastruktur und der Steuerelemente.
• Softwarearchitektur: Schwerpunkt Komponentenorientierung (Dependency Injection, Unit Testing, Type Mocking)
• Scrum als agiler Softwareprozess

Scrum will ich deswegen verwenden, da es die Soft Skills jedes einzelnen in der Gruppe steigert und sich die Teams selbst organisieren lässt. Das ist in der Workshopatmosphäre genau das richtige.

Ich werde daher auch in kürze auf meinem Blog das Logo der .NET Open Space auf meiner Seite hosten. Und wenn ich Zeit finde an dem Wochenende werde ich auch die Konferenz besuchen. Nähere Informationen folgen.

Der Artikel Wettbewerb im dotnet-forum.de ist beendet.
Das Team hat die Artikel in den letzten Tagen genau unter die Lupe genommen und hat zwei Gewinner ausgewählt.
Der Erste Platz geht an Gordon Breuer für den Artikel "Grundlagen zu LINQ, λ-Expressions und Extension-Methods". Gordon bekommt das .Net Productivity Pack bestehend aus einer Lizenz Jetbrains Resharper 4.0 und einer Lizenz Jetbrains dotTrace.
Der Zweite Preis geht an Rainer Hilmer. Er bekommt den Zweiten Preis , eine Lizenz für Jetbrains Resharper 4.0 für seinen Artikel "Extension Methods (C#3 Spracherweiterung) am Beispiel eines Value Limiters"

Herzlichen Glückwunsch den beiden Gewinnern!

Es wurden insgesamt 7 Artikel eingereicht. Um die neuen Sprachfeatures von C# 3.0 kennenzulernen lohnt es sich, jeden einzelnen Artikel zu lesen:

• C# 3.0 Feature: Automatic Properties von ThorstenHans
• C# 3.0 Extension Methods von ThorstenHans
• Extension Methods (C#3 Spracherweiterung) am Beispiel eines Value Limiters von Cyron
• Erweiterungsmethoden: IO-Extensions von flachzange
• Anonyme Typen von ThorstenHans
• Grundlagen zu LINQ, λ-Expressions und Extension-Methods von Anheledir
• Partielle Methoden von ThorstenHans

Gewinnfragen

ASP.NET hat viele Möglichkeiten um Ausgaben oder Daten zu cachen, unter anderem gibt es ein Control mit dem Namen "Substitution" - auf der Zunge vergeht der Name nicht, der Nutzen des Controls ist allerdings nicht zu unterschätzen.

Unter folgendem Link (Übersicht über das Substitution-Webserversteuerelement) findet ihr eine gute Übersicht vom Control.

Wenn es darum geht Daten zu cachen, dann meist weil es lange geht, diese abzurufen, oder aber die Zugriffe immens sind.
Dies kann beispielsweise einen WebRequest auf eine Url sein, die gar nicht erreichbar sein _muss_, oder eine Abfrage ans Dateisystem um Dateiinhalte anzuzeigen, die ggf. aktualisiert worden sind.

Zu beiden Aufgabenstellungen möchte ich hier jeweils ein Beispiel liefern.

Um das erste Beispiel ermöglichen zu können brauchen wir im App_Data-Verzeichnis eine Textdatei mit dem Inhalt "Hallo Welt", diese wollen wir später abfragen.
Danach braucht es ein Substitution-Control auf der ASPX-Seite, soweit wäre das schon fast alles.

Der ASPX-Teil sieht dann ungefähr so aus:

Das Control hat eine einzige wichtige Eigenschaft: "MethodName".
Der hier angegebene Methodennamen wird dazu benutzt, die Methode - falls vorhanden - aufzurufen.

Dabei liefert die Methode den Inhalt des Controls (Als literalen Content) als String zurück.
Dieser wird danach anstelle des Substitution-Control Markups angezeigt, er wird je nach Logik aus dem Cache geladen oder frisch aktualisiert.

Die Methode muss statisch sein der nachstehenden Signatur folgen:

Über den Parameter vom Typ HttpContext kann unter anderem auf den Cache, Response oder den Request zugegriffen werden.
Zuerst müssen wir einen Methodennamen zuweisen, beispielsweise so im Codebehind:

Folgend die Implementation um den Inhalt einer Datei entweder aus dem Cache auszulesen oder aber aktuell zu holen.
Das kann einfach über eine CacheDependency gelöst werden.

CacheDependencys (Es gibt auch eine SqlCacheDependency) überprüfen die Gültigkeit des Cache-Inhaltes aufgrund von verschiedenen Eingaben (Dateinamen / Letzte Änderung / Datenbankänderungen, etc...) und setzen den Cache-Inhalt auf "null" / "Nothing" wenn aktuellere Daten verfügbar sind bzw. die Cache-Zeit abgelaufen ist.

Sobald der Inhalt der Textdatei bzw. dessen Änderungsdatum geändert haben, wird der Cache ungültig, ist somit "null" / "Nothing" und der aktuelle Inhalt wird in den Cache eingelesen + angezeigt.

Bei einem WebRequest sieht es ein wenig anders aus, jedoch verfährt es nach dem gleichen Prinzip (Also Cache auf "null" prüfen und ggf. Daten aktualisieren).
Anstelle einer CacheDependency wird eine Zeitdauer eingestellt.
Für diese Dauer ist der Cacheinhalt gültig, nach Ablauf wird - in diesem Fall - ein neuer WebRequest losgeschickt und der Cache wieder gefüllt:

Das Substitution-Control stellt nur ein Hilfsmittel dar, um Daten aus dem Cache direkt auf der Webseite anzuzeigen.
Die Vorgehensweise innerhalb der "GetData"-Methoden kann auch an einer anderen Stelle genutzt werden, um Daten aus dem Cache anzuzeigen.

Viel Spass damit.

Download des Beispielprojekts:

• Beispielprojekt mit Datei- und WebRequest-Abfrage per Substitution-Control

MSDN-Links:

• Substitution-Klasse
• Übersicht über das Substitution-Webserversteuerelement
• HttpContext-Klasse
• Cache-Klasse
• HttpResponse-Klasse
• HttpRequest-Klasse
• CacheDependency-Klasse
• SqlCacheDependency-Klasse

Nachdem ich letzte Woche mein neues HP Notebook mit vorinstalliertem Windows Vista(R) erhalten habe, musste ich mich das erste mal näher mit Vista befassen. Ich muss zugeben, was ich bis jetzt über Vista gehört und gelesen hatte, hätte widersprüchlicher nicht sein können: von restlos begeistert bis "nicht zu gebrauchen" war alles dabei. Also warum nicht dachte ich mir; XP installieren kannst du später immer noch.

Der erste Eindruck von Vista war ganz angenehm. Der Systemstart geht relativ flott von statten und der erste optische Eindruck ist ganz ansprechend. So begann ich das leere Gerät mit Software zu füllen. Bei der Installation des ersten Programms war sie plötzlich da: die viel diskutierte UAC. Also habe ich die UAC für den Zeitraum der Installation meiner benötigten Programme erst einmal ausgeschaltet. Vista "maulte" zwar ein wenig, aber besser Vista als ich. Nachdem die UAC erst mal deaktiviert war, ging die Installation und das Einrichten wie von XP gewohnt. Nach dem die Installationen abgeschlossen waren die UAC wieder eingeschaltet und das war's, dachte ich. Beim ersten Systemstart mit eingeschalteter UAC viel mir ein neues "Feature" von Vista auf: das blockieren von non Vista-Compliant Programmen die beim Systemstart ausgeführt werden sollen. Und ausgerechnet PSI und SpeedFan; toll. Egal ob die Programme aus dem Autostart-Ordner oder aus der Registrierung gestartet werden, Vista blockiert sie. Da fand ich diesen Post in einem Forum. Das Konzept ist so einfach wie genial. Das von Vista verweigerte Programme einfach als geplanten Task, oder Aufgabe wie es jetzt heißt, anlegen und bei der Benutzeranmeldung ausführen lassen; fertig.

Nachdem auch diese Hürde genommen war, wollte ich natürlich die neuen Vista Feature erkunden. Am meisten gespannt war ich auf die Sidebar. Da ich schon lange mit XP die Desktop Sidebar verwende, hatte ich natürlich hohe Erwartungen an die Vista eigene Sidebar. Nach dem starten der Vista eigenen Sidebar und dem einfügen einiger Gadgets kam bereits die erste Enttäuschung auf. Die Vista Sidebar sieht zwar optisch sehr schön aus, aber der verfügbare Inhalt? Kein Vergleich mit der Desktop Sidebar. Als Beispiel das News-Feed Gadget. In der Vista Sidebar ist es sehr klein gehalten, zeigt lediglich 5 oder 6 Feeds auf einmal. Um überhaupt Feeds anzeigen zu können, müssen diese erst im Internet Explorer abonniert werden. Als Vergleich dazu werden die Feeds in der Desktop Sidebar in einem Dock-Panel angezeigt. Dieses ist in der Größe einstellbar so wie ich es haben will. Auch werden die Feeds nicht einfach fortlaufend angezeigt, sondern nach den einzelnen Feeds sortiert zwischen denen gewechselt werden kann. Um das Abonnement der Feeds kümmert sich ausschließlich die Desktop Sidebar und kein Browser. Das Prinzip der Gadgets in der Vista Sidebar ist zwar ein nettes Konzept, doch gefällt mir persönlich das der Desktop Sidebar mit den Panels wesentlich besser. Es sieht einfach homogener aus. Aber das ist Geschmacksache und über Geschmack lässt sich bekanntlich nicht streiten.

Was Vista an grafischen Gimmicks zu bieten hat finde ich sehr gelungen. Vor allem das Windows-Flip-3D hat es mir angetan. Auch sehen WPF-Anwendungen irgendwie edler aus. Im großen und ganzen empfinde ich die Oberfläche von Vista als sehr flüssig, trotz aktiviertem Aero Stil.

Die UAC erscheint mir als vernünftiger Ansatz zum Thema Sicherheit. Vor allem wenn man den Umstand der, unter Windows Benutzern weit verbreiteten Unart, permanenten Benutzung eines Kontos mit administrativen Rechten bedenkt. Nur die Umsetzung empfinde ich als nicht sehr gelungen. Hier könnte bestimmt eine bessere Lösung gefunden werden. Wenn z.B. Sql Server Management Studio explizit als Administrator gestartet wird, warum muss dann noch einmal nachgefragt werden ob ich dieses Programm auch wirklich gestartet habe? Oder der Zugriff auf das Programm-Verzeichnis. Nicht für jedes Programm ist ein Installer vorhanden. Warum kann ich nicht einfach eine Anwendung in dieses Verzeichnis kopieren ohne erst die UAC zu deaktivieren? Genauso wie das schreiben von Einstellungen in Konfigurationsdateien im Programm-Verzeichnis wird kategorisch unterbunden. Erst nach dem anpassen der Berechtigungen lässt sich hier vernünftig arbeiten. Das ließe sich sicherlich mit einer Trusted List lösen in der die Programme aufgenommen werden welche in das eigene Verzeichnis schreiben dürfen. Es wird mit Sicherheit noch einige Zeit dauern, bis alle Anwendungen dahingehend angepasst wurden nur in das Benutzer-Verzeichnis zu schreiben. Nicht einmal die Microsoft eigenen tun das, wie etwa StyleCop.

Trotz der angesprochenen Ecken und Kanten gefällt mir Vista eigentlich sehr gut. Ich Denke es hat Potential und werde es wohl weiter Verwenden. Es wird sich mit den kommenden Servicepacks mit Sicherheit noch einiges ändern. XP war ja auch erst mit dem SP2 so richtig erfolgreich.

Vorwort

Das ist das Triumvirat der modernen Softwarearchitektur. Einige werden sich jetzt fragen, was ich ihnen eigentlich erzählen will? Nun dann will ich mal ganz vorne anfangen. Zuerst einmal ein kurze Einführung. Ich werde ab September wieder in der Desktop basierten Softwareentwicklung tätig sein. Das gute daran ist, es wird eine Neuentwicklung werden. Und da wittere ich jetzt die Gelegenheit Architekturkonzepte aufzugreifen, die sich schon länger entwickelt haben und immer mehr in Mode kommen.

UnitTesting

Bereits vor vielen Jahren hat Kent Beck mit Extreme Programming den Meilenstein für eine heranwachsende Softwaregeneration gelegt. Er ist - so würde ich es bezeichnen - der Urvater der modernen Testframeworks. Er hat SUnit für Smalltak entwickelt und dann später mit Erich Gamma das ganze nach Java als JUnit portiert. Wer gut aufgepasst hat wird sich jetzt vielleicht fragen, ob das was mit NUnit zu tun hat. Und wie! Schlussendlich ist diese ganz N-Produkt-Sache an Java angelehnt. Viele Gute Frameworks haben den Transfer aus der Javawelt in das .NET Zeitalter gut überstanden und erleben hier einen großen Anklang und Aufschwung.

Nun zurück zu meiner Überschrift. Im laufe der Jahre sind immer mehr Probleme in der objektorientierten Entwicklung entstanden. Spaghetti Code ist den tief verschachtelten Klassenhierarchien gewichen und hat so den Weg zu der gleichen Komplexität geebnet. Nun haben sich Architekten dafür aber wieder etwas einfallen lassen.

Da UnitTesting schon zum guten Ton gehört und es sich aus neu entstehenden Projekten eigentlich nicht mehr wegdenken lässt will ich hier auch weitere Schwerpunkte legen und aufzeigen. Was macht das Testen aber schwierig? Nun ja, wie bekomme ich Abhängigkeiten innerhalb von Klassen geregelt, die nach aussen hin nicht sichtbar sind, also private oder protected? Über das .NET Framework können diese Beschränkungen umgangen werden.

Type Mocking

So kommen wir doch nun aber mal einen Schritt weiter. Ich will Klassen testen, die wiederum von anderen abhängig ist. Schon früher war klar: Es müssen Verträge geschaffen werden und diese nennen sich eben einmal Schnittstellen (Interfaces). Hier kommt Type Mocking ins Spiel. Was ist das, ein Mock (Attrappe)? Diese Technik dient dazu zu einem vorgebenen Interface ein konkrete Implementierung zu erstellen und dabei alle notwendigen Abhängigkeiten von aussen zu injizieren.

Bei UnitTests kann das verwendet werden um einzelne Komponenten unabhängig von ihrem Gesamtsystem, indem sie Leben zu testen. Auch Komponenten können ja ihrerseits wieder Abhängigkeiten haben. Dies kann durch Type Mocking in Einheitentests eliminiert werden, indem wir Komponente A sagen, wie B aussieht, und wie sie sich verhält. Dabei genügt es vollkommen nur ein Interface davon zu besitzen. Wir bauen uns zur Laufzeit, on the fly, das benötigte Objekt B zusammen und jubeln es Komponente A unter. So bekommen wir ein Funktionierendes System. Wir können also unsere Tests abgeschlossen als Sandbox laufen lassen. Das ist ein Technik, die sehr gut funktioniert und aus dem Unittesting nicht mehr wegzudenken ist.

Dependency Injection

Meine Damen und Herren ich darf ihnen nun Dependency Injection oder kurz DI präsentieren. Es ist eine Spezielle Implementierung des Inversion of Control (IoC) Patterns. Dabei leistet DI mehr als sein Muster IoC, das mittlerweile nur einen Teil davon abbildet. Mit DI schaffen wir, was die Objektorientierung in jahrelanger Arbeit angerichtet hat: Wir lösen die starke Kopplung und Verdrahtung von Abhängigkeiten und schaffen eine überschaubare und wartbare Komplexität.

Dazu gibt es einen Container, bei dem alle Interfaces und Objekte registriert werden. Der Container kann dabei als Factory dienen und als alleswissender Dispatcher. Wird ein Objekt, oder Service benötigt, so stellen wir nur eine Anfrage an den Container und er liefert uns das passende Objekt zurück.

Zu schön um wahr zu sein? Nein, schon seit langem lebende Praxis. Diese etwas längere Einführung sollte nur ein kurzer Artikel sein um euch das ganze schmackhaft zu machen. Ich werde nun im folgenden ein paar Frameworks aufzählen, so dass jeder, der sich schon einmal voraus informieren will den nötigen Startpunkt hat.

Frameworks und Schlagworte

Dependency Injection (und mehr)

• Unity
• Autofac
• Castle Windsor
• Spring.NET
• LinFu
• NInject
• StructureMap
  

UnitTesting

• NUnit
• MbUnit
• xUnit
• MSTest (in Visual Studio integriert)
• Pex (Microsoft Research - erweitert MSTest)
• NBehave (Behaviour Driven Developement - BDD)
• StoryQ (BDD)

Type Mocking

• Rhino.Mocks
• Typemock Isolator (kommerziell, für MVPs ein Jahr kostenlos)
• Moq (aufstrebendes neues Framework mit C#3.0 Features)

Schlusswort

Das sollte für den Anfang erst einmal reichen. Ich beschäftige mich in der Theorie mit diesen Themen schon seit ca. zwei Jahren immer mal wieder. Natürlich immer wieder jeweils aufbauend zum nächsten kommenden Thema. Wichtig dabei ist es für mich den Hintergrund zu verstehen um es dann in der Praxis richtig einzusetzen. Benutzt habe ich die ein oder andere Technik schon in der Praxis, nun ist es aber an der Zeit alles zu kombinieren und im richtigen Maße zu verwenden. Mein Blog wird sich daher in nächster Zeit hoffentlich etwas mehr mit Beispielen füllen, die dann mein Genutztes und Gelerntes reflektieren sollen. Wenn, ja wenn mir neben den Vorbereitungen zum MCPD noch genügend Spielraum bleibt. Nebenbei erwähnt, habe ich auch noch eine wundervolle Frau, die meine Anwesenheit und Liebe zu schätzen weiß. Wer noch mehr Quellen zu dem Thema haben will sollte sich die Links in meinem Bloggroll ansehen. Besonders wertvoll waren für mich der Artikel über Autofac, der Blog von Ayende (Rhino.Mock) und die pnpguidance.net von David Hayden, sowie seine Seite. Der Mann hat sogar einen sehr guten Geschmack was grünen Tee angeht. Zu guter letzt noch ein deutscher Artikel, der eine gute Übersicht liefert:

Ich hoffe euch das ganze etwas schmackhaft gemacht zu haben. Feedback erwünscht.

Von Microsoft zur Verfügung gestellte SQL Server 2005 Performance Dashboard Reports können Euch bei der Analyse von Performance-Problemen die nötigen Informationen liefern.

Für diesen Report-Dateien benötigt ihr den Service Pack 2 (SP 2) für den SQL Server 2005.

Download URL für die SQL Server 2005 Performance Dashboard Reports: SQL Server 2005 Performance Dashboard Reports

Nach der einfachen Installation können die Reports wie folgt eingerichtet werden:

Zuerst müssen wir die setup.sql-Daten ausführen. Die setup.sql-Datei-File erstellt die nötigen Einträge in der msdb-Datenbank-Database, damit wir die Reports später benutzen können.

Die setup.sql-Datei-File befindet sich Standardmässig-Default in dem Verzeichnis C:\Program Files\Microsoft SQL Server\90\Tools\PerformanceDashboard, wenn während der Installation kein anderes Verzeichnis definiert wude.

Menü-Eintag File - Open - File auswählen:

Anschliessend die setup.sql-Datei-File auswählen:

Ein kleiner Ausschnitt der setup.sql-Datei-File sieht wie folgt aus:

Mit F5-Taste-Key oder Execute-Button können wir diesen Script laufen lassen. (Wie immer: Auf eigene Gefahr! Ich bin selber nicht unbedingt dafür, dass man solche Installationen direkt auf dem Produktions-Server testet.)

Object Explorer - Database-Server - Database-Instance > Reports > Custom Reports auswählen

Die Reports werden Standardmässig-Default in das Verzeichnis C:\Program Files\Microsoft SQL Server\90\Tools\PerformanceDashboard installiert, wenn kein anderes Verzeichnis während der Installation definiert wurde.

Als Beispiel die performance_dashboard_main.rdl-Datei-File auswählen

Die folgende Meldung mit Run bestägigen

Anschliessend werden die Informationen angezeigt:

Wenn ihr eine andere Report-Datei (wie z.B. database_overview.rdl) auswählt als performance_dashboard_main.rdl, dann wird das System folgende Meldung anzeigen:

Error: The 'version_string' parameter is mission a value

Die anderen Reports, welche die in dem Installationsverzeichnis vorhanden sind, können über den Performance Dashboard-Report aufgerufen werden.

Ein paar Beispiel-Sample Reports findet ihr unten:

User Requests:

User Sessions:

Waits:

IO Statistics:

Databases:

Des Öfteren wurde ich gefragt, wie man zwei Word-Docs separat öffnen kann. Mit separat meine ich z.B. docx1 auf dem linken Monitor und docx2 auf dem rechten Monitor.
Standardmäßig öffnet Word beide Dokumente in einer Word-Applikation und somit kann man sehr schlecht verschiedene Dokumente gleichzeitig bearbeiten (bzw. immer nur hin und her schalten).

Lösung: Damit man beide Word-Dokumente in jeweils einer eigenen Word-Applikation hat, muss man nur folgenden Button in Word drücken:

Ansicht ->Nebeneinander anzeigen

Es gibt noch weitere Interessante Feature, z.B. Synchroner Bildlauf zwischen den beiden Word-Dokumenten etc.

Des Öfteren wurde ich gefragt, wie man zwei Word-Docs separat öffnen kann. Mit separat meine ich z.B. docx1 auf dem linken Monitor und docx2 auf dem rechten Monitor.
Standardmäßig öffnet Word beide Dokumente in einer Word-Applikation und somit kann man sehr schlecht verschiedene Dokumente gleichzeitig bearbeiten (bzw. immer nur hin und her schalten).

Lösung: Damit man beide Word-Dokumente in jeweils einer eigenen Word-Applikation hat, muss man nur folgenden Button in Word drücken:

Ansicht ->Nebeneinander anzeigen

Es gibt noch weitere Interessante Feature, z.B. Synchroner Bildlauf zwischen den beiden Word-Dokumenten etc.

Des Öfteren wurde ich gefragt, wie man zwei Word-Docs separat öffnen kann. Mit separat meine ich z.B. docx1 auf dem linken Monitor und docx2 auf dem rechten Monitor.
Standardmäßig öffnet Word beide Dokumente in einer Word-Applikation und somit kann man sehr schlecht verschiedene Dokumente gleichzeitig bearbeiten (bzw. immer nur hin und her schalten).

Lösung: Damit man beide Word-Dokumente in jeweils einer eigenen Word-Applikation hat, muss man nur folgenden Button in Word drücken:

Ansicht ->Nebeneinander anzeigen

Es gibt noch weitere Interessante Feature, z.B. Synchroner Bildlauf zwischen den beiden Word-Dokumenten etc.

Nachdem ich mich jetzt seit einer Woche mit jQuery beschäftige, möchte ich eigentlich nicht mehr ohne. Der Grund ist ganz einfach. Du kannst damit Browserübergreifend dein Javascript auf einfache Weise schreiben!

Wo du zuvor 10 Zeilen Code gebraucht hast, kommst du nun vielleicht mit 3 aus. Darüber hinaus bietet jQuery viele Effekte an, ein schönes event-Model und unzählige Erweiterungen wie z.B. das Flexgrid - ein leichtgewichtiges, mächtiges Clientcontroll! Ein weiteres Beispiel? Aufrufe zum Server, wie WebService-Methoden, AJAX.pro Methoden oder ein GET/POST mit XmlHTTPRequest gehen mit einem Einzeiler von der Hand. Der Funktion wird lediglich ein Callback angegeben, da die Ausführung ja selbstverständlich asynchron ausgeführt wird.

Nun ist gerade die Eingewöhnung ohne Intellisense etwas schwer, aber dafür gibt es Abhilfe. Im VS2008 gab es einen Bug, der das anzeigen der jQueryinstanz ($) verhindert hat. Kurz gesucht und schon gefunden! Dieser Post hat mir das Leben gerettet. Hier wird beschrieben was notwendig ist, um Intellisense für jQuery komplett einzurichten. Es wird gezeigt, wie eine jQuery.Intellisense.js benutzt wird um das zu bewerkstelligen. Sie besteht nur aus den Funktionsdeklarationen und der Dokumentation.

Leider basiert sie auf der Version 1.2.3. Also nochmal gegoogelt - jetzt wußte ich ja, wonach ich suchen musste - und schon wieder einen Treffer. Hier findet ihr die aktuelle Version (jQuery-1.2.6-Intellisense.js).

Fazit. Wer ernsthaft AJAX programmiert wird sich jQuery kaum entziehen können. Und wer es noch nicht getan hat noch ein Tipp: Schaut euch mal die Google-AJAX-Script-Library an. Hier werdet ihr es neben weiteren interessanten Javascript-Frameworks auch wieder finden.

Happy Coding!

Der absolut einfachste Weg ein Video auf seine eigene Webseite einzubauen geht ist das neue Silverlight Media Player Control aus den ASP.NET Extensions zu verwenden.
Darüber hat man diverse Möglichkeiten, einen vordefinierten Player oder eine eigene Player-Darstellung zu verwenden und das Video seiner Wahl mit oder ohne Kapiteln ins Internet zu bringen. Dieses Video zeigt in 10 Minuten, wie es geht.
Viel Spaß.

ASP.NET Extensions: Silverlight Media Player Control