Valeurs locales immuables en c# - un cas d'utilisation spécifique

Question

Je sais que ce sujet général a déjà été abordé ici. Ce qui m'intéresse, c'est de savoir s'il existe une bonne solution pour mon cas spécifique :

J'ai un outil en ligne de commande comme celui-ci (simplifié) :

static void Main(string[] args)
{
    if (args.Length < 2)
    {
        Console.WriteLine("Usage: MyTool <InputFolder> <OutputFolder>");
        return;
    }

    string inputFolder = args[0];
    string outputFolder = args[1];

    // ...
}

J'attribue des noms aux valeurs des arguments pour rendre le code plus lisible. Je tiens également à exprimer que ces valeurs ne seront pas modifiées ultérieurement.

Ni l'un ni l'autre const ni readonly peut être utilisé ici parce que les valeurs ne sont pas connues au moment de la compilation et parce qu'il s'agit de "variables" locales et non de membres de la classe.

Alors, comment puis-je rendre ce code plus expressif et plus lisible ?

Answer 1

Ma proposition est de créer une classe contenant vos variables

public class Immutable
{
    public Immutable(string[] args)
    {
         InputFolder = args[0];
         OutputFolder = args[1];
    }
    public readonly string InputFolder;
    public readonly string OutputFolder;
}

puis

var m = new Immutable(args)

Answer 2

Qu'en est-il du C# 7.2 ref readonly ?

static void Main(string[] args)
{
    if (args.Length < 2)
    {
        Console.WriteLine("Usage: MyTool <InputFolder> <OutputFolder>");
        return;
    }

    ref readonly var inputFolder = ref args[0];
    ref readonly var outputFolder = ref args[1];
}

Answer 3

Vous pourriez créer une sorte de classe Inputs où vous pourriez analyser le tableau en ses parties et rendre les propriétés qui exposent les valeurs analysées en lecture seule. Exemple simple :

public class Inputs {
    private string[] _args;

    public string InputFolder { get { return _args[0]; } }
    public string OutputFolder { get { return _args[1]; } }

    public Inputs(string[] args) { _args = args.Clone(); }

}

Answer 4

Je ferais quelque chose comme ça :

public class ImmutableObject
{
    public ImmutableObject(string inputFolder, string outputFolder)
    {
        InputFolder = inputFolder;
        OutputFolder = outputFolder;
    }

    public string InputFolder {get;}
    public string OutputFolder {get;}
 }

static void Main(string[] args)
{
    if (args.Length < 2)
    {
        Console.WriteLine("Usage: MyTool <InputFolder> <OutputFolder>");
        return;
    }

    var folders = new ImmutableObject(args[0], args[1]);

    // ...
}

Answer 5

Vous parlez de variables locales.
string est déjà un type immuable. Les valeurs de inputFolder y outputFolder ne changera jamais. Bien sûr, vous pouvez lui attribuer de nouvelles valeurs, mais vous êtes à l'intérieur d'une méthode, quelle taille cette méthode doit-elle avoir pour que vous oubliiez de ne pas lui attribuer de nouvelles valeurs.

Si des valeurs doivent être transmises à d'autres méthodes, elles seront transmises en tant que copies, de sorte que ce qui se passe à l'intérieur d'une méthode n'affectera pas les valeurs réelles de la méthode. inputFolder y outputFolder .

Si vous tenez toujours à ce que ces valeurs soient immuables, envisagez d'utiliser des types conçus pour être immuables.

Tuples de valeurs

(Input string, Output string) folders = (args[0], args[1]);

// Usage
folders.Input
folders.Output  

Ou dictionnaire immuable (nécessite le paquet NuGet System.Collections.Immutable)

var folders = 
    new ImmutableDictionary<string, string>().Add("input", args[0])
                                             .Add("output", args[1]);

// Usage
folders["input"]
folders["output"]