extension-methods

Can anyone help me with a Count extension method for IEnumerable (non generic interface). I know it is not supported in LINQ but how to write it manually? The simplest form would be: public static int Count(this IEnumerable source) { int c = 0; using (var e = source.GetEnumerator()) { while (e.MoveNext()) c++; } return c; } You can then improve on this by querying for ICollection : public static int Count(this IEnumerable source) { var col = source as ICollection; if (col != null) return col.Count; int c = 0; using (var e = source.GetEnumerator()) { while (e.MoveNext()) c++; } return c; }

Before I explain what I want to do, if you look at the following code, would you understand what it's supposed to do? (updated - see below) Console.WriteLine( Coalesce.UntilNull(getSomeFoo(), f => f.Value) ?? "default value"); C# already has a null-coalescing operator that works quite well on simple objects but doesn't help if you need to access a member of that object. E.g. Console.WriteLine(getSomeString()??"default"); works very well but it won't help you here: public class Foo { public Foo(string value) { Value=value; } public string Value { get; private set; } } // this will obviously

I'm looking for some pros and cons for using extension methods over static utility classes in a C# app. For instance, a plus in the extension methods column is the convinience of calling by the class name rather than something like "StringUtils". But a con would be that it can blur the lines between what is in the framework and what isn't. I would say that a pro is that it blurs the lines between what is in the framework and what isn't: you can use your own code as naturally as framework code, operating on framework types. Extension methods shouldn't be used arbitrarily, of course - it's not

Using the C# compilers query comprehension features, you can write code like: var names = new string[] { "Dog", "Cat", "Giraffe", "Monkey", "Tortoise" }; var result = from animalName in names let nameLength = animalName.Length where nameLength > 3 orderby nameLength select animalName; In the query expression above, the let keyword allows a value to be passed forward to the where and orderby operations without duplicate calls to animalName.Length . What is the equivalent set of LINQ extension method calls that achieves what the "let" keyword does here? Let doesn't have its own operation; it

With extension methods, we can write handy LINQ operators which solve generic problems. I want to hear which methods or overloads you are missing in the System.Linq namespace and how you implemented them. Clean and elegant implementations, maybe using existing methods, are preferred. Timwi Append & Prepend /// <summary>Adds a single element to the end of an IEnumerable.</summary> /// <typeparam name="T">Type of enumerable to return.</typeparam> /// <returns>IEnumerable containing all the input elements, followed by the /// specified additional element.</returns> public static IEnumerable<T>