Dariusz quatscht : LINQ

TechTalk Dezember 2009: Anwendungsentwicklung mit Visual Studio 2010

dparys — Fri, 31 Jul 2009 12:05:52 GMT

Erst im Juni habe ich einen TechTalk hinter mir und schon steht mein nächster an. Dieses mal jedoch nicht über einen Monat gezogen sondern in einer Woche werden 5 Städte besucht und mein Kollege Christian Binder wird auch mit von der Partie sein.

In Visual Studio 2010 kommen so viele neue Elemente dazu das wir einfach in diesem TechTalk verschiedene Aspekte live im Coding demonstrieren wollen und auf hoffentlich viele Fragen eingehen dürfen. Ganz nach dem Motto: “Keine Slides! Nur Code!”

Hier der Auszug von der MSDN TechTalk Anmeldeseite:

Der letzte MSDN TechTalk in diesem Jahr nimmt Sie mit auf eine Reise zur nächsten Version von Visual Studio: Visual Studio 2010. Dabei werden Christian Binder und Dariusz Parys die interessantesten Aspekte der neuen Entwicklungsumgebung vorstellen: von Verbesserungen in den einzelnen Frameworks bis hin zu neuen Möglichkeiten in den Application Lifecycle Management Tools, die das Testen und die Entwicklung im Team einfacher machen, wird dieser TechTalk die verschiedenen Aspekte mit Hilfe von Live Codings demonstrieren. Das heißt ganz klar: Keine Slides! Nur Code!

Die Termine:

An manchen Terminen werden wir vermutlich deutlich überziehen, das dürfte Karlsruhe, Berlin und München sein. In Köln und Hamburg sind wir leider an die Öffnungszeiten des Microsoft Office gebunden.

Ich freue mich schon auf viele Teilnehmer und Fragen, bis dann!

Link: Offizielle TechTalk Anmeldeseite

Wie baue ich einen eigenen LINQ Provider

dparys — Wed, 10 Dec 2008 13:45:36 GMT

Eigentlich nur eine kurze Notiz für mich, aber auch brauchbar für alle die einen eigenen LINQ Provider schreiben möchten.

Matt Waren hat eine schöne Blogserie zum Thema “LINQ Provider im Eigenbau” geschrieben.

Dazu gibt es auch einen IQueryable Toolkit der ein paar Hilfsklassen enthält die sehr brauchbar sind.

Was sind relevante Themen in der Softwareentwicklung für Sie?

dparys — Wed, 03 Dec 2008 19:19:00 GMT

Lange Zeit bevor ich bei Microsoft war, habe ich schon in diversen Firmen eigentlich immer aus eigenem Antrieb heraus recht schnell Technologie adaptiert und auch während laufender Projekte reingebracht. Den Mehraufwand hat man gerne selbst getragen (oder tragen lassen, Entschuldigung schon mal an dieser Stelle, Ihr wisst wer gemeint ist) um das Projekt / Produkt auf eine neue technische Ebene zu heben. Meist hat sich der Aufwand auch gelohnt.

Seit ich bei Microsoft bin, liegt hier mein Fokus natürlich verstärkt auf die Microsoft Technologie. Ich möchte mal sagen das ich nicht diesen Bias habe über den Ralf Westphal geschrieben hat, aber mein "Abdriften" in andere Technologie Welten ist definitiv geringer geworden.

Warum schreibe ich das eigentlich? Ganz einfach, nach dem Auswerten der Technical Summit Feedbacks ist mir aufgefallen das die Themen kaum Relevanz für die Teilnehmer hatten und ich nicht von mir ausgehen möchte was relevant ist. Was ich wirklich Cool finden würde, wären Kommentare was für Sie relevante Softwareentwicklungsthemen sind.

Dynamische Abfragen mit LINQ

dparys — Tue, 14 Oct 2008 09:07:37 GMT

In den letzten Tagen habe ich öfters über das Thema ADO.NET Entity Framework gesprochen. Eine der häufigsten Fragen war: “Wie kann ich Daten dynamisch abfragen?”. Es gibt verschiedene Möglichkeiten das zu Bewerkstelligen, heute möchte ich eine generische Aufzeigen: Composable Queries.

LINQ Abfragen gegen Datenbanken liefern in der Regel ein spezialisiertes Query Object zurück, bei LINQ to Entities (ADO.NET Entity Framework) wäre das die Klasse ObjectQuery<T>.

