Tag Archives: .Net Framework

Entity Framework CodeFirst für SQLite

Der ORM Mapper aus dem Hause Microsoft namens “Entity Framework” unterstützt ein sehr nützliches und häufig verwendetes Feature bzw. Ansatz namens “CodeFirst”.
“CodeFirst” ist nichts anderes als die automatische Generierung einer (SQL)-Datenbank, basierend auf dem geschrieben Code (Model). Dabei wird auf convention over configuration gesetzt und so generiert der folgende Code eine Datenbank mit zwei Tabellen inkl. Primary- und Foreign-Keys.

public class Player
{
	public int Id { get; set; }
	public string FirstName { get; set; }
	public string LastName { get; set; }
	public Team Team { get; set; }
}

public class Team
{
	public int Id { get; set; }
	public string Name { get; set; }
	public ICollection<Player> Players { get; set; }
}

In einem laufenden Projekt, an dem ich mitarbeite, soll eine SQLite Datenbank einsetzt werden.

SQLite ist eine Programmbibliothek, die ein relationales Datenbanksystem enthält. SQLite unterstützt einen Grossteil der im SQL-92-Standard festgelegten SQL-Sprachbefehle. Unter anderem implementiert SQLite Transaktionen, Unterabfragen (subselects), Sichten (views), Trigger und benutzerdefinierte Funktionen.

Quelle: Wikipedia

Der Datenbank Zugriff wird mit dem Entity Framework realisiert. Die Entity Framework Unterstützung für SQLite lässt sich über ein NuGet Package hinzufügen: https://www.nuget.org/packages/System.Data.SQLite.

Leider unterstützt SQLite bzw. das SQLite NuGet-Package den CodeFirst-Ansatz nicht. Über diesen Post bin ich auf ein Stück Code gestossen, dass rudimentär den CodeFirst Ansatz implementiert: https://gist.github.com/flaub/1968486e1b3f2b9fddaf

Da ich für das Projekt noch ein paar weitere Funktionalitäten hinzufügen musste und der Code produktiv eingesetzt wird, habe ich beschlossen ein Refactoring durchzuführen und diesen Code wiederum auf GitHub zu veröffentlichen.

Das Resultat findet sich hier:
SQLite CodeFirst
Was alles unterstützt wird und wie die Library verwendet werden kann, ist im GitHub ReadMe beschrieben: Zum ReadMe.

Outlook & C# Serie – Introduction

In meinem letzten privaten Projekt habe ich als PoC einen Prototypen gebaut welcher den Windows Live (oder Outlook.com) Kalender mit Outlook 2013 synchronisiert. Dabei bin ich auf der Outlook 2013 Seite auf einige “Hindernisse” gestossen. Diese Hindernisse und natürlich wie sie zu überwinden sind, stelle ich in der “Outlook & C# Serie” vor.

Mit diesem Post wird erst einmal der Grundstein gelegt. Jeder Anfang ist schwer, deshalb ganz allgemein: Wie hole ich Daten aus meinem Outlook?

Es ist egal ob ein Add-in geplant ist oder ob von einer externen Applikation bsp. WPF auf Outlook Elemente zugegriffen werden soll, der Code ist derselbe. Dafür wird folgendes benötigt.

  1. VSTO (Visual Studio Tools for Office) Installieren:
    http://www.microsoft.com/en-us/download/details.aspx?id=23656

  2. Referenz hinzufügen
    Falls nun ein Add-in geschrieben werden soll, einfach ein Projekt des entsprechenden Typs erstellen. In diesem Fall soll jedoch eine externe Applikation entwickelt werden. Dafür wird ein neues Projekt erstellt und die folgende DLL referenziert:
    C:Program Files (x86)Microsoft Visual Studio 12.0Visual Studio Tools for OfficePIAOffice15Microsoft.Office.Interop.Outlook.dll

  3. Zugriff auf Outlook
    Um Zugriff auf das Outlook Objekt modell zu erhalten wird eine neue Instanz der folgenden Klasse erstellt “Microsoft.Office.Interop.Outlook.Application”.

Outlook ist in Folder organisiert. Hier ein Beispiel wie der Kalender Folder geholt werden kann:

var appointmentsFolder = (Folder)outlook.Session.GetDefaultFolder(OlDefaultFolders.olFolderCalendar);

Eine Übersicht über das Objektmodell gibt es hier: http://msdn.microsoft.com/en-us/library/ms268893.aspx

Get Types by Interface

Die Anforderung ist relativ einfach und kommt immer wieder. Alle Types welche ein bestimmtes Interface implementieren sollen zurückgegeben werden.

var interfaceType = typeof(IMyInterface);
var types = AppDomain.CurrentDomain.GetAssemblies()
    .SelectMany(t => t.GetTypes())
    .Where(t => interfaceType.IsAssignableFrom(t) && !t.IsInterface && !t.IsAbstract);

Das Snippet liefert dabei nur Types zurück die selbst kein Interface sind und Instanziert werden können (nicht abstrakt).