public static string MontoEscrito(this decimal monto, monedaMontoEscrito moneda, idiomaMontoEscrito idioma)
{
string regreso = "";
if (moneda == monedaMontoEscrito.Rec)
{
return("Moneda No Definida Correctamente");
}
switch (idioma)
{
case idiomaMontoEscrito.Español:
regreso = monto.MontoEscritoEspanol(moneda);
break;
case idiomaMontoEscrito.Ingles:
regreso = monto.MontoEscritoIngles(moneda);
break;
default:
regreso = "Idioma No Definido";
break;
}
return(regreso.ToUpper().Trim().Replace(" ", " "));
}
private static string MontoEscritoIngles(this decimal monto, monedaMontoEscrito moneda)
{
string regreso = "";
string ls_cadena;
string ls_aux = "";
int li_terna = 0;
int li_unidad;
int li_decena;
int li_centena;
bool lb_todoCeros;
bool lb_soloLaUnidad;
string[] ls_unidades = { "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" };
string[] ls_decenas = { "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety" };
string[] ls_decenas1 = { "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen" };
// Recogemos la parte entera y la fracción.
decimal ldc_entero = Math.Truncate(monto);
int li_fraccion = monto.ParteDecimal(2);
while (ldc_entero > 0)
{
// Indicamos la terna actual.
li_terna++;
// Se recorre el número por ternas.
ls_cadena = "";
li_unidad = (int)Math.Truncate((ldc_entero % 10));
ldc_entero = Math.Truncate(ldc_entero / 10);
li_decena = (int)(ldc_entero % 10);
ldc_entero = Math.Truncate(ldc_entero / 10);
li_centena = (int)(ldc_entero % 10);
ldc_entero = Math.Truncate(ldc_entero / 10);
// Se analizan las unidades.
if (li_unidad != 0)
{
ls_cadena = ls_unidades[li_unidad - 1] + " ";
}
switch (li_decena)
{
case 1:
switch (li_unidad)
{
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
ls_cadena = ls_decenas1[li_unidad] + " ";
break;
}
break;
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
ls_cadena = ls_decenas[li_decena - 1] + " " + ls_cadena;
break;
} // Final del switch (li_decena)
// Se analizan las centenas.
switch (li_centena)
{
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
ls_cadena = ls_unidades[li_centena - 1] + " hundred " + ls_cadena;
break;
}
// Analizamos la terna.
lb_todoCeros = ((li_unidad + li_decena + li_centena) == 0);
lb_soloLaUnidad = ((li_unidad == 1) && ((li_decena + li_centena) == 0));
switch (li_terna)
{
case 2:
if (!lb_todoCeros)
{
if (lb_soloLaUnidad)
{
ls_cadena = "thousand ";
}
else
{
ls_cadena += "thousand ";
}
}
break;
case 3:
if (!lb_todoCeros)
{
if (lb_soloLaUnidad)
{
ls_cadena += "million ";
}
else
{
ls_cadena += "millions ";
}
}
break;
case 4:
if (lb_soloLaUnidad)
{
ls_cadena = "thousand millions ";
}
else
{
ls_cadena += "thousand millions ";
}
break;
default:
if (li_terna != 1)
{
ldc_entero = 0;
ls_cadena = "";
}
break;
}
// Se monta el sultado de la terna actual con el de las anteriores.
regreso = ls_cadena + regreso;
} // Final del while (ldc_entero > 0)
// Utilizamos la recursividad para montar el literal de los decimales.
if (li_fraccion != 0)
{
ls_aux = ((decimal)li_fraccion).MontoEscritoIngles(monedaMontoEscrito.Rec); //("-RECURSIVIDAD-");
if (li_fraccion == 1)
{
ls_aux = "one cent";
}
else
{
ls_aux += " cents";
}
}
// Montamos la salida final según corresponda.
if (li_terna == 0)
{
// Solo tiene parte decimal.
regreso = ls_aux;
}
else
{
// Hay que añadir el modificar 'de' si es multiplo
// de 1000000.
//If mod(truncate(adec_monto, 0), 1000000)= 0 Then ls_regreso+= 'DE '
if ((Math.Truncate(monto)) % 1000000 == 0)
{
regreso += "DE ";
}
// Añadimos la moneda a la parte entera.
switch (moneda)
{
case monedaMontoEscrito.Rec:
break;
case monedaMontoEscrito.Euros:
if (Math.Truncate(monto) == 1)
{
regreso = "ONE EURO";
}
else
{
regreso += "EUROS";
}
break;
case monedaMontoEscrito.Pesos:
if (Math.Truncate(monto) == 1)
{
regreso = "ONE PESO";
}
else
{
regreso += "PESOS";
}
break;
case monedaMontoEscrito.USD:
if (Math.Truncate(monto) == 1)
{
regreso = "ONE DOLLAR";
}
else
{
regreso += "DOLLARS";
}
break;
case monedaMontoEscrito.Bs:
if (Math.Truncate(monto) == 1)
{
regreso = "ONE BOLIVAR";
}
else
{
regreso += "BOLÍVARES";
}
break;
default:
if (Math.Truncate(monto) == 1)
{
regreso = "ONE BOLIVAR";
}
else
{
regreso += "BOLÍVARES";
}
break;
} // final del switch (moneda.ToUpper().Trim())
// Hay que añadir la parte decimal si la tiene.
if (ls_aux != "")
{
regreso = regreso.Trim() + " and " + ls_aux;
}
}
return(regreso);
}
private static string MontoEscritoEspanol(this decimal monto, monedaMontoEscrito moneda)
{
string[] ls_unidades = { "UN", "DOS", "TRES", "CUATRO", "CINCO", "SEIS", "SIETE", "OCHO", "NUEVE" };
string[] ls_decenas = { "", "", "TREINTA", "CUARENTA", "CINCUENTA", "SESENTA", "SETENTA", "OCHENTA", "NOVENTA" };
string[] ls_centenas = { "", "DOSCIENTOS", "TRESCIENTOS", "CUATROCIENTOS", "QUINIENTOS", "SEISCIENTOS", "SETECIENTOS", "OCHOCIENTOS", "NOVECIENTOS" };
string[] ls_decenas1 = { "DIEZ", "ONCE", "DOCE", "TRECE", "CATORCE", "QUINCE", "DIECISEÍS" };
string[] ls_decenas2 = { "VEINTE", "VEINTIÚN", "VEINTIDÓS", "VEINTITRÉS", "", "", "VEINTISÉIS" };
/////////////////////////////////////////////////////////////////////////////////////////////////////
// Obtiene la parte entera y la fracción. //
/////////////////////////////////////////////////////////////////////////////////////////////////////
decimal ldc_entero = Math.Truncate(monto);
int li_fraccion = monto.ParteDecimal(2);
int li_terna = 0;
int li_unidad = 0;
int li_decena = 0;
int li_centena = 0;
string ls_cadena;
string ls_regreso = "";
string ls_aux = "";
bool lb_todoCeros, lb_soloLaUnidad;
while (ldc_entero > 0)
{
// Indicamos la terna actual.
li_terna++;
// Se recorre el número por ternas.
ls_cadena = "";
li_unidad = (int)(ldc_entero % 10);
ldc_entero = Math.Truncate(ldc_entero / 10);
li_decena = (int)(ldc_entero % 10);
ldc_entero = Math.Truncate(ldc_entero / 10);
li_centena = (int)(ldc_entero % 10);
ldc_entero = Math.Truncate(ldc_entero / 10);
//// Se analizan las unidades.
if (li_unidad != 0)
{
ls_cadena = ls_unidades[li_unidad - 1] + " ";
}
// Se analizan las decenas.
switch (li_decena)
{
case 1:
switch (li_unidad)
{
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
ls_cadena = ls_decenas1[li_unidad] + " ";
break;
default:
ls_cadena = "DIECI" + ls_cadena;
break;
}
break;
case 2:
switch (li_unidad)
{
case 0:
case 1:
case 2:
case 3:
case 6:
ls_cadena = ls_decenas2[li_unidad] + " ";
break;
default:
ls_cadena = "VEINTI" + ls_cadena;
break;
}
break;
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
if (li_unidad == 0)
{
ls_cadena = ls_decenas[li_decena - 1] + " " + ls_cadena;
}
else
{
ls_cadena = ls_decenas[li_decena - 1] + " Y " + ls_cadena;
}
break;
}
// Se analizan las centenas.
switch (li_centena)
{
case 1:
if (li_unidad == 0 && li_decena == 0)
{
ls_cadena = "CIEN ";
}
else
{
ls_cadena = "CIENTO " + ls_cadena;
}
break;
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
case 9:
ls_cadena = ls_centenas[li_centena - 1] + " " + ls_cadena;
break;
}
// Analizamos la terna.
lb_todoCeros = ((li_unidad + li_decena + li_centena) == 0);
lb_soloLaUnidad = ((li_unidad == 1) && ((li_decena + li_centena) == 0));
switch (li_terna)
{
case 2:
if (!lb_todoCeros)
{
if (lb_soloLaUnidad)
{
ls_cadena = "MIL ";
}
else
{
ls_cadena += "MIL ";
}
}
break;
case 3:
if (!lb_todoCeros)
{
if (lb_soloLaUnidad)
{
ls_cadena += "MILLÓN ";
}
else
{
ls_cadena += "MILLONES ";
}
}
break;
case 4:
if (lb_soloLaUnidad)
{
ls_cadena = "MIL MILLONES ";
}
else
{
ls_cadena += "MIL MILLONES ";
}
break;
default:
if (li_terna != 1)
{
ldc_entero = 0;
ls_cadena = "";
}
break;
}
// Se monta el sultado de la terna actual con el de las anteriores.
ls_regreso = ls_cadena + ls_regreso;
} // Final de While
// Utilizamos la recursividad para montar el literal de los decimales.
if (li_fraccion != 0)
{
// Como se retorno como parte entera llega con EURO/EUROS y hay que quitarlo.
// choose case upper(trim(as_moneda))
// case "EUROS"
// ls_aux = trim(left(ls_aux, len(ls_aux) - 5))
// case else
// ls_aux = trim(left(ls_aux, len(ls_aux) - LEN(as_moneda)))
// end choose
ls_aux = ((decimal)li_fraccion).MontoEscritoEspanol(monedaMontoEscrito.Rec); // ("-RECURSIVIDAD-");
if (li_fraccion == 1)
{
ls_aux = "UN CÉNTIMO";
}
else
{
ls_aux += " CÉNTIMOS";
}
}
// Montamos la salida final según corresponda.
if (li_terna == 0)
{
// Solo tiene parte decimal.
ls_regreso = ls_aux;
}
else
{
// Hay que añadir el modificar "de" si es multiplo
// de 1000000.
if (((Math.Truncate(monto)) % 1000000) == 0)
{
// Añadimos la moneda a la parte entera.
ls_regreso += "DE ";
}
switch (moneda)
{
case monedaMontoEscrito.Rec:
break;
case monedaMontoEscrito.Euros:
if (Math.Truncate(monto) == 1)
{
ls_regreso = "UN EURO";
}
else
{
ls_regreso += "EUROS";
}
break;
case monedaMontoEscrito.Pesos:
if (Math.Truncate(monto) == 1)
{
ls_regreso = "UN PESO";
}
else
{
ls_regreso += "PESOS";
}
break;
case monedaMontoEscrito.USD:
if (Math.Truncate(monto) == 1)
{
ls_regreso = "UN DOLAR";
}
else
{
ls_regreso += "DÓLARES";
}
break;
case monedaMontoEscrito.Bs:
if (Math.Truncate(monto) == 1)
{
ls_regreso = "UN BOLIVAR";
}
else
{
ls_regreso += "BOLÍVARES";
}
break;
default:
if (Math.Truncate(monto) == 1)
{
ls_regreso = "UN BOLIVAR";
}
else
{
ls_regreso += "BOLÍVARES";
}
break;
} // final switch (moneda)
if (ls_aux != "")
{
ls_regreso = ls_regreso.Trim() + " CON " + ls_aux;
}
}
return(ls_regreso);
}