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

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

var query = from c in context.Customers
            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.

shot1

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

SELECT
[Extent1].[CustomerID] AS [CustomerID],
[Extent1].[CompanyName] AS [CompanyName],
[Extent1].[ContactName] AS [ContactName],
[Extent1].[ContactTitle] AS [ContactTitle],
[Extent1].[Address] AS [Address],
[Extent1].[City] AS [City],
[Extent1].[Region] AS [Region],
[Extent1].[PostalCode] AS [PostalCode],
[Extent1].[Country] AS [Country],
[Extent1].[Phone] AS [Phone],
[Extent1].[Fax] AS [Fax],
[Extent1].[Comments] AS [Comments]
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.

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:

SELECT
[Extent1].[CustomerID] AS [CustomerID],
[Extent1].[CompanyName] AS [CompanyName],
[Extent1].[ContactName] AS [ContactName],
[Extent1].[ContactTitle] AS [ContactTitle],
[Extent1].[Address] AS [Address],
[Extent1].[City] AS [City],
[Extent1].[Region] AS [Region],
[Extent1].[PostalCode] AS [PostalCode],
[Extent1].[Country] AS [Country],
[Extent1].[Phone] AS [Phone],
[Extent1].[Fax] AS [Fax],
[Extent1].[Comments] AS [Comments]
FROM [dbo].[Customers] AS [Extent1]
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.

shot2

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.

shot3

Eine Auswahl einiger Filterkriterien erzeugt ein anderes Ergebnis:

shot4

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:

protected void OnActionSubmitQuery( object sender, EventArgs e )
{
    using ( NorthwindEntities context = new NorthwindEntities() )
    {
        var query = ConstructBaseQuery( context );
        if ( inputUseCountry.Checked == true )
        {
            query = ConstructQueryByCountry( query );
        }
        if ( inputOrderByCity.Checked == true )
        {
            query = ConstructQueryOrderByCity( query );
        }
        if ( inputOrderByCountry.Checked == true )
        {
            query = ConstructQueryOrderByCountry( query );
        }
        if ( inputUseFewerColumns.Checked == true )
        {
            var q2 = ConstructQueryWithFewerColumns( query );
            outputResult.DataSource = q2;
            outputResult.DataBind();
        }
        else
        {
            outputResult.DataSource = query;
            outputResult.DataBind();
        }
    }
}

IQueryable<Customers> ConstructBaseQuery( NorthwindEntities context )
{
    return context.Customers;
}

IQueryable<Customers> ConstructQueryByCountry( IQueryable<Customers> query )
{
    return query.Where( customer => customer.Country == listOfCountries.SelectedValue );
}

IQueryable<Customers> ConstructQueryOrderByCity( IQueryable<Customers> query )
{
    return query.OrderBy( customer => customer.City );
}

IQueryable<Customers> ConstructQueryOrderByCountry( IQueryable<Customers> query )
{
    return query.OrderBy( customer => customer.Country );
}

IQueryable ConstructQueryWithFewerColumns(IQueryable<Customers> query)
{
    return query.Select(
        customer =>
            new { customer.CompanyName, customer.City, customer.Country } );
}

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.