Pasar de Cantidad en Número a Letra

Como primer aporte para utilerias aporto este sitio.
Problema : Pasar una cantidad a letras, este en un problema que regularmente tenemos.
En las busquedas que hice encontre este Blog de VarioNet , donde hay una clase escrita en VB.Net y C#, que realiza la transformación de número a letra, También como se explica en el blog hay un proyecto para realizar el test unitario, Lo puedes obtener desde aquí,…
En caso de querer utilizar solamente la Clase

Clase en C#:


using System;
using System.Text;
using System.Globalization;


///

/// Convierte números en su expresión numérica a su numeral cardinal
///
public sealed class Numalet
{
#region Miembros estáticos

private const int UNI = 0, DIECI = 1, DECENA = 2, CENTENA = 3;
private static string[,] _matriz = new string[CENTENA + 1, 10]
{
{null,” uno“, “ dos“, “ tres“, “ cuatro“, “ cinco“, “ seis“, “ siete“, “ ocho“, “ nueve“},
{” diez“,” once“,” doce“,” trece“,” catorce“,” quince“,” dieciséis“,” diecisiete“,” dieciocho“,” diecinueve“},
{null,null,null,” treinta“,” cuarenta“,” cincuenta“,” sesenta“,” setenta“,” ochenta“,” noventa“},
{null,null,null,null,null,” quinientos“,null,” setecientos“,null,” novecientos“}
};

private const Char sub = (Char)26;
//Cambiar acá si se quiere otro comportamiento en los métodos de clase

public const String SeparadorDecimalSalidaDefault = “con“;
public const String MascaraSalidaDecimalDefault = “00′/100.-’“;
public const Int32 DecimalesDefault = 2;
public const Boolean LetraCapitalDefault = false;
public const Boolean ConvertirDecimalesDefault = false;
public const Boolean ApocoparUnoParteEnteraDefault = false;
public const Boolean ApocoparUnoParteDecimalDefault = false;

#endregion

#region Propiedades

private Int32 _decimales = DecimalesDefault;
private CultureInfo _cultureInfo = CultureInfo.CurrentCulture;
private String _separadorDecimalSalida = SeparadorDecimalSalidaDefault;
private Int32 _posiciones = DecimalesDefault;
private String _mascaraSalidaDecimal, _mascaraSalidaDecimalInterna = MascaraSalidaDecimalDefault;
private Boolean _esMascaraNumerica = true;
private Boolean _letraCapital = LetraCapitalDefault;
private Boolean _convertirDecimales = ConvertirDecimalesDefault;
private Boolean _apocoparUnoParteEntera = false;
private Boolean _apocoparUnoParteDecimal;

///

/// Indica la cantidad de decimales que se pasarán a entero para la conversión
///
/// Esta propiedad cambia al cambiar MascaraDecimal por un valor que empieze con ‘0′
public Int32 Decimales
{
get { return _decimales; }
set

{
if (value > 10) throw new ArgumentException(value.ToString() + “ excede el número máximo de decimales admitidos, solo se admiten hasta 10.“);
_decimales = value;
}
}

///

/// Objeto CultureInfo utilizado para convertir las cadenas de entrada en números
///
public CultureInfo CultureInfo
{
get { return _cultureInfo; }
set { _cultureInfo = value; }
}

///

/// Indica la cadena a intercalar entre la parte entera y la decimal del número
///
public String SeparadorDecimalSalida
{
get { return _separadorDecimalSalida; }
set

{
_separadorDecimalSalida = value;
//Si el separador decimal es compuesto, infiero que estoy cuantificando algo,
//por lo que apocopo el “uno” convirtiéndolo en “un”
if (value.Trim().IndexOf(” “) > 0)
_apocoparUnoParteEntera = true;
else _apocoparUnoParteEntera = false;
}
}

///

/// Indica el formato que se le dara a la parte decimal del número
///
public String MascaraSalidaDecimal
{
get
{
if (!String.IsNullOrEmpty(_mascaraSalidaDecimal))
return _mascaraSalidaDecimal;
else return ““;
}
set

{
//determino la cantidad de cifras a redondear a partir de la cantidad de ‘0′ o ‘#’
//que haya al principio de la cadena, y también si es una máscara numérica
int i = 0;
while (i < value.Length
&& (value[i] == ‘0′)
| value[i] == ‘#’)
i++;
_posiciones = i;
if (i > 0)
{
_decimales = i;
_esMascaraNumerica = true;
}
else _esMascaraNumerica = false;
_mascaraSalidaDecimal = value;
if (_esMascaraNumerica)
_mascaraSalidaDecimalInterna = value.Substring(0, _posiciones) + “

+ value.Substring(_posiciones)
.Replace(”“, sub.ToString())
.Replace(”“, String.Empty)
.Replace(sub.ToString(), ““) + ““;
else
_mascaraSalidaDecimalInterna = value
.Replace(”“, sub.ToString())
.Replace(”“, String.Empty)
.Replace(sub.ToString(), ““);
}
}

///

/// Indica si la primera letra del resultado debe estár en mayúscula
///
public Boolean LetraCapital
{
get { return _letraCapital; }
set { _letraCapital = value; }
}

///

/// Indica si se deben convertir los decimales a su expresión nominal
///
public Boolean ConvertirDecimales
{
get { return _convertirDecimales; }
set

{
_convertirDecimales = value;
_apocoparUnoParteDecimal = value;
if (value)
{// Si la máscara es la default, la borro
if (_mascaraSalidaDecimal == MascaraSalidaDecimalDefault)
MascaraSalidaDecimal = ““;
}
else if (String.IsNullOrEmpty(_mascaraSalidaDecimal))
//Si no hay máscara dejo la default

MascaraSalidaDecimal = MascaraSalidaDecimalDefault;
}
}

///
/// Indica si de debe cambiar “uno” por “un” en las unidades.
///

public Boolean ApocoparUnoParteEntera
{
get { return _apocoparUnoParteEntera; }
set { _apocoparUnoParteEntera = value; }
}

///

/// Determina si se debe apococopar el “uno” en la parte decimal
///
/// El valor de esta propiedad cambia al setear ConvertirDecimales
public Boolean ApocoparUnoParteDecimal
{
get { return _apocoparUnoParteDecimal; }
set { _apocoparUnoParteDecimal = value; }
}

#endregion

#region Constructores

public Numalet()
{
MascaraSalidaDecimal = MascaraSalidaDecimalDefault;
SeparadorDecimalSalida = SeparadorDecimalSalidaDefault;
LetraCapital = LetraCapitalDefault;
ConvertirDecimales = _convertirDecimales;
}

public Numalet(Boolean ConvertirDecimales, String MascaraSalidaDecimal, String SeparadorDecimalSalida, Boolean LetraCapital)
{
if (!String.IsNullOrEmpty(MascaraSalidaDecimal))
this.MascaraSalidaDecimal = MascaraSalidaDecimal;
if (!String.IsNullOrEmpty(SeparadorDecimalSalida))
_separadorDecimalSalida = SeparadorDecimalSalida;
_letraCapital = LetraCapital;
_convertirDecimales = ConvertirDecimales;
}
#endregion

#region Conversores de instancia

public String ToCustomCardinal(Double Numero)
{ return Convertir((Decimal)Numero, _decimales, _separadorDecimalSalida, _mascaraSalidaDecimalInterna, _esMascaraNumerica, _letraCapital, _convertirDecimales, _apocoparUnoParteEntera, _apocoparUnoParteDecimal); }

public String ToCustomCardinal(String Numero)
{
Double dNumero;
if (Double.TryParse(Numero, NumberStyles.Float, _cultureInfo, out dNumero))
return ToCustomCardinal(dNumero);
else throw new ArgumentException(”” + Numero + “‘ no es un número válido.“);
}

public String ToCustomCardinal(Decimal Numero)
{ return ToCardinal((Numero)); }

public String ToCustomCardinal(Int32 Numero)
{ return Convertir((Decimal)Numero, 0, _separadorDecimalSalida, _mascaraSalidaDecimalInterna, _esMascaraNumerica, _letraCapital, _convertirDecimales, _apocoparUnoParteEntera, false); }

#endregion

#region Conversores estáticos

public static String ToCardinal(Int32 Numero)
{
return Convertir((Decimal)Numero, 0, null, null, true, LetraCapitalDefault, ConvertirDecimalesDefault, ApocoparUnoParteEnteraDefault, ApocoparUnoParteDecimalDefault);
}

public static String ToCardinal(Double Numero)
{
return ToCardinal((Decimal)Numero);
}

public static String ToCardinal(String Numero, CultureInfo ReferenciaCultural)
{
Double dNumero;
if (Double.TryParse(Numero, NumberStyles.Float, ReferenciaCultural, out dNumero))
return ToCardinal(dNumero);
else throw new ArgumentException(”” + Numero + “‘ no es un número válido.“);
}

public static String ToCardinal(String Numero)
{
return Numalet.ToCardinal(Numero, CultureInfo.CurrentCulture);
}

public static String ToCardinal(Decimal Numero)
{
return Convertir(Numero, DecimalesDefault, SeparadorDecimalSalidaDefault, MascaraSalidaDecimalDefault, true, LetraCapitalDefault, ConvertirDecimalesDefault, ApocoparUnoParteEnteraDefault, ApocoparUnoParteDecimalDefault);
}

#endregion

private static String Convertir(Decimal Numero, Int32 Decimales, String SeparadorDecimalSalida, String MascaraSalidaDecimal, Boolean EsMascaraNumerica, Boolean LetraCapital, Boolean ConvertirDecimales, Boolean ApocoparUnoParteEntera, Boolean ApocoparUnoParteDecimal)
{
Int64 Num;
Int32 terna, centenaTerna, decenaTerna, unidadTerna, iTerna;
String cadTerna;
StringBuilder Resultado = new StringBuilder();

Num = (Int64)Math.Abs(Numero);

if (Num >= 1000000000000 || Num < 0) throw new ArgumentException(”El número ‘” + Numero.ToString() + “‘ excedió los límites del conversor: [0;1.000.000.000.000)");
if (Num == 0)
Resultado.Append(" cero");
else

{
iTerna = 0;
while (Num > 0)
{
iTerna++;
cadTerna = String.Empty;
terna = (Int32)(Num % 1000);

centenaTerna = (Int32)(terna / 100);
decenaTerna = terna % 100;
unidadTerna = terna % 10;

if ((decenaTerna > 0) && (decenaTerna < 10))
cadTerna = _matriz[UNI, unidadTerna] + cadTerna;
else if ((decenaTerna >= 10) && (decenaTerna < 20))
cadTerna = cadTerna + _matriz[DIECI, unidadTerna];
else if (decenaTerna == 20)
cadTerna = cadTerna + “ veinte“;
else if ((decenaTerna > 20) && (decenaTerna < 30))
cadTerna = “ veinti” + _matriz[UNI, unidadTerna].Substring(1);
else if ((decenaTerna >= 30) && (decenaTerna < 100))
if (unidadTerna != 0)
cadTerna = _matriz[DECENA, (Int32)(decenaTerna / 10)] + “ y” + _matriz[UNI, unidadTerna] + cadTerna;
else

cadTerna += _matriz[DECENA, (Int32)(decenaTerna / 10)];

switch (centenaTerna)
{
case 1:
if (decenaTerna > 0) cadTerna = “ ciento” + cadTerna;
else cadTerna = “ cien” + cadTerna;
break;
case 5:
case 7:
case 9:
cadTerna = _matriz[CENTENA, (Int32)(terna / 100)] + cadTerna;
break;
default:
if ((Int32)(terna / 100) > 1) cadTerna = _matriz[UNI, (Int32)(terna / 100)] + “cientos” + cadTerna;
break;
}
//Reemplazo el ‘uno’ por ‘un’ si no es en las únidades o si se solicító apocopar

if ((iTerna > 1 | ApocoparUnoParteEntera) && decenaTerna == 21)
cadTerna = cadTerna.Replace(”veintiuno“, “veintiún“);
else if ((iTerna > 1 | ApocoparUnoParteEntera) && unidadTerna == 1 && decenaTerna != 11)
cadTerna = cadTerna.Substring(0, cadTerna.Length - 1);
//Acentúo ‘veintidós’, ‘veintitrés’ y ‘veintiséis’

else if (decenaTerna == 22) cadTerna = cadTerna.Replace(”veintidos“, “veintidós“);
else if (decenaTerna == 23) cadTerna = cadTerna.Replace(”veintitres“, “veintitrés“);
else if (decenaTerna == 26) cadTerna = cadTerna.Replace(”veintiseis“, “veintiséis“);

//Completo miles y millones

switch (iTerna)
{
case 3:
if (Numero < 2000000) cadTerna += “ millón“;
else cadTerna += “ millones“;
break;
case 2:
case 4:
if (terna > 0) cadTerna += “ mil“;
break;
}
Resultado.Insert(0, cadTerna);
Num = (Int32)(Num / 1000);
} //while

}

//Se agregan los decimales si corresponde
if (Decimales > 0)
{
Resultado.Append(” ” + SeparadorDecimalSalida + “ “);
Int32 EnteroDecimal = (Int32)Math.Round((Double)(Numero - (Int64)Numero) * Math.Pow(10, Decimales), 0);
if (ConvertirDecimales)
{
Boolean esMascaraDecimalDefault = MascaraSalidaDecimal == MascaraSalidaDecimalDefault;
Resultado.Append(Convertir((Decimal)EnteroDecimal, 0, null, null, EsMascaraNumerica, false, false, (ApocoparUnoParteDecimal && !EsMascaraNumerica/*&& !esMascaraDecimalDefault*/), false) + “

+ (EsMascaraNumerica ? “” : MascaraSalidaDecimal));
}
else
if (EsMascaraNumerica) Resultado.Append(EnteroDecimal.ToString(MascaraSalidaDecimal));
else Resultado.Append(EnteroDecimal.ToString() + “ ” + MascaraSalidaDecimal);
}
//Se pone la primer letra en mayúscula si corresponde y se retorna el resultado

if (LetraCapital)
return Resultado[1].ToString().ToUpper() + Resultado.ToString(2, Resultado.Length - 2);
else
return Resultado.ToString().Substring(1);
}
}

Clase en VB:

Imports System

Imports System.Text
Imports System.Globalization

”’
”’ Convierte números en su expresión numérica a su numeral cardinal
”’
Public NotInheritable Class Numalet

#Region “Miembros estáticos

Private Const UNI As Integer = 0, DIECI As Integer = 1, DECENA As Integer = 2, CENTENA As Integer = 3
Private Shared _matriz As String(,) = New String(CENTENA, 9) { _
{Nothing, “ uno“, “ dos“, “ tres“, “ cuatro“, “ cinco“, “ seis“, “ siete“, “ ocho“, “ nueve“}, _
{” diez“, “ once“, “ doce“, “ trece“, “ catorce“, “ quince“, “ dieciséis“, “ diecisiete“, “ dieciocho“, “ diecinueve“}, _
{Nothing, Nothing, Nothing, “ treinta“, “ cuarenta“, “ cincuenta“, “ sesenta“, “ setenta“, “ ochenta“, “ noventa“}, _
{Nothing, Nothing, Nothing, Nothing, Nothing, “ quinientos“, Nothing, “ setecientos“, Nothing, “ novecientos“}}
Private Const [sub] As Char = CChar(ChrW(26))
‘Cambiar acá si se quiere otro comportamiento en los métodos de clase
Public Const SeparadorDecimalSalidaDefault As String = “con

Public Const MascaraSalidaDecimalDefault As String = “00′/100.-’
Public Const DecimalesDefault As Int32 = 2
Public Const LetraCapitalDefault As Boolean = False

Public Const ConvertirDecimalesDefault As Boolean = False
Public Const ApocoparUnoParteEnteraDefault As Boolean = False

Public Const ApocoparUnoParteDecimalDefault As Boolean = False

#End Region

#Region “Propiedades

Private _decimales As Int32 = DecimalesDefault
Private _cultureInfo As CultureInfo = Globalization.CultureInfo.CurrentCulture
Private _separadorDecimalSalida As String = SeparadorDecimalSalidaDefault
Private _posiciones As Int32 = DecimalesDefault
Private _mascaraSalidaDecimal As String, _mascaraSalidaDecimalInterna As String = MascaraSalidaDecimalDefault
Private _esMascaraNumerica As Boolean = True

Private _letraCapital As Boolean = LetraCapitalDefault
Private _convertirDecimales As Boolean = ConvertirDecimalesDefault
Private _apocoparUnoParteEntera As Boolean = False

Private _apocoparUnoParteDecimal As Boolean

”’
”’ Indica la cantidad de decimales que se pasarán a entero para la conversión
”’

”’ Esta propiedad cambia al cambiar MascaraDecimal por un valor que empieze con ‘0′
Public Property Decimales() As Int32
Get

Return _decimales
End Get
Set(ByVal value As Int32)
If value > 10 Then

Throw New ArgumentException(value.ToString() + “ excede el número máximo de decimales admitidos, solo se admiten hasta 10.“)
End If
_decimales = value
End Set

End Property

”’
”’ Objeto CultureInfo utilizado para convertir las cadenas de entrada en números
”’
Public Property CultureInfo() As CultureInfo
Get

Return _cultureInfo
End Get
Set(ByVal value As CultureInfo)
_cultureInfo = value
End Set

End Property

”’
”’ Indica la cadena a intercalar entre la parte entera y la decimal del número
”’

Public Property SeparadorDecimalSalida() As String
Get
Return _separadorDecimalSalida
End Get

Set(ByVal value As String)
_separadorDecimalSalida = value
‘Si el separador decimal es compuesto, infiero que estoy cuantificando algo,
‘por lo que apocopo el “uno” convirtiéndolo en “un

If value.Trim().IndexOf(” “) > 0 Then
_apocoparUnoParteEntera = True
Else

_apocoparUnoParteEntera = False
End If
End Set
End Property

”’
”’ Indica el formato que se le dara a la parte decimal del número
”’
Public Property MascaraSalidaDecimal() As String

Get
If Not [String].IsNullOrEmpty(_mascaraSalidaDecimal) Then
Return _mascaraSalidaDecimal
Else

Return “”
End If
End Get
Set(ByVal value As String)
‘determino la cantidad de cifras a redondear a partir de la cantidad de ‘0′ o ”

‘que haya al principio de la cadena, y también si es una máscara numérica
Dim i As Integer = 0
While i < value.Length AndAlso (value(i) = “0“c) Or value(i) = “”

i += 1
End While
_posiciones = i
If i > 0 Then
_decimales = i
_esMascaraNumerica = True

Else
_esMascaraNumerica = False
End If
_mascaraSalidaDecimal = value
If _esMascaraNumerica Then

_mascaraSalidaDecimalInterna = value.Substring(0, _posiciones) + “” + value.Substring(_posiciones).Replace(”“, [sub].ToString()).Replace(”“, [String].Empty).Replace([sub].ToString(), ““) + “
Else

_mascaraSalidaDecimalInterna = value.Replace(”“, [sub].ToString()).Replace(”“, [String].Empty).Replace([sub].ToString(), ““)
End If
End Set

End Property

”’
”’ Indica si la primera letra del resultado debe estár en mayúscula
”’
Public Property LetraCapital() As Boolean

Get
Return _letraCapital
End Get
Set(ByVal value As Boolean)
_letraCapital = value
End Set

End Property

”’
”’ Indica si se deben convertir los decimales a su expresión nominal
”’
Public Property ConvertirDecimales() As Boolean

Get
Return _convertirDecimales
End Get
Set(ByVal value As Boolean)
_convertirDecimales = value
_apocoparUnoParteDecimal = value
If value Then

‘ Si la máscara es la default, la borro
If _mascaraSalidaDecimal = MascaraSalidaDecimalDefault Then
MascaraSalidaDecimal = “”
End If

ElseIf [String].IsNullOrEmpty(_mascaraSalidaDecimal) Then
MascaraSalidaDecimal = MascaraSalidaDecimalDefault
‘Si no hay máscara dejo la default
End If

End Set
End Property

”’
”’ Indica si de debe cambiar “uno” por “un” en las unidades.
”’

Public Property ApocoparUnoParteEntera() As Boolean
Get
Return _apocoparUnoParteEntera
End Get

Set(ByVal value As Boolean)
_apocoparUnoParteEntera = value
End Set
End Property

”’
”’ Determina si se debe apococopar el “uno” en la parte decimal
”’

”’ El valor de esta propiedad cambia al setear ConvertirDecimales
Public Property ApocoparUnoParteDecimal() As Boolean
Get

Return _apocoparUnoParteDecimal
End Get
Set(ByVal value As Boolean)
_apocoparUnoParteDecimal = value
End Set

End Property

#End Region

#Region “Constructores

Public Sub New()
MascaraSalidaDecimal = MascaraSalidaDecimalDefault
SeparadorDecimalSalida = SeparadorDecimalSalidaDefault
LetraCapital = LetraCapitalDefault
ConvertirDecimales = _convertirDecimales
End Sub

Public Sub New(ByVal ConvertirDecimales As Boolean, ByVal MascaraSalidaDecimal As String, ByVal SeparadorDecimalSalida As String, ByVal LetraCapital As Boolean)
If Not [String].IsNullOrEmpty(MascaraSalidaDecimal) Then

Me.MascaraSalidaDecimal = MascaraSalidaDecimal
End If
If Not [String].IsNullOrEmpty(SeparadorDecimalSalida) Then

_separadorDecimalSalida = SeparadorDecimalSalida
End If
_letraCapital = LetraCapital
_convertirDecimales = ConvertirDecimales
End Sub

#End Region

#Region “Conversores de instancia

Public Function ToCustomCardinal(ByVal Numero As Double) As String

Return Convertir(Convert.ToDecimal(Numero), _decimales, _separadorDecimalSalida, _mascaraSalidaDecimalInterna, _esMascaraNumerica, _letraCapital, _
_convertirDecimales, _apocoparUnoParteEntera, _apocoparUnoParteDecimal)
End Function

Public Function ToCustomCardinal(ByVal Numero As String) As String

Dim dNumero As Double
If [Double].TryParse(Numero, NumberStyles.Float, _cultureInfo, dNumero) Then
Return ToCustomCardinal(dNumero)
Else

Throw New ArgumentException(”” + Numero + “‘ no es un número válido.“)
End If
End Function

Public Function ToCustomCardinal(ByVal Numero As Decimal) As String

Return ToCardinal(Numero)
End Function

Public Function ToCustomCardinal(ByVal Numero As Int32) As String

Return Convertir(Convert.ToDecimal(Numero), 0, _separadorDecimalSalida, _mascaraSalidaDecimalInterna, _esMascaraNumerica, _letraCapital, _
_convertirDecimales, _apocoparUnoParteEntera, False)
End Function

#End Region

#Region “Conversores estáticos

Public Shared Function ToCardinal(ByVal Numero As Int32) As String

Return Convertir(Convert.ToDecimal(Numero), 0, Nothing, Nothing, True, LetraCapitalDefault, _
ConvertirDecimalesDefault, ApocoparUnoParteEnteraDefault, ApocoparUnoParteDecimalDefault)
End Function

Public Shared Function ToCardinal(ByVal Numero As Double) As String

Return Convertir(Convert.ToDecimal(Numero), DecimalesDefault, SeparadorDecimalSalidaDefault, MascaraSalidaDecimalDefault, True, LetraCapitalDefault, _
ConvertirDecimalesDefault, ApocoparUnoParteEnteraDefault, ApocoparUnoParteDecimalDefault)
End Function

Public Shared Function ToCardinal(ByVal Numero As String, ByVal ReferenciaCultural As CultureInfo) As String

Dim dNumero As Double
If [Double].TryParse(Numero, NumberStyles.Float, ReferenciaCultural, dNumero) Then
Return ToCardinal(dNumero)
Else

Throw New ArgumentException(”” + Numero + “‘ no es un número válido.“)
End If
End Function

Public Shared Function ToCardinal(ByVal Numero As String) As String

Return Numalet.ToCardinal(Numero, CultureInfo.CurrentCulture)
End Function

Public Shared Function ToCardinal(ByVal Numero As Decimal) As String

Return ToCardinal(Convert.ToDouble(Numero))
End Function

#End Region

Private Shared Function Convertir(ByVal Numero As Decimal, ByVal Decimales As Int32, ByVal SeparadorDecimalSalida As String, ByVal MascaraSalidaDecimal As String, ByVal EsMascaraNumerica As Boolean, ByVal LetraCapital As Boolean, _
ByVal ConvertirDecimales As Boolean, ByVal ApocoparUnoParteEntera As Boolean, ByVal ApocoparUnoParteDecimal As Boolean) As String

Dim Num As Int64
Dim terna As Int32, centenaTerna As Int32, decenaTerna As Int32, unidadTerna As Int32, iTerna As Int32
Dim cadTerna As String

Dim Resultado As New StringBuilder()

Num = Math.Floor(Math.Abs(Numero))

If Num >= 1000000000001 OrElse Num < 0 Then

Throw New ArgumentException(”El número ‘” + Numero.ToString() + “‘ excedió los límites del conversor: [0;1.000.000.000.001]“)
End If
If Num = 0 Then

Resultado.Append(” cero“)
Else
iTerna = 0

Do Until Num = 0

iTerna += 1
cadTerna = String.Empty
terna = Num Mod 1000

centenaTerna = Int(terna / 100)
decenaTerna = terna - centenaTerna * 100 ‘Decena junto con la unidad
unidadTerna = (decenaTerna - Math.Floor(decenaTerna / 10) * 10)

Select Case decenaTerna
Case 1 To 9
cadTerna = _matriz(UNI, unidadTerna) + cadTerna
Case 10 To 19
cadTerna = cadTerna + _matriz(DIECI, unidadTerna)
Case 20
cadTerna = cadTerna + “ veinte

Case 21 To 29
cadTerna = “ veinti” + _matriz(UNI, unidadTerna).Substring(1)
Case 30 To 99
If unidadTerna <&gt; 0 Then

cadTerna = _matriz(DECENA, Int(decenaTerna / 10)) + “ y” + _matriz(UNI, unidadTerna) + cadTerna
Else
cadTerna += _matriz(DECENA, Int(decenaTerna / 10))
End If
End Select

Select Case centenaTerna
Case 1
If decenaTerna > 0 Then

cadTerna = “ ciento” + cadTerna
Else
cadTerna = “ cien” + cadTerna
End If

Exit Select
Case 5, 7, 9
cadTerna = _matriz(CENTENA, Int(terna / 100)) + cadTerna
Exit Select
Case Else

If Int(terna / 100) > 1 Then
cadTerna = _matriz(UNI, Int(terna / 100)) + “cientos” + cadTerna
End If

Exit Select
End Select
‘Reemplazo el ‘uno’ por ‘un’ si no es en las únidades o si se solicító apocopar
If (iTerna > 1 Or ApocoparUnoParteEntera) AndAlso decenaTerna = 21 Then

cadTerna = cadTerna.Replace(”veintiuno“, “veintiún“)
ElseIf (iTerna > 1 Or ApocoparUnoParteEntera) AndAlso unidadTerna = 1 AndAlso decenaTerna <&gt; 11 Then

cadTerna = cadTerna.Substring(0, cadTerna.Length - 1)
‘Acentúo ‘veintidós’, ‘veintitrés’ y ‘veintiséis’
ElseIf decenaTerna = 22 Then
cadTerna = cadTerna.Replace(”veintidos“, “veintidós“)
ElseIf decenaTerna = 23 Then

cadTerna = cadTerna.Replace(”veintitres“, “veintitrés“)
ElseIf decenaTerna = 26 Then
cadTerna = cadTerna.Replace(”veintiseis“, “veintiséis“)
End If

‘Completo miles y millones
Select Case iTerna
Case 3
If Numero < 2000000 Then

cadTerna += “ millón
Else
cadTerna += “ millones
End If

Case 2, 4
If terna > 0 Then cadTerna += “ mil
End Select

Resultado.Insert(0, cadTerna)
Num = Int(Num / 1000)
Loop
End If

‘Se agregan los decimales si corresponde
If Decimales > 0 Then

Resultado.Append(” ” + SeparadorDecimalSalida + “ “)
Dim EnteroDecimal As Int32 = Int(Math.Round((Numero - Int(Numero)) * Math.Pow(10, Decimales)))
If ConvertirDecimales Then

Dim esMascaraDecimalDefault As Boolean = MascaraSalidaDecimal = MascaraSalidaDecimalDefault
Resultado.Append(Convertir(Convert.ToDecimal(EnteroDecimal), 0, Nothing, Nothing, EsMascaraNumerica, False, _
False, (ApocoparUnoParteDecimal AndAlso Not EsMascaraNumerica), False) + “ ” + (IIf(EsMascaraNumerica, ““, MascaraSalidaDecimal)))
ElseIf EsMascaraNumerica Then

Resultado.Append(EnteroDecimal.ToString(MascaraSalidaDecimal))
Else
Resultado.Append(EnteroDecimal.ToString() + “ ” + MascaraSalidaDecimal)
End If
End If

‘Se pone la primer letra en mayúscula si corresponde y se retorna el resultado
If LetraCapital Then
Return Resultado(1).ToString().ToUpper() + Resultado.ToString(2, Resultado.Length - 2)
Else
Return Resultado.ToString().Substring(1)
End If

End Function

End Class

Aqui queda la primer aportación. Veamos que encontramos mas adelante.
Hasta la proxima

About these ads
Acerca de

Un Poco de mi, Soy un Desarrollador de Aplicaciones .Net, el ultimo año he trabajado para una empresa Consultora, me gustan las peliculas, la musica, y de cuando en cuando un buen tequila reposado de preferencia.

Tagged with: , ,
Publicado en C#, VB.Net

Deja un comentario

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

junio 2008
L M X J V S D
« may   jul »
 1
2345678
9101112131415
16171819202122
23242526272829
30  
Categorías
  • Ha ocurrido un error; probablemente el feed está caído. Inténtalo de nuevo más tarde.
Paginas
Seguir

Recibe cada nueva publicación en tu buzón de correo electrónico.

A %d blogueros les gusta esto: