Tag Archives: enumerator

Cinchoo – ChoSynchronizedEnumerator

ChoSynchronizedEnumerator

This is one another custom enumerator that Cinchoo framework provides. ChoSynchronizedEnumerator is a custom enumerator iterates over collection items synchronized way in multi-threaded applications.

How to use

1. Add reference to Cinchoo.Core.dll assembly

2. Namespace Cinchoo.Core.Collections.Generic or Cinchoo.Core.Collections

Using it on Generic Collections

Use Cinchoo.Core.Collection.Generic namespace.

Sample 1: Here we will see how to use it on List<> object,

Below sample iterates over List<> object by two threads simultaneously.

static void Main(string[] args)
{
    object syncRoot = new object();
    List<string> symbols = new List<string>();

    for (int x = 0; x < 5; x++)
        symbols.Add(String.Format("ITEM{0}", x));

    ManualResetEvent evt = new ManualResetEvent(false);
    for (int z = 0; z < 2; z++)
    {
        ThreadPool.QueueUserWorkItem((state) =>
            {
                Thread.CurrentThread.Name = String.Format("Thread_{0}", state);
                evt.WaitOne();
                int counter = 0;
                foreach (string symbol in new ChoSynchronizedEnumerator<string>(symbols, syncRoot))
                {
                    Console.WriteLine("{0}. {1} -- {2}", ++counter, symbol, Thread.CurrentThread.Name);
                }
            }, z);
    }

    evt.Set();
    Console.WriteLine("Press any key to continue...");
    Console.ReadLine();
}

When you run the above code, you will see the output consistently all the time as below. In a non-synchronous model, the output will product unpredictable sequence of results.

1. ITEM0 -- Thread_0
2. ITEM1 -- Thread_0
3. ITEM2 -- Thread_0
4. ITEM3 -- Thread_0
5. ITEM4 -- Thread_0
1. ITEM0 -- Thread_1
2. ITEM1 -- Thread_1
3. ITEM2 -- Thread_1
4. ITEM3 -- Thread_1
5. ITEM4 -- Thread_1
Press any key to continue . . .

Sample 2: Here we will see how to use it on Dictionary<> object

Below sample iterates over Dictionary<> object by two threads simultaneously.

static void Main(string[] args)
{
    object syncRoot = new object();
    Dictionary<int, string> dict = new Dictionary<int, string>();

    for (int x = 0; x < 5; x++)
        dict.Add(x, String.Format("VALUE{0}", x));

    ManualResetEvent evt = new ManualResetEvent(false);
    for (int z = 0; z < 2; z++)
    {
        ThreadPool.QueueUserWorkItem((state) =>
            {
                Thread.CurrentThread.Name = String.Format("Thread_{0}", state);
                evt.WaitOne();
                int counter = 0;
                foreach (KeyValuePair<int, string> keyValue in new ChoSynchronizedEnumerator<KeyValuePair<int, string>>(dict, syncRoot))
                {
                    Console.WriteLine("{0}. {1} -- {2}", keyValue.Key, keyValue.Value, Thread.CurrentThread.Name);
                }
            }, z);
    }

    evt.Set();
    Console.WriteLine("Press any key to continue...");
    Console.ReadLine();
}

When you run the above code, you will see the output consistently all the time as below. In a non-synchronous model, the output will product unpredictable sequence of results.

0. VALUE0 -- Thread_0
1. VALUE1 -- Thread_0
2. VALUE2 -- Thread_0
3. VALUE3 -- Thread_0
4. VALUE4 -- Thread_0
0. VALUE0 -- Thread_1
1. VALUE1 -- Thread_1
2. VALUE2 -- Thread_1
3. VALUE3 -- Thread_1
4. VALUE4 -- Thread_1
Press any key to continue . . .

Using it on Non Generic Collections

Use Cinchoo.Core.Collection namespace.

Sample 3: Here we will see how to use it on ArrayList object

Below sample iterates over ArrayList object by two threads simultaneously.

