Das Problem an der Sache ist, dass der HtmlHelper seine Ausgabe für HTML formatiert und somit einer Übergabe von "<img src="..." alt="..." />" als Linkname nicht verarbeitet werden würde, sondern direkt so ausgegeben.

Ich habe mich dann an Google gewendet und viele verschiedene Ansätze gefunden um das Problem zu lösen oder wenigstens zu umgehen. Hier gibt es allgemein gesagt zwei Lösungsansätze und man muss wohl selber entscheiden welches einem mehr Vorteile bietet und einem persönlich zusagt.

Ansatz 1: Den a-Tag und den img-Tag selber anlegen und die Route mit der UrlHelper-Klasse generieren. Hier ein paar Beispiele:

<a href="<%= Url.RouteUrl(">">
   put in <span>whatever</span> you want, also <img src="a.gif" alt="images" />.
</a>

<a href="<%= Url.Action(">">
   <img src="../../Content/Images/add_48.png" alt="" />
</a>

<%= Html.ActionLink("__IMAGE_PLACEHOLDER__", "Products")
.Replace("__IMAGE_PLACEHOLDER__", "<img src="\" alt="" />")%>

Alle diese Methoden funktionieren und erzeugen einen Link der ein Bild umschießt, doch in meinen Augen ist das eine nicht so schöne Methode, denn solche Links werden doch ziemlich oft generiert und da fände ich eine schöne Methode wie Html.ActionLinkWithImage schon angenehmer und lesbarer.

Ansatz 2: Eine Eigene Helper Methode erstellen die die Generierung für uns übernimmt:

Nach etwas mehr Suchen habe ich auch eine Extension Method in Stephen Walthers Blog gefunden. Diese sieht wie folgt aus (habe die Funktion noch um den Parameter Controller ergänzt):

public static string ImageLink(this HtmlHelper helper, string actionName,
    string controllerName, string imageUrl, string alternateText, object routeValues,
    object linkHtmlAttributes, object imageHtmlAttributes) {

    var urlHelper = new UrlHelper(helper.ViewContext.RequestContext);
    var url = urlHelper.Action(actionName, controllerName, routeValues);

    // Create link
    var linkTagBuilder = new TagBuilder("a");
    linkTagBuilder.MergeAttribute("href", url);
    linkTagBuilder.MergeAttributes(new RouteValueDictionary(linkHtmlAttributes));

    // Create image
    var imageTagBuilder = new TagBuilder("img");
    imageTagBuilder.MergeAttribute("src", urlHelper.Content(imageUrl));
    imageTagBuilder.MergeAttribute("alt", urlHelper.Encode(alternateText));
    imageTagBuilder.MergeAttributes(new RouteValueDictionary(imageHtmlAttributes));

    // Add image to link
    linkTagBuilder.InnerHtml = imageTagBuilder.ToString(TagRenderMode.SelfClosing);

    return linkTagBuilder.ToString();
}

//Benutzung:
<%= Html.ImageLink("Action", "Controller", "Pfad_zum_Bild", "alternativText", new { id = e.Id }, null, new { border = "0" })%>

Diese Funktion erledigt genau das was ich brauchte, sie generiert den benötigten Link und auch den IMG-Tag aus meinen übergebenen Informationen und sieht der Html.ActionLink() Methode dabei auch noch so ähnlich dass man gar nicht darauf kommt, dass es eine nachträglich eingefügte Extension ist

Falls ihr noch nach einer Möglichkeit nutzt das ganze auch mit streng typisierten Links zu nutzen solltet ihr in Mirkos Blog vorbeischauen, er hat auch dafür eine Extension Method gebastelt.

Ich bin mit dieser Lösung ganz zufrieden, doch interessiert es mich trotzdem, wie ihr das in euren Projekten handhabt und eure Links erstellt. Vielleicht habt ihr ja eine bessere Methode auf Lager.

Feel free to Flattr this post at flattr.com, if you like it.

Diese Power Tools verbessern hierbei viele Kleinigkeiten, die den Arbeitsprozess angenehmer machen. Hier ein paar Beispiele:

• STRG+Mausklick auf eine Variable befördert euch zu der Klasse
• STRG+1/2/3 Bringen bequeme Sprungmöglichkeiten innerhalb der markierten Klasse
• ALT+Pfeil hoch/runter verschiebt den markierten Text
• Ein neuer Solution navigator
• Ein verbesserter "Verweis hinzufügen" Dialog mit Suchfunktion
• Farbige und pinnbare Tabs
• und und und

Schnell laden, installieren und genießen! Ich kann schon jetzt nicht mehr ohne!

Feel free to Flattr this post at flattr.com, if you like it.

Wieso das nützlich ist fragst du dich? Na ganz einfach, habt ihr schon mal die Methode String.toInt32() vermisst? Diese ist nur eine (sehr simple) Methode, die man häufiger gebrauchen könnte, die es aber nicht gibt. Diese könnte man sehr einfach mit einer Extension Method erweitern.

Als Beispiel möchte ich hier aber den Artikel von vor ein paar Tagen nehmen, wo wir eine Methode erstellt haben mit der man ein XmlElement in einem XmlDocument umbenennen konnte. Dies mussten wir machen, da die Klasse XmlDocument keine Methode dafür anbietet. Nun wollen wir mal die XmlDocument Klasse um diese Methode erweitern.

