Ich glaube schon seit Windows 98 habe ich mich gefragt, warum Microsoft dem Windows Explorer keine Tabs spendiert. Auch Apple bekommt es unter Mac OS nicht hin den Finder Tab-Fähig zu machen. Warum eigentlich nicht?

Clover zeigt wie es gehen könnte. Dieses einfache kleine Tool kombiniert alle Windows Explorer Fenster unter einem Dach und lässt sich dabei so flüssig bedienen, dass es schon fast wie eine native Lösung wirkt.

Auf den ersten Blick fällt sofort auf, dass hier einige Teile vom Google Chrome eingeflossen sind. So gleicht das Look and Feel der Tabs und auch deren Bedienung bis ins Detail dem von Chrome. Alles ist super Flüssig und funktioniert komplett ohne Konfiguration sofort so wie man es gewohnt ist.

So lassen sich neue Tabs mit STRG+T öffnen und mit STRG+TAB durchschalten. Mit einem Doppelklick während man die STRG-Taste gedrückt hält wird der gewählte Ordner in einem neuen Tab geöffnet. Die Tabs selbst integrieren sich in die Titelleiste des Fensters und verbrauchen so gut wie keinen Platz.

Optional kann man auch noch (wie auch im Chrome) eine Lesezeichenleiste einblenden lassen, in der man seine Lieblingsordner speichern kann. Ich finde aber, dass es die Optik etwas stört.

Das Icon des Programms könnt ihr ebenfalls verändern, wenn euch das Kleeblatt nicht zusagt. Eine Anleitung dafür gibts auf der Homepage des Entwicklers.

Weitere Infos und Download.

Dazu müsst ihr lediglich ein paar Ressourcen hinterlegen:

    <!-- Setzen der Icons für die verschiedenen Auflösungen -->
    <link rel="apple-touch-icon-precomposed" sizes="144x144" href="/Content/grafik/icons/apple-touch-icon-144-precomposed.png">
    <link rel="apple-touch-icon-precomposed" sizes="114x114" href="/Content/grafik/icons/apple-touch-icon-114-precomposed.png">
    <link rel="apple-touch-icon-precomposed" sizes="72x72" href="/Content/grafik/icons/apple-touch-icon-72-precomposed.png">
    <link rel="apple-touch-icon-precomposed" href="/Content/grafik/icons/apple-touch-icon-57-precomposed.png">
    <!-- sorgt dafür dass die App im Vollbild ausgeführt wird -->
    <meta name="apple-mobile-web-app-capable" content="yes">
    <!-- Farbe der Statuszeile -->
    <meta name="apple-mobile-web-app-status-bar-style" content="black">

Safari erkennt dann diese Tags und zeigt euer Icon und führt die Seite dann auch im Vollbildmodus aus. Ein weiteres Goodie ist, dass die Webseite als "App" läuft und im Taskmanager sogar ein eigenes Icon bekommt.

Hier am Beispiel meiner kleinen F1-Tippspiel Seite:

Der Haken
Ein kleines Problem bleibt dann aber noch. Sobald ihr einen Link auf die Seite setzt und der Benutzer diesen antippt wird der Link ein einer neuen Safari Instanz geöffnet. Das Liegt daran, dass iOS euere Seite als App betrachtet und alle Links werden in iOS vom Safari behandelt.

Zum Glück kann man dieses Verhalten sehr einfach mit etwas Javascript umgehen:

<script>(function(a,b,c){if(c in b&&b[c]){var d,e=a.location,f=/^(a|html)$/i;a.addEventListener("click",function(a){d=a.target;while(!f.test(d.nodeName))d=d.parentNode;"href"in d&&(d.href.indexOf("http")||~d.href.indexOf(e.host))&&(a.preventDefault(),e.href=d.href)},!1)}})(document,window.navigator,"standalone")</script>

Weitere Infos und Quelle zu der Lösung findet ihr bei Stackoverflow.

Nun werden alle Links in eurer "App" geöffnet und alles funktioniert wie gewohnt

So kann man dieses Feature super gebrauchen wenn die App E-Mails versenden soll und man größere E-Mail Templates nutzen will. Das Schöne an der Razor Engine ist, dass man diese sehr einfach integrieren kann und der Code sehr verständlich und sauber bleibt.

Die Installation erfolgt hier wie so oft sehr einfach über NuGet:

