Welcome to the Lounge

someList.Where(condition).Select(fields).Distinct().OrderBy(field)

HashSet<Type> distinctSet = new HashSet<Type>();

foreach(var item in someList){
    if(condition){
        distinctSet.Add(item);
    }
}
<sort the set in whatever way you do it manually>

someList.Where(condition).Select(field)

var query =
    from o in Orders
    group o by o.ShipCountry into countryGroups
    select new
    {
        Country = countryGroups.Key,
        Cities =
            from cg in countryGroups
            group cg.ShipPostalCode by cg.ShipCity into cityGroups
            select new
            {
                City = cityGroups.Key,
                PostCodes = cityGroups.Distinct()
            }
    };

//   Brazil
//      Campinas
//         04876-786
//      Resende
//         08737-363
//      Rio de Janeiro
//         02389-673
//         02389-890
//         05454-876

someStuff.Where(c => c != What)
         .Select(d => d + The)
         .Foreach(e => Hell(e));

Sentenryu wrote:

calling a style "cancer" just because you don't want to learn how to read and use it

BillWoodruff wrote:

Well, no, Harold, I haven't seen that style because I haven't read any buggy code that was written by someone who did not know that the 'ForEach sequence iterator only works on a List<T>, and will fail on an IEnumerable<WhatEver> ... until ... now

BillWoodruff wrote:

and will fail on an IEnumerable<WhatEver>

Marc Clifton wrote:

Which is why I have an extension method to overcome that shortcoming

public static void ForEach<T>(this IEnumerable<T> sequence, Action<T> action)
{ 
  // argument null checking omitted
  foreach(T item in sequence) action(item);
}

BillWoodruff wrote:

I get a glimpse of your shadow going around a corner

public static bool If(this bool b, Action action)

public static void IfElse(this bool b, Action ifTrue, Action ifFalse)

public static void ForEach<T>(this IEnumerable<T> sequence, Action<T, int> action)
{ 
  // argument null checking omitted
  var index = 0;
  foreach(T item in sequence) {
    action(item, index);
    index++;
  }
}

public static async Task ForEachAsync<T>(this IEnumerable<T> sequence, Func<T, Task> actionAsync)
{ 
  // argument null checking omitted
  foreach(T item in sequence) await actionAsync(item);
}

(x < 3) ifTrue: [ x <- 3 ].
(x < 3) ifTrue: [ x <- 3 ] Else: [ x <- x + 1 ].

(x > 0) whileTrue: [ x <- x - 1 ].

Sander Rossel wrote:

The newest thing? It has been around for almost 10 years...