Weblogs-Einträge und Nachrichten unserer Experten

Nachfolgend die Unterlagen und Beispiele, die ich heute bei meinem Vortrag bei der .NET User Group in Graz verwenden werde. Zum Einrichten der Beispiele kann die Anleitung unter [1] verwendet werden.

Zum Nachvollziehen des erweiterten Beispiels mit dem LOB-Adapter und Lookup-Provider muss man:

• Einen SQL-LOB-Adapter einrichten, der auf eine lokale Orders-Tabelle (ID int identity(1,1) primary key, PNR varchar(50), ONR varchar(50), cnt int) verweist, einrichten
• Die Maps und den Verweis auf den LOB-Adapter in der Bridge-Konfiguration anpassen oder entsprechend neu gestalten
• Die Konfiguration des Lookup-Providers auf eine SQL Azure DB mit einer entsprechenden Tabelle anpassen

Infos dazu findet man unter [2]. Dort findet man zwei Tutorials, welche die Arbeit mit dem Service-Bus veranschaulichen.

[1] http://www.softwarearchitekt.at/post/2012/04/29/Azure-Service-Bus-EAI-und-EDI-Folien-und-Beispiele-von-Basta-on-Tour-2012-in-Koln.aspx

[2] http://msdn.microsoft.com/en-us/library/windowsazure/hh689864

Azure Service Bus.pdf (1,38 mb)

Azure-Service-Bus-Sample.zip (2,69 mb)

Microsoft hat mich letzte Woche für meine Community-Aktivitäten als Azure-Insider ausgezeichnet, was mich sehr freut. Das bedeutet unter anderem, dass ich nun einen direkten Draht zum Produkt-Team in Redmond habe und somit vorab mit wichtigen und vertraulichichen Informationen versorgt werde. Daneben kann ich mich mit Fragen direkt an die Leute vor Ort wenden.

Nachfolgend meine Folien und mein Beispiel zum Vortrag "Azure Service Bus EAI und EDI", welchen ich diese Woche auf der BASTA! on Tour 2012 in Köln gehalten habe.

Um das Beispiel zum Laufen zu bekommen, muss man ...

• Die aktuelle Azure Service Bus EAI und EDI CTP (am besten in einer Test-VM!!) installieren: http://www.microsoft.com/en-us/download/details.aspx?id=17691
• Im Azure Labs-Portal einen Namespace anlegen: https://portal.appfabriclabs.com/Default.aspx
• Im .NET-Framework-Verzeichnis (z. B. C:\Windows\Microsoft.NET\Framework\v4.0.30319\Config) die beiliegende Datei ServiceBus.config positionieren, damit die Beispiele nicht auf den "echten" Service-Bus sondern auf die Labs-Umgebung zugreifen (es handelt sich dabei ja noch um eine CTP!)
• In der Bridge-Konfiguration die Eigenschaft Namespace auf den zuvor eingerichteten Namespace anpassen
• Im Projekt ESB die Endpunkt-Konfiguration von Client-A und Service-B anpassen, sodass sie auf die entsprechenden URL, welche u. a. den eingerichteten Namespace beinhalten, verweist.
  • Diese Adressen findet man in der Eigenschaft Runtime-Adress, die im Eigenschaften-Fenster zu finden ist, nachdem man in der Bridge-Konfiguration entweder OrderA oder OrderB angeklickt hat. Ersteres steht für die Cient-A und letzteres für den Service-B.

Azure ServiceBus.pdf (625,79 kb)

APRIL_2012_Orders_BOT.zip (2,61 mb)

Nachfolgend findet man die Folien und Beispiele meiner Session zu WCF Security von der BASTA! on Tour. Die Beispiele beinhalten folgende Szenarien:

• Windows Security
• Windows Security via SSL
• SSL mit benutzerdefinierter Benutzerprüfung (benutzerdefinierte AuthorisationPolicy und PasswordValidator)
• SSL mit Clientzertifikaten
• Nachrichtenbasierte Sicherheit mit teilweiser Verschlüsselung der SOAP-Nachrichten

Um die letzten beiden Beispiele zum Laufen zu kriegen, muss man vorher mit der mitgelieferten .bat-Datei die entsprechenden Zertifikate erstellen und diese anschließend im Certificate Store installieren. Am besten verwendet man dazu den als Administrator gestarteten Visual Studio Command Prompt. Den Certificate Store erreicht man über das Zertifikate-Snap-In der Management Console (mmc). Die generierten Dateien ca.cer und ca.crl sind unter "Vertrauenswürdige Stammzertifizierungsstellen" einzutragen; server.pfx und client.pfx unter eigene Zertifikate.

Da das Beispiel für Client-Zertifikate SSL ohne IIS verwendet, ist zusätzlich das server-Zertifikat an das gewünschte SSL-Port zu binden. Dies kann mit dem folgenden Kommandozielen-Befehl bewerkstelligt werden. 44400 ist dabei das gewünschte Port; unter certhash ist der Fingerabdruck des Zertifikates einzutragen und unter appid eine beliebige (eindeutige) GUID.

netsh http add sslcert ipport=0.0.0.0:44400 certhash=e31a0a8320d6f89ba5849a9c46d43c44dd2133ea appid={00112233-4455-6677-8899-AABBCCDDEEFF}

Das WIF-Beispiel befindet sich zwar nicht direkt in dieser Beispielsammlung, aber nachfolgend findet man eine Schritt-für-Schritt-Anweisung, mit der dieses Beispiel nachgestellt werden kann.

WCF_Security.pdf (585,09 kb)

WCF-Security-Szenarien.zip (965,39 kb)

Claims-Sample.pdf (647,27 kb)

Nachfolgend platziere ich meine Folien zu meiner Session "Cloud Computing mit Windows Azure: Einführung und ein Erfahrungsbericht aus einem echten Cloud-Projekt", welche ich diese Woche auf der BASTA! on Tour in Köln gehalten habe. Darüber hinaus findet man nachfolgend auch mein Beispiel zu Azure Federations - der direkt in SQL Azure integrierten Sharding-Lösung.

steyer_Azure.pdf (1,83 mb)

steyer_Azure_Erfahrungsbericht.pdf (1,04 mb)

federations.sql.txt (2,37 kb)

Diese Woche habe ich auf der BASTA! on Tour in Köln aus organisatorischen Gründen eine weitere Session zum Thema "Mobile Web-Apps mit ASP.NET WebAPI, SignalR, jQuery Mobile und knockout.js" kurzerhand eingeschoben. Das Ziel war es zu zeigen, wie man eine mobile, offline- und echtzeit-fähige Web-App mit einem Mix aus serverseitigen Code und Java-Script APIs bauen kann.

Für die mobile GUI kommt  dabei jQuery Mobile zum Einsatz; für die Kommunikation mit dem Server, die neue ASP.NET Web API. Echtzeit-fähigkeit wird mit Web Sockets bzw. dem neuen SignalR-Framework realisiert und für das Offline-Szenario werden der HMTL 5 Local Storage und das Cache-Manifest bemüht, wobei ersterer mittels amplify.js abstrahiert wird, damit auch ältere Browser, die ein zum Local Storage vergleichbares Konzept anbieten, adressiert werden können.

Die Sourcen dazu, welche zu geschätzten 80% aus einem realen Projekt stammen, findet man nachfolgend.

In zwei Wochen findet wieder die BASTA! on Tour in Düsseldorf statt. Der Schwerpunkt dabei ist wieder das Thema Architektur. Mit dabei sind Jörg Neumann, Dr. Holger Schwichtenberg, Christian Wenz, Christian Weyer und meine wenigkeit.

Ich hab wieder die Ehre, auf dieser Veranstaltung über WCF und Security mit WCF (u. a. mit WIF) zu sprechen. Daneben werden ich über Erfahrungen aus einem Azure-Projekt plaudern und die Möglichkeiten von Azure Service Bus, der künftig um EAI/ EDI-Möglichkeiten erweitert wird, erzählen.

