Next year it's starting with a busy busy month. This is the list of the engagements I already have, if you are nearby any of the cities I'll be visiting don't hesitate and we can have some beers ;) I'm also interested in meeting people in Tenerife that are willing to join INETA and create a .NET User Group over there...

So actually this are the planned speaks:

• C# 3.0 Language Features // Madrid .NET User Group, January, 18th 2007

Introducing Extension Methods, Query Languages, Lambda Expressions and all the upcoming C# 3.0 language features. Further details and registration at http://www.madriddotnet.com

• C# 3.0 Language Features // .NET User Group Galicia, Coruña, January, 19th 2007

First meeting of .NET User Group Galicia, and I'll be there presenting Extension Methods, Query Languages, Lambda Expressions and all the upcoming C# 3.0 language features. Further details and registration at http://www.nugg.es

• LOVE Tour: Windows Workflow and Windows Communication Foundation // Tenerife, January, 23rd 2007

I keep collaborating with MSDN presenting .NET Framework 3.0 over major cities in Spain. This time I'll be in Tenerife (Canary Islands) presenting Windows Workflow and Windows Communication Foundation. Further details and registration at http://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032312578&Culture=es-ES

• LOVE Tour: Windows Presentation Foundation // Málaga, January, 25th 2007

I keep collaborating with MSDN presenting .NET Framework 3.0 over major cities in Spain. This time I'll be in Málaga, directly from Tenerife, presenting user interface improvements with Windows Presentation Foundation. Further details and registration at http://msevents.microsoft.com/CUI/EventDetail.aspx?EventID=1032312580&Culture=es-ES

 More to come for February.

A couple of days ago my fellow friend Ricardo Varela started to blog in spanish (in parallel with his actual english blog). Former member of Microsoft communities, he is actually working at Google UK. The actual point is that on his new blog he started a post with some kind of coding teasers, going back to basics, to the principles of coding. This is going to be funny.

Well, this is my answer to his post. There were three questions regarding data structures and alternative thinking about reversing things.

• Do you know how to reverse a string? In example, if you get "abc" the returned string should be "cba"

This seemed pretty easy. In C# every string is represented as an array of chars, so you can use the indexers to get chars at any position and reverse them "manually" with something like:

string inputString = "abc";
string reversedString = string.Empty;

for (int c = inputString.Length; c > 0; c--)
{
    reversedString += inputString[c - 1];
}

Console.WriteLine("Original String: " + inputString);
Console.WriteLine("Reversed String: " + reversedString);

Or you can use some of the features of the .NET Framework to do it in a more "elegant" way:

char[] chars = inputString.ToCharArray();
Array.Reverse(chars);

// Use the reversed array of chars

• Going deeper into data structures, do you know how to reverse the bits of a byte? In example, if you get 1 the returned byte should be 128

I must admit this was a hard one. Although I perfectly know the concepts of bits and bitwise operations the C# language doesn't provide an easy or structured way to access those elementary elements of data structures. I finally managed to achieve it. The smallest numeric data structure available to represent a byte internals I found was a simple byte[8], so now I just have to fill it with the values for each byte:

static byte[] getBits(byte inputByte)
{
    byte[] bits = new byte[8];

    for (int p = 0; p < 8; p++)
    {
        bits[7 - p] = (byte)(1 & (inputByte >> p));
    }

    return bits;
}

Simple? Ok, I'll explain it a bit... the bitwise operator >> just shifts the bits in the byte to the right so if 01010101 is shifted one position to the right it becomes 00101010... then I perform a logical AND operation with the mask 00000001 to determine if the bit is setted. I just store the state of every bit in the output array and return it. As a quick note, the bit array could be directly reversed if I change the line inside the for loop to:

bits[p] = (byte)(1 & (inputByte >> p));

But I wanted more generic methods to convert between byte and bits, so I didn't included reversing directly in that method. Once I have an array, it's simple to reverse it just with the previous method used with string arrays or via the .NET framework features:

Array.Reverse(bits);

And know, we only have to be able to convert the bit array back to a byte structure:

static byte setBits(byte[] bits)
{
    byte obyte = bits[0];

    for (int p = 1; p < 8; p++)
    {
        obyte = (byte)((obyte << 1) + bits[p]);
    }

    return obyte;
}

The method used is similar to the one I used to extract the bits, but this time the bitwise operator << is shifting bits to the left, so I can increase the number til it reach to the desired value. A simple test program to test how it works would be:

byte inputByte = 1;
byte outputByte = 0;

byte[] bits = getBits(inputByte);
Array.Reverse(bits);
outputByte = setBits(bits);

