Ich habe mich ein wenig mit MongoDB beschäftigt, ich finde den Ansatz interessant Daten einfach als Binary JSON ablegen zu können. Ich wollte allerdings wissen wie der Einsatz von MongoDB in einer Web Anwendung aussieht. Hierzu habe ich eine ASP.NET MVC Anwendung verwendet die lediglich Daten anzeigt, erzeugt und aktualisert. Dazu erzeuge ich in jedem Request einen Connect und Disconnecte mich wieder im Dispose Event vom Controller. Diese Anwendung habe ich mittels eines Web Tests in Visual Studio 2010 aufgezeichnet und unter Last (nur auf meinem Laptop) mit 5 verschiedenen Browsern testen lassen.

Die ersten zwei Minuten verlief der Test erstaunlich gut, die Anzahl der Page Requests / Sekunde war faszinierend schnell. Nach zwei Minuten kamen dann aber die ersten Einbrüche. Sieht man im Diagramm oben Links, die blaue Kurve, diese stellt die Pages / Sec dar. Der Peek entsteht durch den Garbage Collector der sich dann ans Aufräumen macht. Trotzdem überzeugen die Resultate

Das ständige Auf- und abbauen der Connection war auch primär mein Testziel. Ich wollte sehen ob MongoDB an irgendeiner Stelle schlapp macht, aber selbst nach über 39.000 Verbindungen in 10 Minuten ist das Ding noch stabil und performant.

Noch besser fande ich allerdings den Speicherverbrauch von MongoDB der war während des Tests nicht einmal über 5 MB gegangen. Ok, ich hatte auch nicht wahnsinnig viele Daten die ich erzeugt habe, aber vergleicht man das mit traditionellen Datenbanken ist es schon ein wahnsinnig großer Unterschied.

Nach diesem Test werde ich MongoDB für mein nächstes Projekt einsetzen. Da es sich bequem über die Kommandozeile starten lässt und ich ein beliebiges Verzeichnis als Datenspeicher definieren kann, ist es auch in Windows Azure einsetzbar. Die Daten lassen sich dann auf ein Cloud Drive legen und sind somit auch an verschiedene VMs anhängbar.

Falls jemand von Euch schon Erfahrungen mit MongoDB oder ähnlichen Datenspeichern gesammelt hat, ich würde mich über Euer Feedback freuen.

Gestern ist der MSDN Webcast zum Thema Entity Framework 4 – Was ist neu? erschienen. In diesem Webcast gehe ich vor allem auf eine neue Möglichkeit mit dem Entity Framework 4 zu arbeiten ein: Code First.

Code First

erlaubt es beliebige Objektmodelle auf ein relationales Schema zu mappen, ohne dabei Abhängigkeiten im Objektmodell auf das Entity Framework zu haben.

Beispiel

Die Klasse Firma hat Mitarbeiter. Diese beiden Klassen liegen in einem eigenen Assembly und könnten so aussehen:

public class Firma
{
    public Guid Id { get; set; }
    public string Name { get; set; }
    public List<Mitarbeiter> Mitarbeiter { get; set; }
}

public class Mitarbeiter
{
    public int Personalnummer { get; set; }
    public string Nachname { get; set; }
    public string Vorname { get; set; }
    public Firma Firma { get; set; }
}

Wenn man nun die beiden Klassen auf ein relationales Modell mappen möchte so kann man in der Anwendung wo dies geschehen soll entsprechende Mappings definieren.

public class FirmaMap : EntityConfiguration<Firma>
{
    public FirmaMap()
    {
        Property( f => f.Id ).IsIdentity();
        Property( f => f.Name ).HasMaxLength( 50 ).IsRequired();
        Relationship( f => f.Mitarbeiter ).FromProperty( m => m.Firma );
    }
}

public class MitarbeiterMap : EntityConfiguration<Mitarbeiter>
{
    public MitarbeiterMap()
    {
        Property( m => m.Personalnummer ).IsIdentity();
        Property( m => m.Nachname ).HasMaxLength( 30 ).IsRequired();
        Property( m => m.Vorname ).HasMaxLength( 30 );
        Relationship( m => m.Firma ).FromProperty( s => s.Mitarbeiter );
    }
}

Mit Hilfe der Mappings lässt sich auch die Datenbank anlegen und zur Laufzeit erstellen (Rechte voraussgesetzt). Was noch lediglich fehlt ist der typisierte ObjectContext welchen ich hier mal aussen vorlasse (gibt es in der Doku und im Webcast zu sehen), ich möchte lediglich noch den Code zeigen der zum Anlegen der Mappings wichtig ist und der es einem dann erlaubt die Datenbank zu erstellen:

var builder = new ContextBuilder<FirmenModel>();

builder.Configurations.Add( new FirmaMap() );
builder.Configurations.Add( new SessionMap() );

var connection = new SqlConnection("some connection string");

using( var context = builder.Create( connection ) )
{
    // das ist nur für Demos sinnvoll die Datenbank vorher zu löschen
    if( context.DatabaseExists() )
    {
        context.DeleteDatabase();
    }

    // dieser Befehl erstellt die Datenbank anhand der Mappings
    context.CreateDatabase();

    // weitere Code zum arbeiten mit den Objekten
    ...
}

Entity Framework 4 – Was ist neu?

Ein Tweet (Twitter-Eintrag) hat mich auf diese Idee gebracht. Da hat jemand seine alte Platte aus dem Keller geholt und mal drauf geschaut was da so alles drauf war. Ich habe heute mal eine alte Box mit CD’s aufgemacht aus vergangenen Tagen. Dabei ist mir eine Projekt CD ins Auge gesprungen die ich mir nochmal angeschaut habe.

Mein Aufruf

Ich fand das so Interessant das ich einfach mal einen Aufruf starten möchte: Postet doch mal Euer Zeug was Ihr so vor 10 oder mehr Jahren gemacht habt, ein Stück Code oder einfach nur einen Screenshot.

Mein Beispiel aus dem Jahre ‘99

Ich selbst habe mich für eine C++ Header Datei entschieden. Damals im Projekt haben wir oft VB6 Komponenten einbinden müssen und es gab meist einen generischen Parameter: SafeArrays. Jeder der schonmal mit C++ SafeArrays implementiert hat, weiß was das für ein Käse ist. Die entwickelte Hilfsklasse machte es einfacher mit den Dingern umzugehen. Hier ist der Code (nur der Header) aus dem Jahre 99:

////////////////////////////////////////////////////////////////////////////////
// ComDefEx.h - Erweiterung zu ComDef.h und ComUtil.h

#ifndef _COMDEFEX_H
#define _COMDEFEX_H

#ifndef _COMDEFEX_API
#define _COMDEFEX_API
#endif

#include <ComDef.h>


////////////////////////////////////////////////////////////////////////////////
// Exception handling

#define _COM_RAISE_ERROR( __hres )                                              \
{                                                                               \
  HRESULT hres = __hres;                                                        \
                                                                                \
  if( FAILED( hres ) )                                                          \
  {                                                                             \
    _com_raise_error( hres );                                                   \
  }                                                                             \
}


#define _COM_RAISE_UNEXPECTED()         _com_raise_error( E_UNEXPECTED )
#define _COM_RAISE_OUTOFMEMORY()        _com_raise_error( E_OUTOFMEMORY )
#define _COM_RAISE_INVALIDARG()         _com_raise_error( E_INVALIDARG )


////////////////////////////////////////////////////////////////////////////////
// _guid_t Declaration

class _COMDEFEX_API _guid_t : public GUID
{
  public:
    // Construction/Destruction
                              _guid_t();
                              _guid_t( const GUID& guid );
                              _guid_t( LPCSTR pszGuid );
                              _guid_t( BSTR bstrGuid );
                              _guid_t( const _bstr_t& bstrGuid );
                              _guid_t( VARIANT vGuid );
                              _guid_t( const _variant_t& vGuid );

    // Operators
    _guid_t&                  operator =( const GUID& guid );
    _guid_t&                  operator =( LPCSTR pszGuid );
    _guid_t&                  operator =( BSTR bstrGuid );
    _guid_t&                  operator =( const _bstr_t& bstrGuid );
    _guid_t&                  operator =( VARIANT vGuid );
    _guid_t&                  operator =( const _variant_t& vGuid );

                              operator _bstr_t() const;     // without braces
                              operator _variant_t() const;  // BSTR without braces

    // General Operations
    void                      GetAsString( _bstr_t& bstrGuid, bool bIncBraces = FALSE ) const;
    void                      GetAsString( _variant_t& vGuid, bool bIncBraces = FALSE ) const;
};


////////////////////////////////////////////////////////////////////////////////
// _safearray_elm/_safearray_t Declaration

template< class T >
class _safearray_t;

template< class T >
class _safearray_elm
{
  // Friends
  friend class _safearray_t< T >;

