ASP.NET was an easy choise for a server side code, but what about client side ?
The heavy viewstate, endless event handlers and infinity number of server side requests just to make the GUI  friendly – well, it just didn’t sound as a proper way to do it.

So, what do we have ?
.NET as a server side platform, but despite  all it’s powerful abilities it has nothing to do with client side. At the end of the day all those fancy control are just HTML and JavaScript.

JavaScript is still the engine that runs at the client side and it’s great, but we all know how many lines of code we have to write and time to spend to make it fast, modular and cross browser.

jQuery – it’s a fast and concise JavaScript Library that simplifies HTML document traversing, event handling, animating, and Ajax interactions for rapid web development.

Indeed, we can do a many things with jQuery and it realy simplify the coding, but what if we have to build a product list with complicated HMTL, complex logic and real time manipulation ?

As i mentioned before, ASP.NET and UpdatePanels are just to heavy and JavaScript is to long.

So, i did some research and find a couple of JavaScript Template Engines.
The first one i bumped in was jsRepeater. At first it seemed like a great solution but after a few tests i found all kinds of bugs related to the syntax conflicts with HTML and JavaScript.

After a few days of googling, tests and googling again i found the one and only –  jTemplates.
jTemplates is a template engine for JavaScript, wich is wraped in a jQuery Plugin.
The syntax is very simple and  intuitive. It’s support parameters, includes, if/else, loops, JavaScript functions and many other nice and usable features.

Let’s say we want to list all our products. What we have to do is to write the template (HTML), pass the data and we have a product list.

Look how easy this is. You just write HTML and werever you need to insert some data you put {$.T.P.ColumnName}.

So, how we use it ?
Just add some textarea to your page, give it some id, set it’s display style to none and write your template inside.

