Linq to entities Select Distinct

Je ne suis pas sûr de ce que je suis absente, mais j'ai été raclée à ce seul tout l'après-midi.

J'ai un Serveur Sql de la vue des Entreprises, qui ressemble à ceci:

CompanyId varchar(30) NOT NULL
CompanyName varchar(100) NOT NULL
CompanyPriority int NULL
ConfigItem int NOT NULL

Avec des données qui ressemble un peu à ceci:

00001 | Company One | 99 | 123
00001 | Company One | 99 | 456
00001 | Company One | 99 | 789
00002 | Company Two | 99 | 123
00002 | Company Two | 99 | 456

Je vais essayer d'obtenir une liste distincte des entreprises. La requête sql je veux exectute est

select distinct CompanyId, CompanyName,CompanyPriority from vwCompany

qui me donne exactement les résultats que je veux qui serait

00001 | Company One | 99
00002 | Company Two | 99

Mais pour la vie de moi je ne peux pas trouver la requête LINQ que les résultats de cette sql, ou tout ce qui produit les mêmes résultats.

À toutes les questions que j'ai trouvé l'utilisation de regroupement qui fonctionne très bien dans mes tests d'unité, mais ne parvient pas à retourner distinctes résultats lorsqu'elle est exécutée à l'encontre d'une base de données réelle.

EDIT:

Donc j'ai essayé quelques petites choses sur la base des réponses à ce jour.

Dim data = _miRepository.GetCompanies().
  Select(Function(c) New With {
           .companyId = c.CompanyId,
           .companyName = c.CompanyName,
           .companyPriority = c.CompanyPriority
         }
       ).Distinct().ToList()

génère le sql

SELECT 
1 AS [C1], 
[Extent1].[CompanyId] AS [CompanyId], 
[Extent1].[CompanyName] AS [CompanyName], 
[Extent1].[CompanyPriority] AS [CompanyPriority]
FROM (SELECT 
      [vwCompany].[CompanyId] AS [CompanyId], 
      [vwCompany].[CompanyName] AS [CompanyName], 
      [vwCompany].[CompanyPriority] AS [CompanyPriority], 
      [vwCompany].[CiId] AS [CiId]
      FROM [dbo].[vwCompany] AS [vwCompany]) AS [Extent1]

qui n'ont pas l'opérateur distinct du tout 🙁

Et oui, je fais cela dans VB.NET juste pour rendre les choses plus difficile de trouver de bons exemples :\

EDIT 2:

Je suis en train d'essayer de se rapprocher d'Eric Js répondre comme je peux en VB.

Dim data = (From c In _miRepository.GetCompanies()
            Select New With {.companyId = c.CompanyId,
                             .companyName = c.CompanyName,
                             .companyPriority = c.CompanyPriority
                            }
                          ).Distinct().ToList()

me donne

SELECT 
1 AS [C1], 
[Extent1].[CompanyId] AS [CompanyId], 
[Extent1].[CompanyName] AS [CompanyName], 
[Extent1].[CompanyPriority] AS [CompanyPriority]
FROM (SELECT 
      [vwCompany].[CompanyId] AS [CompanyId], 
      [vwCompany].[CompanyName] AS [CompanyName], 
      [vwCompany].[CompanyPriority] AS [CompanyPriority], 
      [vwCompany].[CiId] AS [CiId]
      FROM [dbo].[vwCompany] AS [vwCompany]) AS [Extent1]

Toujours pas de mot-clé distinct à être trouvé 🙁

Peut-être il ya une différence subtile dans VB.NET que je suis absent.

EDIT 3:

Afin de progresser avec le reste de cette application, j'ai renoncé, pour le moment, et créé un nouveau point de vue (vwDistinctCompanies) à l'aide de l'instruction sql au début de la question.

Si quelqu'un parvient à le faire fonctionner dans VB.NET à l'encontre d'une vue Sql s'il vous plaît laissez-moi savoir. Tout à fait pourquoi cela devrait-il être si difficile dans LINQ, je n'ai aucune idée 🙁

Juste au cas où vous êtes encore en train d'essayer, j'ai essayé plusieurs requêtes moi-même et le différent de ceux des autres utilisateurs. Il semble que la réponse par @Eric J. est de me donner l'instruction SQL qui a utilisé le DISTINCT mot-clé. Je ne sais pas comment traduire que de VB que j'ai couru à travers de C#
Merci d'essayer. Je ne pouvais pas obtenir l'un d'eux pour faire une requête distinct. Je ne sais pas si c'est parce que c'est en VB ou si c'est parce que c'est contre une vue plutôt qu'un tableau.
Hey, j'ai couru plus de requêtes. Regarde mon édité réponse. Espérons que cela aide.

OriginalL'auteur Nick | 2012-11-27

2

Essayez d'utiliser .Distinct() à la fin de votre requête, par exemple
```
(from r in ctx.MyTable where SomeCondition select r).Distinct();
```
http://msdn.microsoft.com/en-us/library/system.linq.enumerable.distinct.aspx

Si nécessaire, vous pouvez également fournir un IEqualityComparer. Toutefois, pour utiliser le IEqualityComparer, la énumérable doit d'abord être matérialisé à l'aide .ToEnumerable(). Faire cela signifie que le Distinct() l'opération est effectuée sur le client plutôt que sur le serveur de base de données.

http://msdn.microsoft.com/en-us/library/bb338049.aspx

