Geek. Coder. Gamer. Bayern Munich Fan.
Visit my blog stream http://writeline.io
My Name is Dariusz Parys
I'm also known as Writeline
I'm a Technical Evangelist @ Microsoft Germany and you can follow me on Twitter or visit my blog stream.
Eine zentrale Anlaufstelle um technische Informationen zum Windows Compute Cluster Sever 2003 zu beschaffen ist die Seite High-Performance-Computing with Windows Compute Cluster Server 2003.
Hier finden sich eine Menge technischer Whitepaper zu den Themen, Evaluation, Deployment and Extensibility.
Unter anderem ist dort auch gerade das neue Whitepaper Windows Compute Cluster Server and Linux Dual Boot erschienen.
Auf Channel9 ist ein interessantes Video gepostet worden. Es demonstriert die Nutzung von Open XML in einer Java Anwendung die auf Linux läuft. Hier ein Auszug aus der Beschreibung:
The sample application is running on a Linux server (in a VPC for this demo), and it has a typical Linux stack: Tomcat, Apache, MySQL, and a custom Java application. The user connects to this server from a Vista/IE machine, makes a few selections, and creates a DOCX that gets passed back to the client. The user then makes changes in Word 2007 and uploads their modified version to the Linux server, where Java code runs to extract the revision-tracking history and show the document's changes through a browser interface.
Das Feature der Revision-Tracking History wird somit auf einer 100% Nicht-Microsoft Plattform genutzt und analysiiert. Der Benutzer bekommt eine HTML Darstellung der Änderungen die er in einem X-Beliebigen Browser anschauen kann.
Einfach hier mal reinschauen.
Ich gebe es zu, ich habe mich bisher gar nicht mit dem Thema so richtig auseinandergesetzt. Doch nach mehreren Beiträgen zu diesem Thema habe ich mich ein wenig informiert. Jeder der in irgendeiner Form Microsoft Office Dokumente in seinen Anwendungen verarbeiten und modifizieren möchte sollte sich unbedingt mit diesem Format auseinandersetzen.
Weitere Informationen findet man auch hier
http://www.microsoft.com/germany/msdn/office/openxml/default.mspx
Wer erinnert sich nicht noch an so waghalsige Konstrukte in welchem ein Microsoft Word per OLE Automation durch ein COM+ Objekt per Object Pooling auf einem Server zum Erzeugen von Dokumenten genutzt wurde, was nebenbei gesagt auch noch komplett Un-Supported war. Ja, das waren mal Zeiten.
Ende letzten Jahres hatte ich zwei Webcasts zum Thema Guidance Automation Toolkit gehalten. Leider wurden Teil 3 und Teil 4 nie fertig. Damals war ich zu sehr eingespannt und hatte einfach keine Gelegenheit mehr die Serie zum Abschluß zu bringen.
Nun möchte ich mein Versprechen war machen. Dies ist der erste Teil einer kleinen Serie zum Thema Software Factories. In dieser Serie werde ich eine kleine Software Factory von Anfang an bauen und nach und nach mit Funktionalität füllen.
Bevor ich allerdings auf das eigentliche Projekt eingehe, möchte ich nochmal die Notwendigen Schritte wiederholen, die als Grundlage für das mitmachen in dieser Serie notwendig sind.
Zum einen benötigt man Visual Studio 2005. Die Express Edition wird leider nicht unterstützt da die Lizenzbedingungen verbieten dort Erweiterungen zu installieren. (Wobei technisch gesehen es schon möglich wäre).
Des Weiteren benötigt man fürs erste noch zwei weitere Downloads.
Einfach in dieser Reihenfolge installieren.
Nach der Installation startet man Visual Studio 2005 und hat nun einen neuen Projektknoten "Guidance Packages" und ein Template zum Entwickeln einer Software Factory.
Es handelt sich um eine Software Factory die eine Software Factory erstellt. Beim auswählen des Templates erscheint noch eine Wizard Seite.
Mit Finish wird dann die ensprechende Solution erstellt.
Das Template enthält eine Vielzahl von Beispielen mit der Funktionalität des Toolkits. In diesem Teil gehe ich noch nicht auf die Bedeutung der einzelnen Solution Folder ein sondern möchte lediglich das erstellte GuidancePackage1 registrieren und testen.
Zum Registrieren wird entsprechend das Kontextmenu auf dem Projekt "GuidancePackage1" aktiviert und "Register Guidance Package" ausgewählt.
Nach dem die Registrierung erfolgreich abgeschlossen wurde kann man nun eine zweite Instanz von Visual Studio 2005 starten und dort das neue Package aus dem Guidance Packages Knoten auswählen.
Nach dem Erstellen des Projektes findet man nun im Guidance Navigator die entsprechenden Rezepte und Projekttemplates die dieses Beispielpackage enthält. Was Rezepte sind und wie diese mit Aktionen zusammenspielen beschreibe ich im nächsten Beitrag. Vorerst mal ist es nur wichtig das Rezept "Say a message" zu aktivieren und zu testen.
Falls der Guidance Navigator nicht angezeigt wird kann man diesen unter (englisches Visual Studio) EDIT | OTHER WINDOWS | GUIDANCE NAVIGATOR WINDOW anzeigen lassen.
Führt man das Rezept aus so kommt ein Dialog der nach dem Text fragt.
Selbst dieses einfache Rezept zeigt schon Konzepte wie eigene Dialoge und Editoren. Beim Bestätigen des Dialogs mit Finish wird eine MessageBox erzeugt mit den abgefragten Daten.
So das war die Grundlage für die weiteren Teile. Die entsprechenden Softwarepakete sind installiert und beim nächsten mal werden die Konzepte und das Software Factory Projekt das gebaut werden soll vorgestellt.
Eine Anmerkung noch: Falls jemand eine Idee hat für eine Software Factory die ich im Laufe dieser Blog Serie realisieren soll kann er diese unter den Comments reinschreiben. Vielleicht lässt es sich verwirklichen. Ich habe mich noch nicht auf mein Beispiel festgelegt.
Auf MSDN gibt es jetzt die Visual Studio 2008 Beta 2 in verschiedenen Editionen zum runterladen und ausprobieren. Eine Quick-Tour zu einigen der neuen Funktionen gibt Scott Guthrie auf seinem Blog.
[de]
Die letzten zwei Monate hatte ich meine RSS Feed Url auf FeedBurner umgestellt. Leider habe ich Probleme mit der korrekten Ermittlung von Statistikdaten. Deshalb stelle ich diesen Feed wieder zurück auf die Originale RSS Url zurück.
http://blogs.msdn.com/dparys/rss.xml
Sorry für die Unanehmlichkeiten.
[en]
I just used for the last two months FeedBurner but encountered problems in retrieving correct statistics. Therefore I will move back again to my original RSS feed URL.
Please resubscribe at http://blogs.msdn.com/dparys/rss.xml
Sorry for any inconvenience.
Intel hat die Threading Building Blocks nun als Open Source Projekt verfügbar gemacht. Interessant für alle die Multi-Core Prozessoren effektiv aus der Anwendung heraus nutzen möchen und C++ programmieren.
Kernaussagen sind:
Das ganze findet man unter http://www.threadingbuildingblocks.org/
Anmerkung: Hier geht es zum deutschen Beitrag.
As posted before (sorry just in German) Visual Studio 2008 comes with a nice marshaling library for C++/CLI. With that it is easier to convert various native types into managed types and vice versa. Unfortunately the library just supports string conversion. But the good thing is that the library is extensible to support more scenarios. I will show a little example on how to extend the library with a CComVariant to String^ conversion.
CComVariant is an ATL wrapper for VARIANT. I'm not sure how many people used Variants in function declarations as passing parameters. I have done lot of COM development with focus on providing OLE Automation conform interfaces so I used it quite a lot.
Therefore I see some need in providing native Variant to managed type conversion. First we have to extend the marshaling library. This is pretty simple. I just provide two inline methods for the conversions I want to include, which are a CComVariant to String^ and a String^ to CComVariant conversion.
1: #include "StdAfx.h"
2: #include "MyVariantMarshal.h"
3:
4: namespace msclr
5: {
6: namespace interop
7: {
8: using namespace cli;
9: using namespace System;
10: using namespace System::Runtime::InteropServices;
11:
12: template<>
13: inline String^ marshal_as(const CComVariant& from)
14: {
15: if( from.bstrVal == NULL )
16: {
17: return nullptr;
18: }
19:
20: return Marshal::PtrToStringBSTR( IntPtr( from.bstrVal ) );
21: }
22:
23: template<>
24: inline CComVariant marshal_as(String^ const& from)
25: {
26: if( from == nullptr )
27: {
28: return CComVariant( static_cast<const wchar_t*>( NULL ) );
29: }
30:
31: if( from->Length == 0 )
32: {
33: return CComVariant( static_cast<const wchar_t*>( L"" ) );
34: }
35:
36: pin_ptr<const wchar_t> pinnedString = PtrToStringChars( from );
37: CComBSTR bstr( from->Length, static_cast<const wchar_t*>( pinnedString ) );
38: return CComVariant( bstr );
39: }
40: }
41: }
42:
That's it.
The following CLR console application is just reusing my templates and another example on how to make "Hello, world." complicated.
1: #include "stdafx.h"
2: #include "MyVariantMarshal.hpp"
4: using namespace System;
5: using namespace msclr::interop;
6:
7: int main(array<System::String ^> ^args)
8: {
9: String^ text = L"Hello, World.";
10:
11: CComVariant variant = marshal_as<CComVariant>(text);
12: String^ string = marshal_as<String^>(variant);
13:
14: Console::WriteLine( "{0}", string );
15:
16: return 0;
17: }
The point is that even the current implementation of the marshaling library is not providing more than string conversions it is a nice and clean implementation which can be easily extended.
In einem früheren Post habe ich bereits gezeigt das mit Visual Studio 2008 für die C++/CLI Welt eine Marshaling Library kommen wird. Mit Hilfe dieser ist es viel einfacher native Typen und managed Typen zu konvertieren. Das ganze hat nur einen kleinen Hacken: Momentan sind nur String Konvertierungen enthalten.
Das bleibt wahrscheinlich auch zum Release so, wobei ich hierzu noch keine offizielle Aussage gehört habe. Zum Glück lässt sich die Marshaling Library relativ einfach um eigene Anforderungen erweitern. Ob nun komplexere Strukturen oder einfach noch ein paar andere bereits existierende Datentypen wie zum Beispiel der CComVariant aus der ATL, die Erweiterbarkeit ist relativ gut dokumentiert.
In diesem kleinen Beispiel zeige ich wir man CComVariant nach String^ und umgekehrt konvertieren kann. Warum habe ich mich für diesen Datentypen entschieden? In früheren C++ Projekten hatte ich relativ viel mit COM zu tun und musste auch OLE Automation Clients unterstützen. In einem Produkt an dem ich mitgearbeitet habe war fast die gesamte Schnittstelle mit Variants bestückt. Ok, diese waren nicht nur einfach Strings, sondern enthielten SafeArrays die wiederrum Variants enthielten und so weiter (Anmerkung an mich selber: Benutze nächstes mal einfach XML auch wenn die Welt gegen Dich ist).
Zurück zum Beispiel. Hier die zwei inline Methoden zur Erweiterung der Funktionalität.
Ist eigentlich recht simpel. Danach noch eine kleine CLR Konsolenanwendung die demonstriert das die beiden Konvertierungen auch funktionieren.
Voilá!
Eine Zeile zum konvertieren im Verhältnis zu vorher kapselt die ganze Angelegenheit ganz gut weg. Durch den Erweiterungsmechnismus kann man die Bibliothek nach den Semantischen Vorgaben erweitern was an für sich eine schöne Sache ist.
Ich bin vor kurzem auf ein nettes Forum gestoßen welches Fragen rund zum Thema C++ behandelt. Dort gibt es auch eine Sektion zu C++/CLI.
Für jeden C++ Entwickler zu empfehlen: www.c-plusplus.de.