ASP.NET MVC 4 WebApi: OData-Abfragen manuell verarbeiten

Ich habe eine Web-Service erfolgt über die WebAPI zur Verfügung gestellt von ASP .NET MVC 4.
Ich weiß, dass die Schicht auf die WebAPI funktioniert automatisch verarbeitet OData-Abfragen (wie $filter, $top, $skip), aber was ist, wenn ich damit umgehen will die Filterung von mir?

Ich weiß nicht, schicken Sie einfach die Daten aus meiner Datenbank, aber ich habe noch eine Schicht, die fügt einige Eigenschaften hinzu, lässt einige Umbauten etc. Also die Abfrage ALLER meiner Daten umzuwandeln und dann wieder in die WebAPI Klasse für OData-Filterung ist nicht gerade gut genug. Es ist natürlich furchtbar langsam, und in der Regel eine beschissene Idee.

So ist es ein Weg, um propagieren die OData query-Parameter von meinem WebAPI Einstieg in die Funktionen, die ich aufrufen zu Holen und konvertieren der Daten?

Beispielsweise ein man /api/people?$skip=10&$top=10 nennen würde auf dem server:

public IQueryable<Person> get() {
    return PersonService.get(SomethingAboutCurrentRequest.CurrentOData);
}

Und in PersonService:

public IQueryable<Person> getPeople(var ODataQueries) {
    IQueryable<ServerSidePerson> serverPeople = from p in dbContext.ServerSidePerson select p;
    //Make the OData queries
    //Skip
    serverPeople = serverPeople.Skip(ODataQueries.Skip);
    //Take
    serverPeople = serverPeople.Take(ODataQueries.Take);
    //And so on
    //...

    //Then, convert them
    IQueryable<Person> people = Converter.convertPersonList(serverPeople);
    return people;
}

InformationsquelleAutor der Frage frapontillo | 2012-05-28

  1. 37

    Ich stolperte über diesen alten post und ich bin das hinzufügen dieser Antwort, denn es ist jetzt sehr leicht zu handhaben, die OData-Abfragen. Hier ist ein Beispiel:

    [HttpGet]
[ActionName("Example")]
public IEnumerable<Poco> GetExample(ODataQueryOptions<Poco> queryOptions)
{
    var data = new Poco[] { 
        new Poco() { id = 1, name = "one", type = "a" },
        new Poco() { id = 2, name = "two", type = "b" },
        new Poco() { id = 3, name = "three", type = "c" }
    };

    var t = new ODataValidationSettings() { MaxTop = 2 };
    queryOptions.Validate(t);

    //this is the method to filter using the OData framework
    //var s = new ODataQuerySettings() { PageSize = 1 };
    //var results = queryOptions.ApplyTo(data.AsQueryable(), s) as IEnumerable<Poco>;

    //or DIY
    var results = data;
    if (queryOptions.Skip != null) 
        results = results.Skip(queryOptions.Skip.Value);
    if (queryOptions.Top != null)
        results = results.Take(queryOptions.Top.Value);

    return results;
}

