Code and more

Gravatar ist ein öffentlicher und kostenloser Webdienst der die Verknüpfung eines Profilbildes oder auch Avatars mit einer Email-Adresse ermöglicht. Gravatar stellt somit einen Art globalen Avatar bereit.

Die Einbindung in eigene Seiten ist denkbar simpel.

To request a gravatar from our servers, you simply add an image to your users activity with an "src" attribute that points to our gravatar image generator and includes an MD5 hash of the user’s email address. Since all gravatars are rated with an MPAA style rating, you can restrict your site to show only gravatars whose content you are comfortable with. Quelle: http://en.gravatar.com

Für ASP.NET MVC basierte Projekte bietet es sich an, die Einbindung über einen eigenen HtmlHelper zu realisieren. Zunächst habe ich eine Klasse GravatarViewHelper in meinen MVC Projekt angelegt.

Als nächstes werden nun die eigentlichen Extension Methoden definiert.

public static string GravatarLink(this HtmlHelper html, string id, 

                                  string alternateText, string email, 

                                  int size, string rating)
{
    return GravatarLink(html, id, alternateText, email, size, rating, null);
}

public static string GravatarLink(this HtmlHelper html, string id, 

                                  string alternateText, string email, 

                                  int size, string rating, object htmlAttributes)
{
    if (String.IsNullOrEmpty(email))
        return String.Empty;

    var url = BuildGravatarUrl(email, size, rating);
    var tag = BuildTag(id, url, htmlAttributes, alternateText);

    return tag;
}

 

Ziel der Methoden ist es ein <img> Tag zu rendern, dessen “src” Attribut die generierte Gravatar URL enthält. Das Erstellen der Gravatar URL erfolgt in 3 Schritten:

1. Zusammenbauen der Basis URL

2. Erzeugen des MD5 Hash aus der Email Adresse

3. Hinzufügen von Gravatar Optionen (Bildgröße, Rating)

private static string BuildGravatarUrl(string email, int size, string rating)
{
    var builder = new UriBuilder("http://www.gravatar.com/");
    builder.Path = "avatar/";
    builder.Path = builder.Path + CreateEmailMd5Hash(email);

    AppendQueryToGravatarUri(builder, "s="+size);
    AppendQueryToGravatarUri(builder, "r=" + rating);
    AppendQueryToGravatarUri(builder, "d=identicon");

    return builder.ToString();
}

Abschließend muss noch das img Tag erzeugt werden.

private static string BuildTag(string id, string url, 

                               object htmlAttributes, 

                               string alternateText)
{
    var builder = new TagBuilder("img");
    builder.GenerateId(id);
    builder.MergeAttribute("src", url);
    builder.MergeAttribute("alt", alternateText);
    builder.MergeAttributes(new RouteValueDictionary(htmlAttributes));

    return builder.ToString(TagRenderMode.SelfClosing);
}

Nun noch schnell im View ein Import Statement für den neuen HtmlHelper hinzufügen und fertig.

%@Import Namespace="Chessman.Mvc.Helper"%

<%
    foreach (var user in Model)
    {
%>
       <%= Html.GravatarLink("myGravatar", "Gravatar Image", user.Email, 80, "PG") %>
    

<% 

    } 

%>

 

Hier nochmal der komplette Code der GravatarViewHelper Klasse:

public static class GravatarViewHelper
{
    public static string GravatarLink(this HtmlHelper html, string id, 

                                      string alternateText, string email, 

                                      int size, string rating)
    {
        return GravatarLink(html, id, alternateText, email, size, rating, null);
    }

    public static string GravatarLink(this HtmlHelper html, string id, 

                                      string alternateText, string email, 

                                      int size, string rating, object htmlAttributes)
    {
        if (String.IsNullOrEmpty(email))
            return String.Empty;

        var url = BuildGravatarUrl(email, size, rating);
        var tag = BuildTag(id, url, htmlAttributes, alternateText);

        return tag;
    }

    private static string BuildGravatarUrl(string email, int size, string rating)
    {
        var builder = new UriBuilder("http://www.gravatar.com/");
        builder.Path = "avatar/";
        builder.Path = builder.Path + CreateEmailMd5Hash(email);

        AppendQueryToGravatarUri(builder, "s="+size);
        AppendQueryToGravatarUri(builder, "r=" + rating);
        AppendQueryToGravatarUri(builder, "d=identicon");

        return builder.ToString();
    }

    private static void AppendQueryToGravatarUri(UriBuilder builder, string query)
    {
        if (builder.Query != null && builder.Query.Length > 1)
            builder.Query = builder.Query.Substring(1) + "&" + query;
        else
            builder.Query = query;
    }