Jetzt ist man im Grunde schon fertig und kann sofort loslegen. Starten wir mit dem Model, das die Razor Engine für uns verarbeiten wird. Dies ist eine gewöhnliche Klasse (POCO):

public class TipReminder
{
	public string DisplayName { get; set; }

	public string EmailAdress { get; set; }

	public DateTime LastLogin { get; set; }
}

Jetzt legen wir uns ein kleines Template an, das den Inhalt der Email darstellen soll:

@model Projekt.Domain.AppUser
<!DOCTYPE html>

<head>
    <meta name="viewport" content="width=device-width" />
    <title>Newsletter</title>
</head>
<body>
    <div>
        <h2>Hallo @Model.DisplayName</h2>
        <p>Es ist wieder Zeit für einen Newsletter</p>
        <p>Dein letzter Login war am @Model.LastLogin - das ist schon lange her!</p>
        <p>Schau doch mal wieder vorbei.</p>
        <hr />
        <p>Bitte antworten Sie nicht auf diese EMail</p>
        <p>Viel Spaß weiterhin!</p>
    </div>
</body>
</html>

Man beachte hier besonders die Zeilen 10 und 12 wo wir auf das Model zugreifen.

Wenn ihr ASP.NET MVC 3 oder 4 schon mal genutzt habt, werdet ihr feststellen, dass alles exakt der Syntax einer View gleicht, sogar die Definition der strickten Typisierung auf das Model oben.

Die eigentliche Nutzung ist dann ein Kinderspiel:

foreach (AppUser user in db.Users)
{
    string renderedEmail = Razor.Parse(File.ReadAllText(pathToEmailTemplate), user);
    EMailHelper.SendEmail(renderedEmail, user.EmailAdress);
}

Wirklich interessant ist hier nur Zeile 3 wo wir den eigentlichen Aufruf an die RazorEngine tätigen. Die Parse-methode benötigt lediglich das Template als String und ein Model zur Verarbeitung.

Das ist ein wirklich praktisches Feature um die Templates auf einfachste Weise aus dem Programm herauszulösen. Das Ganze ist nicht neu (gibt’s schon seit fast 2 Jahren) man muss nur wissen, dass es möglich ist.

Test-Fehler ingnorieren

Oft will man alle Testfälle eines Projekts ausführen um einen Überblick zu erhalten, Maven bricht per Default aber nach dem ersten Testfehler ab, dieses Verhalten kann man Maven ganz leicht über diesen Parameter abgewöhnen:

mvn test -Dmaven.test.failure.ignore=true

Wenn man will kann man dieses Verhalten auch für ein Projekt vorschreiben, sodass es bei jedem Testdurchlauf so bleibt. Dazu definiert man folgendes Plugin:

  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <configuration>
      <testFailureIgnore>true</testFailureIgnore>
    </configuration>
  </plugin>

Tests beim install überspringen

Standardmäßig führt Maven beim install auch alle Tests aus und bricht bei dem ersten nicht bestandenen Test den install ab. Dies kann je nach Projektbröße auch eine ganze Weile dauern. So kann es viel Zeit sparen wenn man die Tests weglässt. Dieses einfache Kommando hilft uns hier aus:

mvn install -Dmaven.test.skip=true

Habt ihr noch nützliche Maven Parameter? Lasst es mich wissen. .)

Hier gibt es viele Ansätze. Ich hatte schon Seiten, die die CSS Klassen ins HTML hardcoden, irgendwelche anderen Schandtaten betreiben oder nicht wirklich schöne If-Abfragen um die Menüpunkte legen.

            <li @if (activeMenu.Equals("Home"))
                {
                    <text>class="active"</text>
                }>@Html.ActionLink("Home", "index", "home")</li>

Hier muss man natürlich noch bedenken, dass ein entsprechender ViewBag-Eintrag namens "activeMenu" in jeder Action gesetzt werden muss. urgs

Ich möchte diese ganze Logik nicht in den Views haben. Daher habe ich eine kleine ExtensionMethot für den HtmlHelper geschrieben.

Diese Extension generiert für mich die Menülinks und prüft beim Generieren des Links ob das Ziel des Links mit dem aktuellen Controller und der aktuellen View übereinstimmt. Wenn das der Fall ist wird dieser Link als aktiv markiert. So sieht das Ganze aus:

