ansaurus

Question

Answer 1

+2 A:

The first algorithm is the same as alphabetic ordering, so you can use directly:

int res = string.Compare(first,second);

The second algorithm is descending alphabetic ordering of the last two chars:

int res = -string.Compare(first.Substring(first.Length - 2, 2), second.Substring(first.Length - 2, 2));

To sort the list you have two options; the first is to create your own ListBox subclass and override the Sort method as detailed on the MSDN page for ListBox.Sort Method.

The second (easier and uglier) is to put all the items in a collection, order the collection and replace the items in the list, something like this:

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

namespace WindowsFormsApplication1 {
    public partial class Form1 : Form {

        void SortListBox() {
            List<string> items = new List<string>();
            foreach (string value in listBox1.Items) {
                items.Add(value);
            }
            items.Sort((first, second) => string.Compare(first, second));
            listBox1.Items.Clear();
            listBox1.Items.AddRange(items.ToArray());
        }

    }
}

Hope this helps...

Paolo Tedesco 2010-06-10 08:13:46

what did you use for res, first and second?

Arcadian 2010-06-10 08:16:10

well, first and second are two stings like "G35:45:20:41 JG01" and "G35:45:58:11 JG07"... what do you mean with 'what did you use for res'?

Paolo Tedesco 2010-06-10 08:24:04

I assumed you needed help with the algorithm only, and not with the actual lists ordering... is this the case?

Paolo Tedesco 2010-06-10 08:24:53

i'm new to C#, i should have put that in the question. i assumed that the list ordering would be part of the algorithm...

Arcadian 2010-06-10 08:27:36

-1 this doesn't help at all. How does this deal with breaking down the item string into it's specific parts and sorting based on the suffix, then the next int, then the next int, etc, as the OP asked?

GenericTypeTea 2010-06-10 08:42:08

@GenericTypeTea: isn't that the same as sorting alphabetically?

Paolo Tedesco 2010-06-10 08:43:19

@Paolo - Ah, bugger.

GenericTypeTea 2010-06-10 08:45:31

@GenericTypeTea: :)

Paolo Tedesco 2010-06-10 08:47:40

@Paolo - Trust me to over-engineer it. Massively simplified my answer now.

GenericTypeTea 2010-06-10 08:49:18

Answer 2

A:

To change the sorting behaviour of a ListBox, you must implement your own ListBox class. I've written the solution for you and tested it.

Right click on your project, select "Add Class..." and enter the class name "CustomListBox". Add the following code into the class between the namespaces:

using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;  // You need this namespace for ListBox

public class CustomListBox : ListBox
{
    public CustomListBox()
        : base()
    {
    }

    protected override void Sort()
    {
        if (this.Items.Count > 1)
        {
            bool swapped;
            do
            {

                int counter = this.Items.Count - 1;
                swapped = false;

                while (counter > 0)
                {
                    if (this.Items[counter].ToString().CompareTo(
                        this.Items[counter - 1].ToString()) == -1)
                    {
                        object temp = Items[counter];
                        this.Items[counter] = this.Items[counter - 1];
                        this.Items[counter - 1] = temp;
                        swapped = true;
                    }

                    counter -= 1;

                }

            }
            while (swapped);
        }
    }
}

All you need to do with your sorting is to sort alphabetically. As per my example above, you can just use the CompareTo method to determine which string comes before or after another string.

Now you've got your own custom ListBox, you can add additional properties and fields to it:

public class CustomListBox : ListBox
{
    public bool SortByJG;

    // Other code...
}

Then you can change the sort method to change the search based on the current sort mode as follows:

while (counter > 0)
{
    bool swap;
    if (this.SortByJG)
    {
        string[] breakDownCurrent = this.Items[counter].ToString().Split(' ');
        string[] breakDownPrevious = this.Items[counter - 1].ToString().Split(' ');
        if (breakDownCurrent[1].CompareTo(breakDownPrevious[1]) == -1)
        {
            swap = true;
        }
    }
    else
    {
        if (this.Items[counter].ToString().CompareTo(
            this.Items[counter - 1].ToString()) == -1)
        {
            swap = true;
        }
    }

    if (swap)
    {
        object temp = Items[counter];
        this.Items[counter] = this.Items[counter - 1];
        this.Items[counter - 1] = temp;
        swapped = true;
    }

    counter -= 1;

}

To make the sorting work, set Sorted = true; on the ListBox.

UPDATE: Because the OP is struggling to understand, here's the entire class:

using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;  // You need this namespace for ListBox

namespace WindowsApplication1
{

    public class CustomListBox : ListBox
    {

        public CustomListBox()
            : base()
        {
        }

        public bool SortByJG;

        protected override void Sort()
        {

            if (this.Items.Count > 1)
            {
                bool swapped;
                do
                {

                    int counter = this.Items.Count - 1;
                    swapped = false;

                    while (counter > 0)
                    {
                        bool swap = false;
                        if (this.SortByJG)
                        {
                            string[] breakDownCurrent = this.Items[counter].ToString().Split(' ');
                            string[] breakDownPrevious = this.Items[counter - 1].ToString().Split(' ');
                            if (breakDownCurrent[1].CompareTo(breakDownPrevious[1]) == -1)
                            {
                                swap = true;
                            }
                        }
                        else
                        {
                            if (this.Items[counter].ToString().CompareTo(
                                this.Items[counter - 1].ToString()) == -1)
                            {
                                swap = true;
                            }
                        }

                        if (swap)
                        {
                            object temp = Items[counter];
                            this.Items[counter] = this.Items[counter - 1];
                            this.Items[counter - 1] = temp;
                            swapped = true;
                        }

                        counter -= 1;

                    }


                }
                while (swapped);
            }
        }
    }
}

You could now also add your own method to sort with the specified mode:

public void Sort(bool sortByJG)
{
   this.SortByJG = sortByJG;
   if (this.Sorted)
   {
      this.Sort();
   }
   else
   {
      this.Sorted = true;
   }
}

GenericTypeTea 2010-06-10 10:31:51

right so its lstG30.Sorted = true; to get the regular sorting. and to sort by JG you have first call that method.

Arcadian 2010-06-10 10:46:22

No... if you implement the public void Sort(bool sortByJG) method I proposed then you can say list.Sort(true); for JG sorting and list.Sort(false) for standard sorting. That way you can use the same method for both types of sorting.

GenericTypeTea 2010-06-10 10:47:31

and your sure that its ok for the JG method to be called "public void Sort(bool sortByJG)" as well as the regular sorting being called "protected override void Sort()" wouldn't that be a naming conflict as they are both called "Sort"

Arcadian 2010-06-10 10:57:46

No. It's perfectly acceptable. It's a very basic aspect of the language. As long as the methods have different overloads you can have the same name.

GenericTypeTea 2010-06-10 11:16:03

i didn't know that. well i tried lstG30.Sort(true); and it says that "'System.Windows.Forms.ListBox.Sort()' is inaccessible due to its protection level"

Arcadian 2010-06-10 11:50:30

GenericTypeTea 2010-06-10 12:03:10

I can't find any. i'll post what i have above so you can see whats going on.

Arcadian 2010-06-10 12:16:31

Like I said. You need to look in your .DESIGNER.CS file. I.e. ViewForm.Designer.cs. NOT ViewForm.cs.

GenericTypeTea 2010-06-10 12:27:23

posted it. ListBox appears at the top and at the bottom. if i change ones at the top i get "does not exist in context" if i change the ones at the bottom as i have done in the post i get a build error "does not exist in namespace windows.forms"

Arcadian 2010-06-10 12:42:30

Do a find and replace on "System.Windows.Forms.ListBox" with "Jumpgate_Network_Program.CustomListBox" only on that particular file. This is assuming your CustomListBox class is in the "Jumpgate_Network_Program" namespace.

GenericTypeTea 2010-06-10 12:47:22

This is all really basic and fundamental stuff you're asking. I suggest having a read through all these tutorials: http://www.csharp-station.com/Tutorials.aspx. Lesson 6 is about name spaces which will explain my last comment.

GenericTypeTea 2010-06-10 12:53:56

will do. I guess it's easier if you have been doing it for 10 years. Ok thats good. It sorts them properly now. just need to reverse the order of the JG sorting. at the moment it places the lowest at the top and the highest at the bottom.

Arcadian 2010-06-10 13:01:58

GenericTypeTea 2010-06-10 13:29:36

Yh i will thanks. Only started learning about this a few days ago. and everything i know about it either comes from guides off the web, people like you from stack overflow and what i can learn from bookmarking the code and stepping through it slowly.

Arcadian 2010-06-10 13:30:30

Do you mean breakpointing? Heh. Well, best of luck to you! Hope you enjoy it as much as the rest of us.

GenericTypeTea 2010-06-10 13:38:20

ansaurus

tags:

views:

answers:

Custom listbox sorting

related questions