Statische Interface Member?

Hallo,

Ich habe mal einwenig im Code der .NET-Standart Bibliothek gestöbert und bin dabei auf dieses Interface gestoßen

//
// Zusammenfassung:
//     Defines a mechanism for parsing a string to a value.
//
// Typparameter:
//   TSelf:
//     The type that implements this interface.
public interface IParsable<TSelf> where TSelf : IParsable<TSelf>?
{
    //
    // Zusammenfassung:
    //     Parses a string into a value.
    //
    // Parameter:
    //   s:
    //     The string to parse.
    //
    //   provider:
    //     An object that provides culture-specific formatting information about s.
    //
    // Rückgabewerte:
    //     The result of parsing s.
    //
    // Ausnahmen:
    //   T:System.ArgumentNullException:
    //     s is null.
    //
    //   T:System.FormatException:
    //     s is not in the correct format.
    //
    //   T:System.OverflowException:
    //     s is not representable by TSelf.
    static abstract TSelf Parse(string s, IFormatProvider? provider);
    //
    // Zusammenfassung:
    //     Tries to parse a string into a value.
    //
    // Parameter:
    //   s:
    //     The string to parse.
    //
    //   provider:
    //     An object that provides culture-specific formatting information about s.
    //
    //   result:
    //     When this method returns, contains the result of successfully parsing s or an
    //     undefined value on failure.
    //
    // Rückgabewerte:
    //     true if s was successfully parsed; otherwise, false.
    static abstract bool TryParse([NotNullWhen(true)] string? s, IFormatProvider? provider, [MaybeNullWhen(false)] out TSelf result);
}

Kommt es nur mir so vor oder kommt es euch auch einfach falsch vor das ein Interface statische und abstrakte Member vorschreibt und dazu noch das der abstrakte Member statisch ist (Wenn ich versuche einen statischen Member einer Klasse als abstrakt zu deklarieren kommt ein Compilerfehler).

Falls jemand eine Idee hat wozu das gut sein kann, dann bitte eine Antwort schreiben.

Answer 1

[regex9]

Es handelt sich um ein Feature, welches in C# 11 eingeführt wurde. Die Idee dahinter ist, nun auch statische Verhaltensweisen als generische Constraints vorgeben zu können.

Also zum Beispiel bei Typen, die einen bestimmten Operator überladen, da Operatorüberladungen immer statisch sein müssen.

Angenommen, du möchtest eine Methode schreiben, die mehrere Zahlen addiert. Wenn du das für verschiedene numerische Typen (int, double, ...) brauchst, müsstest du dir eigentlich je Typ eine eigene Methode erstellen. Einfacher geht es stattdessen mit so einer generischen Methode:

public T GetSum<T>(params T[] numbers) where T: INumber<T>
{
  T sum = T.Zero;

  foreach(var number in numbers)
  {
    sum += T.CreateChecked(number);
  }

  return sum;
}

INumber ist hierbei ein Interface, welches eine Operatorenüberladung für + vorgibt (bzw. diese Vorschrift vom Interface IAdditionOperators erbt).

Die Kombination aus static und abstract ergibt sich daraus, dass nochmals deutlich gemacht werden soll, dass es sich nur um eine Methodendeklaration handelt, denn im Gegensatz dazu ist es auch möglich, statische Methodendefinitionen in Interfaces anzuführen.