<textarea cols="0" rows ="0" style="display:none;" id="ProductListTemplate"><!--
{#foreach $T.Product as P}
	<div style=”float:left;width:150px;height:150px”>
		<div>{$T.P.Title}</div>
		<img src=”{$T.P.Url}” alt=”{$T.P.Title}” style=”width:10px;height:10px” />
		<hr />
		<div>Price : {$T.P.Price}$</div>
	</div>
{#/for}
--></textarea>

Add some empty container that will hold the result.

<div id="ProductListContainer"></div>

Execute setTemplateElement and execute processTemplate while passing the data into it as a parameter

$("#ProductListContainer").setTemplateElement("ProductListTemplate");
$("#ProductListContainer").processTemplate(data);

Easy, isn’t it ?
I must say that the above example is a simple one, but I’ve been using jTemplates to create complicated lists, grids, trees, popups and even an image editing web application. Use it, I’m sure you will love it.

Related posts:

1. IE Memory Leak – jQuery Fix
2. Script as blocking element and dynamic script loading using document.write
3. Javascript function context, “apply” method and lost “this” object

Yesterday I had to write some app that reads files located on some remote computer.
As I knew already this ins’t such a good practice, because your code can just hang/freeze for seconds waiting for that UNC path to become available or just checking it’s existence.

Still, I had to provide some quick solution and “hoping for the best” wasn’t good enough.
So, this is what I came up with.

        public static T Limex<T>(Func<T> F, int Timeout, out bool Completed)
        {
            T result = default(T);
            Thread thread = new Thread(() => result = F());
            thread.Start();
            Completed = thread.Join(Timeout);
            if (!Completed) thread.Abort();
            return result;
        }

        // Overloaded method, for cases when we don't
        // need to know if the method was terminated
        public static T Limex<T>(Func<T> F, int Timeout)
        {
            bool Completed;
            return Limex(F, Timeout, out Completed);
        }

The usage is very simple, just pass any method (declared or anonymous) and the desired Timeout in milliseconds to the Limex.

Example :

bool Completed;
string Content = Limex(() => File.ReadAllText(@"\\unc\dir\file.ext")
                       ,100 // milliseconds
                       ,out Completed);

if (Completed)
   // Do something
else
  // Do something else

Comments and suggestions for improvement are welcome and will be gratefully appreciated

Related posts:

1. C# Inheritance Question
2. C# Protected Internal
3. C# LINQ Teaser

Well, i needed something like that a few days ago and after Googling for couple of hours I ran across this this great library called HtmlAgilityPack.

Sure, you can do it by using C# WebBrowser control or MSHTML, but you will have to forget about performance or multithreading – it will eat all your memory and the CPU won’t know what’s hit it.

Now, back to the HtmlAgilityPack.
The usage is very simple, and the performance is great ( at least for my needs ).

Following is an example how we can find all images without an “alt” attribute, add it and resave the Html document.

            HtmlDocument HD = new HtmlDocument();
            HD.Load (@"e:\test.htm");
            var NoAltElements = HD.DocumentNode.SelectNodes("//img[not(@alt)]");
            if (NoAltElements != null)
            {
                foreach (HtmlNode HN in NoAltElements)
                {
                    HN.Attributes.Append("alt", "no alt image");
                }
            }

            HD.Save(@"e:\test.htm");

Related posts:

1. C# Image Processing with AForge.NET Framework
2. jTemplates – jQuery Template Engine
3. C# string.Empty vs “”

static void Main(string[] args)
{
    for (byte b = byte.MinValue; b <= byte.MaxValue; b++)
        Console.Write(b);
}

// A little tip
// byte.MinValue = 0
// byte.MaxValue = 255

How many times the above statement will be executed ?

Related posts:

1. C# Inheritance Question
2. C# LINQ Teaser
3. C# Increment operator (++) question

AForge.NET is a C# framework designed for developers and researchers in the fields of Computer Vision and Artificial Intelligence – image processing, neural networks, genetic algorithms, machine learning, robotics, etc.

The framework is published under LGPL v3 license and comprised by the set of libraries and sample applications, which demonstrate their features:

• AForge.Imaging – library with image processing routines and filters
• AForge.Vision – computer vision library
• AForge.Neuro – neural networks computation library
• AForge.Genetic – evolution programming library
• AForge.MachineLearning – machine learning library
• AForge.Robotics – library providing support of some robotics kits
• AForge.Video – set of libraries for video processing

The framework is provided not only with different libraries and their sources, but with many sample applications, which demonstrate the use of this framework, and with documentation help files, which are provided in HTML Help format.

As you can see this framework contains varied libraries, but as for me i was especially interested in the image processing routines and filters.

Let’s see  the  CannyEdgeDetector in action.

using AForge.Imaging.Filters;

// Loading some file
using (Bitmap SampleImage = (Bitmap)Image.FromFile("test.jpg"))
{
    // We must convert it to grayscale because
    // the filter accepts 8 bpp grayscale images
    Grayscale GF = new Grayscale(0.2125, 0.7154, 0.0721);
    using (Bitmap GSampleImage = GF.Apply(SampleImage))
    {
        // Saving the grayscale image, so we could see it later
        GSampleImage.SaveAsJpeg("testBW.jpg", 100);

        // Detecting image edges and saving the result
        CannyEdgeDetector CED = new CannyEdgeDetector(0,70);
        CED.ApplyInPlace(GSampleImage);
        GSampleImage.SaveAsJpeg("testEDGED.jpg",100);
    }
}

// SaveAsJpeg is an extension method i wrote to be able to save
// Jpeg images with parametrized quality
// You can use Image.Save ("image.jpg", ImageFormat.Jpeg) instead

Now, let see the results ( click the image to see full size )

The result is great, and of course we can modify the threshold levels to gain even better results.
As for other filter and effects there are many of them in this library.
There are Noise generators, color correction filters, smoothing filters and more.

Sure, it’s no Photoshop, but i must say it’s very close to it.

Hope you will find this useful, I did.

Related posts:

1. Image Resizing in C#
2. C# Rectangle Packing
3. C# Inheritance Question

The SpeedTrace Pro profiler follows and records the program flow of any .NET application on a function/method level for later profiling or tracing analysis, allowing you to identify performance bottlenecks, deadlocks, software design problems as well as resource and data flow problems.

One of the nicest features in this application is the presence of “Callback-API”.
It provides user-extended functionality to allow developers to adapt the tracer to their needs and to write user-specific extensions for dot.NET Framework 2.0, 3.0 or 3.5 applications.

SpeedTrace Pro can make accessible the arguments and return values of a function. This outstanding feature enables you not only to trace function calls but also to obtain the values passed or returned – important data that normal profilers lose during aggregations. You can make use of this data to obtain the relevant information, especially when bugs appear under certain conditions.

The data tracing values of .NET applications may be used to trap bugs easily and to perform data-dependent analyses.

SpeedTrace - .NET Profiler and Tracer

Related posts:

1. C# The “double” trouble
2. Unusual software bugs
3. C# string.Empty vs “”

Forget for a second about .NET.
If someone asks you how much is 1.000025 – 0.000025 your answer will probably be “1″ and correct. An easy question, right ?

Now, let’s go back to .NET and check if our calculations are correct.

        static void Main(string[] args)
        {
            double d1 = 1.000025;
            double d2 = 0.000025;
            Console.WriteLine((d1 - d2) == 1);
        }

If you think the result will be “true”… well, it’s not.

Let’s see another example :

        static void Main(string[] args)
        {
            double d1 = 1.000025;
            double d2 = 0.000025;

            // Will result 1
            Console.WriteLine(d1 - d2);

            // Will result 0.99999999999999989
            Console.WriteLine((d1 - d2).ToString ("R"));
        }

For those who might not know, the meaning of ToString(“R”) is Round-trip.

This format is supported only for the Single and Double types. The round-trip specifier guarantees that a numeric value converted to a string will be parsed back into the same numeric value. When a numeric value is formatted using this specifier, it is first tested using the general format, with 15 spaces of precision for a Double and 7 spaces of precision for a Single. If the value is successfully parsed back to the same numeric value, it is formatted using the general format specifier. However, if the value is not successfully parsed back to the same numeric value, then the value is formatted using 17 digits of precision for a Double and 9 digits of precision for a Single.

So, what happened here ? Is it a bug ?
The answer is – NO, IT’S NOT A BUG ( and it’s not happening only on my computer ).

The thing is, that the above is about how .NET rounding a floating point number.
I won’t explain here the math ( there is already a great article explaining it ), and i won’t say don’t use floating point types.

You just need to know that when you are using it – be carefull, especialy in equations and formatting, otherwise your calculations will be wrong and your result not accurate.

Related posts:

1. C# Inheritance Question
2. C# string.Empty vs “”
3. C# Increment operator (++) question

    // Question #1
    class Program
    {
        static void Main(string[] args)
        {
            int i = 13;
            string Result = B.Get(i);
            Console.WriteLine(Result);
        }
    }

    public class A
    {
        public static string Get(int Value) {
            return "A";
        }
    }

    public class B : A
    {
        public static string Get(float Value)
        {
            return "B";
        }
    }

    // Question #2
    class Program
    {
        static void Main(string[] args)
        {
            int i = 13;
            string Result = B.Get(i);
            Console.WriteLine(Result);
        }
    }

    public class B
    {
        public static string Get(float Value)
        {
            return "B";
        }

        public static string Get(int Value) {
            return "A";
        }
    }

What will be the result of the above code parts ?

Related posts:

1. C# Increment operator (++) question
2. C# The “double” trouble
3. C# LINQ Teaser

Coming soon…

Related posts:

1. CTRL+A Image maker
2. jTemplates – jQuery Template Engine
3. C# Image Processing with AForge.NET Framework