Archive. Posts from 2004 to 2016, kept as they were written. My current blog is at dariuszparys.com.

Die ADO.NET Data Services (ehemals Astoria) ist ein REST basierter Zugriffsdienst auf Daten. Daten werden im Form von ATOM oder JSON zur Verfügung gestellt und könen mit den HTTP Verben entsprechend modifziert und bearbeitet werden.

Ein Haupteinsatzszenario ist die Nutzung der ADO.NET Data Services um ein Entity Modell zu publizieren.

public class MyDataService : DataService< EntityModel >

Doch was muss man eigentlich tun, um ein eigenes Objektmodell als ADO.NET Data Service zu veröffentlichen? Die Dokumentationen hierzu muss man sich mühselig aus verschiedenen Quellen zusammensuchen. Gerade die Dokumentation zu den ADO.NET Data Services in der VS 2008 SP1 Beta 1 ist wirklich nicht einfach zu finden. Googlen oder Liven bringt nichts, findet man nicht. Deshalb hier der Link:

http://vs2008sp1docs.msdn.microsoft.com/en-us/ms452029.aspx

Auf MSDN Online gibt es noch zwei weitere Dokumente für die ADO.NET Data Services, die allerdings noch mit den alten Objektmodell Namen arbeiten. Die Inhalte sind jedoch auch für das neue Release gültig. Um aber ein eigenes Datenmodell nicht nur lesend, sondern auch modifizierbar, über die Data Services zu publizieren muss man noch ein wichtiges Interface implementieren: IUpdatable. Die Dokumentation hierzu ist in den folgendem Satz zusammengefasst:

Write/Update Support

To enable create, update, and delete support on a CLR data model, the class that models the top-level resource sets must implement the IUpdatable interface. In reference to Example 2, CLR Objects to Astoria resources above, the Accounting.DataModel class would be required to implement the IUpdatable interface.

<Sarkasmus>Exzellente Dokumtation!</Sarkasmus>

Ein bißchen mehr findet man dann doch noch auf dem Astoria Blog – hier ist wenigstens noch die Interface Deklaration mit Kommentaren gepostet. Nach Beispielen habe ich dann auch gar nicht mehr gesucht, wäre wohl auch Hoffnungslos.

Trotz all dieser Probleme (wir sind ja in der Beta Phase) habe ich es dann doch noch geschafft mein kleines Beispiel-Objektmodell als Data Service mit Update Semantik zu publizieren. Im folgenden möchte ich einfach die Schritte zeigen, die ich durchlaufen bin, um das zu erreichen.

Das Objektmodell

Mein Objektmodell bildet Spiele der kommenden Europameisterschaft 2008 ab. Es besteht aus einer Klasse (kann man dann überhaupt schon von einem Modell sprechen?), diese hat nur ein kleine Besonderheit:

[DataServiceKey( "MatchID" )]
public class Match
{
    public int MatchID
    {
        get;
        set;
    }

    public string Home
    {
        get;
        set;
    }

    public string Away
    {
        get;
        set;
    }

    public int GoalsHome
    {
        get;
        set;
    }

    public int GoalsAway
    {
        get;
        set;
    }
}

DataServiceKey! Der DataServiceKey deklariert einfach die Felder, an welchem das Objekt eindeutig zu identifizieren ist. In meinem Beispiel habe ich die Eigenschaft MatchID als Schlüssel genommen. Genauso gut hätte ich auch die Spielpaarung selbst als Schlüssel wählen können, wie zum Beispiel [DataServiceKey( “Home”, “Away” )].

Allerdings muss man kombinierte Schlüssel auch dementsprechend in der URI angeben, insofern habe ich mich für eine kürzere Variante entschieden.

Zugriff auf Resourcen mittels URI

Genau dieses Objekt möchte ich nun über dei ADO.NET Data Services addressierbar machen. Die URI sollte folgendermaßen aussehen:

http://localhost/Euro2008DataService.svc/Matches

Um nun ein bestimmtes Match zu laden, gibt man nun einfach die Schlüssel des Objektes, in dem Beispiel also die MatchID an.