  // Construction/Destruction
  protected:
                              _safearray_elm( SAFEARRAY* psa, int ix1 );
                              _safearray_elm( SAFEARRAY* psa, int ix1, int ix2 );
                              _safearray_elm( SAFEARRAY* psa, int ix1, int ix2, int ix3 );
                              _safearray_elm( SAFEARRAY* psa, int ix1, int ix2, int ix3, int ix4 );

  // Operators
  public:
    _safearray_elm&           operator =( const T& src );
                              operator T() const;

  // Attributes
  protected:
    SAFEARRAY*                m_psa;
    long                      m_rgnIndexPath[ 4 ];
};


template< class T >
class _safearray_t
{
  // Construction/Destruction
  public:
                              _safearray_t();

                              _safearray_t( const _safearray_t& src );
                              _safearray_t( const SAFEARRAY* psa );
                              _safearray_t( SAFEARRAY* psa, bool bCopy );

                              _safearray_t( const VARIANT& src );
                              _safearray_t( VARIANT& src, bool bCopy );

                              ~_safearray_t();

  // Operators
  public:
    _safearray_t&             operator =( const _safearray_t& src );
    _safearray_t&             operator =( const SAFEARRAY* psa );
    _safearray_t&             operator =( const VARIANT& src );

    const _safearray_elm< T > operator ()( int ) const;
    _safearray_elm< T >       operator ()( int );

    const _safearray_elm< T > operator ()( int, int ) const;
    _safearray_elm< T >       operator ()( int, int );

    const _safearray_elm< T > operator ()( int, int, int ) const;
    _safearray_elm< T >       operator ()( int, int, int );

    const _safearray_elm< T > operator ()( int, int, int, int ) const;
    _safearray_elm< T >       operator ()( int, int, int, int );

                              operator const SAFEARRAY*() const;
                              operator SAFEARRAY*();

                              operator VARIANT() const;

  // General Operations
  public:
    void                      Attach( SAFEARRAY* psa );
    void                      Attach( VARIANT& src );

    SAFEARRAY*                Detach();
    _variant_t                DetachVariant();

    void                      Create( UINT nSize1 );
    void                      Create( UINT nSize1, UINT nSize2 );
    void                      Create( UINT nSize1, UINT nSize2, UINT nSize3 );
    void                      Create( UINT nSize1, UINT nSize2, UINT nSize3, UINT nSize4 );

    SAFEARRAY*                Copy() const;

    int                       GetLowerBound( UINT nDim = 1 ) const;
    int                       GetUpperBound( UINT nDim = 1 ) const;
    int                       GetSize( UINT nDim = 1 ) const;
    bool                      IsEmpty() const;

  // Attributes
  protected:
    SAFEARRAY*                m_psa;
};


////////////////////////////////////////////////////////////////////////////////
// Miscellaneous

extern _variant_t             vtEmpty;
extern GUID                   guidEmpty;


struct _SafeLPCSTR
{
  inline LPCSTR operator ,( LPCSTR psz ) { return psz ? psz : ""; }
};


#define SafeLPCSTR( p )       ( _SafeLPCSTR(), ( LPCSTR ) p )


#include "ComDefEx.inl"


#endif  // !_COMDEFEX_H

Würde mich freuen wenn noch jemand diese Idee Lustig findet und einfach mal über sein Zeug bloggt was er damals so gemacht hat.

Vittorio Bertocci bietet einen zwei tägigen Workshop zu Claims-based Authentication und Windows Identity Foundation an. Hier ein Auszug aus der Agenda:

The Workshops Format

2 days of full immersion in Claims-Based Identity and Windows Identity Foundation, where traditional lectures are alternated to instructor-led labs. Everything will be as interactive as it can be, so that you can squeeze as much value as possible from your participation: which is why I am personally flying to every location for delivering the training. Here there’s a high level agenda:

Day 1

• Registration and Breakfast
• Introduction to WIF and Claims Based Identity
• Break
• Labs: Basic Web Sites
• Lunch
• WIF ASP.NET Pipeline and Extensibility Points
• Break
• Labs: More Web Sites
• Break
• ASP.NET Scenarios

Day 2

• Breakfast
• WIF and WCF
• Break
• Labs :  Web Services and Identity
• Lunch
• WIF and Other Technologies
• Break
• Labs:   WIF and Windows Azure
• Break
• Challenge: Build a Solution According to Specs
• Wrap-up & Next Steps

