Comment puis-je créer une instance d'une classe créée dans une méthode disponible pour une autre méthode homologue?

Question

Est-il possible de créer plusieurs objets de classe en fonction du nombre d'utilisateurs que vous souhaitez créer? J'ai pu le faire mais cette instance est uniquement disponible selon la méthode qui l'a créé

public void Create() 
    { 
     //create class objects here 
    } 

et maintenant je ne serais pas en mesure de l'utiliser dans une autre méthode par exemple

public void Use() 
    { 
     //can't use class objects 
    } 

Answer 1

Sans arrêter de vous poser des questions sur vos décisions de conception, voici une réponse claire pour démontrer la technique simple d'utiliser un champ:

public class MyMainClass { 
    private List<MyOtherClass> _instances = new List<MyOtherClass>(); 

    private void Create(int number) { 
     for (int i = 0; i < number; i++) { 
      this._instances.Add(new MyOtherClass()); 
     } 
    } 

    private void Use() { 
     // use the first instance I created 
     MyOtherClass other = this._instances[0]; 

     other.DoSomething(); 
    } 
    ... 
} 

le champ _instances est scope au MyMainClass. Cela signifie qu'il est disponible pour toutes les méthodes d'instance (non statiques) sur la classe à laquelle il appartient.

Pour ce qui est de savoir pourquoi vous essayez de le faire, je laisserai la place à quelqu'un d'autre.

Mise à jour: une autre technique est présentée par Hemant dans une autre réponse où la méthode Create renvoie des instances à l'appelant. Cependant j'ai décidé de rester avec des champs pour démontrer une technique plus fondamentale.

Answer 2

Essayez ceci:

public MyObject[] Create() 
{ 
    //create class objects here and return them 
    return new[] {new MyObject(), new MyObject()}; 
} 

//later 
public void Use() 
{ 
    MyObject[] objs = Create(); 
    //use your objects as you like 
} 

Answer 3

Je pense que vous voulez dire des objets d'instance d'une classe particulière. Voir here for an introduction to classes and instances.

mais en substance:

public class SomeClass{ 
    int someData; 
    void SetData(int data) { 
    someData = data; 
    } 
    int GetData() { 
     return data; 
    } 
} 

// créer des instances de la «SomeClass de

var = new instance1 de SomeClass(); var instance2 = new SomeClass();

instance1.SetData (2); isntance2.SetData (3);

Answer 4

Dans Create() vous créez une classe mais, comme vous le dites, ne pouvez pas nous en dehors de la classe. La première chose que vous devez faire est de changer pour renvoyer l'objet:

public SomeType Create() 
{ 
    //code that creates the object here. 
    //Lets say it gets put into a variable called ret 
    return ret; 
} 
public void Use() 
{ 
    SomeType st = Create(); 
    //use st here. 
} 

Sinon, au lieu de la méthode qui utilise l'objet appelant Create, la méthode qui crée l'objet pourrait passer comme paramètre à Use(SomeType st) .

Pour ce faire avec plusieurs objets, nous devons retourner non pas un SomeType, mais un objet qui contient ces multiples objets SomeType. Parfois, nous avons besoin de certaines propriétés et méthodes à propos de cette collection entière (par exemple, le nombre, la possibilité de revenir en arrière dans la collection, etc.). Dans ce cas, nous retournerions un tableau, un List<SomeType>, un HashSet<SomeType> ou peut-être quelque chose comme Dictionary<string, SomeType> selon le cas.

Si nous n'avons pas besoin de telles opérations sur l'ensemble de la collection, il est plus simple et plus efficace de renvoyer un IEnumerable<SomeType> qui est un objet permettant de travailler sur une séquence de tels objets mais pas beaucoup d'autre. C# a une syntaxe précise pour le faire.Disons que nous allons revenir 10 ces objets:

public IEnumerable<SomeType> Create() 
{ 
    for(int i = 0; i != 10; ++i) 
    { 
    //code that creates the object here. 
    //Lets say it gets put into a variable called ret 
    yield return ret; 
    } 
} 
public void Use() 
{ 
    foreach(SomeType st in Create()) 
    { 
    //use st here. 
    } 
} 

Le mot-clé yield bien masquer beaucoup de complexité à propos IEnumerable<SomeType> et vous permet d'écrire tout le code qui passe à chaque nouvel objet (que la complexité est toujours là dans le code produit, mais pas votre problème à vous soucier).