extension-methods

Under Visual Studio 2008 Can I create an Extension Method to work under a .NET Framework 2.0 project? There is an ugly hack that gets Extension methods working in .Net 2.0; but it would better just to upgrade your framework to 3.5. Alternate Sources: 1 , 2 . In short (from link #2): Extension methods are just normal static methods tagged with the [Extension] attribute. This attribute is actually just added by the compiler behind the scenes. In .NET 3.5, it lives in System.Core, so just define your own attribute like this: namespace System.Runtime.CompilerServices { [AttributeUsage

I am trying to use Microsoft XPath Extension Functions (such as ms:string-compare http://msdn.microsoft.com/en-us/library/ms256114.aspx ) inside an XPathExpression object. These functions are extensions inside the MSXML library, and if I use them in an XslCompiledTransform (simply adding the "ms" namespace) they work like a charm: var xsl = @" <?xml version=""1.0"" encoding=""UTF-8""?> <xsl:stylesheet version=""2.0"" xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" xmlns:xs=""http://www.w3.org/2001/XMLSchema"" xmlns:fn=""http://www.w3.org/2005/xpath-functions"" xmlns:ms=""urn:schemas

I was reading about extension methods in C# 3.0. The text I'm reading implies that an extension method with the same signature as a method in the class being extended would be second in order of execution - that is, the method in the sealed class gets called. If this is the case, how can you extend the sealed class ? Indeed, the actual method takes precedence over the extension method. And just to make it clear - "order of execution" suggests both might be called; only the original method will be invoked. Perhaps pick another name / signature; you can't use extension methods to monkey-patch,

All, Wanted to get a few thoughts on this. Lately I am becoming more and more of a subscriber of "purist" DI/IOC principles when designing/developing. Part of this (a big part) involves making sure there is little coupling between my classes, and that their dependencies are resolved via the constructor (there are certainly other ways of managing this, but you get the idea). My basic premise is that extension methods violate the principles of DI/IOC. I created the following extension method that I use to ensure that the strings inserted into database tables are truncated to the right size:

I'd like to be able to implicitly convert between two classes which are otherwise incompatible. One of the classes is Microsoft.Xna.Framework.Vector3 , and the other is just a Vector class used in an F# project. I'm writing a 3d game in C# with XNA, and -- although it's drawn in 3D, the gameplay takes place in only two dimensions (it's a birds-eye-view). The F# class takes care of the physics, using a 2D vector: type Vector<'t when 't :> SuperUnit<'t>> = | Cartesian of 't * 't | Polar of 't * float member this.magnitude = match this with | Cartesian(x, y) -> x.newValue(sqrt (x.units ** 2.0 + y

I want to write an extension method for the List class that takes an object and adds it to the front instead of the back. Extension methods really confuse me. Can someone help me out with this? myList.AddToFront(T object); List<T> already has an Insert method that accepts the index you wish to insert the object. In this case, it is 0. Do you really intend to reinvent that wheel? If you did, you'd do it like this public static class MyExtensions { public static void AddToFront<T>(this List<T> list, T item) { // omits validation, etc. list.Insert(0, item); } } // elsewhere List<int> list = new