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.
Ein frohes Fest an alle da draußen und einen guten Rutsch! In diesem Sinne, verabschiede ich mich in meinen Weihnachtsurlaub. Bis zum nächsten Jahr!Get your own at Gizmoz.com
Soeben wurde die zweite Podcast Episode in der Reihe "Dariusz quatscht - Die Podcast Show" veröffentlicht. Diesmal habe ich meinen Kollegen Bernhard Frank rund um das Thema "Tigerduck" interviewed. Was Tigerduck im einzelnen ist und ob Bernhard den kommenden Europameister 2008 richtig getippt hat, das alles kann man in dieser Episode erfahren.
Podcast #2 - Tigerduck
Momentan ist der Internet Explorer 8 in Entwicklung und schon gibt es in Richtung Standards Compliance Gute Nachrichten. IE8 besteht den Acid2 Test!
Der Acid2 Test zeichnet einfach ein Smiley indem er verschiedene Web Standards nutzt. Die meisten Browser haben hierbei Probleme. Das ganze Chaos kann man sich einfach mal anschauen wenn man mit einem IE7 oder IE6 diese Webseite besucht:
http://www.webstandards.org/action/acid2/
Und, seht Ihr ein Smiley?
Bei mir sieht das so aus:
Es gibt allerdings noch weitere Browser die diesen Test nicht bestehen. Die Gute Nachricht: IE8 besteht diesen Test und ist damit auf einen Kritikpunkt aller Webentwickler eingegangen.
Mehr dazu gibt es auf diesem Blog Eintrag (in Englisch).
So, ich habe nun das nervige Autostarten des Videos eliminiert, indem ich es ausgelagert habe. Wer es sucht findest es hier:
http://techfiles.de/dparys/videos/Marshaling/marshaling.htm
Nachdem ja Gott und die Welt über das Release von Visual Studio 2008 gebloggt hat, wer weiß, vielleicht auch Paris Hilton und andere Promis, dachte ich mir, ich poste mal das hier. Bin zufällig drüber gestolpert.
Visual Basic and C# Breaking Changes from Visual Studio 2005 to Visual Studio 2008
Man merkt das bald Weihnachten ist. Wie anders könnte man erklären das eine Entwicklungsumgebung für World of Warcraft AddOns rausgekommen ist? Endlich kann man seine geliebten Add-On Erweiterung für World of Warcraft in einer vernünftigen Entwicklungsumgebung erstellen. Neben einem Visuellen Designer gibt es nun auch einen LUA Editor, FrameXML Unterstützung und das Beste: Intellisense!
Hier ein kleiner Screenshot:
Das ganze wurde auf Basis der Visual Studio 2008 Shell erstellt, eine offene Plattform für Entwickler-Tools.
Einfach hier runterladen und ausprobieren.
AddOn Studio for World of Warcraft
Man sieht sich in Azeroth!
Durch Christian's Blogeintrag bin ich auf Microsoft Live Labs Volta aufmerksam geworden. Mit Volta soll es möglich sein Web Anwendungen Technologie-unabhängig zu entwickeln. Unabhängig von der eigentlichen Skript Implementierung, die man für verschiedene Browser berücksichtigen muss. Unabhängig dahingehend, dass man dynamisch entscheiden kann, ob alles in einem Prozess gehostet wird oder mehrere Tiers zur Verfügung stehen, man braucht sich nicht mal Gedanken über die Kommunikationsprotokolle zu machen. Man definiert lediglich Verhalten.
Wie macht Volta das? Volta ist in erster Linie ein Recompiler. Man programmiert ganz normal in seiner .NET Sprache der Wahl (momentan wird C# am besten unterstützt) und Volta rekompiliert dann die Anwendung auf die gewünschte Zielplatform. Hierbei setzt Volta nur auf das IL auf, also nicht auf den eigentlichen Source. In dem folgenden kleinen Beispiel wird die Anwendung dementsprechend auf JavaScript rekompiliert und im Browser lauffähig.
Die Installation integriert Volta in Visual Studio 2008 und stellt somit ein paar Projekttemplates zum Einstieg zur Verfügung. Mit dem Windows Forms Template konnte ich allerdings noch nichts anfangen, vielleicht hat ja jemand ein Beispiel dafür?
Die Solution für das kleine Beispielprojekt ist hier zu sehen und es wird eine VoltaPage angelegt. Ich konnte allerdings später kein dediziertes Page-Item Template finden, insofern einfach Klasse erschaffen und von Page ableiten.
VoltaPage1.cs ist die Klasse mit der Implementierung der Funktionalität. Das Design selbst findet sich in der entsprechenden Page.html Datei wieder. In Page.html werden einfach nur die Elemente definiert mit denen man später programmieren möchte.
1: <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
2: "http://www.w3.org/TR/html4/loose.dtd">
3: <html>
4: <head>
5: <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
6: <title>VoltaTest</title>
7: <link rel="shortcut icon" href="/favicon.ico"/>
8: <style type="text/css">
9: </style>
10: </head>
11: <body>
12: <input id="Button1" type="button" value="Zeige Ergebnis" />
13: <button id="async">
14: Async aufrufen!
15: </button>
16: <div id="output">
17: </div>
18: </body>
19: </html>
Die drei Elemente Input, Button und Div benutze ich in der VoltaPage1 Klasse. Zusätzlich wird dort noch ein Volta Custom Control VoltaControl1 mit geladen und dem Div Element hinzugefügt.
1: using System;
2: using Microsoft.LiveLabs.Volta.Html;
3:
4: namespace VoltaTest
5: {
6: public partial class VoltaPage1 : Page
7: {
8: Input submit;
9: Button async;
10: Div output;
11: Person person;
12:
13: VoltaControl1.VoltaControl1 myControl;
14:
15: public VoltaPage1()
16: {
17: InitializeComponent();
18: submit.Click += new HtmlEventHandler( btn_Click );
19: async.Click += new HtmlEventHandler( async_Click );
20: }
21:
22: partial void InitializeComponent()
23: {
24: submit = Document.GetById<Input>( "Button1" );
25: async = Document.GetById<Button>( "async" );
26: output = Document.GetById<Div>( "output" );
27: person = new Person();
28: myControl = new VoltaControl1.VoltaControl1();
29: output.AppendChild( myControl );
30: }
31:
32: void async_Click()
33: {
34: person.SayHelloWorld( msg =>
35: {
36: output.InnerText = "async: " + msg;
37: } );
38: }
39:
40: void btn_Click()
41: {
42: output.InnerText = person.SayHelloWorld();
43: MyLibrary.SayHelloToPerson( "Dariusz" );
44: }
45: }
46: }
Zeile 8-10 definiert die entsprechenden HTML Elemente. Zeile 11 ist die Klasse Person die im Projekt enthalten ist. Zeiler 13 ist das Volta Custom Control VoltaControl1. Das Custom Control selbst ist wiederum eine Klasse mit einem entsprechenden HTML Design in einem eigenen Assembly. Volta Controls sind Composite Controls. Wichtig ist das man in der Partial Method InitializeComponent() die jeweiligen HTML Elemente mittels des UI Objektmodells zuweist, so das man im späteren Verlauf auch damit arbeiten kann. Dies geschieht in Zeile 24 - 26. In Zeile 28-29 sieht man die Integration des Volta Custom Control welches einfach per AppendChild an ein HTML Element hinzugefügt wird.
Die Klasse Person besitzt weitere Volta-Spezifische Attribute. Zum einen eine Anweisung in einem Multi-Tier Szenario beim ersten Prozess zu bleiben RunAtOrigin, zum anderen das die Methode SayHelloWorld asynchron aufgerufen werden soll über Async.
2: using Microsoft.LiveLabs.Volta.MultiTier;
6: [RunAtOrigin]
7: public class Person
8: {
9: [Async]
10: public extern void SayHelloWorld( Callback<string> callback );
11:
12: public string SayHelloWorld()
13: {
14: return "Hello, world.";
15: }
16: }
17: }
Des wegen ist in Zeile 34-38 der Aufruf über einen delegate realisiert. In Zeile 43 wird zudem eine JavaScript Methode aufgerufen. Diese Methode ist in diesem Beispiel einfach intern über das Import Attribute deklariert.
2: using Microsoft.LiveLabs.Volta;
6: public class MyLibrary
8: [Import( "function helloPerson( personName ) { alert( 'Hello, ' + personName ); }" )]
9: public static extern void SayHelloToPerson( string personName );
10: }
11: }
Volta stellt also Interop Mechanismen von .NET => JavaScript und von JavaScript => .NET zur Verfügung. Genauso wie man Skripte importieren kann, lassen sich Funktionen auch nach JavaScript mittels des Export Attributes exportieren und in JavaScript nutzen.
In Volta kommt bereits eine Bibliothek für Virtual Earth mit, welches das JavaScript Model in .NET Klassen umsetzt und zur Verfügung stellt. Natürlich dynamisch.
Volta ist für mich ein weiterer faszinierender Ansatz, Technologie zu abstrahieren. Man darf gespannt sein, in welche Richtung sich das ganze entwickeln wird.
Einige Leser meines Blogs haben zu recht Beschwerde eingelegt. Es ist in der Tat nervig das die Videos die ich bisher publiziert hatte, immer automatisch starten. Ich habe das zwar nach dem publizieren auch festgestellt, aber nicht so recht gewußt wie man das abstellt.
Zum kodieren meiner Videos benutze ich momentan den Expression Encoder. Beim Encoder gibt es die Möglichkeit gleich einen Silverlight Player auszuwählen, in welchem das fertige Video gleich eingebunden und angezeigt wird.
Nach dem kodieren kann ich das Video gleich auf http://streaming.live.com publizieren und zur Verfügung stellen. Leider haben die Templates des Encoders alle ein AutoPlay Feature.
Nun habe ich meine Templates umgestellt. Das AutoPlay ist ein Attribute des MediaElements. Allerdings erstellen die Templates on-the-fly in JavaScript ein entsprechendes Objekt, welches die AutoPlay Eigenschaft auf true gesetzt bekommt.
Ich habe nun das entsprechende Expression Template im Dateisystem angepasst. Hierzu muss man die Datei StartPlayer.js editieren.
Hier ist der Auszug der Funktion. Die Stelle ist rot markiert.
Also, einfach autoPlay auf false setzen und die Videos werden nicht gleich gestartet. Das nächste Video benutzt definitiv dieses Template, Versprochen!
This is a short 18 minute presentation given by Ale Contenti on the Marshaling Library and STL/CLR. Enjoy!
Update: I removed the inline player and put in the link. I think it isn't annoying anymore to open up my blog.
Here is the link to the video
Im der nächsten C++ Standard Library wird unter anderem die shared_ptr Klasse zur Verfügung stehen. Diese Template Klasse kapselt jeden beliebigen Pointer und übernimmt die Verwaltung dieser. Läuft einmal ein Pointer Out-of-Scope, bzw. wird nicht mehr referenziert, so wird Automatisch das entsprechende Objekt gelöscht und, falls vorhanden der Destruktor aufgerufen. Die entsprechenden Resourcen werden wieder freigegeben.
In der folgenden Beispielklasse werden zwei Strings allokiert und beim löschen der Instanz auch wieder freigegeben. Hier der Code:
1: #include "StdAfx.h"
2: #include "Employee.h"
4: Employee::Employee(void)
6: this->lastname = new TCHAR[ 20 ];
7: this->firstname = new TCHAR[ 20 ];
8:
9: _tcscpy_s( this->lastname, 20, _T( "Parys" ) );
10: _tcscpy_s( this->firstname, 20, _T( "Dariusz" ) );
13: Employee::~Employee(void)
14: {
15: if( this->firstname != NULL )
17: delete this->firstname;
18: }
19: if( this->lastname != NULL )
20: {
21: delete this->lastname;
22: }
23: }
24:
25: TCHAR* Employee::GetFirstname()
26: {
27: return this->firstname;
28: }
29:
30: TCHAR* Employee::GetLastname()
31: {
32: return this->lastname;
33: }
Nutzt man die Employee Klasse so werden jedesmal die zwei internen Member allokiert. Vergisst man hierbei die Klasse korrekt zu löschen, so entstehen Memory-Leaks. Hier ein Beispiel das einen Memory-Leak erzeugt:
1: int _tmain(int argc, _TCHAR* argv[])
2: {
3: {
4: Employee* emp = new Employee();
5:
6: _tprintf_s( _T( "%s\n" ), emp->GetFirstname() );
7: _tprintf_s( _T( "%s\n" ), emp->GetLastname() );
8: }
9:
10:
11: return 0;
12: }
Da die Instanz nicht gelöscht wird, wird der Destruktor auch nicht aufgerufen und der allokierte Speicher nicht freigegeben.
Mit dem nächsten Update für Visual C++ 2008, Anfang des Jahres 2008, kommt eine erste Implementierung der nächsten C++ Standard Libraries, nämlich die Unterstützung des TR1 (Technical Report 1) Umfangs. Darin enthalten ist auch die shared_ptr<T> Klasse.
Das obige Beispiel sieht nun mit der shared_ptr<T> Klasse folgendermaßen aus:
1: #include "stdafx.h"
4: #include "memory"
5: using namespace std::tr1;
6:
7: int _tmain(int argc, _TCHAR* argv[])
9: {
10: shared_ptr< Employee > emp( new Employee() );
12: _tprintf_s( _T( "%s\n" ), emp->GetFirstname() );
13: _tprintf_s( _T( "%s\n" ), emp->GetLastname() );
14: }
15:
16: return 0;
In Zeile 4 und 5 wird die Klasse referenziert und steht entsprechend in Zeile 10 zur Verfügung. Läuft nun die Instanz Out-of-Scope wird automatisch der Destruktor aufgerufen, hier ein Auszug aus der shared_ptr<T> Implementierung:
1: void _Decref()
2: { // decrement reference count
3: if (_Rep != 0)
4: delete _Rep->_Decref();
5: }
Es wird intern mit einem Reference-Counting gearbeitet, ähnlich dem Verfahren des COM Smart Pointer _com_ptr_t.
Alles in allem eine schöne Erweiterung, die man mit Sicherheit auch schon selbst in seine eigenen Bibliotheken eingearbeitet hatte. Nun kommt dies endlich in den nächsten C++ Standard und die Zukunft scheint ein Memory-Leak Problem weniger zu haben.