blocks|key|1219613|text|我使用列名进行排序，以设置可能需要根据列中存储的数据类型和/或列是否已经排序(asc/desc)来处理的任何排序细节。下面是我的ColumnClick事件处理程序中的一段代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1219614|private+void+listView_ColumnClick(object+sender,+ColumnClickEventArgs+e)
++++{
++++++++ListViewItemComparer+sorter+=+GetListViewSorter(e.Column);

++++++++listView.ListViewItemSorter+=+sorter;
++++++++listView.Sort();
++++}

++++private+ListViewItemComparer+GetListViewSorter(int+columnIndex)
++++{
++++++++ListViewItemComparer+sorter+=+(ListViewItemComparer)listView.ListViewItemSorter;
++++++++if+(sorter+==+null)
++++++++{
++++++++++++sorter+=+new+ListViewItemComparer();
++++++++}

++++++++sorter.ColumnIndex+=+columnIndex;

++++++++string+columnName+=+packagedEstimateListView.Columns[columnIndex].Name;
++++++++switch+(columnName)
++++++++{
++++++++++++case+ApplicationModel.DisplayColumns.DateCreated:
++++++++++++case+ApplicationModel.DisplayColumns.DateUpdated:
++++++++++++++++sorter.ColumnType+=+ColumnDataType.DateTime;
++++++++++++++++break;
++++++++++++case+ApplicationModel.DisplayColumns.NetTotal:
++++++++++++case+ApplicationModel.DisplayColumns.GrossTotal:
++++++++++++++++sorter.ColumnType+=+ColumnDataType.Decimal;
++++++++++++++++break;
++++++++++++default:
++++++++++++++++sorter.ColumnType+=+ColumnDataType.String;
++++++++++++++++break;
++++++++}

++++++++if+(sorter.SortDirection+==+SortOrder.Ascending)
++++++++{
++++++++++++sorter.SortDirection+=+SortOrder.Descending;
++++++++}
++++++++else
++++++++{
++++++++++++sorter.SortDirection+=+SortOrder.Ascending;
++++++++}

++++++++return+sorter;
++++}|code-block|syntax|javascript|1219615|下面是我的ListViewItemComparer|1219616|public+class+ListViewItemComparer+:+IComparer
{
++++private+int+_columnIndex;
++++public+int+ColumnIndex
++++{
++++++++get
++++++++{
++++++++++++return+_columnIndex;
++++++++}
++++++++set
++++++++{
++++++++++++_columnIndex+=+value;
++++++++}
++++}

++++private+SortOrder+_sortDirection;
++++public+SortOrder+SortDirection
++++{
++++++++get
++++++++{
++++++++++++return+_sortDirection;
++++++++}
++++++++set
++++++++{
++++++++++++_sortDirection+=+value;
++++++++}
++++}

++++private+ColumnDataType+_columnType;
++++public+ColumnDataType+ColumnType
++++{
++++++++get
++++++++{
++++++++++++return+_columnType;
++++++++}
++++++++set
++++++++{
++++++++++++_columnType+=+value;
++++++++}
++++}


++++public+ListViewItemComparer()
++++{
++++++++_sortDirection+=+SortOrder.None;
++++}

++++public+int+Compare(object+x,+object+y)
++++{
++++++++ListViewItem+lviX+=+x+as+ListViewItem;
++++++++ListViewItem+lviY+=+y+as+ListViewItem;

++++++++int+result;

++++++++if+(lviX+==+null+&&+lviY+==+null)
++++++++{
++++++++++++result+=+0;
++++++++}
++++++++else+if+(lviX+==+null)
++++++++{
++++++++++++result+=+-1;
++++++++}

++++++++else+if+(lviY+==+null)
++++++++{
++++++++++++result+=+1;
++++++++}

++++++++switch+(ColumnType)
++++++++{
++++++++++++case+ColumnDataType.DateTime:
++++++++++++++++DateTime+xDt+=+DataParseUtility.ParseDate(lviX.SubItems[ColumnIndex].Text);
++++++++++++++++DateTime+yDt+=+DataParseUtility.ParseDate(lviY.SubItems[ColumnIndex].Text);
++++++++++++++++result+=+DateTime.Compare(xDt,+yDt);
++++++++++++++++break;

++++++++++++case+ColumnDataType.Decimal:
++++++++++++++++Decimal+xD+=+DataParseUtility.ParseDecimal(lviX.SubItems[ColumnIndex].Text.Replace("$",+string.Empty).Replace(",",+string.Empty));
++++++++++++++++Decimal+yD+=+DataParseUtility.ParseDecimal(lviY.SubItems[ColumnIndex].Text.Replace("$",+string.Empty).Replace(",",+string.Empty));
++++++++++++++++result+=+Decimal.Compare(xD,+yD);
++++++++++++++++break;
++++++++++++case+ColumnDataType.Short:
++++++++++++++++short+xShort+=+DataParseUtility.ParseShort(lviX.SubItems[ColumnIndex].Text);
++++++++++++++++short+yShort+=+DataParseUtility.ParseShort(lviY.SubItems[ColumnIndex].Text);
++++++++++++++++result+=+xShort.CompareTo(yShort);
++++++++++++++++break;
++++++++++++case+ColumnDataType.Int:
++++++++++++++++int+xInt+=+DataParseUtility.ParseInt(lviX.SubItems[ColumnIndex].Text);
++++++++++++++++int+yInt+=+DataParseUtility.ParseInt(lviY.SubItems[ColumnIndex].Text);
++++++++++++++++return+xInt.CompareTo(yInt);
++++++++++++++++break;
++++++++++++case+ColumnDataType.Long:
++++++++++++++++long+xLong+=+DataParseUtility.ParseLong(lviX.SubItems[ColumnIndex].Text);
++++++++++++++++long+yLong+=+DataParseUtility.ParseLong(lviY.SubItems[ColumnIndex].Text);
++++++++++++++++return+xLong.CompareTo(yLong);
++++++++++++++++break;
++++++++++++default:

++++++++++++++++result+=+string.Compare(
++++++++++++++++++++lviX.SubItems[ColumnIndex].Text,
++++++++++++++++++++lviY.SubItems[ColumnIndex].Text,
++++++++++++++++++++false);

++++++++++++++++break;
++++++++}

++++++++if+(SortDirection+==+SortOrder.Descending)
++++++++{
++++++++++++return+-result;
++++++++}
++++++++else
++++++++{
++++++++++++return+result;
++++++++}
++++}
}|1219617|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I sort using column name to set any sorting specifics that may need to be handled based on data type stored in the column and or if the column has already been sorted on(asc/desc). Here's a snippet from my ColumnClick event handler. 

<pre><code>private void listView_ColumnClick(object sender, ColumnClickEventArgs e)
 {
 ListViewItemComparer sorter = GetListViewSorter(e.Column);

 listView.ListViewItemSorter = sorter;
 listView.Sort();
 }

 private ListViewItemComparer GetListViewSorter(int columnIndex)
 {
 ListViewItemComparer sorter = (ListViewItemComparer)listView.ListViewItemSorter;
 if (sorter == null)
 {
 sorter = new ListViewItemComparer();
 }

 sorter.ColumnIndex = columnIndex;

 string columnName = packagedEstimateListView.Columns[columnIndex].Name;
 switch (columnName)
 {
 case ApplicationModel.DisplayColumns.DateCreated:
 case ApplicationModel.DisplayColumns.DateUpdated:
 sorter.ColumnType = ColumnDataType.DateTime;
 break;
 case ApplicationModel.DisplayColumns.NetTotal:
 case ApplicationModel.DisplayColumns.GrossTotal:
 sorter.ColumnType = ColumnDataType.Decimal;
 break;
 default:
 sorter.ColumnType = ColumnDataType.String;
 break;
 }

 if (sorter.SortDirection == SortOrder.Ascending)
 {
 sorter.SortDirection = SortOrder.Descending;
 }
 else
 {
 sorter.SortDirection = SortOrder.Ascending;
 }

 return sorter;
 }
</code></pre>

Below is my ListViewItemComparer

<pre><code>public class ListViewItemComparer : IComparer
{
 private int _columnIndex;
 public int ColumnIndex
 {
 get
 {
 return _columnIndex;
 }
 set
 {
 _columnIndex = value;
 }
 }

 private SortOrder _sortDirection;
 public SortOrder SortDirection
 {
 get
 {
 return _sortDirection;
 }
 set
 {
 _sortDirection = value;
 }
 }

 private ColumnDataType _columnType;
 public ColumnDataType ColumnType
 {
 get
 {
 return _columnType;
 }
 set
 {
 _columnType = value;
 }
 }


 public ListViewItemComparer()
 {
 _sortDirection = SortOrder.None;
 }

 public int Compare(object x, object y)
 {
 ListViewItem lviX = x as ListViewItem;
 ListViewItem lviY = y as ListViewItem;

 int result;

 if (lviX == null &amp;&amp; lviY == null)
 {
 result = 0;
 }
 else if (lviX == null)
 {
 result = -1;
 }

 else if (lviY == null)
 {
 result = 1;
 }

 switch (ColumnType)
 {
 case ColumnDataType.DateTime:
 DateTime xDt = DataParseUtility.ParseDate(lviX.SubItems[ColumnIndex].Text);
 DateTime yDt = DataParseUtility.ParseDate(lviY.SubItems[ColumnIndex].Text);
 result = DateTime.Compare(xDt, yDt);
 break;

 case ColumnDataType.Decimal:
 Decimal xD = DataParseUtility.ParseDecimal(lviX.SubItems[ColumnIndex].Text.Replace("$", string.Empty).Replace(",", string.Empty));
 Decimal yD = DataParseUtility.ParseDecimal(lviY.SubItems[ColumnIndex].Text.Replace("$", string.Empty).Replace(",", string.Empty));
 result = Decimal.Compare(xD, yD);
 break;
 case ColumnDataType.Short:
 short xShort = DataParseUtility.ParseShort(lviX.SubItems[ColumnIndex].Text);
 short yShort = DataParseUtility.ParseShort(lviY.SubItems[ColumnIndex].Text);
 result = xShort.CompareTo(yShort);
 break;
 case ColumnDataType.Int:
 int xInt = DataParseUtility.ParseInt(lviX.SubItems[ColumnIndex].Text);
 int yInt = DataParseUtility.ParseInt(lviY.SubItems[ColumnIndex].Text);
 return xInt.CompareTo(yInt);
 break;
 case ColumnDataType.Long:
 long xLong = DataParseUtility.ParseLong(lviX.SubItems[ColumnIndex].Text);
 long yLong = DataParseUtility.ParseLong(lviY.SubItems[ColumnIndex].Text);
 return xLong.CompareTo(yLong);
 break;
 default:

 result = string.Compare(
 lviX.SubItems[ColumnIndex].Text,
 lviY.SubItems[ColumnIndex].Text,
 false);

 break;
 }

 if (SortDirection == SortOrder.Descending)
 {
 return -result;
 }
 else
 {
 return result;
 }
 }
}
</code></pre>

blocks|key|1219664|text|我会向你推荐你的datagridview，对于很重的东西..它包含了许多汽车功能列表，但我们没有|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1219665|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

i would recommend you to you datagridview, for heavy stuff.. it's include a lot of auto feature listviwe does not

blocks|key|1434650|text|忘了你的自定义分类器吧。使用下一页中的代码重新开始。它将向您展示如何定义从IComparer接口继承的类。每一行都被注释掉了，所以你可以实际看到发生了什么。唯一可能的复杂问题是如何从Listview控件中检索Listview项。将它们放好，您所需要做的就是复制并粘贴IComparer接口类和columnClick方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1434651|http://support.microsoft.com/kb/319401|offset|length|1434652|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|12|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@$D|O|E|P|1|Q]]|A|$]]|$1|F|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|C]]]]

Forget about your custom sorter. Start over using the code at the following page. It will show you how to define a class that inherits from the IComparer interface. Each line is commented out, so you can actually see what is happening. The only potential complication is how you are retrieving your Listview Items from your Listview control. Get those squared away and all you need to do is copy and paste the IComparer interface class and the columnClick method. 