static void Main(string[] args)
{
    object syncRoot = new object();
    ArrayList symbols = new ArrayList();

    for (int x = 0; x < 5; x++)
        symbols.Add(String.Format("ZITEM{0}", x));

    ManualResetEvent evt = new ManualResetEvent(false);
    for (int z = 0; z < 2; z++)
    {
        ThreadPool.QueueUserWorkItem((state) =>
            {
                Thread.CurrentThread.Name = String.Format("Thread_{0}", state);
                evt.WaitOne();
                int counter = 0;
                foreach (string symbol in new ChoSynchronizedEnumerator(symbols, syncRoot))
                {
                    Console.WriteLine("{0}. {1} -- {2}", ++counter, symbol, Thread.CurrentThread.Name);
                }
            }, z);
    }

    evt.Set();
    Console.WriteLine("Press any key to continue...");
    Console.ReadLine();
}

When you run the above code, you will see the output consistently all the time as below. In a non-synchronous model, the output will product unpredictable sequence of results.

1. ZITEM0 -- Thread_0
2. ZITEM1 -- Thread_0
3. ZITEM2 -- Thread_0
4. ZITEM3 -- Thread_0
5. ZITEM4 -- Thread_0
1. ZITEM0 -- Thread_1
2. ZITEM1 -- Thread_1
3. ZITEM2 -- Thread_1
4. ZITEM3 -- Thread_1
5. ZITEM4 -- Thread_1
Press any key to continue . . .

Sample 4: Here we will see how to use it on Hashtable object,

Below sample iterates over Hashtable object by two threads simultaneously.

static void Main(string[] args)
{
    object syncRoot = new object();
    Hashtable dict = new Hashtable();

    for (int x = 0; x < 5; x++)
        dict.Add(x, String.Format("VALUE{0}", x));

    ManualResetEvent evt = new ManualResetEvent(false);
    for (int z = 0; z < 2; z++)
    {
        ThreadPool.QueueUserWorkItem((state) =>
            {
                Thread.CurrentThread.Name = String.Format("Thread_{0}", state);
                evt.WaitOne();
                foreach (DictionaryEntry dictEntry in new ChoSynchronizedEnumerator(dict, syncRoot))
                {
                    Console.WriteLine("{0}. {1} -- {2}", dictEntry.Key, dictEntry.Value, Thread.CurrentThread.Name);
                }
            }, z);
    }

    evt.Set();
    Console.WriteLine("Press any key to continue...");
    Console.ReadLine();
}

When you run the above code, you will see the output consistently all the time as below. In a non-synchronous model, the output will product unpredictable sequence of results.

4. VALUE4 -- Thread_0
3. VALUE3 -- Thread_0
2. VALUE2 -- Thread_0
1. VALUE1 -- Thread_0
0. VALUE0 -- Thread_0
4. VALUE4 -- Thread_1
3. VALUE3 -- Thread_1
2. VALUE2 -- Thread_1
1. VALUE1 -- Thread_1
0. VALUE0 -- Thread_1
Press any key to continue . . .

PS: Please be careful about using this enumerator, you must dispose the enumerator to order to avoid contention, deadlock issues.

Cinchoo – ChoConstraintEnumerator

ChoConstraintEnumerator

This is one another custom enumerator that Cinchoo framework provides. ChoConstraintEnumerator is a custom enumerator iterates over collection items matches the passed constraint logic.

How to use

1. Add reference to Cinchoo.Core.dll assembly

2. Namespace Cinchoo.Core.Collections.Generic or Cinchoo.Core.Collections

Using it on Generic Collections

Use Cinchoo.Core.Collection.Generic namespace.

Sample 1: Here we will see how to use it on List<> object, matches items having value 3 or 5

static void Main(string[] args)
{
    List<string> symbols = new List<string>();

    for (int x = 0; x < 7; x++)
        symbols.Add(String.Format("ITEM{0}", x));

    int counter = 0;
    foreach (string symbol in new ChoConstraintEnumerator<string>(symbols, (x) => x.EndsWith("3") || x.EndsWith("5")))
    {
        Console.WriteLine("{0}. {1}", ++counter, symbol);
    }
}

