CODEWITHSUNDEEP
c#.netlinqextension-methodscompiler-errors
Tom Gullen
Tom Gullen

Reputation: 61727

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

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

Upvotes: 10

Views: 23010

Answers (8)

jgauffin
jgauffin

Reputation: 101150

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

Upvotes: 15

Ssithra
Ssithra

Reputation: 710

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.

Upvotes: 4

m0sa
m0sa

Reputation: 10940

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

Upvotes: 0

BrokenGlass
BrokenGlass

Reputation: 160892

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.

Upvotes: 2

Dutch Nico
Dutch Nico

Reputation: 270

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.

Upvotes: 0

Rik
Rik

Reputation: 29243

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.

Upvotes: 0

abatishchev
abatishchev

Reputation: 100268

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

Upvotes: 1

Stecya
Stecya

Reputation: 23266

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

Upvotes: 1

Related Questions