<a href="http://support.microsoft.com/kb/319401" rel="noreferrer">http://support.microsoft.com/kb/319401</a>

blocks|key|1434741|text|我的解决方案是一个类，用于在单击列标题时对listView项进行排序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1434742|您可以指定每列的类型。|1434743|listView.ListViewItemSorter+=+new+ListViewColumnSorter();
listView.ListViewItemSorter.ColumnsTypeComparer.Add(0,+DateTime);
listView.ListViewItemSorter.ColumnsTypeComparer.Add(1,+int);|code-block|syntax|javascript|1434744|就是这样！|1434745|C#类：|1434746|using+System.Collections;
using+System.Collections.Generic;
using+EDV;

namespace+System.Windows.Forms
{
++++///+<summary>
++++///+Cette+classe+est+une+implémentation+de+l'interface+'IComparer'+pour+le+tri+des+items+de+ListView.+Adapté+de+http://support.microsoft.com/kb/319401.
++++///+</summary>
++++///+<remarks>Intégré+par+EDVariables.</remarks>
++++public+class+ListViewColumnSorter+:+IComparer
++++{
++++++++///+<summary>
++++++++///+Spécifie+la+colonne+à+trier
++++++++///+</summary>
++++++++private+int+ColumnToSort;
++++++++///+<summary>
++++++++///+Spécifie+l'ordre+de+tri+(en+d'autres+termes+'Croissant').
++++++++///+</summary>
++++++++private+SortOrder+OrderOfSort;
++++++++///+<summary>
++++++++///+Objet+de+comparaison+ne+respectant+pas+les+majuscules+et+minuscules
++++++++///+</summary>
++++++++private+CaseInsensitiveComparer+ObjectCompare;

++++++++///+<summary>
++++++++///+Constructeur+de+classe.++Initialise+la+colonne+sur+'0'+et+aucun+tri
++++++++///+</summary>
++++++++public+ListViewColumnSorter()
++++++++++++:+this(0,+SortOrder.None)+{+}

++++++++///+<summary>
++++++++///+Constructeur+de+classe.++Initializes+various+elements
++++++++///+<param+name="columnToSort">Spécifie+la+colonne+à+trier</param>
++++++++///+<param+name="orderOfSort">Spécifie+l'ordre+de+tri</param>
++++++++///+</summary>
++++++++public+ListViewColumnSorter(int+columnToSort,+SortOrder+orderOfSort)
++++++++{
++++++++++++//+Initialise+la+colonne
++++++++++++ColumnToSort+=+columnToSort;

++++++++++++//+Initialise+l'ordre+de+tri
++++++++++++OrderOfSort+=+orderOfSort;

++++++++++++//+Initialise+l'objet+CaseInsensitiveComparer
++++++++++++ObjectCompare+=+new+CaseInsensitiveComparer();

++++++++++++//+Dictionnaire+de+comparateurs
++++++++++++ColumnsComparer+=+new+Dictionary<int,+IComparer>();
++++++++++++ColumnsTypeComparer+=+new+Dictionary<int,+Type>();

++++++++}

++++++++///+<summary>
++++++++///+Cette+méthode+est+héritée+de+l'interface+IComparer.++Il+compare+les+deux+objets+passés+en+effectuant+une+comparaison+
++++++++///qui+ne+tient+pas+compte+des+majuscules+et+des+minuscules.
++++++++///+ Si+le+comparateur+n'existe+pas+dans+ColumnsComparer,+CaseInsensitiveComparer+est+utilisé.
++++++++///+</summary>
++++++++///+<param+name="x">Premier+objet+à+comparer</param>
++++++++///+<param+name="x">Deuxième+objet+à+comparer</param>
++++++++///+<returns>Le+résultat+de+la+comparaison.+"0"+si+équivalent,+négatif+si+'x'+est+inférieur+à+'y'+
++++++++///et+positif+si+'x'+est+supérieur+à+'y'</returns>
++++++++public+int+Compare(object+x,+object+y)
++++++++{
++++++++++++int+compareResult;
++++++++++++ListViewItem+listviewX,+listviewY;

++++++++++++//+Envoit+les+objets+à+comparer+aux+objets+ListViewItem
++++++++++++listviewX+=+(ListViewItem)x;
++++++++++++listviewY+=+(ListViewItem)y;

++++++++++++if+(listviewX.SubItems.Count+<+ColumnToSort+%2B+1+%7C%7C+listviewY.SubItems.Count+<+ColumnToSort+%2B+1)
++++++++++++++++return+0;

++++++++++++IComparer+objectComparer+=+null;
++++++++++++Type+comparableType+=+null;
++++++++++++if+(ColumnsComparer+==+null+%7C%7C+!ColumnsComparer.TryGetValue(ColumnToSort,+out+objectComparer))
++++++++++++++++if+(ColumnsTypeComparer+==+null+%7C%7C+!ColumnsTypeComparer.TryGetValue(ColumnToSort,+out+comparableType))
++++++++++++++++++++objectComparer+=+ObjectCompare;

++++++++++++//+Compare+les+deux+éléments
++++++++++++if+(comparableType+!=+null)+{
++++++++++++++++//Conversion+du+type
++++++++++++++++object+valueX+=+listviewX.SubItems[ColumnToSort].Text;
++++++++++++++++object+valueY+=+listviewY.SubItems[ColumnToSort].Text;
++++++++++++++++if+(!edvTools.TryParse(ref+valueX,+comparableType)+%7C%7C+!edvTools.TryParse(ref+valueY,+comparableType))
++++++++++++++++++++return+0;
++++++++++++++++compareResult+=+(valueX+as+IComparable).CompareTo(valueY);
++++++++++++}
++++++++++++else
++++++++++++++++compareResult+=+objectComparer.Compare(listviewX.SubItems[ColumnToSort].Text,+listviewY.SubItems[ColumnToSort].Text);

++++++++++++//+Calcule+la+valeur+correcte+d'après+la+comparaison+d'objets
++++++++++++if+(OrderOfSort+==+SortOrder.Ascending)+{
++++++++++++++++//+Le+tri+croissant+est+sélectionné,+renvoie+des+résultats+normaux+de+comparaison
++++++++++++++++return+compareResult;
++++++++++++}
++++++++++++else+if+(OrderOfSort+==+SortOrder.Descending)+{
++++++++++++++++//+Le+tri+décroissant+est+sélectionné,+renvoie+des+résultats+négatifs+de+comparaison
++++++++++++++++return+(-compareResult);
++++++++++++}
++++++++++++else+{
++++++++++++++++//+Renvoie+'0'+pour+indiquer+qu'ils+sont+égaux
++++++++++++++++return+0;
++++++++++++}
++++++++}

++++++++///+<summary>
++++++++///+Obtient+ou+définit+le+numéro+de+la+colonne+à+laquelle+appliquer+l'opération+de+tri+(par+défaut+sur+'0').
++++++++///+</summary>
++++++++public+int+SortColumn
++++++++{
++++++++++++set
++++++++++++{
++++++++++++++++ColumnToSort+=+value;
++++++++++++}
++++++++++++get
++++++++++++{
++++++++++++++++return+ColumnToSort;
++++++++++++}
++++++++}

++++++++///+<summary>
++++++++///+Obtient+ou+définit+l'ordre+de+tri+à+appliquer+(par+exemple,+'croissant'+ou+'décroissant').
++++++++///+</summary>
++++++++public+SortOrder+Order
++++++++{
++++++++++++set
++++++++++++{
++++++++++++++++OrderOfSort+=+value;
++++++++++++}
++++++++++++get
++++++++++++{
++++++++++++++++return+OrderOfSort;
++++++++++++}
++++++++}

++++++++///+<summary>
++++++++///+Dictionnaire+de+comparateurs+par+colonne.
++++++++///+ Pendant+le+tri,+si+le+comparateur+n'existe+pas+dans+ColumnsComparer,+CaseInsensitiveComparer+est+utilisé.
++++++++///+</summary>
++++++++public+Dictionary<int,+IComparer>+ColumnsComparer+{+get;+set;+}

++++++++///+<summary>
++++++++///+Dictionnaire+de+comparateurs+par+colonne.
++++++++///+ Pendant+le+tri,+si+le+comparateur+n'existe+pas+dans+ColumnsTypeComparer,+CaseInsensitiveComparer+est+utilisé.
++++++++///+</summary>
++++++++public+Dictionary<int,+Type>+ColumnsTypeComparer+{+get;+set;+}
++++}
}|1434747|初始化ListView：|1434748|++++<var>Visual.WIN.ctrlListView.OnShown</var>++:+
++++eventSender.Columns.Clear();
++++eventSender.SmallImageList+=+edvWinForm.ImageList16;
++++eventSender.ListViewItemSorter+=+new+ListViewColumnSorter();
++++var+col+=+eventSender.Columns.Add("Répertoire");
++++col.Width+=+160;
++++col.ImageKey+=+"Domain";
++++col+=+eventSender.Columns.Add("Fichier");
++++col.Width+=+180;
++++col.ImageKey+=+"File";
++++col+=+eventSender.Columns.Add("Date");
++++col.Width+=+120;
++++col.ImageKey+=+"DateTime";
++++eventSender.ListViewItemSorter.ColumnsTypeComparer.Add(col.Index,+DateTime);
++++col+=+eventSender.Columns.Add("Position");
++++col.TextAlign+=+HorizontalAlignment.Right;
++++col.Width+=+80;
++++col.ImageKey+=+"Num";
++++eventSender.ListViewItemSorter.ColumnsTypeComparer.Add(col.Index,+Int32);|1434749|填写ListView：|1434750|<var>Visual.WIN.cmdSearch.OnClick</var>++:+
//non+récursif+et+sans+fonction
++++..ctrlListView:Items.Clear();
++++..ctrlListView:Sorting+=+SortOrder.None;
++++var+group+=+..ctrlListView:Groups.Add(DateTime.Now.ToString()
++++++++++++++++,+Path.Combine(..cboDir:Text,+..ctrlPattern1:Text)+%2B+"+contenant+"+%2B+..ctrlSearch1:Text);
++++var+perf+=++Environment.TickCount;

++++var+files+=+new+DirectoryInfo(..cboDir:Text).GetFiles(..ctrlPattern1:Text)
++++var+search+=+..ctrlSearch1:Text;
++++var+ignoreCase+=+..Search.IgnoreCase;
++++//var+result+=+new+StringBuilder();
++++var+dirLength+:+int+=+..cboDir:Text.Length;
++++var+position+:+int;
++++var+added+:+int+=+0;
++++for(var+i+:+int+=+0;+i+&lt;+files.Length;+i%2B%2B){
++++++++var+file+=+files[i];
++++++++if(search+==+""
++++++++%7C%7C+(position+=+File.ReadAllText(file.FullName).IndexOf(String(search)
++++++++++++++++++++++++++++,+StringComparison(ignoreCase+?+StringComparison.InvariantCultureIgnoreCase+:+StringComparison.InvariantCulture)))+&gt;+=0)+{

++++++++//++result.AppendLine(file.FullName.Substring(dirLength)+%2B+"\tPos+:+"+%2B+pkvFile.Value);
++++++++++++var+item+=+..ctrlListView:Items.Add(file.FullName.Substring(dirLength));
++++++++++++item.SubItems.Add(file.Name);
++++++++++++item.SubItems.Add(File.GetLastWriteTime(file.FullName).ToString());
++++++++++++item.SubItems.Add(position.ToString("#+###+##0"));
++++++++++++item.Group+=+group;
++++++++++++%2B%2Badded;
++++++++}
++++}
++++group.Header+%2B=+"+:+"+%2B+added+%2B+"/"+%2B+files.Length+%2B+"+fichier(s)"
++++++++++++++++%2B+"++en+"+%2B+(Environment.TickCount+-+perf).ToString("#+##0+msec");|1434751|在ListView列上，单击：|1434752|<var>Visual.WIN.ctrlListView.OnColumnClick</var>++:+
//+Déterminer+si+la+colonne+sélectionnée+est+déjà+la+colonne+triée.
var+sorter+=+eventSender.ListViewItemSorter;
if+(+eventArgs.Column+==+sorter+.SortColumn+)
{
++++//+Inverser+le+sens+de+tri+en+cours+pour+cette+colonne.
++++if+(sorter.Order+==+SortOrder.Ascending)
++++{
++++++++sorter.Order+=+SortOrder.Descending;
++++}
++++else
++++{
++++++++sorter.Order+=+SortOrder.Ascending;
++++}
}
else
{
++++//+Définir+le+numéro+de+colonne+à+trier+;+par+défaut+sur+croissant.
++++sorter.SortColumn+=+eventArgs.Column;
++++sorter.Order+=+SortOrder.Ascending;
}

