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);

Answer 1

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 ;)

Answer 2

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.

Answer 3

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.

Answer 4

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
    }
}

Answer 5

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