Weitere Infos findet man unter http://basta-on-tour.de/

In „Edition 2“ geht es diesmal um die Klärung von zwei Fragestellungen aus der Wirtschaft: „Wie kann man Dienstleistungen vor der Markeinführung simulieren und testen?“ und „Wie kann man intelligente Dienstleistungen durch intelligente Kundenintegration (Smarte Services) entwickeln, die einen besonderen Mehrwert für den Kunden und das eigene Unternehmen bringen?“.

Dazu werden bekannte Verfahren aus der Produktentwicklung den neuen Ansätzen im Dienstleistungsentwicklungsumfeld (u.a. Fraunhofer IAO aus Stuttgart und Evolaris next level GmbH aus Graz mit dem Living Lab) gegenübergestellt. In Fallstudien wird aufgezeigt, wo Smarte Services bereits am Wirken sind und wie man diese entwickelt. Im Rahmen einer Podiumsdiskussion mit internationalen ExpertInnen werden schlussendlich die Potentiale der vorgestellten Ansätze beleuchtet und branchenübergreifende Zusammenhänge hergestellt.

Natürlich gibt es auch heuer wieder viele Möglichkeiten um in den Pausen und im Anschluss der Veranstaltung mit den Experten direkt zu diskutieren und es werden wieder Angebote vorgestellt, um Hilfestellung bei der Optimierung der eigenen Dienstleistungslandschaft im Unternehmen zu bekommen.

Weitere Informationen:

http://www.campus02.at/DE/Studieng%c3%a4nge/Informationstechnologien%20%20Wi5/News%20%20Events/Events/ServTec+2012.aspx

public enum EntityState
{
    Unmodified = 0,
    Modified = 1,
    Deleted = 2
}

public interface IEntity
{
    EntityState State { get; set; }
}

public abstract class Entity : IEntity, ILifecycle
{
    public virtual EntityState State { get; set; }

    public  virtual void MarkAsDeleted()
    {
        State = EntityState.Deleted;
    }

    public virtual void MarkAsModified()
    {
        State = EntityState.Modified;
    }

    public virtual void MarkAsUnModified()
    {
        State = EntityState.Unmodified;
    }

    public virtual LifecycleVeto OnDelete(NHibernate.ISession s)
    {
        return LifecycleVeto.NoVeto;
    }

    public virtual void OnLoad(NHibernate.ISession s, object id)
    {
        State = EntityState.Unmodified;
    }

    public virtual LifecycleVeto OnSave(NHibernate.ISession s)
    {
        return LifecycleVeto.NoVeto;
    }

    public virtual LifecycleVeto OnUpdate(NHibernate.ISession s)
    {
        return LifecycleVeto.NoVeto;
    }


}

[Class(Name = "NHibernateSample.entities.Bestellung, NHibernateSample")]
public class Bestellung : Entity
{
    public Bestellung()
    {
        Positionen = new Iesi.Collections.Generic.HashedSet<Position>();
    }

    protected int bestellungId;


    protected DateTime bestellDatum { get; set; }

    [Id(0, Name = "BestellungId")]
    [Generator(1, Class = "hilo")]
    public virtual int BestellungId
    {
        get { return bestellungId; }
        set
        {
            bestellungId = value;
            this.MarkAsModified();
        }
    }

    [Property(0, Name = "BestellDatum")]
    public virtual DateTime BestellDatum
    {
        get { return bestellDatum; }
        set
        {
            bestellDatum = value;
            this.MarkAsModified();
        }
    }


    [Set(0, Name = "Positionen", Lazy = CollectionLazy.True,
        Cascade = "NONE", Inverse = true)]
    [Key(1, Column = "BestellungId")]
    [OneToMany(2,
        Class = "NHibernateSample.entities.Position,NHibernateSample")]
    public virtual IesiCollections.ISet<Position> Positionen { get; set; }

    public virtual void AddPosition(Position p)
    {
        Positionen.Add(p);
        p.Bestellung = this;
        this.MarkAsModified();
        // p.State = EntityState.Modified;
    }

}


    [Class(Name = "NHibernateSample.entities.Position, NHibernateSample")]
    public class Position : Entity
    {

        [Id(0, Name = "PositionId")]
        [Generator(1, Class = "native")]
        protected virtual int? PositionId { get; set; }


        protected int anzahl;

        [Property(0, Name = "Anzahl")]
        public virtual int Anzahl
        {
            get { return anzahl; }
            set
            {
                anzahl = value;
                this.MarkAsModified();
            }
        }


        private String pizza;

        [Property(0, Name = "Pizza")]
        public virtual String Pizza
        {
            get { return pizza; }
            set
            {
                pizza = value;
                this.MarkAsModified();
            }
        }


        private Bestellung bestellung;

        [ManyToOne(0, Name = "Bestellung", Column = "BestellungId")]
        public virtual Bestellung Bestellung
        {
            get { return bestellung; }
            set
            {
                bestellung = value;
                this.MarkAsModified();
            }
        }


    }

public static class SessionExtensions {
        public static void Attach(this ISession session, IEntity obj) {
           
            if (obj.State == EntityState.Modified)
            {
                session.SaveOrUpdate(obj);
            }
            else if (obj.State == EntityState.Deleted)
            {
                session.Delete(obj);
            }
        }

        public static void AcceptChanges<T>(this Iesi.Collections.Generic.ISet<T> set)
        {
            foreach (IEntity entity in set)
            {
                entity.State = EntityState.Unmodified;
            }
            
        }


        public static void AttachAll<T>(this ISession session, Iesi.Collections.Generic.ISet<T> set)
        {

            foreach (IEntity entity in set)
            {
                Attach(session, entity);
            }
        }   
    }

class BestellungDAO
{

    […]

    /// <summary>
    /// Speichert Bestellung inkl. Positionen
    /// </summary>
    /// <param name="b"></param>
    public void Save(Bestellung b)
    {
        using (ISession session = HibernateHelper.SessionFactory.OpenSession())
        {
            using (ITransaction trans = session.BeginTransaction())
            {
                session.SaveOrUpdate(b); // Keine Cascade !!
                session.AttachAll(b.Positionen);

                trans.Commit();

                b.MarkAsUnModified();
                b.Positionen.AcceptChanges();
            }
        }
    }
}

public static void SaveBestellung()
{
    BestellungDAO dao;
    dao = new BestellungDAO();

    Bestellung b = new Bestellung
    {
        BestellDatum = DateTime.Now,
    };

    Position p1 = new Position { Anzahl = 2, Pizza = "Test 1"};
    b.AddPosition(p1);

    Position p2 = new Position { Anzahl = 2, Pizza = "Test 2"};
    b.AddPosition(p2);

    Position p3 = new Position { Anzahl = 2, Pizza = "Test 3" };
    b.AddPosition(p3);

    dao.Save(b);

    p2.Anzahl = 4;
    p3.State = EntityState.Deleted;

    dao.Save(b);

}

• Durch die Verwendung von Reflection und einer Tiefen- oder Breitensuche könnten alle geänderten Entitäten eines Objektgraphen mit nur einem Methodenaufruf an die Session übergeben werden.
• Diese Implementierung  funktioniert lediglich für ISet aus den IesiCollections. Man sollte hier über eine allgemeine Implementierung nachdenken.

.NET 4.5, Visual Studio 11 und Windows 8 biegen auf die Zielgerade ein. Was bedeutet das für Softwareentwickler? Was ist Hype? Was braucht man? Welche Techniken sind jetzt "tot"?

Wir laden Sie herzlich ein zu unserem Infotag am Mi, 20.06.2012 (Fußballfans: an dem Tag ist kein EM-Spiel!)

9:30 bis 19:00 Uhr in Essen.

Referenten: FH-Prof. Manfred Steyer, Dr. Joachim Fuchs und Dr. Holger Schwichtenberg

