Tanti anni fa... l'MS-DOS
Per diversi anni il sistema operativo DOS è stato uno dei più usati. Era uno dei primi, se non il primo, sistema operativo di massa montato sui PC che man mano si stavano diffondendo nella società.
Era un sistema operativo senza interfaccia grafica e quindi testuale molto diverso da quello che oggi noi conosciamo come Sistema Operativo (per esempio Windows).
L'MS-DOS era composto principalmente da un file il Command.com, o interprete dei comandi, che si incaricava di gestire i comandi impartiti dall'utente, di mostrare messaggi d'errore e così via.
Oltre questa struttura di base c'erano ulteriori comandi di contorno più evoluti come deltree.exe, tree.exe, ecc.
Ad oggi il Command.com (16-bit) è stato rimpiazzato nei sistemi Windows da un'interprete più potente Cmd.exe a 32-bit.
Ma non vi siete mai chiesti com'è possibile creare questi programmi lanciati da linea di comando (del prompt) ?
Ebbene così come Visual Studio 6.0 anche la versione 7.0 del rinnovato ambiente Microsoft oltre a permettere la costruzione di applicazioni evolute come Web Applications, Web Services e Win Forms permette anche di creare questo tipo di applicazioni che sono chiamate Console Applications.



Struttura di una Console Application
Un'applicazione di questo tipo utilizza principalmente due Stream, due flussi, uno in Input e uno in Output rispettivamente per prendere i dati dall'esterno inseriti dall'utente e per stampare a schermo i risultati delle elaborazioni e i dati.
A questi due Stream se ne affianca un terzo che è Error che permette di segnalare in Output degli errori. Riepilogando gli Stream utilizzati sono i seguenti:

• Input Stream In


• Output Stream In


• Error Stream In

Questi Stream sono implementati tramite le proprietà In, Out ed Err della classe System.Console e non rappresentano altro che degli Stream classici System.IO.TextReader per quanto riguarda In e System.IO.TextWriter per quanto riguarda gli altri due.
I dati in ingresso e uscita vengono rappresentati a schermo ma potrebbero essere usati anche degli Stream ad hoc e scrivere i dati in uscita per esempio su disco.

Inoltre per avviarsi un'applicazione Console necessità di una funzione Main di avvio che ha fra i suoi parametri un array di stringhe, vediamo il prototipo qui sotto:


static void Main(string[] args)
{

//Scrivete qui il vostro codice

return;
}


Avrete tutti usato comandi come copy, xcopy o simili. Sapete benissimo che accettano diversi parametri o switch anche contemporaneamente come per esempio copy *.* c:\windows o più semplicemente xcopy /?.
Ebbene questi parametri sono quelli che vanno a finire nell'array di stringhe che è parametro della funzione Main.

Possiamo cominciare a fare dei primi test e costruire un ciclo for per stampare l'elenco dei parametri in ingresso:


static void Main(string[] args)
{
for (int i=0;iConsole.WriteLine("Parametro: {0}",args);
}


Se lanciate in questo momento l'applicazione, non ci saranno parametri impostati e quindi non verrà stampato niente a schermo.
Andiamo quindi ad impostare dei parametri di test, dal Menù Project->Properties di Visual Studio .NET, e poi selezionate la cartella Configuration Properties->Debugging.
Inserite nella casella Command Line Arguments i seguente parametri: par1 par2 par3 come rappresentato qui sotto:

Impostazione dei parametri per la linea di comando

Ora è possibile lanciare per la prima volta il nostro programma.
L'output dovrebbe essere il seguente:

Il programma in esecuzione

Input e Output - Console.ReadLine e Console.WriteLine
Come abbiamo detto precedentemente la classe Console ci mette a disposizione i metodi per interagire con l'utente e per raccogliere l'input da tastiera e rappresentare l'output delle nostre elaborazioni.
Vedremo qui di seguito quindi come utilizzare queste istruzioni.


Console.Write("Inserisci il tuo nome: ");
string nome=Console.ReadLine();

Console.Write("Inserisci il tuo cognome: ");
string cognome=Console.ReadLine();

Console.Write("Il tuo nome completo è : {0} {1}",nome,cognome);


Questo esempio non fa altro che stampare rispettivamente "Inserisci il tuo nome" e poi "Cognome" e prendere in Input dall'utente i dati che verranno inseriti nella due variabili di tipo stringa.
Per finire la Write stampera il nome completo a schermo.
Se andate a vedere nella guida del Framwork le funzioni Write e Writeline hanno diversi Overload proprio per stampare qualsiasi cosa (interi, long, stringhe, ecc.).
Come vedete il codice è molto semplice e comprensibile e apre scenari per eventuali estensioni e evoluzioni per programmi ben più complessi di questo, così come il deltree.exe o l'xcopy.exe.

Volendo potete controllare se fra i parametri in ingresso c'è n'è almeno uno di questo tipo "/?" oppure "/h" ed in caso positivo stampare a schermo la guida del comando oppure se sono usati più parametri incompatibili in combinazione arrestare il programma e segnalare gli errori all'utente.

Conclusioni
Come vedete anche in questo caso con poche istruzioni riuscite ad avere un'applicazione perfettamente funzionante. Anche se questo tipo di applicazioni non viene più usato dagli utenti comuni è una soluzione molto usata dagli amministratori di rete per automatizzare molte procedure, e quindi un'alternativa ai classici script.
Gli script sono molto flessibili ma anche loro hanno un limite. In questo modo potete spaziare e creare i vostri comandi ad hoc in modo che rispondano completamente alle vostre esigenze.