#extension method

The Dummies’ Guide to How to solve Problems with Extension Method

I am pretty much sure that, You have used Extension method in your program. Did you think to create your custom Extension method ?

If not then this article help you to create your own Extension method step by step.

Before jumping to direct practice let’s understand first what is extension method. So, an Extension methodis created to simplify the code. It is a static method which represent as…

How to call extension method which has the same name as an existing method? [duplicate]

Possible Duplicate: Is there any way in C# to override a class method with an extension method?

I have code like

public class TestA { public string ColA { get; set; } public string ColB { get; set; } public string ColC { get; set; } public void MethodA() { MessageBox.Show("Original A1."); } } static class ExtenstionTest { public static void MethodA(this TestA A1) { MessageBox.Show("Extended…

If like me you’ve worked with C# and the .NET framework for years then you will probably have written variations on following code hundreds of time when trying to display values on screen or save values into text based files or SQL statements:

object…

擴充方法是一種讓你可以不用新增任何延伸類別或是修改原類別的情況下

  新增你想加的方法

  例如：原本 String 本身沒有轉 Integer 的方法

  但你可以藉由「擴充方法」的方式，將新的方法定義在 String 上

  (more…)

We all know that whenever possible we code should be written to be type safe. But there are times when its simply not possible. Once such time we came across when putting together the Mvpc libraries behind the Ambidect Technology involved working with…

홍민희 블로그가 이전됐습니다.

내용은 위치만 다음 URL로 이동했을 뿐, 여전히 보존되어 있습니다.

Often we need to iterate over a collection and remove items that meat a given criteria. Sure List<T> has RemoveAll, but what about the cases where you do not have a List<T>?

Typically this results in code like the following:

var collection = new ObservableCollection<int> { 7, 2, 3, 4, 6, 5 }; var toRemove = collection.Where(x => x % 2 == 0).ToList(); foreach (var item in toRemove) collection.Remove(item);

Though there is nothing wrong with this, it means that we must first iterate over the collection, then go back and remove each item.

Here is an extension method that will do it in a single iteration:

private static void RemoveWhere<T>(IList<T> collection, Predicate<T> predicate) { for (var i = collection.Count - 1; i >= 0; i--) { if (predicate(collection[i])) { collection.RemoveAt(i); } } }

The basic idea is to iterate from the back of the list and only remove the items that match the given predicate and remove them. 

Recently I needed a way to get all of the subsets of a specified size within a given list. Lets start with a brief example. Given the array [1, 2, 3, 4], and a desired subset size of 2, I wanted a method that would output a collection containing:[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]. Or given a subset size of 3 the expected output should be [1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4]. 

For python coders you will notice that the functionality I am duplicating can be found in the itertools.combinations method.

For anyone who is unfamiliar with deferred execution, I highly recommend Jon Skeet's blog posts on Edulinq. In part 2, his rewrite of the Where LINQ extension method gives a good example of why to split the extension method into two parts, immediate execution for validation, and deferred execution.

For my method I chose to implement the same pattern.

public static IEnumerable<T[]> Combinations<T>(this IList<T> argList, int argSetSize) { if (argList == null) throw new ArgumentNullException("argList"); if (argSetSize <= 0) throw new ArgumentException("argSetSize Must be greater than 0", "argSetSize"); return combinationsImpl(argList, 0, argSetSize - 1); }

This method performs validation on the arguments and calls the combinationsImpl method. The second parameter indicates the starting position in the list, and the third parameter indicates the number of times the combinationsImpl method is allowed to iterate (this will make sense later).

Now for the real meat and potatoes.

private static IEnumerable<T[]> combinationsImpl<T>(IList<T> argList, int argStart, int argIteration, List<int> argIndicies = null) { argIndicies = argIndicies ?? new List<int>(); for (int i = argStart; i < argList.Count; i++) { argIndicies.Add(i); if (argIteration > 0) { foreach (var array in combinationsImpl(argList, i + 1, argIteration - 1, argIndicies)) { yield return array; } } else { var array = new T[argIndicies.Count]; for (int j = 0; j < argIndicies.Count; j++) { array[j] = argList[argIndicies[j]]; } yield return array; } argIndicies.RemoveAt(argIndicies.Count - 1); } }

The algorithm here is not as complicated as it looks. Starting with the first items in the list we recursively add items to our array until the array reaches the desired length. Once the desired length is reached the array is returned, we remove the last index that was used to build the array (essentially backing up and skipping over) and continue as long as we can.

For example consider the array [1, 2, 3] finding all combinations of length 2.

We start by collecting the first item into our result set [1]. We then proceed to the next item and collect it. Our result set is now [1, 2]. Since the result set is of length 2 we return it, remove the last item (making the result set [1]) and continue going through the list. We then collect 3 making the result set [1, 3], and return it. Since we have reached the end of the list, we increment the starting index, and start the result set over making it [2]. Moving to the next it we collect 3 making the result set [2, 3].