Inhalte: C# 5.0, Visual Basic 11, ADO.NET 4.5 und ADO.NET Entity Framework 5.0, ASP.NET 4.5, ASP.NET MVC, ASP.NET Web API, WCF 4.5, WPF 4.5, App-Programmierung mit Windows 8, Migration auf Azure und Visual Studio 11

Genaue Agenda: http://www.IT-Visions.de/[QBMS]/go.aspx?N21INT

Erfahren Sie jetzt schon, was mit .NET 4.5, Visual Studio 11 und Windows 8 auf Sie als .NET-Softwareentwickler zukommt. Dieser Infotag liefert Ihnen einen prägnanten Überblick über die kommenden Entwicklerprodukte von Microsoft. Sie erhalten eine geballte Informationsladung und eine objektive, neutrale Bewertung - ohne Marketing-Aussagen von Microsoft. Vortragende an diesem Tag sind drei Top-Experten der .NET-Entwicklungsszene, die Sie von Vorträgen, Fachartikeln und Fachbüchern schon kennen:

149€ zzgl. 19% MwSt (Frühbucherpreis bis 30.04.2012) danach 199€ zzgl. 19% MwSt

Wir freuen uns auf Ihre Anmeldung per Website oder Faxformular.

Anmeldung: http://www.IT-Visions.de/[QBMS]/go.aspx?N21INT

Möchten Sie diesen Infotag lieber als In-House-Veranstaltung für beliebig viele Teilnehmer zum Festpreis buchen?

Senden Sie uns eine Anfrage über dieses Formular: http://www.IT-Visions.de/[QBMS]/go.aspx?N21INT

Nachfolgend mein Code Only-Beispiel, welches ich heute Vormittag auf der BASTA! Spring präsentiert habe.

src.zip (1,70 mb)

Weitere Links:

• Code Only und Self Tracking Entities: http://tinyurl.com/76qwxrx 
• Entity Framework Power Tools CTP1 für Database First und Code Only: http://tinyurl.com/ef-power-tools-ctp1

Nachfolgend der Link zu unserem Code Only Cheat Sheet.

http://www.it-visions.de/produkte/seminar.aspx?v=6298

Nachfolgend die Unterlagen meiner Session zu NoSQL, BASE und Sharding am Beispiel von Azure Storage Services und SQL Azure Federations auf der BASTA! Spring 2012.

Nachfolgend findet man die Folien von meinem Vortrag über Azure "AppFabric", den ich in zwei Stunden beim Architekturforum von MS Österreich halten werde. Mein Beispiel zu "AppFabric" Integration (AppFabric Dec. 2011 CTP) findet man unter [1].

AppFabric.pdf (611,22 kb)

[1] http://www.softwarearchitekt.at/post/2012/01/08/Azure-(AppFabric)-EAIEDI-December-2011-CTP-Sample-sending-SOAP-and-SWT-Token-to-XML-Bridge.aspx

Below, you find a sample for the Azure (AppFabric) EAI/EDI December 2011 CTP with a client (Client A) that sends a SOAP-message to an XML-Bridge. The bridge transforms the message and sends it to the destination service (OrderServiceB). This service is located on-premise and connected to the cloud by the usage of a relay-binding.

To send a SOAP-message to the bridge, the client has to request a SWT-Token from Azure (AppFabric) Access Control. For that, it uses the helper-classes AccessControllClient and WrapUtil located in the directory tools. After retrieving it, it includes the token in the actual message within a HTTP-header. Furthermore, the client has to send this message using SSL (Transport-Security without credentials).

After the transformation of the request, the bridge has to change to SOAP-Action-header for the receiving service within a route action; after the receipt and transformation of the response, the SOAP-Action-header now containing the action associated with the response is changed one more time for the receiver using a send action.

The file EAI_Order_Sample.zip contains the EAI-Project; EAI_ServicesAndClients_without_Key.zip consists of the Client (ClientA) and Service (OrderServiceB). Furthermore, it contains a OrderServiceA which directly accepts the SOAP-messages created from Client A (without transformation) and a ClientB that directly sends correct SOAP-messages to OrderServiceB. The latter two were used for creating and testing the former two and are not required for this sample. Both services write the received orders to c:\temp and support for the Cancellation-Option within ClientA has not been implemented yet.

Below, you find a sample for the Azure (AppFabric) EAI/EDI December 2011 CTP with a client (Client A) that sends a SOAP-message to an XML-Bridge. The bridge transforms the message and sends it to the destination service (OrderServiceB). This service is located on-premise and connected to the cloud by the usage of a relay-binding.

To send a SOAP-message to the bridge, the client has to request a SWT-Token from Azure (AppFabric) Access Control. For that, it uses the helper-classes AccessControllClient and WrapUtil located in the directory tools. After retrieving it, it includes the token in the actual message within a HTTP-header. Furthermore, the client has to send this message using SSL (Transport-Security without credentials).

After the transformation of the request, the bridge has to change to SOAP-Action-header for the receiving service within a route action; after the receipt and transformation of the response, the SOAP-Action-header now containing the action associated with the response is changed one more time for the receiver using a send action. 

The file EAI_Order_Sample.zip contains the EAI-Project; EAI_ServicesAndClients_without_Key.zip consists of the Client (ClientA) and Service (OrderServiceB). Furthermore, it contains a OrderServiceA which directly accepts the SOAP-messages created from Client A (without transformation) and a ClientB that directly sends correct SOAP-messages to OrderServiceB. The latter two were used for creating and testing the former two and are not required for this sample. Both services write the received orders to c:\temp and support for the Cancellation-Option within ClientA has not been implemented yet.

EAI_Order_Sample.zip (44,89 kb)

EAI_ServicesAndClients_without_Key.zip (2,57 mb)

Am Dienstag, 10. Jänner 2012 werde ich ab 16:00 am Architekturforum bei MS Österreich über Windows Azure Service Bus, Access Control und Applications sprechen. Nachfolgend die Beschreibung sowie der Link für die Anmeldung.

Windows Azure stellt eine Middleware-Lösung für die Cloud zur Verfügung. Sie bringt u. a. einen Service Bus sowie einen Security Token Service für erweiterte Sicherheitsszenarien, die Single-Sign-On sowie das "ausdehnen" einer Windows-Domäne auf die Cloud ermöglichen.

Für den Zugriff auf REST-basierte Services bietet WCF WebAPI mit der Klasse HttpClient eine Erleichterung für Entwickler. In den Genuss dieser Neuerung kommt man, indem man über NuGet die WebAPI ins Client-Projekt lädt.

Asynchronität

WebClient ist in Hinblick auf Asynchronität  entworfen, was man unter anderem daran bemerkt, dass sämtliche Methoden, welche zum Übertragen von Daten zur Verfügung stehen, lediglich in einer aynchronen Variante, welche als Ergebnis einen Task liefert, angeboten werden. Über die Eigenschaft Result von Task kommt man dann zum Ergebnis, wobei diese Eigenschaft so lange blockiert, bis dieses tatsächlich zur Verfügung steht. Dies korreliert mit dem Mindset, welches mit Windows 8 und Metro Einzug halten soll: Alles was länger als x ms dauert, wird zur Verbesserung des Antwortverhaltens der Anwendung asynchron.

Anfragen absenden

Für die vier populärsten HTTP Verben steht jeweils eine Methode zur Verfügung: GetAsync, PostAsync, PutAsync und DeleteAsync. Übergeben wird an diese Methoden die URL der anzusprechenden Ressource. Überladungen erlauben auch die Übergabe eines CancellationTokens zum Abbruch der angestoßenen asynchronen Aktion sowie das Angeben eines Wertes des enums HttpCompletionOption. Mit letzterem wird festgelegt, ob lediglich der Header (HttpCompletionOption.ResponseHeadersRead) oder auch die Nutzdaten (HttpCompletionOption.ResponseContentRead) der Antwort zu lesen sind.

Daten senden

