Avrei una classe planet generica, con proprietà di sola lettura impostate dai parametri del costruttore.

class Planet
{
    public string Name { get; private set; }
    public double Mass { get; private set; }

    public Planet(string name, double mass)
    {
        this.Name = name;
        this.Mass = mass;
    }
}

Avrei quindi una classe PlanetFactory per la generazione di pianeti ben noti:

static class PlanetFactory
{
    public static Planet CreateEarth() 
    { 
        return new Planet("Earth", 597219000000000000000000); 
    }

    public static CreateByName(string name)
    {
        if (name.Equals("Earth")) return CreateEarth();
    }
}

Avrei quindi una classe manager per contenere tutti i tuoi pianeti:

class PlanetManager
{
    private Dictionary<string, Planet> planets;

    public GetPlanet(string name)
    {
        if (!planets.ContainsKey(name))
        {
            planets.add(name, PlanetFactory.CreateByName(name));
        }

        return planets[name];
    }
}

Questo approccio significa che puoi facilmente aggiungere nuovi pianeti conosciuti e fornire un meccanismo per l'aggiunta di nuovi pianeti attraverso la classe PlanetManager (anche se avresti bisogno di un metodo diverso per farlo).

Potresti creare proprietà statiche su Planet per ciascuno dei pianeti specifici che desideri creare.

Ad esempio:

public class Planet
{
    public string Name { get; set; }
    public double Mass { get; set; }

    private static Planet _earth;
    public static Planet Earth { get { return GetEarth(); } }

    //Use this approach so that you only create a planet if it is needed
    private static Planet GetEarth()
    {
         if(_earth == null)
              _earth = new Planet { Name = "Earth", Mass = 123.0 };
         return _earth;
    }
}

Questo approccio è simile a come funziona la classe System.Drawing.Color . Dai uno sguardo a questo in ILSpy , in particolare le proprietà dei colori con nome come Aqua , White , ecc.

Vorrei utilizzare una soluzione simile a Stephens, in quanto implica un dizionario e PlanetManager è statico.

Questo esempio presuppone che tu abbia già un% base di tipo% di tipo co_de e sottoclassi di Planet (come Planet ) per pianeti diversi. Ciò funzionerebbe anche per le implementazioni planetarie senza sottoclassi (come in tutti i pianeti sono istanze di Earth e non una classe derivata). Se stai estendendo Planet per creare tutti i tuoi pianeti, ti consiglio di creare Planet astratto in modo che debba essere esteso per creare istanze.

public static class PlanetManager
{
    static PlanetManager()
    {
        // Initialize the planets dictionary in a static constructor
        _planets = new Dictionary<string, Planet>();
        // Add existing planets to the dictionary using the appropriate constructor
        _planets.Add("earth", new Earth());
    }

    private static Dictionary<string, Planet> _planets;

    public static void AddPlanet(string name, Planet planet)
    {
        if(name == null)
        {
            throw new ArgumentNullException("name");
        }

        if(planet == null)
        {
            throw new ArgumentNullException("planet");
        }

        if(_planets.ContainsKey(name.ToLower()))
        {
            // Only one planet per name
            throw new InvalidOperationException("That planet already exists.");
        }

        // Add the planet to the dictionary
        _planets[name.ToLower()] = planet;
    }

    public static Planet GetPlanet(string name)
    {
        if(name == null)
        {
            // Null checks
            throw new ArgumentNullException("name");
        }

        // Case-insensitive planet matching that lets exceptions fall through to caller
        return _planets[name.ToLower()];
    }
}

Questa implementazione non è thread-safe.

Sei, per qualsiasi motivo, dati hard-coding nel tuo programma. Questo è di per sé un odore di codice (cosa fai quando Marte subisce una collisione catastrofica e perde il 5% se è di massa?), Ma a volte il codice reale è maleodorante e ci sono alcuni modi per farlo meglio di altri.

Dato che nel nostro esempio vogliamo consentire ai programmatori downstream di creare le proprie istanze di pianeta, vorremmo una classe Planet o una struct non statica. E poiché ci sono anche dei pianeti reali, qualche forma di metodo statico per popolare quella classe sarebbe appropriata. Potresti creare una nuova sottoclasse per ogni pianeta standard, oppure potresti creare un metodo statico distinto per ogni pianeta, ma penso che entrambi i modelli introducano troppa complessità.

Un semplice singolo statico 'IPlanet statico GetPlanet (nome stringa)' dovrebbe essere sufficiente per l'interfaccia, e la codifica hard dei valori racchiusi all'interno di una struttura di controllo è più che abbastanza complessa. Se un metodo di otto o nove diramazioni ti sembra troppo complesso, puoi sempre percorrere la strada pulita e includere semplicemente un file XML con i dati nell'assembly.

Naturalmente, se i tuoi "pianeti" avessero davvero metodi e comportamenti interni diversi, sarebbero appropriate classi diverse ... ma un singolo metodo "GetPlanet" sarebbe comunque un modo giusto per selezionarle.

In particolare, sembra che questo si adatti esattamente al schema dei pesi volanti . Molte delle risposte lo hanno implementato in vari modi. Conoscere il nome del modello può aiutarti a ricercare altri possibili approcci.

Simile a Stephen, ma per un'API più pulita, usa un enum per i pianeti ed eredita PlanetManager dal Dizionario. Mi piace così:

public enum SolSystemPlanet { Earth }

public class PlanetManager : Dictionary<SolSystemPlanet, Planet>
{
    new public Planet this[SolSystemPlanet planet]
    {
        get 
        {
            if (!this.ContainsKey(planet))
                this.Add(planet, Create(planet));

            return base[planet];
        }
    }

    private static Planet Create(SolSystemPlanet planet)
    {
        switch (planet)
        {
            case SolSystemPlanet.Earth:
                return new Earth();
            default:
                throw new ArgumentException("Planet Not Supported");
        }
    }
}

Il risultato finale è che ottieni pianeti in questo modo:

PlanetManager planets = new PlanetManager();
Console.WriteLine(planets[SolSystemPlanet.Earth].ToString());