So back to topic: What is this post about? Inspired by a small discussion in the Powerbuilder 12.5 beta newsgroup I created a small plugin to easily create some Structures and NonVisualObjects from a Datawindow.

This is very useful if you want to transfer data from or to a Datawindow by dot notation. If you have a lot of fields it can be a very painful job to create the Nonvisual and enter the variables in the correct order. Because of this Bruce Armstrong created a small tool called “Dw2Struct” that can do this for you in PB Classic. What I do is to extend the tool for NonVisuals and build a add-in around it.

So take a look at the code and the binaries. The Installation is easy. Just put it in a directory where Powerbuilder 12.5 .NET looks for add-ins. You can see what paths are observed by going to Extras->Options->Add-In. If you are not sure where to copy it, enter the path where you unpack the downloaded files. After restart the IDEs shows you two new entries in context menu of Datawindow. That’s it.

Have fun!

Links:

• PB-Addin-Dw2Struct.zip
• GitHub

Das neue Board befindet sich jetzt hier. Als Engine nutze ich das auf DotNetNuke basierende Vivo. Vivo selbst und die Community sind noch im Aufbau, weswegen es mit Sicherheit an der ein oder anderen Ecke haken wird. Also – Einfach mal reinschauen.

Links:

• www.powerbuilder.devbar.de
• vivo
• Ning

Links

• CodeProject: Top Ten Extensions for Visual Studio 2010

Das Schlüsselwor DYNAMIC gibt es in C# jetzt auch. Aber anstatt es, wie in Powerbuilder, vor die Methode oder den Event zu stellen wird es hier als Datentyp eingesetzt.

Powerbuilder:

powerobject  lpo_powerobject
n_test               lnv_test

lnv_test = CREATE n_test
lpo_powerobject = lnv_test
lpo_powerobject.DYNAMIC of_helloWorld ( )

C#

dynamic myobject;
myojbject = new TestA();
myobject.HelloWorld ( );

Das heißt natürlich im Umkehrschluss, dass man jetzt jede beliebige Methode als Aufruf programmieren kann ohne dass der Compiler aufmuckt. Ich würde sagen: Fluch und Segen

Daraus folgt aber auch, dass ich jede belibige Klasse unabhängig von Vererbungshierarchie in myObject füllen kann an der die Methode HelloWorld existiert.

Dieses Listing soll das Verhalten verdeutlichen:

static void Main(string[] args)
{
	dynamic work = null;

	work = new TestA();
	work.HelloWorld();

	work = new TestB();
	work.HelloWorld();

	Console.Read();

}

public class TestA
{
	public void HelloWorld()
	{
		Console.WriteLine("Hallo ich bin TestA");
	}
}

public class TestB
{
	public void HelloWorld()
	{
		Console.WriteLine("Hallo ich bin TestB");
	}
}

Fazit

Dynamic ist eine schöne Sache um späte Bindung zu vereinfachen. Früher oder später führt es aber, bei zu häufiger Anwendung, zum Chaos. Also: Immer Verantwortungsbewusst einsetzen

Links

• Coding4fun: Augmnented Reality Domino Knowk-Down Game
• Goblin XNA auf CodePlex

Aber jetzt kommt’s : 70 Euronen. Mein Herz hat geblutet . Das Buch ist zwar sein Geld Wert, aber trotzdem frag’ ich mich natürlich ob man nicht auch günstiger in’s Thema kommt. Vielleicht habt ihr ja einen Tipp.

Ansonsten würde ich es aber trotzdem weiterempfehlen.

Links:

• Amazon

Tuples erstellen

Um einen Tuple in C# zu erstellen benötigt man den Standardtyp Tuple. Die Tuple-Klasse hat 8 überladene statische Methoden mit dem Namen Create.

• Create (T1)
• Create(T1,T2)
• Create(T1,T2,T3)
• Create(T1,T2,T3,T4)
• Create(T1,T2,T3,T4,T5)
• Create(T1,T2,T3,T4,T5,T6,T7)
• Create(T1,T2,T3,T4,T5,T6,T7,T8)