When you run the above code, the output will be

1. ITEM3
2. ITEM5
Press any key to continue . . .

Sample 2: Here we will see how to use it on Dictionary<> object, matches items having key either 3 or 5

static void Main(string[] args)
{
    Dictionary<int, string> dict = new Dictionary<int, string>();

    for (int x = 0; x < 7; x++)
        dict.Add(x, String.Format("VALUE{0}", x));

    foreach (KeyValuePair<int, string> keyValue in new ChoConstraintEnumerator<KeyValuePair<int, string>>(dict, (x) => x.Key == 3 || x.Key == 5))
    {
        Console.WriteLine("{0}. {1}", keyValue.Key, keyValue.Value);
    }
}

When you run the above code, the output will be

3. VALUE3
5. VALUE5
Press any key to continue . . .

Using it on Non Generic Collections

Use Cinchoo.Core.Collection namespace.

Sample 3: Here we will see how to use it on ArrayList object, matches items having value 3 or 5

static void Main(string[] args)
{
    ArrayList symbols1 = new ArrayList();

    for (int x = 0; x < 7; x++)
        symbols1.Add(String.Format("ZITEM{0}", x));

    int counter1 = 0;
    foreach (object symbol in new ChoConstraintEnumerator(symbols1, (x) => x.ToString().EndsWith("3") || x.ToString().EndsWith("5")))
    {
        Console.WriteLine("{0}. {1}", ++counter1, symbol);
    }
}

When you run the above code, the output will be

1. ZITEM3
2. ZITEM5
Press any key to continue . . .

Sample 4: Here we will see how to use it on Hashtable object, matches items having key either 3 or 5

static void Main(string[] args)
{
    Hashtable hash = new Hashtable();

    for (int x = 0; x < 7; x++)
        hash.Add(x, String.Format("VALUE{0}", x));

    foreach (DictionaryEntry dictEntry in new ChoConstraintEnumerator(hash, (x) => ((DictionaryEntry)x).Key.ToString() == "3" || ((DictionaryEntry)x).Key.ToString() == "5"))
    {
        Console.WriteLine("{0}. {1}", dictEntry.Key, dictEntry.Value);
    }
}

When you run the above code, the output will be

5. VALUE5
3. VALUE3
Press any key to continue . . .

Cinchoo – ChoReverseEnumerator

ChoReverseEnumerator

This is one another custom enumerator that Cinchoo framework provides. ChoReverseEnumerator is a custom enumerator iterates over collection items in reverse order.

How to use

1. Add reference to Cinchoo.Core.dll assembly

2. Namespace Cinchoo.Core.Collections.Generic or Cinchoo.Core.Collections

Using it on Generic Collections

Use Cinchoo.Core.Collection.Generic namespace.

Sample 1: Here we will see how to use it on List<> object

static void Main(string[] args)
{
    List<string> symbols = new List<string>();

    for (int x = 0; x < 5; x++)
        symbols.Add(String.Format("ITEM{0}", x));

    int counter = 0;
    foreach (string symbol in new ChoReverseEnumerator<string>(symbols))
    {
        Console.WriteLine("{0}. {1}", ++counter, symbol);
    }
}

When you run the above code, the output will be

1. ITEM4
2. ITEM3
3. ITEM2
4. ITEM1
5. ITEM0
Press any key to continue . . .

Sample 2: Here we will see how to use it on Dictionary<> object

static void Main(string[] args)
{
    Dictionary<int, string> symbols = new Dictionary<int, string>();

    for (int x = 0; x < 5; x++)
        symbols.Add(x, String.Format("VALUE{0}", x));

    foreach (KeyValuePair<int, string> keyValue in new ChoReverseEnumerator<KeyValuePair<int, string>>(symbols))
    {
        Console.WriteLine("{0}. {1}", keyValue.Key, keyValue.Value);
    }
}

When you run the above code, the output will be

