Iterating through generic collections

Well, as Sam said, at least I gained some knowledge. For one thing, I know now that I should research system namespaces a bit more :)

Good work Jrue.

I agree with Sam though. If you look at Collections and Generic namespace, you can find pretty much everything :)

Jure, I am sure it is quite educational to write something such as that. There are however many surprising productivity tools in the collections namespaces. You will find many worthwhile projects that build upon the existing classes. I assume it is possible to extend the existing Dictionary so that it does the allocation ("new") automatically.

Ughhh, didn't know something similar already exists. And it has much more logical name too...

But, mine has advantage when it comes to multiple dimensions:

Dictionary:

Dictionary> test = new Dictionary>();
test[10] = new Dictionary(); // throws exception without this line
test[10]["blah"] = 3;

DreamList:

DreamList, int> list2D = new DreamList, int>();
list2D[10]["blah"] = 3; // new DreamList at index 10 get's created automatically

DreamList is like a Dictionary, right?

I developed my code much further, into something I named DreamList (dll and source code at the bottom).
It's even possible to use multi-dimensional DreamList:

my_list["cat"][3.14][some_object] = "value";

This is the single line you need, nothing more. Notice that index can be of any type too, not just int.

Good answer from Jure Ziberna

I was getting sleepy when I wrote my previous reply. I was trying to clarify what I said but my mind just could not do it.

First note that use of indexes such as in "list's elements by index" is actually using the Item method. I can't find that stated explicitly in the documentation but I am nearly certain it is so. The frustrating thing is that I don't see any documentation of "operator []" in collections. I assume that "list's elements by index" is the same as the "operator []".

The Add method is totally different from the "operator []". The Add method adds to the list. The "operator []" gets an item in the list. Some collections will work the way you want them to and add items that don't exist for a key but most collections that have a one-for-one correspondence of index number and item do not add items when the index does not exist, for the reason that Jure explained. When a collection is essentially an array with an item for every index value preceding the maximum existing index, it is more productive to assume that an out-of-range index value is a mistake. Once you accept that, you will discover it is easy to use collections that work like arrays.

Note that if you use an array such as the one that is in the C# language, you can't add new entries simply by using an out-of-range index value as an index. Try to find a language that does do that; not many do, perhaps none. Do you know what a sparse matrix is? They are like arrays except there is not a one-for-one correspondence of index value and items. You can probably use the syntax you want to with sparse matrices. The C language does not support arrays in the manner you want and the vector class in C++ does not. Arrays in VB are also not dynamic in the manner you want. I think JavaScript might but it does not have true arrays; in JavaScript, the equivalent syntax is used for something that is more of a dictionary that maps keys to items.

Ok, so you have a list that consists of 5 items and you write mylist[1000] = 3. See the problem? Your list would have to create 995 empty items in between. That's wasteful if you ask me.

But I have a solution for you and it's called "Indexers". Check this out:

    class Program
    {
        static void Main(string[] args)
        {
            Indexer list = new Indexer();
            list[1000] = 3;
            Console.WriteLine(list[1000]);

            Indexer listStr = new Indexer();
            listStr[1000] = "test";
            Console.WriteLine(listStr[1000]);

            Console.ReadKey();
        }
    }

    class Indexer
    {
        private List values = new List();
        private List indexes = new List();

        public T this[int index]
        {
            set
            {
                int i;
                if ((i = indexes.FindIndex(new Predicate((int num) => { return index == num; }))) != -1)
                {
                    values[i] = value;
                    return;
                }
                else
                {
                    indexes.Add(index);
                    values.Add(value);
                }
            }
            get
            {
                int i;
                if ((i = indexes.FindIndex(new Predicate((int num) => { return index == num; }))) != -1)
                {
                    return values[i];
                }
                else throw new Exception("Value does not exist!");
            }
        }
    }

This will do what you want.

I don't think it's stupid that the generic list will accept an array during initialization. As you stated, it's very cool to be able to import values from an array to the list. I think it's stupid that assigning a value via index is handled differently than using the Add() method. I know that it must be handled somewhat differently, because you're not just tacking on a value at the end of the list, but at the least it should accept a variable assignment without requiring a value to already exist.

But that isn't the case, so thanks very much for your replies. I was able to get my code running without any other problems.

The first example is wrong, because it simply sets capacity (number of elements that list can hold) and not "count" (number of elements that are actually there).

The second example works perfectly fine, and, it's not stupid at all.
It's great that you can initialize a list by passing a standard array to the constructor, so that you can copy elements from an array to your list when you initialize the list. That's really great.
You can use this to do what you want by passing an empty array, created on the spot with "new" keyword, so that you don't have to add 10 elements but have 10 elements already in it.

What would be stupid, is that list would have a default number of elements from the start (say 20) when you just need a few. How are you going to count all the elements that you assigned? You can't use Count property, because it will return 20, so you have to resort to some less readable, probably also less efficient code. That would be kinda stupid, wouldn't it?

The reason your first code doesn't work is because at that state List has no items in its collection.

You can set initially capacity though, by calling this overloaded constructor:

... = new List(10);

which will set your list to 10 items.

Edit: Forgot that "capacity" and "count" is something completely different.

This will work (tested it):

... = new List(new string[10]);

I found the problem, though I'm still confused. It turns out that assigning a value to a generic list prior to using the Add method causes an exception. For instance, I get that exception when this code runs:

List devLoadList = new List(); devLoadList[0] = "stuff";

But this works:

List devLoadList = new List(); devLoadList.Add(""); devLoadList[0] = "stuff";

I'm not sure why I have to add items to a generic list before I assign values to the collection by index.