Quel type de langage de requête .NET est-ce?

Question

Je me demande quel genre de langage de requête .NET ce qui suit est:

tableName.Select(e => e.PartitionKey == „KeyX“).ToList().OrderBy(e => e.SomeValue).Take(25) 

je l'ai trouvé comme exemple pour effectuer des requêtes Tables de stockage Windows Azure.

Cet objet est-il un nom et peut-il également être utilisé avec SQL au lieu de Azure Storage Tables, est-ce quelque chose inclus dans .NET ou une bibliothèque supplémentaire?

Merci

Answer 1

Il est LINQ, même si je pense que votre requête est légèrement foiré. C'est un sujet énorme, mais vraiment important. Il existe différentes implémentations de LINQ pour travailler avec in-process collections, SQL, services Web REST comme appropriés, etc.

Notez qu'il ya un soutien direct anguage aussi:

// Wouldn't work in this particular case - see below 
var query = (from e in tableName 
      where e.PartitionKey == "KeyX" 
      orderby e.SomeValue 
      select e).Take(25); 

Notez que la ToList() dans la requête en la question force l'exécution immédiate de la partie Azure et l'extraction des résultats au client en tant que List<T>. Il peut puis être commandé et limité sur le client. J'utiliserais normalement AsEnumerable() pour cela (ce qui force le reste de la requête à se faire dans LINQ to Objects, mais sans matérialiser immédiatement en List), mais ToList est une autre option.

Answer 2

.Select(…), .ToList(), .OrderBy(…) et .Take(…) sont LINQ query operators.

Ils sont implémentés en tant que méthodes d'extension pour les types IEnumerable<T> et IQueryable<T>. Pour le premier, ils résident dans le System.Linq.Enumerable class statique; pour ce dernier, ils sont définis dans le System.Linq.Queryable class. Comme ces méthodes renvoient le même type que celui sur lequel elles opèrent, elles permettent le chaînage des méthodes: .Select(…).ToList().OrderBy(…).Take(…).

---

LINQ, en bref, est une API déclarative (avec de fortes racines dans la programmation fonctionnelle) qui a été introduite dans .NET 3.5. Son but principal est d'interroger des séquences et des collections de toutes sortes: collections d'objets en mémoire, documents XML, bases de données SQL, sources de données réseau, etc. Elle a été rendue possible par plusieurs extensions aux langages C# et VB.NET:

• méthodes d'extension, par exemple:

  static class Enumerable 
  { 
      public static bool IsEmpty<T>(this IEnumerable<T> xs) 
      {       // ^^^^ 
       foreach (T x in xs) 
       { 
        return false; 
       } 
       return true; 
      } 
  } 
  

  qui permet d'écrire:

  // List<int> numbers = …; 
  numbers.IsEmpty() 
  

  au lieu de

  Enumerable.IsEmpty(numbers) 
  

• inférence type amélioré

• nouvelle, plus compacte syntaxe => pour les délégués anonymes (fonctions lambda).

  delegate (int x, int y) { return x == y; } // only this was valid in C# 2 
       (int x, int y) => { return x == y; } 
       (int x, int y) => x == y; 
  
  (int x) => x > 0 
       x => x > 0 
  

• expressions et des arbres d'expression (le compilateur code source de sortie en tant que structure de données AST au lieu comme CIL "bytecode", voir l'espace de noms System.Linq.Expressions)

• transformations de syntaxe/syntaxe de compréhension de la requête:

  from x in xs where W select S 
  

  devient

  xs.Where(x => W).Select(x => S) 
  

  qui devient à son tour:

  // using System.Linq 
  Enumerable.Select(Enumerable.Where(xs, x => W), x => S)