Question

My system currently runs in differents environments.

I got a Environment enum on my system, something like this

public enum Environment {

    [UsePayPal(false)]
    [ServerInstallDir("InstallPathOnServer")]
    [IntegrationSystemURI("localhost/someFakeURI")]
    [UpdateSomeInfo(true)]
    [QueuePrefix("DEV")]
    [UseCache(false)]
    [AnotherSystemURI("localhost/anotherFakeURI")]
    Development = 0,

    [UsePayPal(false)]
    [ServerInstallDir("InstallPathOnBUILDServer")]
    [IntegrationSystemURI("build-server/someFakeURI")]
    [UpdateSomeInfo(true)]
    [QueuePrefix("QA")]
    [UseCache(false)]
    [AnotherSystemURI("build-server/anotherFakeURI")]
    QA = 1,

    [UsePayPal(true)]
    [ServerInstallDir("InstallPathOnServer")]
    [IntegrationSystemURI("someservice.com/URI")]
    [UpdateSomeInfo(true)]
    [QueuePrefix("PRD")]
    [UseCache(true)]
    [AnotherSystemURI("anotherservice/URI")]
    Production = 2,
}

I’m working like this, because I dont like code like

if(CURRENT_ENVIRONMENT == Environment.QA || CURRENT_ENVIRONMENT == Environment.DEV)
    EnableCache()

or

if(CURRENT_ENVIRONMENT == Environment.QA || CURRENT_ENVIRONMENT == Environment.DEV){
    DoSomeStuff();
}

because I think that’s scatter my logic all over the system, and not on a single point.

If some day I add another Test Enviroment, I dont need to go all over my code to see if I work like on Development, QA or Production enviroment.

Ok, but, with all that config I may end up with too maby attributes on my Enum, lets say, in 3 years each enum value will have 15~20 attributes, and that looks weird.

What do you guys think? How do you usually handle this situation? Its really too many attributes, or thats ok?

Answer 1

Create an Environment class with a private constructor and as many properties as you need to describe the environment, and expose static readonly instances as public properties. You can also have an Environment.Current property that points to one of these instances.

Example code:

sealed class Environment
{
    // The current environment is going to be one of these -- 1:1 mapping to enum values
    // You might also make these properties if there's fine print pointing towards that
    public static readonly Environment TestEnvironment;
    public static readonly Environment ProductionEnvironment;

    // Access the environment through this
    public static Environment Current { get; set; }

    static Environment()
    {
        TestEnvironment = new Environment {
            UsePayPal = false,
            ServerInstallDir = "/test"
        };
        ProductionEnvironment = new Environment { 
            UsePayPal = true, 
            ServerInstallDir = "/prod"
        };
    }

    // Environment propeties here:
    public bool UsePayPal { get; private set; }
    public string ServerInstallDir { get; private set; }

    // We don't want anyone to create "unauthorized" instances of Environment
    private Environment() {}
}

Use it like:

Environment.Current = Environment.TestEnvironment;

// later on...
Console.WriteLine(Environment.Current.ServerInstallDir);