public static MvcHtmlString NavigationActionLink(
    this HtmlHelper htmlHelper, string linkText,
    string actionName, string controllerName, object routeValues = null,
    object htmlAttributes = null, 
    string wrapperElement = "li", string flag = "active")
{
    var generatedLink = HtmlHelper.GenerateLink(
                    htmlHelper.ViewContext.RequestContext,
                    htmlHelper.RouteCollection, linkText,
                    (string)null, actionName, controllerName,
                    new RouteValueDictionary(routeValues), 
                    (IDictionary<string, object>)HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));

    var wrappedElement = WrapGeneratedLink(
                    htmlHelper, actionName, 
                    controllerName, wrapperElement, flag, generatedLink);

    return MvcHtmlString.Create(wrappedElement.ToString(TagRenderMode.Normal));
}

private static TagBuilder WrapGeneratedLink(
    HtmlHelper htmlHelper, string actionName, string controllerName,
    string wrapper, string flag, string generatedLink)
{
    var wrapperElement = new TagBuilder(wrapper)
                                {
                                    InnerHtml = generatedLink
                                };

    if (CurrentRouteMatchesGeneratedUrl(actionName, controllerName, htmlHelper))
    {
        wrapperElement.AddCssClass(flag);
    }
    return wrapperElement;
}

private static bool CurrentRouteMatchesGeneratedUrl(
    string actionName, string controllerName, HtmlHelper htmlHelper)
{
    var currentAction = (string)htmlHelper.ViewContext.RouteData.Values["action"];
    var currentController = (string)htmlHelper.ViewContext.RouteData.Values["controller"];

    return string.Equals(currentAction, actionName, 
                        StringComparison.CurrentCultureIgnoreCase) &amp;&amp;
            string.Equals(currentController, controllerName, 
                        StringComparison.CurrentCultureIgnoreCase);
}

Hier der Code nochmal etwas schöner formatiert.

Dieser Helper orientiert sich an dem gewöhnlichen ActionLink und hat die gleichen Parameter bis auf die letzten zwei, mit denen man bestimmen kann wie der Link hervorgehoben werden soll.

So könnte man nun die Menülinks verwenden am Beispiel Twitter Bootstrap:

<div class="navbar navbar-inverse navbar-fixed-top">
    <div class="navbar-inner">
        <div class="container">
            <div class="nav-collapse">
                <ul class="nav">
                @Html.NavigationActionLink("meinlink", "index", "home")
                @Html.NavigationActionLink("meinlink", "index", "account", null, null, "div", "selected")
                </ul>
            </div>
        </div>
    </div>
</div>    

So würde der erste Link folgendes generieren:

<li class="active"><a href="/">meinlink</a></li>

Und der zweite Link das hier:

<div class="selected"><a href="/">meinlink</a></div>

Auf diese Weise kann mann etwas Einfluss darauf nehmen was da generiert wird und mit welcher Klasse das erzeugte Feld markiert wird.

Der zweite Link macht natürlich keinen Sinn in dem Twitter Bootstrap Beispiel und wurde nur zu Demonstrationszwecken genutzt

So entfernt man den hässlichen Code aus den Views und muss sich darum keinen Kopf mehr machen.

Übrigens: In dem meisten Fällen reicht es wenn man nur nach dem Controller prüft, da häufig mehrere Actions zu einem Menüpunkt gehören und man dann einen Menüpunkt mit einem Controller abdeckt.

Wie macht ihr das?

Wie ist eure Methode um diese kleine Problematik zu lösen? Habt ihr vielleicht einen schöneren/einfacheren Ansatz? Dann würde ich mich sehr freuen wenn ihr mich belehren würdet

Twitter mit Geschäftsmodell 

Es ist DAS Problem, das Twitter, Facebook und alle anderen Dienste haben, wie mache ich Geld damit? Dieses Problem scheint bei App.net sich gar nicht zu stellen, denn jeder Nutzer muss eine jährliche oder monatliche Gebühr zahlen um den Dienst nutzen zu können.

Das finde ich persönlich sehr gut, denn das löst ziemlich viele Probleme, nicht nur aus der Sicht der Betreiber und Entwickler.

Das Feeling

Wenn man App.net nutzt erinnert das einen an die Anfänge von Twitter, als alles noch neu war und Twitter noch auf das Feedback der Nutzer hörte und zb. Features aus der Community übernahm wie die RT-Funktion.

