
Introduction
This library class converts numbers between a variety of number bases - in
fact, any number base between 2 (binary) and 36. This goes beyond the .NET
framework conversion libraries which offer a limited set of conversions
The library exposes a number of common conversions (such as Binary to
Decimal/base10) for simple use as well as allowing user defined conversions
under advanced use (such as base 26 to base 5)
Background
Recently I needed to calculate the numeric column ordinals for an Excel
spreadsheet. Columns begin at 'A' and continue to 'B, ..., Z, AA, AB, ...' etc.
I could not find any code to do this anywhere and also came across a number of
posts on various coding sites asking how to perform conversions between
arbitrary number bases
I solved my Excel requirement using a short function but decided it would be
a useful exercise to develop a general number conversion class - this is the
result. This class is generic enough to include handling the Excel scenario as
well as all conventional number bases from 2 to 36 (inclusive)
The actual process of converting between bases is fairly trivial and I chose
to convert to base 10 as an interim step. Therefore, when converting from base 3
to 7, for example, the code converts from base 3 to 10 then 10 to 7. I'm sure it
is possible to develop a single algorithm to perform the conversion in one step
so this may appear in a later version although I feel the current solution is
easier to maintain and debug so maybe not
Code structure
There are 3 projects in the attached solution:
- MarkGwilliam.com.Framework.Convert - Conversion class library
- MarkGwilliam.com.Framework.Convert.Tests - Unit tests (requires NUnit)
- MarkGwilliam.com.Framework.Convert.Demo - UI demo (see screenshot above)
Using the code
A simple demo is included. Download the code,
open the solution, set the Demo project as startup and run. This will start the
UI demo which you can use for simple conversions
In your own code, the Converter
class can be used in a number of
ways:
- Simple use: built-in converters
- Advanced use: custom converters
- Advanced use: converter instances
...these are detailed below
Simple use: built-in converters
The simplest method is to use one of the 12 built-in static converters:
Convert.BinToDec.Convert()
Convert.BinToHex.Convert()
Convert.BinToOct.Convert()
Convert.DecToBin.Convert()
Convert.DecToHex.Convert()
- etc.
This allows all conversion combinations using Binary, Octal, Decimal and
Hexadecimal. For example:
string binary = Converter.HexToBin.Convert("FFFF");
Advanced use: custom converters
In addition to the built-in static converters you can also perform custom
conversion:
string base5 = Converter.Convert(NumberBases.Hexadecimal, 5, "FFFF");
Advanced use: converter instances
Converter instances can also be created instead of using the built-in static
converters or the static Converter.Convert()
methods (overloaded)
Instances are created using the static Converter.Create()
factory methods which have a number of overloads. Once an instance is created,
calls can be made to the Convert()
method to perform conversions
using the number bases specified when creating the converter instance
Converter fromExcel = Converter.Create(26, NumberingSchemes.AToZ, NumberBases.Decimal,
NumberingSchemes.ZeroToZ);
string columnNumber = fromExcel.Convert("AA");
Limitations
There are a few limitations to bear in mind:
- Negative numbers are not supported
- All converted values are returned as strings
- The largest value that can be converted is
Int64.MaxValue
as
long
is used internally
- Special character denoting number bases are not supported. For instance,
Hexadecimal values are often written as
0xFF01
or
&HFF01
. This class requires the simpler FF01
notation
Points of Interest
The download includes unit tests
(requires NUnit) which, apart
from validating the conversions and testing class behaviour, also shows a number
of other ways to use the class
The source is liberally commented and the associated documentation file
(.CHM) is included
Further development
A couple of future plans:
- Allow use of custom numbering strings. i.e. user defined symbols to use as
digits
- Support for number bases > 36
History
- Version 1.0 - 1st Jan 2007 - Initial version
Mark Gwilliam is a freelance .Net consultant based in the UK specialising in .Net architecture, design and coding.
He has been working in IT for around 15 years and has worked primarily in the financial sector and is always keen to lead, learn, follow or teach