statique de la classe abstraite

J'ai besoin d'un moyen de créer une classe statique où certaines constantes peuvent être spécifique à chaque cas, mais codé en dur.

Ce que je veux vraiment faire est d'avoir une classe où plusieurs constantes sont fournis lorsque la classe est étendue - je veux les constantes codée en dur. J'ai pensé que je vais faire de l'abstrait propriétés et définir le get { return constante; } lors de l'extension de la classe.

Je sais que c'est pas possible, alors maintenant, je suis confronté à deux options et je me demande ce qui serait le mieux et pourquoi (si il y a des options qui me manque, s'il vous plaît laissez-moi savoir!)

1. Créer une classe statique avec nullable champs et de lever une exception si les champs sont nuls lorsque la méthode statique est appelé.
2. Abandonner la classe statique. Non statique de la classe avec le résumé des propriétés et de créer une instance de l'objet partout où j'en ai besoin, même si toutes les fonctionnalités est vraiment statique.

Je sais que cela peut-être très subjectif et dépendant, mais je vais tourner en rond en pensant à cela et peut vraiment faire avec un peu d'intrants externes. Qu'en plus, je l'espère, il peut y avoir loin de faire ce que je veux et j'en suis juste à penser que c'est mal.

Mise à jour: Code: je vais essayer d'écrire un peu de code qui décrit ce que j'aimerais faire. Je sais que ce code ne peut pas marcher!

Imaginer que la classe abstraite de Calcul se trouve dans une dll, utilisé par de nombreux projets. La fonctionnalité est la même pour toutes, seulement la Constante varie d'un projet à.

public abstract static class Calculation
{
    private abstract int Constant { get; }    //The constant is unknown at this time

    public static int Calculate(int inputValue)
    {
        return inputValue * Constant;
    }
}

La classe Calc est définie dans un projet distinct, où la fonctionnalité est nécessaire et la Constante est connue.

public static class Calc : Calculation
{
    private override int Constant { get { return 2; }
}

...

static class Program
{
    [STAThread]
    static void Main()
    {
        //At some point:
        int result = Calc.Calculate(6);
    }
}

Je suppose que le plus simple serait de créer un non-statique de la classe et de créer une instance, cependant j'ai peur d'avoir plusieurs instances de la classe pourrait être coûteux et voudrais éviter si possible.

Je ne vois pas comment je pourrais écrire cela comme un pattern singleton sans l'écrire à nouveau dans chaque projet ayant seulement la Imbriquée classe dans la dll. Qui n'empêche pas le réalisateur de créer une classe ordinaire et est susceptible de relancer le débat, pour chaque projet, d'où le code est utilisé.

Mise à jour #2 : Ce que je ment avec l'option est celui-ci:

Classe dans une dll:

public static class Calculation 
{
    public int? Constant {get; set;}

    public static int Calculate(int inputValue)
    {
        if (Constant == null)
            throw new ArgumentNullException();

        return inputValue * (int)Constant;
    }
}

Utilisation de la fonction dans un autre projet:

static class Program
{
    [STAThread]
    static void Main()
    {
        //At some point:
        Calculation.Constant = 2;
        int result = Calc.Calculate(6);
    }
}

Option est très simple et élégant, ce qui me dérange à propos de ça que rien forces l'implémenteur de définir la Constante. J'ai peur d'un (certes peu probable) scénario où un coin obscur de cas sera la cause de la propriété de ne pas être ensemble et pour le code à l'échec (et de la Constante étant le dernier suspect)...

OriginalL'auteur David Božjak | 2011-09-13