Gli engine
Qui le cose sembrano complicarsi, la struttura delle classi risulta più complessa, ma solo in apparenza. Per comprenderla meglio e necessario conoscere il modo in cui i programmi sono stati modificati nel corso del tempo.
Agli inizi l'unica parte in comune ai vari programmi era la gestione della riga di comando, ognuno gestiva all'interno del Program.cs tutta la parte di lavorazione delle immagini, con l'eccezione dei due tool per gli astucci (Scatola e Cartella) che avevano una parte in comune: il "builder".
Quando è stata introdotta l'interfaccia grafica è stato necessario estrapolare le varie funzioni di creazione ed inserirle nella libreria comune creando gli "engine"; per mantenere uniformità di interfaccia è stato necessario creare dei wrapper attorno ai builder (che hanno mantenuto la struttura riportata nel diagramma qui sotto).
Ecco perchè i due engine degli astucci hanno un livello di struttura più profondo sia a livello di classi che di interfaccia.
Gli engine hanno due costruttori, uno senza parametri che viene utilizzato dalla GUI:
/// Constructor
/// </summary>
public MontaggioFotoEngine() : base()
{
parameters = new MontaggioFotoParameters();
ScriptingClass = new MontaggioFotoScripting();
}
Ed uno che prende come parametro una istanza della classe CommandLine utilizzato dai tool a linea di comando:
/// Constructor
/// </summary>
/// <param name="par"></param>
public MontaggioFotoEngine(CommandLine par) : base(par)
{
parameters = new MontaggioFotoParameters();
MontaggioFotoCommandLine p = (MontaggioFotoCommandLine)par;
FullSize = p.FullSize ? true : FullSize;
Trim = p.Trim ? true : Trim;
WithBorder = p.WithBorder ? true : WithBorder;
Padding = p.Padding;
ScriptingClass = new MontaggioFotoScripting();
Script = p.Script;
}
Un'altra coppia di metodi gestisce i parametri in formato JSON; la prima deserializza il file e scrive i parametri all'interno dell'engine.
Viene utilizzata dalla GUI per il passaggio delle opzioni dai controlli delle form o dalla lettura di un file, e dalla riga di comando quando viene utilizzato il parametro --json.
/// Sets the parameters from json formatted string
/// </summary>
/// <param name="json"></param>
public override void SetJsonParams(string json)
{
MontaggioFotoParameters p = JsonSerializer.Deserialize<MontaggioFotoParameters>(json);
parameters = p;
SetBaseJsonParams();
FullSize = p.FullSize;
WithBorder = p.WithBorder;
Trim = p.Trim;
Padding = p.Padding;
Script = p.Script;
}
L'altro metodo esegue la serializzazione dei parametri su un file ed è utilizzato solo dalla GUI quando effettua il salvataggio delle impostazioni:
/// Returns the parameters in json format
/// </summary>
/// <returns></returns>
public override string GetJsonParams()
{
GetBaseJsonParams();
MontaggioFotoParameters p = (MontaggioFotoParameters)parameters;
p.FullSize = FullSize;
p.WithBorder = WithBorder;
p.Trim = Trim;
p.Padding = Padding;
return JsonSerializer.Serialize(p);
}
Tutto questo in preparazione del metodo principe che è quello che alla fine, sulla base dei dati raccolti, esegue il lavoro vero e proprio:
/// Does the dirty work
/// </summary>
/// <returns>Image to print</returns>
MagickImage GetResult();
/// <summary>
/// Does the dirty work
/// </summary>
/// <param name="quiet">suppress messages when running</param>
/// <returns>Image to print</returns>
MagickImage GetResult(bool quiet);
Ovviamente ogni classe specializzata ne esegue l'override per le sue funzioni specifiche, che meritano approfondimenti separati.