Momentan gibt es noch keinen bestätigten Termin für Deutschland. Wenn Ihr Interesse an diesem Workshop habt, schreibt mir eine Email (dparys at microsoft.com).

Letzte Woche habe ich RESTPoll publiziert, eine REST Service API um Umfragen zu erstellen. Da es noch keinen Client dafür gab, habe ich jetzt eine erste Version einer Silverlight Anwendung fertig und eine Test-Umfrage erstellt. Falls sich ein freiwilliger findet, ein schönes UI dafür zu scribbeln, würde ich mich freuen.

Hier die Test-Umfrage zu einem nicht technischen Thema:

Wer im übrigen mal die API ausprobieren möchte, kann einfach den gleichen Silverlight Client nehmen. Im Parameter initParams einfach die Poll Id austauschen.

Als nächstes werde ich noch ein Live Writer Plugin schreiben das es einem erlaubt Polls direkt im Live Writer zu erstellen und mit seinem Blog Post zu publizieren.

Hinweis: Funktioniert momentan leider nur mit der Sl4 Beta Runtime, versuche das schnell zu fixen.

Hinweis 2: Silverlight 3 Runtime sollte jetzt auch funktionieren.

In Visual Studio 2010 gibt es nun die Möglichkeit direkt auf Klassen- und Methoden zu navigieren. Hierzu drückt man den Tastatur Short Cut CTRL + , und erhält den Navigate To Dialog.

Im oberen Beispiel habe ich nach bill gesucht und erhalte nun alle in der Solution vorhandenen Deklarationen die den Teilbegriff bill beinhalten.

Neben dem Navigate To Dialog zeige ich im Screencast wie man durch Cursorpositionierung alle auf dem Screen sichtbaren Verwendungen einer Klasse, Eigenschaft oder Methode angezeigt bekommt. Das folgende Beispiel zeigt die Methode SendBillEvent, der Cursor steht bei BillEvent, einem Delegate und automatisch werden die restlichen sichtbaren Verwendungen durch ein Grau hinterlegt.

Das ganze hier auch noch als Screencast, zum Anschauen:

Letztes Jahr hatte ich eine Screencast Serie über die Entwicklung einer Silverlight Poll Anwendung gestartet. Während der Entwicklung gab es das ein oder andere Problem, ich wurde auch während der Serie von Silverlight 3 überholt und im Prinzip habe ich die Serie nie beendet.

Ich habe mir diese Wochen nochmals Gedanken darüber gemacht und werde die Screencast Serie mit Sicherheit bis Ende Mai zu Ende bringen. Ja, ich weiß, ist zwar auch noch ewig, aber ich möchte das ganze dann auch auf Silverlight 4 machen.

Damit ich für den Client auch eine Basis habe, habe ich diese Woche einen REST Service geschrieben den ich auch seit heute publiziert habe.

Der Service ist zu erreichen unter http://restpoll.cloudapp.net und sollte grundsätzlich funktional sein. Er hat mit Sicherheit viele Bugs (seit Ihr ja von mir gewohnt) und die JSON Serialisierung habe ich noch gar nicht getestet (wirklich gar nicht, kann sein das die gar nicht tut).

Mit dem Service kann ich Polls anlegen und publizieren. Er ist kostenfrei und wird auf Windows Azure gehostet. Die Daten werden auf Windows Azure Storage abgelegt.

Über Feedback würde ich mich freuen, speziell zum Design der API, da diese mir selbst schon zu umständlich vorkommt.

Blog Poll REST API

Um ein Plain Old Xml über den XmlSerializer auszuspucken, muss man die Standardeinstellungen ändern und die Namensräume weglassen. Hier ist eine Extension Method die das realisiert:

public static class XmlSerializerExtensions
{
    public static void SerializeAsPlainOldXml(this XmlSerializer serializer, 
                                                Stream stream, object o)
    {
        XmlWriterSettings settings = new XmlWriterSettings();
        settings.OmitXmlDeclaration = true;
        settings.Indent = true;

        XmlSerializerNamespaces noNamespaces = new XmlSerializerNamespaces();
        noNamespaces.Add(string.Empty, string.Empty);

        using (XmlWriter writer = XmlWriter.Create(stream, settings))
        {
            serializer.Serialize(writer, o, noNamespaces);
        }
    }
}

Danach kann man das Objekt einfach per serializer.SerializeAsPlainOldXml(stream, obj) als Plain XML wegschreiben, wobei serializer eine Instanz von XmlSerializer ist.