Question

i have a situation, i need to process an jagged array of 20k registers every time a user press a key. I have a grid and while the user is typing the system shows a filtered result in a grid. so. So i have a jagged array filled with all 20k registers. and the i have a list (global to the control) and it´s cleaned up every time the user press a key and filled up with just the filtered registers and then show then in the grid.

Here is the code

the model
public struct PlayerLookUpAdapter
    {
        [Browsable(false)]
        public decimal Id { get; set; }
        [DisplayName("Número")]
        public String Number { get; set; }
        [DisplayName("Nombre")]
        public String Name { get; set; }
        [DisplayName("Apellido")]
        public String Surname { get; set; }
        [DisplayName("DNI")]
        public String Document { get; set; }
        [DisplayName("Estado")]
        public String Status { get; set; }
    }

private PlayerLookUpAdapter[] _source; // here are the 20k registers

List<PlayerLookUpAdapter> filteredOut = new List<PlayerLookUpAdapter>(); // here the filtered ones

// this code is executed every time the user press a key
private void tb_nro_KeyUp(object sender, KeyEventArgs e)
        {
            if (!(e.KeyCode.Equals(Keys.Enter) || e.KeyCode.Equals(Keys.Down)) && _source!=null)
            {
                String text = tb_nro.Text.ToUpper();
                if (String.IsNullOrEmpty(text))
                {
                    fg.DataSource = _source;
                    fg.Refresh();
                    return;
                }
                fg.DataSource = null;
                filteredOut.Clear();
                int length = _source.Length;
                for (int i = 0; i < length; i++)
                {
                    PlayerLookUpAdapter cur = _source[i];
                    if (cur.Number.ToUpper().StartsWith(text) || cur.Surname.ToUpper().StartsWith(text) || cur.Name.ToUpper().StartsWith(text))
                        filteredOut.Add(cur);
                }
                fg.DataSource = filteredOut;
                SetGridColumnsProperties();
                fg.Refresh();

            }
            else
            {
                fg.Focus();
            }
        }

is it a good solution in terms of memory usage and performance? have you got any advice? How can i gain more speed. It works realy good, but what about if i got 100k registers instead of 20k?

Thanks in advance.

Answer 1

I think this should be a prime example for using a tree.

If you lay your Data down in a Tree (i actually don’t know if C#/.Net supports a Tree Data-Structure, or you have get your own hands dirty).

The Speed you search in a Tree will increase in comparison for searching in an Array (because a Tree gots a search-speed of somehting like O(n)=n*log(n))

The Theory is easy: if a User Types in a Literal, the Tree goes to the Node starting with this Literal, on this nodes are all possible other nodes and so on. For example: The User types in an “t” you go to the “t” Node, then he types in an “e” you go to the subnode “te”, there are some other subnodes like “test” and the system will propose the User these subnodes.