4. VALUE4
3. VALUE3
2. VALUE2
1. VALUE1
0. VALUE0
Press any key to continue . . .

Using it on Non Generic Collections

Use Cinchoo.Core.Collection namespace.

Sample 3: Here we will see how to use it on ArrayList object, with 2 steps

static void Main(string[] args)
{
    ArrayList symbols = new ArrayList();

    for (int x = 0; x < 5; x++)
        symbols.Add(String.Format("ZITEM{0}", x));

    int counter = 0;
    foreach (object symbol in new ChoReverseEnumerator(symbols))
    {
        Console.WriteLine("{0}. {1}", ++counter, symbol);
    }
}

When you run the above code, the output will be

1. ZITEM4
2. ZITEM3
3. ZITEM2
4. ZITEM1
5. ZITEM0
Press any key to continue . . .

Sample 4: Here we will see how to use it on Hashtable object, with 2 steps

static void Main(string[] args)
{
    Hashtable hash = new Hashtable();

    for (int x = 0; x < 5; x++)
        hash.Add(x, String.Format("VALUE{0}", x));

    foreach (DictionaryEntry dictEntry in new ChoReverseEnumerator(hash))
    {
        Console.WriteLine("{0}. {1}", dictEntry.Key, dictEntry.Value);
    }
}

When you run the above code, the output will be

0. VALUE0
1. VALUE1
2. VALUE2
3. VALUE3
4. VALUE4
Press any key to continue . . .

Cinchoo – ChoSteppedEnumerator

ChoSteppedEnumerator

This is one another custom enumerator that Cinchoo framework provides. ChoSteppedEnumerator is a custom enumerator iterates over collection items while skipping some items.

How to use

1. Add reference to Cinchoo.Core.dll assembly

2. Namespace Cinchoo.Core.Collections.Generic or Cinchoo.Core.Collections

Using it on Generic Collections

Use Cinchoo.Core.Collection.Generic namespace.

Sample 1: Here we will see how to use it on List<> object, with 2 steps

static void Main(string[] args)
{
    List<string> symbols = new List<string>();

    for (int x = 0; x < 7; x++)
        symbols.Add(String.Format("ITEM{0}", x));

    int counter = 0;
    foreach (string symbol in new ChoSteppedEnumerator<string>(symbols, 2))
    {
        Console.WriteLine("{0}. {1}", ++counter, symbol);
    }
}

When you run the above code, the output will be

1. ITEM0
2. ITEM3
3. ITEM6
Press any key to continue . . .

Sample 2: Here we will see how to use it on Dictionary<> object , with 2 steps

static void Main(string[] args)
{
    Dictionary<int, string> symbols = new Dictionary<int, string>();

    for (int x = 0; x < 7; x++)
        symbols.Add(x, String.Format("VALUE{0}", x));

    foreach (KeyValuePair<int, string> keyValue in new ChoSteppedEnumerator<KeyValuePair<int, string>>(symbols, 2))
    {
        Console.WriteLine("{0}. {1}", keyValue.Key, keyValue.Value);
    }
}

When you run the above code, the output will be

0. ITEM0
3. ITEM3
6. ITEM6
Press any key to continue . . .

Using it on Non Generic Collections

Use Cinchoo.Core.Collection namespace.

Sample 3: Here we will see how to use it on ArrayList object, with 2 steps

static void Main(string[] args)
{
    ArrayList symbols = new ArrayList();

    for (int x = 0; x < 7; x++)
        symbols.Add(String.Format("ITEM{0}", x));

    int counter = 0;
    foreach (object symbol in new ChoSteppedEnumerator(symbols, 2))
    {
        Console.WriteLine("{0}. {1}", ++counter, symbol);
    }
}

When you run the above code, the output will be

1. ITEM0
2. ITEM3
3. ITEM6
Press any key to continue . . .

Sample 4: Here we will see how to use it on Hashtable object, with 2 steps

