myugaruの色々構想中・・・！

http://blogs.wankuma.com/myugaru/archive/2008/03/06/126524.aspx のコードを示します。

・・・NyaRuRuさんのアレ（※）の影響がもろに出ています・・・

（※アレ→http://blogs.wankuma.com/myugaru/archive/2008/02/26/125044.aspx）

しかしまあ誰が組んでも同じになると思われます（と言って逃げます・・・汗

んーと、そろそろアレも言わなきゃいけないですねえ。面倒ですね色々と・・・。

以下のコードの使用に際してmyugaruの許可は必要ありません。また起こる現象の責任は全て使用者の自己責任で処理願います。myugaruは一切の責を負うつもりはございません。バグレポートなどは喜んでお受けしますが修正の義務も無いものといたします。 うはっ硬っ・・・（・ω・；A）ごめんねごめんねごめんね・・・。

拡張メソッドとは？→http://blogs.wankuma.com/myugaru/archive/2008/03/07/126694.aspx

// GameTemplate
//
// Copyright (c) 2008 myugaru
//
// Module Name : LinkedListEx.cs
// Abstract: LinkedList拡張メソッド
    
using System;
using System.Collections.Generic;
    
namespace LinkedListEx
{
    /// <summary>
    /// LinkedList拡張メソッド
    /// </summary>
    static class MyExtention
    {
        /// <summary>
        /// LinkedList拡張：ノードの列挙
        /// </summary>
        /// <typeparam name="T">型引数</typeparam>
        /// <param name="list">リスト</param>
        /// <param name="action">列挙アクション
        /// delegate void action(LinkedListNode ノード)</param>
        public static void ForEach<T>(
            this LinkedList<T> list, Action<LinkedListNode<T>> action)
        {
            var node = list.First;
            // ループ中にノード削除を許可するので常にnullチェックする
            while (node != null) {
                // 自身の削除もありうるのでNextノードを退避
                var next = node.Next;
                // Action呼び出し
                action(node);
                node = next;
                // 一周したら終わり
                if (node == list.First)
                    break;
            }
        }
    
        /// <summary>
        /// LinkedList拡張：ノードの検索(Predicate版)
        /// 戻り：見つかったノード。見つからなければnull
        /// </summary>
        /// <typeparam name="T">型引数</typeparam>
        /// <param name="list">リスト</param>
        /// <param name="predicate">検索用
        /// bool predicate(LinkedListNode ノード)</param>
        /// <returns>見つかったノード。見つからなければnull</returns>
        public static LinkedListNode<T> Find<T>(
            this LinkedList<T> list, Predicate<LinkedListNode<T>> predicate)
        {
            var node = list.First;
            // ループ中にノード削除を許可するので常にnullチェックする
            while (node != null) {
                // 自身の削除もありうるのでNextノードを退避
                var next = node.Next;
                if (predicate(node)) {
                    // 見つかったノードを返す
                    return node;
                }
                node = next;
                // 一周したら終わり
                if (node == list.First)
                    break;
            }
            return null;
        }
    
        /// <summary>
        /// LinkedList拡張：ノードの検索(Predicate版)
        /// 戻り：一番最後の見つかったノード。見つからなければnull
        /// </summary>
        /// <typeparam name="T">型引数</typeparam>
        /// <param name="list">リスト</param>
        /// <param name="predicate">検索用
        /// bool predicate(LinkedListNode ノード)</param>
        /// <returns>一番最後の見つかったノード。見つからなければnull</returns>
        public static LinkedListNode<T> FindLast<T>(
            this LinkedList<T> list, Predicate<LinkedListNode<T>> predicate)
        {
            var node = list.Last;
            // ループ中にノード削除を許可するので常にnullチェックする
            while (node != null) {
                // 自身の削除もありうるのでPreviousノードを退避
                var previous = node.Previous;
                if (predicate(node)) {
                    // 見つかったノードを返す
                    return node;
                }
                node = previous;
                // 一周したら終わり
                if (node == list.Last)
                    break;
            }
            return null;
        }
    
