Links

• CodeProject: Top Ten Extensions for Visual Studio 2010

Links:

• Visual Studio 2010 – Community Wallpapers

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

Hier mal ein bischen Quick & Dirty für euch, wie man “Glassfenster” unter Windows 7 bzw. Windows Vista erstellt.

C#

Als erstes erstellt ihr eine Winform-Anwendung und deklariert folgende externe Funktionen.

[DllImport("dwmapi.dll", PreserveSig = false)]
public static extern void DwmExtendFrameIntoClientArea
(IntPtr hwnd, ref MARGINS margins);

[DllImport("dwmapi.dll", PreserveSig = false)]
public static extern bool DwmIsCompositionEnabled();

Außerdem braucht ihr diese Struktur.

[StructLayout(LayoutKind.Sequential)]
public struct MARGINS
{
 public int Left;
 public int Right;
 public int Top;
 public int Bottom;
}

Als Nächstes müsst ihr die “OnLoad”-Methode überschreiben.

protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
if (DwmIsCompositionEnabled())
{
 // Paint the glass effect.

 margins = new MARGINS();
 margins.Top = -1;
 margins.Left = -1;
 margins.Right = -1;
 margins.Bottom = -1;
 DwmExtendFrameIntoClientArea(this.Handle, ref margins);
 }
}

Zum Schluss noch “OnPaintBackground” überschreiben.

protected override void OnPaintBackground(PaintEventArgs e)
{
 base.OnPaintBackground(e);

 if (DwmIsCompositionEnabled())
 {
  // paint background black to enable include glass regions

  e.Graphics.Clear(Color.Black);
  // revert the non-glass rectangle back to it's original colour

  Rectangle clientArea = new Rectangle(
  margins.Left,
  margins.Top,
  this.ClientRectangle.Width - margins.Left - margins.Right,
  this.ClientRectangle.Height - margins.Top - margins.Bottom
  );
  Brush b = new SolidBrush(this.BackColor);
  e.Graphics.FillRectangle(b, clientArea);
 }
}

Fertig!

Download:

• AeroGlass_CSharp

Links:

• CodeProject-Artikel