    private static string CreateEmailMd5Hash(string email)
    {
        var provider = new MD5CryptoServiceProvider();
        var bytesToHash = Encoding.UTF8.GetBytes(email);
        bytesToHash = provider.ComputeHash(bytesToHash);

        var result = String.Empty;
        foreach (var b in bytesToHash)
        {
            result = (result + b.ToString("x2"));
        }

        return result;
    }

    private static string BuildTag(string id, string url, object htmlAttributes, 

                                   string alternateText)
    {
        var builder = new TagBuilder("img");
        builder.GenerateId(id);
        builder.MergeAttribute("src", url);
        builder.MergeAttribute("alt", alternateText);
        builder.MergeAttributes(new RouteValueDictionary(htmlAttributes));

        return builder.ToString(TagRenderMode.SelfClosing);
    }
}

Manchmal ist es zum aus der Haut fahren. In meiner App wird eine Liste per Ajax geladen (Index Action). Jeder Eintrag der Liste stellt direkt eine Löschfunktion zur Verfügung. Zum Löschen wird die Delete Action per Ajax Post aufgerufen. Diese leitet nach getaner Arbeit mittels RedirectToAction an die Index Methode weiter. So weit, so gut.

Nun wird aber in der Index Action mit Request.IsAjaxRequest entschieden ob die ganze Seite oder nur die Liste  als PartialView gerendert werden soll. Die Request.IsAjaxRequest Abfrage müsste in meinem Fall “true” zurückgeben. Tut sie auch, allerdings nur im Internet Explorer. Im Firefox klappt es ums Verrecken nicht. Irgendwie gehen benötigte Header Informationen verloren oder werden nicht richtig gesetzt. 

Eine Möglichkeit zur Lösung oder besser Umgehung des Problems bietet sich mit TempData an. In der Delete Action wird eine Variable [IsActionRedirect] in TempData gesetzt und in der IndexAction abgefragt. (if (Request.IsAjaxRequest() || TempData["ActionRedirect"] != null)) Je nach Ergebnis wird dann der entsprechende View gerendert. Nicht schön aber es funktioniert.

Ich mag den neuen IE 8 wirklich. Aber manchmal treibt mich das Ding in den Wahnsinn. Folgendes Szenario: Ich rufe mittels jQuery $.getJson eine Action in meinem Controller auf, die mir das gewünschte Json Objekt zurückgibt. Das Ergebnis wird dann an eine bestehende Liste auf der Seite angefügt. So weit so gut. Beim ersten Aufruf funktioniert auch alles wunderbar. Aber ab dem zweiten Aufruf scheint der IE den Aufruf  zu cachen, denn er fügt zwar einen neuen Eintrag an allerdings hat dieser immer die gleichen Werte. Im Firefox funktioniert es einwandfrei. Benutzt man statt $.getJson die $.post Methode funktioniert es auch im IE. Abgesehen von der Tatsache das POST in meinem Fall kontextbezogen eh die bessere, weil logischere Methode war, wäre ich für eine Erklärung dankbar.

Gestern hatte ich eine zwar kurze aber durchaus interessante Unterhaltung mit einem Freund über das Für und Wider von Kommentaren im Quelltext. Ohne ins Detail gehen zu wollen, sei gesagt das unsere Auffassungen durchaus konträr waren. Sind Kommentare wirklich notwendig im Hinblick auf schnellen Entwicklungsfortschritt und Kommunikation des Entwicklerteams untereinander?

Nein.  Die meisten Kommentare sind nötig wie ein Kropf:

• sie stören den Lesefluss und “verschmutzen” den Code
• sie haben ein geringes Haltbarkeitsdatum
• sie verschleiern schlechten Code
• sie enthalten falsche Informationen
• sie stehen außerhalb des Refactorings

Über allem steht der Grundgedanke: Guter Code braucht keine Kommentare, er spricht für sich selbst. Moderne Programmiersprachen verfügen über genügend Ausdruckskraft um sauberen, strukturierten und somit verständlichen Code zu schreiben. Natürlich gibt es, wie überall, Ausnahmen. Kommentare sollen und müssen immer dann eingesetzt werden,  wenn die Ausdruckskraft der verwendeten Sprache nicht ausreicht um Sachverhalte klar und leicht verständlich zu beschreiben. Wie alles im Leben hat auch die Vermeidung von Kommentaren eine Kehrseite – das Schreiben sauberen Codes. Und das erfordert vom Entwickler ein hohes Maß an Sorgfalt und große Selbstdisziplin.