how to create multiple objects and enumerate them in c#

my problem is as follows:

Im building a console application which asks the user for the numbers of objects it should create and 4 variables that have to be assigned for every object. The new objects name should contain a counting number starting from 1.

How would you solve this? Im thinking about a class but im unsure about how to create the objects in runtime from userinput. Is a loop the best way to go?

What kind of class, struct, list, array .... would you recommend. The variables in the object are always the same type but i need to name them properly so I can effectivly write methods to perform operations on them in a later phase of the program.

Im just learning the language and I would be very thankful for a advice on how to approach my problem.

From stackoverflow

• Use a list or an array. List example:

  int numberOfObjects = 3;
  List<YourType> listOfObjects = new List<YourType>();
  for(int i = 0 ; i < numberOfObjects ; i++ ) 
  {
      // Get input and create object ....
      // Then add to your list
      listOfObjects.Add(element);
  }
  

  Here, listOfObjects is a Generic list that can contain a variable number of objects of the type YourType. The list will automatically resize so it can hold the number of objects you add to it. Hope this helps.

  annakata : Actually sound more like a `Dictionary` (for a custom class foo) with the "name" requirement.

  Thorarin : I'm not sure if that is an actual requirement, or just because he needs to get more confortable with the concept of arrays.

• Why not just write the methods to use the index of the array? Or if you need some form of key/value type of functionality. You could use a dictionary class and have your method check for the key of the value you passed to it.

  A dictionary is similar to an array.

• If I understood what you are asking you could probably do something like this:

  class Foo 
  {
     private static int count;
     public string name;
     public Foo(...){
       name = ++count + "";
     }
  }
  

  Thorarin : I've thought about that, but I thought it better to discourage such a pattern at this point. If you wanted to make absolutely sure no object has the same number / name, you could enforce it like this. Then again, you should probably add a `volatile` to your static variable in that case.

• I'm guessing what you're trying to do here, but this is a stab in the dark. The problem I'm having is dealing with the whole "the new objects name should contain a counting number starting from 1" thing. Anyway, here's my attempt:

  public class UserInstantiatedClass
  {
     public int UserSetField1;
     public int UserSetField2;
     public int UserSetField3;
     public int UserSetField4;
     public string UserSpecifiedClassName;
  }
  
  public static class MyProgram
  {
     public static void Main(string [] args) 
     {
        // gather user input, place into variables named 
        // numInstances, className, field1, field2, field3, field4
        List<UserInstantiatedClass> instances = new List< UserInstantiatedClass>();
        UserInstantiatedClass current = null;
        for(int i=1; i<=numInstances; i++)
        {
           current = new UserInstantiatedClass();
           current.UserSpecifiedClassName = className + i.ToString(); // adds the number 1, 2, 3, etc. to the class name specified
           current.UserSetField1 = field1;
           current.UserSetField2 = field2;
           current.UserSetField3 = field3;
           current.UserSetField4 = field4;
           instances.Add(current);
        }
        // after this loop, the instances list contains the number of instances of the class UserInstantiatedClass specified by the numInstances variable.  
     }
  }
  

• If I understand your problem correctly:

  class MyClass
  {
      public int ObjectNumber { get; set; }
      public string SomeVariable { get; set; }
      public string AnotherVariable { get; set; }
  }
  
  // You should use keyboard input value for this 
  int objectsToCreate = 10;
  
  // Create an array to hold all your objects
  MyClass[] myObjects = new MyClass[objectsToCreate];
  
  for (int i = 0; i < objectsToCreate; i++)
  {
      // Instantiate a new object, set it's number and
      // some other properties
      myObjects[i] = new MyClass()
      {
          ObjectNumber = i + 1,
          SomeVariable = "SomeValue",
          AnotherVariable = "AnotherValue"
      };
  }
  

  This doesn't quite do what you described. Add in keyboard input and stuff :) Most of this code needs to be in some kind of Main method to actually run, etc.

  In this case, I've chosen a class to hold your 4 variables. I have only implemented 3 though, and I've implemented them as properties, rather than fields. I'm not sure this is necessary for your assignment, but it is generally a good habit to not have publically accessible fields, and I don't want to be the one to teach you bad habits. See auto-implemented properties.

  You mentioned a struct, which would be an option as well, depending on what you want to store in it. Generally though, a class would be a safer bet.

  A loop would indeed be the way to go to initialize your objects. In this case, a for loop is most practical. It starts counting at 0, because we're putting the objects in an array, and array indexes in C# always start at 0. This means you have to use i + 1 to assign to the object number, or the objects would be numbered 0 - 9, just like their indexes in the array.

  I'm initializing the objects using object initializer syntax, which is new in C# 3.0. The old fashioned way would be to assign them one by one:

  myObjects[i] = new MyClass();
  myObjects[i].ObjectNumber = i + 1;
  myObjects[i].SomeVariable = "SomeValue";
  

  Alternatively, you could define a constructor for MyClass that takes 3 parameters.

  One last thing: some people here posted answers which use a generic List (List<MyClass>) instead of an array. This will work fine, but in my example I chose to use the most basic form you could use. A List does not have a fixed size, unlike an array (notice how I initialized the array). Lists are great if you want to add more items later, or if you have no idea beforehand how many items you will need to store. However, in this case, we have the keyboard input, so we know exactly how many items we'll have. Thus: array. It will implicitly tell whoever is reading your code, that you do not intend to add more items later.

  I hope this answered some questions, and raised some new ones. See just how deep the rabbit hole goes :P