Comment puis-je forcer un constructeur C # pour être une usine?

Question

Le code ci-dessous se compose de deux classes :

• SmartForm (classe simple modèle)
• SmartForms (classe pluriel qui contient une collection de SmartForm objets)

Je veux être en mesure d'instancier les deux classes singulier et pluriel comme ceci (à savoir que je ne veux pas une méthode de fabrication GetSmartForm ()):

SmartForms smartForms = new SmartForms("all");
SmartForm smartForm = new SmartForm("id = 34");

Pour consolider la logique, seule la classe plurielle devrait accéder à la base de données . La classe singulière, quand on lui demande de s'instancier, simplement instancier une classe plurielle, puis choisissez l'un objet de la collection de l'objet pluriel et devenir cet objet .

Comment puis-je faire? J'ai essayé d'assigner l'objet à this qui ne fonctionne pas.

using System.Collections.Generic;

namespace TestFactory234
{
    public class Program
    {
        static void Main(string[] args)
        {
            SmartForms smartForms = new SmartForms("all");
            SmartForm smartForm = new SmartForm("id = 34");
        }
    }

    public class SmartForm
    {
        private string _loadCode;

        public string IdCode { get; set; }
        public string Title { get; set; }

        public SmartForm() {}

        public SmartForm(string loadCode)
        {
            _loadCode = loadCode;
            SmartForms smartForms = new SmartForms(_loadCode);
            //this = smartForms.Collection[0]; //PSEUDO-CODE
        }

    }

    public class SmartForms
    {
        private string _loadCode;

        public List<SmartForm> _collection = new List<SmartForm>();
        public List<SmartForm> Collection
        {
            get
            {
                return _collection;
            }
        }

        public SmartForms(string loadCode)
        {
            _loadCode = loadCode;
            Load();
        }

        //fills internal collection from data source, based on "load code"
        private void Load()
        {
            switch (_loadCode)
            {
                case "all":
                    SmartForm smartFormA = new SmartForm { IdCode = "customerMain", Title = "Customer Main" };
                    SmartForm smartFormB = new SmartForm { IdCode = "customerMain2", Title = "Customer Main2" };
                    SmartForm smartFormC = new SmartForm { IdCode = "customerMain3", Title = "Customer Main3" };
                    _collection.Add(smartFormA);
                    _collection.Add(smartFormB);
                    _collection.Add(smartFormC);
                    break;
                case "id = 34":
                    SmartForm smartForm2 = new SmartForm { IdCode = "customerMain2", Title = "Customer Main2" };
                    _collection.Add(smartForm2);
                    break;
                default:
                    break;
            }
        }
    }
}

Answer 1

Il ne doit pas être exactement le même objet, il a juste l'air d'être le même pour les observateurs extérieurs. Si vous copiez toutes les données d'un objet à un autre, il accomplira la même chose.

public SmartForm(string loadCode)
{
    _loadCode = loadCode;
    SmartForms smartForms = new SmartForms(_loadCode);
    this.IdCode = smartForms[0].IdCode;
    this.Title = smartForms[0].Title;
}

Answer 2

Vous ne pouvez pas obtenir un objet à un autre « devenir ».

Utiliser des méthodes statiques au lieu des constructeurs (et font les constructeurs privés / interne / whatever de sorte que seules les méthodes statiques peuvent y accéder). Il existe de nombreux avantages à l'utilisation de méthodes statiques sur les constructeurs:

• Vous pouvez retourner le cas échéant null
• Vous pouvez retourner un objet existant le cas échéant
• Vous pouvez faire beaucoup de travail et puis appeler un constructeur simple qui définit simplement les champs

L'inconvénient est qu'ils ne fonctionnent pas avec la collection C # / objet initializers: (

Une alternative aux méthodes statiques (qui ne fonctionne pas bien, certes avec l'injection de dépendance,) est d'avoir une usine séparée et appeler des méthodes d'instance sur ce point.

Answer 3

Vous ne pouvez pas. Microsoft fait en définissant une méthode statique publique Créer () au lieu. Voir par exemple WebRequest et HttpWebRequest dans l'espace de noms System.Net. Je vous suggère de faire la même chose.

Faites interne ou privé constructeur de la classe de base, ne peut donc pas être instanciée directement. Ou mieux encore, faire une classe abstraite. Exploitez les constructeurs cachés dans votre implémentation Create ().

Answer 4

Vous pouvez utiliser un internal ou modificateur de protected pour le constructeur, au lieu de public. Tel que:

public SmartForm() {}
public SmartForm(string loadCode)
{
    _loadCode = loadCode;
    SmartForms smartForms = new SmartForms(_loadCode);
    //this = smartForms.Collection[0]; //PSEUDO-CODE
}

devient:

internal SmartForm() {}
internal SmartForm(string loadCode)
{
    _loadCode = loadCode;
    SmartForms smartForms = new SmartForms(_loadCode);
    //this = smartForms.Collection[0]; //PSEUDO-CODE
}

Answer 5

Vous pourriez faire une classe privée appelée SmartFormData, et de mettre toutes les valeurs en elle.

Faites la classe du pluriel SmartForms maintenir une collection de ces objets, et faire le constructeur singulier de SmartForm trouver l'instance SmartFormData droit au pluriel de SmartForms.

Ensuite, faire toutes les propriétés en SmartForm singulier aller chercher leurs valeurs de SmartFormData

Cependant, la meilleure façon de le faire est d'avoir un constructeur privé et utiliser une méthode de fabrication.

Y at-il une raison que vous devez utiliser un constructeur?