//+Procéder+au+tri+avec+les+nouvelles+options.
eventSender.Sort();|1434753|上面使用的函数edvTools.TryParse|1434754|class+edvTools+{
++++///+<summary>
++++///+Tente+la+conversion+d'une+valeur+suivant+un+type+EDVType
++++///+</summary>
++++///+<param+name="pValue">Référence+de+la+valeur+à+convertir</param>
++++///+<param+name="pType">Type+EDV+en+sortie</param>
++++///+<returns></returns>
++++public+static+bool+TryParse(ref+object+pValue,+System.Type+pType)
++++{
++++++++int+lIParsed;
++++++++double+lDParsed;
++++++++string+lsValue;
++++++++if+(pValue+==+null)+return+false;
++++++++if+(pType.Equals(typeof(bool)))+{
++++++++++++bool+lBParsed;
++++++++++++if+(pValue+is+bool)+return+true;
++++++++++++if+(double.TryParse(pValue.ToString(),+out+lDParsed))+{
++++++++++++++++pValue+=+lDParsed+!=+0D;
++++++++++++++++return+true;
++++++++++++}
++++++++++++if+(bool.TryParse(pValue.ToString(),+out+lBParsed))+{
++++++++++++++++pValue+=+lBParsed;
++++++++++++++++return+true;
++++++++++++}
++++++++++++else
++++++++++++++++return+false;
++++++++}
++++++++if+(pType.Equals(typeof(Double)))+{
++++++++++++if+(pValue+is+Double)+return+true;
++++++++++++if+(double.TryParse(pValue.ToString(),+out+lDParsed)
++++++++++++++++%7C%7C+double.TryParse(pValue.ToString().Replace(NumberDecimalSeparatorNOT,+NumberDecimalSeparator),+out+lDParsed))+{
++++++++++++++++pValue+=+lDParsed;
++++++++++++++++return+true;
++++++++++++}
++++++++++++else
++++++++++++++++return+false;
++++++++}
++++++++if+(pType.Equals(typeof(int)))+{
++++++++++++if+(pValue+is+int)+return+true;
++++++++++++if+(Int32.TryParse(pValue.ToString(),+out+lIParsed))+{
++++++++++++++++pValue+=+lIParsed;
++++++++++++++++return+true;
++++++++++++}
++++++++++++else+if+(double.TryParse(pValue.ToString(),+out+lDParsed))+{
++++++++++++++++pValue+=+(int)lDParsed;
++++++++++++++++return+true;
++++++++++++}
++++++++++++else
++++++++++++++++return+false;
++++++++}
++++++++if+(pType.Equals(typeof(Byte)))+{
++++++++++++if+(pValue+is+byte)+return+true;
++++++++++++byte+lByte;
++++++++++++if+(Byte.TryParse(pValue.ToString(),+out+lByte))+{
++++++++++++++++pValue+=+lByte;
++++++++++++++++return+true;
++++++++++++}
++++++++++++else+if+(double.TryParse(pValue.ToString(),+out+lDParsed))+{
++++++++++++++++pValue+=+(byte)lDParsed;
++++++++++++++++return+true;
++++++++++++}
++++++++++++else
++++++++++++++++return+false;
++++++++}
++++++++if+(pType.Equals(typeof(long)))+{
++++++++++++long+lLParsed;
++++++++++++if+(pValue+is+long)+return+true;
++++++++++++if+(long.TryParse(pValue.ToString(),+out+lLParsed))+{
++++++++++++++++pValue+=+lLParsed;
++++++++++++++++return+true;
++++++++++++}
++++++++++++else+if+(double.TryParse(pValue.ToString(),+out+lDParsed))+{
++++++++++++++++pValue+=+(long)lDParsed;
++++++++++++++++return+true;
++++++++++++}
++++++++++++else
++++++++++++++++return+false;
++++++++}
++++++++if+(pType.Equals(typeof(Single)))+{
++++++++++++if+(pValue+is+float)+return+true;
++++++++++++Single+lSParsed;
++++++++++++if+(Single.TryParse(pValue.ToString(),+out+lSParsed)
++++++++++++++++%7C%7C+Single.TryParse(pValue.ToString().Replace(NumberDecimalSeparatorNOT,+NumberDecimalSeparator),+out+lSParsed))+{
++++++++++++++++pValue+=+lSParsed;
++++++++++++++++return+true;
++++++++++++}
++++++++++++else
++++++++++++++++return+false;
++++++++}
++++++++if+(pType.Equals(typeof(DateTime)))+{
++++++++++++if+(pValue+is+DateTime)+return+true;
++++++++++++DateTime+lDTParsed;
++++++++++++if+(DateTime.TryParse(pValue.ToString(),+out+lDTParsed))+{
++++++++++++++++pValue+=+lDTParsed;
++++++++++++++++return+true;
++++++++++++}
++++++++++++else+if+(pValue.ToString().Contains("UTC"))+//Date+venant+de+JScript
++++++++++++{
++++++++++++++++if+(_MonthsUTC+==+null)+InitMonthsUTC();
++++++++++++++++string[]+lDateParts+=+pValue.ToString().Split('+');
++++++++++++++++lDTParsed+=+new+DateTime(int.Parse(lDateParts[5]),+_MonthsUTC[lDateParts[1]],+int.Parse(lDateParts[2]));
++++++++++++++++lDateParts+=+lDateParts[3].ToString().Split(':');
++++++++++++++++pValue+=+lDTParsed.AddSeconds(int.Parse(lDateParts[0])+*+3600+%2B+int.Parse(lDateParts[1])+*+60+%2B+int.Parse(lDateParts[2]));
++++++++++++++++return+true;
++++++++++++}
++++++++++++else
++++++++++++++++return+false;

++++++++}
++++++++if+(pType.Equals(typeof(Array)))+{
++++++++++++if+(pValue+is+System.Collections.ICollection+%7C%7C+pValue+is+System.Collections.ArrayList)
++++++++++++++++return+true;
++++++++++++return+pValue+is+System.Data.DataTable
++++++++++++++++%7C%7C+pValue+is+string+&&+(pValue+as+string).StartsWith("<");
++++++++}
++++++++if+(pType.Equals(typeof(DataTable)))+{
++++++++++++return+pValue+is+System.Data.DataTable
++++++++++++++++%7C%7C+pValue+is+string+&&+(pValue+as+string).StartsWith("<");

++++++++}
++++++++if+(pType.Equals(typeof(System.Drawing.Bitmap)))+{
++++++++++++return+pValue+is+System.Drawing.Image+%7C%7C+pValue+is+byte[];

++++++++}
++++++++if+(pType.Equals(typeof(System.Drawing.Image)))+{
++++++++++++return+pValue+is+System.Drawing.Image+%7C%7C+pValue+is+byte[];

++++++++}
++++++++if+(pType.Equals(typeof(System.Drawing.Color)))+{
++++++++++++if+(pValue+is+System.Drawing.Color)+return+true;
++++++++++++if+(pValue+is+System.Drawing.KnownColor)+{
++++++++++++++++pValue+=+System.Drawing.Color.FromKnownColor((System.Drawing.KnownColor)pValue);
++++++++++++++++return+true;
++++++++++++}

++++++++++++int+lARGB;
++++++++++++if+(!int.TryParse(lsValue+=+pValue.ToString(),+out+lARGB))+{
++++++++++++++++if+(lsValue.StartsWith("Color+[A=",+StringComparison.InvariantCulture))+{
++++++++++++++++++++foreach+(string+lsARGB+in+lsValue.Substring("Color+[".Length,+lsValue.Length+-+"Color+[]".Length).Split(','))
++++++++++++++++++++++++switch+(lsARGB.TrimStart().Substring(0,+1))+{
++++++++++++++++++++++++++++case+"A":
++++++++++++++++++++++++++++++++lARGB+=+int.Parse(lsARGB.Substring(2))+*+0x1000000;
++++++++++++++++++++++++++++++++break;
++++++++++++++++++++++++++++case+"R":
++++++++++++++++++++++++++++++++lARGB+%2B=+int.Parse(lsARGB.TrimStart().Substring(2))+*+0x10000;
++++++++++++++++++++++++++++++++break;
++++++++++++++++++++++++++++case+"G":
++++++++++++++++++++++++++++++++lARGB+%2B=+int.Parse(lsARGB.TrimStart().Substring(2))+*+0x100;
++++++++++++++++++++++++++++++++break;
++++++++++++++++++++++++++++case+"B":
++++++++++++++++++++++++++++++++lARGB+%2B=+int.Parse(lsARGB.TrimStart().Substring(2));
++++++++++++++++++++++++++++++++break;
++++++++++++++++++++++++++++default:
++++++++++++++++++++++++++++++++break;
++++++++++++++++++++++++}
++++++++++++++++++++pValue+=+System.Drawing.Color.FromArgb(lARGB);
++++++++++++++++++++return+true;
++++++++++++++++}
++++++++++++++++if+(lsValue.StartsWith("Color+[",+StringComparison.InvariantCulture))+{
++++++++++++++++++++pValue+=+System.Drawing.Color.FromName(lsValue.Substring("Color+[".Length,+lsValue.Length+-+"Color+[]".Length));
++++++++++++++++++++return+true;
++++++++++++++++}
++++++++++++++++return+false;
++++++++++++}
++++++++++++pValue+=+System.Drawing.Color.FromArgb(lARGB);
++++++++++++return+true;
++++++++}
++++++++if+(pType.IsEnum)+{
++++++++++++try+{
++++++++++++++++if+(pValue+==+null)+return+false;
++++++++++++++++if+(pValue+is+int+%7C%7C+pValue+is+byte+%7C%7C+pValue+is+ulong+%7C%7C+pValue+is+long+%7C%7C+pValue+is+double)
++++++++++++++++++++pValue+=+Enum.ToObject(pType,+pValue);
++++++++++++++++else
++++++++++++++++++++pValue+=+Enum.Parse(pType,+pValue.ToString());
++++++++++++}
++++++++++++catch+{
++++++++++++++++return+false;
++++++++++++}
++++++++}
++++++++return+true;
++++}
}|1434755|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|18|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|19|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|1A|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|1B|8|@]|9|@]|A|$G|H]]|$1|O|3|P|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Q|3|R|5|F|7|1D|8|@]|9|@]|A|$G|H]]|$1|S|3|T|5|6|7|1E|8|@]|9|@]|A|$]]|$1|U|3|V|5|F|7|1F|8|@]|9|@]|A|$G|H]]|$1|W|3|X|5|6|7|1G|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|F|7|1H|8|@]|9|@]|A|$G|H]]|$1|10|3|11|5|6|7|1I|8|@]|9|@]|A|$]]|$1|12|3|13|5|F|7|1J|8|@]|9|@]|A|$G|H]]|$1|14|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|15|$]]

My solution is a class to sort listView items when you click on column header.

You can specify the type of each column.

<pre><code>listView.ListViewItemSorter = new ListViewColumnSorter();
listView.ListViewItemSorter.ColumnsTypeComparer.Add(0, DateTime);
listView.ListViewItemSorter.ColumnsTypeComparer.Add(1, int);
</code></pre>

That's it !

The C# class : 

<pre class="lang-csharp prettyprint-override"><code>using System.Collections;
using System.Collections.Generic;
using EDV;

