Quelle est la meilleure façon de mettre en œuvre une constante globale en C#?

Il dépend. Si c'est vraiment une constante qui ne change pas, même dans les futures versions de votre code, puis const est très bien. Sinon, avec un static readonly champ.

Un const va s'incruster dans la convocation de l'assemblée, alors qu'avec static readonly la convocation de l'assemblée ne contient qu'une référence sur le terrain. Cela signifie const nécessite la recompilation de tous les dépendants code chaque fois que vous modifiez la valeur, tandis que public readonly utilise la nouvelle valeur, même sans avoir à recompiler l'appel de l'assemblée.

Si vous souhaitez stocker de la "constante" dans un fichier de config, mais comme Intellisense, vous pouvez utiliser un bien public setter. Et puis le remplir à partir du fichier de configuration au moment de l'exécution. Mais je dirais que les valeurs de configuration ne doit pas être static en premier lieu. Pour les valeurs de configuration que j'avais utiliser un singleton, de la sorte, de préférence le Cio de la variation et de ne pas le Class.Instance variation. Donc, je venais de définir une interface comme suit:

interface IMyConfig
{
  string Key{get;}
}

Et des classes qui ont besoin de cette config le prendre comme un paramètre du constructeur:

public MyClass(IMyConfig config)
{
    ...
}

OriginalL'auteur CodesInChaos

Je ne suis pas sûr si je comprends complètement le problème... vous allez avoir une solution pour le stockage des variables globales qui ne cause pas de recompilation d'assemblages qui font référence à ces variables globales si vous les changer? Si oui, alors pourquoi ne pas essayer de penser à la refonte de votre architecture que par la L'Inversion de Contrôle principe? Penser "ne nous appelez pas, nous vous appellerons" le hollywood principe. Si toutes les assemblées qui nécessitent quelques const appelez simplement une interface (qui elles-mêmes) qui expose une propriété avec la valeur qu'ils exigent, et puis vous avez un projet de constantes de mise en œuvre de ceux de l'interface (par le référencement de ces projets et la mise en œuvre de ces interfaces) ensuite, ces projets n'aurez plus jamais besoin recompilling lorsque vous modifiez la valeur de la constante.

Je suis sûr que vous savez de toute façon mais ont une lire sur le De SOLIDES principes, "D" étant la Dépendance principe d'Inversion (Inversion de Contrôle). Je pense que compte tenu de vos préoccupations (en supposant que j'ai bien compris vous avez droit), ils pourraient vraiment vous aider.

Un exemple de l'Inversion de Contrôle pourrait être aussi simple que:

MyService.dll :

public class MyService
{

    //injected dependency
    public IMyConstants MyConstants { get; set; }

    public MyMethod(){

        //get your query...
        var query = IMyConstants.Query;
    }

}

MyConstants.dll :

public MyConstants : IMyConstants {

    //implementation of query property from the myservices.dll interface
    public string Query { ... }

}

De sorte que le myconstants.dll les références de la myservice.dll plutôt que l'inverse (sens myservices n'aurez pas besoin de recompiler). Ensuite, la phase de code (pour mettre tout cela en place, et injecter des dépendances) vie ailleurs.

Désolé si j'ai mal compris, de l'espoir qui aide bien!

OriginalL'auteur james lewis

Vous pouvez utiliser le Cache de l'objet et de le définir dans le Mondial.asax

OriginalL'auteur Barry Kaye