http://localhost/Euro2008DataService.svc/Matches(1)

Hätte ich nun als Schlüssel Home und Away definiert und möchte das Spiel Deutschland gegen Pole suchen, so würde der Zugriff folgendermaßen aussehen:

http://localhost/Euro2008DataService.svc/Matches(Away=’Poland’,Home=’Germany’)

Das eigene Data Model

Die Defintion des Datenmodells fehlt uns, um das Match Objekt als Data Service Resource zur Verfügung zu stellen.

namespace MyDataService
{
    public class Euro2008DataModel
    {
        public IQueryable<Match> Matches
        {
            get
            {
                return MatchRepository.Instance.ListOfMatches.AsQueryable<Match>();
            }
        }
    }
}

Das Datenmodell greift auf eine Singleton Klasse zu die eine Liste von Matches im Speicher bereit stellt. Hier die Definition:

public class MatchRepository
{
    private static MatchRepository repository;

    private List<Match> listOfMatches;
    private static object locker = new object();

    private MatchRepository()
    {
        listOfMatches = new List<Match>()
        {
            new Match
            {
                MatchID = 1,
                Home = "Germany",
                Away = "Poland",
                GoalsHome = 2,
                GoalsAway = 0
            },
            new Match
            {
                MatchID = 2,
                Home = "German",
                Away = "Croatia",
                GoalsHome = 4,
                GoalsAway = 1
            },
        new Match
            {
                MatchID = 3,
                Home = "Austria",
                Away = "Germany",
                GoalsHome = 0,
                GoalsAway = 3
            }
        };
    }

    public static MatchRepository Instance
    {
        get
        {
            lock( locker )
            {
                if( repository == null )
                {
                    repository = new MatchRepository();
                }
                return repository;
            }
        }
    }

    public List<Match> ListOfMatches
    {
        get
        {
            return this.listOfMatches;
        }
    }
}

Anmerkung: Die Spielstände sind nur meine EM Tipps für die deutschen Gruppenspiele.

Das Datenmodell selbst muss nur noch über die DataService Klasse als REST Dienst publiziert werden.

public class Euro2008DataService : DataService<Euro2008DataModel>
{
    public static void InitializeService( IDataServiceConfiguration config )
    {
        config.SetEntitySetAccessRule( "*", EntitySetRights.All );
        config.SetServiceOperationAccessRule( "*", ServiceOperationRights.All );
    }
}

Damit hat man nun schon das eigene Objektmodell per ADO.NET Data Services lesend der Außenwelt zur Verfügung gestellt. Ruft man nun die entsprechende URI http://localhost/Euro2008DataService.svc/Matches erhält man den folgenden ATOM Feed.

<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<feed xml:base="http://localhost:1746/Euro2008DataService.svc/"
      xmlns:d="http://schemas.microsoft.com/ado/2007/08/dataservices"
      xmlns:m="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata"
      xmlns="http://www.w3.org/2005/Atom">
  <title type="text">Matches</title>
  <id>http://localhost:1746/Euro2008DataService.svc/Matches</id>
  <updated>2008-06-06T09:10:31Z</updated>
  <link rel="self" title="Matches" href="Matches" />
  <entry m:type="MyDataService.Match">
    <id>http://localhost:1746/Euro2008DataService.svc/Matches(1)</id>
    <title type="text"></title>
    <updated>2008-06-06T09:10:31Z</updated>
    <author>
      <name />
    </author>
    <link rel="edit" title="Match" href="Matches(1)" />
    <content type="application/xml">
      <m:properties>
        <d:MatchID m:type="Edm.Int32">1</d:MatchID>
        <d:Home>Germany</d:Home>
        <d:Away>Poland</d:Away>
        <d:GoalsHome m:type="Edm.Int32">2</d:GoalsHome>
        <d:GoalsAway m:type="Edm.Int32">0</d:GoalsAway>
      </m:properties>
    </content>
  </entry>
  <entry m:type="MyDataService.Match">
    <id>http://localhost:1746/Euro2008DataService.svc/Matches(2)</id>
    <title type="text"></title>
    <updated>2008-06-06T09:10:31Z</updated>
    <author>
      <name />
    </author>
    <link rel="edit" title="Match" href="Matches(2)" />
    <content type="application/xml">
      <m:properties>
        <d:MatchID m:type="Edm.Int32">2</d:MatchID>
        <d:Home>German</d:Home>
        <d:Away>Croatia</d:Away>
        <d:GoalsHome m:type="Edm.Int32">4</d:GoalsHome>
        <d:GoalsAway m:type="Edm.Int32">1</d:GoalsAway>
      </m:properties>
    </content>
  </entry>
  <entry m:type="MyDataService.Match">
    <id>http://localhost:1746/Euro2008DataService.svc/Matches(3)</id>
    <title type="text"></title>
    <updated>2008-06-06T09:10:31Z</updated>
    <author>
      <name />
    </author>
    <link rel="edit" title="Match" href="Matches(3)" />
    <content type="application/xml">
      <m:properties>
        <d:MatchID m:type="Edm.Int32">3</d:MatchID>
        <d:Home>Austria</d:Home>
        <d:Away>Germany</d:Away>
        <d:GoalsHome m:type="Edm.Int32">0</d:GoalsHome>
        <d:GoalsAway m:type="Edm.Int32">3</d:GoalsAway>
      </m:properties>
    </content>
  </entry>