Der Einsatz von PostAsync und PutAsync erwartet die Übergabe von zu sendenden Nutzdaten in der Form einer Instanz des Typs HttpContent (siehe Methode PostBuchungDemo, unten). Hierbei handelt es sich um eine abstrakte Klasse, deren Subklassen verschiedene Darstellungsformen von Ressourcen repräsentieren. So kann zum Beispiel an ObjectContent, wie in der unten abgebildeten Methode PostBuchungDemo ersichtlich, ein zu serialisierendes Objekt übergeben werden. Alternativen dazu sind u. a. die selbstsprechenden Klassen StringContent und StreamContent. Hierbei ist darauf zu achten, dass jene HTTP-Header, die den Inhalt betreffen dem ObjectContent bekannt zu geben sind; die restlichen können über die Eigenschaft DefaultRequestHeaders von HttpClient festgelegt werden. Wie der Name dieser Eigenschaft schon vermuten lässt, werden diese Header-Einträge standardmäßig bei jedem Aufruf, der über den jeweiligen HttpClient erfolgt, herangezogen. Diese logische Aufteilung dürfte für HTTP-Kenner nicht gerade intuitiv erscheinen, da sämtliche HTTP-Header gemeinsam und ohne Gruppierung übertragen werden.

Die volle Kontrolle

Möchte man die volle Kontrolle über die zu sendenden Anfragen haben, kann die Methode SendAsync bemüht werden (siehe Methode SendBuchungDemo, unten). In diesem Fall kann man von den vier Verben GET, POST, PUT und DELETE abweichen und auch Header-Einträge für eine bestimmte Anfrage setzen.

Fazit

Auch wenn die betrachtete API derzeit noch ein wenig Wortreich ist und ab und an ein paar Convenience-Methoden schön wären, bietet diese sich noch in Entwicklung befindliche API mehr Komfort als die bis dato zur Verfügung gestandenen Alternativen. Man muss sich nicht mehr um das Serialisieren und Deserialisieren selber kümmern, es werden out-of-the-box die wichtigsten Darstellungsformen, wie JSON, XML oder URL-Encodet Strings, unterstützt und man erhält Unterstützung beim Definieren der Header durch die API.

private static void GetHotelsDemo()
{
    HttpClient client = new HttpClient();

    HttpResponseMessage response = client
                                    .GetAsync("http://localhost:5721/hotels?$filter=Sterne ge 4",HttpCompletionOption.ResponseContentRead)
                                    .Result;
            
    if (!response.IsSuccessStatusCode)
    {
        Console.ForegroundColor = ConsoleColor.Red;
        Console.WriteLine("Fehler: " + response.StatusCode + " "
                            + response.Content.ReadAsStringAsync().Result);
        Console.ReadLine();
    }

    var hotels = response
                    .Content
                    .ReadAsOrDefaultAsync<List<Hotel>>()
                    .Result;

    foreach (var hotel in hotels)
    {
        Console.WriteLine(hotel.ToString());
    }
}

private static void PostBuchungDemo()
{
    HttpClient client = new HttpClient();

    client.DefaultRequestHeaders.AcceptLanguage.Add(new StringWithQualityHeaderValue("bar"));
    client.DefaultRequestHeaders.AcceptLanguage.Add(new StringWithQualityHeaderValue("x-styrian"));
    client.DefaultRequestHeaders.AcceptLanguage.Add(new StringWithQualityHeaderValue("de"));

    HotelBuchung buchung = new HotelBuchung { HotelId = 2, Vorname = "Peter", Nachname="Silie" };
    HttpContent content = new ObjectContent(typeof(HotelBuchung), buchung);
    content.Headers.ContentType = JsonMediaTypeFormatter.DefaultMediaType;
            
    HttpResponseMessage response = client
                                    .PostAsync("http://localhost:5721/hotels/3/buchungen", content)
                                    .Result;

    if (!response.IsSuccessStatusCode)
    {
        Console.ForegroundColor = ConsoleColor.Red;
        Console.WriteLine("Fehler: " + response.StatusCode + " "
                            + response.Content.ReadAsStringAsync().Result);
        Console.ReadLine();
    }

    Console.WriteLine("Status: " + response.StatusCode);
    Console.WriteLine("Content: " + response.Content.ReadAsStringAsync().Result);

}

private static void SendBuchungDemo()
{
    HttpClient client = new HttpClient();

    HotelBuchung buchung = new HotelBuchung { HotelId = 2, Vorname = "Peter", Nachname = "Silie" };

    HttpContent content = new ObjectContent(typeof(HotelBuchung), buchung);
    content.Headers.ContentType = JsonMediaTypeFormatter.DefaultMediaType;

    HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, "http://localhost:5721/hotels/3/buchungen");
    request.Headers.AcceptLanguage.Add(new StringWithQualityHeaderValue("bar"));
    request.Headers.AcceptLanguage.Add(new StringWithQualityHeaderValue("x-styrian"));
    request.Headers.AcceptLanguage.Add(new StringWithQualityHeaderValue("de"));
    request.Content = content;

    HttpResponseMessage response = client
                                    .SendAsync(request)
                                    .Result;

    if (!response.IsSuccessStatusCode)
    {
        Console.ForegroundColor = ConsoleColor.Red;
        Console.WriteLine("Fehler: " + response.StatusCode + " "
                            + response.Content.ReadAsStringAsync().Result);
        Console.ReadLine();
    }

    Console.WriteLine("Status: " + response.StatusCode);
    Console.WriteLine("Content: " + response.Content.ReadAsStringAsync().Result);

}

Unterstützung für REST gibt es in der WCF schon längere Zeit, wobei diese bis dato eher eingeschränkt war. Dies ist mitunter der Tatsache geschuldet, dass WCF das zum Einsatz kommende Transportprotokoll „weg-abstrahiert“. Gerade bei REST benötigt man jedoch die volle Kontrolle über die HTTP-basierten Nachrichten. Die in den Startlöchern stehende WCF WebAPI [1] soll hier Abhilfe schaffen. Dieser Blog-Eintrag zeigt, wie man eine einfache Hotel-Reservierung mit dieser neuen Bibliothek entwickeln kann.

Einrichten

Am einfachsten kommt man via NuGet [3] in den Genuss der aktuellen Vorab-Version von WebAPI. Es handelt sich dabei um einen Package-Manager, welcher zur Verfügung gestellte Komponenten aus einem Repository herunterlädt und direkt ins gewünschte Visual Studio-Projekt integriert. NuGet kann über den Extension Manager von Visual Studio 2010 heruntergeladen und eingerichtet werden (Tools | Extension-Manager). Danach kann NuGet über den Befehl Manage NuGet Packages, welcher sich im Kontextmenü der einzelnen Projekte im Solution-Explorer wieder findet, zum Herunterladen der WebAPI herangezogen werden. Dazu wird im NuGet-Dialog einfach nach WCF WebAPI gesucht und die Komponente WebApi.all ausgewählt. Das hier besprochene Beispiel geht davon aus, dass die Preview 6 von WebAPI im Rahmen einer Web-Anwendung Verwendung findet.

Datenvertrag und Services

Zunächst werden Datenverträge eingerichtet. Im betrachteten Beispiel handelt es sich hierbei um eine Klasse Hotel sowie um eine weitere Kasse HotelBuchung.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Runtime.Serialization;

namespace WebAPI
{
    [DataContract(Namespace="www.softwarearchitekt.at/services/hotel")]
    public class Hotel
    {
        public Hotel() { 
            LastModified = DateTime.Now;  
        }

        [DataMember]
        public int HotelId { get; set; }

        [DataMember]
        public string Name { get; set; }

        [DataMember]
        public int Sterne { get; set; }

        [DataMember]
        public DateTime LastModified { get; set; }

        public override string ToString()
        {
            return HotelId + " " + Name + " " + Sterne;
        }


    }

    [DataContract(Namespace = "www.softwarearchitekt.at/services/hotel")]
    public class HotelBuchung {

        [DataMember]
        public int HotelBuchungId { get; set; }

        [DataMember]
        public int HotelId { get; set; }

        [DataMember]
        public string Vorname { get; set; }

