C# -Erweiterungsmethode, die nur mit einer Instanz der Klasse arbeitet. Irgendwie in der Nähe?

Question

Soweit ich weiß, C# lassen Sie uns Erweiterungsmethoden mit einer Instanz einer Klasse nur verwenden:

public class MyClass 
{ 
    public static string GetStuff() 
    { 
     return string.Empty; 
    } 
} 

public static class MyClassExtension 
{ 
    public static string GetOtherStuff(this MyClass myClass) 
    { 
     return string.Empty; 
    } 
} 

Verbrauch: Jedoch

MyClass.GetStuff(); 
MyClass.GetOtherStuff();  // Cannot resolve symbol 'GetOtherStuff' 
new MyClass().GetOtherStuff(); // This works 

ich, dass der MVC-Framework mir bemerkt erlaubt zu verlängern die HtmlHelpers so, dass ich meine Erweiterungsmethoden verwenden kann, ohne irgendeine Instanz einer Klasse zu erstellen. wenn ich eine Erweiterungsmethode für HtmlHelper wie dies zum Beispiel zu erstellen:

public static string MyHtmlHelper(this HtmlHelper helper) 
{ 
    return string.Empty; 
} 

kann ich es in einem Rasiermesser Ansicht wie folgt verwenden:

@Html.MyHtmlHelper() // no need to instantiate a class 

Ich würde wirklich das gleiche Ergebnis zu erzielen wie mit meinem MyClass, so kann ich tun:

MyClass.GetOtherStuff() 

Wie könnte ich das tun?

Answer 1

können Sie nicht statische Methoden einer Klasse über Erweiterungsmethoden hinzufügen ...

Weil es Sinn machen, nicht. Was Sie vorschlagen, unterscheidet sich nicht von der Erstellung einer zweiten statischen Klasse mit Ihrer neuen Hilfsmethode. Tu das einfach.

Sie wollen, dies zu tun:

public class MyClass 
{ 
    public static string GetStuff() 
    { 
     return string.Empty; 
    } 

    // Extension method. 
    public static string GetOtherStuff() 
    { 
     // cannot use any non-public members of MyClass 
     return string.Empty; 
    } 
} 
MyClass.GetStuff(); 
MyClass.GetOtherStuff(); 

Die oben nicht möglich ist. Auch wäre es Ihnen keinen Vorteil gegenüber nur tun:

public class MyClass 
{ 
    public static string GetStuff() 
    { 
     return string.Empty; 
    } 
} 

public class MyClassExtension 
{ 
    public static string GetOtherStuff() 
    { 
     // also cannot use any non-public members of MyClass 
     return string.Empty; 
    } 
} 
MyClass.GetStuff(); 
MyClassExtension.GetOtherStuff(); 

Eine letzte Alternative ist, eine Unterklasse erstellen:

public class MyClass 
{ 
    public static string GetStuff() 
    { 
     return string.Empty; 
    } 
} 

public class MyClassExtension : MyClass 
{ 
    public static string GetOtherStuff() 
    { 
     // also cannot use any non-public members of MyClass 
     return string.Empty; 
    } 
} 
MyClassExtension.GetStuff(); 
MyClassExtension.GetOtherStuff(); 

Answer 2

Nein, man kann nicht eine C# Extension-Methode erstellen, die keine Instanz der benötigt Klasse. (Here's a longer explanation)

Option # 1

aber Sie können erstellen Sie Ihre Erweiterungsmethoden, die die bestehende @Html/HtmlHelper in Razor Ansichten hängen ab.

public static class HtmlHelperExtensions 
{ 
    public static string GetOtherStuff(this HtmlHelper helper) 
    { 
     return "other stuff"; 
    } 
} 

Option # 2

Es ist auch möglich, eigene Äquivalent HtmlHelper, zu erstellen, damit Sie sie dann in genau der gleichen Art und Weise aus einer Ansicht .cshtml Razor zugreifen können.

eine leere Klasse definieren mit Erweiterungsmethoden zu erweitern:

public class MyCustomHelper 
{ 
    // Can just be an empty class. 
} 

public static class MyCustomHelperExtensions 
{ 
    public string GetStuff(this MyCustomHelper helper) 
    { 
     return "stuff"; 
    } 
} 

public static class MyOtherCustomHelperExtensions 
{ 
    public string GetOtherStuff(this MyCustomHelper helper) 
    { 
     return "other stuff"; 
    } 
} 

Die HtmlHelper Instanz wird von a property on WebViewPage.cs abgerufen.Sie können WebViewPage mit Ihrem eigenen Klasse erweitern und then configure Razor to use that instead:

public class BaseViewPage<TModel> : WebViewPage<TModel> 
{ 
    private MyCustomHelper _foo; 

    public MyCustomHelper Foo 
    { 
     get 
     { 
      if (_foo == null) 
      { 
       _foo = new MyCustomHelper(); 
      } 

      return _foo; 
     } 
     set 
     { 
      _foo = value; 
     } 
    } 
} 

public class BaseViewPage : WebViewPage 
{ 
    private MyCustomHelper _foo; 

    public MyCustomHelper Foo 
    { 
     get 
     { 
      if (_foo == null) 
      { 
       _foo = new MyCustomHelper(); 
      } 

      return _foo; 
     } 
     set 
     { 
      _foo = value; 
     } 
    } 
} 

und den Zugang dann von einem Rasiermesser wie folgt lesen:

<div> 
    @Foo.GetOtherStuff() 
</div> 

Answer 3

Könnten Sie in jedem Ihrer Module aus der Baseclass erben:

public abstract class MyBaseClass 
{ 
    public static string SomeProperty { get; set; } 

} 

//Module 1 
public class MyClassOne : MyBaseClass 
{ 
    public static string MyFunction() 
    { 
     return SomeProperty + "MyClassOne"; 
    } 
} 

//Module 2 
public class MyClassTwo : MyBaseClass 
{ 
    public static string MyFunction() 
    { 
     return SomeProperty + "MyClassTwo"; 
    } 
} 

Dies würde erlauben Sie zu tun:

MyClassOne.MyFunction() 

Answer 4

Sie können Reflektionen verwenden, um Ihrer Klasse statische Methoden hinzuzufügen. Diese Stackoverflow answer gibt Ihnen möglicherweise eine Idee über die Verwendung von Reflektion zum Hinzufügen von Methoden.