Bigio

What is Bigio used for?

Bigio is a several collections special adapted to store a lot of elements. Standard List and LinkedList is great choice for the most of cases, but they become useless if you have to work with thousands and millions of elements because of:
1. Ineffective operations because of structure of List and LinkedList
2. Memory overhead of that system collections.

Getting started

There is no nuget-package of Bigio library at this moment, because it still in active development.
If you want to use it you have to clone repository:
Just copy-past that in git client: git clone https://github.com/80LevelElf/Bigio.git
Or download zip file with repository Then open downloaded folder, move to 'bin' folder and copy 'Bigio.dll' file to your project working directory.
Then just specify reference to Bigio.dll from needed projects.

Structure of Bigio

At this moment Bigio consist of this main parts:
1. BigArray
2. BigQueue
3. BigStack
Click to move into separate wiki pages of each collection.

Quck start

All Bigio collections use familiar API and interfaces to make work with it easy.
API of 'BigList' quite similar to system 'List' API, for example:

Insert million elements to random positions:

var list = new BigArray<int>();
Random random = new Random();

for (int i = 0; i < 1000000; i++)
{
    list.Insert(random .Next(list.Count), i);
}

After that we can find index of some element:

list.IndexOf(random.Next(list.Count));

Remove last entry of some element:

list.RemoveLast(random.Next(list.Count));

Or find first event element with LINQ(or default(T) if all elements are odd):

var firstEven = list.FirstOrDefault(i => i % 2 == 0);

Is there any alternative solutions?

Of course they are! The most famous alternative is Wintellect's Power Collections of Wintellect company. It's great solution developed by clever people, but in most of cases Bigio will be faster:
All search estimations measured for collections with 1.000.000 elements.
We compare Bigio.BigArray<T> and PowerCollections.BigList<T>

Estimation much be different in different computers(depend on processor and count of cores inside it), compilers and the phases of the moon.

Search:

IndexOf(item):

LastIndexOf(item):

Find(predicate):

FindLast(predicate):

FindAll(predicate):

Adding and insertions:

Add(item):

Insert(item) in the start position:

Insert(item) in the middle position:

Insert(item) in the random position:

AddRange(range):

InsertRange(range) in random position:

Other:

BinarySearch(item, 0, collectionLength)

Foreach through full collection

For through full collection

Reverse() all elements

Memory estimation (memory size of process with only one collection):

As you can see Bigio give you much faster and smaller solution for big collection than PowerCollections.