static void Main(string[] args)
{
    Hashtable hash = new Hashtable();

    for (int x = 0; x < 7; x++)
        hash.Add(x, String.Format("VALUE{0}", x));

    foreach (DictionaryEntry dictEntry in new ChoSteppedEnumerator(hash, 2))
    {
        Console.WriteLine("{0}. {1}", dictEntry.Key, dictEntry.Value);
    }
}

When you run the above code, the output will be

6. VALUE6
3. VALUE3
0. VALUE0
Press any key to continue . . .

Cinchoo – ChoCircularEnumerator

ChoCircularEnumerator

Cinchoo provides number of helper classes. ChoCircularEnumerator is one of the helper class to iterate over collection items in circular manner. In order to avoid infinite iteration over the collection items, you must provide number of circular iteration while creating enumerator.

How to use

1. Add reference to Cinchoo.Core.dll assembly

2. Namespace Cinchoo.Core.Collections.Generic or Cinchoo.Core.Collections

Using it on Generic Collections

Use Cinchoo.Core.Collection.Generic namespace.

Sample 1: Here we will see how to use it on List<> object, with 2 iterations

static void Main(string[] args)
{
    List<string> symbols = new List<string>();

    for (int x = 0; x < 5; x++)
        symbols.Add(String.Format("ITEM{0}", x));

    int counter = 0;
    foreach (string symbol in new ChoCircularEnumerator<string>(symbols, 2))
    {
        Console.WriteLine("{0}. {1}", ++counter, symbol);
    }
}

When you run the above code, the output will be

1. ITEM0
2. ITEM1
3. ITEM2
4. ITEM3
5. ITEM4
6. ITEM0
7. ITEM1
8. ITEM2
9. ITEM3
10. ITEM4
Press any key to continue . . .

Sample 2: Here we will see how to use it on Dictionary<> object , with 2 iterations

static void Main(string[] args)
{
    Dictionary<int, string> symbols = new Dictionary<int, string>();

    for (int x = 0; x < 5; x++)
        symbols.Add(x, String.Format("VALUE{0}", x));

    foreach (KeyValuePair keyValue in new ChoCircularEnumerator<KeyValuePair<int, string>>(symbols, 2))
    {
        Console.WriteLine("{0}. {1}", keyValue.Key, keyValue.Value);
    }
}

When you run the above code, the output will be

0. ITEM0
1. ITEM1
2. ITEM2
3. ITEM3
4. ITEM4
0. ITEM0
1. ITEM1
2. ITEM2
3. ITEM3
4. ITEM4
Press any key to continue . . .

Using it on Non Generic Collections

Use Cinchoo.Core.Collection namespace.

Sample 3: Here we will see how to use it on ArrayList object, with 2 iterations

static void Main(string[] args)
{
    ArrayList symbols = new ArrayList();

    for (int x = 0; x < 5; x++)
        symbols.Add(String.Format("ITEM{0}", x));

    int counter = 0;
    foreach (object symbol in new ChoCircularEnumerator(symbols, 2))
    {
        Console.WriteLine("{0}. {1}", ++counter, symbol);
    }
}

When you run the above code, the output will be

1. ITEM0
2. ITEM1
3. ITEM2
4. ITEM3
5. ITEM4
6. ITEM0
7. ITEM1
8. ITEM2
9. ITEM3
10. ITEM4
Press any key to continue . . .

Sample 4: Here we will see how to use it on Hashtable object, with 2 iterations

static void Main(string[] args)
{
    Hashtable hash = new Hashtable();

    for (int x = 0; x < 5; x++)
        hash.Add(x, String.Format("VALUE{0}", x));

    foreach (DictionaryEntry dictEntry in new ChoCircularEnumerator(hash, 2))
    {
        Console.WriteLine("{0}. {1}", dictEntry.Key, dictEntry.Value);
    }
}

When you run the above code, the output will be

4. VALUE4
3. VALUE3
2. VALUE2
1. VALUE1
0. VALUE0
4. VALUE4
3. VALUE3
2. VALUE2
1. VALUE1
0. VALUE0
Press any key to continue . . .