corniel.nl/blog

Every developer has to debug the code he is working on. You IDE helps you by showing your local variable watches and, allowing you to define watches. Those watches are the ToString() representation of the objects/expressions you watch.

That’s nice, but you can improve this experience a lot by defining your own debugger display! Of course, there some types in .NET that show you more than the default implementation of object (ToString(){ return GetType().FullName; }), but for you own classes, this is the behavior, by default.

So, what to do? Well, you can implement ToString() for your class, but there are a lot of scenario’s (take ToString() for XDocument) where the result of ToString() is not what you want for your debugger display. Fortunately, .NET gives you the opportunity to add the DebuggerDisplayAttribute. This attrubute decorates your class with an instruction so that your debugger knows what to do, when showing a watch on it.

Basically, you can write a full expression in the attribute constructor argument, but referring to a (non public) property is more convenient. You can refer to a method too, but this can lead to unintended behavior. The expression is evaluated by the runtime and debugging a VB.NET project will give you a warning “Because the evaluation could cause side effects, it will not be executed, until enabled by the user”, even if the debugger display is implemented in C#. Using properties will not lead to this kind of situations.

For most situations you want to return a string, but you can return other objects as well. The IDE will call the DebuggerDisplay of that object. The cases where this can be of value, is where you want to show 17 instead of “17”. Most of the time returning a string is what you want.