        /// <summary>
        /// LinkedList拡張：ソート状態維持で値を追加(Comparison版)
        /// 戻り：追加したノード
        /// </summary>
        /// <typeparam name="T">型引数</typeparam>
        /// <param name="list">リスト</param>
        /// <param name="value">値</param>
        /// <param name="comparison">比較用
        /// delegate int comparison(T 左値, T 右値)</param>
        /// <returns>追加したノード</returns>
        public static LinkedListNode<T> Add<T>(
            this LinkedList<T> list, T value, Comparison<T> comparison)
        {
            // comparisonにより追加位置を見つける
            var node = list.Find(n => comparison(value, n.Value) <= 0);
            if (node != null) {
                // 追加位置が発見できたら直前へ追加
                list.AddBefore(node, value);
                node = node.Previous;
            } else {
                // 追加位置が発見できないなら末尾に追加
                list.AddLast(value);
                node = list.Last;
            }
            return node;
        }
    
        /// <summary>
        /// LinkedList拡張：ソート状態維持で値を追加(IComparer版)
        /// 戻り：追加したノード
        /// </summary>
        /// <typeparam name="T">型引数</typeparam>
        /// <param name="list">リスト</param>
        /// <param name="value">値</param>
        /// <param name="comparer">比較用
        /// int comparer.Compare(T 左値, T 右値)</param>
        /// <returns>追加したノード</returns>
        public static LinkedListNode<T> Add<T>(
            this LinkedList<T> list, T value, IComparer<T> comparer)
        {
            // Comparison版を呼ぶ
            return list.Add(value, comparer.Compare);
        }
    
        /// <summary>
        /// LinkedList拡張：ソート状態維持で値を追加(valueがIComparer実装版)
        /// 戻り：追加したノード
        /// </summary>
        /// <typeparam name="T">型引数</typeparam>
        /// <param name="list">リスト</param>
        /// <param name="value">値（ICompare実装）
        /// int value.Compare(T 左値, T 右値)</param>
        /// <returns>追加したノード</returns>
        public static LinkedListNode<T> Add<T>(
            this LinkedList<T> list, T value) where T : IComparer<T>
        {
            // Comparison版を呼ぶ
            return list.Add(value, value.Compare);
        }
    
        /// <summary>
        /// LinkedList拡張：キー値変更後の再ソート(Comparison版)
        /// 戻り：追加したノード
        /// </summary>
        /// <typeparam name="T">型引数</typeparam>
        /// <param name="node">キー値に変更のあったノード</param>
        /// <param name="comparison">比較用
        /// delegate int comparison(T 左値, T 右値)</param>
        /// <returns>追加したノード</returns>
        public static LinkedListNode<T> ReSorting<T>(
            this LinkedListNode<T> node, Comparison<T> comparison)
        {
            // リストと値の参照を退避
            var list = node.List;
            var value = node.Value;
            // ノードを一旦削除
            list.Remove(node);
            // ソート有効で再追加
            return list.Add(value, comparison);
        }
    
        /// <summary>
        /// LinkedList拡張：キー値変更後の再ソート(IComparer版)
        /// 戻り：追加したノード
        /// </summary>
        /// <typeparam name="T">型引数</typeparam>
        /// <param name="node">キー値に変更のあったノード</param>
        /// <param name="comparer">比較用
        /// int comparer.Compare(T 左値, T 右値)</param>
        /// <returns>追加したノード</returns>
        public static LinkedListNode<T> ReSorting<T>(
            this LinkedListNode<T> node, IComparer<T> comparer)
        {
            // Comparison版を呼ぶ
            return node.ReSorting(comparer.Compare);
        }
    
        /// <summary>
        /// LinkedList拡張：キー値変更後の再ソート(valueがIComparer実装版)
        /// 戻り：追加したノード
        /// </summary>
        /// <typeparam name="T">型引数</typeparam>
        /// <param name="node">キー値に変更のあったノード</param>
        /// <returns>追加したノード</returns>
        public static LinkedListNode<T> ReSorting<T>(
            this LinkedListNode<T> node) where T : IComparer<T>
        {
            // Comparison版を呼ぶ
            return node.ReSorting(node.Value.Compare);
        }
    }
}