fonctionnalité partagée entre les applications de la console C #

Question

J'ai deux applications de console, Query et Update, qui partagent certaines fonctionnalités. Je souhaitais que les deux classes héritent d'une classe de base commune, mais le problème est que, pour une application console, je dois disposer d'une fonction static Main . Ce que j'ai actuellement est la suivante:

namespace Utils
{
    public class ConsoleBase
    {
        protected const int ERROR_EXIT_CODE = 1;
        protected static void printWarning(string msg) {...}
        public ConsoleBase(IEnumerable<string> args) { ... }
...

namespace Update
{
    class Update : ConsoleBase
    {
        private static ConsoleBase _consoleBase;
        public static void Main(string[] args) { ... }
...

namespace Query
{
    class Query : ConsoleBase
    {
        private static ConsoleBase _consoleBase;
        public static void Main(string[] args) { ... }
...

Cela me semble être un problème de conception: hériter de ConsoleBase et en avoir une instance en tant que variable statique au sein de chaque classe dérivée. La raison pour laquelle je le fais est que:

1. Je peux avoir des méthodes static définies dans ConsoleBase et accessibles à d'autres méthodes static dans les classes dérivées.
2. Je peux transmettre des arguments de ligne de commande au constructeur pour ConsoleBase , effectuer des tâches courantes, puis accéder à nouveau aux arguments dans les classes dérivées via des propriétés et méthodes public . sur l'instance de ConsoleBase .

Donc, dans les classes dérivées, j'ai un mélange d'appels de méthodes / propriétés sur l'instance de ConsoleBase , par exemple.

_consoleBase.UseDebugMode()

En plus d'appeler des méthodes statiques héritées et d'accéder aux constantes héritées définies dans ConsoleBase , par exemple.

printWarning(CONST_MSG_IN_BASE_CLASS);

Puis-je nettoyer cela en quelque sorte? Est-il mauvais à la fois d'hériter d'une classe et de conserver une instance de cette classe de base pour pouvoir travailler?

Answer 1

Ne mélangez pas les méthodes statiques et d'instance comme celle-ci.

Envisagez de séparer la responsabilité fournie par les méthodes statiques dans une classe différente dont vous pouvez hériter. Faites de la fonctionnalité non statique une classe distincte que vous agrégez et instanciez dans Update and Query.

En outre, si Update et Query sont des dérivés de ConsoleBase, pourquoi avez-vous besoin des instances agrégées?

Answer 2

Oui, vous pouvez définir une classe de base avec un principal statique protégé, puis appelez BaseClass.Main (args) à partir de la méthode Main des classes héritées.

Ce syntex est plus correct:

public class BaseApp
{
    public static Main(String[] args)
    {
        // TODO: ...
    }
}

public class App1 : BaseApp // Same for App2
{
    // There is no need to keep a reference of the base class
    // if you are accessing static methods only

    public static Main(String[] args)
    {
        BaseApp.Main(args); // Access via class, not via instance
    }
}

Answer 3

Je ne pense pas que vous ayez besoin de faire ça. Pourquoi n’appelez-vous pas simplement la fonction ConsoleBase.Main () avec vos arguments de ligne de commande?

Avoir une instance de la classe de base pose un problème de conception.