La IEqualityComparer vous permet de contrôler exactement les enregistrements sont traités comme des égaux et donc ne se distingue pas des autres enregistrements.

Si vous souhaitez sélectionner un sous-ensemble de colonnes de votre tableau, modifier
```
select r
```
pour sélectionner un type anonyme comme ceci:
```
(from r in ctx.MyTable where SomeCondition
    select new 
    { 
        CompanyId = r.CompanyId, 
        CompanyName = r.CompanyName, 
        CompanyPriority = r.CompanyPriority
    }
).Distinct();
```
ou si vous avez besoin d'un objet fortement typé (par exemple, parce que vous utilisez fortement typé vues MVC:
```
public class CompanyModel
{
    public int CompanyId { get; set; }
    public string CompanyName { get; set; }
    public int CompanyPriority { get; set; }
}

// Then in the Linq statement

(from r in ctx.MyTable where SomeCondition
    select new CompanyModel()
    {
        CompanyId = r.CompanyId, 
        CompanyName = r.CompanyName, 
        CompanyPriority = r.CompanyPriority
    }
).Distinct();
```
OriginalL'auteur Eric J.

ÉDITÉ par:-

Ignorer tout mon code que j'ai mentionné plus tôt (tout ce qui est après la fin de modifier l'article). J'ai essayé de tester davantage. Branchez le VB suivants du code et me dire quels sont les résultats que vous avez:

(From c In ctx.Companies Select New With { _
    Key .companyId = c.CompanyId, _
    Key .companyName = c.CompanyName, _
    Key .companyPriority = c.CompanyPriority _
}).Distinct()

Je les ai testés à l'aide de LINQPad et j'ai eu le SQL suivant:

SELECT DISTINCT [t0].[CompanyId] AS [companyId],
                [t0].[CompanyName] AS [companyName],
                [t0].[CompanyPriority] AS [companyPriority]
FROM [Companies] AS [t0]

LA FIN DE L'EDIT-

J'ai eu ce problème il ya quelques jours. C'est ce que j'ai fait.

Ce que vous êtes à la recherche pour les besoin de la GroupBy clause comme vous l'avez mentionné dans votre post. Juste à l'aide de Distinct ne fonctionnera pas tant que vous vous attendiez (autant Que je sache). La suite expression lambda est ce que j'ai fait et de droit après l'instruction SQL générée par le lambda code.

Lambda Code:

Companies.GroupBy(c => new {
                           c.CompanyId,
                           c.CompanyName,
                           c.CompanyPriority
                       })
         .Select(p => new {
                          CompanyId = p.Key.CompanyId,
                          CompanyName = p.Key.CompanyName,
                          CompanyPriority = p.Key.CompanyPriority
                      })

Code SQL:

SELECT [t0].[CompanyId] AS [companyId],
       [t0].[CompanyName] AS [companyName],
       [t0].[CompanyPriority] AS [companyPriority]
FROM [Companies] AS [t0]
GROUP BY [t0].[CompanyId],
         [t0].[CompanyName],
         [t0].[CompanyPriority]

Étrangement, il travaille dans LinqPad mais pas dans mon application. Je me demande si c'est parce que c'est contre un IQuerable sur une ObjectSet ou si c'est juste la version de EF que le projet a été mis en place contre la. Malheureusement, j'ai été rédigés à mi-chemin à travers afin de couvrir l'original dev congé. Quand j'ai un peu de répit, je vais revenir à ce (j'ai 2h de route jusqu'à la revue du sprint et j'ai besoin de quelque chose aujourd'hui :\ ).

OriginalL'auteur Steven

Essayer:

var results = (from company in context.Companies
    select new {
        CompanyId = company.CompanyId,
        CompanyName = company.CompanyName,
        CompanyPriority = company.CompanyPriority
    }).Distinct();

La clé est d'obtenir les éléments de la requête qui PEUT être unique ensemble, puis d'appeler le .Distinct() extension. Si vous laissez le configID bien là, ils vont tous être uniques.

OriginalL'auteur Joel Etherton

var query = from c in context.vwCompany
            group c by new { 
                c.CompanyId, 
                c.CompanyName, 
                c.CompanyPriority } into g
            select g.Key;

Requête générée (à partir de SQL Server Profiler) ressemble à:

SELECT 
1 AS [C1], 
[Distinct1].[CompanyId] AS [CompanyId], 
[Distinct1].[CompanyName] AS [CompanyName]
[Distinct1].[CompanyPriority] AS [CompanyPriority]
FROM ( SELECT DISTINCT 
    [Extent1].[CompanyId] AS [CompanyId], 
    [Extent1].[CompanyName] AS [CompanyName]
    [Extent1].[CompanyPriority] AS [CompanyPriority]
    FROM [dbo].[vwCompany] AS [Extent1]
) AS [Distinct1]

OriginalL'auteur Sergey Berezovskiy

0

Ne pourrait-il pas être les deux tables? Un avec
```
00001 | Company One | 99
00002 | Company Two | 99
```
Et l'autre avec
```
00001 | 123
00001 | 456
00001 | 789
00002 | 123
00002 | 456
```
qui est plus normalisé et rendrait votre requête vraiment facile?

Oui il faut, malheureusement, cette décision est hors de mes mains 🙁

OriginalL'auteur Andrew Morton

Vous devez vous connecter pour publier un commentaire.