Console.WriteLine("Input Byte: " + inputByte);
Console.WriteLine("Reversed Byte: " + outputByte);

• And a more complex one. Floating point numbers are represented usually by the standard IEEE 754, would you be able to reverse the bits of a floating point number? In example, if you get 118.625f the output should be -17180580000f

Wow! This is was a really hard one. I didn't know how the IEEE 754 standard worked so I read it at the wikipedia (the IEEE page for this standard is under revision and there was no info available) and it seems pretty simple. The floating point its a 32bit data structured divided like this:

So now it seems much simpler to me. It's just a bit reversing operation, in C# the two floating point structures are Float or Double, the former to store floating point numbers with 32bits precision and the last with 64bits; the problem is that those types don't allow bitwise operations, so I need to create a new set of methods to work with them using the BitConverter class.

It's probably refactorizable so just a pair of methods suit all the needs of bit operations, but the goal was to reverse the floating point number, so here I go:

static byte[] getFloatingBits(double input)
{
    byte[] bytes = BitConverter.GetBytes(input);

    if (BitConverter.IsLittleEndian)
    {
        Array.Reverse(bytes);
    }

    byte[] bits = new byte[64];

    for (int i = 0; i < 8; i++)
    {
        Array.Copy(getBits(bytes[i]), 0, bits, i * 8, 8);
    }

    return bits;
}

I explain the method it...The float type can by divided into 4 bytes and the BitConverter.GetBytes method can give us an array of that four bytes, but unfortunately it doesn't include a method to turn back an array of four bytes to a float, so I created this method for the double type and used casting :(

The method is pretty simple, I extract the 8 bytes of the double precision float number. Then, I verify if the processor is LittleEndian and in that case I reverse the byte order to reflect the actual value. Everything is copied to an array of bits, and we are done. Now we only need to reverse that array of bits:

Array.Reverse(bits);

And turn back to the method that reverse the process from a bit array to a double precision floating number:

static double setFloatingBits(byte[] bits)
{
    byte[] bytes = new byte[8];

    for (int i = 0; i < 8; i++)
    {
        byte[] actualByte = new byte[8];
        Array.Copy(bits, i * 8, actualByte, 0, 8);
        
        bytes[i] = setBits(actualByte);
    }

    if (BitConverter.IsLittleEndian)
    {
        Array.Reverse(bytes);
    }

    return BitConverter.ToDouble(bytes, 0);
}

The issue is that the expected floating number is not the one I got with this method that reverse the complete array of bits. In fact, I've also re-read the question and it said "are you able to reverse the order of the bits for the exponent and mantissa?" ... I actually did also that, reversing only bits for mantissa and exponent, obtaining the following bit arrays:

Original: 0 10000000 10111011010100000000000
Reversed: 0 00000001 00000000000101011011101
Expected: 1 10000100 00100000000000000101011

But that reversed number doesn't represent the one that Ricardo stated in his post. What am I doing wrong? Is anything wrong in my point of view or is the expected number wrong? I'm really curious about why there is one bit less in the expected number and how the sign bit changed.

During the following post I'm going to explain a design pattern widely used during software development processes and how it fits into the .NET ecosystem. This pattern would probably fits into the structural patterns group and it's mainly used to decouple components, so abstractions and concrete implementations can vary independently.

Using the provider pattern in .NET (and most object oriented languages) is pretty easy. We need the following artifacts:

• A provider definition, used as a contract that specifies what it should do
• One or multiple provider implementations of the declared contract
• A consumer willing to make use of the provider and it's implementations

Imaging the following real life scenario: There is a basic definition of what a car should do (provider definition) and what is considered a car: it must have 4 wheels, an engine, steering wheel, etc.. in the market you are able to find lot of implementations following the actual definition of a car (implementations of the provider), and we, as consumers, can make use of the knowledge and methods defined in the provider contract to change the implementation we use without affecting our behavior (we are able to switch cars and use the common definition of it, as a car, to drive any of the implementations).

So know, imagine it in the context of software development. We have an interface that defines a set of properties and methods that our provider must implement; we then have one or multiple implementations of that interface available; and of course, any consuming application can use the interface to switch between implementations without being affected. Have a look to the following diagram:

This is pretty awesome and practical when we are willing to create componentized and decoupled applications. We just use interfaces. This pattern has been widely used in the new ASP.NET 2.0 to create the application services provider infrastructure. For example, the MembershipProvider can be defined either as SqlMembershipProvider or as a custom OracleMembershipProvider; they both provide the same functionality but with different behavior (one uses SQL Server as repository while the other is using Oracle databases)

