Le moyen le plus rapide pour convertir une base de 10 numéros à toute la base dans .NET?

Convertir.ToString peut être utilisé pour convertir un nombre équivalent de la chaîne de la représentation dans une base spécifiée.

Exemple:

string binary = Convert.ToString(5, 2); //convert 5 to its binary representation
Console.WriteLine(binary);              //prints 101

Cependant, comme souligné par les commentaires, Convert.ToString prend uniquement en charge les éléments suivants limitée mais généralement suffisante - ensemble de bases: 2, 8, 10 ou 16.

Mise à jour (pour répondre à l'exigence de convertir à toute la base):

Je ne suis pas au courant de n'importe quelle méthode de la BCL qui est capable de convertir des nombres à toute la base de sorte que vous devez écrire votre propre fonction d'utilité. Un exemple simple serait ressembler à ça (notez que cela ne peut certainement être fait plus rapidement en remplacement de la concaténation de chaîne):

class Program
{
static void Main(string[] args)
{
//convert to binary
string binary = IntToString(42, new char[] { '0', '1' });
//convert to hexadecimal
string hex = IntToString(42, 
new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'A', 'B', 'C', 'D', 'E', 'F'});
//convert to hexavigesimal (base 26, A-Z)
string hexavigesimal = IntToString(42, 
Enumerable.Range('A', 26).Select(x => (char)x).ToArray());
//convert to sexagesimal
string xx = IntToString(42, 
new char[] { '0','1','2','3','4','5','6','7','8','9',
'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x'});
}
public static string IntToString(int value, char[] baseChars)
{
string result = string.Empty;
int targetBase = baseChars.Length;
do
{
result = baseChars[value % targetBase] + result;
value = value / targetBase;
} 
while (value > 0);
return result;
}
///<summary>
///An optimized method using an array as buffer instead of 
///string concatenation. This is faster for return values having 
///a length > 1.
///</summary>
public static string IntToStringFast(int value, char[] baseChars)
{
//32 is the worst cast buffer size for base 2 and int.MaxValue
int i = 32;
char[] buffer = new char[i];
int targetBase= baseChars.Length;
do
{
buffer[--i] = baseChars[value % targetBase];
value = value / targetBase;
}
while (value > 0);
char[] result = new char[32 - i];
Array.Copy(buffer, i, result, 0, 32 - i);
return new string(result);
}
}

Mise À Jour 2 (Amélioration Du Rendement)

