Dans cet article, l’auteur présente en détail la requête conjointe Linq, car j’ai bien peur que les lecteurs ne comprennent pas très bien cet aspect, donc avant de parler de la requête conjointe Linq, je vais d’abord vous exposer quelques informations, puis expliquer comment la requête conjointe Linq est implémentée, en espérant vous aider.
Commençons par comprendre quelques points de connaissance concernant la requête conjointe Linq.
1. Type de livraison anonyme
vide statique Main(string[] args)
{ var User = GetAnonymous(). Cast(new { UserName = « », LastLoginIp = « » }) ;
Console.Write(User.UserName) ;
}
objet statique GetAnonymous()
{ var User = new { UserName = « yaosansi », LastLoginIp = « 127.0.0.1 » } ;
retourner l’utilisateur ;
}
Lorsque nous définissons un type anonyme, il ne peut être transmis que par le type objet, et le compilateur ne connaîtra pas le type réel du type anonyme après le passage du type.
Cette ligne peut être lancée via la méthode d’extension Cast. Voici un prototype de la méthode Cast.
public static T Cast (cet objet o, T t)
{
retour () ;
}
2. Comment générer une liste de types anonymes pour une requête fédérée Linq ?
var User = GetAnonymous(). Cast(new { UserName = « », LastLoginIp = « » }) ;
var list = nouvelle liste < ?>() ;
Le principe est le même que celui mentionné ci-dessus.
var User = new
{
UserName = « yaosansi », LastLoginIp = « 127.0.0.1 »
};
var list = User.MakeList() ;
liste. Ajouter (Utilisateur) ;
Console.Write(list[0]. UserName) ;
Jetons un œil à la méthode MakeList() :
public static List MakeList(this T t) {
retour à nouveau List() ;
}
Bien sûr, vous pouvez penser que la méthode ci-dessus n’est pas assez parfaite, et que vous devez ajouter un utilisateur à la liste, donc vous avez la méthode suivante :
public static List MakeList (this T t,params T[] items)
{
retourner de nouvelles listes(ides) ;
}
Lorsqu’elle est appelée, elle peut s’écrire comme :
var User = new
{
UserName = « yaosansi », LastLoginIp = « 127.0.0.1 »
};
var list = User.MakeList(User) ;
Console.Write(list[0]. UserName) ;
Cette fois, passons au but et comprenons comment la requête fédérée Linq est implémentée.
Var q = à partir de p dans DB. Produits
où p.Supplier.Pays == « USA » & & p.UnitsInStock == 0
sélectionner p ;
La requête ci-dessus est composée de deux tables liées, et seul le contenu d’une table est retourné ; dans ce cas, une Liste fortement typée peut être renvoyée dans la couche de données. Par exemple :
Liste publique SelectProducts()
{ var q = de p dans dB. Produits
où p.Supplier.Pays == « USA » & & p.UnitsInStock == 0
sélectionner p ;
retour q.ToList ;
}
Si l’ensemble de résultats retourné est plus grand que deux tableaux, comment devrait-il être passé ? Vous avez dû penser que si l’ensemble de résultats retourné est une seule ligne de données, nous pouvons utiliser le type de livraison anonyme que nous avons mentionné plus tôt pour obtenir les résultats dont nous avons besoin. Objet public
Objet public SelectProducts()
{ var q = de p dans dB. Produits
où p.Supplier.Pays == « USA » & & p.UnitsInStock == 0
select new {p.UnitsInStock,p.Supplier.Sid} ; résultat var = q.Single() ;
résultat de retour ;
}
Cependant, ce postulat est que la couche logique métier doit connaître les types spécifiques de types d’anonymat dans la couche de données. Cette superposition a peu d’importance. Ce n’est pas ce que nous voulons. De plus, la méthode utilisant le type anonyme List pour retourner l’ensemble de résultats de données multi-lignes a également échoué après des expériences. Cela signifie qu’aucune des deux méthodes pour passer l’anonymat au début de cet article ne fonctionnera.
Méthode 1 : La requête fédérée Linq personnalise les classes avec la même structure que le type de retour
classe publique CustomQuery
{ public uint UnitsInStock
{ get ; set ; }
public int Sid
{ get ; set ; }
}
Cela peut être résolu lorsque les résultats de la requête sont un ensemble de résultats de plusieurs tables. Puisque vous devez connaître le type d’anonymat rendu, vous devez définir une classe supplémentaire en plus de ne pas se conformer à la multicouche. Mais c’est vrai et cela peut reproduire les résultats dont nous avons besoin en utilisant des types forts.
Méthode 2 : Requête fédérée Linq utilisant la délégation System.Func (Référence : Retour de var d’une méthode dans C# 3.0)
Couche de données :
public IEnumerable GetCustomersWithOrders(Func,
TProjection> projection)
{ retour du client dans _customers
soit customerOrders = à partir de la commande dans _orders
où l’ordre. CustomerID = customer.ID
projection de sélection (client, clientsCommandes) ;
}
Couche de logique métier :
var results = GetCustomersWithOrders(
(client, commandes) => nouveau
{ Nom = client. Nom,
OrderCount = commandes. Count()
});
Le résultat retourné de cette manière reste un véritable type anonyme dans la couche logique métier et peut être utilisé directement.
Méthode 3 : Les requêtes fédérées Linq utilisent des procédures stockées ou des vues. |
Publié sur 08/05/2015 16:34:23
|
|
|
