Question

I am looking for a collection class for the scenario below:

• Fast collection lookup, one item at a time.
• The collection contains around 300 K items.
• Collection population speed might not be important, but ideally fast too.
• No update/delete/insert is needed once collection is loaded

Example of items of type Ip2Location that would be populated into the collection:

public class Ip2Location
{
   public long IpFrom {get; set;}
   public long IpTo {get; set;}
   public string Country {get; set;}  
}

IpFrom      IpTo        Country
16909056    16909311    AU
16909312    16941055    US

Item lookup against the collection is done via a specified IP, like this:

IpFrom < currentIp < IpTo

Any ideas, including reference links, would be very much appreciated!

Comparison: HashSet, SortedSet

Are there any better collection classes?

Reference: the comparison table in the link below:
http://geekswithblogs.net/BlackRabbitCoder/archive/2011/06/16/c.net-fundamentals-choosing-the-right-collection-class.aspx

Update:

Problem using Array.BinarySearch:

var index = Array.BinarySearch(ipCountries, new IpCountry { IpFrom = 16909056}, new Ip2LocationComparer());

It works in small numbers of row, doesn’t work in 300k items (e.g. index is -(totalrow+1) ). The search item is loaded within the 300 K items collection.

        public class Ip2LocationComparer: IComparer<IpCountry>
        {
            public int Compare(IpCountry x, IpCountry y)
            {
                if (x != null && y != null)
                    return (x.IpFrom <= y.IpFrom && y.IpFrom <= x.IpTo)? 0 : -1;

                return -1;

            }
        }

Update 2

I changed it to below

public class Ip2LocationComparer: IComparer<IpCountry>
            {
                public int Compare(IpCountry x, IpCountry y)
                {
       if (x != null && y != null)

            {
                if (x.IpFrom > y.IpFrom)
                    return 1;

                if (x.IpFrom < y.IpFrom)
                    return -1;

                if (x.IpFrom == y.IpFrom)
                {
                    if (y.IpFrom > x.IpTo)
                        return 1;

                    if (y.IpFrom < x.IpTo)
                        return -1;

                }

            }

            return 0;
}

But the index return from BinarySearch is still nagtive, which is right between the matching item and the follow item. e.g. if my search IpFrom is 3, the index is between 2 and 4. Why it doen’t return 2? I haven’t test the IpTo scenario yet.

Any idea would be appreciated!

Answer 1

You could store this in an array.

If you sorted the array after populating, then a BinarySearch would be a very fast way to lookup where your currentIp falls.