namespace System.Windows.Forms
{
 /// &lt;summary&gt;
 /// Cette classe est une implémentation de l'interface 'IComparer' pour le tri des items de ListView. Adapté de http://support.microsoft.com/kb/319401.
 /// &lt;/summary&gt;
 /// &lt;remarks&gt;Intégré par EDVariables.&lt;/remarks&gt;
 public class ListViewColumnSorter : IComparer
 {
 /// &lt;summary&gt;
 /// Spécifie la colonne à trier
 /// &lt;/summary&gt;
 private int ColumnToSort;
 /// &lt;summary&gt;
 /// Spécifie l'ordre de tri (en d'autres termes 'Croissant').
 /// &lt;/summary&gt;
 private SortOrder OrderOfSort;
 /// &lt;summary&gt;
 /// Objet de comparaison ne respectant pas les majuscules et minuscules
 /// &lt;/summary&gt;
 private CaseInsensitiveComparer ObjectCompare;

 /// &lt;summary&gt;
 /// Constructeur de classe. Initialise la colonne sur '0' et aucun tri
 /// &lt;/summary&gt;
 public ListViewColumnSorter()
 : this(0, SortOrder.None) { }

 /// &lt;summary&gt;
 /// Constructeur de classe. Initializes various elements
 /// &lt;param name="columnToSort"&gt;Spécifie la colonne à trier&lt;/param&gt;
 /// &lt;param name="orderOfSort"&gt;Spécifie l'ordre de tri&lt;/param&gt;
 /// &lt;/summary&gt;
 public ListViewColumnSorter(int columnToSort, SortOrder orderOfSort)
 {
 // Initialise la colonne
 ColumnToSort = columnToSort;

 // Initialise l'ordre de tri
 OrderOfSort = orderOfSort;

 // Initialise l'objet CaseInsensitiveComparer
 ObjectCompare = new CaseInsensitiveComparer();

 // Dictionnaire de comparateurs
 ColumnsComparer = new Dictionary&lt;int, IComparer&gt;();
 ColumnsTypeComparer = new Dictionary&lt;int, Type&gt;();

 }

 /// &lt;summary&gt;
 /// Cette méthode est héritée de l'interface IComparer. Il compare les deux objets passés en effectuant une comparaison 
 ///qui ne tient pas compte des majuscules et des minuscules.
 /// &lt;br/&gt;Si le comparateur n'existe pas dans ColumnsComparer, CaseInsensitiveComparer est utilisé.
 /// &lt;/summary&gt;
 /// &lt;param name="x"&gt;Premier objet à comparer&lt;/param&gt;
 /// &lt;param name="x"&gt;Deuxième objet à comparer&lt;/param&gt;
 /// &lt;returns&gt;Le résultat de la comparaison. "0" si équivalent, négatif si 'x' est inférieur à 'y' 
 ///et positif si 'x' est supérieur à 'y'&lt;/returns&gt;
 public int Compare(object x, object y)
 {
 int compareResult;
 ListViewItem listviewX, listviewY;

 // Envoit les objets à comparer aux objets ListViewItem
 listviewX = (ListViewItem)x;
 listviewY = (ListViewItem)y;

 if (listviewX.SubItems.Count &lt; ColumnToSort + 1 || listviewY.SubItems.Count &lt; ColumnToSort + 1)
 return 0;

 IComparer objectComparer = null;
 Type comparableType = null;
 if (ColumnsComparer == null || !ColumnsComparer.TryGetValue(ColumnToSort, out objectComparer))
 if (ColumnsTypeComparer == null || !ColumnsTypeComparer.TryGetValue(ColumnToSort, out comparableType))
 objectComparer = ObjectCompare;

 // Compare les deux éléments
 if (comparableType != null) {
 //Conversion du type
 object valueX = listviewX.SubItems[ColumnToSort].Text;
 object valueY = listviewY.SubItems[ColumnToSort].Text;
 if (!edvTools.TryParse(ref valueX, comparableType) || !edvTools.TryParse(ref valueY, comparableType))
 return 0;
 compareResult = (valueX as IComparable).CompareTo(valueY);
 }
 else
 compareResult = objectComparer.Compare(listviewX.SubItems[ColumnToSort].Text, listviewY.SubItems[ColumnToSort].Text);

 // Calcule la valeur correcte d'après la comparaison d'objets
 if (OrderOfSort == SortOrder.Ascending) {
 // Le tri croissant est sélectionné, renvoie des résultats normaux de comparaison
 return compareResult;
 }
 else if (OrderOfSort == SortOrder.Descending) {
 // Le tri décroissant est sélectionné, renvoie des résultats négatifs de comparaison
 return (-compareResult);
 }
 else {
 // Renvoie '0' pour indiquer qu'ils sont égaux
 return 0;
 }
 }

 /// &lt;summary&gt;
 /// Obtient ou définit le numéro de la colonne à laquelle appliquer l'opération de tri (par défaut sur '0').
 /// &lt;/summary&gt;
 public int SortColumn
 {
 set
 {
 ColumnToSort = value;
 }
 get
 {
 return ColumnToSort;
 }
 }

 /// &lt;summary&gt;
 /// Obtient ou définit l'ordre de tri à appliquer (par exemple, 'croissant' ou 'décroissant').
 /// &lt;/summary&gt;
 public SortOrder Order
 {
 set
 {
 OrderOfSort = value;
 }
 get
 {
 return OrderOfSort;
 }
 }

 /// &lt;summary&gt;
 /// Dictionnaire de comparateurs par colonne.
 /// &lt;br/&gt;Pendant le tri, si le comparateur n'existe pas dans ColumnsComparer, CaseInsensitiveComparer est utilisé.
 /// &lt;/summary&gt;
 public Dictionary&lt;int, IComparer&gt; ColumnsComparer { get; set; }

 /// &lt;summary&gt;
 /// Dictionnaire de comparateurs par colonne.
 /// &lt;br/&gt;Pendant le tri, si le comparateur n'existe pas dans ColumnsTypeComparer, CaseInsensitiveComparer est utilisé.
 /// &lt;/summary&gt;
 public Dictionary&lt;int, Type&gt; ColumnsTypeComparer { get; set; }
 }
}
</code></pre>

Initializing a ListView :

<pre class="lang-js prettyprint-override"><code> &lt;var&gt;Visual.WIN.ctrlListView.OnShown&lt;/var&gt; : 
 eventSender.Columns.Clear();
 eventSender.SmallImageList = edvWinForm.ImageList16;
 eventSender.ListViewItemSorter = new ListViewColumnSorter();
 var col = eventSender.Columns.Add("Répertoire");
 col.Width = 160;
 col.ImageKey = "Domain";
 col = eventSender.Columns.Add("Fichier");
 col.Width = 180;
 col.ImageKey = "File";
 col = eventSender.Columns.Add("Date");
 col.Width = 120;
 col.ImageKey = "DateTime";
 eventSender.ListViewItemSorter.ColumnsTypeComparer.Add(col.Index, DateTime);
 col = eventSender.Columns.Add("Position");
 col.TextAlign = HorizontalAlignment.Right;
 col.Width = 80;
 col.ImageKey = "Num";
 eventSender.ListViewItemSorter.ColumnsTypeComparer.Add(col.Index, Int32);
</code></pre>

Fill a ListView :

<pre class="lang-js prettyprint-override"><code>&lt;var&gt;Visual.WIN.cmdSearch.OnClick&lt;/var&gt; : 
//non récursif et sans fonction
 ..ctrlListView:Items.Clear();
 ..ctrlListView:Sorting = SortOrder.None;
 var group = ..ctrlListView:Groups.Add(DateTime.Now.ToString()
 , Path.Combine(..cboDir:Text, ..ctrlPattern1:Text) + " contenant " + ..ctrlSearch1:Text);
 var perf = Environment.TickCount;

 var files = new DirectoryInfo(..cboDir:Text).GetFiles(..ctrlPattern1:Text)
 var search = ..ctrlSearch1:Text;
 var ignoreCase = ..Search.IgnoreCase;
 //var result = new StringBuilder();
 var dirLength : int = ..cboDir:Text.Length;
 var position : int;
 var added : int = 0;
 for(var i : int = 0; i &amp;lt; files.Length; i++){
 var file = files[i];
 if(search == ""
 || (position = File.ReadAllText(file.FullName).IndexOf(String(search)
 , StringComparison(ignoreCase ? StringComparison.InvariantCultureIgnoreCase : StringComparison.InvariantCulture))) &amp;gt; =0) {

 // result.AppendLine(file.FullName.Substring(dirLength) + "\tPos : " + pkvFile.Value);
 var item = ..ctrlListView:Items.Add(file.FullName.Substring(dirLength));
 item.SubItems.Add(file.Name);
 item.SubItems.Add(File.GetLastWriteTime(file.FullName).ToString());
 item.SubItems.Add(position.ToString("# ### ##0"));
 item.Group = group;
 ++added;
 }
 }
 group.Header += " : " + added + "/" + files.Length + " fichier(s)"
 + " en " + (Environment.TickCount - perf).ToString("# ##0 msec");
</code></pre>

On ListView column click :

<pre class="lang-js prettyprint-override"><code>&lt;var&gt;Visual.WIN.ctrlListView.OnColumnClick&lt;/var&gt; : 
// Déterminer si la colonne sélectionnée est déjà la colonne triée.
var sorter = eventSender.ListViewItemSorter;
if ( eventArgs.Column == sorter .SortColumn )
{
 // Inverser le sens de tri en cours pour cette colonne.
 if (sorter.Order == SortOrder.Ascending)
 {
 sorter.Order = SortOrder.Descending;
 }
 else
 {
 sorter.Order = SortOrder.Ascending;
 }
}
else
{
 // Définir le numéro de colonne à trier ; par défaut sur croissant.
 sorter.SortColumn = eventArgs.Column;
 sorter.Order = SortOrder.Ascending;
}

// Procéder au tri avec les nouvelles options.
eventSender.Sort();
</code></pre>

Function edvTools.TryParse used above