</feed>

IUpdatable implementieren

Ein simpler WPF Client ist nun in der Lage die Daten zu visualisieren

shot1

Damit der WPF Client nun auch die Ergebnisse nicht nur anzeigen, sondern auch anpassen kann, muss die Klasse Euro2008DataModel noch das Interface IUpdatable implementieren. Das Interface selbst hat einige Methoden, doch um nur die Aktualisierung der Ergebnisse für diese kleine Beispiel zu ermöglichen langen die folgenden:

public class Euro2008DataModel : IUpdatable
{
    public IQueryable<Match> Matches
    {
        get
        {
            return MatchRepository.Instance.ListOfMatches.AsQueryable<Match>();
        }
    }

    #region IUpdatable Members

    // Operations not implemented omitted for clarity

    public object GetResource( IQueryable query, string fullTypeName )
    {
        var result = Matches.Provider.CreateQuery( query.Expression );
        foreach( var item in result )
        {
            return item;
        }
        return null;
    }

    public object ResolveResource( object resource )
    {
        Match target = ( Match ) resource;
        return Matches.Where( m => m.MatchID == target.MatchID ).First();
    }

    public void SaveChanges()
    {
        // nothing to do here, as we can't rollback
    }

    public void SetValue( object targetResource, string propertyName, object propertyValue )
    {
        Match target = ( Match ) targetResource;

        var foundMatch = Matches.Where( m => m.MatchID == target.MatchID ).First();

        PropertyInfo info = foundMatch.GetType().GetProperty( propertyName );
        info.SetValue( foundMatch, propertyValue, null );
    }

    #endregion
}

Die Methode GetResource() gibt den Parameter query vom Typ IQueryable hinein. Hier würde unter Umständen noch ein Mapping auf einen anderen Queryprovider durchgeführt werden, in diesem Fall muss ich nichts tun. Der übergebene Query Provider ist genau der gleiche den ich für die interne Implementierung benutze um auf die Daten zuzugreifen. Ich kann hier folgende Doku empfehlen die Erläutert wie man einen Provider implementiert und diesen entsprechend anpasst.

Die Methode SaveChanges() muss nichts machen, da bereits bei SetValue() die Werte direkt in das Repository geschieben werden. Und wir erinnern uns, die Liste der Spiele wird im Speicher gehalten. Dementsprechend werden Properties auch gleich in das Original Objekt gesetzt. Hat man einen Datenbereich der Transaktionorientiert arbeitet oder mit einem Original – New-Value Ansatz, so würde man erst bei SaveChanges() letztlich den Commit machen.

Ist das neue Datenmodell publiziert, so kann man auch per WPF Client die Ergebnisse ein wenig anpassen, vielleicht ist das dann doch ein wenig realistischer…

shot2

Habe ich bereits erwähnt das Deutschland Europameister 2008 wird?