如何做一个linq组

Question

I have a linq query in my aspnet core application that is returning more rows then it should. The query is as follows.

public List<csAutoComplete> GetAutoComplete(string Type, string filter)
{
string[] GasCodesnotListed = { "F97", "F98", "F99" };
Model1 = from x in _context.TblGascodes
    where ((x.GasCode.StartsWith("F13") || x.GasName.StartsWith("F13")) &&
            !GasCodesnotListed.Contains(x.FedclusterCode))
    orderby x.GasCode
    group x by new csAutoComplete { ACCode = x.GasCode, ACName = x.GasName } into Alpha
    select new csAutoComplete  <=== (Is this the issue???)
        {
        ACCode = Alpha.Key.ACCode,
        ACName = Alpha.Key.ACCode + " - " + Alpha.Key.ACName
        };
return Model1.ToList();
}

} returns (7) results

So I pasted into LINQ pad and got the result I expected of (1)

string[] GasCodesnotListed = { "F97", "F98", "F99" };
TblGasCodes
   .Where (
      x => 
        ((x.GasCode.StartsWith ("F13") || x.GasName.StartsWith ("F13")) && 
           !(GasCodesnotListed.Contains (x.GasCode))
        )
   )
   .OrderBy (x => x.GasCode)
   .GroupBy (
      x => 
         new  
         {
            ACCode = x.GasCode, 
            ACName = x.GasName
         }
   )
   .Select (
      Alpha => 
         new  
         {
            ACCode = Alpha.Key.ACCode, 
            ACName = ((Alpha.Key.ACCode + " - ") + Alpha.Key.ACName)
         }
   )

The only difference seems to be in the new csAutoComplete. If that is a class definition why should that make a difference? How do I resolve this.

Answer 1

In your code, there seems to be an important difference in GasCodesnotListed.Contains (one looks at FedclusterCode, the other at GasCode):

where (x.GasCode.StartsWith ("F13") && !GasCodesnotListed.Contains (x.**FedclusterCode**))

...versus...

.Where (
  x => 
    (
       x.GasCode.StartsWith ("F13") && 
       !(GasCodesnotListed.Contains (x.**GasCode**))
    )
)

Answer 2

Unless you overrode Equals in csAutoComplete , GroupBy will compare instances of csAutoComplete using Object.ReferenceEquals() or some equivalent. Two instances with identical GasCode and GasName properties will be two separate group keys. If you've got seven items coming in, that'll group them in seven groups of one item each.

This is not the case with anonymous types. Separate instances with the same values for their properties will be treated as equal by GroupBy .

var items = new[] { 0, 0 }.Select(n => new { x = n, y = n.ToString() }).ToArray();

var groups = items.GroupBy(x => x).ToArray();

//  Not equal here!
var aretheyequal = items[0] == items[1];

//  But GroupBy isn't fooled: There's only one group
var groupcount = groups.Length;

Use your anonymous type for a group key -- or overload Equals on csAutoComplete if you like to live on the edge. It can cause funny bugs, in my experience (or more accurately, programmers write funny bugs by failing to be mindful of the changes it introduces). I prefer not to go there.

Hence, I think your GetAutoComplete method is OK, except for the group by line, which I would change to this:

group x by new { ACCode = x.GasCode, ACName = x.GasName } into Alpha

The later reference to ACCode = Alpha.Key.ACCode etc. shouldn't need to change, since the property names are the same.