.NET at 9.400 ft above sea level : C#

Visual Studio 2010 and .NET Framework Beta 2 available on Wednesday

Edgar Sánchez — Mon, 19 Oct 2009 16:31:27 GMT

This blog has been abandoned for the longest time :-$ but I’ve got great news to try and re-inaugurate it (again): it’s just been announced that beta 2 for Visual Studio 2010 and .NET Framework 4 will be available the day after tomorrow, i.e. on October 21st; moreover, we now have a firm date for the launch of the final versions of these products: March 22nd 2010. There is a lot of cool stuff in the new versions of Visual Studio and .NET Framework but my personal favorites (at least for the time being :-) are:

The inclusion of dynamic programming elements in C# and other framework languages. Good things from languages like Python, Groovy, or Ruby are now an integral part of C#.
The inclusion of F# as a first level language of the .NET Framework, welcome functional programming to the most popular commercial development platform on the planet!
A new version of Entity Framework, making the oficial .NET ORM tool more flexible and adequate. Less and less, we’ll need to code SQL by hand and laboriously move data from tables to objects and viceversa.

As I said, there’s a lot of cool stuff in Visual Studio 2010 and .NET Framework 4, but I plan to start using those three things as soon as possible in customer projects, after all, to have success stories by March 2010, we have to start working before this year ends.

Cloning objects in .NET

Edgar Sánchez — Sun, 18 May 2008 06:27:38 GMT

In an interesting project where I'm giving a hand, we need to clone objects of a number of different types, perhaps surprisingly the CLR doesn't offer a general cloning method, of course you could use MemberwiseClone() but this is a protected method, so it can be invoked only from inside the class of the object being cloned, which makes it difficult to use it in a general method, besides, MemberWiseClone() does just a shallow copy and what we really need is a deep copy.

There is a good reason for not having such a general method: object cloning is one of those problems which have a simple solution for simple scenarios but that resist a satisfactory solution for all the scenarios, for example the objects may have references to other objects and even to themselves be it directly or after a long chain, for example a customer has invoices that have payments that refer to the customer, a general cloning algorithm for a web several times more complex than that is anything but trivial. But the need of moving objects (and their web) is inescapable in distributed environments, because you have to move the invoices and the customers from the business layer to the presentation layer, so there are indeed mechanisms, albeit with some limitations, for serializing and deserializing object graphs, with the help of these mechanisms we can try and build a general object cloner:

    1 
    2     public static T BinaryClone<T>(this T originalObject)
    3     {
    4         using (var stream = new System.IO.MemoryStream())
    5         {
    6             var binaryFormatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
    7             binaryFormatter.Serialize(stream, originalObject);
    8             stream.Position = 0;
    9             return (T)binaryFormatter.Deserialize(stream);
   10         }
   11     }
   12 

We just convert, using as intermediary a memory stream, our object to a bit string and then we synthesize a *new object* from that bit string. The use of BinaryClone() flows nicely:

    1 
    2     var clone = person.BinaryClone();
    3 

Easy to write, but we have to be careful of the performance and the corner cases. I run a few *very informal* performance tests with this object:

    1 
    2     var person = new Person
    3     {
    4         Id = 101,
    5         Name = "Sánchez, Sebastián",
    6         Salary = 590.20m,
    7         BirthDate = new DateTime(2000, 6, 15),
    8         Address = new Address { Number = "N24-78", Street = "Pasaje Córdova" }
    9     };
   10 

And I found that doing a hundred thousand clones takes some nine thousand milliseconds, that is each cloning takes less than one ten-thousandth of a second, which is adequate to our needs. BinaryFormatter has been with us since .NET Framework 1.0 so I'm not like saying anything even remotely new or unknown, but tomorrow (or the day after, or the day after...) I'll talk about a small refinement to BinaryClone().

A cool way to find out whether a number is palindromic

Edgar Sánchez — Tue, 06 May 2008 06:40:08 GMT