This pattern itself, IMHO, can dramatically increase the quality of your architecture because of the modularity and simplicity it provides.

One of the hidden treasures of .NET is the existence of a Provider Model Framework that allows you to create custom Providers for anything (not only extensions of ASP.NET Providers, but any kind of .NET application or service)

Using .NET Framework 2.0 Provider Model

So let's start writting some code. To create a provider we first have to create a public abstract class that defines our contract. This class must implement the System.Configuration.ProviderBase abstract class and it should contain the definition of methods and properties used as the "contract" of our provider.

1 public abstract class ImageProvider : ProviderBase
2 {
3    public abstract bool CanSaveImages { get; }
4    public abstract Image GetImage(int id);
5    public abstract void SaveImage(Image image);
6 }

We then need to add the actual implementations of the provider. In this case, we are going to add an image provider for the file system and an extra one for SQL Server.

 1 public class FileSystemImageProvider : ImageProvider
 2 {
 3     public override bool CanSaveImages
 4     {
 5         get
 6         {
 7             return true; // As we allow to save images
 8         }
 9     }
10 
11     public override Image GetImage(int id)
12     {
13         // Some witty code to get the image from a folder in the FileSystem
14         return null;
15     }
16 
17     public override void SaveImage(System.Drawing.Image image)
18     {
19         // Some witty code to save the image to a folder in the FileSystem
20     }
21 }
22 
23 
24 public class SqlImageProvider : ImageProvider
25 {
26     public override bool CanSaveImages
27     {
28         get
29         {
30             return true; // As we allow to save images
31         }
32     }
33 
34     public override Image GetImage(int id)
35     {
36         // Some witty code to get the image from a folder in the FileSystem
37         return null; ;
38     }
39 
40     public override void SaveImage(System.Drawing.Image image)
41     {
42         // Some witty code to save the image to a folder in the FileSystem
43     }
44 }

And finally, we need to create the service that will use the ImageProvider. It's is coupled to the contract definition of our provider and not to it's implementations, so it knows what to ask for but no actually how or where will it be done. The service just initializes the provider using the LoadProvider() method (it should read the provider from the config file; have in mind that here it's hardcoded for instructional purposes and you only need to change the LoadProvider method to achieve that goal)

 1 public class ImageService
 2 {
 3     private ImageProvider _provider;
 4 
 5     public ImageProvider Provider
 6     {
 7         get
 8         {
 9             return _provider;
10         }
11     }
12 
13     public ImageService()
14     {
15         LoadProvider();
16     }
17 
18     public void LoadProvider()
19     {
20         ProviderSettings ps = new ProviderSettings("FileSystemImageProvider", "FileSystemImageProvider_Type_Assembly");
21         _provider = ProvidersHelper.InstantiateProvider(ps, typeof(FileSystemImageProvider)) as ImageProvider;
22     }
23 
24     public Image GetImage(int id)
25     {
26         return _provider.GetImage(id);
27     }
28 
29     public void SaveImage(Image image)
30     {
31         _provider.SaveImage(image);
32     }
33 }

The main caveat of using the .NET Provider Model is that you must reference the System.Web assembly in, probably, non-web projects. This is needed in order to access the ProvidersHelper class used to instantiate the provider collection. And it also forces the application to use the System.Configuration namespace and classes to read the provider configuration located in the web.config or app.config files.

You'll have to deal with the types and assembly names where those types are defined to create the ProviderSettings instance needed by the ProvidersHelper.InstantiateProvider method. It's maybe not recommended to use all this "web" references in a desktop or service context; so there's a clean and elegant alternative for the OO purists :)

The pure OO implementation

So, we need to get rid of the System.Web reference and make the provider pattern work without using the .NET Framework 2.0 model. The first thing we need to do is to refactor provider's abstract class to an interface (or leave it as a class, it's up to you, but remove the ProviderBase inheritance and any reference to the System.Configuration namespace) and change the concrete providers implementations to make them use the newly created interface. The class diagram should look similar to:

First, we should create the following code for the provider contract:

1 public interface IImageProvider
2 {
3     bool CanSaveImages { get; }
4     Image GetImage(int id);
5     void SaveImage(Image image);
6 }

And of course change the signature of the concrete provider implementations for FileSystemImageProvider and SqlImageProvider so they use the new contract:

 1 public class FileSystemImageProvider : IImageProvider
 2 {
 3    // Implementation of the provider code, only signature of the class changed
 4 }
 5 
 6 
 7 public class SqlSystemImageProvider : IImageProvider
 8 {
 9    // Implementation of the provider code, only signature of the class changed
10 }

