We put them all in their own namespace Company.Common.Extensions. That way, if you have any of our extension methods, you have them all. Plus, at least at my shop, we don’t have to worry about our developers not knowing about extension methods. I have the opposite worry, extension method overload! 🙂
In general, exceptions included, you should treat an extension method as if it were a normal static method. In this case you should throw an ArgumentNullException. Throwing a NullReferenceException here is a bad idea for a few reasons A null reference did not actually occur so seeing one is counterintuitive Throwing a NullReferenceException and causing … Read more
Some of differences that will determine whether you want to use a Partial Class or an Extension Method are Partial Class Only works against classes in the same project/assembly Target class has to be marked as partial Has access to the Target class’ fields and protected members Target must be a class implementation Extension Method … Read more
I definitely prefer the name ThingExtensions over IThingExtensions. The reason being that to most programmers an I prefix on a type implies that it is an interface. This is both a very common pattern and part of the .Net Design Guidelines. Adding an I prefix for the extension method case breaks both assumptions and established … Read more
Extension methods only work on instances, so it can’t be done, but with some well-chosen class/method names and generics, you can produce a result that looks just as good: public class SelectList { // Normal SelectList properties/methods go here public static SelectList Of<T>() { Type t = typeof(T); if (t.IsEnum) { var values = from … Read more
No, IEnumerable doesn’t have many extension methods on it: IEnumerable<T> does. They are two separate interfaces, although IEnumerable<T> extends IEnumerable. The normal LINQ ways of converting are to use the Cast<T>() and OfType<T>() extension methods which do extend the nongeneric interface: IEnumerable<TextBox> textBoxes = Controls.OfType<TextBox>(); IEnumerable<Control> controls = Controls.Cast<Control>(); The difference between the two is … Read more
EDIT: I’ve now blogged about this in more detail. My original (and I now believe incorrect) thought: generic constraints aren’t taken into account during the overload resolution and type inference phases – they’re only used to validate the result of the overload resolution. EDIT: Okay, after a lot of going round on this, I think … Read more
I had this exact question so I found this post two years later. However, I think it is important to note that this will only not compile and give the “The call is ambiguous” error if the code calling the duplicate extension methods is not in the same namespace as one of them. If the … Read more
Use a foreach loop: foreach (var p in names) { Console.WriteLine(p); } There is no reason to use delegates and extension methods all over the place if that doesn’t actually improve readability; a foreach loop is not any less explicitly telling readers what’s being done than a ForEach method.
No, Extension methods can not act as implementation for an interface. Extensions methods are just syntactic sugar for a static method taking an instance of that class as the first parameter, thus not being a member of the specific class, which is a requirement for implementing an interface.