[code=C#]using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;

namespace HelloWorld
{
[DebuggerDisplay("{DebuggerDisplay}")]
public class DebuggerDisplayClassStringProperty
{
public int Number { get; set; }
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
private string DebuggerDisplay { get { return this.Number.ToString(CultureInfo.InvariantCulture); } }
}

[DebuggerDisplay("{DebuggerDisplay()}")]
public class DebuggerDisplayClassStringMethod
{
public int Number { get; set; }
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
private string DebuggerDisplay() { return this.Number.ToString(CultureInfo.InvariantCulture); }
}

[DebuggerDisplay("{DebuggerDisplay}")]
public class DebuggerDisplayClassObjectProperty
{
public int Number { get; set; }
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
private int DebuggerDisplay { get { return this.Number; } }
}

[DebuggerDisplay("{DebuggerDisplay()}")]
public class DebuggerDisplayClassObjectMethod
{
public int Number { get; set; }

[ExcludeFromCodeCoverage]
[DebuggerBrowsable(DebuggerBrowsableState.Never)]
private int DebuggerDisplay() { return this.Number; }
}
}[/code]

If you want to create unit tests for it, is up to you, and if you expose the property publicly. If you don’t want to unit test the functionality, I recommend the use of the ExcludeFromCodeCoverage attribute. If you want to test it, you can use reflection.

[code=C#]using NUnit.Framework;
using System.Reflection;

namespace HelloWorld.UnitTests
{
[TestFixture]
public class DebuggerDisplayClassTest
{
[Test]
public void DebuggerDisplay_StringMethod_String17()
{
var cls = new DebuggerDisplayClassStringMethod() { Number = 17 };
var dd = cls.GetType().GetMethod(“DebuggerDisplay”, BindingFlags.Instance | BindingFlags.NonPublic);

var act = dd.Invoke(cls, new object[0]);
var exp = “17”;

Assert.AreEqual(exp, act);
}

[Test]
public void DebuggerDisplay_ObjectMethod_Int17()
{
var cls = new DebuggerDisplayClassObjectMethod() { Number = 17 };
var dd = cls.GetType().GetMethod(“DebuggerDisplay”, BindingFlags.Instance | BindingFlags.NonPublic);

var act = dd.Invoke(cls, new object[0]);
var exp = 17;

Assert.AreEqual(exp, act);
}

[Test]
public void DebuggerDisplay_StringProperty_String17()
{
var cls = new DebuggerDisplayClassStringProperty() { Number = 17 };
var dd = cls.GetType().GetProperty(“DebuggerDisplay”, BindingFlags.Instance | BindingFlags.NonPublic);

var act = dd.GetValue(cls);
var exp = “17”;

Assert.AreEqual(exp, act);
}

[Test]
public void DebuggerDisplay_ObjectProperty_Int17()
{
var cls = new DebuggerDisplayClassObjectProperty() { Number = 17 };
var dd = cls.GetType().GetProperty(“DebuggerDisplay”, BindingFlags.Instance | BindingFlags.NonPublic);

var act = dd.GetValue(cls);
var exp = 17;

Assert.AreEqual(exp, act);
}
}
}[/code]

14 tech·days

Two days of new technology

Last week, I went to the tech days. I would like to share some thoughts and impressions with you. Feel free to comment, share your own thoughts.

wo 16 april 2014

Massive.js [key note]

Erich Gamma showed Monaco, the online development platform of Microsoft. It was quite impressive to see such a huge application written in JavaScript. The focus of the talk was in how to manage this code. The Monaco team faced big issues passing the 100kloc. JavaScript is really (too) forgiving. That, combined with the lack of interfacing and strong typing, the introduced TypeScript. The concluded that TypeScript saved there day, and should always be considered when you’re adding more than just some lines of JavaScript code.

Some TV crew took my by surprise after the session:

New and improved ASP.NET MVC 5/Web API2

This was a nice – and nothing more – talk about the new MVC(5) stuff. MS added a nice feature to MVC5/API2: The routing attribute, a real improvement imho. The focus was more on Web API, than on MVC. I think this is a good thing. Personally I would not recommend the use of MVC in the traditional serverside approach at all. Furthermore, I would not be surprised if Web API 3 (or a later version) will be released independent from MVC (or without).

Fundamentals guide to HDP & HDInsight

This talk was about HaDoop, an open source framework developed by Yahoo. It allows you to analyze Big Data using map/reduce. For .NET the allow querying using Linq. Really interesting stuff!

See: hadoopsdk.codeplex.com

Using NuGet the way you should

I was really looking forward to this this session, and it was a nice talk. Unfortunately (due to continuous crashes of Visual Studio) there was not enough time for questions (I had some). In general: if you distribute code and/or libraries use NuGet. Not only because it can speed up development (by reducing the compilation time), it also forces you to think about versioning and separating concerns.

Using Orleans for building scalable cloud applications

Orleans is a MS platform that is developed to make (the game) Helo more scalable. The way it works by creating factories (Silo) that supply proxy references (grains) to the actual instances. Orleans decides where the real instances live, and can handle the up and down scaling. It is a powerful framework, but more suited for applications like Helo, than for applications like Exact Online. But maybe at some point It can become interesting for us too.

See: research.microsoft.com/en-us/projects/orleans

do 17 april 2014

Xamarin: native apps for iOS/Android in C#

Two years ago, I went to a Xamarin session, and I was quite impressed. I downloaded it and tried to get started. Unfortunately, the evaluation version was so limited that you hardly could do anything with it. What a deception that this is still the case. Furthermore, the development experience for iOS is still (a little) hell. But, and that is the good thing, what can be accomplished with Xamarin is great. If you have to develop native apps on commercial base, Xamarin should be your choice if you have a C# background.

Using MVVM so you can write better code and less code

MVVM (Model-View-View model) is approach that has a lot of strong advocates. In fact, a lot of client side frameworks (like Knockout and AngularJS) are MVVM. This session used (server side) MVC.NET, but it was not about the framework, it was about the methodology (and that was good!). The view model is the key in this approach. It fills the gap between the model (and data) and the view. It handles changes of the model (and therefor the view). When the view model changes, it notifies the view, so that it can update, if the view needed new data, the view model delivers. Calculations needed for the view are done by the view model too. The claim of the speaker that this results in less code is discussable, the first one is not. This will definably improve your code quality! If you did not already use this pattern, you start using it right now.

Event processing at all scales with RX

Bart De Smet is a phenomenon. If he speaks somewhere, I always want to be at least at one of his talks. Therefor I ended up at an RX (Reactive Extensions). De Smets is working on Cortana, an digital assistant or Windows Phone. It serializes expressions and enables the handling of the RX events in the cloud (Azure). It was a nice talk, but not as good (imho) as earlier talks I went to. Still, if you missed it, you should watch the video.

Games Services and Telemetry Processing in MS Azure

I have to admit that I was triggered by “Games”, but in fact this talk was on telemetry processing, and not on gaming. It was really good talk, and showed some nice ways of processing Big Data using Azure.

Conclusions

By going to the cloud (whatever cloud that is) means that code becomes async. Depending on you requirements, data, events, and/or computing can be moved to the cloud. There are no free lunches there, so you always have to do the math first.

JavaScript is only becoming more important, so get your hands dirty and do a lot of JS coding. Try AngularJS, Knockout (also for hands on experience on MVVM), and of course TypeScript.

Programming today is a race between software engineers striving to build bigger and better idiot-proof programs, and the Universe trying to produce bigger and better idiots. So far, the Universe is winning (..)

Rick Cook

Creating a Windows icon containing multiple bitmaps is not supported by .NET. Fortunately, on the net (the other one) I found a (version 1.1) .NET implementation to read a multi icon.

The re-usability wasn’t that great, merging and writing was not supported, and as .NET 1.1 did not support Typed lists yet, I had to rewrite it all:

[code=c#]using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Linq;

namespace HelloWorld.Drawing
{
///

public class MultiIcon : List
{
///

public MultiIcon() { }

///

public override string ToString()
{
var str = string.Format(“{0} Items: {1}”,
GetType().FullName,
this.Count);
if (this.Count == 1)
{
str += string.Format(“, Size: {0} px”,
this.First().Width);
}
if (this.Count > 1)
{
str += string.Format(“, Smallest: {0} px, Largest: {1} px”,
this.GetSmallest().Width,
this.GetLargest().Width);
}
return str;
}

///

/// The filepath to load from. public static MultiIcon Load(string filepath)
{
using (var stream = new FileStream(filepath, FileMode.Open, FileAccess.Read))
{
return Load(stream);
}
}
///

/// The stream to load from. public static MultiIcon Load(Stream stream)
{
// Read the stream.
using (var reader = new BinaryReader(stream))
{
var icon = new MultiIcon();
var entries = new List();

// Read the header.
var header = reader.ReadMultiIconHeader();

// Read the icon entries.
for (int i = 0; i < header.Count; i++)
{
var entry = reader.ReadMultiIconEntry();
entries.Add(entry);
}
// Read the icons based on the entries.
foreach (var entry in entries)
{
var ico = reader.ReadIcon(header, entry);
icon.Add(ico);
}
return icon;
}
}
}

///

public static class MultiIconExtensions
{
///

/// The list of icons. /// The filepath to save to. public static void Save(this IList icons, string filepath)
{
using (var stream = new FileStream(filepath, FileMode.CreateNew, FileAccess.Write))
{
icons.Save(stream);
}
}
///

/// The list of icons. /// The stream to save to. public static void Save(this IList icons, Stream stream)
{
using (var writer = new BinaryWriter(stream))
{
long startposition = stream.Position;

var entries = new List();
var buffers = new List();
// create header.
var header = new MultiIconHeader()
{
Count = (short)icons.Count,
};
// create entries.
for (int i = 0; i < icons.Count; i++)
{
using (var icon_stream = new MemoryStream())
{
var entry = new MultiIconEntry();
var item = icons[i];
item.Save(icon_stream);
icon_stream.Position = 0;

using (var reader = new BinaryReader(icon_stream))
{
// icoHeader.Reserved[2],
// icoHeader.Type[2],
// none.Pos[2],
// Width[1],
// Height[1],
// ColorCount[1],
// Reserved[1]
// Planes[2]
// BitCount[2]
// BytesInRes[4]
// none.OffSet[4]
var header_reserved = reader.ReadInt16();
var header_type = reader.ReadInt16();
var none_startpos = reader.ReadInt16();
entry.Width = reader.ReadByte();
entry.Height = reader.ReadByte();
entry.ColorCount = reader.ReadByte();
entry.Reserved = reader.ReadByte();
entry.Planes = reader.ReadInt16();
entry.BitCount = reader.ReadInt16();
entry.BytesInRes = reader.ReadInt32();
entry.ImageOffset = MultiIconHeader.ByteSize + MultiIconEntry.ByteSize * icons.Count + buffers.Sum(buf => buf.Length);
var none_offset = reader.ReadInt32();

var buffer = new byte[icon_stream.Length - icon_stream.Position];
icon_stream.Read(buffer, 0, buffer.Length);
entries.Add(entry);
buffers.Add(buffer);
}
}
}
// Writer header.
writer.Write(header);

// Write entries.
foreach (var entry in entries)
{
writer.Write(entry);
}
// Write images.
foreach (var buffer in buffers)
{
writer.Write(buffer);
}
// Clear buffer and save.
writer.Flush();
}
}

///

/// The list of icons. /// The smallest icon.
public static Icon GetSmallest(this IEnumerable icons)
{
var icon =
(
from
item in icons
orderby
item.Width ascending
select
item
)
.FirstOrDefault();

return icon;
}
///

/// The list of icons. /// The largest icon.
public static Icon GetLargest(this IEnumerable icons)
{
var icon =
(
from
item in icons
orderby
item.Width descending
select
item
)
.FirstOrDefault();

return icon;
}
}
///

internal class MultiIconHeader
{
///

public const int ByteSize = 2 + 2 + 2;

///

public MultiIconHeader()
{
this.Type = 1;
}

public short Reserved { get; set; }
public short Type { get; set; }
public short Count { get; set; }
}

///

internal static class MultiIconHeaderExtensions
{
///

/// The reader. public static MultiIconHeader ReadMultiIconHeader(this BinaryReader reader)
{
var header = new MultiIconHeader()
{
Reserved = reader.ReadInt16(),
Type = reader.ReadInt16(),
Count = reader.ReadInt16(),
};
return header;
}

///

/// The writer. /// The Windows multi icon header to write. public static void Write(this BinaryWriter writer, MultiIconHeader header)
{
writer.Write(header.Reserved);
writer.Write(header.Type);
writer.Write(header.Count);
}
}
///

internal class MultiIconEntry
{
///

public const int ByteSize = 1 + 1 + 1 + 1 + 2 + 2 + 4 + 4;

///

public MultiIconEntry() { }

public byte Width { get; set; }
public byte Height { get; set; }
public byte ColorCount { get; set; }
public byte Reserved { get; set; }
public short Planes { get; set; }
public short BitCount { get; set; }
public int BytesInRes { get; set; }
public int ImageOffset { get; set; }
}

///

internal static class MultiIconEntryrExtensions
{
///

/// The reader. public static MultiIconEntry ReadMultiIconEntry(this BinaryReader reader)
{
var entry = new MultiIconEntry()
{
Width = reader.ReadByte(),
Height = reader.ReadByte(),
ColorCount = reader.ReadByte(),
Reserved = reader.ReadByte(),
Planes = reader.ReadInt16(),
BitCount = reader.ReadInt16(),
BytesInRes = reader.ReadInt32(),
ImageOffset = reader.ReadInt32(),
};
return entry;
}

///

/// The reader. public static Icon ReadIcon(this BinaryReader reader, MultiIconHeader header, MultiIconEntry entry)
{
const short ICON_STREAM_START = 1;
const int ICON_STREAM_OFFSET = 22;

using (var newIcon = new MemoryStream())
{
using (var writer = new BinaryWriter(newIcon))
{
// Write it
writer.Write(header.Reserved);
writer.Write(header.Type);
writer.Write(ICON_STREAM_START);
writer.Write(entry.Width);
writer.Write(entry.Height);
writer.Write(entry.ColorCount);
writer.Write(entry.Reserved);
writer.Write(entry.Planes);
writer.Write(entry.BitCount);
writer.Write(entry.BytesInRes);
writer.Write(ICON_STREAM_OFFSET);

// Grab the icon
byte[] tmpBuffer = new byte[entry.BytesInRes];
reader.BaseStream.Position = entry.ImageOffset;
reader.Read(tmpBuffer, 0, entry.BytesInRes);
writer.Write(tmpBuffer);

// Finish up
writer.Flush();
newIcon.Position = 0;
return new Icon(newIcon);
}
}
}

///

/// The writer. /// The Windows multi icon entry to write. public static void Write(this BinaryWriter writer, MultiIconEntry entry)
{
writer.Write(entry.Width);
writer.Write(entry.Height);
writer.Write(entry.ColorCount);
writer.Write(entry.Reserved);
writer.Write(entry.Planes);
writer.Write(entry.BitCount);
writer.Write(entry.BytesInRes);
writer.Write(entry.ImageOffset);
}
}
}[/code]

It works perfectly. The only thing I still need to solve is the conversion of PNG24 to ICO:
[code=c#]var icon = Icon.FromHandle(new Bitmap("some_pgn24.png").GetHicon());[/code]
This results in an icon that does not have an alpha-channel. When I solved this, I will inform you.

Probably you are familiar with ISO. Some guys in a big office creating tons of paperwork every year. One of the standards they created is 8601. One of the items it describes is the number of the week, witch is commonly used.

Unfortunately Microsoft didn’t add an implementation for this week number in its .NET framework. A colleague of mine found one and added it to our extensions:

[code=c#]namespace HelloWorld.Extensions
{
public static class DateTimeExtensions
{
/// Returns ISO WeekNumber (1-53) for a given year.
///
The datetime. public static int ISOWeekNumberOld(this System.DateTime dt)
{
// Set Year
int yyyy = dt.Year;
// Set Month
int mm = dt.Month;
// Set Day
int dd = dt.Day;
// Declare other required variables
int DayOfYearNumber;
int Jan1WeekDay;
int WeekNumber = 0, WeekDay;
int i, j, k, l, m, n;
int[] Mnth = new int[12] { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
int YearNumber;
// Set DayofYear Number for yyyy mm dd
DayOfYearNumber = dd + Mnth[mm - 1];
// Increase of Dayof Year Number by 1, if year is leapyear and month is february
if ((DateTime.IsLeapYear(yyyy) == true) && (mm == 2))
DayOfYearNumber += 1;
// Find the Jan1WeekDay for year
i = (yyyy – 1) % 100;
j = (yyyy – 1) – i;
k = i + i / 4;
Jan1WeekDay = 1 + (((((j / 100) % 4) * 5) + k) % 7);
// Calcuate the WeekDay for the given date
l = DayOfYearNumber + (Jan1WeekDay – 1);
WeekDay = 1 + ((l – 1) % 7);
// Find if the date falls in YearNumber set WeekNumber to 52 or 53
if ((DayOfYearNumber <= (8 – Jan1WeekDay)) && (Jan1WeekDay > 4))
{
YearNumber = yyyy – 1;
if ((Jan1WeekDay == 5) || ((Jan1WeekDay == 6) && (Jan1WeekDay > 4)))
WeekNumber = 53;
else
WeekNumber = 52;
}
else
YearNumber = yyyy;
// Set WeekNumber to 1 to 53 if date falls in YearNumber
if (YearNumber == yyyy)
{
if (DateTime.IsLeapYear(yyyy) == true)
m = 366;
else
m = 365;
if ((m – DayOfYearNumber) < (4 – WeekDay)) { YearNumber = yyyy + 1; WeekNumber = 1; } } if (YearNumber == yyyy) { n = DayOfYearNumber + (7 – WeekDay) + (Jan1WeekDay – 1); WeekNumber = n / 7; if (Jan1WeekDay > 4)
WeekNumber -= 1;
}
return (WeekNumber);
}
}
}
[/code]

Not only is this an extreme unreadable piece of code, it seems to be invalid as well. So I decided to create something more understandable:

[code=c#]namespace HelloWorld
{
/// Represents a date as specified by ISO 8601 week date.
///
/// See: http://en.wikipedia.org/wiki/ISO_8601
/// and: http://en.wikipedia.org/wiki/ISO_week_date
///
public struct Iso8601WeekDate
{
private int m_Day;
private int m_Year;
private int m_Week;
private DateTime m_Date;

/// Initializes a new instance of the Tjip.Iso8601WeekDate structure to the specified System.DateTime.
///
The date of the ISO 8601 WeekDate. public Iso8601WeekDate(DateTime date)
{
// Only the date will be available.
m_Date = date.Date;
// Set the year.
m_Year = date.Year;
// The day is oke by default, Unless its sunday (int value = 0)…
m_Day = (date.DayOfWeek == DayOfWeek.Sunday) ? 7 : (int)date.DayOfWeek;

// Now the week number.
DateTime startdate = GetFirstDayOfFirtWeekOfYear(date.Year);
DateTime enddate = GetFirstDayOfFirtWeekOfYear(date.Year + 1);
// The date is member of a week in the next year.
if (m_Date >= enddate)
{
startdate = enddate;
m_Year++;
}
// The date is member of a week in the previous year.
if (m_Date < startdate)
{
startdate = GetFirstDayOfFirtWeekOfYear(date.Year – 1);
m_Year–;
}
// Day of the week.
int dayofyear = (m_Date – startdate).Days;

// The week number is not zero based.
m_Week = dayofyear / 7 + 1;
}

/// Gets the date component of this instance.
public DateTime Date { get { return m_Date; } }
/// Gets the year component of the date represented by this instance.
public int Year { get { return m_Year; } }
/// Gets the week component of the date represented by this instance.
public int Week { get { return m_Week; } }
/// Gets the day component of the date represented by this instance.
public int Day { get { return m_Day; } }

/// Gets the date of the first day of the first week of the year.
///
/// Source: http://en.wikipedia.org/wiki/ISO_8601
///
/// There are mutually equivalent descriptions of week 01:
/// – the week with the year’s first Thursday in it (the formal ISO definition),
/// – the week with 4 January in it,
/// – the first week with the majority (four or more) of its days in the starting year,
/// – the week starting with the Monday in the period 29 December – 4 January.
///
public static DateTime GetFirstDayOfFirtWeekOfYear(int year)
{
DateTime start = new DateTime(year, 01, 04);
while (start.DayOfWeek != DayOfWeek.Monday)
{
start = start.AddDays(-1);
}
return start;
}

/// Represents the Tjip.Iso8601WeekDate as System.String.
public override string ToString()
{
return ToString(“YYYY-Www-D”);
}
/// Represents the Tjip.Iso8601WeekDate as System.String.
///
The format. ///
/// Representations of the following formatting are allowed:
/// – YYYYWww
/// – YYYY-Www
/// – YYYYWwwD
/// – YYYY-Www-D
///
/// [YYYY] indicates the ISO week-numbering year which is slightly different
/// to the calendar year (see below).
///
/// [Www] is the week number prefixed by the letter ‘W’, from W01 through W53.
///
/// [D] is the weekday number, from 1 through 7, beginning with
///
/// Monday and ending with Sunday. This form is popular in the
/// manufacturing industries.
///
public string ToString(string format)
{
switch (format)
{
case “YYYYWww”: return string.Format(“{0}W{1:00}”, this.Year, this.Week, this.Day);
case “YYYY-Www”: return string.Format(“{0}-W{1:00}”, this.Year, this.Week, this.Day);
case “YYYYWwwD”: return string.Format(“{0}W{1:00}{2}”, this.Year, this.Week, this.Day);
case “YYYY-Www-D”: return string.Format(“{0}-W{1:00}-{2}”, this.Year, this.Week, this.Day);
default: throw new NotSupportedException(string.Format(“The format ‘{0}’ is not supported.”, format));
}
}
/// Returns the hash code for this instance.
///
/// A 32-bit signed integer that is the hash code for this instance.
///
public override int GetHashCode()
{
// It should be fast, so shift.
// ..3…..6…………14 = 23 bit
// bits: DDDWWWWWWYYYYYYYYYYYYYY
int hash = this.Day + this.Week >> 3 + this.Year >> 9;
return hash;
}
}
}[/code]

And to extend it to System.DateTime:

[code=c#]namespace HelloWorld.Extensions
{
public static class DateTimeExtensions
{
public static Iso8601WeekDate ToIso8601WeekDate(this DateTime dt)
{
return new Iso8601WeekDate(dt);
}
/// Returns the (ISO 8601) number of the week.
///
The datetime. /// The (ISO 8601) number of the week.
///
/// Source: http://en.wikipedia.org/wiki/ISO_8601
///
public static int ISO8601WeekNumber(this DateTime dt)
{
Iso8601WeekDate weekdate = new Iso8601WeekDate(dt);
return weekdate.Week;
}
}
}[/code]

Not only is this imho much easier to read (and working correctly), you can format it like ISO spected it.

Well, no comment required, i guess.

[code=c#](..)
if (contextvalue == 0)
{
string empty = “”;
return (empty.ToString());
}[/code]

Sometimes, you write a piece of code you’re proud of. Because it’s a clever, elegant, or just fun. The snippet I post here is a bit of all, at least in my opinion.

[code=c#]///

/// Number to convert. /// Formatted Roman number.
public static string ToFormattedRomanNumber(int number)
{
if (number <= 0 || number > 3999)
{
throw new ArgumentOutOfRangeException(“With the default ASCII set only Roman numerals between 1 and 4000 can be represented.”);
}
// 1, 5, 10, 50, 100, 500, 1000.
string[] order = { “I”, “V”, “X”, “L”, “C”, “D”, “M” };
int pointer = 0;
int digits = number;
string result = string.Empty;

while (digits > 0)
{
int digit = digits % 10;
switch (digit)
{
case 0: break;
case 1: result = string.Format(
“{1}{0}”, result, order[pointer]);
break;
case 2: result = string.Format(
“{1}{1}{0}”, result, order[pointer]);
break;
case 3: result = string.Format(
“{1}{1}{1}{0}”, result, order[pointer]);
break;
case 4: result = string.Format(
“{1}{2}{0}”, result, order[pointer], order[pointer + 1]);
break;
case 5: result = string.Format(
“{1}{0}”, result, order[pointer + 1]);
break;
case 6: result = string.Format(
“{2}{1}{0}”, result, order[pointer], order[pointer + 1]);
break;
case 7: result = string.Format(
“{2}{1}{1}{0}”, result, order[pointer], order[pointer + 1]);
break;
case 8: result = string.Format(
“{2}{1}{1}{1}{0}”, result, order[pointer], order[pointer + 1]);
break;
case 9: result = string.Format(
“{1}{2}{0}”, result, order[pointer], order[pointer + 2]);
break;
}
digits = digits / 10;
pointer = pointer + 2;
}
return result;
}[/code]