Man merkt deutlich dass alle noch mit den Möglichkeiten spielen, alles ist sauber und aufgeräumt, keine (oder kaum) SEO-Agenturen und Bots die einem sofort followen, wenn man das falsche Buzzword twittert postet. Aber das wird sicherlich auch noch folgen

Vorteile von App.net

Bereits nach kurzer Nutzung, fällt auf, dass es auf App.net zivilisierter zugeht. Ok, das könnte auch daran liegen, dass es erst 23,000 Nutzer gibt, aber ich denke, dass es an dem Bezahlsystem liegt. Denn bei Twitter kann sich jeder 10x Accounts machen, mit denen er dann unnötigen Spam verbreiten oder irgendwelche Bots laufen lassen kann.

Wenn man für jeden Account, der dann auch an eine Kreditkarte gebunden ist Geld zahlen muss wird sich jeder sicherlich fragen ob das wirklich nötig ist und der Aufwand sich überhaupt lohnt.

Ich denke die echten Vorteile werden sich erst später mit der Zeit herauskristallisieren. Und wenn Twitter weiterhin so aggressiv die Dritthersteller absägt und immer mehr Werbung in die Timeline schaltet werden die Leute scharenweise überlaufen.

Die Unterschiede

Das Erste was auffällt ist natürlich das Zeichenlimit von 256 Zeichen. Dies verdoppelt fast den Wert von Twitter mit 140 erlaubten Zeichen. Hier bin ich mir ehrlich gesagt nicht sicher ob das wirklich besser ist. (Auch wenn es definitiv die nerdigere Zahl ist )

Meine Erfahrung hat jedenfalls gezeigt, dass sich Menschen mehr Gedanken machen wenn sie sich kurz fassen müssen und das ist genau das was Twitter so besonders macht. Man hat alle Infos schnell auf einen schnellen Blick.

Weiterhin fällt auch die sehr minimalistische Oberfläche auf, die größtenteils auf Farben verzichtet. Auch wenn es nicht schlecht aussieht, denke ich dass sich hier demnächst vieles ändern wird, da das Ganze noch in den Kinderschuhen steckt.

Alles andere hat wirklich sehr viel Ähnlichkeit mit Twitter, nicht nur optisch auch funktionell:

Man sieht Funktionen wie "Repost" und "Favorite", was so ziemlich den Funktionen bei Twitter entspricht. Alle Posts die eine Antwort haben kann kann man auch in einer Konversation darstellen. Noch erkennt das System nicht die geposteten Links zu Bildern und Videos wie Twitter es tut, aber ich denke mal es ist nur eine Frage der Zeit.

Clients

Im Vergleich zu Twitter will App.Net Dritthersteller dafür belohnen Software für ihre Plattform zu erstellen. So gibt es schon diverse Clients für alle Systeme. Es macht sogar der Running-Gag die Runde, dass App.Net mehr Apps hat als User

Auf dem iPhone gibt es schon diverse Clients die alle im Schnitt 4€ kosten. Auch Browser Plugins und Standalone Programme sind vorhanden. Hier geht es definitiv in die richtige Richtung.

Was ist nicht so toll

Wenn man Twitter kennt gibt es leider nicht viel neues zu entdecken, ein paar Sachen gibt es aber, die man nicht einfach aus Twitter übernehmen kann, und das ist hauptsächlich der Name.

Der Dienst hat leider einen ziemlich nichtssagenden Namen, unter App.Net kann man sich alles mögliche vorstellen. Wie nennt man die Posts die man veröffentlicht? "Tweets" oder "Twittern" sind Begriffe die sich inzwischen richtig eingebürgert haben. Mit so etwas kann App.Net leider nicht dienen.

Wie nennt man nun so ein Statusupdate bei App.Net? Keine Ahnung, manche sprechen von Posts, andere sagen Updates - etwas einheitliches muss her, aber der Name lässt leider nichts schlüssiges zu, denn "Apps" würde man sicherlich falsch verstehen

Fazit

Bisher hat man mit App.Net ein Twitter ohne Werbung - nicht mehr und nicht weniger. Potential ist definitiv vorhanden und die Entwicklung wird sicherlich rasch vorangehen, denn der Dienst wächst mit knapp 10% pro Tag.

