What does the error "Extension method must be static" mean?

Question

I'm having trouble with this class, in particular the method:

public IQueryable<T> ExecuteOrderBys<T>(this IQueryable<T> source)

It says the error:

Extension method must be static

However when I made the method static, it throws other areas, specifically to this.xxx can't be accessed in a static method.

I'm a bit confused about the return types with <T> and the return types, if someone could explain it to me and how it works I would be grateful.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Collections;


/// <summary>
/// A collection of order bys
/// </summary>
public class OrderByCollection
{
    private ArrayList Orderings = new ArrayList();

    public int? Skip { get; set; }
    public int? Take { get; set; }

    public OrderByCollection()
    {
        // Default skip and takes to nulls so we know if they are set or not
        this.Skip = null;
        this.Take = null;
    }

    /// <summary>
    /// Add an order by to this collection
    /// </summary>
    public void AddOrderBy(string Field, bool Descending)
    {
        OrderByObj NewObj = new OrderByObj(Descending, Field);
        this.Orderings.Add(NewObj);
    }

    /// <summary>
    /// Executes the order bys
    /// </summary>
    public IQueryable<T> ExecuteOrderBys<T>(this IQueryable<T> source)
    {
        int ExecutionIndex = 0;
        foreach (OrderByObj O in this.Orderings)
        {
            if (ExecutionIndex == 0)
            {
                if (O.Descending)
                    source = LinqHelper.OrderByDescending(source, O.Field);
                else
                    source = LinqHelper.OrderBy(source, O.Field);
            }
            else
            {
                if (O.Descending)
                    source = LinqHelper.ThenByDescending((IOrderedQueryable<T>)source, O.Field);
                else
                    source = LinqHelper.ThenBy((IOrderedQueryable<T>)source, O.Field);
            }
            ExecutionIndex++;
        }

        // Skip and take
        if (this.Skip != null)
            source = source.Skip(this.Skip.Value);
        if (this.Take != null)
            source = source.Take(this.Take.Value);

        return (IOrderedQueryable<T>)source;
    }
}

Edit

I'm trying to make a class that can do the following:

var q = db.tblJobHeaders;

OrderByCollection OBys = new OrderByCollection();
OBys.AddOrderBy("some field", true);
OBys.AddOrderBy("anotherfield", false);
OBys.ExecuteOrderBys(q);

This is the same issue you just asked about: http://stackoverflow.com/questions/6096299/extension-methods-must-be-defined-in-a-non-generic-static-class - yes, different classes, but essentially the same issue. — Oded, May 23 '11 at 11:25
@Oded: There the issue was in non-static class, here - in non-static method. Both compiler error are quite informative, btw. — abatishchev, May 23 '11 at 11:26
@Oded @Monster @Abat i've included some code on how the class should work, I'm getting really confused now, I just want a simple method, I do think it is different to my other questions sorry if it is not but I'm having trouble understanding this. — Tom Gullen, May 23 '11 at 11:30
I don't think I want it to be an extension method, I'm really confused about this. I just want it to be a normal method that takes in some data and returns some data but the return types are confusing me. I don't get this — Tom Gullen, May 23 '11 at 11:35

jgauffin · Accepted Answer · 2011-05-23T12:01:11.957

You are not trying to extend IQueryable at all by the look of your example. Remove this from method definition and your example should work fine.

public class OrderByCollection
{
    // .. shameless cut ..
    public IQueryable<T> ExecuteOrderBys<T>(IQueryable<T> source)
    {
        // .. we don't need no stinking body ..
    }
}

Which will make your example work:

var q = db.tblJobHeaders;

OrderByCollection OBys = new OrderByCollection();
OBys.AddOrderBy("some field", true);
OBys.AddOrderBy("anotherfield", false);
OBys.ExecuteOrderBys(q);

As a side note I would not use bool to define how the orderby's should be sorted. The code is unclear. Use a enum or different methods instead:

OBys.AddOrderBy("some field", Sort.Ascending);

or:

OBys.AddOrderByDescending("some field");

Update

Extension methods are used to "plugin" methods to existing classes or interfaces. By writing public IQueryable<T> ExecuteOrderBys<T>(this IQueryable<T> source) you are really saying that the method should be hooked into IQueryable<T>. And it should therefore be accessed like myQuery.ExecuteOrderBys.

My guess is that extension methods must be static and be included in static classes to avoid confusion:

a) They are really not members of the classes or interfaces and can not access anything else than public fields/properties/methods.

b) They can extend any class. Without the restriction you could put a method call DoSomething(this ThatObject instance) in a class called ThatObject. The problem with would be that you can't access anything else than the public interface since it's an extension method.

The confusing possibilities would be endless ;)

Brilliant thank you! I'm a tad confused by the this keyword in the method parameter (I was copying the method header from another similar function), does it mean it's being extended then? — Tom Gullen, May 23 '11 at 11:41

score 4 · Answer 2 · answered May 23 '11 at 11:42

Making your method static was the right thing to do to make it an extension method (was the fact of making an extension method the right thing to do or not is another debate !).

Now, since your method is static, it is attached to the class where it is defined, not any instance of this class. That's why the keyword this is meaningless here. this means "current instance of the class" : it doesn't exist by definition in a static method.

The "this" you need to refer to is simply your input parameter source. Put source where there was this and sure your code will compile with the desired effect.

score 2 · Answer 3 · answered May 23 '11 at 11:27

Extension methods can only be defined as static methods in a static class - that means you cannot use any instance variables of this class - the only dependency of an extension method should be the instance of the type you pass in and static / compile time values.

A workaround in your case may be to define Skip and Take as const (and apply an appropriate constant value for both of them) or alternatively pass them as parameters to your extension method.

score 1 · Answer 4 · answered May 23 '11 at 11:23

1

Extension must be defined in static class

Try this:

public static class YourExtension
{
    public static IQueryable<T> ExecuteOrderBys<T>(this IQueryable<T> source)
    {
        // do something
    }
}

answered May 23 '11 at 11:23

Stecya

22,896
10
72
102

Thanks, I figured that out from the error but it leads on to other errors so I'm not sure how to fix it – Tom Gullen May 23 '11 at 11:23

score 1 · Answer 5 · answered May 23 '11 at 11:23

1

public static class OrderByCollection
{
    // that's extension method
    // it should be static
    public static IQueryable<T> ExecuteOrderBys<T>(this IQueryable<T> source)
    {
    }
}

answered May 23 '11 at 11:23

abatishchev

98,240
88
296
433

score 0 · Answer 6 · answered May 23 '11 at 11:23

Change it to

public static class OrderByCollection

and

public static IQueryable<T> ExecuteOrderBys<T>(this IQueryable<T> source)

The key issue here being the static keyword, which indicates that the class doesn't have any state of its own, and that the method wont be needing any state information.

score 0 · Answer 7 · answered May 23 '11 at 11:26

0

You shouldn't access members by this.xxx, you should accesss them via the this.. variable. In this case: source After making the method and the class containing it static.

answered May 23 '11 at 11:26

Dutch Nico

250
2
8

score 0 · Answer 8 · answered May 23 '11 at 11:29

First, convert the your collection class to a generic class, you need this in order to use type inference for IQueryable of T in the extension method:

public class OrderByCollection<T> 
{
    private List<T> Orderings = new List<T>();
    ...
}

Then declare a new static class containing the extension method. Since the method will be static you cannot use the this qualifier, but the instance passed as the source argument:

public static class Extensions {
  public static IQueryable<T> ExecuteOrderBys<T>(this OrderByCollection<T> source) {
      // instead of this.xxx use source.xxx
      IQueryable<T> result;
      ...
      if (source.Skip != null)
        result = source.Skip(this.Skip.Value);
      if (source.Take != null)
        result = source.Take(this.Take.Value);
      ...
  } 
}

What does the error "Extension method must be static" mean?

8 Answers8

Update