        [DataMember]
        public string Nachname { get; set; }
        
    }

}

Die im letzten Abschnitt besprochene Methode erlaubt lediglich das Einschränken der abzurufenden Hotels anhand des Attributs Sterne. Wem das zu wenig ist, kann auf die in WCF WebAPI integrierte ODATA-Unterstützung zurückgreifen. Bei ODATA [2] handelt es sich um einen Standard, der es unter anderem erlaubt, Abfragen via HTTP zu formulieren. Um in den Genuss dieses Standards zu kommen, ist lediglich eine REST-Operation, welche als Rückgabewert IQueryable<T> liefert, einzurichten. 

[WebGet(UriTemplate="")]
public IQueryable<Hotel> GetHotels()
{
    return hotels.AsQueryable();
}

Nachfolgend findet man das Beispiel des End2End-Workshops, den ich heute auf der BASTA! on Tour gemeinsam mit Christian Wenz veranstaltet habe. Es zeigt das Zusammenspiel von EF, WCF und ASP.NET MVC 4 mit jQuery.

WWWingsLight.zip (6,29 mb)

Nachfolgend platziere ich meine Unterlagen sowie die Beispiele meiner Session "Die Zukunft von WCF: WCF 4.5" von der letzten BASTA! on Tour.

steyer_WCF.pdf (431,22 kb)

WCF_Futures_Samples.zip (1.018,46 kb)

Nachfolgend findet man die Unterlagen und das Beispiel zu meiner Session über ASP.NET MVC 4, Entity Framework und jQuery auf der letzten BASTA! on Tour.

steyer_MVC.pdf (726,81 kb)

HotelReservierung.zip (4,76 mb)

Nachfolgend mein Beispiel und meine Folien zu meiner Session über Code Contracts.

MiniBar.zip (44,21 kb)

Code_Contracts.pdf (698,17 kb)

Nachfolgend die Folien und Beispiele meines Teils der Session "Was ist neu in Visual Studio 2011 und .NET 4.5"?

wcf45_und_async_samples.zip (2,70 mb)

was-ist-neu.pdf (974,07 kb)

Nachfolgend meine Folien und mein Beispiel zur Session "Software Design mit C# 4 - Patterns und fortgeschrittene Sprachelemente".

SoftwareDesign.pdf (661,94 kb)

DesignByExample.zip (71,20 kb)

Nachfolgend findet man meine Folien und das Beispiel zu meiner Session "Testbare Systeme mit Dependency Injection und Mocking Frameworks"

steyer_Solution.zip (14,36 mb)

steyer_DI.pdf (639,86 kb)

Unter [1] habe ich gezeigt, wie man Self-Tracking Entities (STE) mit Code Only relativ einfach realisieren kann. Am Ende dieses Beitrags findet man die hier beschriebenen wiederverwendbaren Klassen (Datei TrackingHelper.cs) und ein Beispiel. Nachfolgend fasse ich zusammen, was zu tun ist, um diesen Ansatz in der Praxis einzusetzen.

-        Alle Entitäten implementieren das Interface IEntity, welches (analog zu STE) eine State-Eigenschaft vorgibt.

-        Wird die Entität verändert, muss der Status auf Changed gesetzt werden. Dies kann entweder, über eine Property (wie bei STE), über AOP (z. B. PostSharp) oder manuell geschehen.

o   Ausnahme: Ist die Entity ist im Zustand New, bleibt sie in diesem im Zustand
(wie bei STE)

-        Nach dem Speichern muss bei den Entitäten (wie bei STE) die Methode ResetState(s) aufgerufen werden, damit der Zustand (wieder) auf Unchanged gesetzt wird. Das selbe ist nach dem Laden zu machen.

-        Für Relationen ist ein „Fixup“ zu machen, d. h. wenn A auf B verweist, muss auch B auf A verweisen. Auch eventuelle Fremdschlüsselmappings müssen damit korrelieren. Dies kann entweder in den Properties erfolgen (wie bei STE), über AOP oder manuell. Ein Beispiel dafür findet man nachfolgend.

// Beispiel für manuelles "Fix-up"

// h2 ist vom Typ Hotel; r vom Typ Region

h2.Region = r;             // Region nach Hotel

h2.RegionId = r.RegionId;  // Hotel nach Region

r.Hotels.Add(h2);          // Fremdschlüsselmapping

[1] http://www.softwarearchitekt.at/post/2011/08/25/Self-Tracking-Entities-mit-Code-Only-implementieren.aspx

TrackingHelper.cs (1,93 kb)

CodeOnlyWithSTE_Sample.zip (43,21 kb)

Below I place the slides and samples I used during my "WCF futures"-Session.

steyer_WCF4.5.pdf (406,53 kb)

2011_10_18__WCF4.5_Samples_ScanDev.zip (576,86 kb)

WebAPI.zip (4,31 mb)

RIA_JS.zip (599,78 kb)

Für Fälle, in denen TCP zu viel Overhead mit sich bringt, bietet WCF 4.5 nun ein udpBinding an. Wie der Namen vemuten lässt, stützt es sich auf das verbindungslose Protokoll UDP und erlaubt somit eine, in Relation zu TCP gesehen, schlanke Form der Kommunikation - ohne Three-Way-Handshake und Bestätigungsnachrichten. Dies bedeutet aber auch, dass es der Sender nicht bemerkt, wenn Nachrichten verloren gehen. Insofern macht dieses Binding nur in Fällen sinn, wo das egal ist oder gar gewünscht ist, weil die Daten zum Beispiel nach einem erneuten Senden bereits veraltet wären.

Außerdem erlaubt UDP das Versenden von Multicasts. Damit sind Nachrichten gemeint, die von beliebig vielen Interessenten im lokalen Netzwerk empfangen werden können. Dazu verwendet man sowohl für den Service- also auch für den Client-Endpunkt eine IP-Adresse aus dem Bereich 224.x.x.x bis 239.x.x.x. Jene, die die Zeit der IPv4-Klassen miterlebt haben, werden diesen Adress-Bereich auch als Klasse D bezeichnen oder anders ausgedrückt: Alle Adressen dieses Bereichs beginnen haben ein binäres Muster, welches mit 1110 beginnt. Bei der Vergabe von Multicast-Adressen muss man sich jedoch vor Augen führen, dass die Adressen 224.x.x.x und 239.x.x.x für spezielle Zwecke reserviert sind, sodass sich dieser Wertebereich für die freie Verwendung auf 225.x.x.x bis 238.x.x.x beschränkt. Darüber hinaus soll an dieser Stelle nochmals ausdrücklich erwähnt werden, dass UDP-Nachrichten nicht über Netzwerkgrenzen geroutet werden und somit nur innerhalb eines Netzwerks herangezogen werden können.

Das nachfolgende Beispiel zeigt die Implementierung eines UDP-Multicasts. Es verwendet die Multicast-Adresse 225.1.1.1:9999. Somit können beliebig viele Instanzen des Service gestartet werden, wobei jeder Server alle vom Client gesendeten Nachrichten erhält, sofern diese nicht verloren gehen. Antworten mehrere Services auf eine Anfrage des Clients, zieht dieser lediglich die zuerst erhaltene heran; alle anderen werden ignoriert. Eine Möglichkeit, dies zu Umgehen, stellt der Einsatz von Callbacks (Duplex) dar. Allerdings unterstützt das udbBinding in der aktuellen Developer Preview (noch?) keine Duplex-Szenarien, weswegen diese manuell implementiert werden müssten.

Service-Konfiguration

<system.serviceModel>

 <services>
 <service name="UdpSample.FlugService">

 <endpoint address="FlugService" binding="udpBinding" contract="UdpSample.IFlugService"/>

 <host>
 <baseAddresses>
 <add baseAddress="soap.udp://225.1.1.1:9999/"/>
 </baseAddresses>
 </host>

 </service>
 </services>

 <behaviors>
 <serviceBehaviors>
 <behavior>
 <serviceMetadata httpGetEnabled="false" httpsGetEnabled="false"/>
 <serviceDebug includeExceptionDetailInFaults="true"/>
 </behavior>
 </serviceBehaviors>
 </behaviors>
 <serviceHostingEnvironment aspNetCompatibilityEnabled="true" multipleSiteBindingsEnabled="true"/>
