4

I have found several links to methods of making extension methods work in .NET2.0 (The moth, Discord & Rhyme, Stack Overflow). I have also heard vaguely from a colleague that this causes some problems with libraries or something? Is this the case? Also all 3 use different methods:

The moth:

namespace System.Runtime.CompilerServices
{
  public class ExtensionAttribute : Attribute { }
}

Discord and Rhyme

namespace System.Runtime.CompilerServices
{
  [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
  public class ExtensionAttribute : Attribute {}
}

Stack Overflow

namespace System.Runtime.CompilerServices
{
    [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class
         | AttributeTargets.Method)]
    public sealed class ExtensionAttribute : Attribute {}
}

Whats the difference between these methods, and which one would you recommend?

Community
  • 1
  • 1
Casebash
  • 114,675
  • 90
  • 247
  • 350

5 Answers5

4

Ultimately it isn't going to make much difference; you could argue that the one that matches the runtime is preferred, but the ideal answer is to switch to .NET 3.5 (otherwise at a later date it can get confusing with different versions of the same attribute in scope etc).

The [AttributeUsage] will prevent it being attached to things where it won't do anything - but it won't do aything by itself anyway...

Looking at metadata against the type, the exact attribute usage seems most like the stackoverflow variant - but ultimately this isn't hugely important - the name and namespace is all that matters (and that it inherits from Attribute).

Marc Gravell
  • 1,026,079
  • 266
  • 2,566
  • 2,900
  • I actually ended up using LINQBridge (http://www.albahari.com/nutshell/linqbridge.aspx) in the end, which meant that I didn't need to do this manually – Casebash Feb 17 '10 at 22:04
  • Defining it yourself can be a nightmare: http://stackoverflow.com/questions/11025100/escape-catch-22-with-extension-attributes-in-net-2-0 – Lilith River Jun 14 '12 at 14:37
1

The difference is simple enough:

In your first example, you can put the attribute anywhere. In the second example, you can only apply it to a method, never more than one to the same method and an inherited class with the method overridden will not inherit the attribute. In the third example, you can apply it to a method, a class or an assembly.

If you try to apply it in any other place, you will get a compiler error.

The second seems to make most sense.

pdr
  • 6,372
  • 1
  • 29
  • 38
1

I would recommend Discord and Rhyme because it providing meaningful constraints for how the attribute is supposed to be applied.

  1. It can only be applied to methods
  2. You can only apply it once
  3. The attribute cannot be inherited
smaclell
  • 4,568
  • 7
  • 41
  • 49
1

Personally, I would recommend avoiding all three. Each option makes this work by performing a "trick" - I would not rely on this for production code.

If you want to use extension methods, upgrade to C# 3.0. Otherwise, just stick to calling the method using the non-extension method syntax.

You can always take an extension method call like so:

public static class Utility {
    public static string Extension(this string original) { ... }

// call with:
var newString = myString.Extension();

And call it directly:

string newString = Utility.Extension(myString);

This will be more consistent with C#/.NET 2 syntax, and would be my recommendation.

Reed Copsey
  • 554,122
  • 78
  • 1,158
  • 1,373
  • What effect does the `this` have? – Casebash Feb 17 '10 at 00:37
  • The this causes the System.Runtimes.CompilerServices.Extension attribute to get placed on the method call in C# 3. This is what makes "extension" methods work as extension methods, instead of standard static methods. – Reed Copsey Feb 17 '10 at 00:44
  • What difference does this make? Does this allow us to access the private scope within the methods? – Casebash Feb 17 '10 at 01:21
  • @Casebash: Nope. Functionally, it's identical. It just allows C# 3 to treat this as an extension method, so you can write "myString.Extension()" instead of "Utility.Extension(myString)" - that's why I was saying, if you're in C# 2, stick to C# 2, since it doesn't offer any advantages (other than convenience). – Reed Copsey Feb 17 '10 at 01:36
  • You said you would not rely on it for production code. How could it break? – Casebash Feb 17 '10 at 02:34
  • This is how: http://stackoverflow.com/questions/11025100/escape-catch-22-with-extension-attributes-in-net-2-0 – Lilith River Jun 14 '12 at 14:38
1

The SO version is the accurate one, for the pure sake of accuracy you should use it.

Fwiw, the AttributeTarget.Method specifier is crystal clear. Class and Assembly less so. Both the C# and the VB.NET compiler emit the attribute on the static class / Module that contains the extension method. And on the assembly that contains the class / Module. Why they do this is less crystal clear, it wouldn't be needed to properly compile them. I'm guessing this is an optimization at work, helping both the compiler and IntelliSense discover when an extension method should be considered.

Getting the attribute applied to the assembly is actually a problem. That won't work right when you compile code to .netmodules. But that's a very obscure issue.

Hans Passant
  • 922,412
  • 146
  • 1,693
  • 2,536