Limite la création d'instances d'une classe?

Je suis à l'aide de C#. J'ai créé une classe qui peut être inclus dans toute c#.net projet (desktop ou web), mais je veux que seulement 10 objets seront créés dans l'application de ma classe. Si des instances de l'objet créé plus de 10 alors il devrait donner une erreur ou simple volonté de ne pas fonctionner.

Il peut y avoir deux situations,

Je vais inclus myclass.cs fichier dans n'importe quel
projet ou
Je vais le faisceau de ma classe dans une DLL et de l'inclure dans n'importe quelle application

Dans les deux cas, il doit, par erreur, si plus de 10 instances de ma classe est créée dans l'application.

Cette question a été posée par mon professeur, il m'a dit de chercher la réponse sur internet, j'ai essayé mais pas trouvé de solution pour ce problème, je n'ai pas entendu dire que l'on peut limiter les objets?

Est-il possible, si oui, alors comment?

Grâce

source d'informationauteur Prashant

c#class instance oop

18

Garder une variable statique avec le nombre d'instances créées. Augmentation nombre à chaque la construction de l'objet. Faire l'objet IDisposable et décrémenter le nombre sur chaque appel dispose(). Si vous voulez être thread-safe, utilisez Interloqué.Increment() et Interloqué.Decrement() pour modifier la valeur de cette variable au lieu de ++ et --.
9

Je crois que vous voulez de la forme de la multiton modèle.

La multiton modèle est une variation sur le motif de singleton, mais qui permet de n instances de l'objet. Un peu comme la façon dont la classe singleton a une variable statique de tenir l'instance unique, le multiton est souvent mis en œuvre avec un tableau statique ou carte d'instances, en fonction de comment vous voulez accéder à des instances - les tableaux ne permettent numérique d'accès, mais en utilisant une carte, vous pouvez fournir des clés de Chaîne à vos instances, les rendant nommé.
8

Vous aurez simplement besoin d'utiliser le modèle de fabrique avec un compteur du nombre d'instances créées, après quoi la méthode lèvera une exception ou retourne la valeur null.

Exemple:
```
public class Foobar
{
    private static int numInstances = 0;

    public static Foobar CreateFoobar()
    {
        if (numInstances++ < 10)
        {
            return new Foobar();
        }

        return null;
    }

    protected Foobar()
    {
        ...
    }
}
```
La méthode ci-dessus fonctionne parfaitement bien pour une seule instance de l'application, mais pour un multi-instance de l'application, vous voudrez probablement utiliser un sémaphore (une mise en œuvre existe dans System.Threading), qui vise précisément pour ce genre de situation (limitation de l'accès aux ressources/objets). Il permet de contourner le problème de la plusieurs instances de la classe demandée presque simultanément et le nombre des contrôles défaillants.

Je voudrais créer un statique entier et le mettre à jour lorsque vous instancier un nouvel objet.

class YourClass
{
    static int Count = 0;

    public YourClass()
    {
       Count++;
       if(Count > 10)
       {
           //throw exception
       }
    }
}

0

prendre un compteur statique dans la classe, et de lever une exception dans le constructeur de la classe si count>10
0

Pour l'élimination de l'instance également créer un statique décharger méthode (similaires à domaine d'application). Ont le décharger appel de la méthode de la mise en œuvre de IDisposable qui décrémente le compteur à l'aide de Contrefil.Décrémenter et dispose également de l'instance.

(Je pars du principe que si votre limitant le nombre d'instances que vous avez des ressources dans l'instance pour gérer.)

Vous pouvez également utiliser des génériques pour permettre à l'usine de la classe pour être ré-utilisé pour limiter les instances de classes différentes. Contraintes d'utilisation d'exiger de l'instance à mettre en œuvre IDisposible et avoir un constructeur par défaut. Également fournir une non-propriété statique de retourner l'instance réelle.
```
public class foo : IDisposable 
   {
   public foo() { ; }
   public string Name;

   public void Dispose()  { ; } 
   //Real class would free up instance resources
   }
```
```
  LimitedInstance< foo > li = LimitedInstance< foo >.CreateInstance();

  li.Instance.Name = "Friendly Name for instance";
  //do stuff with li

  LimitedInstance< foo >.UnloadInstance( ref li );
```
Seul problème, c'est que vous ne pouvez pas la surcharge de l'opérateur d'affectation en C#. Donc, si vous procédez de la manière suivante:
```
   li = null;
```
Au lieu d'appeler la décharger méthode, puis l'instance restera sur le tas, et votre compteur de nombre de cas ne sera pas décompté, jusqu'à ce que le GC se produit.

Vous devez vous connecter pour publier un commentaire.