</system.serviceModel>

Client-Konfiguration

<system.serviceModel>

 <client>
 <endpoint address="soap.udp://225.1.1.1:9999/FlugService"
 binding="udpBinding"
 contract="UdpSample.IFlugService"
 name="FlugService" />
 </client>

</system.serviceModel>

Nachfolgend findet man den 2. Teil unseres End-2-End-Workshops von der BASTA! den ich heute von meinem IT-Visions-Kollegen Joachim Fuchs erhalten habe. 

Basta2011Herbst.zip (3,13 mb)

Nachfolgend die Unterlagen zum ersten Teil des End-2-End-Workshops von der Basta (der zweite Teil, der dann auch den Workflow beinhaltet folgt noch).

Part1-Vormittag.zip (963,20 kb)

Nachfolend findet man meine Unterlagen sowie das Beispiel der Session über ASP.NET MVC und REST. 

• steyer_REST_MIT_MVC.pdf (701,49 kb)
• sample-BASTA.zip (603,51 kb)

Nachfolgend findet man den Link zu meiner Session über Entity Framework 4.1 Code Only, welche ich heute auf der BASTA! gehalten habe.

steyer_EF4_1_CodeOnly.pdf (458,12 kb)

Weitere Infos findet man hier:

• EF 4.1 Code Only Cheet Sheet
• Self-Tracking Entities mit Code Only Implementieren
• Entity Framework 4.1 Code First und ORACLE

Nachfolgend die Folien zu meinem Vortrag zur Scrum auf der BASTA! 2011 

steyer_Scrum.pdf (404,02 kb)

EF 4.1 bringt mit Code Only einige nette Möglichkeiten, die über den Code First-Ansatz hinausgehen. Doch leider muss man sich derzeit für eine der von EF bereitgestellten Spielarten entscheiden. Das bedeutet mitunter, dass man zwischen Code Only und Self Tracking-Entities entscheiden muss.

Was aber, wenn man Code Only in verteilten Umgebungen einsetzen möchte?

In diesem Fall wäre es wünschenswert, die Vorteile dieser beiden Ansätze zu verbinden. Das nachfolgende Beispiel demonstriert deswegen, wie mittels Code Only Entitäten mit den Eigenschaften von Self Tracking-Entities implementiert werden können. Der erste Teil beinhaltet ein paar allgemine Hilfskonstrukte; der zweite Teil zeigt anhand eines Beispiels, wie man diese einsetzt.

// --- Wiederverwendbarer Teil --------------

public enum DetachedEntityState
{
    New, Updated, Deleted, Unchanged
}

public interface IEntity
{
    DetachedEntityState State { get; set; }
}

public static class StateTrackingHelper
{

    public static void ApplyStates<T>(this ICollection<T> entities, DbContext ctx) where T : class, IEntity 
    {
        foreach (var e in entities)
        {
            ApplyState(e, ctx);
        }
    }

    public static void ApplyState<T>(this T entity, DbContext ctx) where T : class, IEntity
    {
        switch (entity.State)
        {
            case DetachedEntityState.New:
                ctx.Entry<T>(entity).State = System.Data.EntityState.Added;
                break;
            case DetachedEntityState.Updated:
                ctx.Entry<T>(entity).State = System.Data.EntityState.Modified;
                break;
            case DetachedEntityState.Deleted:
                ctx.Entry<T>(entity).State = System.Data.EntityState.Deleted;
                break;
        }
    }

    public static ICollection<T> ResetStates<T>(this ICollection<T> entities) where T : class, IEntity
    {
        foreach (var e in entities)
        {
            ResetState(e);
        }
        return entities;
    }

    public static void ResetState<T>(this T entity) where T : class, IEntity
    {
        entity.State = DetachedEntityState.Unchanged;
    }
        
}

// --- Anwendung --------------

public class Region: IEntity
{
    public Region()
    {
        Hotels = new List<Hotel>();
        Top10Hotels = new List<Hotel>();
    }

    private int _RegionId;
    public int RegionId
    {
        get
        {
            return _RegionId;
        }
        set
        {
            if (_RegionId != value) {
                _RegionId = value;
                this.State = DetachedEntityState.Updated; 
            }
        }
    }
    private string _Bezeichnung;
    public string Bezeichnung
    {
        get
        {
            return _Bezeichnung;
        }
        set
        {
            if (_Bezeichnung != value) {
                _Bezeichnung = value;
                this.State = DetachedEntityState.Updated; 
            }
        }
    }

    private ICollection<Hotel> _Hotels;

    public virtual ICollection<Hotel> Hotels
    {
        get
        {
            return _Hotels;
        }
        set
        {
            if (_Hotels != value) {
                _Hotels = value;
                this.State = DetachedEntityState.Updated; 
            }

        }
    }
    private ICollection<Hotel> _Top10Hotels;
    public virtual ICollection<Hotel> Top10Hotels
    {
        get
        {
            return _Top10Hotels;
        }
        set
        {
            if (_Top10Hotels != value) {
                _Top10Hotels = value;
                this.State = DetachedEntityState.Updated; 
            }

                 
        }
    }

    private DetachedEntityState _State;
    [NotMapped]
    public DetachedEntityState State
    {
        get
        {
            return _State;
        }
        set
        {
            _State = value;
        }
    }
}

public class Hotel : IEntity
{
    private int _HotelId;
    public int HotelId
    {
        get
        {
            return _HotelId;
        }
        set
        {

            if (_HotelId != value) {
                _HotelId = value;
                this.State = DetachedEntityState.Updated; 
            }

            
        }
    }
    private string _Bezeichnung;
    public string Bezeichnung
    {
        get
        {
            return _Bezeichnung;
        }
        set
        {
            if (_Bezeichnung != value) {
                _Bezeichnung = value;
                this.State = DetachedEntityState.Updated; 
            }
                
        }
    }
    private int _Sterne;
    public int Sterne
    {
        get
        {
            return _Sterne;
        }
        set
        {

            if (_Sterne != value) {
                _Sterne = value;
                this.State = DetachedEntityState.Updated; 
            }
        }
    }

    private int _RegionId;
    public int RegionId
    {
        get
        {
            return _RegionId;
        }
        set
        {
            if (_RegionId != value) {
                _RegionId = value;
                this.State = DetachedEntityState.Updated; 
            }
        }
    }

    private Region _Region;
    [ForeignKey("RegionId"), InverseProperty("Hotels")]
    public virtual Region Region
    {
        get
        {
            return _Region;
        }
        set
        {
            if (_Region != value) {
                _Region = value;
                this.State = DetachedEntityState.Updated; 
            }
        }
    }

    private DetachedEntityState _State;
    [NotMapped]
    public DetachedEntityState State
    {
        get
        {
            return _State;
        }
        set
        {
            _State = value;
        }
    }
        
}

public class WellnessHotel : Hotel
{
    private int _AnzahlSaunen;
    public int AnzahlSaunen
    {
        get
        {
            return _AnzahlSaunen;
        }
        set
        {
            if (_AnzahlSaunen != value) {
                _AnzahlSaunen = value;
                this.State = DetachedEntityState.Updated; 
            }
                
        }
    }
    private int _AnzahlThermalBecken;
    public int AnzahlThermalBecken
    {
        get
        {
            return _AnzahlThermalBecken;
        }
        set
        {
            if (_AnzahlThermalBecken != value) {
                _AnzahlThermalBecken = value;
                this.State = DetachedEntityState.Updated; 
            }
        }
    }
}

public class HotelDbContext : DbContext
{
    public HotelDbContext(): base("CodeOnlyHotelDb") { } // .\SQLEXPRESS