The ImageService still almost the same, we only need to change LoadProvider's code so it creates an instance of the desired concrete implementation without using the ProvidersHelper class. Something like this may work perfectly:

1 public void LoadProvider()
2 {
3     _provider = Activator.CreateInstance(typeof(FileSystemImageProvider)) as IImageProvider;
4 }

Any conclusion?

As you can see, the approach it's quite similar for both methods and it's really simple to introduce it in most of actual software projects and architectures. It provides ease of installation, highly decoupled systems and modularity both in development and deployment.

There's no excuse to avoid this pattern, as far as it's possible and pragmatic to use it in the context of your architecture :)

Hope this helps anyone.

Yesterday I spent all the day in the preconference sessions at TechEd Developers 2006. I was going to attend Software Architecture sessions by Scott Hanselman, by I ended up at Agile Team System sessions by Roy Osherove.

It's really interesting to see Royt explain Agile and Team System concepts, althought the were not very deep if you are experienced with agile methods and practices. We saw Agile concepts, TDD and Continuous Integrantion practices and finally how to apply Scrum with Team System.

The most productive part to me was the Scrum session, and I got a really nice piece of intelligence from the Test Driven Development session. The name of test methods is really important because it's used directly as documentation, as a permanent sample of your code represented by unit tests. I already knew this, but the naming rules I used made me create names like this:

public void CreateUserWithNullUserName

And there's nothing wrong with that name, it's almost perfect from my point of view, because it states clearly what the unit test is testing. But Roy presented a naming rule based in three parts that results in a much much better name:

public void CreateUser_WhenUsernameIsNull_ThrowsInvalidOperationException

Indredible!!! Much more pragmatic. Much more readable. Much simpler to see the behaviour of that unit test with the pattern MethodName_Behaviour_ExpectedResult.

This has become an adopted practice. Inmediatly. During the next days I'll keep posting my thoughts about TechEd and sessions here.

I've been a fan of Lego Mindstorms since I first saw it two or three years ago. I bought my own Robotic Invention System (well, frankly it was Diana's gift for one of my birthdays... yoohoo!!!) and I love it... it provides me great intellectual and funny moments... I've learned how to use C# and .NET to program my robots and tried to attach a bluetooth device to it with no success.

I was really sad when Lego retired the kit, because I thought it would be almost impossible to find more pieces or expansion kits... but far away from what I though Lego announced a new version of the Mindstorms kit called NXT ... and it looks much more impressive than (the now old-fashioned) RIS; look at it:

I want one of those now! While I manage to buy one this is a list of interesting resources (an interesting fact is that the Lego website is developed using ASP.NET):

• Lego Mindstorms NXT press announcement (dated 4 January?!?)
• http://www.nxtbot.com/
• Lego Mindstorms NXT product features
• Lego Mindstorms NXT Issues Call for "NXT" Great Developers

By the way... Just related to my Lego Mindstorms addiction, I'll be speaking in an event called Applied robotics with Lego Mindstorms and C# in our April meeting (third Thursday) at Madrid .NET User Group

It would be held in Madrid, Spain; and in perfect spanish :-D ... If you can pass by and visit us that day, it would be great!

As part of my MVP package I received an email from my MVP lead with 4 vouchers to upgrade my current certifications (MCAD and MCSD) to the new 2.0 certs. Actually I will take the following exams:

• 70-551 - UPGRADE: MCAD Skills to MCPD Web Developer by Using the Microsoft .NET Framework
• 70-552 - UPGRADE: MCAD Skills to MCPD Windows Developer by Using the Microsoft .NET Framework
• 70-553 - UPGRADE: MCSD Microsoft .NET Skills to MCPD Enterprise Application Developer by Using the Microsoft .NET Framework: Part 1
• 70-554 - UPGRADE: MCSD Microsoft .NET Skills to MCPD Enterprise Application Developer by Using the Microsoft .NET Framework: Part 2

All this exams are in beta status. I'll take all of them between Feb13th and Mar, 13th... one each Friday. There's no study materials nor books available yet, so the only info is what I already know and MSDN. I'm preparing a Fast Study Guide for each of those exams using the table of contents that Microsoft published in every prepartion guide (follow the links above) ... As soon as the TOC is almost complete I'll upload them so more people could use them to study for their exams.

Is anyone else taking this exams?

Hey, I just came from a quick new year's holidays in the snow and found in my mailbox that I've been awarded with an MVP for Visual Developer - Visual C# ... pretty good news and Xmas present to me. Thanks to the people who believed in me and had me in their minds for this award (I can assure you there are lot of benefits when becoming MVP) and I'll try me best to keep working for the communities (online and offline) during the whole 2006.