Die Abfrage

   1: var query = from c in context.Customers

   2:             select c;

liefert somit als Resultat das Objekt ObjectQuery<Customers> zurück (Anm.: Wenn es sich um ein Default Mapping der Northwind Datenbank handelt). Schaut man sich die Schnittstellen an, die ObjectQuery<T> implementiert, entdeckt man die Schnittstellen IQueryable und IQueryable<T>. Die Grundlage um Abfragen miteinander flexibel zu kombinieren.

Die obige Abfage ist definiert aber nicht ausgeführt. Der entsprechend visualisierte T-SQL Code des Providers sieht bisher wie folgt aus:

   1: SELECT

   2: [Extent1].[CustomerID] AS [CustomerID],

   3: [Extent1].[CompanyName] AS [CompanyName],

   4: [Extent1].[ContactName] AS [ContactName],

   5: [Extent1].[ContactTitle] AS [ContactTitle],

   6: [Extent1].[Address] AS [Address],

   7: [Extent1].[City] AS [City],

   8: [Extent1].[Region] AS [Region],

   9: [Extent1].[PostalCode] AS [PostalCode],

  10: [Extent1].[Country] AS [Country],

  11: [Extent1].[Phone] AS [Phone],

  12: [Extent1].[Fax] AS [Fax],

  13: [Extent1].[Comments] AS [Comments]

  14: FROM [dbo].[Customers] AS [Extent1]

Anm.: Den T-SQL Code kann man sich über eine ToTraceString() Methode von ObjectQuery anzeigen lassen.

Die Abfrage lässt sich noch erweitern, zum Beispiel möchte ich nur alle Kunden aus Deutschland angezeigt bekommen.

   1: var query2 = query.Where( customer => customer.Country == "Germany" );

Damit wird die bestehende Abfrage um die Where Bedingung ergänzt und der T-SQL Code enthält die entsprechende Bedingung:

   1: SELECT

   2: [Extent1].[CustomerID] AS [CustomerID],

   3: [Extent1].[CompanyName] AS [CompanyName],

   4: [Extent1].[ContactName] AS [ContactName],

   5: [Extent1].[ContactTitle] AS [ContactTitle],

   6: [Extent1].[Address] AS [Address],

   7: [Extent1].[City] AS [City],

   8: [Extent1].[Region] AS [Region],

   9: [Extent1].[PostalCode] AS [PostalCode],

  10: [Extent1].[Country] AS [Country],

  11: [Extent1].[Phone] AS [Phone],

  12: [Extent1].[Fax] AS [Fax],

  13: [Extent1].[Comments] AS [Comments]

  14: FROM [dbo].[Customers] AS [Extent1]

  15: WHERE N'Germany' = [Extent1].[Country]

Und so lässt sich das ganze fortsetzen.

Damit lassen sich dynamische Abfragefilter in einer Anwendung erstellen, die dem Benutzer die Möglichkeit geben, Spalten auszuwählen, Bedingungen anzugeben und Sortierungskriterien zu bestimmen. In einer kleinen Beispielanwendung hat der Benutzer die Möglichkeit die Kunden Tabelle der Northwind Datenbank entsprechend einzuschränken.

Der Benutzer kann die Anzahl der Spalten minimieren, einen Filter auf das anzuzeigende Land zu setzen und auch eine Sortierung wählen.

Selektiert man keinen Filter wird die Abfrage entsprechend 1:1 im GridView angezeigt.

Eine Auswahl einiger Filterkriterien erzeugt ein anderes Ergebnis:

Im Anwendungscode wird die gleiche Query als Grundlage genommen. Diese wird in der Methode ConstructBaseQuery erzeugt. Annhand der Selektion der Kriterien wird diese Abfrage im Code modifiziert. Hier der entsprechende Sourcecode:

   1: protected void OnActionSubmitQuery( object sender, EventArgs e )

   2: {

   3:     using ( NorthwindEntities context = new NorthwindEntities() )

   4:     {

   5:         var query = ConstructBaseQuery( context );

   6:         if ( inputUseCountry.Checked == true )

   7:         {

   8:             query = ConstructQueryByCountry( query );

   9:         }

  10:         if ( inputOrderByCity.Checked == true )

  11:         {

  12:             query = ConstructQueryOrderByCity( query );

  13:         }

  14:         if ( inputOrderByCountry.Checked == true )

  15:         {

  16:             query = ConstructQueryOrderByCountry( query );

  17:         }

  18:         if ( inputUseFewerColumns.Checked == true )

  19:         {

  20:             var q2 = ConstructQueryWithFewerColumns( query );

  21:             outputResult.DataSource = q2;

  22:             outputResult.DataBind();

  23:         }

  24:         else

  25:         {

  26:             outputResult.DataSource = query;

  27:             outputResult.DataBind();

  28:         }

  29:     }

  30: }

