Mit dem ICE macht Bahnfahren Spass
Ich gehöre ja zu den Menschen, die so gut wie nie weitere Entfernungen mit der Bahn fahren. Täglich fahre ich mit der Bahn zur Arbeit und wieder zurück, doch verbringe ich da maximal 15 Minuten im Zug (RE). Hier habe ich auch schon viele negative Erfahrungen mit der Bahn gesammelt und bin auch Zeuge geworden wie anderen Menschen ihre negativen Erfahrungen gemacht haben.
Doch während meiner kürzlichen Reise von Berlin nach Minden, konnte die Bahn wirklich viele Pluspunkte bei mir sammeln.
Für diese Fahrt habe ich mich für einen IC entschieden, mit dem ich von Berlin starten wollte. Doch leider (wie sollte es auch andres sein) habe ich den Zug um ca 1 Minute verpasst, wirklich sehr sehr ärgerlich, wenn man seinen Zug bei der Abfahrt vom Bahnsteig beobachten kann, und dazu kam noch, dass der nächste IC (mit den gleichen Anschlusszügen) erst wieder in ein paar Stunden fuhr.
Dann bin ich also mit einem enormen FFFFUUUU-Gesicht zum Info-Schalter der Bahn gegangen - doch hier begann für mich die Überraschung.
Die Dame an dem Info-Schalter hat mein Problem sofort verstanden, und kurz in ihrem Computer rum getippt - keine 10 Minuten später saß ich in einem ICE der in die selbe Richtung fuhr. Die zweite Überraschung kam dann, als der Schaffner kam und ich mein Ticket nachlösen wollte.
Der Schaffner, in meinem Fall sogar eine Schaffnerin, hat sich meine Leidensgeschichte 
angehört und hat mich ohne eine weitere Zuzahlung mitfahren lassen. Auch wenn die Zuzahlung die 30 Eur wohl nicht überschritten hätte, fand ich es trotzdem sehr überraschend, dass hier so menschlich und kulant gehandelt wurde, da bin ich aus meinem Bahnalltag und auch aus dem Medien wirklich anderes gewohnt.
Ich weiß hier natürlich nicht ob es immer so ist oder ich nur Glück hatte und eine nette Schaffnerin erwischt habe (wobei ich es nicht glaube). Aber so wie es momentan aussieht denke ich, dass die Menschlichkeit und teilweise auch die Freundlichkeit des Bahnpersonals in den ICE/IC Zügen eingesperrt ist. - Schade eigentlich!
XML: Den Namen eines XmlNode Aendern
Wenn man unter .NET mit XML Dokumenten arbeitet, nimmt man sehr oft Änderungen am Dokument vor. Doch letztens ist mir aufgefallen, dass eine der einfachsten Änderungen garnicht so einfach ist, nämlich wenn man den Namen eines XmlNode ändern will. Also die XmlNode.Name Eigenschaft.
Denn wenn man mal einen Blick ins MSDN wirft wird man feststellen, dass diese Eigenschaft read-only ist! Das ist natürlich blöd, da man nun keinen einfachen Weg hat den Namen des Knotens zu ändern.
Wenn man diesen aber unbedingt ändern will muss man das über einen kleinen Umweg machen. Man muss ein neues XmlElement erstellen und dabei den Namen ändern, anschließend noch alle Attribute und Kinder-Elemente des alten Elements übernehmen und an der Stelle des alten wieder in das XmlDocument einfügen.
Bild 1: Struktur & Änderungswunsch
Konkret sieht das Ganze so aus: C#
private void Form1_Load(object sender, EventArgs e) {
//XmlDomument erstellen und eine Xml-Datei laden
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(Application.StartupPath + "\\xml.xml");
//Zur Demonstration die alte XML-Struktur ausgeben
System.Console.WriteLine(xmlDoc.OuterXml);
//Das Element das umbenannt werden soll heraussuchen
XmlElement oldElement = (XmlElement)xmlDoc.GetElementsByTagName("books")[0];
//Das herausgesuchte Element mit einem neuen Namen klonen
XmlElement newElement = renameXmlElement(oldElement, "my-books");
//Das alte Element mit dem neuen ersetzen
oldElement.ParentNode.ReplaceChild(newElement, oldElement);
//Kontrolle: Die neue Struktur ausgeben
System.Console.WriteLine(xmlDoc.OuterXml);
xmlDoc.Save(Application.StartupPath + "\\xml.xml");
}
public static XmlElement renameXmlElement(XmlElement e, string newname) {
//Neues XmlElement mit neuem namen anlegen
XmlElement newElement = e.OwnerDocument.CreateElement(newname);
//Dem neuen XmlElement alle Attribute des alten Elements übergeben
foreach (XmlAttribute a in e.Attributes) {
newElement.SetAttributeNode((XmlAttribute)a);
}
//Dem neuen XmlElement alle Kinder Elemente des alten Elements anhängen
foreach (XmlNode n in e.ChildNodes) {
newElement.AppendChild(n.Clone());
}
//Das neue XmlElement zurückgeben
return newElement;
}
Und hier das Ganze noch mal in VB.NET:
Private Sub Form1_Load(sender As Object, e As EventArgs)
'XmlDomument erstellen und eine Xml-Datei laden
Dim xmlDoc As New XmlDocument()
xmlDoc.Load(Application.StartupPath + "\xml.xml")
'Zur Demonstration die alte XML-Struktur ausgeben
System.Console.WriteLine(xmlDoc.OuterXml)
'Das Element das umbenannt werden soll heraussuchen
Dim oldElement As XmlElement = DirectCast(xmlDoc.GetElementsByTagName("books")(0), XmlElement)
'Das herausgesuchte Element mit einem neuen Namen klonen
Dim newElement As XmlElement = renameXmlElement(oldElement, "my-books")
'Das alte Element mit dem neuen ersetzen
oldElement.ParentNode.ReplaceChild(newElement, oldElement)
'Kontrolle: Die neue Struktur ausgeben
System.Console.WriteLine(xmlDoc.OuterXml)
xmlDoc.Save(Application.StartupPath + "\xml.xml")
End Sub
Public Shared Function renameXmlElement(e As XmlElement, newname As String) As XmlElement
'Neues XmlElement mit neuem namen anlegen
Dim newElement As XmlElement = e.OwnerDocument.CreateElement(newname)
'Dem neuen XmlElement alle Attribute des alten Elements übergeben
For Each a As XmlAttribute In e.Attributes
newElement.SetAttributeNode(DirectCast(a, XmlAttribute))
Next
'Dem neuen XmlElement alle Kinder Elemente des alten Elements anhängen
For Each n As XmlNode In e.ChildNodes
newElement.AppendChild(n.Clone())
Next
'Das neue XmlElement zurückgeben
Return newElement
End Function
Kompliziert ist es natürlich nicht, aber trotzdem etwas ärgerlich, dass man diese Methode dann doch selber implementieren muss.
Windows Aero Glas in eigenen Projekten Nutzen Teil 5 – Der letzte Versuch
In den letzten Tagen habe ich mal wieder ein wenig mit der Windows API herumgespielt, speziell mit der Aero Glas API (DWMAPI). Ich habe euch ja auch noch versprochen einen Beitrag über Steuerelemente in Verbindung mit Glas nachzuliefern. Nunja hier ist er 
Bild 1: Probleme mit der Transparenz
In Bild 1 sehen wir das Problem, viele der Windows Forms Steuerelemente nutzen GDI zur Darstellung und haben deswegen keinen Alpha-Kanal, der aber für die Darstellung auf Glas benötigt wird. Deswegen nutzen wir die Schwarze Farbe um unsere Fläche in Glas zu verwandeln, leider denkt der DWM dann, dass auch die Texte auf unseren Steuerelementen zu Glas werden sollen.
Ich habe mich nun ein wenig im Internet umgehört und verschiedene Ansätze gefunden und diverse Hacks mit der Windows32API Ausprobiert, die aber alle leider nicht mehr funktionieren. So will ich euch heute zwei Möglichkeiten vorstellen wie man es doch hinkriegen könnte.
1. Owner Drawing
Da die Steuerelemente mit GDI gerendert werden haben wir ein kleines Problem wie man oben sieht. Also müssen wir die Darstellung der Steuerelemente selbst in die Hand nehmen. Dieser Vorgang nennt sich OwnerDrawing und bedeutet soviel wie "SelberZeichnen". Ich will das Ganze mal anhand einer Textbox demonstrieren.
Und genauso ist auch das Vorgehen. Wir erstellen eine neue Klasse und nennen Sie "AeroTextBox". Diese Klasse erbt nun von der Original TextBox. Nun müssen wir ein paar kleine Änderungen an der Klasse vornehmen in Bezug auf die Darstellung, also des WM_PAINT Ereignisses.
Da wir das Zeichnen des Steuerelements selbst in die Hand nehmen wollen müssen wir die WM_PAINT Message abfangen und auf unsere eigene Methode umleiten:
C#
protected override void WndProc(ref System.Windows.Forms.Message m)
{
base.WndProc( ref m);
switch (m.Msg)
{
case 0xf: //WM_PAINT
RedrawControlAsBitmap(this.Handle);
break;
}
}
VB.NET
Protected Overrides Sub WndProc(ByRef m As System.Windows.Forms.Message) MyBase.WndProc(m) Select Case m.Msg Case &Hf 'WM_PAINT RedrawControlAsBitmap(Me.Handle) Exit Select End Select End Sub
Wie man sieht fangen wir hier die Message ab und rufen unsere eigene Methode auf, die das Zeichnen übernehmen wird:
C#
public void RedrawControlAsBitmap(IntPtr hwnd)
{
Control c = Control.FromHandle(hwnd);
using (Bitmap bm = new Bitmap(c.Width, c.Height))
{
c.DrawToBitmap(bm, c.ClientRectangle);
using (Graphics g = c.CreateGraphics())
{
g.DrawImage(bm, new Point(-1, -1));
}
}
c = null;
}
VB.NET
Public Sub RedrawControlAsBitmap(hwnd As IntPtr) Dim c As Control = Control.FromHandle(hwnd) Using bm As New Bitmap(c.Width, c.Height) c.DrawToBitmap(bm, c.ClientRectangle) Using g As Graphics = c.CreateGraphics() g.DrawImage(bm, New Point(-1, -1)) End Using End Using c = Nothing End Sub
Was hier passiert ist eigentlich sehr simpel, wir zeichnen das Control neu und legen das gezeichnete Bild nun über das Control drüber. Nur diesmal machen wir das ganze mit einem Alpha Kanal, sodass der DWM uns die Darstellung nicht versaut!
Nun bleibt noch ein kleines Problem, nämlich dass bei manchen Aktionen des Benutzers wie zB. bei MouseOver oder KeyPress Events das Steuerelement neugezeichnet wird und unsere Funktion da oben nicht greift. Hier müssen wir manuell dafür sorgen, dass Windows erneut die WM_PAINT Message versendet. Das erreichen wir indem wir die einzelnen Events überschreiben und die Invalidate()-Methode aufrufen. Diese Methode erklärt die ganze Oberfläche des Steuerelements für ungültig und bewirkt, dass das Steuerelement neu gezeichnet wird.
C#
protected override void OnMouseClick(System.Windows.Forms.MouseEventArgs e)
{
base.OnMouseClick(e);
Invalidate();
}
protected override void OnMouseMove(System.Windows.Forms.MouseEventArgs e)
{
base.OnMouseMove(e);
Invalidate();
}
protected override void OnTextChanged(System.EventArgs e)
{
base.OnTextChanged(e);
Invalidate();
}
protected override void OnMouseEnter(System.EventArgs e)
{
base.OnMouseEnter(e);
Invalidate();
}
VB.NET
Protected Overrides Sub OnMouseClick(e As System.Windows.Forms.MouseEventArgs) MyBase.OnMouseClick(e) Invalidate() End Sub Protected Overrides Sub OnMouseMove(e As System.Windows.Forms.MouseEventArgs) MyBase.OnMouseMove(e) Invalidate() End Sub Protected Overrides Sub OnTextChanged(e As System.EventArgs) MyBase.OnTextChanged(e) Invalidate() End Sub Protected Overrides Sub OnMouseEnter(e As System.EventArgs) MyBase.OnMouseEnter(e) Invalidate() End Sub
Nun wird das Control richtig dargestellt. Wie ihr vielleicht auch gesehen habt haben wir in unserer Methode, die für das Neuzeichnen verantwortlich ist nicht TextBox sondern die Superklasse Control benutzt. Das bedeutet für uns, dass wir mit diesem Code jedes Steuerelement ableiten und auf diese Weise neuzeichnen können mit mehr oder weniger viel Erfolg. Ich habe mal ein paar Klassen abgeleitet und für euch auf dem Glass-Form platziert:
Bild 2: Die OwnerDrawn Steuerelemente
Wie man sieht ist das schon eine sehr vielversprechende Verbesserung der Darstellung, wenn auch nicht perfekt. Aber natürlich steht es euch noch frei die Darstellung weiter zu verbessern und auf die einzelnen Steuerelemente anzupassen.
Nachdem ihr die selbst erstellten Klassen die von den einzelnen Steuerelementen erben einmal kompiliert habt, wird Visual Studio dies bemerken und euch diese neuen Steuerelemente zusammen mit den anderen in der Toolbox anbieten. Diese können dann wie gewohnt per Drag & Drop auf das Formular gezogen werden.
Bild 3: Bequemer Gehts nicht
Wie ihr euch vorstellen könnt ist es ein ziemlicher Aufwand jedes Steuerelement noch mal neu anzulegen und dessen komplette Darstellung zu übernehmen. Es ist wirklich sehr frickelig! Deswegen wird dieser Ansatz auch eher selten verwendet! Die Demo dazu könnt ihr euch übrigens am Ende des Artikels herunterladen.
Variante 2. "The Microsoft Way"
Natürlich stolpert man irgendwann bei der Recherche über das Windows API SDK in dem es einige Beispiele dazu gibt wie man die neuen Funktionen in Windows benutzt, darunter natürlich auch Glas.
Der Ansatz den Microsoft da aber nach ihrer eigenen Best Practise verwendet ist aber eher ernüchternd. Hier geht es nach dem Motto, platziert einfach keine Steuerelemente auf dem Glas! - Super nicht?
In dem einzigen Beispiel das Microsoft da aufführt wird eine Form gezeigt, dessen Rahmen in das Formular bis zum darauf liegendem Panel erweitert wurde, nicht wirklich spannend. Aber wenn ich so überlege, fällt mit spontan auch kein Windows Programm auf, bei dem irgendwelche Steuerelemente auf dem Glas liegen - kennt ihr welche? In dem meisten Programmen liegen fast nur Grafiken auf dem Glas oder so ähnliche Controls wie die im Windows Explorer.
Also sage ich es mal Microsofts Worten: lasst die Controls vom Glas weg oder benutzt WPF!
Hier noch die Demo zu der Variante 1: Download [VS 2008 Projekt]
Zur zweiten Variante habe ich keine Demo gemacht, ihr könnt euch ja das Windows API SDK herunterladen und dort im Aero Ordner nachgucken.
Twitter? Ihhhhh…
Ach ja, ihr kennt es (zumindest wenn ihr bei Twitter seid), man spricht mit Kollegen und oder Bekannten die vielleicht nicht so nerdig internet versiert sind wie man selbst und erwähnt in einem Nebensatz Twitter. Ups, da ist es passiert...
Und schon gehts los, man bekommt einen mysteriösen Blick zugeworfen und wird von oben bis unten noch mal gemustert als ob man soeben den Holocaust geleugnet hat. - Nein, so schlimm ist es natürlich nicht - aber ein gewisses Lachen kann sich die andere Person dann doch nicht verkneifen.
"Twitter? Das ist doch diese Seite wo alle drauf schreiben, was sie grade gegessen haben und ob sie grade Durchfall haben"
Und meißt kommt dann auch noch sowas ähnliches hinterher:
"Warum bist du da denn angemeldet? Die genzen Sachen gehen fremde Leute doch nix an - also für mich wär das nichts!"
Mit so ähnlichen Szenen werde ich monatlich ca. 2 - 3 mal konfrontiert, und ich habe blöderweise immer noch keinen Weg gefunden einem ungläubigen Gelegenheitssurfer den Sinn von Twitter kurz und überzeugend zu erläutern.
Es sind meist diese Leute, die möglichst keine privaten Informationen über sich im Internet verraten wollen aber fröhlich auf jeden "Like" bzw. "Gefällt mir" Button klicken und auf allen Plattformen alá Facebook und StudiVZ angemeldet sind und lauter Fotos von sich hochladen bei denen man total betrunken irgendwo in einen Busch kotzt.
"Das ist ja was ganz anderes" Kommt dann als Antwort wenn man diese Personen darauf hinweist. - Ja ne, is klar!
Leider ist das genau das Bild was Otto Normalbürger von Twitter im Kopf hat, wobei man fairer Weise sagen muss, dass dieses Bild auch nicht wirklich falsch ist - leider! Denn genauso hat Twitter angefangen, man hat stolz sein Frühstück fotografiert und es der Welt präsentiert. (Arnold Schwarzenegger machts vor)
Doch Twitter hat sich schon lange gewandelt, und ist zurzeit die am schnellsten Wachsende Suchmaschine der Welt. Nirgends findet man schneller aktuellere Informationen zu allen Themen. Die Menge ist hier der natürliche Filter, wenn es darum geht Wichtiges von Unwichtigem zu trennen und durch Retweets die interessanten Dinge an die Oberfläche zu spülen.
Das sind dann einige der Argumente mit denen ich versuche einer Person Twitter zu erklären, doch diese Argumente ziehen nicht. "Ich habe meine Seiten wie Stern oder Heise auf denen ich mich informiere und die liefern mir die Infos auch schnell genug!"
Argh! Egal es ist ja nicht mein Job den Eingeborenen Leuten das große Internet zu erklären.
Für mich persönlich ist Twitter inzwischen zu dem wichtigsten Dienst mutiert. Es ist schon fast ein Reflex geworden die Twitter-App zu starten wenn man grade das Handy in der Hand hat um schnell mal zu schauen, was es so neues gibt.
Ich folge vielen Leuten, die in der selben Branche tätig sind wie ich und von denen ich schon viel gelernt habe oder durch ihre Tweets an viele interessante Dinge gekommen bin, genauso wie meine Follower durch mich. (Hoffe ich zumindest )
Und ja, ab und zu rutscht mir auch der ein oder andere Tweet raus darüber was ich gegessen habe, man muss ja schließlich die Tradition beibehalten - back to the roots!
Wie schauts bei euch aus? Wie erklärt ihr euren Bekannten was Twitter ist und warum ihr dieses Teufelszeug es benutzt? Vielleicht habt ihr ja ein paar Tipps, sodass ich bei der nächsten Debatte deutlich gewinne!
Goodbye VB.NET hallo C#
Es ist seltsam, wie man sich mit der Zeit entwickelt. Vielleicht ist es euch auch währen der letzten Beiträge auch aufgefallen. Nach fast einem Jahrzehnt bin ich nun von VB.NET auf C# umgestiegen, und möchte auch garnicht mehr zurück.
Der Umstieg ist bei mir aber nicht zufällig gekommen. Aktuell arbeite ich auch Beruflich immer öfter auch in Java Projekten mit und muss mich dann immer komplett umstellen was die Syntax angeht. Dies war immer besonders ärgerlich! Mit C# habe ich mich bis vor ein paar Monaten nie wirklich beschäftigt, ich wusste dass es existierte aber mehr auch nicht.
Die ersten Umstieggedanken kamen bei mir als ich Hilfe im Netz zu etwas komplexeren Themen gesucht habe. Da musste ich schnell feststellen, dass das eine C# Domäne war. Man findet nur wenig Support in VB.NET, obwohl es eigentlich die selbe Sprache ist.
Das Problem ist auch, dass VB eine Sprache ist, die damals für Anfänger entwickelt wurde und es DIE Sprache ist wenn es darum geht mit den Programmieren anzufangen. Was nichts schlimmes ist, aber dem entsprechend sind auch alle VB-Foren überfüllt mit Anfängern, die statt ein Buch zu lesen jede Kleinigkeit nachfragen und fertigen Code zum C&P erwarten.
Wer ein Beispiel sucht sollte hier, hier oder hier mal gucken...
Aber das war nicht der Hauptgrund für mich zum Wechseln, wie gesagt bot es sich an, da ich öfters mal mit Java in Kontakt komme, aber auch ein weiterer wichtiger Punkt spielte eine große Rolle.
Die Schreibarbeit
Denn der Visual Basic Code ist sehr viel umfangreicher, da fast alles ausgeschrieben wird und somit fast richtige Sätze entstehen. Das ist für Anfänger gut, aber wenn man länger damit arbeitet dann macht diese enorme Tipperei einen wirklich fertig, das macht dann auch Visual Studios IntelliSense auch nur wenig erträglicher. Zumahl habe ich die Erfahrung gemacht, dass je anspruchsvoller ein Projekt mit der Zeit wird desto komplexer wird auch die Syntax von VB.
Diese einfache C-Ähnliche Syntax geht einfach viel schneller und angenehmer von den Händen. Jaja, natürlich ist das alles Geschmackssache, ich will hier ja auch niemanden überzeugen, sondern einfach nur meine Gedanken dazu schreiben.
Trotzdem will ich hier die Frage in den Raum stellen, welche der beiden Sprachen ihr lieber benutzt und was eure Argumente für oder gegen "eure" Sprache sind. Nebenbei habe ich hier rechts in der Seitenleiste eine kleine Umfrage gestartet, da könnt ihr ja mal mit abstimmen!
Die Zukunft
Vielleicht werde ich die Nächsten Tutorials auch Bi-Lingual verfassen, aber im Verlauf der Zeit werden wohl alle Beispiele hier in C# sein.
Übrigens: Im web gibt es viele Anbieter, die web basierte Übersetzungstools für VB.NET zu C# und umgekehrt anbieten. Diese wandeln den Code zu ca 90% zuverlässig in die jeweils andere Sprache um, es sind nur noch kleine kosmetische Eingriffe nötig. Ich benutze da gerne den Converter von Developerfusion
Microsoft SQL CE: Blobs Speichern und auslesen
In diesem kleinem Tutorial möchte ich euch zeigen, wie man BLOBs (Binary Large Objects) in die Compact Edition vom Microsofts SQL Server speichern und wieder laden kann. Dies soll eine Art Weiterführung von dem letzten Einstiegspost sein. Ich kann euch aber nicht versprechen, dass noch weitere Beiträge zu dem Thema kommen werden.
Auch wen Relationale Datenbanken überwiegend dazu benutzt werden um Text-Basierte Informationen zu speichern, wie Benutzernamen, IP Adressen oder andere Texte, kommt es doch häufiger vor, dass man auch Dateien wie Bilder in eine Datenbank legen möchte. Dies ist zB. nützlich wenn man eine Benutzerdatenbank hat und zu jedem Benutzer ein Bild hinterlegen will.
Das Vorgehen an Sich ist dabei sehr ähnlich, ihr erstellt ein SqlCeCommand und fügt dem wie gewohnt einige Parameter hinzu:
using (SqlCeConnection con = new SqlCeConnection(conString)) {
con.Open();
using (SqlCeCommand com = new SqlCeCommand
("INSERT INTO cp_image (date, image) VALUES (@Date, @Filename)", con)) {
com.Parameters.AddWithValue("@Date", DateTime.Now.ToString());
com.Parameters.AddWithValue("@Filename",
System.IO.File.ReadAllBytes(filename)).SqlDbType = SqlDbType.Image;
com.ExecuteNonQuery();
}
}
Absolut nichts neues wie ihr sehen könnt, wir geben die Datei, die wir anhängen wollen einfach als byte-Array als Parameter mit.
Sehr wichtig ist hierbei folgende Stelle in Zeile 8:
.SqlDbType = SqlDbType.Image;
Wenn ihr diese Information nicht mit angebt, werdet ihr Probleme bekommen, sobald ihr eine Datei in die Datenbank schreiben wollt die größer ist als 8 KB!!! Denn wenn man einen Parameter angibt ohne dessen Typ mit anzugeben versucht SQLCE den Typ selbst zu bestimmen und wählt dazu dann den Typ varbinary, dessen Größe auf 8000 Byte beschränkt ist!
Mit dem Ausführen des SqlCeCommands sollte die Datei bzw. das Bild in diesem Fall dann in eure Datenbank Datei wandern.
Das Auslesen der Datei aus der Datenbank gestaltet sich ebenfalls nicht kompliziert. Hier meine Funktion um ein Bild aus der Datenbank zu lesen:
public Image getImageFromDB(int id) {
Image img;
byte[] imgData = null;
using (SqlCeConnection con = new SqlCeConnection(conString)) {
con.Open();
using (SqlCeCommand com = new SqlCeCommand
("SELECT image FROM cp_image WHERE id = '" + id.ToString() + "'", con)) {
using (SqlCeDataReader dr = com.ExecuteReader()) {
while (dr.Read()) {
imgData = (byte[])dr["image"];
}
}
}
}
if (imgData != null) {
//Es wurde ein Bild geladen
MemoryStream ms = new MemoryStream(imgData);
img = Image.FromStream(ms);
return img;
}
return null;
}
Dazu benutze ich einfach nur einen gewöhnlichen DataAdapter, mit dem ich aus der Spalte namens "image" die Bildinformationen auslese, diese müssen noch in ein byte-Array gecastet werden, da diese als Object geliefert werden.
Zum Schluss wird noch das Byte-Array in ein System.Drawing.Image verwandelt und zurückgegeben. Dies kann man dann zB. direkt in eine PictureBox laden.
Hier ist die Tabelle, die ich in diesem Beispiel benutzt habe:
Bild 1: Tabelleninformationen
Wie ihr eine Verbindung zur Datenbank herstellt und normale Select- und Insert-Befehle benutzt könnt ihr im Ersten Teil nachlesen.
Windows Aero Glas in eigenen Projekten Nutzen Teil 4 – Formulare ohne Border
Dieses Thema hatten wir hier schon oft, und trotzdem gibt es immer noch was neues zu berichten. Windows Forms Fenster stellen sich ganz schön an wenn es darum geht ihre Steuerelemente und sich selbst richtig darzustellen, zu den Steuerelementen wird bald ein Teil 5 (und hoffentlich der letzte) kommen, hier geht es jetzt erst einmal um das (Boderlose) Formular an sich.
Wenn ihr nämlich mal versucht habt ein Windows Form Formular ohne Border (FormBorderStyle=None) mit der mit Glas-Optik zu nutzen habt ihr wohl innerhalb kürzester Zeit feststellen müssen, dass es nicht geht. Warum ist das so?
Nun, ich denke die meisten von euch benutzen die Win32API Funktion DwmExtendFrameIntoClient um das Fenster in eine Glasscheibe zu verwandeln - was auch vollkommen richtig ist, nur wenn man sich den Namen der Funktion durchließt wird man feststellen, dass deren Aufgabe es ist das Frame (den Rahmen) auf das Formular zu erweitern, was auch super funktioniert, solange man einen Rahmen hat. Stellt man nun aber die Eigenschaft FormBorderStyle auf None, hat die Form keinen Rahmen mehr und dementsprechend kann man diesen auch nicht in die Form erweitern.
Was nun? Es muss doch irgendwie gehen!
Natürlich geht das, dazu müssen wir nur eine andere DWM Funktion aus der Win32API Verwenden, nämlich DwmEnableBlurBehindWindow. Diese Funktion macht genau das selbe, nämlich einen definierten Bereich des Formulars in Glas verwandeln.
Aber diese Funktion bietet noch mehr Spielereien, so kann man auch geometrische Figuren in Glas verwandeln oder nur bestimmte Teile einer Form verglasen. Siehe folgende Bilder:
Bild 1: Ein Paar der Möglichkeiten das Glas zu verteilen. (Natürlich kann man den FormBorderStyle auch auf None stellen, dann würde einfach nur der Rahmen fehlen)
Dazu benötigen wir folgenden Code. 1: Das Befüllen des Fensterinhalts mit Glas:
//Import der nötigen Funktion aus der DLL
[System.Runtime.InteropServices.DllImport("dwmapi")]
private static extern int DwmEnableBlurBehindWindow(
System.IntPtr hWnd, ref DWM_BLURBEHIND pBlurBehind);
//Funktion um ein Rechtek auf dem Formular zu malen
[System.Runtime.InteropServices.DllImport("gdi32.dll")]
static extern IntPtr CreateRectRgn(int x1, int y1, int x2, int y2);
Wie ihr sehen könnt, ist der Letzte Parameter vom Typ DWM_BLURBEHIND - dies ist ein Struct, welches wir nun erstmal anlegen müssen. (Auf die zweite Funktion komme ich gleich zu sprechen)
public struct DWM_BLURBEHIND
{
public int dwFlags;
public bool fEnable;
public System.IntPtr hRgnBlur;//HRGN
public bool fTransitionOnMaximized;
}
Nun müssen wir nur noch das Struct anlegen, mit Parametern füllen und der Funktion übergeben:
private void Form1_Load(object sender, EventArgs e)
{
//Das Rechteck vorbereiten, dieses soll so groß sein
//wie die Fläche die mit Glas befüllt werde soll
//in diesem Fall soll es die gesamte Form füllen
hr = CreateRectRgn(0, 0, this.Width, this.Height);
//Anlegen des Scructs
DWM_BLURBEHIND dbb;
dbb.fEnable = true;
dbb.dwFlags = 1 | 2; //Konstanten mehr in der API
dbb.hRgnBlur = hr;
dbb.fTransitionOnMaximized = true;
//Aufruf der Funktion
DwmEnableBlurBehindWindow(this.Handle, ref dbb);
}
Zum Schluss sollte man noch dafür sorgen, dass die Form schwarz bemalt wird, damit wir das Glas überhaupt zu Gesicht bekommen. Hierfür überschreiben wir einfach die OnPaintBackground Methode der Form:
protected override void OnPaintBackground(System.Windows.Forms.PaintEventArgs e)
{
e.Graphics.FillRectangle(
new System.Drawing.SolidBrush(System.Drawing.Color.Black),
this.ClientRectangle);
}
Das war es auch schon, gar nicht mal so komplex finde ich. Wenn ihr das Rechte Bild aus Bild 1 erzeugen wollt geht ihr genauso vor nur benutzt ihr eine andere Funktion im die Fläche für das Glas anzugeben:
[System.Runtime.InteropServices.DllImport("gdi32")]
private static extern System.IntPtr CreateEllipticRgn(
int nLeftRect, int nTopRect, int nRightRect, int nBottomRect);
Mit dieser Funktion lassen sich Elliptische Figuren malen, um diese zu verwenden einfach die Zuweisungs Zeile ersetzen:
hr = CreateEllipticRgn(30, 30, 170, 170);
Natürlich kann man auch den Border deaktivieren, um einfach nur die reine Clientoberfläche des Formulars zu bekommen:
Bild 2: Sieht nicht allzu spannend aus
Wie man sieht haben wir nun das was wir wollten, nur hebt das Fenster sich kaum vom Hintergrund ab, obwohl es aktiv ist. Leider können wir dem Formular keinen so schönen Schatten geben wie man es von Windows Vista/7 gewohnt ist, da es keinen Rahmen hat. Wenn man das Formular dennoch etwas hervorheben will, kann man das machen in dem man eine Grafik mit einem Transparentem Verlauf auf der Form platziert und somit den Schatten emuliert, oder man benutzt einen kleinen Trick und weist dem Formular den Schatten der Windows Menüs zu:
private const int CS_DROPSHADOW = 0x00020000;
protected override CreateParams CreateParams
{
get
{
CreateParams p = base.CreateParams;
p.ClassStyle |= CS_DROPSHADOW;
return p;
}
}
Hier überschreiben wir die CreateParams und sagen, dass das Formular einen Schatten werfen soll. Das ganze sieht dann so aus:
Bild 3: Der Schatten hebt das Fenster etwas vom Hintergrund ab
Diesen Schatten sollte man aber mit Vorsicht genießen, denn das ist der Schatten der Windows Menüs. (Der kommt wenn ihr zB. in irgendeinem Programm auf "Datei" klickt, das erscheinende Menü wird diesen Schatten haben.) Diesen kann man in den Einstellungen deaktivieren, also bitte achten dass der folgende Haken gesetzt ist:
Bild 4: Aktivieren der Menüschatten
Soviel dazu, ich hoffe dieser Artikel hat euch gefallen oder konnte euch weiter helfen, wie oben erwähnt werde ich in den nächsten Tagen einen 5en Teil schreiben, in dem es darum geht wie man GDI+ Steuerelemente möglichst gut auf Glas darstellen kann.
Wie gewohnt gibt es hier das Demoprojekt:
Quellen:
Blog von Kenny Kerr
The Code Project
Microsoft SQL Server Compact Edition – Eine Einfuehrung
Oft müssen Clientprogramme große Datenmangen speichern, und in den meisten Fällen wird dazu eine Datenbank eingesetzt. Wenn man eine Internetverbindung voraussetzt kann man einen mächtigen Datenbank Server anbinden und die Daten in der Cloud sichern. Doch oft ist eine Offline Lösung viel einfacher und effektiver.
Inzwischen gibt es auch viele verschiedene lokale Datenbanksysteme wie zB. SQLite, DB4O oder auch MS SQL Server Compact Edition. Alle diese Serversysteme haben auch den Vorteil, dass diese auf den mobilen Systemen problemlos eingesetzt werden können, haben aber auch den Nachteil, dass sie meist nicht den Vollen Feature Umfang eines echten SQL Servers bieten können.
Vorbereitung
In diesem Artikel soll es um den SQL Server Compact Edition von Microsoft gehen, diesen wollte ich schon immer mal testen und nun hatte ich mal die Zeit dazu.
Sofern ihr es noch nicht habt könnt ihr den SQL CE Server kostenlos bei Microsoft herunterladen. Nach der Installation arbeiten wir wie gewohnt im Visual Studio.
Implementierung
Die ganze Implementierung der Datenbank, Erzeugung der Tabellen sowie die Anbindung erfolgt aus Visual Studio heraus. Die Funktionen die man dort hat sind aber auch stark von dem Provider abhängig, so bieten verschiedene Provider mehr oder weniger Funktionalität.
Um eine Datenbank zu einem Projekt hinzuzufügen öffnet einfach den Projektmappen-Explorer (Ansicht->Projektmappen-Explorer) und Klickt mit der rechten Maustaste auf euer Projekt und dann auf "Hinzufügen"->"Komponente..." und wählt eine Lokale Datenbank aus. In dem Datenbank Assistent Fenster klickt nun 2 Mal auf "Zurück" um auf die erste Seite des Assistenten zu gelangen.
Klickt nun auf "Neue Verbindung". In dem folgendem Fenster sollte man darauf achten, dass als Datenquelle "Microsoft SQL Server Compact 3.5" ausgewählt ist.
Bild 1: Datenbank Konfiguration
Klickt nun auf "Erstellen..." nun solltet ihr das Fenster aus Bild 1 sehen. Wählt oben den Speicherort eurer Datenbank und legt wenn nötig ein Passwort fest um die Datenbank zu verschlüsseln. Bestätigt das Ganze noch zwei Mal mit OK. Visual Studio sollte euch dann darauf hinweisen, dass ihr vorhabt eine Lokale Datenbank zu verwenden und schlägt euch vor diese in euer Projekt zu importieren - das nehmen wir gerne an.
Visual Studio fügt die neu erzeugte Datenbank Datei dem Projekt hinzu und setzt auch die nötigen Verweise auf System.Data und auf System.Data.SqlServerCe.
Anlegen der Tabellen
Beim Anlegen der Tabellen in unserer Datenbank ist uns Visual Studio natürlich ebenfalls sehr behilflich. Öffnet einfach den Server-Explorer (Ansicht->Server-Explorer) und erweitert eure frisch angelegte Datenbank. (Eventuell müsst ihr auch ein Passwort angeben wenn ihr die Datenbank verschlüsselt habt)
Klickt nun mit der rechten Maustaste auf Tabellen und wählt "Tabelle erstellen" um den Tabellen Assistenten zu starten.
Bild 2: Tabellen Assistent
Hier könnt ihr eure Tabelle anlegen und konfigurieren. Wenn ihr die nun fertige Tabelle im Server-Explorer rechts anklickt und dann "Tabelleneigenschaften" wählt bekommt ihr noch mehr Konfigurationsmöglichkeiten wie etwa Beziehungen.
Bereits beim Erstellen der Tabellen ist es euch vielleicht schon aufgefallen, dass es nicht so viele Datentypen zur Auswahl gibt wie in einem richtigen SQL Server aber das sind nicht die einzigen Einschränkungen...
Arbeiten mit der Datenbank
Das Arbeiten mit der Datenbank gestaltet sich nicht anders als mit anderen Datenbanken. Die Objekte die man dafür benötigt heißen sogar fast gleich. Alle Klasse die man nutzt haben noch den Zusatz "Ce", also statt "SqlCommand" heißt es nun "SqlCeCommand".
Und auch die Nutzung unterscheidet sich nur geringfügig:
Datenbank Verbindung herstellen:
private SqlCeConnection con;
private string dbLocation = Environment.CurrentDirectory + "\\clipboard.sdf";
private string conString;
private void connectDB(){
conString = "Data Source=\"" + dbLocation + "\"; Password=\"bigbasti.com\"; Encrypt=True";
con = new SqlCeConnection(conString);
con.Open();
}
Eine Select Abfrage durchführen:
///
/// Führt einen Select Befehl auf der Datenbank aus und gibt das ergebnis in einer DataTable zurück
///
///Der auszuführende Befehl
/// Return: Ein DataTable mit den ausgelesenen Daten
public DataTable executeSelect(string query) {
connectDB();
DataTable dt = new DataTable();
SqlCeCommand com = new SqlCeCommand(query, con);
SqlCeDataAdapter sad = new SqlCeDataAdapter(com);
sad.Fill(dt);
con.Close();
return dt;
}
public int checkDouble(string link, string date) {
int retVal;
using (SqlCeConnection con = new SqlCeConnection(conString)) {
con.Open();
//Doppelte Einträge verhindern
DataTable dt = executeSelect("SELECT * FROM cp_link WHERE link LIKE '" + link + "'");
if (dt.Rows.Count > 0) {
executeNonQuery("DELETE FROM cp_link WHERE link LIKE '" + link + "'");
}
}
return retVal;
}
UPDATE, DELETE und INSERT:
///
/// Executes an SQL statement against the SqlCeConnection and returns
/// the number of rows affected.You also can use ExecuteNonQuery to
/// change the data in a database without using a DataSet by executing
/// UPDATE, INSERT, or DELETE statements.
///
///Der Befehl der ausgeführt werden soll
/// The number of rows affected.
public int executeNonQuery(string q) {
int retVal;
using (SqlCeConnection con = new SqlCeConnection(conString)) {
con.Open();
using (SqlCeCommand com = new SqlCeCommand(q, con)) {
retVal = com.ExecuteNonQuery();
}
}
return retVal;
}
public int doSomeInsert(string link, string date) {
int retVal;
using (SqlCeConnection con = new SqlCeConnection(conString)) {
con.Open();
using (SqlCeCommand com = new SqlCeCommand("INSERT INTO cp_link (link, date) VALUES (@link, @date )", con)) {
com.Parameters.AddWithValue("@link", link);
com.Parameters.AddWithValue("@date", date);
retVal = com.ExecuteNonQuery();
}
}
return retVal;
}
Hier gibts eigentlich nichts besonderes. Leider hat man hier, da es eine Compact Edition ist nicht so viele Befehle zur Verfügung wie im Original. So fehlt zB. auch der TRUNCAT Befehl wie ich erstaunt feststellen musste. Ich habe da nicht noch weiter recherchiert was noch alles fehlt, da ich für das was ich gemacht habe keine besonderen Aktionen benötigte.
Deployment
Wenn ihr das Projekt über ein Setup-Projekt deployen wollt dann sollte da eigentlich nichts schief gehen. Ihr könnt aber natürlich auch ohne ein extra Setup-Projekt deployen, dazu solltet ihr folgende Schritte machen:
- Öffnet die Eigenschaften eures Projekts
- Öffnet dort den "Veröffentlichen" (Publish) Tab
- Klickt auf den Knopf "Erforderliche Komponenten"
- Sucht den Eintrag "SQL Server Compact Edition 3.5" und entfernt das Häkchen und schließt die Eigenschaften
- Nun benötigen wir die erforderlichen DLL Dateien, diese liegen in "C:\Programe\Microsoft SQL Server Compact Edition\"
- Es sind 7 oder auch mehr Dateien, abhängig davon wie viele Sprachen installiert sind (siehe Bild links)
- Markiert diese DLLs und zieht diese direkt in den Projektmappen-Explorer, da mit diese DLLs dem Projekt hinzugefügt werden
- Markiert die neuen DLLs in dem Projektmappen-Explorer -> klickt mit der rechten Maustaste darauf und wählt "Eigenschaften"
- Setzt die Eigenschaft "In Ausgabeverzeichnis kopieren" auf "Kopieren, wenn neuer" damit ihr immer die Aktuelle Version im Build Verzeichnis habt
- Klickt im Projektmappen-Explorer mit der rechten Maustaste auf System.Data.SqlServerCe und wählt Eigenschaften
- Setzt hier die Eigenschaft "Lokale Kopie" auf True. Dieser Schritt ist nötig damit das Programm lokal nach der DLL sucht und nicht versucht sich diese aus dem GAC (Global Assembly Cache) zu holen.
Und das war es eigentlich schon. Nun könnt ihr das Projekt problemlos deployen.
Nächste Termine
Archive
Kategorien
- .NET
- Allgemein
- Apple
- ASP
- Buch
- Computer
- CSharp
- Gut zu Wissen
- Handy
- html5
- Internet
- iPhone
- Java
- Linux
- Microsoft
- Mocrosoft Office
- MVC
- PHP
- Programme
- Programmierung
- Server
- Tipps & Tricks
- Visual Basic
- XML