Das ganze funktioniert sehr einfach:

    public static class XmlDocumentExtension
    {
        public static bool RenameXmlElement(this XmlDocument doc,
                                            XmlElement oldElement,
                                            string newName) {
            try {
                //Neues XmlElement mit neuem namen anlegen
                XmlElement newElement = oldElement.OwnerDocument.CreateElement(newName);

                //Dem neuen XmlElement alle Attribute des alten Elements übergeben
                foreach (XmlAttribute a in oldElement.Attributes) {
                    newElement.SetAttributeNode((XmlAttribute)a);
                }

                //Dem neuen XmlElement alle Kinder Elemente des alten Elements anhängen
                foreach (XmlNode n in oldElement.ChildNodes) {
                    newElement.AppendChild(n.Clone());
                }

                oldElement.ParentNode.ReplaceChild(newElement, oldElement);
            } catch {
                return false;
            }

        return true;
        }
    }

Wir legen eine ganz normale Klasse an, diese kann heißen wie man will, ich habe sie hier nur zum besseren Verständnis so benannt. In der klasse legen wir nun die Funktion an um die wir unsere Klasse erweitern wollen. Hierbei ist wichtig, dass sowohl die Klasse als auch die Funktion als public und static markiert wird. Des Weiteren sollte man einen Verweis auf System.Code.dll setzen.

Bei der Deklaration der Funktion muss man dann angeben welche Klasse erweitert werden soll. Hier erweitern wir die Klasse XmlDocument weswegen vor diesem Parameter noch ein this steht. Dieser Parameter wird nur dazu benötigt und muss dann später bei dem Aufruf der Funktion nicht gesetzt werden.

Bild 1: Auch IntelliSense erkennt unsere Erweiterung an und bietet diese an

Natürlich bleibt die "original" Klasse XmlDocument unberührt von dieser Aktion und wird nur virtuell erweitert. Diese Erweiterung ist natürlich auch nur für das Aktuelle Projekt nutzbar.

Ich finde dieses Feature wirklich sehr nützlich und kann es euch deswegen auch nur empfehlen.

Feel free to Flattr this post at flattr.com, if you like it.

Wenn man Module nicht benutzen sollte warum gibt es sie dann?

Module gibt es in VB.NET nur aus einem Grund, nämlich um VB6 Programmierern den Umstieg auf die .NET Plattform zu erleichtern. Denn .NET ist komplett Objektorientiert und hier haben Module keinen Platz. Aber um es den Entwicklern einfacher zu machen bestehende Projekte auf die .NET Plattform zu porten wurden die Module mitgenommen.

Modul, Klasse wo ist eigentlich der Unterschied?

Wenn man sich so ein Modul anschaut hat es eine Enorme Ähnlichkeit mit einer gewöhnlichen Klasse, unterscheidet sich aber dennoch gewaltig von ihr.

Im Prinzip sind Module auch Klassen, die aber vielen Beschränkungen unterliegen. Hier die Hauptpunkte:

• Alle Methoden und Variablen eines Moduls sind automatisch Shared, was bedeutet, dass man auf diese Methoden/Variablen zugreifen kann ohne eine Instanz der Klasse bilden zu müssen.
• Alle Methoden und Variablen eines Moduls sind in dem gesamten Projekt verfügbar und sind somit Global - was nicht im Sinne von OOP ist. Der Programmierer kann dabei direkt auf die Methoden und Variablen zugreifen, dies erzeugt das Bild von Globalen Objekten und steht dabei im Gegensatz zu dem Klassischen Objektzugriff Object.Member.
• Module sind automatisch NonInheritable, was die Instanzierung verhindert, desweiteren kann ein Modul auch nicht mit weiteren Schnittstellen wie z.B.: Interfaces erweitert werden.
• Module sind zur Laufzeit einzigartig. Das bedeutet, dass alle Programmteile immer auf die selben Werte zugreifen, anders als bei einer Klasse wo jede Instanz eigene Werte hat.
• Ein weiterer Punkt ist, dass Module nicht nach Außen hin sichtbar sind und somit eine Wiederverwendung ausschließen, was im totalen Gegensatz der OOP ist.

Warum werden Module dann so häufig benutzt?

Im Normalfall ist es entweder Unwissenheit oder Faulheit, oder beides. Denn viele Einsteiger (und auch alte VB6 Hasen) haben Probleme damit das Objektorientierte Prinzip zu verstehen, und da kommen die Module wie gerufen, denn diese ersparen die korrekte Deklarierung, man muss keine Namespaces beachten, die Instanzierung kann man sich auch sparen und man muss sich nicht mit Properties herumschlagen! Also geht im Endeffekt alles schneller aber dafür wird lauter Spaghetticode erzeugt!

Schlusswort

Wenn du noch relativ neu in der Objektorientierten Programmierung bist oder ein umsteiger von VB6, lass dich nicht davon verleiten schnellen unsauberen Code zu schreiben. Lass dir lieber etwas mehr Zeit um das OOP Konzept zu verstehen und mach es dann richtig. Je länger man diesen Pakt mit dem Teufel eingeht, desto schwieriger wird es dann später die alten Gewohnheiten los zulassen.

Ein weiterer Punkt ist, dass es unter C# keine Module gibt, daher wird man spätestens dann Probleme bekommen wenn man an einem C# Projekt mitarbeitet und dann gezwungen ist sauberer zu programmieren!

Feel free to Flattr this post at flattr.com, if you like it.

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!

Feel free to Flattr this post at flattr.com, if you like it.

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.

Feel free to Flattr this post at flattr.com, if you like it.

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.

<< Teil 4 des Tutorials

Feel free to Flattr this post at flattr.com, if you like it.

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!

Feel free to Flattr this post at flattr.com, if you like it.

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

Feel free to Flattr this post at flattr.com, if you like it.

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.

<< Zu Teil 1

Feel free to Flattr this post at flattr.com, if you like it.