parse - convertir tipo string a int c#

¿Cómo convertir un entero gi-normo(en formato de cadena) a formato hexadecimal?(DO#)

Question

Dado un valor entero potencialmente enorme (en formato de cadena C #), quiero poder generar su equivalente hexadecimal. Los métodos normales no se aplican aquí ya que estamos hablando de números arbitrariamente grandes, 50 dígitos o más. Las técnicas que he visto que usan una técnica como esta:

// Store integer 182
int decValue = 182;
// Convert integer 182 as a hex in a string variable
string hexValue = decValue.ToString("X");
// Convert the hex string back to the number
int decAgain = int.Parse(hexValue, System.Globalization.NumberStyles.HexNumber);

no funcionará porque el entero para convertir es demasiado grande.

Por ejemplo, necesito poder convertir una cadena como esta:

843370923007003347112437570992242323

a su equivalente hexadecimal

estos no funcionan:

C # convertir entero a hexadecimal y viceversa ¿Cómo convertir números entre hexadecimal y decimal en C #?

Answer 1

Como dijo Jens, eche un vistazo a la implementación de BigInt en Code Project . Incluso si no tienen una función para convertir a hexadecimal, podría escribir fácilmente una función para hacerlo usted mismo, siempre que este BigInt tenga una operación de división y módulo (no creo que tenga una función de módulo, por lo que lo haría también necesita escribir módulo usted mismo)

Answer 2

Oh, eso es fácil:

 var s = "843370923007003347112437570992242323";
var result = new List<byte>();
result.Add( 0 );
foreach ( char c in s )
{
int val = (int)( c - ''0'' );
for ( int i = 0 ; i < result.Count ; i++ )
{
int digit = result[i] * 10 + val;
result[i] = (byte)( digit & 0x0F );
val = digit >> 4;
}
if ( val != 0 )
result.Add( (byte)val );
}
var hex = "";
foreach ( byte b in result )
hex = "0123456789ABCDEF"[ b ] + hex;

Answer 3

Use un BigInteger para almacenar el número entero y luego use .ToString ("X") en ese objeto.

Ejemplo:

var number = BigInteger.Parse("843370923007003347112437570992242323");
string hexValue = number.ToString("X");

Sin embargo, esto está limitado a .NET 4 y posterior. Pero Jens A. apuntó a una clase BigInteger en el proyecto de código que la clase contiene un método llamado ToHexString para que funcione para un escenario <.NET 4.

Answer 4

heh soluciones agradables para dec <-> conversiones hexadecimales aquí en hasta ahora, ... pero necesitaba (gigantesca fracción int gigantesca) con casi ninguna precisión perdida así que modifiqué todos los códigos que encontré con mis códigos ya terminados y aquí hay algunos Puedo compartir (sin gran uso de lib / lib real)

//---------------------------------------------------------------------------
AnsiString str_hex2dec(const AnsiString &hex)
{
char c;
AnsiString dec="",s;
int i,j,l,ll,cy,val;
int i0,i1,i2,i3,sig;
sig=+1; l=hex.Length();
if (l) { c=hex[l]; if (c==''h'') l--; if (c==''H'') l--; }
i0=0; i1=l; i2=0; i3=l;
for (i=1;i<=l;i++) // scan for parts of number
{
char c=hex[i];
if (c==''-'') sig=-sig;
if ((c==''.'')||(c=='','')) i1=i-1;
if ((c>=''0'')&&(c<=''9'')) { if (!i0) i0=i; if ((!i2)&&(i>i1)) i2=i; }
if ((c>=''A'')&&(c<=''F'')) { if (!i0) i0=i; if ((!i2)&&(i>i1)) i2=i; }
if ((c>=''a'')&&(c<=''f'')) { if (!i0) i0=i; if ((!i2)&&(i>i1)) i2=i; }
}
l=0; s=""; if (i0) for (i=i0;i<=i1;i++)
{
c=hex[i];
if ((c>=''0'')&&(c<=''9'')) c-=''0'';
else if ((c>=''A'')&&(c<=''F'')) c-=''A''-10;
else if ((c>=''a'')&&(c<=''f'')) c-=''A''-10;
for (cy=c,j=1;j<=l;j++)
{
val=(s[j]<<4)+cy;
s[j]=val%10;
cy =val/10;
}
while (cy>0)
{
l++;
s+=char(cy%10);
cy/=10;
}
}
if (s!="")
{
for (j=1;j<=l;j++) { c=s[j]; if (c<10) c+=''0''; else c+=''A''-10; s[j]=c; }
for (i=l,j=1;j<i;j++,i--) { c=s[i]; s[i]=s[j]; s[j]=c; }
dec+=s;
}
if (dec=="") dec="0";
if (sig<0) dec="-"+dec;
if (i2)
{
dec+=''.'';
s=hex.SubString(i2,i3-i2+1);
l=s.Length();
for (i=1;i<=l;i++)
{
c=s[i];
if ((c>=''0'')&&(c<=''9'')) c-=''0'';
else if ((c>=''A'')&&(c<=''F'')) c-=''A''-10;
else if ((c>=''a'')&&(c<=''f'')) c-=''A''-10;
s[i]=c;
}
ll=((l*1234)>>10); // num of decimals to compute
for (cy=0,i=1;i<=ll;i++)
{
for (cy=0,j=l;j>=1;j--)
{
val=s[j];
val*=10;
val+=cy;
s[j]=val&15;
cy=val>>4;
}
dec+=char(cy+''0'');
for (;;)
{
if (!l) break;;
if (s[l]) break;
l--;
}
if (!l) break;;
}
}
return dec;
}
//---------------------------------------------------------------------------
AnsiString str_dec2hex(AnsiString dec)
{
AnsiString hex=""; BYTE a,b;
int i,j,i0,i1,i2,i3,l,sig;
sig=+1; l=dec.Length();
i0=0; i1=l; i2=0; i3=l;
for (i=1;i<=l;i++) // scan for parts of number
{
char c=dec[i];
if (c==''-'') sig=-sig;
if ((c==''.'')||(c=='','')) i1=i-1;
if ((c>=''0'')&&(c<=''9'')) { if (!i0) i0=i; if ((!i2)&&(i>i1)) i2=i; }
}
if (i0) for (;i1>=i0;i1=j-1)// process integer part /16
{
for (a=0,j=i0,i=i0;i<=i1;i++)
{
a*=10; a+=dec[i]-''0'';
if (a<16) { if (j>i0){ dec[j]=''0''; j++; } continue; }
b=a>>4; a=a&15;
if (b>10) { dec[j]=''1''; j++; b-=10; }
dec[j]=b+''0''; j++;
}
if ((!a)&&(hex=="")) continue;
if (a<10) a+=''0''; else a+=''A''-10;
hex=AnsiString(char(a))+hex;
}
if (hex=="") hex="0";
if ((i2)&&(i2<=i3)) // process fractional part *16
for (hex+=".",j=i3-i2+2;j;j--)
{
for (a=0,b=0,i=i3;i>=i2;i--)
{
a=dec[i]-''0'';
b+=a<<4; dec[i]=(b%10)+''0''; b/=10;
}
if (b<10) b+=''0''; else b+=''A''-10;
hex+=char(b);
}
if (sig<0) hex="-"+hex; hex+="h";
return hex;
}
//---------------------------------------------------------------------------

PD: si necesita cortar los dígitos fraccionarios (para formatear los números), debe redondear el dígito más significativo de la parte cortada.

• redondeando abs arriba en modo dec si digit> = ''5''
• redondeando abs arriba en modo hexadecimal si digit> = ''8''

si te preguntas qué significa esta línea:

ll=((l*1234)>>10); // num of decimals to compute

que calcula la cantidad de dígitos fraccionarios que coinciden con la precisión de la cadena de entrada (1.205 dígitos decimales decimales por dígito fraccionario hexadecimal). Esta relación se obtiene mediante la medición empírica de precisión de hasta 1280 bits por parte fraccional de número. por simplicidad 1e-l se puede almacenar con un error máximo de hasta 1e- (l + 1). Esta relación es casi constante (excepto para valores bajos de dígitos fraccionarios (<16 dígitos) por lo que esta fórmula se puede usar para cualquier número mayor de dígitos de forma segura. (<= 8 dígitos) dígitos