31:

  32: IQueryable<Customers> ConstructBaseQuery( NorthwindEntities context )

  33: {

  34:     return context.Customers;

  35: }

36:

  37: IQueryable<Customers> ConstructQueryByCountry( IQueryable<Customers> query )

  38: {

  39:     return query.Where( customer => customer.Country == listOfCountries.SelectedValue );

  40: }

41:

  42: IQueryable<Customers> ConstructQueryOrderByCity( IQueryable<Customers> query )

  43: {

  44:     return query.OrderBy( customer => customer.City );

  45: }

46:

  47: IQueryable<Customers> ConstructQueryOrderByCountry( IQueryable<Customers> query )

  48: {

  49:     return query.OrderBy( customer => customer.Country );

  50: }

51:

  52: IQueryable ConstructQueryWithFewerColumns(IQueryable<Customers> query)

  53: {

  54:     return query.Select(

  55:         customer =>

  56:             new { customer.CompanyName, customer.City, customer.Country } );

  57: }

Für die Projektion des Anonymen Typen (Zeile 52-57) musste ich allerdings ein einfaches IQueryable zurückliefern, deshalb die Variable q2 (Zeile 20).

Dies ist eine Möglichkeit dynamische Abfragen mit LINQ zu erstellen und hat den Charme das dies mit jedem IQueryable / IQueryable<T> funktioniert und somit bei LINQ to SQL wie auch bei LINQ to Entities und LINQ to “was weiß ich was für ein Provider eingesetzt wird” funktioniert.

Silverlight 2 Beta 2 und ADO.NET Data Services

dparys — Fri, 13 Jun 2008 10:23:47 GMT

Seit Silverlight 2 Beta 2 draußen ist, kann ich endlich wieder an meinem Projekt weiterarbeiten. Ich schreibe eine kleine Anwendung die auf einen Datendienst zugreift, den ich mit den ADO.NET Data Services erstellt habe. Ich mußte feststellen das es drei wichtige Dinge zu beachten gilt:

System.Data.Services.Client

Dieses Assembly ist verantwortlich für die Integration des Proxy Codes in das Silverlight Projekt. Es muß referenziert werden damit der erstellte Proxy mittels DataSvcUtil entsprechend funktioniert.

Asynchrone Aufrufe

Möchte man nun auf Daten zugreifen, so muss dies immer asynchron geschehen. Synchrone Aufrufe werden in der aktuellen Beta nicht unterstützt.

Versucht man synchron eine Abfrage gegen den Data Service mittels eines Proxies abzusetzen

   1: var query = from p in ctx.Products

   2:             select p;

3:

   4: foreach( var item in query )

   5: {

   6:     // do something

   7: }

bekommt man eine NotImplementedMethodException . Man muss auf jeden Fall asynchron arbeiten. Die eigentliche Abfrage muss explizit in ein DataServiceQuery<T> umgewandelt werden. Folgender Code demonstriert die asynchrone Abfrage:

   1: var query = from p in ctx.Products

   2:             select p;

3:

   4: var dataQuery = ( DataServiceQuery<Product> ) query;

5:

   6: dataQuery.BeginExecute( OnLoadProductsComplete, dataQuery );

Die Methode OnLoadProductsComplete letztlich, ist dafür verantwortlich die Ergebnisse zu verwerten. Der folgende Code zeigt wie man dann die Daten auslesen kann:

   1: private void OnLoadProductsComplete( IAsyncResult ar )

   2: {

   3:     var dataQuery = ( DataSeviceQuery<Product> ) ar.AsyncState;

4:

   5:     var query = dataQuery.EndExecute( ar );

6:

   7:     foreach( var item in query )

   8:     {

   9:         // to whatever has to be done

  10:     }

  11: }

ADO.NET Data Service im gleichen Projekt

Was nirgends dokumentiert ist und vermutlich ein Bug ist (ich konnte es noch nicht genauer verifizieren), ist die Tatsache, dass in der jetzigen Beta der Data Service relativ angesprochen werden muss. Sprich, dieser sollte im gleichen Projekt wie das Silverlight Web Projekt liegen. Alles andere hat bei mir auf der Maschine nur einen Fehler beim Aufruf vom Invoke des Proxies ergeben (callOpen error). Um den Proxy mit der relativen URI zu instanzieren nutzt man einen entsprechenden Konstruktor:

   1: var ctx = new ModelEntitiesProxy( new Uri( "test.svc", UriKind.Relative ) );

Vielleicht gibt es ein Workaround für die absolute Adressierung, ausserhalb des Silverlight Web Projektes. Wenn jemand hier einen Link hat, ich wäre dankbar.

So, nun konnte ich das Projekt an den Service anbinden und mit den Daten arbeiten. Subjektiv gesehen ist die Performance nicht optimal zwischen dem Silverlight Projekt und dem Data Service. Es kommt mir träge vor, ist allerdings nur ein Subjektiver Eindruck, nicht durch Zahlen belegt. Abschliessend bleibt noch zu sagen, das die Beta durchaus für eine Evaluation eingesetzt werden kann, wobei man die Performance mal ausser Acht lassen sollte. Hier wird sich mit Sicherheit im Hinblick auf das Release noch was tun.

Objekte mittels ADO.NET Data Services publizieren

dparys — Fri, 06 Jun 2008 12:39:04 GMT

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.

   1: 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:

   1: [DataServiceKey( "MatchID" )]

   2: public class Match

   3: {

   4:     public int MatchID

   5:     {

   6:         get;

   7:         set;

   8:     }

9:

  10:     public string Home

  11:     {

  12:         get;

  13:         set;

  14:     }

15:

  16:     public string Away

  17:     {

  18:         get;

  19:         set;

  20:     }

21:

  22:     public int GoalsHome

  23:     {

  24:         get;

  25:         set;

  26:     }

27:

  28:     public int GoalsAway

  29:     {

  30:         get;

  31:         set;

  32:     }

  33: }

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.

   1: namespace MyDataService

   2: {

   3:     public class Euro2008DataModel

   4:     {

   5:         public IQueryable<Match> Matches

   6:         {

   7:             get

   8:             {

   9:                 return MatchRepository.Instance.ListOfMatches.AsQueryable<Match>();

  10:             }

  11:         }

  12:     }

  13: }

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

   1: public class MatchRepository

   2: {

   3:     private static MatchRepository repository;

4:

   5:     private List<Match> listOfMatches;

   6:     private static object locker = new object();

7:

   8:     private MatchRepository()

   9:     {

  10:         listOfMatches = new List<Match>()

  11:         {

  12:             new Match

  13:             {

  14:                 MatchID = 1,

  15:                 Home = "Germany",

  16:                 Away = "Poland",

  17:                 GoalsHome = 2,

  18:                 GoalsAway = 0

  19:             },

  20:             new Match

  21:             {

  22:                 MatchID = 2,

  23:                 Home = "German",

  24:                 Away = "Croatia",

  25:                 GoalsHome = 4,

  26:                 GoalsAway = 1

  27:             },

  28:         new Match

  29:             {

  30:                 MatchID = 3,

  31:                 Home = "Austria",

  32:                 Away = "Germany",

  33:                 GoalsHome = 0,

  34:                 GoalsAway = 3

  35:             }

  36:         };

  37:     }

38:

  39:     public static MatchRepository Instance

  40:     {

  41:         get

  42:         {

  43:             lock( locker )

  44:             {

  45:                 if( repository == null )

  46:                 {

  47:                     repository = new MatchRepository();

  48:                 }

  49:                 return repository;

  50:             }

  51:         }

  52:     }

53:

  54:     public List<Match> ListOfMatches

  55:     {

  56:         get

  57:         {

  58:             return this.listOfMatches;

  59:         }

  60:     }

  61: }

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.

   1: public class Euro2008DataService : DataService<Euro2008DataModel>

   2: {

   3:     public static void InitializeService( IDataServiceConfiguration config )

   4:     {

   5:         config.SetEntitySetAccessRule( "*", EntitySetRights.All );

   6:         config.SetServiceOperationAccessRule( "*", ServiceOperationRights.All );

   7:     }

   8: }

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.

   1: <?xml version="1.0" encoding="utf-8" standalone="yes"?>

   2: <feed xml:base="http://localhost:1746/Euro2008DataService.svc/"

   3:       xmlns:d="http://schemas.microsoft.com/ado/2007/08/dataservices"

   4:       xmlns:m="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata"

   5:       xmlns="http://www.w3.org/2005/Atom">

   6:   <title type="text">Matches</title>

   7:   <id>http://localhost:1746/Euro2008DataService.svc/Matches</id>

   8:   <updated>2008-06-06T09:10:31Z</updated>

   9:   <link rel="self" title="Matches" href="Matches" />

  10:   <entry m:type="MyDataService.Match">

  11:     <id>http://localhost:1746/Euro2008DataService.svc/Matches(1)</id>

  12:     <title type="text"></title>

  13:     <updated>2008-06-06T09:10:31Z</updated>

  14:     <author>

  15:       <name />

  16:     </author>

  17:     <link rel="edit" title="Match" href="Matches(1)" />

  18:     <content type="application/xml">

  19:       <m:properties>

  20:         <d:MatchID m:type="Edm.Int32">1</d:MatchID>

  21:         <d:Home>Germany</d:Home>

  22:         <d:Away>Poland</d:Away>

  23:         <d:GoalsHome m:type="Edm.Int32">2</d:GoalsHome>

  24:         <d:GoalsAway m:type="Edm.Int32">0</d:GoalsAway>

  25:       </m:properties>

  26:     </content>

  27:   </entry>

  28:   <entry m:type="MyDataService.Match">

  29:     <id>http://localhost:1746/Euro2008DataService.svc/Matches(2)</id>

  30:     <title type="text"></title>

  31:     <updated>2008-06-06T09:10:31Z</updated>

  32:     <author>

  33:       <name />

  34:     </author>

  35:     <link rel="edit" title="Match" href="Matches(2)" />

  36:     <content type="application/xml">

  37:       <m:properties>

  38:         <d:MatchID m:type="Edm.Int32">2</d:MatchID>

  39:         <d:Home>German</d:Home>

  40:         <d:Away>Croatia</d:Away>

  41:         <d:GoalsHome m:type="Edm.Int32">4</d:GoalsHome>

  42:         <d:GoalsAway m:type="Edm.Int32">1</d:GoalsAway>

  43:       </m:properties>

  44:     </content>

  45:   </entry>

  46:   <entry m:type="MyDataService.Match">

  47:     <id>http://localhost:1746/Euro2008DataService.svc/Matches(3)</id>

  48:     <title type="text"></title>

  49:     <updated>2008-06-06T09:10:31Z</updated>

  50:     <author>

  51:       <name />

  52:     </author>

  53:     <link rel="edit" title="Match" href="Matches(3)" />

  54:     <content type="application/xml">

  55:       <m:properties>

  56:         <d:MatchID m:type="Edm.Int32">3</d:MatchID>

  57:         <d:Home>Austria</d:Home>

  58:         <d:Away>Germany</d:Away>

  59:         <d:GoalsHome m:type="Edm.Int32">0</d:GoalsHome>

  60:         <d:GoalsAway m:type="Edm.Int32">3</d:GoalsAway>

  61:       </m:properties>

  62:     </content>

  63:   </entry>

  64: </feed>

IUpdatable implementieren

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

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:

   1: public class Euro2008DataModel : IUpdatable

   2: {

   3:     public IQueryable<Match> Matches

   4:     {

   5:         get

   6:         {

   7:             return MatchRepository.Instance.ListOfMatches.AsQueryable<Match>();

   8:         }

   9:     }

10:

  11:     #region IUpdatable Members

12:

  13:     // Operations not implemented omitted for clarity

14:

  15:     public object GetResource( IQueryable query, string fullTypeName )

  16:     {

  17:         var result = Matches.Provider.CreateQuery( query.Expression );

  18:         foreach( var item in result )

  19:         {

  20:             return item;

  21:         }

  22:         return null;

  23:     }

24:

  25:     public object ResolveResource( object resource )

  26:     {

  27:         Match target = ( Match ) resource;

  28:         return Matches.Where( m => m.MatchID == target.MatchID ).First();

  29:     }

30:

  31:     public void SaveChanges()

  32:     {

  33:         // nothing to do here, as we can't rollback

  34:     }

35:

  36:     public void SetValue( object targetResource, string propertyName, object propertyValue )

  37:     {

  38:         Match target = ( Match ) targetResource;

39:

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

41:

  42:         PropertyInfo info = foundMatch.GetType().GetProperty( propertyName );

  43:         info.SetValue( foundMatch, propertyValue, null );

  44:     }

45:

  46:     #endregion

  47: }

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…

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