Die Methoden geben folgende Datentypen zurück.

• Tuple<T1>
• Tuple<T1,T2>
• Tuple<T1,T2,T3>
• Tuple<T1,T2,T3,T4>
• Tuple<T1,T2,T3,T4,T5>
• Tuple<T1,T2,T3,T4,T5,T6>
• Tuple<T1,T2,T3,T4,T5,T6,T7>
• Tuple<T1,T2,T3,T4,T5,T6,T7,TRest…> ( alle Tuples > 8 wie das geht kommt noch )

Hier der Code um einen einfachen Tuple zu erstellen.

var album = Tuple.Create<string,int>("Rammstein", 2008);
Console.WriteLine(album);
Console.Read();

Die Ausgabe ist: (Rammstein, 2008)

Natürlich kann man auch auf einzelne Elemente zugreifen.

var album = Tuple.Create<string,int>("Rammstein", 2008);
Console.WriteLine("Band: {0}, Jahr: {1}", album.Item1, album.Item2);
Console.Read();

Die Ausgabe ist: Band: Rammstein, Jahr: 2008

Verschachtelte Tuples

Tuples lassen sich auch verschachteln.

var album = Tuple.Create("Rammstein", 2008,new Tuple<int,int>(1,2));
Console.WriteLine(album);
Console.Read();

Die Ausgabe ist: (Rammstein,(1,2))

Tuples > 8

Die Create-Methoden haben nur 8 Überladungen. Wenn man Tuples erstellen will, die größer als 8 Elemente sind, benutzt man den new-Operator.

var album = new Tuple<string, int, int, int, int, int, int,  Tuple<int, int>>("Rammstein", 1, 2, 3, 4, 5, 6, new  Tuple<int, int>(8, 9));
Console.WriteLine(album);
Console.Read();

Die Ausfabe ist: (Rammstein, 1, 2, 3, 4, 5, 6, 7, 8, 9)

Das direkte zugreifen auf die Elemente ist ebenfalls möglich.

var album = new Tuple<string, int, int, int, int, int, int, Tuple<int, int>>("Rammstein", 1, 2, 3, 4, 5, 6, new Tuple<int, int>(8, 9));
Console.WriteLine(album.Rest.Item1);
Console.Read();

Fazit

Hin und wieder kommt man in die Verlegenheit temporär Daten speichern zu müssen. Eine vernünftige Gruppierung hält den Code sauber und übersichtlich. Was man allerdings vermeiden sollte, ist das Verwenden von Tuples anstatt eines sauberen Klassenkonzepts. Wenn ich also meinen Album-Datentyp noch öfter brauchen werden, dann erstelle ich mir lieber eine Klasse mit sprechend benannten Attributen anstatt Item1 Item2, etc.

Und noch etwas zum Schluss: Die Frage die ich mir zu Anfang gestellt habe war, warum man hier mit der Begrenzung auf 8 Parameter arbeitet. Des Rätsels Lösung: C# unterstützt keine generischen Konstruktoren/Methoden mit unterschiedlichen Datentypen. Soll heißen, dass z.B Create nur generisch sein könnte, wenn es nur int-Werte nehmen würde. Das ergibt aber keinen Sinn, da man dann besser ein Array deklarieren könnte.

Wer also der englischen Sprache mächtig ist sollte hier zugreifen. Ich finde ~ 30 Euro für ein Fachbuch ist auch noch im sehr fairen Bereich.

Links:

• Amazon

Mir hat das Buch viele Erkenntnisse über meinen eigenen Programmierstil und Verbesserungsmöglichkeiten geliefert. Vererbung ist z.B. nicht immer der beste Weg und wie setzt man Interfaces sinnvoll ein.