<pre class="lang-csharp prettyprint-override"><code>class edvTools {
 /// &lt;summary&gt;
 /// Tente la conversion d'une valeur suivant un type EDVType
 /// &lt;/summary&gt;
 /// &lt;param name="pValue"&gt;Référence de la valeur à convertir&lt;/param&gt;
 /// &lt;param name="pType"&gt;Type EDV en sortie&lt;/param&gt;
 /// &lt;returns&gt;&lt;/returns&gt;
 public static bool TryParse(ref object pValue, System.Type pType)
 {
 int lIParsed;
 double lDParsed;
 string lsValue;
 if (pValue == null) return false;
 if (pType.Equals(typeof(bool))) {
 bool lBParsed;
 if (pValue is bool) return true;
 if (double.TryParse(pValue.ToString(), out lDParsed)) {
 pValue = lDParsed != 0D;
 return true;
 }
 if (bool.TryParse(pValue.ToString(), out lBParsed)) {
 pValue = lBParsed;
 return true;
 }
 else
 return false;
 }
 if (pType.Equals(typeof(Double))) {
 if (pValue is Double) return true;
 if (double.TryParse(pValue.ToString(), out lDParsed)
 || double.TryParse(pValue.ToString().Replace(NumberDecimalSeparatorNOT, NumberDecimalSeparator), out lDParsed)) {
 pValue = lDParsed;
 return true;
 }
 else
 return false;
 }
 if (pType.Equals(typeof(int))) {
 if (pValue is int) return true;
 if (Int32.TryParse(pValue.ToString(), out lIParsed)) {
 pValue = lIParsed;
 return true;
 }
 else if (double.TryParse(pValue.ToString(), out lDParsed)) {
 pValue = (int)lDParsed;
 return true;
 }
 else
 return false;
 }
 if (pType.Equals(typeof(Byte))) {
 if (pValue is byte) return true;
 byte lByte;
 if (Byte.TryParse(pValue.ToString(), out lByte)) {
 pValue = lByte;
 return true;
 }
 else if (double.TryParse(pValue.ToString(), out lDParsed)) {
 pValue = (byte)lDParsed;
 return true;
 }
 else
 return false;
 }
 if (pType.Equals(typeof(long))) {
 long lLParsed;
 if (pValue is long) return true;
 if (long.TryParse(pValue.ToString(), out lLParsed)) {
 pValue = lLParsed;
 return true;
 }
 else if (double.TryParse(pValue.ToString(), out lDParsed)) {
 pValue = (long)lDParsed;
 return true;
 }
 else
 return false;
 }
 if (pType.Equals(typeof(Single))) {
 if (pValue is float) return true;
 Single lSParsed;
 if (Single.TryParse(pValue.ToString(), out lSParsed)
 || Single.TryParse(pValue.ToString().Replace(NumberDecimalSeparatorNOT, NumberDecimalSeparator), out lSParsed)) {
 pValue = lSParsed;
 return true;
 }
 else
 return false;
 }
 if (pType.Equals(typeof(DateTime))) {
 if (pValue is DateTime) return true;
 DateTime lDTParsed;
 if (DateTime.TryParse(pValue.ToString(), out lDTParsed)) {
 pValue = lDTParsed;
 return true;
 }
 else if (pValue.ToString().Contains("UTC")) //Date venant de JScript
 {
 if (_MonthsUTC == null) InitMonthsUTC();
 string[] lDateParts = pValue.ToString().Split(' ');
 lDTParsed = new DateTime(int.Parse(lDateParts[5]), _MonthsUTC[lDateParts[1]], int.Parse(lDateParts[2]));
 lDateParts = lDateParts[3].ToString().Split(':');
 pValue = lDTParsed.AddSeconds(int.Parse(lDateParts[0]) * 3600 + int.Parse(lDateParts[1]) * 60 + int.Parse(lDateParts[2]));
 return true;
 }
 else
 return false;

 }
 if (pType.Equals(typeof(Array))) {
 if (pValue is System.Collections.ICollection || pValue is System.Collections.ArrayList)
 return true;
 return pValue is System.Data.DataTable
 || pValue is string &amp;&amp; (pValue as string).StartsWith("&lt;");
 }
 if (pType.Equals(typeof(DataTable))) {
 return pValue is System.Data.DataTable
 || pValue is string &amp;&amp; (pValue as string).StartsWith("&lt;");

 }
 if (pType.Equals(typeof(System.Drawing.Bitmap))) {
 return pValue is System.Drawing.Image || pValue is byte[];

 }
 if (pType.Equals(typeof(System.Drawing.Image))) {
 return pValue is System.Drawing.Image || pValue is byte[];

 }
 if (pType.Equals(typeof(System.Drawing.Color))) {
 if (pValue is System.Drawing.Color) return true;
 if (pValue is System.Drawing.KnownColor) {
 pValue = System.Drawing.Color.FromKnownColor((System.Drawing.KnownColor)pValue);
 return true;
 }

 int lARGB;
 if (!int.TryParse(lsValue = pValue.ToString(), out lARGB)) {
 if (lsValue.StartsWith("Color [A=", StringComparison.InvariantCulture)) {
 foreach (string lsARGB in lsValue.Substring("Color [".Length, lsValue.Length - "Color []".Length).Split(','))
 switch (lsARGB.TrimStart().Substring(0, 1)) {
 case "A":
 lARGB = int.Parse(lsARGB.Substring(2)) * 0x1000000;
 break;
 case "R":
 lARGB += int.Parse(lsARGB.TrimStart().Substring(2)) * 0x10000;
 break;
 case "G":
 lARGB += int.Parse(lsARGB.TrimStart().Substring(2)) * 0x100;
 break;
 case "B":
 lARGB += int.Parse(lsARGB.TrimStart().Substring(2));
 break;
 default:
 break;
 }
 pValue = System.Drawing.Color.FromArgb(lARGB);
 return true;
 }
 if (lsValue.StartsWith("Color [", StringComparison.InvariantCulture)) {
 pValue = System.Drawing.Color.FromName(lsValue.Substring("Color [".Length, lsValue.Length - "Color []".Length));
 return true;
 }
 return false;
 }
 pValue = System.Drawing.Color.FromArgb(lARGB);
 return true;
 }
 if (pType.IsEnum) {
 try {
 if (pValue == null) return false;
 if (pValue is int || pValue is byte || pValue is ulong || pValue is long || pValue is double)
 pValue = Enum.ToObject(pType, pValue);
 else
 pValue = Enum.Parse(pType, pValue.ToString());
 }
 catch {
 return false;
 }
 }
 return true;
 }
}
</code></pre>

blocks|key|1219880|text|您可以使用像这样的手动排序算法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1219881|public+void+ListItemSorter(object+sender,+ColumnClickEventArgs+e)
++++{
++++++++ListView+list+=+(ListView)sender;
++++++++int+total+=+list.Items.Count;
++++++++list.BeginUpdate();
++++++++ListViewItem[]+items+=+new+ListViewItem[total];
++++++++for+(int+i+=+0;+i+<+total;+i%2B%2B)
++++++++{
++++++++++++int+count+=+list.Items.Count;
++++++++++++int+minIdx+=+0;
++++++++++++for+(int+j+=+1;+j+<+count;+j%2B%2B)
++++++++++++++++if+(list.Items[j].SubItems[e.Column].Text.CompareTo(list.Items[minIdx].SubItems[e.Column].Text)+<+0)
++++++++++++++++++++minIdx+=+j;
++++++++++++items[i]+=+list.Items[minIdx];
++++++++++++list.Items.RemoveAt(minIdx);
++++++++}
++++++++list.Items.AddRange(items);
++++++++list.EndUpdate();
++++}|code-block|syntax|javascript|1219882|此方法使用按O%5E2顺序和升序的选择排序。您可以将降序的“>”改为“<”，也可以为此方法添加参数。它对任何被点击的列进行排序，对于少量的数据非常有效。|1219883|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

You can use a manual sorting algorithm like this

<pre><code>public void ListItemSorter(object sender, ColumnClickEventArgs e)
 {
 ListView list = (ListView)sender;
 int total = list.Items.Count;
 list.BeginUpdate();
 ListViewItem[] items = new ListViewItem[total];
 for (int i = 0; i &lt; total; i++)
 {
 int count = list.Items.Count;
 int minIdx = 0;
 for (int j = 1; j &lt; count; j++)
 if (list.Items[j].SubItems[e.Column].Text.CompareTo(list.Items[minIdx].SubItems[e.Column].Text) &lt; 0)
 minIdx = j;
 items[i] = list.Items[minIdx];
 list.Items.RemoveAt(minIdx);
 }
 list.Items.AddRange(items);
 list.EndUpdate();
 }
</code></pre>

this method uses selection sort in O^2 order and as Ascending. You can change the '>' with '&lt;' for a descending or add an argument for this method.
It sorts any column that is clicked and works perfect for small amount of data.

blocks|key|1219955|text|由于这仍然是一个查看次数最多的线程，我想我可能会注意到，我想出了一个动态解决方案来按列对listview进行排序。下面是代码，以防其他人也想使用它。它几乎只涉及将列表视图项发送到数据表，按列名对数据表的默认视图进行排序(使用单击的列的索引)，然后用defaultview.totable()方法覆盖该表。然后，几乎只需将它们添加回列表视图。哇啦，这是一个按列排序的列表视图。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1219956|public+void+SortListView(int+Index)
++++{
++++++++DataTable+TempTable+=+new+DataTable();
++++++++//Add+column+names+to+datatable+from+listview
++++++++foreach+(ColumnHeader+iCol+in+MyListView.Columns)
++++++++{
++++++++++++TempTable.Columns.Add(iCol.Text);
++++++++}
++++++++//Create+a+datarow+from+each+listviewitem+and+add+it+to+the+table
++++++++foreach+(ListViewItem+Item+in+MyListView.Items)
++++++++{
+++++++++++++DataRow+iRow+=+TempTable.NewRow();
+++++++++++++//+the+for+loop+dynamically+copies+the+data+one+by+one+instead+of+doing+irow[i]+=+MyListView.Subitems[1]...+so+on
++++++++++++for+(int+i+=+0;+i+<+MyListView.Columns.Count;+i%2B%2B)
++++++++++++{
++++++++++++++++if+(i+==+0)
++++++++++++++++{
++++++++++++++++++++iRow[i]+=+Item.Text;
++++++++++++++++}
++++++++++++++++else
++++++++++++++++{
++++++++++++++++++++iRow[i]+=+Item.SubItems[i].Text;
++++++++++++++++}
++++++++++++}
++++++++++++TempTable.Rows.Add(iRow);
++++++++}
++++++++string+SortType+=+string.Empty;
++++++++//LastCol+is+a+public+int+variable+on+the+form,+and+LastSort+is+public+string+variable
++++++++if+(LastCol+==+Index)
++++++++{
++++++++++++if+(LastSort+==+"ASC"+%7C%7C+LastSort+==+string.Empty+%7C%7C+LastSort+==+null)
++++++++++++{
++++++++++++++++SortType+=+"DESC";
++++++++++++++++LastSort+=+"DESC";
++++++++++++}
++++++++++++else
++++++++++++{
++++++++++++++++SortType+=+"ASC";
++++++++++++++++LastSort+=+"ASC";
++++++++++++}
++++++++}
++++++++else
++++++++{
++++++++++++SortType+=+"DESC";
++++++++++++LastSort+=+"DESC";
++++++++}
++++++++LastCol+=+Index;
++++++++MyListView.Items.Clear();
++++++++//Sort+it+based+on+the+column+text+clicked+and+the+sort+type+(asc+or+desc)
++++++++TempTable.DefaultView.Sort+=+MyListView.Columns[Index].Text+%2B+"+"+%2B+SortType;
++++++++TempTable+=+TempTable.DefaultView.ToTable();
++++++++//Create+a+listview+item+from+the+data+in+each+row
++++++++foreach+(DataRow+iRow+in+TempTable.Rows)
++++++++{
++++++++++++ListViewItem+Item+=+new+ListViewItem();
++++++++++++List<string>+SubItems+=+new+List<string>();
++++++++++++for+(int+i+=+0;+i+<+TempTable.Columns.Count;+i%2B%2B)
++++++++++++{
++++++++++++++++if+(i+==+0)
++++++++++++++++{
++++++++++++++++++++Item.Text+=+iRow[i].ToString();
++++++++++++++++}
++++++++++++++++else
++++++++++++++++{
++++++++++++++++++++SubItems.Add(iRow[i].ToString());
++++++++++++++++}
++++++++++++}
++++++++++++Item.SubItems.AddRange(SubItems.ToArray());
++++++++++++MyListView.Items.Add(Item);
++++++++}
++++}|code-block|syntax|javascript|1219957|这个方法是动态的，因为它使用现有的列名，不需要知道每列的索引或名称，甚至不需要知道listview/datatable中有多少列。您可以通过为listview.columnclick创建事件，然后执行SortListView(e.column)来调用它。|1219958|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Since this is still a top viewed thread, I thought I might note that I came up with a dynamic solution to sort the listview by column. Here's the code just in case someone else wants to use it as well. It pretty much just involves sending the listview items to a datatable, sorting the default view of the datatable by the column name (using the index of the clicked column), and then overwriting that table with the defaultview.totable() method. Then pretty much just add them back to the listview. And wa la, its a sorted listview by column.

