Binary, octal, and hexadecimal 32 bit structs

• Download source code - 5.43 KB
• Download sample - 6.89 KB

Introduction

Although data is obviously stored in memory or on disk in binary form, .NET automatically converts it into base 10 (decimal) whenever we want to see the data or set values. It does have a little functionality for getting or setting values in other bases, as listed below.

Inbuilt functions

Setting an Int32 (base = 2 for binary, 8 for octal, or 16 for hexadecimal): Convert.ToInt32 (string, base). E.g.:

string binaryString = "11111111";
int i = Convert.ToInt32 (binaryString, 2);

i now equals 255.

Alternative for hexadecimal only:

int i = 0xFF;

i now equals 255.

Getting a value from an Int32: Convert.ToString (integer, base). E.g.:

int i = 255;
string binaryString = Convert.ToString (i, 2);

binaryString now equals 1111111.

This class library

These suffice in most situations, but I’ve often found I need a more natural/flexible way that basically wraps these functions up. This class library is a few simple bits of code to address this. All the structs are built around an Int32 (m_Value), so are therefore called Bin32, Oct32, and Hex32.

The first thing you’ll notice in each struct are several implicit and one explicit operator methods.

In Bin32, the first one is:

public static implicit operator Bin32(int value) {... }

This bit of magic allows us to accept an int directly to create an instance of Bin32, without needing to call an overloaded constructor in our code (it's done automatically to a private constructor). You can do this, for example:

Bin32 binaryValue = 255;

instead of the usual:

Bin32 binaryValue = new Bin32(255);

The next is similar, but allows us to use a string:

public static implicit operator Bin32(string value) {... }

So, we can simply use:

Bin32 binaryValue = "11111111";

A little further down is a similar method to the first, but with Bin32 and int reversed.

public static implicit operator int(Bin32 value) {... }

This allows us to automatically use our value as an int without explicitly casting.

Bin32 binaryValue = "11111111";
int i = binaryValue;

The next line is different in that it is explicit rather than implicit:

public static explicit operator string(Bin32 value) {... }

By using the explicit keyword, it means we have to explicitly cast to this type to use the method.

Bin32 binaryValue = "11111111";
string binaryString = (string)binaryValue;

Why not use implicit here? Well, having multiple implicit return types can cause some major headaches. Just try changing the explicit to implicit, and then try:

Console.WriteLine(binaryValue);

Oops! There is a lot of ambiguity created as it doesn’t know what to write to the console – more than one choice is too many!

Initially, I had the string as implicit and the int as explicit. It can work fine that way, but a lot more code is needed as all unary, binary, logical, and conditional operators then require overloading. Keeping the int as implicit, we get to use the code that Microsoft has already done for the Int32 operators :-).

For more information on operator overloading, see my article: An Introduction to Operator Overloading in C#'.

As well as the explicit cast there are also the two ToString methods (one for Oct32).

I’ve implemented the standard IComparable and IEquatable interfaces. The Parse, ToString, and TryParse methods are mainly covered in by the in-built functions I covered at the beginning of the article.

There is one other class here – a static class called ExtensionMethods, where a few simple extension methods are declared to give added functionality to ints and strings without having to actually call any Bin32, Oct32, or Hex32 instances ourselves.

In use

Add a reference to BinOctHex.dll to your project. Using these structs is very easy. A simple example is attached. All the usual stuff you can do with an int can be done with any of these (including bit shifting, which makes more sense in hex and binary). You can also do operations on combinations of these. E.g.:

(bin number % hexnumber) / octnumber;

Motivation for use

I often need to do calculations on multiple binary and hexadecimal numbers and have the results displayed in either base (octal less frequently, but I included it for completeness).

Imagine something simple such as:

((1 + 2 + 3 + 4 + 5) % 4) * 15 = ?

Easy if they're all ints, but what if they're mixed binary and hex strings?

((00000001 + 00000010 + 00000011 + 00000100 + 00000101) % 00000100) * 0F = ?(base 8)

Currently, you'd have to convert each string manually to an int, and then convert again to display the answer in the correct base. Using this, you just perform the calculation as it looks.

string a1 = "00000001";
string b1 = "00000010";
string c1 = "00000011";
string d1 = "00000100";
string e1 = "00000101";
string f1 = "00000100";
string g1 = "0F";

// Using methods built in.
int h1 = (
    (Convert.ToInt32(a1, 2) +
    Convert.ToInt32(b1, 2) +
    Convert.ToInt32(c1, 2) +
    Convert.ToInt32(d1, 2) +
    Convert.ToInt32(e1, 2))
    % Convert.ToInt32(f1, 2))
    * Convert.ToInt32(g1, 16);
Console.WriteLine(Convert.ToString(h1, 8));

Bin32 a2 = a1;
Bin32 b2 = b1;
Bin32 c2 = c1;
Bin32 d2 = d1;
Bin32 e2 = e1;
Bin32 f2 = f1;
Hex32 g2 = g1;

// Using Bin32, Oct32, Hex32 structs - a simple one liner
Oct32 h2 = ((a2 + b2 + c2 + d2 + e2) % f2) * g2;
Console.WriteLine((String)h2);

I also timed the code above, and both performed in roughly the same time - sometimes the first section was fractionally quicker, sometimes the second - so it's not slowing anything down at all. Working with straight ints is about 50x faster, but if you have data in a different base, then you have to do the conversion anyway. If you want to change it to an int to remove the overhead - that's what the implicit casting is for.

History

• 7^th August 2008: Initial version.
• 6^th October 2008: Linked to An Introduction to Operator Overloading in C#'.

You must Sign In to use this message board.

FAQ  Noise Tolerance Very HighHighMediumLowVery Low  Search Messages    Layout Expand All MessagesThread ViewNo Javascript (slow)No Javascript Preview    Per page 102550

Msgs 1 to 4 of 4 (Total in Forum: 4) (Refresh) FirstPrevNext

Hi Cape Town Developer 2:29 7 Oct '08   Thanks man, thank u im playing around with the .NET COM PORT Wrapper and the RS 323 protocall. I will look into this code, my usage for this will be for serial RS323 communication, i guess this will be usefull for encoding and decoding and monitoring bits comming thru via a COM Port, well thats my usage no need for binary viewing on my pc Wisdom is often meant as the ability and desire to make choices that can gain approval in a long-term examination by many people. Sign In·View Thread·PermaLink Re: Hi DaveyM69 2:49 7 Oct '08   You shouldn't need it for encoding/decoding but it could be useful for monitoring/logging. Thanks for taking a look, and for taking the time to comment. Dave BTW, in software, hope and pray is not a viable strategy. (Luc Pattyn) Visual Basic is not used by normal people so we're not covering it here. (Uncyclopedia) Sign In·View Thread·PermaLink Excellent merlin981 2:17 7 Oct '08   Excellent article. I can definitely find uses for these structs. Thanks for sharing. Five from me ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ LINQ Exchange - Learn about LINQ and Lambda Expressions Mentally Jumbled - Geek Blog Joke of the Day and Random Jokes - ReallyFunnyQuickJokes.com ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Sign In·View Thread·PermaLink Re: Excellent DaveyM69 2:48 7 Oct '08   Thanks Dave BTW, in software, hope and pray is not a viable strategy. (Luc Pattyn) Visual Basic is not used by normal people so we're not covering it here. (Uncyclopedia) Sign In·View Thread·PermaLink

Last Visit: Monday, December 1, 2008 8:57 PM     Last Update:Monday, December 1, 2008 8:57 PM