using System;
using System.Windows.Forms;
using System.Collections;
 
namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
 
        //ListViewItemSorterに指定するフィールド
        ListViewItemComparer listViewItemSorter;
 
        private void Form1_Load(object sender, EventArgs e)
        {
            listView1.Dock = DockStyle.Fill;
            listView1.View = View.Details;
 
            ColumnHeader ch1 = new ColumnHeader();
            ColumnHeader ch2 = new ColumnHeader();
            ch1.Text = "名前";
            ch2.Text = "ファイルの種類";
            listView1.Columns.Add(ch1);
            listView1.Columns.Add(ch2);
 
            listView1.ColumnClick += new ColumnClickEventHandler(ListView1_ColumnClick);
 
            ListViewItem lvi;
            // フォルダをリストに追加
            // フォルダの場合はタグにtrueを付ける
            lvi = new ListViewItem(new string[]{"ccc", "フォルダ"});
            lvi.Tag = true;
            listView1.Items.Add(lvi);
            lvi = new ListViewItem(new string[]{"aaa", "フォルダ"});
            lvi.Tag = true;
            listView1.Items.Add(lvi);
            lvi = new ListViewItem(new string[]{"bbb", "フォルダ"});
            lvi.Tag = true;
            listView1.Items.Add(lvi);
            // ファイルをリストに追加
            // ファイルの場合はタグにfalseを付ける
            lvi = new ListViewItem(new string[]{"a.txt", "テキストファイル"});
            lvi.Tag = false;
            listView1.Items.Add(lvi);
            lvi = new ListViewItem(new string[]{"c.txt", "テキストファイル"});
            lvi.Tag = false;
            listView1.Items.Add(lvi);
            lvi = new ListViewItem(new string[]{"b.txt", "テキストファイル"});
            lvi.Tag = false;
            listView1.Items.Add(lvi);
            //ListViewItemComparerの作成と設定
            listViewItemSorter = new ListViewItemComparer();
            listViewItemSorter.ColumnModes = new ListViewItemComparer.ComparerMode[]
            {
                ListViewItemComparer.ComparerMode.String,
                ListViewItemComparer.ComparerMode.String
            };
            //ListViewItemSorterを指定する
            listView1.ListViewItemSorter = listViewItemSorter;
            listView1.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize);
        }
 
        //列がクリックされた時
        private void ListView1_ColumnClick(object sender, ColumnClickEventArgs e)
        {
            //クリックされた列を設定
            listViewItemSorter.Column = e.Column;
            //並び替える
            listView1.Sort();
        }
    }
 
 
    // ListViewItemComparerクラスは以下のページから引用しました
    // http://d...content-available-to-author-only...n.net/vb/dotnet/control/lvitemsort.html
 
    /// <summary>
    /// ListViewの項目の並び替えに使用するクラス
    /// </summary>
    public class ListViewItemComparer : IComparer
    {
        /// <summary>
        /// 比較する方法
        /// </summary>
        public enum ComparerMode
        {
            String,
            Integer,
            DateTime
        };
 
        private int _column;
        private SortOrder _order;
        private ComparerMode _mode;
        private ComparerMode[] _columnModes;
 
        /// <summary>
        /// 並び替えるListView列の番号
        /// </summary>
        public int Column
        {
            set
            {
                if (_column == value)
                {
                    if (_order == SortOrder.Ascending)
                        _order = SortOrder.Descending;
                    else if (_order == SortOrder.Descending)
                        _order = SortOrder.Ascending;
                }
                _column = value;
            }
            get
            {
                return _column;
            }
        }
        /// <summary>
        /// 昇順か降順か
        /// </summary>
        public SortOrder Order
        {
            set
            {
                _order = value;
            }
            get
            {
                return _order;
            }
        }
        /// <summary>
        /// 並び替えの方法
        /// </summary>
        public ComparerMode Mode
        {
            set
            {
                _mode = value;
            }
            get
            {
                return _mode;
            }
        }
        /// <summary>
        /// 列ごとの並び替えの方法
        /// </summary>
        public ComparerMode[] ColumnModes
        {
            set
            {
                _columnModes = value;
            }
        }
 
        /// <summary>
        /// ListViewItemComparerクラスのコンストラクタ
        /// </summary>
        /// <param name="col">並び替える列番号</param>
        /// <param name="ord">昇順か降順か</param>
        /// <param name="cmod">並び替えの方法</param>
        public ListViewItemComparer(
            int col, SortOrder ord, ComparerMode cmod)
        {
            _column = col;
            _order = ord;
            _mode = cmod;
        }
        public ListViewItemComparer()
        {
            _column = 0;
            _order = SortOrder.Ascending;
            _mode = ComparerMode.String;
        }
 
        //xがyより小さいときはマイナスの数、大きいときはプラスの数、
        //同じときは0を返す
        public int Compare(object x, object y)
        {
            int result = 0;
            //ListViewItemの取得
            ListViewItem itemx = (ListViewItem)x;
            ListViewItem itemy = (ListViewItem)y;
 
            //並べ替えの方法を決定
            if (_columnModes != null && _columnModes.Length > _column)
                _mode = _columnModes[_column];
 
            //並び替えの方法別に、xとyを比較する
            switch (_mode)
            {
                case ComparerMode.String:
 
                    if (_column == 0) // 名前のヘッダーをクリックしたときの処理
                    {
                        // タグの値が同じならフォルダとファイルの比較ではない
                        if (itemx.Tag == itemy.Tag)
                        {
                            result = string.Compare(itemx.SubItems[_column].Text, itemy.SubItems[_column].Text);
                        }
                        else
                        {
                            // フォルダとファイルを比較しているので-1を返す
                            result = -1;
                        }
                    }
                    else // ファイルの種類をクリックしたときの処理
                    {
                        result = string.Compare(itemx.SubItems[_column].Text, itemy.SubItems[_column].Text);
                    }
                    break;
                case ComparerMode.Integer:
                    result = int.Parse(itemx.SubItems[_column].Text) -
                        int.Parse(itemy.SubItems[_column].Text);
                    break;
                case ComparerMode.DateTime:
                    result = DateTime.Compare(
                        DateTime.Parse(itemx.SubItems[_column].Text),
                        DateTime.Parse(itemy.SubItems[_column].Text));
                    break;
            }
 
            //降順の時は結果を+-逆にする
            if (_order == SortOrder.Descending)
                result = -result;
            else if (_order == SortOrder.None)
                result = 0;
 
            //結果を返す
            return result;
        }
    }
}
 