Weiter ins Detail gehen kann ich jetzt noch nicht, da ich einfach zu frisch auf dem System bin, aber das werde ich später gerne noch nachholen

Seid ihr auch auf App.Net unterwegs? Sagt mir was ihr davon haltet und fügt mich hinzu wenn ihr mögt -> @bigbasti

Sicherlich kennt ihr diese hässlichen Popups auf größeren Seiten wie Welt.de die auch eine (Bezahl-)App im Appstore haben. Diese Popups sind nicht nur unschön, sondern nerven auch extrem!

In iOS6 will Apple das Ganze nun etwas verschönern und bietet den Webseiten an ein Banner über dem Seiteninhalt anzuzeigen, das die gewünschte App inklusive ein paar Informationen wie Bewertung und Hersteller enthält.

Wie das aussehen kann seht ihr in dem oberen Screenshot des Safari unter iOS6. Statt einem Popup zeigt ted.com den neuen Banner an.

Implementierung

Wenn ihr eure Seite auch mit einer App verknüpfen wollt könnt ihr das ziemlich einfach gestalten:

<meta name="apple-itunes-app" content="app-id=%APPID%, app-argument=%APPPARAMETER%">

Ihr bindet einfach den oberen Meta-Tag in eurem Header ein und der mobile Safari erledigt den Rest. Ihr habt hier dabei zwei Parameter zu befüllen, wobei der zweite optional ist.

Die App-ID ist die Id der App im Appstore. Diese findet ihr in der URL der App im iTunes Store:

http://itunes.apple.com/de/app/doodle-jump-achtung-hochste/id307727765?mt=8

Dabei gebt ihr nur die Zahl an (ohne "id").

Der zweite Parameter wird der App (falls die verlinkte App bereits installiert ist) übergeben. So könnt ihr den Besucher nahtlos in die App wechseln lassen und automatisch an die Stelle in der App springen auf der der Besucher auf der Webseite war.

Da iOS6 sich wenn es bald raus ist ziemlich schnell verbreiten wird lohnt es sich sicher schon mal die Header anzupassen

Eine der einfachsten und schnellsten Möglichkeiten Logging zu implementieren ist es die fertige und sehr mächtige Library Log4Net zu nutzen. Java Entwickler werden diese als Log4J kennen und schätzen.

Am schnellsten geht es wenn ihr Log4Net über NuGet installiert:

Nun habt ihr schon mal die Assembly in eurem Projekt. Als nächstes müssen wir Log4Net konfigurieren. Das kann man zum Beispiel in der web.config machen:

    <configSections>
        <section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net"/>
    </configSections>

    <log4net>
        <root>
            <level value="ALL" />
            <appender-ref ref="RollingFile" />
        </root>
        <appender name="RollingFile" type="log4net.Appender.RollingFileAppender">
            <file value="app.log" />
            <appendToFile value="true" />
            <maximumFileSize value="1000KB" />
            <maxSizeRollBackups value="2" />
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%date [%thread] %-5p %c - %message%newline" />
            </layout>
        </appender>
    </log4net>

Interessant ist hier eigentlich der Appender-Teil, denn hier definiert ihr wie geloggt werden soll. In diesem Beispiel werden alle Ausgaben in eine Datei namens app.log geloggt, weiterhin werden Informationen wie Datum, Zeit, Thread, Log-Level, Klasse und Lognachricht angezeigt. Hier gibt es unendlich viele Kombinationen.

Auf der Homepage von Log4Net findet ihr noch viele andere Beispiele für Appender-Configs, mit denen ihr direkt in eine Datenbank loggen könnt, oder die Nachrichten an einen SMTP Server senden könnt, die dann per Mail versendet werden. Natürlich kann auch auf die Konsole geloggt werden, sucht euch einfach die Appender aus die ihr benötigt und tragt diese ein, ihr könnt auch mehrere Appender kombinieren.

Bevor ihr nun losloggen könnt müsst ihr den Logger noch laden. Das macht ihr in der Application_Start-Methode in der Global.asax.cs. Hierzu reicht eine einfach Zeile:

log4net.Config.XmlConfigurator.Configure();

Wenn ihr die Konfiguration von Log4Net in eine Extra Datei auslagern wollt, könnt ihr hier auch den Pfad zu dieser Konfiguration angeben.

