Was bedeutet der Fehler "Extension-Methode muss statisch sein" bedeuten?

Ich habe Probleme mit dieser Klasse, insbesondere die Methode:

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

Sagt es die Fehlermeldung:

Erweiterung Methode muss statisch sein

Allerdings wenn ich die Methode statisch ist, wirft es andere Bereiche, speziell auf this.xxx kann nicht zugegriffen werden, in der eine statische Methode.

Ich bin ein wenig verwirrt über die Rückkehr Typen mit <T> und die Rückgabetypen, wenn jemand könnte es mir erklären und wie es funktioniert wäre ich dankbar.

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

Bearbeiten

Ich versuche, mich eine Klasse, die Folgendes tun können:

var q = db.tblJobHeaders;

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

Hi Tom, Kannst du bitte posten Sie den code für ExecuteOrderBys?
Dies ist die gleiche Ausgabe, die Sie gerade fragte: stackoverflow.com/questions/6096299/... - ja, verschiedene Klassen, aber im wesentlichen das gleiche Problem.
Es wurde das Thema im nicht-statische Klasse, hier - in nicht-statische Methode. Beide compiler-Fehler sind Recht informativ, btw.
ich habe einige code auf, wie die Klasse arbeiten soll, ich bin wirklich verwirrt jetzt, ich wollen einfach nur eine einfache Methode, die ich denke, es ist anders als meine anderen Fragen sorry wenn es nicht ist, aber ich habe Schwierigkeiten, das zu verstehen.
Ich glaube nicht, dass ich will, dass es eine Erweiterung Methode, ich bin wirklich verwirrt darüber. Ich will einfach nur, dass es eine normale Methode, die in einigen Daten und gibt einige Daten, aber die return-Typen sind verwirrend mich. Ich habe nicht diesen

InformationsquelleAutor Tom Gullen | 2011-05-23

.net c#compiler-errors extension-methods linq

15

Sie nicht versuchen, zu verlängern IQueryable überhaupt durch das Aussehen von Ihrem Beispiel. Entfernen this von der Methode, definition und dein Beispiel sollte funktionieren.
```
public class OrderByCollection
{
    //.. shameless cut ..
    public IQueryable<T> ExecuteOrderBys<T>(IQueryable<T> source)
    {
        //.. we don't need no stinking body ..
    }
}
```
Was machen Ihre Beispiel Arbeit:
```
var q = db.tblJobHeaders;

OrderByCollection OBys = new OrderByCollection();
OBys.AddOrderBy("some field", true);
OBys.AddOrderBy("anotherfield", false);
OBys.ExecuteOrderBys(q);
```
Als seitliche Anmerkung, die ich nicht verwenden würde bool zu definieren, wie die orderby ' s sortiert werden sollen. Der code ist noch unklar. Verwenden Sie ein enum oder anderen Methoden statt:
```
OBys.AddOrderBy("some field", Sort.Ascending);
```
oder:
```
OBys.AddOrderByDescending("some field");
```
Update

Erweiterung Methoden verwendet, um "plugin" - Methoden zu vorhandenen Klassen oder Schnittstellen. Durch das schreiben public IQueryable<T> ExecuteOrderBys<T>(this IQueryable<T> source) Sie wirklich sagen, dass die Methode sollte angeschlossen werden, in IQueryable<T>. Und daher sollte zugegriffen werden, wie myQuery.ExecuteOrderBys.

Meine Vermutung ist, dass erweiterungsmethoden müssen statisch sein und auf statische Klassen, um Verwirrung zu vermeiden:

a) sind Sie wirklich nicht-Mitglieder der Klassen oder Schnittstellen, und kann nicht auf etwas anderes als öffentliche Felder/Eigenschaften/Methoden.

b) Sie kann sich für jede Klasse. Ohne die Einschränkung könnte man einen Aufruf der Methode DoSomething(this ThatObject instance) in einer Klasse genannt ThatObject. Das problem wäre, dass Sie können nicht auf etwas anderes als die öffentliche Schnittstelle, da es eine Erweiterung-Methode.

Den verwirrenden Möglichkeiten wäre endlos 😉

Genial danke!!! Ich bin ein bisschen verwirrt durch die dieses Schlüsselwort im parameter der Methode (ich war kopieren die Methode header von einem anderen ähnlichen Funktion), heißt es, es wird dann erweitert?
check mein update.

InformationsquelleAutor jgauffin
4

Machen Ihre statische Methode war die richtige Sache zu tun ist, um Sie zu Erweiterung Methode (war die Tatsache, dass eine Erweiterung Methode, die richtige Sache zu tun oder nicht, ist eine andere Debatte !).

Nun, da die Methode statisch ist, ist es angebracht, die Klasse, wo es definiert ist, nicht jede Instanz dieser Klasse. Das ist, warum die keyword - this ist sinnlos hier. this bedeutet "die aktuelle Instanz der Klasse" : Sie existiert nicht per definition, in der eine statische Methode.

"" Finden Sie einfach Ihre Eingabe parameter source. Setzen source wo es this und sicherstellen, dass der code kompiliert wird mit dem gewünschten Effekt.

InformationsquelleAutor Ssithra
2

Extension-Methoden können nur definiert werden als statische Methoden in einer statischen Klasse - das bedeutet, Sie können verwenden alle Instanzvariablen dieser Klasse - die einzige Abhängigkeit einer Erweiterung Methode sollte sein, die Instanz des Typs, den Sie übergeben, und statische /compile-Zeit-Werte.

Umgehen Sie das Problem in Ihrem Fall sein kann, um zu definieren Skip und Take als const (und einen entsprechenden Konstanten Wert für beide) oder alternativ übergeben Sie Sie als Parameter an Ihre extension-Methode.

InformationsquelleAutor BrokenGlass
1

Erweiterung muss definiert werden, im statischen Klasse

Versuchen Sie dies:
```
public static class YourExtension
{
    public static IQueryable<T> ExecuteOrderBys<T>(this IQueryable<T> source)
    {
        //do something
    }
}
```
Danke, ich dachte mir, dass aus dem Fehler führt aber zu anderen Fehlern also ich bin mir nicht sicher, wie es zu lösen ist

InformationsquelleAutor Stecya

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

InformationsquelleAutor abatishchev

0

Ändern
```
public static class OrderByCollection
```
und
```
public static IQueryable<T> ExecuteOrderBys<T>(this IQueryable<T> source)
```
Die zentrale Frage ist hier die static - Schlüsselwort, das angibt, dass die Klasse nicht haben jeder Staat seine eigene, und dass die Methode nicht sein, dass Staatliche Informationen.

InformationsquelleAutor Rik
0

Sollte man nicht den Zugriff auf Mitglieder durch.xxx, sollten Sie Ihren Zugang über die.. variable. In diesem Fall: Quelle
Nach der Methode und die Klasse, in der es statisch.

InformationsquelleAutor Dutch Nico

Zuerst konvertieren Sie Ihre Sammlung Klasse an eine generische Klasse, die Sie benötigen, um zu verwenden Typrückschluss für IQueryable T in der extension-Methode:

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

Dann deklarieren Sie eine neue statische Klasse, die das extension-Methode. Da die Methode statisch sein, Sie können nicht verwenden dieser qualifier, aber die Instanz übergeben als argument source:

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

InformationsquelleAutor m0sa

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Update