<pre><code>public void SortListView(int Index)
 {
 DataTable TempTable = new DataTable();
 //Add column names to datatable from listview
 foreach (ColumnHeader iCol in MyListView.Columns)
 {
 TempTable.Columns.Add(iCol.Text);
 }
 //Create a datarow from each listviewitem and add it to the table
 foreach (ListViewItem Item in MyListView.Items)
 {
 DataRow iRow = TempTable.NewRow();
 // the for loop dynamically copies the data one by one instead of doing irow[i] = MyListView.Subitems[1]... so on
 for (int i = 0; i &lt; MyListView.Columns.Count; i++)
 {
 if (i == 0)
 {
 iRow[i] = Item.Text;
 }
 else
 {
 iRow[i] = Item.SubItems[i].Text;
 }
 }
 TempTable.Rows.Add(iRow);
 }
 string SortType = string.Empty;
 //LastCol is a public int variable on the form, and LastSort is public string variable
 if (LastCol == Index)
 {
 if (LastSort == "ASC" || LastSort == string.Empty || LastSort == null)
 {
 SortType = "DESC";
 LastSort = "DESC";
 }
 else
 {
 SortType = "ASC";
 LastSort = "ASC";
 }
 }
 else
 {
 SortType = "DESC";
 LastSort = "DESC";
 }
 LastCol = Index;
 MyListView.Items.Clear();
 //Sort it based on the column text clicked and the sort type (asc or desc)
 TempTable.DefaultView.Sort = MyListView.Columns[Index].Text + " " + SortType;
 TempTable = TempTable.DefaultView.ToTable();
 //Create a listview item from the data in each row
 foreach (DataRow iRow in TempTable.Rows)
 {
 ListViewItem Item = new ListViewItem();
 List&lt;string&gt; SubItems = new List&lt;string&gt;();
 for (int i = 0; i &lt; TempTable.Columns.Count; i++)
 {
 if (i == 0)
 {
 Item.Text = iRow[i].ToString();
 }
 else
 {
 SubItems.Add(iRow[i].ToString());
 }
 }
 Item.SubItems.AddRange(SubItems.ToArray());
 MyListView.Items.Add(Item);
 }
 }
</code></pre>

This method is dynamic as it uses the existing column name and doesn't require you to know the index or name of each column or even how many columns are in the listview/datatable. You can call it by doing creating an event for the listview.columnclick and then SortListView(e.column).

blocks|key|1435011|text|对项目here进行了较小的更改，以适应ListView中字符串和数值的排序。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1435012|Form1.cs包含|1435013|using+System;
using+System.Windows.Forms;

namespace+ListView
{
++++public+partial+class+Form1+:+Form
++++{
++++++++Random+rnd+=+new+Random();
++++++++private+ListViewColumnSorter+lvwColumnSorter;

++++++++public+Form1()
++++++++{
++++++++++++InitializeComponent();
++++++++++++//+Create+an+instance+of+a+ListView+column+sorter+and+assign+it+to+the+ListView+control.
++++++++++++lvwColumnSorter+=+new+ListViewColumnSorter();
++++++++++++this.listView1.ListViewItemSorter+=+lvwColumnSorter;

++++++++++++InitListView();
++++++++}

++++++++private+void+InitListView()
++++++++{
++++++++++++listView1.View+=+View.Details;
++++++++++++listView1.GridLines+=+true;
++++++++++++listView1.FullRowSelect+=+true;

++++++++++++//Add+column+header
++++++++++++listView1.Columns.Add("Name",+100);
++++++++++++listView1.Columns.Add("Price",+70);
++++++++++++listView1.Columns.Add("Trend",+70);

++++++++++++for+(int+i+=+0;+i+<+10;+i%2B%2B)
++++++++++++{
++++++++++++++++listView1.Items.Add(AddToList("Name"+%2B+i.ToString(),+rnd.Next(1,+100).ToString(),+rnd.Next(1,+100).ToString()));
++++++++++++}
++++++++}

++++++++private+ListViewItem+AddToList(string+name,+string+price,+string+trend)
++++++++{
++++++++++++string[]+array+=+new+string[3];
++++++++++++array[0]+=+name;
++++++++++++array[1]+=+price;
++++++++++++array[2]+=+trend;

++++++++++++return+(new+ListViewItem(array));
++++++++}

++++++++private+void+listView1_ColumnClick(object+sender,+ColumnClickEventArgs+e)
++++++++{
++++++++++++//+Determine+if+clicked+column+is+already+the+column+that+is+being+sorted.
++++++++++++if+(e.Column+==+lvwColumnSorter.SortColumn)
++++++++++++{
++++++++++++++++//+Reverse+the+current+sort+direction+for+this+column.
++++++++++++++++if+(lvwColumnSorter.Order+==+SortOrder.Ascending)
++++++++++++++++{
++++++++++++++++++++lvwColumnSorter.Order+=+SortOrder.Descending;
++++++++++++++++}
++++++++++++++++else
++++++++++++++++{
++++++++++++++++++++lvwColumnSorter.Order+=+SortOrder.Ascending;
++++++++++++++++}
++++++++++++}
++++++++++++else
++++++++++++{
++++++++++++++++//+Set+the+column+number+that+is+to+be+sorted;+default+to+ascending.
++++++++++++++++lvwColumnSorter.SortColumn+=+e.Column;
++++++++++++++++lvwColumnSorter.Order+=+SortOrder.Ascending;
++++++++++++}

++++++++++++//+Perform+the+sort+with+these+new+sort+options.
++++++++++++this.listView1.Sort();
++++++++}

++++}
}|code-block|syntax|javascript|1435014|ListViewColumnSorter.cs包含|1435015|using+System;
using+System.Collections;
using+System.Windows.Forms;

///+<summary>
///+This+class+is+an+implementation+of+the+'IComparer'+interface.
///+</summary>
public+class+ListViewColumnSorter+:+IComparer
{
++++///+<summary>
++++///+Specifies+the+column+to+be+sorted
++++///+</summary>
++++private+int+ColumnToSort;
++++///+<summary>
++++///+Specifies+the+order+in+which+to+sort+(i.e.+'Ascending').
++++///+</summary>
++++private+SortOrder+OrderOfSort;
++++///+<summary>
++++///+Case+insensitive+comparer+object
++++///+</summary>
++++private+CaseInsensitiveComparer+ObjectCompare;

++++///+<summary>
++++///+Class+constructor.++Initializes+various+elements
++++///+</summary>
++++public+ListViewColumnSorter()
++++{
++++++++//+Initialize+the+column+to+'0'
++++++++ColumnToSort+=+0;

++++++++//+Initialize+the+sort+order+to+'none'
++++++++OrderOfSort+=+SortOrder.None;

++++++++//+Initialize+the+CaseInsensitiveComparer+object
++++++++ObjectCompare+=+new+CaseInsensitiveComparer();
++++}

++++///+<summary>
++++///+This+method+is+inherited+from+the+IComparer+interface.++It+compares+the+two+objects+passed+using+a+case+insensitive+comparison.
++++///+</summary>
++++///+<param+name="x">First+object+to+be+compared</param>
++++///+<param+name="y">Second+object+to+be+compared</param>
++++///+<returns>The+result+of+the+comparison.+"0"+if+equal,+negative+if+'x'+is+less+than+'y'+and+positive+if+'x'+is+greater+than+'y'</returns>
++++public+int+Compare(object+x,+object+y)
++++{
++++++++int+compareResult;
++++++++ListViewItem+listviewX,+listviewY;

++++++++//+Cast+the+objects+to+be+compared+to+ListViewItem+objects
++++++++listviewX+=+(ListViewItem)x;
++++++++listviewY+=+(ListViewItem)y;

++++++++decimal+num+=+0;
++++++++if+(decimal.TryParse(listviewX.SubItems[ColumnToSort].Text,+out+num))
++++++++{
++++++++++++compareResult+=+decimal.Compare(num,+Convert.ToDecimal(listviewY.SubItems[ColumnToSort].Text));
++++++++}
++++++++else+
++++++++{
++++++++++++//+Compare+the+two+items
++++++++++++compareResult+=+ObjectCompare.Compare(listviewX.SubItems[ColumnToSort].Text,+listviewY.SubItems[ColumnToSort].Text);
++++++++}

++++++++//+Calculate+correct+return+value+based+on+object+comparison
++++++++if+(OrderOfSort+==+SortOrder.Ascending)
++++++++{
++++++++++++//+Ascending+sort+is+selected,+return+normal+result+of+compare+operation
++++++++++++return+compareResult;
++++++++}
++++++++else+if+(OrderOfSort+==+SortOrder.Descending)
++++++++{
++++++++++++//+Descending+sort+is+selected,+return+negative+result+of+compare+operation
++++++++++++return+(-compareResult);
++++++++}
++++++++else
++++++++{
++++++++++++//+Return+'0'+to+indicate+they+are+equal
++++++++++++return+0;
++++++++}
++++}

++++///+<summary>
++++///+Gets+or+sets+the+number+of+the+column+to+which+to+apply+the+sorting+operation+(Defaults+to+'0').
++++///+</summary>
++++public+int+SortColumn
++++{
++++++++set
++++++++{
++++++++++++ColumnToSort+=+value;
++++++++}
++++++++get
++++++++{
++++++++++++return+ColumnToSort;
++++++++}
++++}

++++///+<summary>
++++///+Gets+or+sets+the+order+of+sorting+to+apply+(for+example,+'Ascending'+or+'Descending').
++++///+</summary>
++++public+SortOrder+Order
++++{
++++++++set
++++++++{
++++++++++++OrderOfSort+=+value;
++++++++}
++++++++get
++++++++{
++++++++++++return+OrderOfSort;
++++++++}
++++}

}|1435016|entityMap|0|LINK|mutability|MUTABLE|url|http://support.microsoft.com/kb/319401^0|3|4|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|11|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|13|8|@]|9|@]|C|$I|J]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

Made minor changes to the article <a href="http://support.microsoft.com/kb/319401" rel="nofollow">here</a> to accommodate sorting of both string and numeric values in ListView.

Form1.cs contains

<pre><code>using System;
using System.Windows.Forms;

namespace ListView
{
 public partial class Form1 : Form
 {
 Random rnd = new Random();
 private ListViewColumnSorter lvwColumnSorter;

 public Form1()
 {
 InitializeComponent();
 // Create an instance of a ListView column sorter and assign it to the ListView control.
 lvwColumnSorter = new ListViewColumnSorter();
 this.listView1.ListViewItemSorter = lvwColumnSorter;

 InitListView();
 }

 private void InitListView()
 {
 listView1.View = View.Details;
 listView1.GridLines = true;
 listView1.FullRowSelect = true;

 //Add column header
 listView1.Columns.Add("Name", 100);
 listView1.Columns.Add("Price", 70);
 listView1.Columns.Add("Trend", 70);

 for (int i = 0; i &lt; 10; i++)
 {
 listView1.Items.Add(AddToList("Name" + i.ToString(), rnd.Next(1, 100).ToString(), rnd.Next(1, 100).ToString()));
 }
 }

 private ListViewItem AddToList(string name, string price, string trend)
 {
 string[] array = new string[3];
 array[0] = name;
 array[1] = price;
 array[2] = trend;

 return (new ListViewItem(array));
 }

 private void listView1_ColumnClick(object sender, ColumnClickEventArgs e)
 {
 // Determine if clicked column is already the column that is being sorted.
 if (e.Column == lvwColumnSorter.SortColumn)
 {
 // Reverse the current sort direction for this column.
 if (lvwColumnSorter.Order == SortOrder.Ascending)
 {
 lvwColumnSorter.Order = SortOrder.Descending;
 }
 else
 {
 lvwColumnSorter.Order = SortOrder.Ascending;
 }
 }
 else
 {
 // Set the column number that is to be sorted; default to ascending.
 lvwColumnSorter.SortColumn = e.Column;
 lvwColumnSorter.Order = SortOrder.Ascending;
 }

 // Perform the sort with these new sort options.
 this.listView1.Sort();
 }

 }
}
</code></pre>

ListViewColumnSorter.cs contains 

<pre><code>using System;
using System.Collections;
using System.Windows.Forms;

/// &lt;summary&gt;
/// This class is an implementation of the 'IComparer' interface.
/// &lt;/summary&gt;
public class ListViewColumnSorter : IComparer
{
 /// &lt;summary&gt;
 /// Specifies the column to be sorted
 /// &lt;/summary&gt;
 private int ColumnToSort;
 /// &lt;summary&gt;
 /// Specifies the order in which to sort (i.e. 'Ascending').
 /// &lt;/summary&gt;
 private SortOrder OrderOfSort;
 /// &lt;summary&gt;
 /// Case insensitive comparer object
 /// &lt;/summary&gt;
 private CaseInsensitiveComparer ObjectCompare;