log4net.Config.XmlConfigurator.Configure(new System.IO.FileInfo(filename));

Nun wechseln wir mal in einen Controller und loggen mal etwas:

    public ActionResult Index()
    {
        ILog logger = LogManager.GetLogger(typeof(HomeController));

        logger.Info("Index Action wurde aufgerufen.....");

        try
        {
            logger.Debug("Don't mess with math dude...");
            int zero = 0;
            int endOfWorld = 12 / zero;
        }
        catch (Exception ex)
        {
            logger.Error("Ohh noez, you're dead now!", ex);
        }

        return View();
    }

Wie man sieht funktioniert das Ganze ziemlich einfach und effektiv. Der Logger lässt euch zwischen verschiedenen Log-Leveln auswählen. In der XML-Konfiguration definiert ihr den Loglevel, dann werden nur bestimmte Dinge geloggt. So könnt ihr für Diagnosezwecke den DEBUG-Level setzen um alle wichtigen Infos zu erhalten, und später wenn alles erledigt ist den Level wieder auf INFO senken.

So sieht übrigens die Ausgabe zu dem oberen Code aus:

Im Grunde ziemlich simpel, aber sehr effektiv. Alternativ kann man auch ELMAH verwenden.

Ein Demo-Projekt findet ihr hier.

Besonders zu Beginn eines Projekts ist es super bequem den DropCreateDatabaseAlways-Initialisierer zu benutzen, der einem bei jeder Modeländerung eine frische und an das neue Model aktuelle Datenbank generiert. Doch irgendwann läuft die Applikation und man hat diverse Testdaten gespeichert die man nicht verlieren will, oder die App wurde nun schon installiert und ein Update steht bevor - was nun?

Natürlich kann man die Datenbank nicht mehr einfach neu erstellen mit DropCreateDatabaseAlways da dann auch alle Daten verloren gehen. Man muss die Datenbank aktualisieren, und genau hier kommen die Entity Framework Migrations ins Spiel, die seit der Version 4.3 Bestandteil des EF sind.

Falls ihr noch eine alte Version von EF verwendet solltet ihr NuGet anschmeißen und die neue Version installieren:

Ich würde euch empfehlen nun den CreateDatabaseIfNotExists-Initialisierer für eure Datenbank zu nutzen, um eure Daten nach der Modeländerung nicht zu verlieren.

Wenn ihr nun euer model ändert und versucht die App zu starten solltet ihr diesen Fehler zu sehen bekommen:

”The model backing the 'YourDBContext' context has changed since the database was created. Consider using Code First Migrations to update the database (http://go.microsoft.com/fwlink/?LinkId=238269).” 

1. Nun müssen wir aktiv werden und die Datenbank-Migration aktivieren

Dazu führen wir den Befehl "Enable-Migrations" auf der NuGet Konsole aus. Dieses Kommando legt einen neuen Ordner namens "Migrations" in eurem Projekt an.

In diesem Ordner werdet ihr eine "Configurations"-Klasse finden, die ca so aussehen sollte:

internal sealed class Configuration : DbMigrationsConfiguration
{
    public Configuration()
    {
        AutomaticMigrationsEnabled = false;
    }

    protected override void Seed(DB context)
    {
        //  This method will be called after migrating to the latest version.

        //  You can use the DbSet.AddOrUpdate() helper extension method 
        //  to avoid creating duplicate seed data. E.g.
        //
        //    context.People.AddOrUpdate(
        //      p => p.FullName,
        //      new Person { FullName = "Andrew Peters" },
        //      new Person { FullName = "Brice Lambson" },
        //      new Person { FullName = "Rowan Miller" }
        //    );
        //
    }
}

Dies sollte euch an eure Initialisierungs Klasse erinnern, denn hier habt ihr auch eine Seed-Methode, die nach der Migration ausgeführt wird und euch die Möglichkeit gibt direkt Daten in die Datenbank zu schreiben.

Ich würde weiterhin empfehlen den Konstruktor der Klasse um folgende Anweisung zu erweitern:

AutomaticMigrationDataLossAllowed = false;

Dies sorgt dafür, dass ihr keine Daten verliert wenn die Datenbank aktualisiert wird.

2. Erste Migration anlegen

Nun wind wir soweit, dass wir unsere erste Migration anlegen können, dies geschieht ebenfalls über die NuGet Konsole mit dem Befehl: "Add-Migration" Anschließend werdet ihr noch nach einem Namen für die Migration gefragt, hier könnt ihr eure Fantasie benutzen

Es wird nun eine weitere Klasse in eurem Migrations-Ordner angelegt, diese hat ein Timestamp und eure Bezeichnung im Namen. Die Klasse ist in eine Up- & Down-Methode aufgeteilt, in der jeweils die Aktionen gespeichert sind, die nötig sind um die gewünschten Änderungen an der Datenbank durchzuführen oder diese Änderungen wieder rückgängig zu machen.

public partial class Initial : DbMigration
{
    public override void Up()
    {
    }

    public override void Down()
    {
    }
}

3. Migration durchführen

Nun können wir damit beginnen die Datenbank zu verändern. Hier haben wir nun zwei Möglichkeiten.

1. Direktes Update durchführen über die NuGet Konsole
2. Ein SQL Skript erzeugen und dieses dann auf dem SQl-Server ausführen

Da ich auf meinem Entwicklungsrechner keine Verbindung zu der Produktivumgebung habe, erzeuge ich eigentlich immer SQL Skripte, die ich dann auf der Remote-Maschine benutze um die Datenbank zu aktualisieren.

1. Direkt Update

Dazu nutzen wir den Befehl "Update-Database".  Dadurch wird die Datenbank auf die neueste Version aktualisiert. Wenn ihr auf einen Spezifischen Stand updaten oder downgraden wollt könnt ihr den Stand über den Parameter "-TargetMigration=$" machen. "Update-Database -TargetMigration=XXX".

Falls ihr einen älteren Stand angebt, werden die Down-Methoden der aktuelleren Migrationsklassen aufgerufen.

2. SQL Skript erzeugen

Wenn ihr dem "Update-Database" Befehl den "-Script" Parameter übergebt, wird für euch ein Migrations Skript angelegt, dass alle nötigen Änderungen enthält. Diese betreffen auch die Downgrades, falls ihr einen älderen Stand als Ziel angebt.

Dieses SQL Skript kann dann problemlos auf dem SQL Server eingespielt werden und verhält sich genau wie eine "Direkte" Migration.

Zusammenfassung

Die Entity Framework Datenbank Migration ist eine sehr bequeme Art die Datenbank auf seinem Testsystem und auch auf dem Zielsystem zu aktualisieren. Vor Allem ist es cool, dass ich jederzeit auch Zwischenreleases wiederherstellen kann.

Doch erreichen mich immer mehr Mails mit der Frage danach wie man den Schlüssel wiederherstellen kann wenn man Windows neuinstalliert hat, wenn die Installation beschädigt ist oder wenn die Daten auf einer anderen Festplatte liegen.

Manchmal passiert es auch, dass Get My Keys Back es nicht schafft den Office Key auszulesen, obwohl Office installiert ist. Mit dieser Anleitung könnt ihr es nun manuell machen.

Get My Keys Back funktioniert hier natürlich nicht, da es nur in der gerade aktiven Registry nach dem Schlüssel sucht. Ich habe mich mit dieser Frage etwas beschäftigt und hoffe euch mit diesem Beitrag eine Hilfestellung geben zu können.

SerialDecoder

Um es euch möglichst einfach zu machen habe ich das kleine Tool "SerialDecoder" geschrieben, das ihr ab sofort auf meiner Homepage herunterladen und testen könnt. Dieses Programm benötigt aber auch die Werte aus der Registry, und zwar aus der Registry die nicht mehr aktiv ist, z.B. die auf eurer anderen Festplatte von der ihr die Seriennummer haben wollt.

Der Prozess den Schlüssel zu beschaffen unterteilt sich in drei Schritte:

1. Beschaffen der Registrydaten von der alten Festplatte
2. Beschaffen der Daten aus der alten Registry
3. Umwandeln der Daten in den schlüssel

An euch liegt es nun diese Daten aus der anderen Festplatte zu lesen. Dies ist relativ einfach, folgt einfach dieser kleinen Anleitung:

1. Schließt die alte Festplatte an und öffnet diese im Windows Explorer
2. Navigiert dort in das Verzeichnis: \Windows\System32\config
3. Kopiert aus diesem Verzeichnis die Datei "SOFTWARE" in ein Verzeichnis auf eurer aktiven Festplatte.
   

   Die gesuchte Datei

4. Startet nun die Registry, indem ihr die Windows-Taste und die R-Taste gleichzeitig drückt.
   

   Windows-Taste + R drücken

5. In das nun erscheinende Fenster tippt ihr "regedit" ohne "" und drückt auf OK.
6. Im Regestrierungseditor klickt ihr auf Datei und dann auf Struktur laden... (Tipp: Struktur laden ist nur anklickbar, wenn ihr den passenden Knoten (HKEY_LOCAL_MACHINE) auswählt)
   

   Struktur laden

7.  Wählt nun die eben kopierte Datei "SOFTWARE" aus.
   

   Datei laden

8. Gebt nun einen schlüssigen Namen ein z.B. "Alte Festplatte"
9. Nun wird diese Registry Datei geladen und ihr seht sie in eurem Registry-Explorer. Öffnet diese nun.

Schritt 2: Auslesen der Schlüssel

Navigiert in der nun geladenen Struktur an folgende Stellen um die Keys zu erhalten:

Office auf 32-Bit Systemen:

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Office

Office auf 64-Bit Systemen:

HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\Office

Bei Office wählt ihr nun eure Version, wobei

• 11 = 2003
• 12 = 2007
• 14 = 2010
• 15 = 2013

Im Normalfall solltet ihr einfach die größte Zahl auswählen. In diesem Verzeichnis wählt ihr nun den Ordner Registration. Hier werden wahrscheinlich einige Ordner mit sehr kryptischen Namen sein, sucht den wo der Schlüssel namens "DigitalProductId" auftaucht:

Probiert die Ordner einfach durch, der richtige Ordner ist meist der mit den meisten Schlüsseln.

Klickt nun mit der rechten Maustaste auf den passenden Ordner und wählt "Exportieren". Speichert die Datei nun ab.

(Falls ihr nur diesen Key benötigt springt zum Schritt 3 Schlüssel umwandeln weiter unten)

Windows Key:

SOFTWARE\Microsoft\Windows NT\CurrentVersion

Hier seht ihr nun einige Schlüssel, unter Anderem auch den DigitalProductId, der uns interessiert (Beispiel für Windows Key).

Klickt nun mir der rechten Maustaste auf den Ordner "CurrentVersion" in der rechten Übersicht und wählt "Exportieren" und speichert die Daten an einem für euch leicht wieder findbaren Ort.

Schritt 3: Schlüssel umwandeln

Da ihr nun die Daten zum Windows und/oder zum Office Key gesichert habt könnt ihr diese nun nutzen um den Key wiederherzustellen.

Nun müsst ihr mein kleines Tool namens "SerialDecoder" von meiner Homepage laden und starten.

Öffnet nun eine der Dateien die ihr eben durch das Exportieren erstellt habt in einem Texteditor:
Sucht den Eintrag namens "DigitalProductId" und markiert alle Zeichen ab hex: bis zum Ende des Eintrags. Ein Beispiel wie es aussehen kann seht ihr in dem Oberen Bild. Wichtig: Markiert wirklich nur diesen Bereich ohne das hex: und ohne den Eigenschaften-Namen, wirklich genauso wie es oben in dem Bild gezeigt ist.

Das Bild zeigt ein Beispiel für einen Windows Key, die Office-Keys sind für gewöhnlich länger, lasst euch davon also nicht verwirren.

Kopiert diesen Markierten Text nun in die Zwischenablage und fügt diesen Text nun im SerialDecoder ein:

Nicht erschrecken: Der SerialDecoder entfernt alle unnötigen Zeichen wie Leerzeichen und Zeilenumbrüche.

Klickt nun auf "Schlüssel auslesen" unten im Fenster und wählt die Art von Schlüssel die ihr auslesen wollt. (Hier Windows Key)

Der SerialDecoder wandelt nun die Daten in euren Key um.

ACHTUNG: SerialDecoder kann nicht feststellen ob ihr die Daten korrekt eingefügt habt, also ob ihr vielleicht zuviel kopiert habt oder zu wenig. Deswegen achtet sehr genau was ihr reinkopiert! Des Weiteren kann ich natürlich nicht für die Korrektheit des ausgelesenen Keys garantieren. Das Programm ist grad in der Testphase und lebt momentan von eurem Feedback, damit ich es weiter verbessern kann.