extension-methods

I am trying to write an extension method for the WPF Window class. I am doing it in a class library project in my solution, so that I can use it in all my projects in the solution. Here is my code: using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Windows; namespace ExtensionMethods { public static class MyExtensions { public static void ResizeToPrimaryScreenWorkingArea(this System.Windows.Window w) { } } } When I try to compile this, I get the following error: The type or namespace name 'Window' does not exist in

If the LINQ Count() extension method is invoked on an IEnumerable<T> that has a Count property (e.g. List<T> ), does the Count() method look for that property and return it (rather than counting the items by enumerating them)? The following test code seems to indicate that it does: using System; using System.Collections; using System.Collections.Generic; using System.Diagnostics; using System.Linq; namespace CountSpeedTest { // Output: // List - CLR : 0 ms // Enumerate - CLR : 10 ms // List - Mine: 12 ms // Enumerate - Mine: 12 ms class Program { private const int Runs = 10; private const int

My question is : how to move beyond writing a custom implementation of a technique for databinding multiple controls (controls without built-in DataSource properties), for each possible type of data , to simple properties ... as described and demonstrated in code that follows ... to achieve a more poweful solution that will be independent of whether the binding is to a string, or an int, or other types. My guess is: this will involve reflection; but, I'm stuck at that point. I'm looking for strategic advice on which "direction" to move next, hints, clues, not a complete code answer, but of

I frequently face the problem to check whether an IEnumerable<T> is null before iterating over it through foreach or LINQ queries, then I often come into codes like this: var myProjection = (myList ?? Enumerable.Empty<T>()).Select(x => x.Foo)... Hence, I thought to add this extension-method to an Extensions class: public static class MyExtensions { public static IEnumerable<T> AsEmptyIfNull<T>(this IEnumerable<T> source) { return source ?? Enumerable.Empty<T>(); } } A little issue comes immediately in my mind looking at this code, i.e., given the "instance-methods aspect" of extension-methods,

I've got an extension method: public static class StringEx { public static bool Like(this string a, string b) { return a.ToLower().Contains(b.ToLower()); } } How to reflect it properly via GetMethod with my parameters? I've tried this with no success (Got an exception about static method): var like = typeof(StringEx).GetMethod("Like", new[] {typeof(string), typeof(string)}); comparer = Expression.Call(prop, like, value); Use this extension method to get other extension methods: public static class ReflectionExtensions { public static IEnumerable<MethodInfo> GetExtensionMethods(this Type type,

This question already has an answer here: Partial type inference 3 answers I've created the following extension method public static T Map<TEntity,T>(this TEntity entity) where TEntity : IEntity { return Mapper.Map<TEntity, T>(entity); } This allows the following Db.ExchangeSets.FirstOrDefault().Map<ExchangeSet, ExchangeSetSimpleViewModel>() However i'm wondering if there is anyway i can modify the extension method so i can call a shorted version as follows Db.ExchangeSets.FirstOrDefault().Map<ExchangeSetSimpleViewModel>() Please Note : Whether or not automapper should be used like this is not