    public DbSet<Hotel> Hotels { get; set; }
    public DbSet<Region> Regionen { get; set; }
}

public class RegionDAO
{

    public List<Region> FindAll()
    {
        using (var ctx = new HotelDbContext())
        {
            var result = ctx.Regionen.Include("Hotels").ToList();
            result.ResetStates();
            return result;
        }

    }

    public void UpdateRegion(Region r)
    {
        using (var ctx = new HotelDbContext())
        {
            ctx.Regionen.Attach(r);

            r.ApplyState(ctx);
            r.Hotels.ApplyStates(ctx);
                
            ctx.SaveChanges();

            r.ResetState();
            r.Hotels.ResetStates();
        }
    }

    public void SaveRegion(Region r1)
    {
        using (var ctx = new HotelDbContext())
        {
            ctx.Regionen.Add(r1);
            ctx.SaveChanges();
        }
    }



}

class Program
{
    static void Main(string[] args)
    {
        Database.SetInitializer(new DropCreateDatabaseAlways<HotelDbContext>());

        CreateSaveModifySaveDemo();
        LoadShowModifySaveDemo();
        LoadShowModifySaveDemo();

        Console.WriteLine("fertig!");
        Console.ReadLine();

    }

    private static void CreateSaveModifySaveDemo()
    {
        var dao = new RegionDAO();

        Region r1 = new Region { Bezeichnung = "Graz" };
        Hotel h1 = new Hotel { Bezeichnung = "Hotel zur Post", Sterne = 2 };

        WellnessHotel h2 = new WellnessHotel
        {
            Bezeichnung = "Hotel zur Wellness",
            Sterne = 4,
            AnzahlSaunen = 3,
            AnzahlThermalBecken = 4
        };

        r1.Hotels.Add(h1);
        r1.Hotels.Add(h2);
        r1.Top10Hotels.Add(h2);

        dao.SaveRegion(r1);

        h2.Sterne++;
        r1.Bezeichnung += "!"; // kleine Änderung

        dao.UpdateRegion(r1);
    }

    private static void LoadShowModifySaveDemo()
    {
        var dao = new RegionDAO();

        var regionen = dao.FindAll();
        foreach (var r in regionen)
        {
            Console.WriteLine(r.Bezeichnung);
            r.Bezeichnung += "$"; // kleine Änderung
            int i = 0;
            foreach (var h in r.Hotels)
            {
                Console.WriteLine("\t" + h.Bezeichnung + ", Sterne: " + h.Sterne);
                if (i++ % 2 == 0) h.Bezeichnung += "$"; // kleine Änderung
            }
            Console.WriteLine();
            dao.UpdateRegion(r);
        }
            
    }

}

Bei jedem Deployment legt AppFabric June CTP einige temporäre Dateien, welche gemeinsam schon einige hundert MB groß sein können. Diese Dateien findet man unter dem versteckten Ordner C:\Users\USERNAME\AppData\Local\dftmp, wo sie darauf warten gelöscht zu werden.

Der Traum eines modernen Applikations-Servers für die Windows bzw. Windows Azure-Plattform rückt mit der June CTP von Azure AppFabric ein Stück näher, zumal in dieser Vorab-Version erstmals der Applikations-Manager enthalten ist. Damit lassen sich Applikationen konfigurieren und überwachen. Vorallem für die Konfiguration von mehrschichtigen Applikationen gibt es ein paar nette Ideen, welche die Verwaltung drastisch vereinfachen dürften.

Leider ist die CTP nicht ganz unproblematisch. Nachdem ich eine in VS 2010 erstellte AppFabric-Applikation mit CTRL-F5 gestartet hat, ist zunächst nicht viel passiert. Um die Applikation in Aktion zu sehen, bin ich wie folgt vorgegangen:

1. Applikation mit CTRL-F5 ausführen
2. In den IIS-Manager wechseln.
3. Web-Site, die zur Laufzeit für die aktuelle Ausführung der Applikation erstellt wurde, auswählen (Sie trägt den Namen des Projekts in sich).
   
   
4. Herausfinden, unter welchem Port die Site läuft (Rechtsklick | Bindungen bearbeiten).
5. Herausfinden, unter welchen (dynamisch erzeugten App-Pool) die Applikation ausgeführt wird (Rechtsklick | Website verwalten | Erweiterte Einstellungen).
6. App-Pool unter Anwendungspool auswählen und dessen Benutzer auf ein Konto setzen, welches die für die Applikation nötigen Rechte hat (Rechtsklick auf Pool | Erweiterte Einstellungen | Konto unter Identität festlegen).
7. App-Pool neu starten
8. Applikation neu starten
9. Applikation unter Verwendung der zuvor ermittelten Portnummer im Browser öffnen. Die URL lautet auf http://localhost:PORT/Webprojekt; Im betrachteten Fall ist dies http://localhost:PORT/Web1

Im Oktober gehts wieder auf nach Schweden, wo ich in Stockholm auf der Scandev on Tour über die Neuerungen in WCF vNext und WCF RIA Services vNext plaudern werde.

Weitere Infos findet man unter [1].

 [1] http://www.scandevtour.se/2011-tour/

Wie schon in den Jahren zuvor bin ich auch dieses Jahr für den Agile Day auf der BASTA!, der größten unabhängigen deutschsprachigen .NET Konferenz, verantwortlich. Nachfolgend die Agenda dazu:

• Crashkurs für Scrum Master
  Manfred Steyer FH CAMPUS 02 | www.IT-Visions.de
• Agiles Projektmanagement mit Kanban
  Christoph Seck cluster sysko GmbH
• Scrum @ bbv Software Services AG
  Urs Enzler bbv Software Services AG
• Die Teststrategie komplexer Softwaresysteme in der Praxis
  Frank Düsterbeck HEC GmbH

Weitere Infos findet man unter [1].

[1] http://basta.net/2011/

Im September findet in Mainz wieder die BASTA!, die größte unabhängige deutschsprachige .NET-Konferenz statt. Diesesmal habe ich die Ehre, mich mit den folgenden Sessions/ Workshops einbringen zu dürfen:

• ADO.NET Entity Framework 4.1
• REST mit MVC
• Crashkurs für Scrum Master
• End-to-End: eine komplette .NET-Anwendung in einem Tag 

Besonders frue ich mich auf den Workshop "End-to-End: eine komplette .NET-Anwendung in einem Tag" am FR, in dem ich gemeinsam mit meinen IT-Visions-Kollegen Holger Schwichtenberg und Joachim Fuchs zeigen werde, wie man die vielen Tools und Frameworks von .NET 4, wie zum Beispiel Entity Framework, WCF, WPF und ASP.NET MVC, in Kombination zur Entwicklung moderner verteilter Applikationen nutzen kann.

Die kommende Version von WCF, welche Gerüchten zu Folge 4.5 heißen wird, bringt einige Neuerungen in Sachen REST. So soll es zum Beispiel einfach möglich sein, Formate jenseits von XML und JSON via REST zu verwenden. Für AJAX-basierte Clients gibt es auch Unterstützung.

Mein Artikel im .NET Magazin 7.2011 informiert über die voraussichtlichen Möglichkeiten anhand der aktuellen Preview-Version.

http://it-republik.de/dotnet/dotnet-magazin-ausgaben/Office-365-000452.html

Ein konzeptionelles Problem des Entity Frameworks ist das explizite Entity Data Model (EDM). Klar, irgendwo muss beschrieben werden, was wie zu mappen ist. Aber das explizite EDM ist redundant: Entitätsklassen müssen zum einen entwickelt und zum anderen im EDM, genauer gesagt im CSDL-Teil, beschrieben werden. Dasselbe gilt für DB-Strukturen und die Beschreibung im SSDL-Teil des EDM. Wenn sich irgendwo etwas ändert, muss das an den anderen Stellen nachgezogen werden. Das ist aber nicht das einzige Problem:

1.      Ab einer gewissen Anzahl an Entitäten wird die graphische Darstellung des EDM unübersichtlich. Normalerweise würde man nun das Modell auf verschiedene Submodelle aufteilen, aber das ist nicht ohne weiteres möglich, zumal man nicht auf Tabellen in anderen Modellen referenzieren kann.

2.      Das Modell kann nicht einfach modularisiert werden.  Der Grund dafür ist derselbe, wie beim letzten Punkt: Man kann Modelle nicht sinnvoll aufteilen.

3.      Kommen wir zum letzten Punkt: Wechsel der Datenbank. Dies ist ja eines der großen Versprechen von O/R-Mappern. Möchte man das eingesetzte DBMS wechseln, muss man für das neue DBMS ein erneutes SSDL generieren lassen und dieses gemeinsam mit den existierenden MDL-Teil und CSDL-Teil verwenden.

Bei (N)Hibernate gibt es diese Probleme eigentlich nicht. Der Grund dafür ist, dass lediglich die Mapping-Aspekte zu beschreiben sind – und das auf eine, im Vergleich zu den XML-Untiefen des EDM, ziemlich übersichtliche Art. Alles andere leitet das Framework aus den bestehenden Klassen ab.

Glücklicherweise ist dies seit Entity Framework 4.1 mit dem Code-First-Ansatz nun auch möglich. Dieser suggeriert zwar, dass man zuerst die Entitäten modellieren muss und dann daraus eine Datenbank zu erstellen ist, aber dank der Möglichkeit von Codegenerierung ist dies nicht der Fall. So bietet zum Beispiel die Entity Framework Power Tools CTP1, welche über den Extension Manager von VS 2010 bezogen werden können, diese Möglichkeit.

 Mit der Mai CTP von Azure AppFabric [1] stellt Microsoft erstmals eine Implementierung von Topics zur Verfügung – wenn auch vorerst lediglich über die Azure-Cloud. Über ein REST-Interface oder einen .NET-Wrapper können damit Nachrichten an Abonnenten versendet werden. Darüber hinaus besteht auch die Möglichkeit, Topics direkt über WCF zu verwenden. Bei solchen Szenarien nehmen WCF-Services die Rolle der Abonnenten ein und WCF-Clients die Rolle des Verlegers.

Das nachfolgende Beispiel demonstriert dies. Dazu kommt ein Topic FlugBuchungenTopic mit zwei Abonnenten zum Einsatz: Accounting und BonusMilesManager. Letzterer weist auch einen Filter auf. Dieser schließt Flugbuchungen, die nicht von Vielfliegern stammen, aus. Die zum Filtern benötigten Daten müssen allerdings zusätzlich in Form von Nachrichteneigenschaften übertragen werden. Deswegen kommt beim Senden der OperationContext zum Einsatz, um diese Metadaten als Teil einer Instanz von BrokeredMessageProperty zu hinterlegen. Die Service-Operation ruft am Begin diese Instanz, welche in der Auflistung IncomingMessageProperties zu finden sind, ab.

private void CreateIfNotExist(string suffix)
{
    SharedSecretCredential myManagementCredentials =
        TransportClientCredentialBase.CreateSharedSecretCredential(IssuerName, IssuerKey);

    ServiceBusNamespaceClient namespaceClient = new ServiceBusNamespaceClient(
        ServiceBusEnvironment.CreateServiceUri("sb", ServiceNamespace, string.Empty),
        myManagementCredentials);

    string topicName = "FlugBuchungenTopic" + suffix;

    Topic myTopic;
    myTopic = namespaceClient.GetTopics().FirstOrDefault(t => t.Path == topicName.ToLower());
    if (myTopic == null)
    {
        myTopic = namespaceClient.CreateTopic(topicName.ToLower());
    }

    var subs = myTopic.GetSubscriptions();
    if (subs.Count(s => s.Name == "Accounting".ToLower()) == 0)
    {
        SubscriptionDescription desc;
        desc = new SubscriptionDescription();
        desc.EnableDeadLetteringOnMessageExpiration = true;
                
        RuleDescription ruleDesc;
        ruleDesc = new RuleDescription();
        ruleDesc.FilterExpression = new SqlFilterExpression("IstVielFlieger = True");
        ruleDesc.FilterAction = new SqlFilterAction("set PremiumKunde = True");
                
                
        var acc = myTopic.AddSubscription("Accounting".ToLower(), desc /*, ruleDesc*/);

    }

    if (subs.Count(s => s.Name == "BonusMilesManager".ToLower()) == 0)
    {
        SubscriptionDescription desc;
        desc = new SubscriptionDescription();
        desc.EnableDeadLetteringOnMessageExpiration = true;

        var filter = new SqlFilterExpression("IstVielFlieger = True");

        myTopic.AddSubscription("BonusMilesManager".ToLower(), desc, filter);
    }

}

REST wird gerne als Alternative zu SOAP-basierten Web Services eingesetzt. Dabei wird HTTP direkt, ohne zusätzliche Protokolle, zur Kommunikation mit Services verwendet. Mit dem WCF Web API, welches Teil der nächsten WCF-Version sein soll, wird die Unterstützung für solche Szenarien ausgebaut. Die aktuelle Preview-Version [1] gibt einen Vorgeschmack auf die zu erwartenden Möglichkeiten.

Im aktuellen .NET Magazin [2] beschreibe ich einige der neuen Möglichkeiten. Meine Beispiele dazu können ebenfalls unter [2] heruntergeladen werden.

[1] http://wcf.codeplex.com

[2] http://it-republik.de/dotnet/dotnet-magazin-ausgaben/Office-365-000452.html

Diese Woche habe mein Buch Verteilte Systeme und Services mit .NET 4.0: Konzepte und Lösungen mit WCF 4.0, das ich gemeinsam mit Holger Schwichtenberg geschrieben habe und in das einige Teile aus dem Vorgänger Buch von Matthias Fischer und Jörg Krause eingeflossen sind, fertiggestellt. Das ganze soll noch im Juli auf den Markt kommen. Bei diesem Buch war es uns wichtig, nicht nur auf WCF 4 einzugehen, sondern auch auf benachbarte Technologien, die man in Praxis gemeinsam mit WCF einsetzen muss, darunter die Worflow Foundation (WF), Entity Framework (EF), Data Services, RIA Services, Windows Identity Foundation (WIF) und Azure AppFabric.

Nachfolgend  das Inhaltsverzeichnis. 

1. Serviceorientierung
2. Überblick zu WCF
3. Services mit WCF erstellen
4. REST-Services mit WCF
5. Sichere Zustellung und Transaktionen
6. WS-Reliable Messaging, Transaktionen, MSMQ/ Queued Services)
7. Datenbasierte Services (WCF im Zusammenspiel mit Entity Framework 4.1, insbesondere Self-Tracking Entities, WCF Data Services, WCF RIA Services)
8. Workflows mit WF
9. Hosting (Self-Hosting mit Windows-Diensten, IIS, AppFabric)
10. Systemintegration und erweiterte Szenarien (Routing, Discovery, Publish/Subscribe, ESB mit WCF entwickeln)
11. Sicherheit (Sicherheitsszenarien inkl. Single-Sign-On mit Windows Indentity Foundation, WIF)
12. WCF und Azure AppFabric (AppFabric Service Bus, AppFabric Access Control)
13. Erweiterungsmodell
14. WCF erweitern

Von 6. bis 10. Juni 2011 gestalte ich mit Joachim Fuchs von IT-Visions im Auftrag von MS Employ einen PowerWorkshop zum Thema ".NET: End-to-End". Das Ziel dieses Workshops liegt darin zu vermitteln, wie komplexe Unternehmensanwendungen durch das Zusammenspiel verschiedener .NET-Technologien entwickelt werden können.

Dabei werden die folgenden Themen behandelt:

- .NET 4
- Silverlight 5
- WPF 4
- SL 5
- RIA-Services
- WCF 4
- Entity Framework 4.1
- ASP.NET MVC
 

Weitere Informationen finden sich im Folder zum Workshop (517,92 kb)