clases abstractas, Interfaces y enumeraciones PARTE II

LA IMPLEMENTACION
Creemos un proyecto de consola:

Y generemos en el 4 módulos denominados AnalizaArgumentos, Analizador, OcurrenciaPalabra y WordCount.-
El código de las clases que se montan en cada modulo esta en las paginas siguientes.-
Luego para utilizarlo genere archivos de texto e invoque en la línea de comandos a los mismos con las opciones que desee.-


Por ejemplo colocando esto en la ventana de propiedades del proyecto en la opción DEBUG:
-a -o Texto.txt Conecciones.txt -fSalida.txt


Esto es interpretado por el programa asi:
-a: Un switch que significa ORDENADO ALFABETICAMENTE


-o: Un switch que significa ORDENADO por OCURRENCIA y luego ALFABETICAMENTE


Texto.txt Conecciones.txt: Son dos archivos de texto, que estan en el paso de ejecucion (o en el directorio de trabajo en el que estamos ya que en el ejemplo marcamos C:\M3)


-fSalida.txt: Es un archivo de salida de la información que genera WordCount. La alternativa por defecto es la pantalla de texto.-






La clase Abstracta Analizador
/*=====================================================================
Archivo: Analizador.cs
Esta clase tiene el cuerpo basico para trabajar como un analizador de
* argumentos para un programa que admite parametros en su invocacion
* desde la linea de comandos. Los parametros, se asume, comienzan con
* llaves (switchs) que indican alguna particularidad del mismo.
* Un ejemplo valido seria
* c:\prog1.exe -eArchivo.txt -sSalida.txt
* Donde prog1.exe es el programa que se ejecuta y tanto -eArchivo.txt
* como -sSalida.txt son los argumentos
* -e (antes de Archivo.txt) y -s (antes de Salida.txt) son las llaves.
*

=====================================================================*/

//
using System;
using System.Globalization;


///////////////////////////////////////////////////////////////////////////////


public abstract class Analizador {
private String[] separadores; // Por defecto: "/", "-"
private String[] argumentos; // Estos son los argumentos validos
//que el analizador debe reconocer
private Boolean argSensiblesAMayOMin; // Indica si los argumentos deben ser sensibles a Mayusculas/Minusculas


//
protected enum SwitchStatus { NoError, Error, ShowUsage };


// Constructor 1
public Analizador(String[] switchSymbols)
: this(switchSymbols, false, new string[] { "/", "-" }) {
}


// Constructor 2
public Analizador(String[] switchSymbols, Boolean caseSensitiveSwitches)
: this(switchSymbols, caseSensitiveSwitches, new string[] { "/", "-" }) {
}


// Constructor 3, sin valores por defecto
public Analizador(String[] _argumentos, Boolean _argSensiblesAMayOMin, String[] switchChars)
{
this.argumentos = _argumentos;
this.argSensiblesAMayOMin = _argSensiblesAMayOMin;
this.separadores = switchChars;
}


// -
public abstract void ModoDeUso(String errorInfo);



protected virtual SwitchStatus OnSwitch(String switchSymbol, String switchValue) {
return(SwitchStatus.Error);
}



// Cada clase derivada debe implementar el metodo OnNonSwitch
//observe que sino por defecto un switch se considera un error
protected virtual SwitchStatus OnNonSwitch(String value) {
return(SwitchStatus.Error);
}


// Informamos a la clase derivada despues que se hizo todo el analisi
// -
protected virtual SwitchStatus OnDoneParse() {
// -
return(SwitchStatus.Error);
}


// Solo sabemos analizar argumentos de la linea de comandos
public Boolean Parse() {
return(Parse(Environment.GetCommandLineArgs()));
}


// Este es el analizador
public Boolean Parse(String[] args) {
SwitchStatus ss = SwitchStatus.NoError; //

int ArgNum;
for (ArgNum = 0; (ss == SwitchStatus.NoError) && (ArgNum < fisswitch =" false;" n =" 0;" fisswitch =" (0" flegalswitchsymbol =" false;" n =" 0;" flegalswitchsymbol =" (0" flegalswitchsymbol =" (0"> salir
if (!fLegalSwitchSymbol) {

ss = SwitchStatus.Error;
break;
} else {
// Switch valido -> notificar a la clase derivada el switch y su valor
ss = OnSwitch(
argSensiblesAMayOMin ? argumentos[n] : argumentos[n].ToLower(CultureInfo.InvariantCulture),
args[ArgNum].Substring(1 + argumentos[n].Length));
}
}
else // Esto no es un switch, retornar a la clase derivada para que lo analice
{
ss = OnNonSwitch(args[ArgNum]);
}
}

// Fin del analisis de los argumentos
if (ss == SwitchStatus.NoError) {
// -
ss = OnDoneParse();
}

if (ss == SwitchStatus.ShowUsage) {
//
ModoDeUso(null);
}

if (ss == SwitchStatus.Error) {
//
ModoDeUso((ArgNum == args.Length) ? null : args[ArgNum]);
}

// -
return(ss == SwitchStatus.NoError);
}
}


///////////////////////////////// End of File /////////////////////////////////