Creating objects dynamically in loop

While others have given you an alternate but no one is telling why do they recommend you that.

That's because You cannot access object with dynamic names.

(Food for thought: Just think for a moment if you could do so, how will you access them before they are even coded/named.)

Instead create a Dictionary<string, myClass> as others mentioned.

Use a Dictionary<String, myClass> instead:

var dict= new Dictionary<String, myClass>();

foreach (string name in array)
{
    dict.Add(name, new myClass());
}

Now you can access the myClass instances by your names:

var one = dict["one"];

or in a loop:

foreach (string name in array)
{
    myClass m = dict[ name ];
}

You can use this approach:

  var array = [srt1, srt2, str3];
  var other_array = [];

  for(var i = 0; i <  array.length; i++){
    other_array.push({
    name: array[i]
    })
  }

And for lookup it is easy to find the instance you need by filtering:

var instance1 = other_array.filter(function(result) {
return result.name == 'str1';
});

Looks like you need a list of dictionary of your objects:

var myClassDictionary = new Dictionary<string,myClass>();

foreach (string name in array)
{
  myClassDicationry.Add(name, new myClass());
}

// usage:
// myClass["one"] <- an instance of myClass

There are no programming languages that I know of that let you define variable names in runtime.

You could do something like this -

Dictionary<string, myClass> classes = new Dictionary<string, myClass>();

foreach(string name in array)
{
    classes[name] = new myClass();
}

Then you can refer to the named instances later

classes[name].MyClassMethod();

You can use the following code.

string[] array = new string[] { "one", "two", "three" };
Dictionary<String, myClass> list;
class myClass(){

   public myClass(){
   list = new Dictionary<String, myClass>();
   }
 } 

 foreach (string name in array)
 {
    list.Add(name, new myClass())
 }

You can use lists to store the objects so you can access them

list<myClass> myClasses = new List<myClass>();
foreach (myClass object in myClasses)
{
    //preform interaction with your classes here 
}

Not applicable to C#, or any statically-typed language for that matter.

For curiosity, I tried if what I remembered in PHP(creating variables on-the-fly) is still correct.

It's still the same PHP, last I used it was year 2000. You can generate variables on-the-fly, not saying it's advisable though, it pollutes the global variables, it can corrupt some existing variable or object with same name.

https://ideone.com/nJDiou

<?php

class MyClass
{
    private $v;
    function __construct($x) {
        $this->v = $x;
    }
    public function getValue() {
        return $this->v;
    }
}

$one = new MyClass("I'm tough!");

echo "The one: " . $one->getValue() . "\n";

$i = 0;
foreach(array("one","two","three") as $h) {
   $$h = new MyClass("Says who? " . ++$i);
}

echo "The one: " . $one->getValue() . "\n";

echo $two->getValue() . "\n";
echo $three->getValue() . "\n";

echo "loop\n";

foreach(array("three","one","two") as $h) {
   echo $$h->getValue() . "\n";
}

?>

Outputs:

The one: I'm tough!
The one: Says who? 1
Says who? 2
Says who? 3
loop
Says who? 3
Says who? 1
Says who? 2