Einführung in Erweitungsmethoden
Hallo ihr da draußen! Ich bin gestern auf ein Snippet bei dotnet-snippets gestoßen, in dem ein Element an ein bestehendes Array angehangen werden soll. Nachdem ich dort eine einfachere Methode vorgeschlagen habe, ist mir noch ein viel elegantere Art und Weise eingefallen, wie man dies Bewerkstelligen könnte. Und zwar über Erweiterungsmethoden! Dabei bleibt das Vorgehen das selbe. Bei Erweiterungsmethoden handelt es sich um Erweitungen zu bestehenden Funktionalitäten von Klassen/Typen. In unserem Fall des Arrays. Wir bauen uns also zwei Erweitungen, eine für das Ändern der Größe und eine zum Anhängen des Elementes. Was brauchen wir dafür? Als allererstes benötigen wir eine als static deklarierte Klasse, diese nennen wir ArrayExtensions.
/// <summary>
/// Klasse für Array-Erweiterungen
/// </summary>
public static class ArrayExtensions
{
}
als nächstes fangen wir an uns den Funktionsrumpf für die Resize-Funktion anzusehen
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="Source"></param>
/// <param name="NewSize"></param>
public static T[] Resize<T>(this T[] Source, int NewSize)
{
}
Wir ihr sehen könnt, benötigen wir in dem Fall einen Rückgabewert der Funktion. Warum? Bei einem Array handelt es sich um einen Value Type, daher kann dies nicht direkt in der Erweiterungsmethode geändert werden. Es ist leider auch nicht möglich, die Funktion so zu deklarieren, dass das Array als ref übergeben wird. Wenn jemand dennoch eine Lösung gefunden hat, bitte melden!. Bei Referenz-Typen könnt ihr nach eigenem Ermessen in der Erweiterungsmethode an dem Objekt rumpfuschen, ohne dass ihr die Änderung zurückgeben müsst.
Aus diesem Grund gilt: Wenn in der Erweiterungsmethode zu einem ValueType gehört, und dort das ValueType-Object geändert werden soll, muss das geänderte Objekt zurückgegeben und zugewiesen werden. Der Aufruf würde dann so aussehen:
object[] myArray = new object[] { 1, 2, 3 };
myArray = myArray.Resize(4);
Der Parameter NewSize ist, denk ich mal, selbsterklärend. Des Weiteren müssen Erweiterungsmethoden immer als static deklariert sein. Sie werden jedoch per Instanzmethodensyntax aufgerufen. Also wie in obrigen Beispiel.
Das Interessantere ist jedoch der erste Parameter der Funktion. Dieser beginnt, wie ihr sehen könnt mit this T[]. Darüber wird signalisiert, dass es sich um eine Erweiterungsmethode für den Typ T[] handelt. Also eine Erweiterung für ein Array von irgendeinem Typ. Die fertige Version sieht dann so aus:
/// <summary>
/// Klasse für Array-Erweiterungen
/// </summary>
public static class ArrayExtensions
{
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="Source"></param>
/// <param name="NewSize"></param>
public static T[] Resize<T>(this T[] Source, int NewSize)
{
Array.Resize(ref Source, Source.Length + 1);
return Source;
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="Source"></param>
/// <param name="NewElement"></param>
public static T[] Append<T>(this T[] Source, T NewElement)
{
Array.Resize(ref Source, Source.Length + 1);
Source[Source.Length - 1] = NewElement;
return Source;
}
}