À l'aide d'une matrice de mémoire tampon au lieu de concaténation de chaîne à construire la chaîne de résultat donne une amélioration de la performance en particulier sur le grand nombre (voir la méthode IntToStringFast). Dans le meilleur des cas (c'est à dire la plus longue possible d'entrée) cette méthode est à peu près trois fois plus vite. Toutefois, pour les 1-chiffres (c'est à dire 1-chiffre dans la base cible), IntToString sera plus rapide.

On peut également utiliser une version légèrement modifiée de la accepté un seul et ajuster la base de caractères de la chaîne à ses besoins:

public static string Int32ToString(int value, int toBase)
{
string result = string.Empty;
do
{
result = "0123456789ABCDEF"[value % toBase] + result;
value /= toBase;
}
while (value > 0);
return result;
}

Très en retard à la fête sur ce point, mais j'ai écrit une classe helper récemment pour un projet au travail. Il a été conçu pour convertir des chaînes courtes en chiffres et en arrière de nouveau (simpliste parfait de hachage fonction), mais il permettra également d'effectuer le numéro de conversion entre des bases arbitraires. Le Base10ToString méthode de la mise en œuvre répond à la question qui a été posté.

La shouldSupportRoundTripping drapeau passé au constructeur de la classe est nécessaire pour prévenir la perte des premiers chiffres du numéro de chaîne au cours de la conversion en base 10 et de retour à nouveau (crucial, compte tenu de mes besoins!). La plupart du temps la perte de leader de 0s à partir du numéro de chaîne ne sera probablement pas un problème.

De toute façon, voici le code:

using System;
using System.Collections.Generic;
using System.Linq;
namespace StackOverflow
{
///<summary>
///Contains methods used to convert numbers between base-10 and another numbering system.
///</summary>
///<remarks>
///<para>
///This conversion class makes use of a set of characters that represent the digits used by the target
///numbering system. For example, binary would use the digits 0 and 1, whereas hex would use the digits
///0 through 9 plus A through F. The digits do not have to be numerals.
///</para>
///<para>
///The first digit in the sequence has special significance. If the number passed to the
///<see cref="StringToBase10"/> method has leading digits that match the first digit, then those leading
///digits will effectively be 'lost' during conversion. Much of the time this won't matter. For example,
///"0F" hex will be converted to 15 decimal, but when converted back to hex it will become simply "F",
///losing the leading "0". However, if the set of digits was A through Z, and the number "ABC" was
///converted to base-10 and back again, then the leading "A" would be lost. The <see cref="System.Boolean"/>
///flag passed to the constructor allows 'round-tripping' behaviour to be supported, which will prevent
///leading digits from being lost during conversion.
///</para>
///<para>
///Note that numeric overflow is probable when using longer strings and larger digit sets.
///</para>
///</remarks>
public class Base10Converter
{
const char NullDigit = '\0';
public Base10Converter(string digits, bool shouldSupportRoundTripping = false)
: this(digits.ToCharArray(), shouldSupportRoundTripping)
{
}
public Base10Converter(IEnumerable<char> digits, bool shouldSupportRoundTripping = false)
{
if (digits == null)
{
throw new ArgumentNullException("digits");
}
if (digits.Count() == 0)
{
throw new ArgumentException(
message: "The sequence is empty.",
paramName: "digits"
);
}
if (!digits.Distinct().SequenceEqual(digits))
{
throw new ArgumentException(
message: "There are duplicate characters in the sequence.",
paramName: "digits"
);
}
if (shouldSupportRoundTripping)
{
digits = (new[] { NullDigit }).Concat(digits);
}
_digitToIndexMap =
digits
.Select((digit, index) => new { digit, index })
.ToDictionary(keySelector: x => x.digit, elementSelector: x => x.index);
_radix = _digitToIndexMap.Count;
_indexToDigitMap =
_digitToIndexMap
.ToDictionary(keySelector: x => x.Value, elementSelector: x => x.Key);
}
readonly Dictionary<char, int> _digitToIndexMap;
readonly Dictionary<int, char> _indexToDigitMap;
readonly int _radix;
public long StringToBase10(string number)
{
Func<char, int, long> selector =
(c, i) =>
{
int power = number.Length - i - 1;
int digitIndex;
if (!_digitToIndexMap.TryGetValue(c, out digitIndex))
{
throw new ArgumentException(
message: String.Format("Number contains an invalid digit '{0}' at position {1}.", c, i),
paramName: "number"
);
}
return Convert.ToInt64(digitIndex * Math.Pow(_radix, power));
};
return number.Select(selector).Sum();
}
public string Base10ToString(long number)
{
if (number < 0)
{
throw new ArgumentOutOfRangeException(
message: "Value cannot be negative.",
paramName: "number"
);
}
string text = string.Empty;
long remainder;
do
{
number = Math.DivRem(number, _radix, out remainder);
char digit;
if (!_indexToDigitMap.TryGetValue((int) remainder, out digit) || digit == NullDigit)
{
throw new ArgumentException(
message: "Value cannot be converted given the set of digits used by this converter.",
paramName: "number"
);
}
text = digit + text;
}
while (number > 0);
return text;
}
}
}

Cela peut aussi être sous-classé pour tirer personnalisé nombre de convertisseurs:

namespace StackOverflow
{
public sealed class BinaryNumberConverter : Base10Converter
{
public BinaryNumberConverter()
: base(digits: "01", shouldSupportRoundTripping: false)
{
}
}
public sealed class HexNumberConverter : Base10Converter
{
public HexNumberConverter()
: base(digits: "0123456789ABCDEF", shouldSupportRoundTripping: false)
{
}
}
}

Et le code pourra être utilisé comme ceci:

using System.Diagnostics;
namespace StackOverflow
{
class Program
{
static void Main(string[] args)
{
{
var converter = new Base10Converter(
digits: "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz",
shouldSupportRoundTripping: true
);
long number = converter.StringToBase10("Atoz");
string text = converter.Base10ToString(number);
Debug.Assert(text == "Atoz");
}
{
var converter = new HexNumberConverter();
string text = converter.Base10ToString(255);
long number = converter.StringToBase10(text);
Debug.Assert(number == 255);
}
}
}
}

Je recherchais un moyen rapide de convertir le nombre décimal à une autre base dans la gamme de [2..36] j'ai donc développé le code suivant. Son simple à suivre et utilise un objet Stringbuilder comme un proxy pour un tampon de caractères que nous pouvons indice de caractère par caractère. Le code semble être très rapide par rapport aux alternatives et beaucoup plus vite que l'initialisation des caractères individuels dans un tableau de caractères.

Pour votre propre usage, vous préférerez peut-être:
1/Retourne une chaîne vide plutôt que de jeter une exception.
2/retirez le radix vérifiez la méthode de courir encore plus vite
3/Initialiser l'objet Stringbuilder avec 32 '0' et de supprimer la ligne de résultat.Supprimer( 0, i );. Ce sera la cause de la chaîne de caractères à renvoyer avec les zéros non significatifs et d'augmenter la vitesse.
4/Faire l'objet Stringbuilder un champ statique au sein de la classe, alors peu importe combien de fois la DecimalToBase méthode est appelée, l'objet Stringbuilder est seulement initialisées à la fois. Si vous faites ce changement 3 ci-dessus ne fonctionnerait plus.

J'espère que quelqu'un trouve cela utile 🙂

AtomicParadox

        static string DecimalToBase(int number, int radix)
{
//Check that the radix is between 2 and 36 inclusive
if ( radix < 2 || radix > 36 )
throw new ArgumentException("ConvertToBase(int number, int radix) - Radix must be between 2 and 36.");
//Create a buffer large enough to hold the largest int value represented in binary digits 
StringBuilder result = new StringBuilder("                                ");  //32 spaces
//The base conversion calculates the digits in reverse order so use
//an index to point to the last unused space in our buffer
int i = 32; 
//Convert the number to the new base
do
{
int remainder = number % radix;
number = number / radix;
if(remainder <= 9)
result[--i] = (char)(remainder + '0');  //Converts [0..9] to ASCII ['0'..'9']
else
result[--i] = (char)(remainder + '7');  //Converts [10..36] to ASCII ['A'..'Z']
} while ( number > 0 );
//Remove the unwanted padding from the front of our buffer and return the result
//Note i points to the last unused character in our buffer
result.Remove( 0, i );
return (result.ToString());
}

J'avais un besoin similaire, sauf que j'ai besoin de faire des maths sur les "chiffres" ainsi. J'ai pris quelques suggestions ici et a créé une classe qui peut faire toutes ces choses amusantes. Il permet à n'importe quel caractère unicode à être utilisés pour représenter un nombre et il travaille avec des décimales trop.

Cette classe est assez facile à utiliser. Il suffit de créer un certain nombre, comme un type de New BaseNumber, définir quelques propriétés, et votre. Les routines de prendre soin de commutation entre la base 10 et base x automatiquement et la valeur que vous avez définie est conservé dans la base de vous dans, donc pas de précision est perdu (jusqu'à la conversion qui est, mais même alors, la perte de précision due doit être très minime, car cette routine utilise Double et Long dans la mesure du possible).

Je ne peux pas commande sur la vitesse de cette routine. Il est probablement très lent, donc je ne sais pas si il va répondre aux besoins de celui qui a posé la question, mais il certain, c'est flexible, donc j'espère que quelqu'un d'autre peut utiliser ce fichier.

Pour quelqu'un d'autre qui pourrait avoir besoin de ce code pour le calcul de la prochaine colonne dans Excel, je vais inclure la boucle de code que j'ai utilisé, qui tire parti de cette classe.

Public Class BaseNumber
Private _CharacterArray As List(Of Char)
Private _BaseXNumber As String
Private _Base10Number As Double?
Private NumberBaseLow As Integer
Private NumberBaseHigh As Integer
Private DecimalSeparator As Char = System.Globalization.CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator
Private GroupSeparator As Char = System.Globalization.CultureInfo.CurrentCulture.NumberFormat.NumberGroupSeparator
Public Sub UseCapsLetters()
'http://unicodelookup.com
TrySetBaseSet(65, 90)
End Sub
Public Function GetCharacterArray() As List(Of Char)
Return _CharacterArray
End Function
Public Sub SetCharacterArray(CharacterArray As String)
_CharacterArray = New List(Of Char)
_CharacterArray.AddRange(CharacterArray.ToList)
TrySetBaseSet(_CharacterArray)
End Sub
Public Sub SetCharacterArray(CharacterArray As List(Of Char))
_CharacterArray = CharacterArray
TrySetBaseSet(_CharacterArray)
End Sub
Public Sub SetNumber(Value As String)
_BaseXNumber = Value
_Base10Number = Nothing
End Sub
Public Sub SetNumber(Value As Double)
_Base10Number = Value
_BaseXNumber = Nothing
End Sub
Public Function GetBaseXNumber() As String
If _BaseXNumber IsNot Nothing Then
Return _BaseXNumber
Else
Return ToBaseString()
End If
End Function
Public Function GetBase10Number() As Double
If _Base10Number IsNot Nothing Then
Return _Base10Number
Else
Return ToBase10()
End If
End Function
Private Sub TrySetBaseSet(Values As List(Of Char))
For Each value As Char In _BaseXNumber
If Not Values.Contains(value) Then
Throw New ArgumentOutOfRangeException("The string has a value, " & value & ", not contained in the selected 'base' set.")
_CharacterArray.Clear()
DetermineNumberBase()
End If
Next
_CharacterArray = Values
End Sub
Private Sub TrySetBaseSet(LowValue As Integer, HighValue As Integer)
Dim HighLow As KeyValuePair(Of Integer, Integer) = GetHighLow()
If HighLow.Key < LowValue OrElse HighLow.Value > HighValue Then
Throw New ArgumentOutOfRangeException("The string has a value not contained in the selected 'base' set.")
_CharacterArray.Clear()
DetermineNumberBase()
End If
NumberBaseLow = LowValue
NumberBaseHigh = HighValue
End Sub
Private Function GetHighLow(Optional Values As List(Of Char) = Nothing) As KeyValuePair(Of Integer, Integer)
If Values Is Nothing Then
Values = _BaseXNumber.ToList
End If
Dim lowestValue As Integer = Convert.ToInt32(Values(0))
Dim highestValue As Integer = Convert.ToInt32(Values(0))
Dim currentValue As Integer
For Each value As Char In Values
If value <> DecimalSeparator AndAlso value <> GroupSeparator Then
currentValue = Convert.ToInt32(value)
If currentValue > highestValue Then
highestValue = currentValue
End If
If currentValue < lowestValue Then
currentValue = lowestValue
End If
End If
Next
Return New KeyValuePair(Of Integer, Integer)(lowestValue, highestValue)
End Function
Public Sub New(BaseXNumber As String)
_BaseXNumber = BaseXNumber
DetermineNumberBase()
End Sub
Public Sub New(BaseXNumber As String, NumberBase As Integer)
Me.New(BaseXNumber, Convert.ToInt32("0"c), NumberBase)
End Sub
Public Sub New(BaseXNumber As String, NumberBaseLow As Integer, NumberBaseHigh As Integer)
_BaseXNumber = BaseXNumber
Me.NumberBaseLow = NumberBaseLow
Me.NumberBaseHigh = NumberBaseHigh
End Sub
Public Sub New(Base10Number As Double)
_Base10Number = Base10Number
End Sub
Private Sub DetermineNumberBase()
Dim highestValue As Integer
Dim currentValue As Integer
For Each value As Char In _BaseXNumber
currentValue = Convert.ToInt32(value)
If currentValue > highestValue Then
highestValue = currentValue
End If
Next
NumberBaseHigh = highestValue
NumberBaseLow = Convert.ToInt32("0"c) 'assume 0 is the lowest
End Sub
Private Function ToBaseString() As String
Dim Base10Number As Double = _Base10Number
Dim intPart As Long = Math.Truncate(Base10Number)
Dim fracPart As Long = (Base10Number - intPart).ToString.Replace(DecimalSeparator, "")
Dim intPartString As String = ConvertIntToString(intPart)
Dim fracPartString As String = If(fracPart <> 0, DecimalSeparator & ConvertIntToString(fracPart), "")
Return intPartString & fracPartString
End Function
Private Function ToBase10() As Double
Dim intPartString As String = _BaseXNumber.Split(DecimalSeparator)(0).Replace(GroupSeparator, "")
Dim fracPartString As String = If(_BaseXNumber.Contains(DecimalSeparator), _BaseXNumber.Split(DecimalSeparator)(1), "")
Dim intPart As Long = ConvertStringToInt(intPartString)
Dim fracPartNumerator As Long = ConvertStringToInt(fracPartString)
Dim fracPartDenominator As Long = ConvertStringToInt(GetEncodedChar(1) & String.Join("", Enumerable.Repeat(GetEncodedChar(0), fracPartString.ToString.Length)))
Return Convert.ToDouble(intPart + fracPartNumerator / fracPartDenominator)
End Function
Private Function ConvertIntToString(ValueToConvert As Long) As String
Dim result As String = String.Empty
Dim targetBase As Long = GetEncodingCharsLength()
Do
result = GetEncodedChar(ValueToConvert Mod targetBase) & result
ValueToConvert = ValueToConvert \ targetBase
Loop While ValueToConvert > 0
Return result
End Function
Private Function ConvertStringToInt(ValueToConvert As String) As Long
Dim result As Long
Dim targetBase As Integer = GetEncodingCharsLength()
Dim startBase As Integer = GetEncodingCharsStartBase()
Dim value As Char
For x As Integer = 0 To ValueToConvert.Length - 1
value = ValueToConvert(x)
result += GetDecodedChar(value) * Convert.ToInt32(Math.Pow(GetEncodingCharsLength, ValueToConvert.Length - (x + 1)))
Next
Return result
End Function
Private Function GetEncodedChar(index As Integer) As Char
If _CharacterArray IsNot Nothing AndAlso _CharacterArray.Count > 0 Then
Return _CharacterArray(index)
Else
Return Convert.ToChar(index + NumberBaseLow)
End If
End Function
Private Function GetDecodedChar(character As Char) As Integer
If _CharacterArray IsNot Nothing AndAlso _CharacterArray.Count > 0 Then
Return _CharacterArray.IndexOf(character)
Else
Return Convert.ToInt32(character) - NumberBaseLow
End If
End Function
Private Function GetEncodingCharsLength() As Integer
If _CharacterArray IsNot Nothing AndAlso _CharacterArray.Count > 0 Then
Return _CharacterArray.Count
Else
Return NumberBaseHigh - NumberBaseLow + 1
End If
End Function
Private Function GetEncodingCharsStartBase() As Integer
If _CharacterArray IsNot Nothing AndAlso _CharacterArray.Count > 0 Then
Return GetHighLow.Key
Else
Return NumberBaseLow
End If
End Function
End Class

Et maintenant, pour le code de la boucle à travers des colonnes Excel:

    Public Function GetColumnList(DataSheetID As String) As List(Of String)
Dim workingColumn As New BaseNumber("A")
workingColumn.SetCharacterArray("@ABCDEFGHIJKLMNOPQRSTUVWXYZ")
Dim listOfPopulatedColumns As New List(Of String)
Dim countOfEmptyColumns As Integer
Dim colHasData As Boolean
Dim cellHasData As Boolean
Do
colHasData = True
cellHasData = False
For r As Integer = 1 To GetMaxRow(DataSheetID)
cellHasData = cellHasData Or XLGetCellValue(DataSheetID, workingColumn.GetBaseXNumber & r) <> ""
Next
colHasData = colHasData And cellHasData
'keep trying until we get 4 empty columns in a row
If colHasData Then
listOfPopulatedColumns.Add(workingColumn.GetBaseXNumber)
countOfEmptyColumns = 0
Else
countOfEmptyColumns += 1
End If
'we are already starting with column A, so increment after we check column A
Do
workingColumn.SetNumber(workingColumn.GetBase10Number + 1)
Loop Until Not workingColumn.GetBaseXNumber.Contains("@")
Loop Until countOfEmptyColumns > 3
Return listOfPopulatedColumns
End Function

Vous remarquerez que la partie importante de la partie Excel est que 0 est identifié par un @ dans le re-basé nombre. Je viens donc de filtrer tous les nombres qui ont un @ et je reçois la séquence correcte (A, B, C, ..., Z, AA, AB, AC, ...).