 /// &lt;summary&gt;
 /// Class constructor. Initializes various elements
 /// &lt;/summary&gt;
 public ListViewColumnSorter()
 {
 // Initialize the column to '0'
 ColumnToSort = 0;

 // Initialize the sort order to 'none'
 OrderOfSort = SortOrder.None;

 // Initialize the CaseInsensitiveComparer object
 ObjectCompare = new CaseInsensitiveComparer();
 }

 /// &lt;summary&gt;
 /// This method is inherited from the IComparer interface. It compares the two objects passed using a case insensitive comparison.
 /// &lt;/summary&gt;
 /// &lt;param name="x"&gt;First object to be compared&lt;/param&gt;
 /// &lt;param name="y"&gt;Second object to be compared&lt;/param&gt;
 /// &lt;returns&gt;The result of the comparison. "0" if equal, negative if 'x' is less than 'y' and positive if 'x' is greater than 'y'&lt;/returns&gt;
 public int Compare(object x, object y)
 {
 int compareResult;
 ListViewItem listviewX, listviewY;

 // Cast the objects to be compared to ListViewItem objects
 listviewX = (ListViewItem)x;
 listviewY = (ListViewItem)y;

 decimal num = 0;
 if (decimal.TryParse(listviewX.SubItems[ColumnToSort].Text, out num))
 {
 compareResult = decimal.Compare(num, Convert.ToDecimal(listviewY.SubItems[ColumnToSort].Text));
 }
 else 
 {
 // Compare the two items
 compareResult = ObjectCompare.Compare(listviewX.SubItems[ColumnToSort].Text, listviewY.SubItems[ColumnToSort].Text);
 }

 // Calculate correct return value based on object comparison
 if (OrderOfSort == SortOrder.Ascending)
 {
 // Ascending sort is selected, return normal result of compare operation
 return compareResult;
 }
 else if (OrderOfSort == SortOrder.Descending)
 {
 // Descending sort is selected, return negative result of compare operation
 return (-compareResult);
 }
 else
 {
 // Return '0' to indicate they are equal
 return 0;
 }
 }

 /// &lt;summary&gt;
 /// Gets or sets the number of the column to which to apply the sorting operation (Defaults to '0').
 /// &lt;/summary&gt;
 public int SortColumn
 {
 set
 {
 ColumnToSort = value;
 }
 get
 {
 return ColumnToSort;
 }
 }

 /// &lt;summary&gt;
 /// Gets or sets the order of sorting to apply (for example, 'Ascending' or 'Descending').
 /// &lt;/summary&gt;
 public SortOrder Order
 {
 set
 {
 OrderOfSort = value;
 }
 get
 {
 return OrderOfSort;
 }
 }

}
</code></pre>

blocks|key|1220116|text|我可以看到这个问题最初是在5年前发布的，当时程序员必须更加努力地工作才能获得他们想要的结果。使用Visual+Studio+2012及更高版本，懒惰的程序员可以转到列表视图属性设置的设计视图，然后单击属性->排序，选择升序。还有许多其他属性特性可以获得懒惰(又称智能)程序员可以利用的各种结果。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1220117|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I can see that this question was originally posted 5 yrs ago when programmers had to work harder to get their desired results.
With Visual Studio 2012 and beyond, a lazy programmer can go the Design View for the Listview properties settings, and click on Properties->Sorting, choose Ascending.
There are plenty of other properties features to obtain the various results a lazy (aka smart) programmer can leverage.

blocks|key|1220174|text|我稍微修改了微软的例子：https://support.microsoft.com/en-us/kb/319401|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1220175|此方法将只排序一次，以升序排序。我的修改使它可以按两种方式排序。|1220176|public+class+ListViewItemComparer+:+IComparer
{
++++private+int+col;
++++bool+bAsc+=+false;
++++public+ListViewItemComparer()
++++{
++++++++col+=+0;
++++}
++++public+ListViewItemComparer(int+column,+bool+b)
++++{
++++++++col+=+column;
++++++++bAsc+=+b;
++++}
++++public+int+Compare(object+x,+object+y)
++++{
++++++++if+(bAsc)
++++++++{
++++++++++++return+String.Compare(((ListViewItem)x).SubItems[col].Text,+((ListViewItem)y).SubItems[col].Text);
++++++++++++bAsc+=+false;
++++++++}
++++++++else
++++++++{
++++++++++++return+String.Compare(((ListViewItem)y).SubItems[col].Text,+((ListViewItem)x).SubItems[col].Text);
++++++++++++bAsc+=+true;
++++++++}
++++}

}|code-block|syntax|javascript|1220177|然后，每当单击列标题时，我都会创建一个此类的对象|1220178|++++++++bool+sortAscending+=+false;
++++++++private+void+inventoryList_ColumnClick(object+sender,+ColumnClickEventArgs+e)
++++++++{

++++++++++++if+(!sortAscending)
++++++++++++{
++++++++++++++++sortAscending+=+true;
++++++++++++}
++++++++++++else
++++++++++++{
++++++++++++++++sortAscending+=+false;
++++++++++++}
++++++++++++this.inventoryList.ListViewItemSorter+=+new+ListViewItemComparer(e.Column,+sortAscending);

++++++++}|1220179|entityMap|0|LINK|mutability|MUTABLE|url|https://support.microsoft.com/en-us/kb/319401^0|C|19|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|E|5|6|7|10|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|11|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|13|8|@]|9|@]|C|$I|J]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

I slightly modified the example from Microsoft: <a href="https://support.microsoft.com/en-us/kb/319401" rel="nofollow noreferrer">https://support.microsoft.com/en-us/kb/319401</a>

This method will only sort once to sort ascending. My modifications make it sort both ways.

<pre><code>public class ListViewItemComparer : IComparer
{
 private int col;
 bool bAsc = false;
 public ListViewItemComparer()
 {
 col = 0;
 }
 public ListViewItemComparer(int column, bool b)
 {
 col = column;
 bAsc = b;
 }
 public int Compare(object x, object y)
 {
 if (bAsc)
 {
 return String.Compare(((ListViewItem)x).SubItems[col].Text, ((ListViewItem)y).SubItems[col].Text);
 bAsc = false;
 }
 else
 {
 return String.Compare(((ListViewItem)y).SubItems[col].Text, ((ListViewItem)x).SubItems[col].Text);
 bAsc = true;
 }
 }

}
</code></pre>

Then I create an object of this class whenever a column header is clicked

<pre><code> bool sortAscending = false;
 private void inventoryList_ColumnClick(object sender, ColumnClickEventArgs e)
 {

 if (!sortAscending)
 {
 sortAscending = true;
 }
 else
 {
 sortAscending = false;
 }
 this.inventoryList.ListViewItemSorter = new ListViewItemComparer(e.Column, sortAscending);

 }
</code></pre>

blocks|key|1435208|text|我用了这个技巧|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1435209|private+void+lv_TavComEmpty_ColumnClick(object+sender,+ColumnClickEventArgs+e)
++++++++{
++++++++++++ListView+lv+=+(ListView)sender;

++++++++++++//propriety+SortOrder+make+me+some+problem+on+graphic+layout
++++++++++++//i+use+this+tag+to+set+last+order
++++++++++++if+(lv.Tag+==+null+%7C%7C+(int)lv.Tag+>+0)
++++++++++++//if+(lv.Sorting+==+SortOrder.Ascending)
++++++++++++{
++++++++++++++++ListViewItem[]+tmp+=+lv.Items.Cast<ListViewItem>().OrderBy(t+=>+t.SubItems[e.Column].Text).ToArray();
++++++++++++++++lv.Items.Clear();
++++++++++++++++lv.Items.AddRange(tmp);

++++++++++++++++lv.Tag+=+-1;
++++++++++++++++//lv.Sorting+=+SortOrder.Descending;
++++++++++++}
++++++++++++else
++++++++++++{
++++++++++++++++ListViewItem[]+tmp+=+lv.Items.Cast<ListViewItem>().OrderByDescending(t+=>+t.SubItems[e.Column].Text).ToArray();
++++++++++++++++lv.Items.Clear();
++++++++++++++++lv.Items.AddRange(tmp);

++++++++++++++++lv.Tag+=+%2B1;
++++++++++++++++//lv.Sorting+=+SortOrder.Ascending;
++++++++++++}
++++++++}|code-block|syntax|javascript|1435210|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

i used this trick

<pre><code>private void lv_TavComEmpty_ColumnClick(object sender, ColumnClickEventArgs e)
 {
 ListView lv = (ListView)sender;

 //propriety SortOrder make me some problem on graphic layout
 //i use this tag to set last order
 if (lv.Tag == null || (int)lv.Tag &gt; 0)
 //if (lv.Sorting == SortOrder.Ascending)
 {
 ListViewItem[] tmp = lv.Items.Cast&lt;ListViewItem&gt;().OrderBy(t =&gt; t.SubItems[e.Column].Text).ToArray();
 lv.Items.Clear();
 lv.Items.AddRange(tmp);

 lv.Tag = -1;
 //lv.Sorting = SortOrder.Descending;
 }
 else
 {
 ListViewItem[] tmp = lv.Items.Cast&lt;ListViewItem&gt;().OrderByDescending(t =&gt; t.SubItems[e.Column].Text).ToArray();
 lv.Items.Clear();
 lv.Items.AddRange(tmp);

 lv.Tag = +1;
 //lv.Sorting = SortOrder.Ascending;
 }
 }
</code></pre>

blocks|key|1435310|text|我使用的基类与其他类使用的基类相同，只是我将其更改为允许字符串、日期和数字排序。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1435311|您可以使用支持字段来初始化它，如下所示：|1435312|private+readonly+ListViewColumnSorterExt+fileSorter;
...
public+Form1()
{
++++InitializeComponent();
++++fileSorter+=+new+ListViewColumnSorterExt(myListView);
}|code-block|syntax|javascript|1435313|代码如下：|1435314|public+class+ListViewColumnSorterExt+:+IComparer
{
++++///+<summary>
++++///+Specifies+the+column+to+be+sorted
++++///+</summary>
++++private+int+ColumnToSort;
++++///+<summary>
++++///+Specifies+the+order+in+which+to+sort+(i.e.+'Ascending').
++++///+</summary>
++++private+SortOrder+OrderOfSort;
++++///+<summary>
++++///+Case+insensitive+comparer+object
++++///+</summary>
++++private+CaseInsensitiveComparer+ObjectCompare;

++++private+ListView+listView;
++++///+<summary>
++++///+Class+constructor.++Initializes+various+elements
++++///+</summary>
++++public+ListViewColumnSorterExt(ListView+lv)
++++{
++++++++listView+=+lv;
++++++++listView.ListViewItemSorter+=+this;
++++++++listView.ColumnClick+%2B=+new+ColumnClickEventHandler(listView_ColumnClick);

++++++++//+Initialize+the+column+to+'0'
++++++++ColumnToSort+=+0;

++++++++//+Initialize+the+sort+order+to+'none'
++++++++OrderOfSort+=+SortOrder.None;

++++++++//+Initialize+the+CaseInsensitiveComparer+object
++++++++ObjectCompare+=+new+CaseInsensitiveComparer();
++++}

++++private+void+listView_ColumnClick(object+sender,+ColumnClickEventArgs+e)
++++{
++++++++ReverseSortOrderAndSort(e.Column,+(ListView)sender);
++++}

++++///+<summary>
++++///+This+method+is+inherited+from+the+IComparer+interface.++It+compares+the+two+objects+passed+using+a+case+insensitive+comparison.
++++///+</summary>
++++///+<param+name="x">First+object+to+be+compared</param>
++++///+<param+name="y">Second+object+to+be+compared</param>
++++///+<returns>The+result+of+the+comparison.+"0"+if+equal,+negative+if+'x'+is+less+than+'y'+and+positive+if+'x'+is+greater+than+'y'</returns>
++++public+int+Compare(object+x,+object+y)
++++{
++++++++int+compareResult;
++++++++ListViewItem+listviewX,+listviewY;

++++++++//+Cast+the+objects+to+be+compared+to+ListViewItem+objects
++++++++listviewX+=+(ListViewItem)x;
++++++++listviewY+=+(ListViewItem)y;

++++++++if+(decimal.TryParse(listviewX.SubItems[ColumnToSort].Text,+out+decimal+dx)+&&+decimal.TryParse(listviewY.SubItems[ColumnToSort].Text,+out+decimal+dy))
++++++++{
++++++++++++//compare+the+2+items+as+doubles
++++++++++++compareResult+=+decimal.Compare(dx,+dy);
++++++++}
++++++++else+if+(DateTime.TryParse(listviewX.SubItems[ColumnToSort].Text,+out+DateTime+dtx)+&&+DateTime.TryParse(listviewY.SubItems[ColumnToSort].Text,+out+DateTime+dty))
++++++++{
++++++++++++//compare+the+2+items+as+doubles
++++++++++++compareResult+=+DateTime.Compare(dtx,+dty);
++++++++}
++++++++else
++++++++{
++++++++++++//+Compare+the+two+items
++++++++++++compareResult+=+ObjectCompare.Compare(listviewX.SubItems[ColumnToSort].Text,+listviewY.SubItems[ColumnToSort].Text);
++++++++}
++++++++//+Calculate+correct+return+value+based+on+object+comparison
++++++++if+(OrderOfSort+==+SortOrder.Ascending)
++++++++{
++++++++++++//+Ascending+sort+is+selected,+return+normal+result+of+compare+operation
++++++++++++return+compareResult;
++++++++}
++++++++else+if+(OrderOfSort+==+SortOrder.Descending)
++++++++{
++++++++++++//+Descending+sort+is+selected,+return+negative+result+of+compare+operation
++++++++++++return+(-compareResult);
++++++++}
++++++++else
++++++++{
++++++++++++//+Return+'0'+to+indicate+they+are+equal
++++++++++++return+0;
++++++++}
++++}

++++///+<summary>
++++///+Gets+or+sets+the+number+of+the+column+to+which+to+apply+the+sorting+operation+(Defaults+to+'0').
++++///+</summary>
++++private+int+SortColumn
++++{
++++++++set
++++++++{
++++++++++++ColumnToSort+=+value;
++++++++}
++++++++get
++++++++{
++++++++++++return+ColumnToSort;
++++++++}
++++}

++++///+<summary>
++++///+Gets+or+sets+the+order+of+sorting+to+apply+(for+example,+'Ascending'+or+'Descending').
++++///+</summary>
++++private+SortOrder+Order
++++{
++++++++set
++++++++{
++++++++++++OrderOfSort+=+value;
++++++++}
++++++++get
++++++++{
++++++++++++return+OrderOfSort;
++++++++}
++++}

++++private+void+ReverseSortOrderAndSort(int+column,+ListView+lv)
++++{
++++++++//+Determine+if+clicked+column+is+already+the+column+that+is+being+sorted.
++++++++if+(column+==+this.SortColumn)
++++++++{
++++++++++++//+Reverse+the+current+sort+direction+for+this+column.
++++++++++++if+(this.Order+==+SortOrder.Ascending)
++++++++++++{
++++++++++++++++this.Order+=+SortOrder.Descending;
++++++++++++}
++++++++++++else
++++++++++++{
++++++++++++++++this.Order+=+SortOrder.Ascending;
++++++++++++}
++++++++}
++++++++else
++++++++{
++++++++++++//+Set+the+column+number+that+is+to+be+sorted;+default+to+ascending.
++++++++++++this.SortColumn+=+column;
++++++++++++this.Order+=+SortOrder.Ascending;
++++++++}

++++++++//+Perform+the+sort+with+these+new+sort+options.
++++++++lv.Sort();
++++}
}|1435315|如果你想指定与排序顺序相关的图标，那么在Listview中添加一个图像列表，并确保你更新了下面的示例，以反映你用于排序的图像的名称(你可以在导入它们时为它们指定任意的名称)。将上面的listView_ColumnClick更新为如下所示：|1435316|private+void+listView_ColumnClick(object+sender,+ColumnClickEventArgs+e)
{
++++if+(sender+is+ListView+lv)
++++{
++++++++ReverseSortOrderAndSort(e.Column,+lv);

++++++++if+(+++lv.Columns[e.Column].ImageList.Images.Keys.Contains("Ascending")+
++++++++++++&&+lv.Columns[e.Column].ImageList.Images.Keys.Contains("Descending"))
++++++++{
++++++++++++switch+(Order)
++++++++++++{
++++++++++++++++case+SortOrder.Ascending:
++++++++++++++++++++lv.Columns[e.Column].ImageKey+=+"Ascending";
++++++++++++++++++++break;
++++++++++++++++case+SortOrder.Descending:
++++++++++++++++++++lv.Columns[e.Column].ImageKey+=+"Descending";
++++++++++++++++++++break;
++++++++++++++++case+SortOrder.None:
++++++++++++++++++++lv.Columns[e.Column].ImageKey+=+string.Empty;
++++++++++++++++++++break;

++++++++++++}
++++++++}

++++}
}|1435317|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

I used the same base class as that what the others seem to use only I altered it as to allow for string, date and numerical sorting.

You can initialize it using a backing-field like so:

<pre><code>private readonly ListViewColumnSorterExt fileSorter;
...
public Form1()
{
 InitializeComponent();
 fileSorter = new ListViewColumnSorterExt(myListView);
}
</code></pre>

Here is the code:

<pre><code>public class ListViewColumnSorterExt : IComparer
{
 /// &lt;summary&gt;
 /// Specifies the column to be sorted
 /// &lt;/summary&gt;
 private int ColumnToSort;
 /// &lt;summary&gt;
 /// Specifies the order in which to sort (i.e. 'Ascending').
 /// &lt;/summary&gt;
 private SortOrder OrderOfSort;
 /// &lt;summary&gt;
 /// Case insensitive comparer object
 /// &lt;/summary&gt;
 private CaseInsensitiveComparer ObjectCompare;

 private ListView listView;
 /// &lt;summary&gt;
 /// Class constructor. Initializes various elements
 /// &lt;/summary&gt;
 public ListViewColumnSorterExt(ListView lv)
 {
 listView = lv;
 listView.ListViewItemSorter = this;
 listView.ColumnClick += new ColumnClickEventHandler(listView_ColumnClick);

 // Initialize the column to '0'
 ColumnToSort = 0;

 // Initialize the sort order to 'none'
 OrderOfSort = SortOrder.None;

 // Initialize the CaseInsensitiveComparer object
 ObjectCompare = new CaseInsensitiveComparer();
 }

 private void listView_ColumnClick(object sender, ColumnClickEventArgs e)
 {
 ReverseSortOrderAndSort(e.Column, (ListView)sender);
 }

 /// &lt;summary&gt;
 /// This method is inherited from the IComparer interface. It compares the two objects passed using a case insensitive comparison.
 /// &lt;/summary&gt;
 /// &lt;param name="x"&gt;First object to be compared&lt;/param&gt;
 /// &lt;param name="y"&gt;Second object to be compared&lt;/param&gt;
 /// &lt;returns&gt;The result of the comparison. "0" if equal, negative if 'x' is less than 'y' and positive if 'x' is greater than 'y'&lt;/returns&gt;
 public int Compare(object x, object y)
 {
 int compareResult;
 ListViewItem listviewX, listviewY;

 // Cast the objects to be compared to ListViewItem objects
 listviewX = (ListViewItem)x;
 listviewY = (ListViewItem)y;

 if (decimal.TryParse(listviewX.SubItems[ColumnToSort].Text, out decimal dx) &amp;&amp; decimal.TryParse(listviewY.SubItems[ColumnToSort].Text, out decimal dy))
 {
 //compare the 2 items as doubles
 compareResult = decimal.Compare(dx, dy);
 }
 else if (DateTime.TryParse(listviewX.SubItems[ColumnToSort].Text, out DateTime dtx) &amp;&amp; DateTime.TryParse(listviewY.SubItems[ColumnToSort].Text, out DateTime dty))
 {
 //compare the 2 items as doubles
 compareResult = DateTime.Compare(dtx, dty);
 }
 else
 {
 // Compare the two items
 compareResult = ObjectCompare.Compare(listviewX.SubItems[ColumnToSort].Text, listviewY.SubItems[ColumnToSort].Text);
 }
 // Calculate correct return value based on object comparison
 if (OrderOfSort == SortOrder.Ascending)
 {
 // Ascending sort is selected, return normal result of compare operation
 return compareResult;
 }
 else if (OrderOfSort == SortOrder.Descending)
 {
 // Descending sort is selected, return negative result of compare operation
 return (-compareResult);
 }
 else
 {
 // Return '0' to indicate they are equal
 return 0;
 }
 }

 /// &lt;summary&gt;
 /// Gets or sets the number of the column to which to apply the sorting operation (Defaults to '0').
 /// &lt;/summary&gt;
 private int SortColumn
 {
 set
 {
 ColumnToSort = value;
 }
 get
 {
 return ColumnToSort;
 }
 }

 /// &lt;summary&gt;
 /// Gets or sets the order of sorting to apply (for example, 'Ascending' or 'Descending').
 /// &lt;/summary&gt;
 private SortOrder Order
 {
 set
 {
 OrderOfSort = value;
 }
 get
 {
 return OrderOfSort;
 }
 }

 private void ReverseSortOrderAndSort(int column, ListView lv)
 {
 // Determine if clicked column is already the column that is being sorted.
 if (column == this.SortColumn)
 {
 // Reverse the current sort direction for this column.
 if (this.Order == SortOrder.Ascending)
 {
 this.Order = SortOrder.Descending;
 }
 else
 {
 this.Order = SortOrder.Ascending;
 }
 }
 else
 {
 // Set the column number that is to be sorted; default to ascending.
 this.SortColumn = column;
 this.Order = SortOrder.Ascending;
 }

 // Perform the sort with these new sort options.
 lv.Sort();
 }
}
</code></pre>

If you'd like to assign icons in regards to the sort order then add an image list to the Listview and make sure you update the below sample to reflect the names of your images that you use for sorting (you can assign them any name when you import them). Update the above listView_ColumnClick to something like this:

<pre><code>private void listView_ColumnClick(object sender, ColumnClickEventArgs e)
{
 if (sender is ListView lv)
 {
 ReverseSortOrderAndSort(e.Column, lv);

 if ( lv.Columns[e.Column].ImageList.Images.Keys.Contains("Ascending") 
 &amp;&amp; lv.Columns[e.Column].ImageList.Images.Keys.Contains("Descending"))
 {
 switch (Order)
 {
 case SortOrder.Ascending:
 lv.Columns[e.Column].ImageKey = "Ascending";
 break;
 case SortOrder.Descending:
 lv.Columns[e.Column].ImageKey = "Descending";
 break;
 case SortOrder.None:
 lv.Columns[e.Column].ImageKey = string.Empty;
 break;

 }
 }

 }
}
</code></pre>

Currently I use a custom sorter on the listview, and i can sort the listview each time i click on the FIRST column, but it won't sort by other columns.

SortStyle: Variable to determine whether it is Ascending Sort, or Descending.

<pre><code>if (e.Column == 0)
{
 if (SortStyle == 0)
 {
 List.ListViewItemSorter = customSortDsc;
 SortStyle = 1;
 }
 else
 {
 List.ListViewItemSorter = customSortAsc;
 SortStyle = 0;
 }
}
</code></pre>

This works fine when sorting for the first column, but if you were to do it on any other column, it would just sort by the first column. Is there a way to sort by the column clicked?

Sorting A ListView By Column

Visual Studio

Windows

目前我在listview上使用了一个自定义的排序器，我可以在每次单击第一列时对listview进行排序，但它不会按其他列排序。SortStyle:用于确定是升序还是降序的变量。if (e.Column == 0){    if (SortStyle == 0)    {        List.ListViewItem...

问按列对ListView进行排序
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问按列对ListView进行排序EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问按列对ListView进行排序
EN