using System;
using System.Windows.Forms;
using System.Collections;

namespace WindowsFormsApplication1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        //ListViewItemSorterに指定するフィールド
        ListViewItemComparer listViewItemSorter;

        private void Form1_Load(object sender, EventArgs e)
        {
            listView1.Dock = DockStyle.Fill;
            listView1.View = View.Details;

            ColumnHeader ch1 = new ColumnHeader();
            ColumnHeader ch2 = new ColumnHeader();
            ch1.Text = "名前";
            ch2.Text = "ファイルの種類";
            listView1.Columns.Add(ch1);
            listView1.Columns.Add(ch2);

            listView1.ColumnClick += new ColumnClickEventHandler(ListView1_ColumnClick);

            ListViewItem lvi;
            // フォルダをリストに追加
            // フォルダの場合はタグにtrueを付ける
            lvi = new ListViewItem(new string[]{"ccc", "フォルダ"});
            lvi.Tag = true;
            listView1.Items.Add(lvi);
            lvi = new ListViewItem(new string[]{"aaa", "フォルダ"});
            lvi.Tag = true;
            listView1.Items.Add(lvi);
            lvi = new ListViewItem(new string[]{"bbb", "フォルダ"});
            lvi.Tag = true;
            listView1.Items.Add(lvi);
            // ファイルをリストに追加
            // ファイルの場合はタグにfalseを付ける
            lvi = new ListViewItem(new string[]{"a.txt", "テキストファイル"});
            lvi.Tag = false;
            listView1.Items.Add(lvi);
            lvi = new ListViewItem(new string[]{"c.txt", "テキストファイル"});
            lvi.Tag = false;
            listView1.Items.Add(lvi);
            lvi = new ListViewItem(new string[]{"b.txt", "テキストファイル"});
            lvi.Tag = false;
            listView1.Items.Add(lvi);
            //ListViewItemComparerの作成と設定
            listViewItemSorter = new ListViewItemComparer();
            listViewItemSorter.ColumnModes = new ListViewItemComparer.ComparerMode[]
            {
                ListViewItemComparer.ComparerMode.String,
                ListViewItemComparer.ComparerMode.String
            };
            //ListViewItemSorterを指定する
            listView1.ListViewItemSorter = listViewItemSorter;
            listView1.AutoResizeColumns(ColumnHeaderAutoResizeStyle.HeaderSize);
        }

        //列がクリックされた時
        private void ListView1_ColumnClick(object sender, ColumnClickEventArgs e)
        {
            //クリックされた列を設定
            listViewItemSorter.Column = e.Column;
            //並び替える
            listView1.Sort();
        }
    }


    // ListViewItemComparerクラスは以下のページから引用しました
    // http://d...content-available-to-author-only...n.net/vb/dotnet/control/lvitemsort.html

    /// <summary>
    /// ListViewの項目の並び替えに使用するクラス
    /// </summary>
    public class ListViewItemComparer : IComparer
    {
        /// <summary>
        /// 比較する方法
        /// </summary>
        public enum ComparerMode
        {
            String,
            Integer,
            DateTime
        };

        private int _column;
        private SortOrder _order;
        private ComparerMode _mode;
        private ComparerMode[] _columnModes;

        /// <summary>
        /// 並び替えるListView列の番号
        /// </summary>
        public int Column
        {
            set
            {
                if (_column == value)
                {
                    if (_order == SortOrder.Ascending)
                        _order = SortOrder.Descending;
                    else if (_order == SortOrder.Descending)
                        _order = SortOrder.Ascending;
                }
                _column = value;
            }
            get
            {
                return _column;
            }
        }
        /// <summary>
        /// 昇順か降順か
        /// </summary>
        public SortOrder Order
        {
            set
            {
                _order = value;
            }
            get
            {
                return _order;
            }
        }
        /// <summary>
        /// 並び替えの方法
        /// </summary>
        public ComparerMode Mode
        {
            set
            {
                _mode = value;
            }
            get
            {
                return _mode;
            }
        }
        /// <summary>
        /// 列ごとの並び替えの方法
        /// </summary>
        public ComparerMode[] ColumnModes
        {
            set
            {
                _columnModes = value;
            }
        }

        /// <summary>
        /// ListViewItemComparerクラスのコンストラクタ
        /// </summary>
        /// <param name="col">並び替える列番号</param>
        /// <param name="ord">昇順か降順か</param>
        /// <param name="cmod">並び替えの方法</param>
        public ListViewItemComparer(
            int col, SortOrder ord, ComparerMode cmod)
        {
            _column = col;
            _order = ord;
            _mode = cmod;
        }
        public ListViewItemComparer()
        {
            _column = 0;
            _order = SortOrder.Ascending;
            _mode = ComparerMode.String;
        }

        //xがyより小さいときはマイナスの数、大きいときはプラスの数、
        //同じときは0を返す
        public int Compare(object x, object y)
        {
            int result = 0;
            //ListViewItemの取得
            ListViewItem itemx = (ListViewItem)x;
            ListViewItem itemy = (ListViewItem)y;

            //並べ替えの方法を決定
            if (_columnModes != null && _columnModes.Length > _column)
                _mode = _columnModes[_column];

            //並び替えの方法別に、xとyを比較する
            switch (_mode)
            {
                case ComparerMode.String:

                    if (_column == 0) // 名前のヘッダーをクリックしたときの処理
                    {
                        // タグの値が同じならフォルダとファイルの比較ではない
                        if (itemx.Tag == itemy.Tag)
                        {
                            result = string.Compare(itemx.SubItems[_column].Text, itemy.SubItems[_column].Text);
                        }
                        else
                        {
                            // フォルダとファイルを比較しているので-1を返す
                            result = -1;
                        }
                    }
                    else // ファイルの種類をクリックしたときの処理
                    {
                        result = string.Compare(itemx.SubItems[_column].Text, itemy.SubItems[_column].Text);
                    }
                    break;
                case ComparerMode.Integer:
                    result = int.Parse(itemx.SubItems[_column].Text) -
                        int.Parse(itemy.SubItems[_column].Text);
                    break;
                case ComparerMode.DateTime:
                    result = DateTime.Compare(
                        DateTime.Parse(itemx.SubItems[_column].Text),
                        DateTime.Parse(itemy.SubItems[_column].Text));
                    break;
            }

            //降順の時は結果を+-逆にする
            if (_order == SortOrder.Descending)
                result = -result;
            else if (_order == SortOrder.None)
                result = 0;

            //結果を返す
            return result;
        }
    }
}