public class Poco
{
    public int id { get; set; }
    public string name { get; set; }
    public string type { get; set; }
}

    InformationsquelleAutor der Antwort qujck

  2. 3

    Die Abfrage aus der URL übersetzt wird, in einem LINQ-Ausdruck Baum, der dann ausgeführt wird, gegen die IQueryable Ihrem Betrieb gibt. Analysieren Sie den Ausdruck und stellen die Ergebnisse in irgendeiner Weise Sie wollen. Der Nachteil ist, dass Sie brauchen, um IQueryable implementieren, das ist nicht super einfach. Werfen Sie einen Blick auf diese blog post Serie, wenn Sie interessiert sind: http://blogs.msdn.com/b/vitek/archive/2010/02/25/data-services-expressions-part-1-intro.aspx. Es ist die Rede von WCF Data Services, aber die filter-Ausdrücke verwendet, um die Web-API wird sehr ähnlich sein.

    InformationsquelleAutor der Antwort Vitek Karas MSFT

  3. 2

    Einen Weg, Mit Web-api wäre mit Kunden-message-handler http://www.asp.net/web-api/overview/working-with-http/http-message-handlers

    Schreiben Sie einen benutzerdefinierten handler wie folgt:

    public class CustomHandler : DelegatingHandler
    {
        protected override Task<HttpResponseMessage> SendAsync(
            HttpRequestMessage request, CancellationToken cancellationToken)
        {
            return base.SendAsync(request, cancellationToken).ContinueWith(
                (task) =>
                {
                    HttpResponseMessage response = task.Result;
                    var persons = response.Content.ReadAsAsync<IQueryable<Person>>().Result;
                    var persons2 = new List<Person>(); //This can be the modified model completely different
                    foreach (var item in persons)
                    {
                        item.Name = "changed"; //here you can change the data
                        //persons2.Add(....); //Depending on the results modify this custom model
                    }
                    //overwrite the response
                    response = new HttpResponseMessage<IEnumerable<Person>>(persons2); 
                    return response;
                }
            );
        }
    }

    Registrieren Sie sich in der globalen.asax.cs

    Methode im application-Klasse: 

    static void Configure(HttpConfiguration config)
 {
     config.MessageHandlers.Add(new CustomHandler()); 
 }

protected void Application_Start()
{
     ....
     .....
     //call the configure method
     Configure(GlobalConfiguration.Configuration);
 }

    InformationsquelleAutor der Antwort Abhijit Kadam

  4. 0

    Ich hab sowas schon mit WCF Data Services asp.net mvc 3.5, aber es war ein bisschen ein Durcheinander.

    Der erste Schritt ist, zu schreiben, die Strecke, so dass der skip und top-Optionen nicht erhalten zweimal, einmal von dir und einmal von der Laufzeit.

    Hab ich das umschreiben mit einem HttpModule. In Ihrem BeginRequest-Methode würden Sie code wie diesen:

    HttpApplication app = (HttpApplication)sender;
if (HttpContext.Current.Request.Path.Contains(YOUR_SVC))
{
    if (app.Request.Url.Query.Length > 0)
    {
        //skip questionmark
        string queryString = app.Request.Url.Query.Substring(1) 
                    .Replace("$filter=", "filter=")
                    .Replace("$orderby=", "orderby=")
                    .Replace("$top=", "top=")
                    .Replace("$skip=", "skip=");

                HttpContext.Current.RewritePath(app.Request.Path, "", queryString);
    }
}

    Dann nur um den query-string und pflücken die Parameter, die Sie benötigen. 

    if (HttpContext.Current.Request.QueryString["filter"] != null)
    var filter = HttpContext.Current.Request.QueryString["filter"] as string;

    Dann teilen Sie die filter-string und parse es in einer sql-Anweisung oder jede andere db-Befehle. Ich war mit NHibernate in meinem Fall. Ich war auch in der Lage, zu begrenzen, was die filter-Befehle, die ich unterstützt, und das machte die Sache einfacher. Ich habe nicht die Gruppierungen, zum Beispiel. Meist nur die Vergleichsoperatoren.

    Gibt es eine Liste von filter-Operatoren in OData.org. Split die Zeichenfolge, die durch "und" und "oder" in einzelnen Klauseln. Split jede Ziffer durch ein Leerzeichen, und Sie sollten eine 3-element-array mit den Namen der Eigenschaft in [0] der operator in [1] und dem Wert in [2].

    Die Klauseln werden in Bezug auf eine Person, aber ich nehme an, Sie werden in der Lage, konvertieren Sie Sie in etwas, das ziehen die richtigen Ergebnisse aus der db.

    Landete ich die Abkehr von diesem Ansatz, da es nicht für die Arbeit-BEITRÄGE. Ich hatte zu schreiben, meine eigenen Linq-provider, sondern Schreibe meine eigenen filter-string-parser gemacht, dass einfacher zu verstehen.

    InformationsquelleAutor der Antwort Jason Freitas

Schreibe einen Kommentar