Einen Besuch Wert - Das .NET-Forum.de

dparys — Tue, 03 Jun 2008 09:09:10 GMT

Letzte Woche bin ich auf eine Webseite hingewiesen worden. Das .NET-Forum.de. Neben einem Entwickler-Blog Aggregator gibt es auch ein Forum in welchem man sich zu Inhalten austauschen kann. Einfach mal vorbeischauen.

Funktionale Programmiertechniken in C# 3.0 Anwenden

dparys — Fri, 02 May 2008 13:10:11 GMT

Hier ein Link zu einem interessanten Blog Eintrag:

Query Composition using Functional Programming Techniques in C# 3.0

Eric White zeigt in diesem Tutorial wie man Funktionale Programmiertechniken mit C# 3.0 zum Erstellen von LINQ Abfragen verwenden kann. Lesenswert! (Englisch)

Zwei weitere Webcasts der LINQ und Konsorten Serie...

dparys — Tue, 29 Apr 2008 10:14:20 GMT

...sind jetzt online.

Eine Einführung in die ADO.NET Data Services

Transaktionen und konkurrierende Zugriffe

Fehlt nur noch der letzte Webcast der demnächst live gehen wird. Viel Spaß beim reinschauen.

Webcast: LINQ to Entities

dparys — Tue, 22 Apr 2008 16:00:43 GMT

LINQ und Konsorten ist die Reihe die sich mit dem Thema LINQ und deren diverser Provider auseinandersetzt. Seit heute ist auch der Webcast zu LINQ to Entities verfügbar. LINQ to Entities ist noch der alte Name für diese Technologie, korrekterweise sollte ich das ganze ADO.NET Entity Framework nennen. Trotzdem habe ich es bei dem Titel belassen. Das ADO.NET Entity Framework ist momentan noch nicht final veröffentlicht und befindet sich noch in der Entwicklung. Ich habe diese Version für diesen Webcast benutzt.

Webcast LINQ to Entities

Webcast: LINQ to XML

dparys — Tue, 22 Apr 2008 11:00:39 GMT

In der Reihe LINQ und Konsorten ist nun LINQ to XML verfügbar. Neben den Möglichkeiten mit LINQ auf die neue XML API zuzugreifen, wird diese in erster Linie erklärt. Was in diesem Webcast an einer Demo fehlt, ist das Lesen eines XML Dokumentes per Streaming. Dieses kleine Beispiel werde ich noch per Screencast auf diesem Blog nachreichen.

Webcast LINQ to XML

Webcast: LINQ to Objects

dparys — Tue, 22 Apr 2008 08:34:29 GMT

Dieser Webcast der LINQ und Konsorten Reihe ist mir irgendwie am schwersten Gefallen. Im Nachhinein würde ich LINQ to Objects nicht seperiert als Talk anbieten, allerdings kann man das ein odere andere Beispiel aus den offiziellen Samples nun als Videostream begutachten.

Webcast LINQ to Objects

Webcast: LINQ to SQL

dparys — Wed, 16 Apr 2008 11:39:58 GMT

In der Reihe LINQ und Konsorten ist seit dem 07.04 nun auch der zweite Teil der Serie verfügbar.

LINQ und Konsorten (Teil 2) - LINQ to SQL

Ich habe bereits Feedback bekommen das ich lauter sprechen soll. Während der Aufnahme zum dritten Teil habe ich nun auch endlich den Grund für die schlechte Audioqualität gefunden. Ich hatte den Codec vermutet, es war aber das Tool das ich zur Aufnahme und zum Encoden verwende: Camtasia. Camtasia ist ein gutes Produkt, leider werden einige Funktionen, darunter auch die Audiolevel Funktion, nur korrekt in ein Flash Video reinkodiert. Da ich es zu spät gemerkt habe, hat es eine Weile gedauert um die Qualität des Audios in der 3. Folge aufzuwerten, für Teil 4 bin ich nun gewappnet.