【C#】Array 型の static 関数を拡張メソッドで使えるようにするクラス

```cs:ArrayExtensions.cs
using System;
using System.Collections.ObjectModel;

/// <summary>
/// 配列の拡張メソッドを管理するクラス
/// </summary>
public static class ArrayExtensions
{
	/// <summary>
	/// 指定した配列をラップする読み取り専用のラッパーを作成します
	/// </summary>
	public static ReadOnlyCollection<T> AsReadOnly<T>( this T[] self )
	{
		return Array.AsReadOnly( self );
	}
		
	/// <summary>
	/// <para>Array 内の要素の範囲を、要素の型に応じて、</para>
	/// <para>0 (ゼロ)、false、または null に設定します</para>
	/// </summary>
	public static void Clear( this Array self )
	{
		Array.Clear( self, 0, self.Length );
	}
		
	/// <summary>
	/// <para>Array 内の要素の範囲を、要素の型に応じて、</para>
	/// <para>0 (ゼロ)、false、または null に設定します</para>
	/// </summary>
	public static void Clear( this Array self, int index, int length )
	{
		Array.Clear( self, index, length );
	}

	/// <summary>
	/// <para>指定された配列に、指定された述語によって定義された条件と</para>
	/// <para>一致する要素が含まれているかどうかを判断します</para>
	/// </summary>
	public static bool Exists<T>( this T[] self, Predicate<T> match )
	{
		return Array.Exists( self, match );
	}

	/// <summary>
	/// <para>指定された述語によって定義された条件と一致する要素を検索し、</para>
	/// <para>Array 全体の中で最もインデックス番号の小さい要素を返します</para>
	/// </summary>
	public static T Find<T>( this T[] self, Predicate<T> match )
	{
		return Array.Find( self, match );
	}
		
	/// <summary>
	/// 指定された述語によって定義された条件と一致するすべての要素を取得します
	/// </summary>
	public static T[] FindAll<T>( this T[] self, Predicate<T> match )
	{
		return Array.FindAll( self, match );
	}

	/// <summary>
	/// <para>指定された述語によって定義された条件と一致する要素を、Array 全体を対象に検索し、</para>
	/// <para>最もインデックス番号の小さい要素の 0 から始まるインデックスを返します</para>
	/// </summary>
	public static int FindIndex<T>( this T[] self, Predicate<T> match )
	{
		return Array.FindIndex( self, match );
	}
		
	/// <summary>
	/// <para>指定された述語によって定義された条件と一致する要素を、Array の指定されたインデックスから、</para>
	/// <para>最後の要素までを範囲として検索し、最もインデックス番号の小さい要素の 0 から始まるインデックスを返します</para>
	/// </summary>
	public static int FindIndex<T>( this T[] self, int startIndex, Predicate<T> match )
	{
		return Array.FindIndex( self, startIndex, match );
	}
		
	/// <summary>
	/// <para>指定された述語によって定義された条件と一致する要素を、Array の指定されたインデックスから、</para>
	/// <para>指定された要素数を範囲として検索し、最もインデックス番号の小さい要素の 0 から始まるインデックスを返します</para>
	/// </summary>
	public static int FindIndex<T>( this T[] self, int startIndex, int count, Predicate<T> match )
	{
		return Array.FindIndex( self, startIndex, count, match );
	}
		
	/// <summary>
	/// 指定された述語によって定義された条件と一致する要素を、Array 全体を対象に検索し、最もインデックス番号の大きい要素を返します
	/// </summary>
	public static T FindLast<T>( this T[] self, Predicate<T> match )
	{
		return Array.FindLast( self, match );
	}

	/// <summary>
	/// <para>指定された述語によって定義された条件と一致する要素を、Array 全体を対象に検索し、</para>
	/// <para>最もインデックス番号の大きい要素の 0 から始まるインデックスを返します</para>
	/// </summary>
	public static int FindLastIndex<T>( this T[] self, Predicate<T> match )
	{
		return Array.FindLastIndex( self, match );
	}

	/// <summary>
	/// <para>指定された述語によって定義された条件と一致する要素を、Array の先頭の要素から、</para>
	/// <para>指定されたインデックス位置までを範囲として検索し、最もインデックス番号の大きい要素の 0 から始まるインデックスを返します</para>
	/// </summary>
	public static int FindLastIndex<T>( this T[] self, int startIndex, Predicate<T> match )
	{
		return Array.FindLastIndex( self, startIndex, match );
	}
		
	/// <summary>
	/// <para>指定された述語によって定義された条件と一致する要素を、Array の指定されたインデックス位置から、</para>
	/// <para>指定された要素数までを範囲として検索し、最もインデックス番号の大きい要素の 0 から始まるインデックスを返します</para>
	/// </summary>
	public static int FindLastIndex<T>( this T[] self, int startIndex, int count, Predicate<T> match )
	{
		return Array.FindLastIndex( self, startIndex, count, match );
	}

	/// <summary>
	/// 指定された配列内の各要素に対して、指定された処理を実行します
	/// </summary>
	public static void ForEach<T>( this T[] self, Action<T> action )
	{
		for ( int i = 0; i < self.Length; i++ ) 
		{
			action( self[ i ] );
		}
	}
	
	/// <summary>
	/// 指定された配列内の各要素に対して、指定された処理を実行します
	/// </summary>
	public static void ForEach<T>( this T[] self, Action<T, int> action )
	{
		for ( int i = 0; i < self.Length; i++ ) 
		{
			action( self[ i ], i );
		}
	}

	/// <summary>
	/// Array 全体を対象に指定したオブジェクトを検索し、インデックス番号の最も小さい要素のインデックスを返します
	/// </summary>
	public static int IndexOf<T>( this T[] self, T value )
	{
		return Array.IndexOf( self, value );
	}

	/// <summary>
	/// 指定したオブジェクトを検索し、1 次元の Array 全体でそのオブジェクトが最初に見つかった位置のインデックス番号を返します
	/// </summary>
	public static int IndexOf( this Array self, object value )
	{
		return Array.IndexOf( self, value );
	}
		
	/// <summary>
	/// <para>指定したオブジェクトを、Array の指定したインデックス位置から最後の要素までを範囲として検索し、</para>
	/// <para>最もインデックス番号の小さい要素のインデックス番号を返します</para>
	/// </summary>
	public static int IndexOf<T>( this T[] self, T value, int startIndex )
	{
		return Array.IndexOf( self, value, startIndex );
	}

	/// <summary>
	/// <para>指定されたオブジェクトを、1 次元 Array の指定されたインデックスから最後の要素までを範囲として検索し、</para>
	/// <para>インデックス番号の最も小さい要素のインデックス番号を返します</para>
	/// </summary>
	public static int IndexOf( this Array self, object value, int startIndex )
	{
		return Array.IndexOf( self, value, startIndex );
	}

	/// <summary>
	/// <para>指定したオブジェクトを、Array の指定したインデックスから指定した要素数を範囲として検索し、</para>
	/// <para>インデックス番号の最も小さい要素のインデックス番号を返します</para>
	/// </summary>
	public static int IndexOf<T>( this T[] self, T value, int startIndex, int count )
	{
		return Array.IndexOf( self, value, startIndex, count );
	}
		
	/// <summary>
	/// <para>指定したオブジェクトを、指定したインデックス位置から、指定した要素数を範囲とする 1 次元 Array 要素の範囲内で検索し、</para>
	/// <para>最もインデックス番号の小さい要素のインデックス番号を返します</para>
	/// </summary>
	public static int IndexOf( this Array self, object value, int startIndex, int count )
	{
		return Array.IndexOf( self, value, startIndex, count );
	}

	/// <summary>
	/// 指定したオブジェクトを Array 全体を対象に検索し、インデックス番号の最も大きい要素のインデックスを返します
	/// </summary>
	public static int LastIndexOf<T>( this T[] self, T value )
	{
		return Array.LastIndexOf( self, value );
	}

	/// <summary>
	/// 指定したオブジェクトを検索し、1 次元の Array 全体でそのオブジェクトが最後に見つかった位置のインデックス番号を返します
	/// </summary>
	public static int LastIndexOf( this Array self, object value )
	{
		return Array.LastIndexOf( self, value );
	}
		
	/// <summary>
	/// <para>指定したオブジェクトを、Array の先頭の要素から、指定されたインデックス位置までを範囲として検索し、</para>
	/// <para>インデックス番号の最も大きい要素のインデックス番号を返します</para>
	/// </summary>
	public static int LastIndexOf<T>( this T[] self, T value, int startIndex )
	{
		return Array.LastIndexOf( self, value, startIndex );
	}
		
	/// <summary>
	/// <para>1 次元 Array の先頭の要素から、指定したインデックスまでを対象に指定したオブジェクトを検索し、</para>
	/// <para>インデックス番号の最も大きい要素のインデックス番号を返します</para>
	/// </summary>
	public static int LastIndexOf( this Array self, object value, int startIndex )
	{
		return Array.LastIndexOf( self, value, startIndex );
	}
		
	/// <summary>
	/// <para>指定したオブジェクトを、Array の指定したインデックス位置から、指定した要素数を範囲として検索し、</para>
	/// <para>インデックス番号の最も大きい要素のインデックス番号を返します</para>
	/// </summary>
	public static int LastIndexOf<T>( this T[] self, T value, int startIndex, int count )
	{
		return Array.LastIndexOf( self, value, startIndex, count );
	}
		
	/// <summary>
	/// <para>指定したオブジェクトを、1 次元 Array の指定したインデックス位置から、指定した要素数を範囲として検索し、</para>
	/// <para>インデックス番号の最も大きい要素のインデックス番号を返します</para>
	/// </summary>
	public static int LastIndexOf( this Array self, object value, int startIndex, int count )
	{
		return Array.LastIndexOf( self, value, startIndex, count );
	}

	/// <summary>
	/// 1 次元の Array 内全体の要素のシーケンスを反転させます
	/// </summary>
	public static void Reverse( this Array self )
	{
		Array.Reverse( self );
	}

	/// <summary>
	/// 1 次元 Array 内の要素範囲の並び順を反転させます
	/// </summary>
	public static void Reverse( this Array self, int index, int length )
	{
		Array.Reverse( self, index, length );
	}

	/// <summary>
	/// 配列内のすべての要素が、指定された述語によって定義された条件と一致するかどうかを調べます
	/// </summary>
	public static bool TrueForAll<T>( this T[] self, Predicate<T> match )
	{
		return Array.TrueForAll( self, match );
	}

	/// <summary>
	/// Array 全体の要素を並べ替えます
	/// </summary>
	public static void Sort<T>( this T[] self )
	{
		Array.Sort( self );
	}

	/// <summary>
	/// Array 内の要素を、指定した Comparison<T> を使用して並べ替えます
	/// </summary>
	public static void Sort<T>( this T[] self, Comparison<T> comparison )
	{
		Array.Sort( self, comparison );
	}
}
```