Preserving order with LINQ

Are you actually talking about SQL, or about arrays? To put it another way, are you using LINQ to SQL or LINQ to Objects?

The LINQ to Objects operators don't actually change their original data source - they build sequences which are effectively backed by the data source. The only operations which change the ordering are OrderBy/OrderByDescending/ThenBy/ThenByDescending - and even then, those are stable for equally ordered elements. Of course, many operations will filter out some elements, but the elements which are returned will be in the same order.

If you convert to a different data structure, e.g. with ToLookup or ToDictionary, I don't believe order is preserved at that point - but that's somewhat different anyway. (The order of values mapping to the same key is preserved for lookups though, I believe.)

If you are working on an array, it sounds like you are using LINQ-to-Objects, not SQL; can you confirm? Most LINQ operations don't re-order anything (the output will be in the same order as the input) - so don't apply another sort (OrderBy[Descending]/ThenBy[Descending]).

[edit: as Jon put more clearly; LINQ generally creates a new sequence, leaving the original data alone]

Note that pushing the data into a Dictionary<,> (ToDictionary) will scramble the data, as dictionary does not respect any particular sort order.

But most common things (Select, Where, Skip, Take) should be fine.

I found a great answer in a similar question which references official documentation. To quote it:

For Enumerable methods (LINQ to Objects, which applies to List<T>), you can rely on the order of elements returned by Select, Where, or GroupBy. This is not the case for things that are inherently unordered like ToDictionary or Distinct.

From Enumerable.GroupBy documentation:

The IGrouping<TKey, TElement> objects are yielded in an order based on the order of the elements in source that produced the first key of each IGrouping<TKey, TElement>. Elements in a grouping are yielded in the order they appear in source.

This is not necessarily true for IQueryable extension methods (other LINQ providers).

Source: Do LINQ's Enumerable Methods Maintain Relative Order of Elements?

Any 'group by' or 'order by' will possibly change the order.

The question here is specifically referring to LINQ-to-Objects.

If your using LINQ-to-SQL instead there is no order there unless you impose one with something like:

mysqlresult.OrderBy(e=>e.SomeColumn) 

If you do not do this with LINQ-to-SQL then the order of results can vary between subsequent queries, even of the same data, which could cause an intermittant bug.

For me the issue was determining the default sort order which turned out to be by 2 columns as shown below. After many iterations I was able to find the default sort order and redo it in my LINQ query. To remove duplicates a simple foreach is used to create a new list of strings without duplicates.

//original sorting order lost var inv2 = db.Inventories .GroupBy(l => l.VendorFullSKU) .Select(cl => new Inventory2 { VariantID = cl.FirstOrDefault() == null ? 0 : cl.FirstOrDefault().VariantID, Quan = cl.Sum(c => c.Quan), Color = cl.FirstOrDefault() == null ? "" : cl.FirstOrDefault().Color }); //original sorting order restored var bl = (from pv in db.ProductVariants join inv in inv2 on pv.VariantID equals inv.VariantID orderby inv.VariantID, inv.Color //sort select inv.Color ).ToList(); //remove duplicates while preserving original sort order var colorsDistinct = new List<string>(); foreach (var item in bl) { if (!colorsDistinct.Contains(item)) colorsDistinct.Add(item); }