Thanks to Alberto Amescua, David Carmona and Alfonso Rodriguez from Microsoft Spain, to all the guys at INETA Europe, all the leaders of Spanish User Groups, all the members of Madrid .NET User Group... and, of course, to all the ilitios, my beloved mates at Ilitia Technologies.

I had the chance to read the overview and specs of Orcas' C# 3.0 and there are lot of interesting things that are put together to support LINQ in the next version of the language. One of the most easily applicable new features are Extension Methods, but what are they used for? Easy, the extend current types with new static methods by simply adding an using directive with the extender class and without adding a line of code to the previous existing classes... let's see an easy example:

 namespace Acme.Utilities
{
      public static class Extensions
      {
            public static int ToInt32(this string s) {
                  return Int32.Parse(s);
            }
            public static T[] Slice(this T[] source, int index, int count) {
                  if (index < 0 || count < 0 || source.Length – index < count)
                       throw new ArgumentException();
                  T[] result = new T[count];
                  Array.Copy(source, index, result, 0, count);
                  return result;
            }
      }
}

string s = "1234";
int i = s.ToInt32();  // Same as Extensions.ToInt32(s)
int[] digits = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int[] a = digits.Slice(4, 3);      // Same as Extensions.Slice(digits, 4, 3)

So, this seems quite useful to me right now, and obviously to the framework guys at Redmond. Firstly, the object type could be extended with lot of methods by simply adding the using System to each class, and thus classes will be more clean and modularized, containing only implementation and logic within their domain of action. Obviously, it wouldn't be that useful without C# 2.0 Generics, the cornerstone of all the upcoming features, and without new inference methods in arrays and vars.

Well, extension methods seems a bit like one step forward than implementing interfaces or inheritance... I mean, why would I implement IMyInterface or inherit from a base class to extend it if I can extend my objects by simply adding an using MyNamespace.IMyExtension??

Actually, I have in mind an easy-to-think example of a good scenario to apply method extensions: data access layers and object to relational mappers... Guess the following:

We may have a set of object classes that describe the entities in my scenario, all of them decorated with a set of attributes that declare how they map to my rdbms database (i.e. table name, relations, fields, etc...) Now, guess we have developed a set of classes that contains typical database methods (save, retrieve, update, find, etc...) declared with generic types, and instrumented with the ability to read types attributes to discover what procedures and tables should it call to retrieve data...

In this case, when we have our two dll's compiled (entities and the datamapping framework) it's just a done-puzzle to extend my entities with the new persistence methods and have full access to the database and data without modifying my original entities' code. And going further, this is so reusable that it can be plugged everywhere as far as my original classes contain the required attribute decoration to support the datamapping extension.

It's just a shame that we have to wait that long to see this feature working in our development environments; but you can still test it with the C# 3.0 Community Technology Preview

I'm finally releasing the source code of my Clearscreen SharpHIP 1.4 control, just in case any of wanna have a look to it. Download it here

If you are new to the control, it's an approach of a Human Interaction Proof within a C# control that was created to stop spam comments on blogs and prevent automatic form submission in ASP.NET applications. Have a look to the latest binaries release, because you'll find a readme.txt file there with instructions on how to install and use it.

The source code is provided "as is", without any documentation beyond the source code. Anyway it's a quite simple control that features how to render images on the fly.

I've updated the Clearscreen.SharpHIP control to solve most of the reported issues. The new features and fixes for this release are:

• Bug Fixed: Enabled deletion of comments in .Text versions for logged admins
• Bug Fixed: Use of IsValid property is now working correctly
• Bug Fixed: Session and ViewState values for ValidationForm where mistyped on the code and where not working correctly.
• New features added:
  • Removed captcha at all when an admin or trusted used is logged in
  • Added support and compatibility for the new Community Server v1.0
  • Added help to install on Community Server v1.0
  • Added JavascriptURLDetection property (bool) to use Javascript or Server
  • side code to detect the URL that should be used in the image source.

Follow the link to download: Clearscreen SharpHIP HIP-CAPTCHA Control v1.4 for ASP.NET

Hope that this new release helps to solve most of the actual issues, but if you find any bug or have any improvement that wasn't contained within this version, contact me and I'll try my best to solve it.

UPDATE: I updated the control to solve a reported error with image generation and javascript on some situations where the page that host the control has a formal querystring. The update is included in the zip file. [05/04/2005 21:00 GMT+1]