Das Buch richtet sich zwar eher an Java-Entwickler aber wer C# kann, kommt auch sehr gut zurecht. Den reinen Powerbuilder-Entwicklern würde ich abraten. Viele Elemente (Interfaces, EventHandler, Enumarations, … ) gibt es in der Powerbuilder Classic nicht und in Powerbuilder .NET nur bedingt.

Kritikpunkt ist sicherlich der Preis, der mit Knapp 50 Euronen doch sehr happig ist. Ich habe die Investition aber nicht bereut.

Links:

• Amazon

Eines der interessantesten Features in Powerbuilder .NET ist die Verwendung von WPF (XAML) zur Definition der Benutzeroberfläche. Dabei ist es nicht nur möglich Controls auf dem Fenster mit XAML zu beschreiben, sondern auch innerhalb von Datawindows (Custom Control). In dieser kleinen Beispielanwendung bette ich ein 5-Sterne-Rating-XAML-Control zur Bewertung von Filmen in ein Datawindow ein und “binde” es an die enthaltenen Daten.

Überblick

Der Source und das Tool können hier heruntergeladen werden. Das Projekt besteht aus einem Fenster, einem Datawindow, ein paar Ressourcen und einem Assembly (RatingControlSample.dll). Das Assembly enthält  das Rating-Control, dass wir im Datawindow verwenden wollen (gefunden auf Nick Andersson’s Blog). Um mir die Arbeit ein wenig zu vereinfachen, habe ich mir ein External-Datawindow gebaut, das meine Filme enthält. Natürlich könnte hier auch eine Datenbank oder ein SOAP-Service als Datenquelle genutzt werden.

Vorgehensweise

Das Erstellen des Projekts, des Fensters und des Datawindows ist wie aus Powerbuilder Classic bekannt.

1. Das Assemly aufnehmen

Dafür sucht ihr im Navigator(links) den Bereich “References” und wählt “Add Reference”. Anschließend müsst ihr per “Browse” das gewünschte Assembly auswählen.

2. Das Custom Control hinzufügen

Wenn ihr im Datawindow-Painter seid, gibt es in eurer Toolbox einen Eintrag “Custom Control”. Zieht das Control auf das Datawindow und es öffnet sich ein neuer Dialog. Das Wichtige hier ist der XAML-Code, der eingefügt werden muss.

<RatingControl xmlns="clr-namespace:RatingControlSample;assembly=RatingControlSample" Width="87" Height="15" />

Die restlichen Felder kann man erstmal leer lassen.

3. Das Control mit den Datawindow verbinden

Um das Datawindow mit den Daten zu binden, sind folgende Eigenschaften des Controls wichtig:

• Table und Column: Dies ist die Tabelle und die Spalte die in das Control übergeben werden soll. Im Fall eines External-Datawindows muss nur Column gefüllt werden. In diesem Fall wird Column mit “rating” gefüllt.
• Content: Hier wird der Name der Property angegeben, in die der Wert aus “Column” geschrieben werden soll. Selbstverständlich müssen die Datentypen kompatibel sein. Für das Beispiel sollte hier “RatingValue” stehen, da die entsprechende Eigenschaft zum Einblenden der Sterne so heißt. Die Eigenschaft kann Werte von 1 bis 5 aufnehmen, je nachdem wieviele Sterne vergeben werden.
• Keyclause: Hier wird die Bedingung angegeben, die zum Laden der Tabelle genutzt werden soll. Ich brauche dies in meinem Beispiel eigentlich nicht, da ich auf ein External-Datawindow zurückgreife.
• XAML Syntax: Hier kann die in Schritt 2 eingegebene Syntax bearbeitet werden.

Wenn ihr das Datawindow verwendet, wird das Control entsprechend den Daten aus dem DW geladen. Wenn der Anwender die Anzahl der Sterne verändert, wird der entsprechende Wert in das Datawindow zurückgeschrieben.

Viel Spaß beim Ausprobieren

Links:

• MovieCat downloaden
• Nick Andersson’s Blog