In this blog entry I proposed a solution to Problem 4 at Project Euler, a crucial element of the problem is to find out whether a number is a palindrome (909 is, 809 isn't), a bit out of laziness and a bit in order to reuse existing methods, I decided to verify the palindrome by converting the number into a char array and then comparing this array with its mirror version, it works but it's not really that mathematical... Dustin Campbell proposed a solution kind of similar to mine (alas, more elegant and, above that, in F#) and using the same trick of converting the number to chars, as he didn't like this part of the solution, in this new blog entry he proposes the detection of a palindrome by mirroring the number one digit at a time. A translation of his F# code to C# 3.0 could be:

    1     Func<int, int, int> TailReverseNumber = null;
    2     TailReverseNumber = (n, res) => n == 0 ? res : TailReverseNumber(n / 10, 10 * res + n % 10);
    3 
    4     Func<int, bool> IsPalindrome = n => n == TailReverseNumber(n, 0);

TailReverseNumber takes a number n and "mirrors" it, one digit at a time, for example: TailReverseNumber(237, 0) -> TailReverseNumber(23, 7) -> TailReverseNumber(2, 73) -> TailReverseNumber(0, 732), the big trick is that res works as an accumulator that is multiplied by 10, therefore moving its value to the left, and putting in the "hole" that appears at the right the least significant digit of n. As it names implies, TailReverseNumber() uses tail recursion, so that no extra call stack space is used to save any intermediate results, which makes the process pretty efficient. Actually, in my PC it's four times faster than the initial solution. More efficient and more elegant, a smart guy Dustin.

Which is the ten thousand first prime?

Edgar Sánchez — Fri, 02 May 2008 05:09:56 GMT

Prime numbers have a good deal of practical applications (for example in cryptography) but let's face it, even if they would have none, they would still be the favorite toy of mathematicians. In Problem 7 of Project Euler, we are asked to find the 10001st element of the famous list, my approach was this:

Define the *infinite* sequence of the prime numbers
From this sequence, throw away the first 10000 items and then take the first of the remaining

Creating an infinite sequence in C# is easy (since version 2) thanks to IEnumerables and, above all, the yield statement:

    1 IEnumerable<int> Primes()
    2 {
    3     yield return 2;
    4 
    5     var primesSoFar = new List<int>();
    6     primesSoFar.Add(2);
    7 
    8     Func<int, bool> IsPrime = n => primesSoFar.TakeWhile(p => p <= (int)Math.Sqrt(n)).FirstOrDefault(p => n % p == 0) == 0;
    9 
   10     for (int i = 3; true; i += 2)
   11     {
   12         if (IsPrime(i))
   13         {
   14             yield return i;
   15             primesSoFar.Add(i);
   16         }
   17     }
   18 }

The yield at line 3 returns the first item of the sequence: the always excepcional 2 (the only even prime). Then at line 5 we create a list where we will be saving the generated primes as we progress in the sequence (this way we will gain speed at the cost of memory). The IsPrime(n) function defined at line 9, proposes a method -pretty crude actually- of verifying whether a number is prime: we take all primes generated so far which are lower or equal than the square root of n, and we look for the first among them that divides n evenly, if such a divisor exists then n is not a prime, that is: if none of the primes already generated is an exact divisor of n then FirstOrDefault() returns a 0, signaling the fact that n is indeed a prime. Finally at line 10 starts the loop that, every time the Prime() invoker asks for an item, it progresses thru 3, 5, 7, 9, 11, 13, ... stopping and returning, thru yield, when it finds a new prime.

With this sequence in our hands, step 2 of my plan is utterly simple:

return Primes().Skip(nth - 1).First();

We take the Primes() sequence, ignore the first nth - 1 (in our case nth = 100001) and then take the first of the remaining. This little code returns the answer in far less than a second.

The square of the sum vs. the sum of the squares

Edgar Sánchez — Mon, 28 Apr 2008 02:56:32 GMT

The sixth Project Euler problem poses an exercise that, to me, offers no major hurdles:

What is the difference between the sum of the squares and the square of the sums [of a sequence of natural numbers]?

The functional C# solution is fairly easy to write and read:

    1     public int SquareSumsLessSumSquares(IEnumerable<int> sequence)
    2     {
    3         var sum = sequence.Sum();
    4         var sumSquares = sequence.Select(i => i * i).Sum();
    5         return sum * sum - sumSquares;
    6     }

We get any sequence of integers (list, array, etc.) and we find the sum of its elements at line 3. The Select() in line 4 generates a new sequence with the square of each item from the original sequence and then we add them up. From there, getting the answer to Problem 6 is easy. Actually, the specific value that the problem asks for is to find out this difference for the first 100 natural numbers, so the corresponding call is:

    var result006 = SquareSumsLessSumSquares(Enumerable.Range(1, 100));

Now, given that the sequence we are focused on is 1, 2, 3, ..., 100, we can leverage a couple of math formulas:

Isn't the Wikipedia something? With this information in our hands we can re-write our solution this way:

    1     public int SquareSumsLessSumSquaresFirstNumbers(int n)
    2     {
    3         var sum = n * (n + 1) / 2;
    4         var sumSquares = n * (n + 1) * (2 * n + 1) / 6;
    5         return sum * sum - sumSquares;
    6     }

Clearly this latter way of solving the problem uses far less memory and CPU time. My first solution follows what is called a "brute force" approach, contemption intended. It works, for sure, but there are more elegant and efficient ways of solving the problem. The moral of this story is that a little research can take us a long way towards fresh solutions, probably better than our first approach. How frequently have you seen brute force solutions in production environments?

Recursive lambdas and sequence aggregations

Edgar Sánchez — Thu, 24 Apr 2008 05:22:45 GMT

The fifth problem at Project Euler proposes this nostalgic primary school exercise: find the smallest quantity that is evenly divisible by some numbers, the least common multiple of 1, 2, 3, ..., 20 to be precise. To begin with, let's remember the old arithmetic formula:

Where gcd is the greatest common divisor of a and b. It's also useful to remember that the lcm is associative, that is lcm(1,2,3) is the same as lcm(lcm(1,2), 3), in other words, we can calculate the lcm of 1 and 2, then the lcm of this result and 3, then the lcm of this result and 4, and so on. In functional C#, these ideas can be expressed like so:

    1     Func<int, int, int> gcd = null;
    2     gcd = (x, y) => x % y == 0 ? y : gcd(y, x % y);
    3 
    4     return Enumerable.Range(1, 20).Aggregate(1, (x,y) => x * (y / gcd(x, y)));

Line 2 finds the gcd of x and y like this: if the remainder of dividing x by y is zero, then y is the gcd, if not, we must find the gcd of y and such remainder. Note that gcd is defined recursively. The only interesting point here is that in order to define a recursive lambda expression, it is mandatory to first declare the expression variable (which we do in line 1), and only after this the compiler allows us to define a lambda expression in terms of itself. Odd, granted, but easy to get used to.

Line 4 takes the sequence 1, 2, ..., 20 and accumulates the lcm as the sequence is traversed, that is: it starts calculating lcm(1, 1) (let's call this accum1), then it calculates lcm(accum1, 2) (let's call this accum2), then it calculates lcm(accum2, 3), ..., and finishes with lcm(accum19, 20) which is precisely lcm(1, 2, ..., 20). The Aggregate() function is frequently used for chores like adding each term of a sequence, or multiplying them all, in our case we are using Aggregate() to get the succesive lcm's, which answers the question of Project Euler in two and a half lines of code, cool, eh?

Nested sequences and palindrome numbers

Edgar Sánchez — Tue, 22 Apr 2008 06:41:44 GMT

Problem 4 of Project Euler poses and impractical albeit intriguing problem: given all three digit numbers (100, 101, 102, ..., 998, 999), find the largest product of 2 of those numbers, where the product is a palindrome. For example, 580.085 is the product of two three-digit numbers (995 x 583) but it isn't the largest of such products. One possible functional C# solution is:

    1     Func<int,bool> IsPalindrome = n => { var nchar = n.ToString().ToCharArray(); return nchar.SequenceEqual(nchar.Reverse()); };
    2 
    3     return Enumerable.Range(100, 900)
    4         .SelectMany(i => Enumerable.Range(i, 900 - (i - 100)).Select(j => i * j))
    5         .Where (p => IsPalindrome(p))
    6         .Max();

To begin with, let's focus on the interesting part: at line 3, Enumerable.Range() generates the sequence 100, 101, ..., 998, 999; SelectMany() at line 4 does several things, first for every number i from the previous line it generates the sequence i, i + 1, i + 2, ..., 998, 999, and then the inner Select() generates the products {100 x 100, 100 x 101, ..., 100 x 999}, {101 x 101, 101 x 102, ..., 101 x 999 }, ... As you can see, there are 999 sequences generated (are all the same size?) finally SelectMany() kindly "flattens" those 999 sequences in one large sequence containing each and every product; line 5 then is easy, the Where() just keeps those products that are palindromes; the Max() in line 6 isn't worth any explanation.

Back to line 1, I took the lazy path to check whether a number is a palindrome: I just converted it to a string and then to a char array, finally I checked whether that array is equal, item by item, to its reversed version (and all that work just to leverage IEnumerable.Reverse() ;-)

Oracle 10g for Windows Vista released

Edgar Sánchez — Wed, 09 May 2007 03:25:00 GMT

Oracle has just released a version of its database server specific for Windows Vista, you can download Oracle Database 10g Release 2 (10.2.0.3) Enterprise/Standard Edition for Microsoft Windows Vista (slightly long name). Now, if what you want is to *develop* applications with Visual Studio 2005 in Vista that work with Oracle, the story is somewhat more complex:

In the Visual Studio 2005 Vista machine, you must install Oracle Database 10g Client Release 2 (10.2.0.3) (same URL as the server).
If you plan to use System.Data.OracleClient, the Oracle ADO.NET provider written by Microsoft then you're all set.
If you plan to use ODP, the ADO.NET provider written by Oracle itself, then you must download and install Oracle10g Release 2 ODAC and Oracle Developer Tools for Visual Studio .NET (10.2.0.2.21) *after* having installed the client of Step 1, this additional installer provides the following components:

ODP, the ADO.NET Oracle provider itself
ODE, Oracle Database Extensions for .NET 2.0, a server add-in that allows you to write stored procedures in C# (yeah, that's right, you can use C# instead of PL/SQL)
ODT, Oracle Developer Tools for Visual Studio 2005, a Visual Studio add-in that allows you to browse an Oracle server, create tables, view data, etc. from within the IDE

Why you have to install first the 10.2.0.3 client and after that ODP, ODE and ODT from the 10.2.0.2.21 client is beyond my comprehension but I'll better stick to the procedure.

Mono 1.1.16: Python, Windows Forms, ASP.NET 2.0

Edgar Sánchez — Fri, 07 Jul 2006 15:02:00 GMT

This is actually Beta 3 of Mono 1.2, some highlights (according to the official announcement):

IronPython 1.0 Beta 8 works with this release out of the box.
Majorly improved Windows.Forms and System.Drawing as our beta program for Windows.Forms continues.
New default optimizations boost performance for compute intensive applications.
Long standing debugging line numbers bug fixed.
Preview code for the new Compacting GC.
Hardened runtime for verification, AppDomain unloading and type loading failures
Significant progress on ASP.NET 2.0, some Starter Kits are now functional, as well as large improvements to its test suite.

Seems like we are one step closer to SmartClients (TM) in Linux... Go get your copy here.

From the Peculiar Ideas Departament: Compilr

Edgar Sánchez — Fri, 30 Jun 2006 14:12:00 GMT

Say you're away from home and just have to compile some lines of code to prove a theory, how do you do? Easy: browse to http://www.caller.me.uk/Compilr/, type or paste your lines and the code is compiled in a far and away server. It sounds like a strange proposition to me, but who knows, may be there are reams of programmers with Internet access that don't have a compiler at hand... Where's the money in the site? Advertising of course (Google is now generating some really weird spawn.) For the time being, they offer you C#, VB.NET, C, and Fortran compilers. Come to think of it, if they offer a few exotic languages like Lisp, Prolog, or APL, I may very well give it a try...

ADO.NET provider for Postgresql

Edgar Sánchez — Sat, 24 Jun 2006 05:08:00 GMT

This is not really news as the driver has been available since April: Npgsql is an ADO.NET data provider written in C# that enables any .NET application to work with Postgresql 7.x and 8.x. You can download the provider from here.

.NET in Linux (and something about numerical analysis)

Edgar Sánchez — Thu, 22 Jun 2006 05:58:00 GMT

Every few months news emerge about the Mono project: spearheaded by Miguel de Icaza in order to have a Linux .NET implementation that would allow to more easily create Windows like applications in Linux, Mono has managed to implement a good C# compiler, most of the BCL (ADO.NET included) and a pretty reasonable ASP.NET 1.1, but it has failed to have a production-level Windows Forms implementation (they are moving ahead, but Microsoft goes much faster.) A couple of years ago I got enthusiastic about Mono, but now I see (sadly) that it's stalling (even though it was acquired by Novell, or may be exactly because of that [;)]).

While visiting the Mono site I found (again) dnAnalytics, an open source project trying to implement a standard set of numerical methods libraries (stuff like matrix manipulation, differential equations, etc.) in C#. It runs OK in Mono and also in the official .NET (although it doesn't use the new abilities in .NET 2.0), it could be of use for those of you working on numerical analysis.

Friendly Web sites, design patterns, and metacognition

Edgar Sánchez — Thu, 08 Jun 2006 05:06:00 GMT

First of all, you just have to love the guys that created these register policies:

Isn't that all what you expect from a Web community member? Who needs lawyers anyway? Before you start laughing, note that JavaRanch gets millions of entries in its forums every month and they have won a Jolt Productivity Award on the Web Site and Developer Networks category twice in a row. When you know that, you are not surprised that these same guys created the Head First book series, of which I started to read Head First Design Patterns today, a book where, for example, the possibilities of the decorator pattern are illustrated in this way:

Does that chap looks like an object decorator or what? The authors use in funny ways the results of metacognitive research (that is, the research on how people learn), so you will laugh while you learn. Now, the authors write all of their examples in Java (nothing is perfect ), but luckily a good soul already translated the samples to .NET . Recommended reading.

Datasets are not for everything (and neither XML)

Edgar Sánchez — Wed, 07 Jun 2006 04:02:00 GMT

First of all, let me tell you that datasets are wonderful, especially if you have to do CRUD operations on relational records. But that doesn't mean they are always the best choice. Ditto for XML. With the obvious statement out of the way, let me tell you this little tale:

My pal Sandra needed to execute a process except for a group of operations, moreover, this group of "forbidden" operations could be changed at runtime. So, to begin with, Sandra defined an XML file with the forbidden operations:

<Operation>Destroy</Operation>

<Operation>Maime</Operation>

</ForbiddenOperations>

Then, she populated a dataset with the contents of the XML file:

DataSet dataSet = new DataSet();

dataSet.ReadXml(@"..\..\ForbiddenOperations.xml");

And now, she could execute the process, except for forbidden operations, like so:

DataTable operationsTable = dataSet.Tables[0];

DataRow[] foundRows = operationsTable.Select("Operation_Text='" + operation + "'");

if (foundRows.Length == 0)

{

// It isn't a forbidden operation, so do the process

}

It works, and it uses just a few lines of code. OTOH, it's terribly inefficient. To begin with, reading an XML file to populate a dataset demands a lot of resources and the file becomes a semaphore. Furthermore, the Select() method scans the table linearly, interpreting the expression for every row. If the table has many rows or the process is invoked many times, the response time will suffer noticeably.

Which is the alternative? First, let's put the forbidden operations in the App.config file:

</appSettings>

Then, populate a string dictionary with those operations:

string[] forbiddenOperations = ConfigurationSettings.AppSettings["forbiddenOperations"].Split(',');

StringDictionary forbiddenOperationsDictionary = new StringDictionary();

foreach (string operation in forbiddenOperations)

{

forbiddenOperationsDictionary.Add(operation, operation);

}

And finally, you can execute the process, except for forbidden operations, like so:

if (!forbiddenOperationsDictionary.ContainsKey(operation))

{

// It isn't a forbidden operation, so do the process

}

The first and last parts are more compact than in the first solution, even though the second part takes more lines. But the whole process is far more efficient and fast.

So, even though datasets are great, don't use them for everything, in particular don't use them as a dictionary or a cache, if you want to find objects or records by a certain key it's far better to use a dictionary. Ditto, for XML.

C# Expression Evaluators

Edgar Sánchez — Tue, 06 Jun 2006 05:30:00 GMT

Warning: this is not the usual code sample ready to be cut and pasted in your homework due for tomorrow.

OTOH, if you are one of those guys that just have to understand why and how you can implement an expression evaluator in C#, then boy has Chuck Jazdzewski some interesting information for you. Chuck likes to propose interesting problems/challenges (often useless yet fascinating) and then discuss at detail various approaches to the problem, in the case of expression evaluators, Chuck offers us four alternatives:

The classic procedural solution (á la plain old Visual Basic)
The object oriented solution (at the best 199x Smalltalk/Java style)
The visitor pattern solution (for the guys one stair above average Java or C# programmers)
The layered solution using partial classes (for the neoteric programmers using C# 2.0 or VB.NET 2005)

As I said, don't expect a complete solution ready to be run but some pseudo-code and an interesting discussion of pros and cons. It may not help you with tomorrow's homework but it sure will help you impress the geek gal on the next cubicle.