Andrei Rinea's technical blog

Career change

Andrei Rinea — Wed, 18 Sep 2024 14:09:35 +0000

It’s been quite a well since I’ve written so I should start somewhere.

In July 2019 I’ve transitioned to Security Engineering from Software Development. I’m an Application Security Engineer since then. It’s been, and still is, a fun ride.

Why did I switch from development? Honestly there’s a mix of reasons: I’ve wanted to try something different, I’ve grown dissatisfied with the position I was holding and there was this opportunity to remain at my current employer under a new manager that I’ve respected more.

What is Application Security Engineering? Although I’ve been in this new field for 5+ years now I still feel like a total n00b. Therefore I’ll try to explain as best as I can…

Application Security is the sub-field of Information Security which aims to measure and improve the security posture (level) of software applications. There are several components:

Secure Design: thinking how to properly build the piece of software from a security standpoint
Threat Modeling: analyzing the actors, interactions and trust boundaries, in order to identify and mitigate risks
Secure Coding: using tools and practices to prevent, identify common security vulnerabilities in code
Vulnerability Management: monitoring and patching 3rd party software included
Incident Response: preparing plans to properly handle security incidents (sometimes, but not always “hacks”)
Compliance: ensuring that the application meets industry security standards, legal requirements, and best practices

There’s many new tools and techniques that complement the ones used in software development. Some are FOSS (Free Open Source Software), some are not, some are reliable and mature, some not really.. Sometimes you build your own security tools because of monetary reasons (yes, the cost to build still is cheaper in some areas).

I used to think Security Engineering is just a small area, well defined, right next to Software Development. Boy was I wrong…

Having fun with HTML 5 History API – part three

Andrei Rinea — Fri, 22 Jul 2016 16:38:43 +0000

Part 1 – Description of the problem
Part 2 – simple history replacement
Part 3 – additional history items – this article

As we’ve seen in the previous parts, we can alter the history of the current page navigation by replacing the current URL with a new one (this freedom has limits, of course, and we can’t alter the protocol or the host). For women is very important to show off a nice makeup. You can get a smooth makeup with advises from makeup professionals.

What we’ll explore in this part is creating new history items while not leaving the page. In order to achieve this, we’ll make use of

history.pushState( ... )

and an event called popstate :

window.addEventListener('popstate', function () { /* ... */ });

First we’ll need to replace all replaceState calls to pushState calls. The parameters stay the same:

function loadModels(make, pushState, onSuccess) {
    $.ajax({
        cache: true,
        type: 'GET',
        url: '@Url.Action("GetModelsByMake")',
        data: { 'makeId': make },
        success: function (data) {
            if (pushState)
                history.pushState(null, null, "/Home/Selector?mkId=" + make);
            var models = $("#SelectedModel");
            models.empty();
            models.append($("<option></option>").attr("value", "").text(" -- please select a model -- "));
            $.each(data, function (key, val) {
                models.append($("<option></option>").attr("value", val.Id).text(val.Text));
            });
            $('#divModel').show();
            if (onSuccess)
                onSuccess();
        },
        error: function (xhr, ajaxOptions, error) {
            alert(error);
            $('#divModel').hide();
        }
    });
}

// ...

function modelChanged() {
    var makeId = getParameterByName("mkId", document.location.href);
    var modelId = $("#SelectedModel").val();
    if (!modelId)
        history.pushState(null, null, "/Home/Selector?mkId=" + makeId);
    else
        history.pushState(null, null, "/Home/Selector?mkId=" + makeId + "&mdId=" + modelId);
}


At this point we can run the app and see how changing the make and / or the model alters the URL but also the back button can take us to the previous URL on the page. However, restoration of the selection doesn’t happen upon going back. This is because we didn’t add the event listener yet.
So let’s do that. Add the following piece of code:
window.addEventListener('popstate', function () {
    $("#SelectedMake").off("change");
    $("#SelectedModel").off("change");
    init(function () {
        $("#SelectedMake").change(makeChanged);
        $("#SelectedModel").change(modelChanged);
    });
});

In this event handler we’ll capture the situation when the user hit the back button and the URL is on the same page, practically a synthetical location has been navigated to.
Because the URL changed we need to re-init the page, hence the call to the init function. However, the init function will tend to indirectly alter the URL again because it would change the make or model. This would happen because the change event handlers of the drop downs would fire. To prevent this we’re unsubscribing them first. This is done using the .off(“change”) jquery shortcuts.
We, then, need to call the init function which has an asynchronous part, the AJAX call, and only after the call has successfully ended we need to re-subscribe the event handlers. This is why we call init with a new parameter, a function containing the re-subscription to the change events. Therefore we’ll need to change the init function too:
function init(afterInit) {
    var makeId = getParameterByName("mkId", document.location.href);
    if (!makeId) {
        $("#SelectedMake").val("");
        $('#divModel').hide();
        if (afterInit)
            afterInit();
        return;
    }
    $("#SelectedMake").val(makeId);
    var modelId = getParameterByName("mdId", document.location.href);
    loadModels(makeId, false, function () {
        $("#SelectedModel").val(modelId);
        if (afterInit)
            afterInit();
    });

the changes in the function add some extra functionality:
– clears the selection in the make dropdown if the navigated state does not contain one (line 4)

– hides the model selector if no make is selected (line 5)

– selects a make if the navigated state contains one (line 10)
The navigation works forward too, the popState event will fire in this case also.

At this point the app should function well, handling all navigation states.
This concludes this short series on HTML 5 History API.
You can check out the final stage of the HTML code here.

Having fun with HTML 5 History API – part two

Andrei Rinea — Mon, 18 Jul 2016 18:00:32 +0000

Part 1 – Description of the problem
Part 2 – this article (simple history replacement)
Part 3 – additional history items

As we saw earlier in part 1, hitting the back button into a page with filled in fields will not restore (all) the values, but merely the ones that exist at the time of the page loading. In some cases, for example cascading dropdowns, will not be shown or exist at all at the time of the page load.

What we will accomplish in this part is to push into the query string (without reloading the page!) the selected make and the selected model (where applicable).

We are going to make use of

history.replaceState(...)

function. There is a W3C standard available for this function (and others). Note that this is supported on all browsers, but only the recent versions.

To do so we need a few things:

A function to parse (a) query string; sadly JavaScript does not have anything built in, not even jQuery is of much help..
Change the URL upon changing of selection
Restore selection from the URL – including cascading

Great! Let’s start.

Upon a bit of searching around which turned into stackoverflowing, I reached the most voted question on this matter called ‘How can I get query string values in JavaScript?‘.

I really looked for a quick-simple-and-standards-compliant-and-so-on solution but the best I could scavenge was this:

function getParameterByName(name, url) {
    if (!url) url = window.location.href;
    name = name.replace(/[\[\]]/g, "\\$&");
    var regex = new RegExp("[?&]" + name + "(=([^&#]*)|&|#|$)"),
        results = regex.exec(url);
    if (!results) return null;
    if (!results[2]) return '';
    return decodeURIComponent(results[2].replace(/\+/g, " "));
}

Ugly but it works.

We already have a bit of initialization ( quick tip/reminder : in jQuery you can write a function that will execute upon document ‘ready’ just like so: $(function() { /* … */ }); ) :

$(function () {
    $("#SelectedMake").change(makeChanged);
    makeChanged(); // <- this wasn't really necessary
});

Let’s add an event handler for the change of the selected model in order to change the URL from there, too:

$(function () {
    $("#SelectedMake").change(makeChanged);
    $("#SelectedModel").change(modelChanged);
});

// ...

function modelChanged() {
    var makeId = getParameterByName("mkId", document.location.href);
    var modelId = $("#SelectedModel").val();
    if (!modelId)
        history.replaceState(null, null, "/Home/Selector?mkId=" + makeId);
    else
        history.replaceState(null, null, "/Home/Selector?mkId=" + makeId + "&mdId=" + modelId);
}

We also need to change the makeChanged logic in order to simplify the function and allow future reuse of the ajax populating call (changed lines are highlighted) :

function loadModels(make, pushState, onSuccess) {
    $.ajax({
        cache: true,
        type: 'GET',
        url: '@Url.Action("GetModelsByMake")',
        data: { 'makeId': make },
        success: function (data) {
            if (pushState)
                history.replaceState(null, null, "/Home/Selector?mkId=" + make);
            var models = $("#SelectedModel");
            models.empty();
            models.append($("").attr("value", "").text(" -- please select a model -- "));
            $.each(data, function (key, val) {
                models.append($("").attr("value", val.Id).text(val.Text));
            });
            $('#divModel').show();
            if (onSuccess)
                onSuccess();
        },
        error: function (xhr, ajaxOptions, error) {
            alert(error);
            $('#divModel').hide();
        }
    });
}

function makeChanged() {
    var selectedMake = $("#SelectedMake").val();
    if (selectedMake === "") {
        $('#divModel').hide();
    } else {
        loadModels(selectedMake, true);
    }
}

We refactored out the ajax call into the loadModels function and added two parameters:

pushState – this would control whether after successfully loading the models the URL should be changed or not
onSuccess – an option callback to be executed after successfully loading the models

At this point, if we run the sample, we should have URL changing functionality fully implemented but if we submit into the next page and go back to the selector page only the make dropdown will have its selection restored and that isn’t our work but the browser’s (this worked from the beginning).

Finally, in order to restore selection from the URL, a bit of initialization is necessary:

$(function () {
    init();
    $("#SelectedMake").change(makeChanged);
    $("#SelectedModel").change(modelChanged);
});

// ... 

function init() {
    var makeId = getParameterByName("mkId", document.location.href);
    if (!makeId) return;
    var modelId = getParameterByName("mdId", document.location.href);
    loadModels(makeId, false, function () {
        $("#SelectedModel").val(modelId);
    });
}

.. and now all should work smooth! 🙂

You can check out the code on Github. For this particular step of development here’s the link to the HTML code.

Having fun with HTML 5 History API – part one

Andrei Rinea — Mon, 18 Jul 2016 14:11:52 +0000

Part 1 – this article
Part 2 – simple history replacement
Part 3 – additional history items

Have you ever come across a web page with a few fields, let’s say cascading drop downs, you know like these:

… and after carefully filling in the fields you submit, and you are taken to the next page. Only to find out that you made a mistake and you push the back button in your browser. Guess what, now (almost) all your fields are reset and you have to begin all over again. Frustrating.

Apart from that, I have noticed that “infinite scrolling” has really taken off in a lot of sites, some news site (for example this one – at least at the time of the writing) even change the URL as you scroll down into the next article.

And then I wondered, how could I use this gimmick into solving the first issue (i.e. losing fields information after pressing back) and I came up with two possible solutions to this. I will showcase a small PoC for each one in the next two parts.

First let’s consider the following minimal web project (ASP.NET MVC but since this is about JavaScript, the back end doesn’t really matter) with two drop-downs. The first dropdown will let you choose a make of automobiles and the second one will let you choose a model from that particular make. In the end you press continue and you are directed to a new page:

Things start to go sideways if you press back in the last stage. You will be taken back to the selector page, the browser will do its best to restore the values but it will only succeed in setting back the make, the model restoration will not work:

The client side (HTML markup, CSS and JavaScript lumped together in one file :P) looks like so:

@model HistoryApiSample.Models.SelectorViewModel
@{
    ViewBag.Title = "Selector";
}

&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;style&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;
    .lbl {
        display: inline-block;
        width: 210px;
        text-align: right;
    }
&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;/style&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;
&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;h2&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;Car select&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;/h2&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;

@using (Html.BeginForm())
{
    &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;div id="divMake"&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;
        @Html.LabelFor(m =&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; m.SelectedMake, new { @class = "lbl" })
        @Html.DropDownListFor(m =&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; m.SelectedMake, Model.Makes, " -- please select a make -- ")
    &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;/div&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;

    &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;div id="divModel" style="display: none;"&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;
        @Html.LabelFor(m =&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; m.SelectedModel, new { @class = "lbl" })
        @Html.DropDownListFor(m =&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; m.SelectedModel, Model.Models, " -- please select a model -- ")
    &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;/div&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;

    &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;input type="submit" value="Continue" /&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;
}

@section scripts
{

    &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;script type="text/javascript"&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;
        $(function () {
            $("#SelectedMake").change(makeChanged);
            makeChanged();
        });

        function makeChanged() {
            var selectedMake = $("#SelectedMake").val();
            if (selectedMake === "") {
                $('#divModel').hide();

            } else {
                $.ajax({
                    cache: true,
                    type: 'GET',
                    url: '@Url.Action("GetModelsByMake")',
                    data: { 'makeId': selectedMake },
                    success: function (data) {
                        var models = $("#SelectedModel");
                        models.empty();
                        models.append($("&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;option&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;/option&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;").attr("value", "").text(" -- please select a model -- "));
                        $.each(data, function (key, val) {
                            models.append($("&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;option&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;/option&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;").attr("value", val.Id).text(val.Text));
                        });
                        $('#divModel').show();
                    },
                    error: function (xhr, ajaxOptions, error) {
                        alert(error);
                        $('#divModel').hide();
                    }
                });
            }
        }
    &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;/script&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;

}

The controller code:

        // ...
        [HttpGet]
        public ActionResult Selector()
        {
            var model = new SelectorViewModel
            {
                Makes = new[]
                {
                    new SelectListItem { Value = "VW",  Text = "Volkswagen" },
                    new SelectListItem { Value = "AUD", Text = "Audi"       },
                    new SelectListItem { Value = "SEA", Text = "Seat"       },
                    new SelectListItem { Value = "SKD", Text = "Skoda"      }
                },
                Models = Enumerable.Empty&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;SelectListItem&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt;()
            };
            return View(model);
        }

        [HttpPost]
        public ActionResult Selector(SelectorViewModel viewModel)
        {
            return RedirectToAction("ShowSelection", new
            {
                makeId = viewModel.SelectedMake,
                modelId = viewModel.SelectedModel
            });
        }

        [HttpGet]
        public ActionResult ShowSelection(string makeId, string modelId)
        {
            string makeName = null;
            string modelName = null;
            switch (makeId)
            {
                case "VW": makeName = "Volkswagen"; break;
                case "AUD": makeName = "Audi"; break;
                case "SEA": makeName = "Seat"; break;
                case "SKD": makeName = "Skoda"; break;
            }
            switch (modelId)
            {
                case "TIG": modelName = "Tiguan"; break;
                case "TRG": modelName = "Touareg"; break;
                case "A4": modelName = "A4"; break;
                case "A6": modelName = "A6"; break;
                case "LEO": modelName = "Leon"; break;
                case "IBZ": modelName = "Ibiza"; break;
                case "FAB": modelName = "Fabia"; break;
                case "OCT": modelName = "Octavia"; break;
            }
            var viewModel = new SelectionViewModel
            {
                Make = makeName,
                Model = modelName
            };
            return View(viewModel);
        }

        [HttpGet]
        public ActionResult GetModelsByMake(string makeId)
        {
            object data;
            switch (makeId)
            {
                case "VW":
                    data = new[]
                    {
                        new DataItem { Id = "TIG", Text = "Tiguan"  },
                        new DataItem { Id = "TRG", Text = "Touareg" }
                    };
                    break;
                case "AUD":
                    data = new[]
                    {
                        new DataItem { Id = "A4", Text = "A4"  },
                        new DataItem { Id = "A6", Text = "A6" }
                    };
                    break;
                case "SEA":
                    data = new[]
                    {
                        new DataItem { Id = "LEO", Text = "Leon"  },
                        new DataItem { Id = "IBZ", Text = "Ibiza" }
                    };
                    break;
                case "SKD":
                    data = new[]
                    {
                        new DataItem { Id = "FAB", Text = "Fabia"  },
                        new DataItem { Id = "OCT", Text = "Octavia" }
                    };
                    break;
                default:
                    return HttpNotFound();
            }
            return Json(data, JsonRequestBehavior.AllowGet);
        }

        private class DataItem
        {
            public string Id { get; set; }
            public string Text { get; set; }
        }


Finally the viewmodels:

    public class SelectorViewModel
    {
        [Display(Name = "select a make")]
        public string SelectedMake { get; set; }
        public IEnumerable&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;SelectListItem&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; Makes { get; set; }

        [Display(Name = "select a model")]
        public string SelectedModel { get; set; }
        public IEnumerable&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;lt;SelectListItem&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;gt; Models { get; set; }
    }

    public class SelectionViewModel
    {
        public string Make { get; set; }
        public string Model { get; set; }
    }


In the next part we’ll explore the simplest way to fix this issue, rewriting history (sounds dramatic but it isn’t :P).
You can check out the code of the HTML view for this stage of development here.

When Stackoverflow goes looney like a leftie

Andrei Rinea — Mon, 20 Jun 2016 22:25:42 +0000

I was recently doing reviews on Stackoverflow when a ‘go home you’re drunk’ page ‘caught’ me. Lookie here:

This was supposed to be a test to catch ‘speeding’ reviewers. I admit that C/C++ are not my strongest points but I can understand code in C/C++ and rarely even write in them.

I guess they went overboard this time.

Local meetup – AngularJS intro

Andrei Rinea — Wed, 18 Nov 2015 21:54:48 +0000

Lately I’ve been toying with AngularJS and I wanted to share my findings in a short practical presentation. I will be building a small SPA (single page application) with AngularJS and run through the most commonly used directives and features of the framework.

If you are in Bucharest on 8th of December, after work (19:00) drop by and have a look The presentation will be in the ADCES group, the location being Electronic Arts (AFI Park 2).

Entrance is free, just register on this event either via Facebook or via Meetup. Hope to see you there

PS: Did I tell you that we’re having beers afterwards?

Visual Studio smart replace

Andrei Rinea — Wed, 04 Nov 2015 10:57:23 +0000

Let’s say you need to replace an expression in many files in Visual Studio with another expression. The case in question is replacing

nameof(someVariable)
to
"someVariable"

Sure you can try to replace

nameof(
to
"

but this will leave the double quote open and we don’t want this. Searching on the internetz and finding some stackoverflow solution and with the help of a second pair of eyes from a colleague we managed to find a solution like so:

Hit CTRL-SHIFT-H in Visual Studio and check “Use Regular Expressions”. Then select your scope, for example “Entire solution” and use the following expressions:

Find what:
nameof$([a-zA-z]+)$

Replace with:
"$1"

This will do the job. Let’s analyze the expressions a bit. The “Find what:” one, first. ‘nameof’ is the literal occurence of ‘nameof’. The first round bracket is preceded by backslash because we need to escape it. This is because the round bracket is used in the regular expressions syntax while in our case we need to literally find it. This was the ‘\(‘ part.

Now there is the ‘([a-zA-z]+)’ part. This has several sub-parts. The round brackets mean that the whole segment should be captured. We’ll later see why and what this is. Next, the square bracket part means that this should match any letter be it uppercase or lowercase (yes, I didn’t handle digits or underscores etc. which may be used in parameter/variable names, that is left as an exercise to the reader :P). The plus sign means the square bracket part may occur multiple times. This means that a parameter/variable name may have more than one such character. Finally we close this part with the round bracket.

The final part in the “Find what:” expression is a literal closing round bracket which, again, is escaped by being prefixed with a backslash.

In the “Replace with:” expression, the captured part in the previous expression (what is enclosed in the regular-expression-syntax round brackets) is expressed as $1, as first numbered. Finally we enclose this in double quotes because that is what we need.

As for why I had to rollback from C# 6 nameof expression to a stringly-typed version, that’s a story for another time, I guess.

Cross-platform browser keyboard shortcuts

Andrei Rinea — Thu, 09 Apr 2015 15:20:35 +0000

As of recently I began working on a Mac-book pro and I have to get used to a keyboard with different keys and different layout. One of the most used piece of software today is a browser. I routinely use Opera but there are still sites that don’t work well with it, although it uses pretty much the same rendering engine like Chrome.

I suspect these issues arise from the fact that Chrome tends to become the new IE 6 for many web developers (i.e. : write a page, test it in Chrome, it works, the rest of browsers doesn’t matter to me, continue to next page etc.).

I consider, just like Scott Hanselman, that using the keyboard is the most efficient way to command a computer (and not the mouse / touchpad) therefore I strive to use it to the max. However, switching from OS X to the Windows virtual machine back and forth can be confusing since there are different shortcuts. For example F5 in Windows refreshes the window while in OS X it doesn’t (be it because by default you have to press Fn and then F5 in order to send F5 otherwise a media function will be sent or because this key does not do this function).

Therefore I gathered a few useful shortcut keys that work in both Windows and OS X so I can use them. Many of them work across all major browsers (IE, Firefox, Chrome, Opera and Safari). Use Command (Cmd) key in OS X and Control (Ctrl) in Windows. I’ll include only the secondary key(s) in the table below since the primary key should be held down. I am planning to update this table several times.

Function	Second key	Internet Explorer	Opera for Windows	Opera for Mac	Chrome for Windows	Chrome for Mac
Quit (Close) app	Q			✓	x	✓
Close tab (window)	W			✓	✓	✓
Refresh tab	R			✓	✓	✓
Open a new tab	T			✓	✓	✓
Open last closed tab	SHIFT-T			✓	✓	✓
View source	U			✓	✓	x
Print page	P			✓	✓	✓
Select all page content	A			✓	✓	✓
Save current page to computer	S			✓	✓	✓
Add to favorites / bookmark	D			✓	✓	✓
Find in page	F			✓	✓	✓
Find again	G			✓	✓	✓
Show history	H				✓	x
View downloads	J			✓	✓	x
Focus the address bar	L			✓	✓	✓
Undo	Z			✓	✓	✓
Cut	X			✓	✓	✓
Copy	C			✓	✓	✓
Paste	V			✓	✓	✓
Open a new window	N			✓	✓	✓
Open a new private window	SHIFT-N			✓	✓	✓

✓ = available
x = unavailable
[white_space] = not yet verified

(work in progress)

Dear readers, what other useful shortcuts is this table missing?

Quick trick : Copy file path

Andrei Rinea — Wed, 04 Feb 2015 13:38:44 +0000

Are you in a command line prompt and you need the full path of the file as an argument? You don’t need to type all of the path manually, not even pre-complete it using TABs. Just navigate to the file.
Here comes the trick part : hold SHIFT while right-clicking it. The context menu will look like so :

I wrote before about the SHIFT-right click so this is somehow connected.

You will then have the full path of the file in the clipboard ready to be pasted wherever you need.

Hope this helps someone!

Overriding and overloading in Java and .NET – differences, changes and gotchas

Andrei Rinea — Wed, 04 Dec 2013 09:15:46 +0000

Foraying even more in the fundamentals of Java (coming from a .NET background) I’ve come across some interesting things, along with changes in Java SE 5. But first let’s clear up a bit these two notions (overloading and overriding).

Overriding

Is a language feature that allows a subclass/inheriting class to have a method identical (we’ll later see a slight exception to this) to the one in the base class/superclass in every way except the implementation. That is, to have the same return type, the same name, same paramater types, same parameter order, just the code (and the parameter names) can differ.

This is by no means a definitive definition, Wikipedia, .NET CLS’s and JLS may very well differ slightly.

A typical C# overriding example (yes, I also dislike animal examples but they are so eaaaasyyyy to come up with) :

public class Dog 
{
    public virtual void MakeSound()
    {
         Console.WriteLine("Bark.");
    }
}

public class Hound : Dog
{
    public override void MakeSound()
    {
         Console.WriteLine("Wooofff!!!");
    }
}

Java developers unaware of the intricacies of C# will wonder what is that “virtual” thing. In C# all methods are “final” (sealed) by default unlike Java where methods are “virtual” (non-final / non-sealed) by default. This is a profound difference which we’ll discuss later. The “:” stands for “extends”. We’ll discuss the “override” keyword soon, also.

The equivalent piece of code in Java would look like :

public class Dog {
    public void makeSound() {
        System.out.println("Bark.");
    }
}

public class Hound extends Dog {
    public void makeSound() {
        System.out.println("Woofff!!!");
    }
}

Method overriding makes the platform select the method implementation at runtime. What does this mean? It means that having an instance of a Dog (be it effectively a Dog instance or an instance of a Hound which is also a Dog) and calling the MakeSound method will make the JVM / CLR select the appropiate implementation irrespective of the type of the reference to that instance. Here’s a code sample that illustrates it (perfectly equivalent for both C# and Java – except the casing of the MakeSound method) :

Dog d = new Dog();
Hound h1 = new Hound();
Dog h2 = new Hound();

d.MakeSound();
h1.MakeSound();
h2.MakeSound();

The output will be

Bark.
Wooofff!!!
Wooofff!!!

For the d instance it is expected to have “Bark.” printed but notice how for the h2 instance, although the reference is of type Dog, the Hound implementation is used. This is because, just as I was saying above, the runtime will select the implementation for that exact instance type irrespective of the reference type.

As I promised earlier, let’s discuss a bit about the override keyword (C#) and the @Override annotation (Java). C# enforces you to use the override keyword when overriding (otherwise you would be using “method hiding” – a feature that we’ll discuss later) while Java does not. Since Java 5 the optional @Override annotation has been introduced, that you should use whenever you do overriding.

The main reason this @Override annotation is useful is that when doing an override, if you mistake the signature, the return type or even the method name the compiler will emit an error, stopping you from a potential overload instead of override. I’ve written about this before but I’ll extend the older example :

Let’s say you have a `Person` class that has an ID and a name and you want two different instances that have the same ID and name to be semantically equal. So you write the class :

public class Person {
    private int id;
    private String name;

    public int getId() { return id; }
    public void setId(int id) { this.id = id; }

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public int hashCode() { return id; }
    public boolean equals(Person other) { return this.id == other.id; }
}

Seems legit. We even took the time to override the hashCode function along with equals, as it is a good practice (in both Java and C#) to override these as a pair. Then we go ahead and write some code that exercises this class :

Person john = new Person();
john.setId(1);
john.setName("John");
List persons = new ArrayList<>();
persons.add(john);
//...
Person johnnyBoy = new Person();
johnnyBoy.setId(1);
johnnyBoy.setName("John");

System.out.println(persons.contains(johnnyBoy));

Guess what, this will print “false” in spite of what some people might expect. The Object class (from which all class inherit directly or indirectly) contains the equals method which has a single argument of type Object and not Person. So the equals method on the Person class is not overriding but overloading. The contains method above uses the equals(Object) method which is NOT the one provided by us, which, by default, compares instances.

Let’s correct things :

public class Person {
    private int id;
    private String name;

    public int getId() { return id; }
    public void setId(int id) { this.id = id; }

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public int hashCode() { return id; }
    @Override public boolean equals(Object other) { return this.id == ((Person)other).id; } // In production make sure to also check for a null argument.
}

Now the “testing code” will correctly print “true”. By applying @Override to equals (or any overriden method) the Java compiler will check that the provided method matches a base class overridable (non-final) method and triggers an error if the signature, name, parameter types differ or the base class method is final (“sealed” in C#).

This type of error will be less likely to appear in C# since C# developers were accustomed since the very first version to use the override keyword. They still can omit the keyword resulting in overload, but, again, it’s less likely.

A peculiar difference between Java and C# is that C# allows method hiding. This is a feature allows the inheriting class/subclass to declare a method with an identical return type, name and signature like a base class/superclass method which is sealed/final.
Such a “hiding” method will require the new keyword or else the compiler will emit a warning (not an error!). Let’s revisit our mutts :

public class Dog 
{
    public void MakeSound() // note that lacking the "virtual" keyword is equivalent to "final" in Java
    {
         Console.WriteLine("Bark.");
    }
}

public class Hound : Dog
{
    public void MakeSound()
    {
         Console.WriteLine("Wooofff!!!");
    }
}

// ...

Dog d = new Dog();
Hound h1 = new Hound();
Dog h2 = h1;

d.MakeSound();
h1.MakeSound();
h2.MakeSound();

Running this will output :

Bark.
Woofff!!!
Bark.

The surprise is that calling MakeSound on the h2 reference (which is of the Dog type) will invoke the Dog implementation rather than the Hound implementation even if the instance is of type Hound. Method hiding is a kind of overloading, which, we’ll see later uses early (method) binding and not late binding.

Overloading

Overloading is a language feature allowing two or more methods two have the same name but different parameter types, or a different number of parameters and maybe a different return type, be it in the same actual class or in the class hierarchy.

As we saw earlier the Person class had an equals method that accepted a single Person parameter while its base class (Object) had another method called also equals but having a single parameter of type Object.

Overloading is quite subtle both for the class producer and for the class consumer and should be used, in my opinion, with care and moderation.

Here’s another peculiarity between C# and Java, in the context of overloading. Let’s say you have a params/varargs overload along another method(s) :

C# version :

class Program
{
    static void Main()
    {
        DoStuff(23);
    }

    public static void DoStuff(object obj)
    {
        Console.WriteLine("Single object parameter overload");
    }

    public static void DoStuff(params int[] numbers)
    {
        Console.WriteLine("params integer array overload");
    }
}

Java version :

public static void main(String[] args) {
    doStuff(23);
}

public static void doStuff(Object obj)
{
    System.out.println("Single object parameter overload");
}

public static void doStuff(int... numbers)
{
    System.out.println("params integer array overload");
}

What do you think each of the version will print upon execution? This is not intuitive. The C# will select the params (probably because the params type is closer to the type of the value passed in?) while Java will select the overload with the closest “number” of parameters, the Object overload. Take care if you port code from one language to another

Another interesting situation is when you have to lump together two or more types, part of the same hierarchy like this :

public void MakeSound(Dog dog) {
    System.out.println("Bark.");
}

public void MakeSound(Hound hound) {
    System.out.println("Wooofff!!!");
}

Dog[] canides = new Dog[2];
canides[0] = new Dog();
canides[1] = new Hound();

for(Dog canide : canides) {
    MakeSound(canide);
}

The compiler will make an early binding from the call at line 14 to the first overload of MakeSound (the one with the Dog parameter) irrespective of the actual type passed in. This “issue” happens irresepective of the platform (Java / .NET)

Enough for overloading and overriding for now, till the next time,

Take care and be (type)safe! 😛

Numeric literals in Java 7 and in C#

Andrei Rinea — Wed, 27 Nov 2013 19:58:33 +0000

In both Java and C# it’s quite easy to express integer numerical literals. You can use both decimal and hexadecimal base to represent the value. Only for the hexadecimal base you need to prefix the value with 0x. For decimal base values that exceed 2^31-1 you need to provide a suffix (typically L) specifying this fact so the compiler will treat it like a long integer value. C# also provides unsigned long values (U prefix). In both languages the casing of the suffix does not matter.

Java : (notice, there are no unsigned primitives in Java)

int i1 = 23; // integer, decimal
int h1 = 0x17; // integer, hexadecimal
long i2 = 12345678900L; // long integer (64 bit signed integer)

C# :

int i1 = 23;
int h1 = 0x17;
ulong u1 = 12345678900U;
long i2 = 12345678900L;

As you might have read in Beginning Java for .NET developers on slide 14, beginning in Java 7 you can also use two more features, that are not present in C# (at least at the time of this writing) :

Binary base :

int b1 = 0b11001010;

Underscores in literals (no matter which base) :

int b1 = 0b1100_1010;
long myCardNumber = 2315_2432_2111_1110;
int thousandsSeparated = 123_456_000;

The restrictions on the underscore placing is that you may not place it at the beginning of the value (prefix) or at the end (suffix). Also, for non-integer literals, you may not place it adjacent to the decimal separator.

For floating-point literals you must use the dot as decimal separator (if you need to specify a fraction, if not, you’re not required). You must use F for float-single-precision (32 bit) and D for float-double-precision (64 bit). Moreover in C# you have also the M suffix corresponding to the decimal (128 bit) value type.

C# :

float x1 = 0.001F;
double x2 = 12.33D;
decimal x3 = 111.2M;
float x4 = 33F;

Java :

float f1 = 0.001F;
double f2 = 12.31D;
float f3 = 123F;

Enum – comparison of Java and .NET

Andrei Rinea — Tue, 26 Nov 2013 09:41:00 +0000

A useful feature added in Java 1.5 (also known as J2SE 5.0, 2004) is the enum. In .NET enums have been present since the very first version (2002, and as a beta since 2000) but the engineers at Sun managed to learn something from the shortcomings of the enums in .NET and provided more flexibility.

Let’s start with the simplest, the .NET implementation. In .NET all data types, including value types (equivalent of the primitive types) are part of the type hierarchy, being, indirectly inherited from System.Object (equiv. of java.lang.Object). The enums are just a specialization on top of exact numeric types, by default int (System.Int32). A typical declaration :

public enum Month
{
    January,
    February,
    March,
    April,
    May,
    June,
    July,
    August,
    September,
    October,
    November,
    December,
}

Notice that the compiler is forgiving and doesn’t complain that after the last element we forgot to not place a comma. It will also work, of course, if we don’t place a comma after the last element. Behind the scenes the compiler will generate a value-type inheriting from System.Enum that will have 12 constants. By default these constants we’ll be of type Int32 and their value, again, by default, will start from 0 and increase by 1 for each member. January will be 0 and December will be 11. Casts between the backing type (Int32 in this case) and the Months type will be allowed both at design time and at runtime.

You can also force individual values for each member

public enum Month
{
    January = 3,
    February = 33,
    March = 222,
    April = 14,
    May = 20,
    June = 23,
    July,
    August,
    September,
    October,
    November,
    December,
}

In this case January will be equal to 3, February 33, …, June 23, July 24 (not specified but after a value-specified member, the next member will be the last value + 1 if specific value is not present. You can even force things into a bad situation like so :

public enum Months
{
    January = 1,
    February,
    March,
    April,
    May,
    June,
    July = 1,
    August,
    September,
    October,
    November,
    December,
}

Guess what, not only this is completely valid, but there won’t be just two duplicate values (January and July being equal to themselves, and equal to 1) but also February will be 2, just like August and so on. Of course, this is not recommended. The compiler and the runtime will happily apply your stupid scheme but the humans will be confused. This excess of freedom is not to my liking but I can’t do much about it except counter-recommend it. Ideally you should not have to specify values for typical enums. Except for…

Flag-value enums (these are akin to Java’s EnumSet)

[Flags]
public enum PizzaToppings
{
    None = 0,
    Mozzarella = 1,
    Pepperoni = 2,
    Anchovies = 4,
    Mushrooms = 8,
    Corn = 16
}

//...

PizzaToppings myFavs = PizzaToppings.Pepperoni | PizzaToppings.Anchovies;
Console.WriteLine(myFavs);

This will not print “6” although this will be the int value of myFavs. It will print “Pepperoni, Anchovies”.
You’ll use the | (bitwise OR) to combine flags into a certain PizzaToppings instance. To detect a certain flag exists you can use any of these two ways :

bool hasAnchovies1 = (myFavs & PizzaToppings.Anchovies) != PizzaToppings.None;
bool hasAnchovies2 = myFavs.HasFlag(PizzaToppings.Anchovies);

The first one is uglier, old-school (pre .NET 4.0) but it’s completely type-safe. The second one is cleaner, more elegant but you can place an instance of another enum in there. The compiler will not complain. Just the runtime which will throw an ArgumentException.

Converting strings into enum instances and vice-versa is trivial also :

string s1 = "Anchovies";
string s2 = "AnCHOviES";

PizzaToppings pt1 = (PizzaToppings)Enum.Parse(typeof(PizzaToppings), s1);
PizzaToppings pt2 = (PizzaToppings)Enum.Parse(typeof(PizzaToppings), s2, ignoreCase: true);
PizzaToppings pt3 = (PizzaToppings)Enum.Parse(typeof(PizzaToppings), s2); // ArgumentException - by default the parsing does not ignore casing

(note : typeof(PizzaToppings) in C# is equivalent to PizzaToppings.class in Java; the strange third parameter in pt2 is a named parameter. Optionally you can include the parameter name followed by a colon before its value in order to improve the readability of the code. The compiler will “remove” this before compiling)

Being seen like the backing-value-type by the runtime you can very well use enums in a switch :

switch(month) 
{
    case Month.January : 
        Console.WriteLine("Cold, brrr...."); 
        break;
    case Month.February : 
        Console.WriteLine("Still cold, brrr...."); 
        break;
// ...
}

Being value-types take in account boxing and unboxing performance implications when assigning instances to object fields or variables and vice-versa (this is similar to the autoboxing issues with primitives in Java).

A few best practices :

Consider singular names for simple enums. For flagged enums consider plural forms.
Include a “Unknown”, “None”, “NotApplicable” etc. default value for each enum. This will help you in case you forget to initialize a field of that enum type, for example. You’ll be surprised by the default value and you’ll know (by a warning, exception etc.) that the initialization did not take place.
Do not abuse them. If you find yourself having an instance of enum in a class and in most of the methods switching or if’ing over that field then it might be a sign of a poor OOP design. Inheritance might be the key. Beware of switch!
In switches based on enums consider including a default clause throwing an out of range exception in order to detect unhandled newly-added enum values.

Finally, let’s metion that you can also use byte, short (Int16) and long (Int64) as backing type for your enums :

public enum Mood : byte
{
    Happy,
    Bored,
    Sad,
    Angry,
    Ecstatic,
    Sleepy
}

Let’s consider this enough, for now, in the .NET world and let’s take a look in Java.

Before Java SE 5 there was no support for enums. People were cramming static final public fields (“constants” as seen in .NET, or more precisely public static readonly) in classes. There were and still are no static classes so they were forced to create a private constructor and even throw an exception in that private constructor like so :

public class Mood {
    private Mood() {
        throw new IllegalOperationException(); // prevent accidental instantiation even within the class
    }

    public static final int HAPPY = 0;
    public static final int BORED = 1;
    public static final int SAD = 2;
    public static final int ANGRY = 3;
    public static final int ECSTATIC = 4;
    public static final int SLEEPY = 5;
}

It, obviously sucked and the only improvement was to move all these (except the constructor) in an interface. Yes, in Java you may declare final fields (“constants”) in an interface. Not much better… just a tiny bit.

This was lousy since there was no kind of type safety. There was no printing support either. Switching on an int and casing on these fields was a nightmare since you had no easy way to enumerate them and many more problems.

Final-ly (:P) Java SE 5 came out and the enum support with it. This was quite impressing (note, my background is .NET development) – the enum support. Here’s why :

The enum types are reference types. This simplifies the null management (yes, in .NET there is nullable types support but it’s a bit less intuitive than a reference type).
Because of the previous point the enums can be treated like any class. This means you can implement interfaces, add methods, override (non-final / virtual) methods. We’ll later see some interesting things on this.
We still get the same support for switching, parsing from strings, converting to strings and all others. EnumSet helps with flagged enums.
You can have custom constructor(s) for your enum values

There is no primitive type backing but that’s no loss. All enums inherit from java.lang.Enum and can override toString(). Each enum value is a different instance of the enum class, instantiated either with the default constructor either with a custom one. Here’s a full-fledged Java enum sample :

public enum Planet {
    MERCURY (3.303e+23, 2.4397e6),
    VENUS   (4.869e+24, 6.0518e6),
    EARTH   (5.976e+24, 6.37814e6),
    MARS    (6.421e+23, 3.3972e6),
    JUPITER (1.9e+27,   7.1492e7),
    SATURN  (5.688e+26, 6.0268e7),
    URANUS  (8.686e+25, 2.5559e7),
    NEPTUNE (1.024e+26, 2.4746e7),
    PLUTO   (1.27e+22,  1.137e6);

    private final double mass;   // in kilograms
    private final double radius; // in meters
    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }
    public double mass()   { return mass; }
    public double radius() { return radius; }

    // universal gravitational constant  (m3 kg-1 s-2)
    public static final double G = 6.67300E-11;

    public double surfaceGravity() {
        return G * mass / (radius * radius);
    }
    public double surfaceWeight(double otherMass) {
        return otherMass * surfaceGravity();
    }
}

By default toString() returns the same value as name() but, as told earlier, it can be overriden. You can also obtain the ordinal of an enum instance within the enum with the ordinal() instance method.

Although it’s a reference type you can very well switch on an enum in Java, without any problem :

switch(myPlanet) {
    case EARTH :
       System.out.println("Home");
       break;

Note that switch, in Java, does not require break (or any other control mechanism) for each branch. So you can easily (accidentally) fall-through and no compiler or runtime will save you.

Implementing interfaces in an enum can be done in two ways : on each member or at the enum level :

// at member level
public enum Chores implements Runnable {
    TAKE_OUT_THE_TRASH {
        @Override
        public void run() { // ...
        }
    },
    DO_THE_LAUNDRY {
        @Override
        public void run() { // ...
        }
    }
}

public enum FunStuff implements Runnable {
    GO_OUT,
    VISIT_NEW_PLACES,
    // ...

    @Override
    public void run() { // ...
    }
}

All in all, I admire the better implementation of enums in Java and hope all platforms will have a better support in the future.

Beware of primitive wrappers in Java

Andrei Rinea — Wed, 20 Nov 2013 20:06:53 +0000

A .NET developer can be tricked into thinking that, for example, Integer is the same with int in Java. This is dangerous, in particular for a C# developer, because in C# System.Int32 is absolutely equivalent to int. “int” is just an alias.

In Java there are 8 primitive data types :

byte (this is equivalent to sbyte in C#)
short (just like short / Int16 in C#)
int (just like int / Int32 in C#)
long (equivalent to long / Int64)
float (similar to float / Single)
double (similar to double / Double)
boolean (equivalent to bool / Boolean)
char (equivalent to char / Char)

Now, these primitive types are not part of the Java Type System, as you might have seen in Beginning Java for .NET developers in the slides, at page 21. These primitives (“value types”) have reference-type peers that are typically spelled the same (except int/Integer, char/Character) and just have the first letter capitalized.

Just like you should avoid comparing strings with == in Java, you should avoid declaring variables and fields of the reference-type peers, unless for a good reason.
The main danger lies in the fact that being reference types and Java not having operator overloading (see Beginning Java for .NET developers, slide 15) comparing two instances with the == operator will compare the instances and not the values.

“Oh, but you’re wrong!”, some of you might say, “I’ve written code like this and it worked!”. Code like this :

public class Main {

    public static void main(String[] args) {
        Integer i1 = 23;
        Integer i2 = 23;

        System.out.println("i1 == i2 -> " + (i1 == i2));
    }
}

Yes, it does print

i1 == i2 -> true

It will work to values up to 127 inclusive. Just replace 23 with 128 (or higher) and see how things go. I’ll wait here.
Surprised? You shouldn’t be. This thing works because of a reason called integer caching (and there are ways to extend the interval on which it works – by default -128 up to 127 inclusive) but you shouldn’t rely on it.

Just use int where available or at least use the .intValue() method.

You might wonder what is the Integer (and the rest of the reference-type wrappers) there for? For a few things where they are needed. Once, because the generics in Java are lacking and you can’t define a generic type with primitive type(s) as type arguments. That’s right, you can’t have List. Scary? Yes, especially when coming from .NET where generics are not implemented with type erasure. So you need to say List and then watch out for reference comparison instead of value comparison, autoboxing performance loss and so on.

The other reason why you need these wrappers is because there is no nullable-types support in Java. So if you need to have a variable or a field that can store a primitive type but might also have to store a null then Integer will be better for you than int.

Just make sure you understand these implications and … be (type :P) safe!

Avoid comparing strings with == in Java

Andrei Rinea — Tue, 19 Nov 2013 18:00:46 +0000

While beginning development in Java, especially if coming from a .NET background (but not necessarily) you might do string comparison with == in Java. Don’t do it. It will compare the string instances and not their effective value.
You might even try it first to check if == really works, testing it in a wrong manner like so :

public static void main(String[] args) {

    String s1 = "Abc";
    String s2 = "Abc";

    System.out.println("s1 == s2 -> " + (s1 == s2));
}

This will output

s1 == s2 -> true

.. which might lead you to believe this works. This does return the correct value because of a feature present in Java and .NET called string interning (not specific to Java or .NET).

Try to obtain a string instance dynamically like concatenating two existing instances and see how things don’t work anymore :

public static void main(String[] args) {

    String s1 = "Abc";
    String s2 = "Abc";

    // new lines :
    String capitalA = "A";
    String bc = "bc";
    String s3 = capitalA + bc;

    System.out.println("s1 == s2 -> " + (s1 == s2));
    // new line :
    System.out.println("s1 == s3 -> " + (s1 == s3));
}

s1 == s2 -> true
s1 == s3 -> false

Weird, huh? That’s because at compile time there are four distinct strings generated : “Abc” (once, even if referred twice), “A” and “bc”. The “Abc” instance obtained by joining “A” and “bc” will be generated at runtime and, of course, it will be a different instance than the first “Abc” instance. That’s why the result of the == operator comparison will be false.

But the compiler can be smarter than you might expect. How’s that? Here’s how :

public static void main(String[] args) {

    String s1 = "Abc";
    String s2 = "Abc";

    String capitalA = "A";
    String bc = "bc";
    String s3 = capitalA + bc;

    // new line
    String s4 = "A" + "bc";

    System.out.println("s1 == s2 -> " + (s1 == s2));
    System.out.println("s1 == s3 -> " + (s1 == s3));
    // new line
    System.out.println("s1 == s4 -> " + (s1 == s4));
}

.. resulting in :

s1 == s2 -> true
s1 == s3 -> false
s1 == s4 -> true

The compiler inferred the result of the string concatenation in the s4 initialization and then interned the resulted string, detected the already existing “Abc” instance and reused it.

Alright, that’s not the right way to do it, the correct way to do it is to use the .equals(String s) instance method of the String class. Like so :

public static void main(String[] args) {

    String s1 = "Abc";

    String capitalA = "A";
    String bc = "bc";
    String s2 = capitalA + bc;

    System.out.println("s1.equals(s2) -> " +  s1.equals(s2));
}

This works nice :

s1.equals(s2) -> true

All’s well until we teak things a bit :

public static void main(String[] args) {

    String s1 = null;
    String s2 = null;

    System.out.println("s1.equals(s2) -> " +  s1.equals(s2));
}

Guess what, it’s not “true” that’s being displayed but the stack trace of a NullPointerException. Your solution might be some weird ternary expression (yuck) that looks like so :

public static void main(String[] args) {

    String s1 = null;
    String s2 = null;

    boolean b = s1 == null ? s2 == s1 : s1.equals(s2);
    System.out.println(b);
}

You can extract this expression into a static method in a helper class if you find yourself doing this often.

As a final aspect to consider, if one of the two strings is a constant value you can still use equals on that one like so :

public static void main(String[] args) {

    String s1 = getData();
    String s2 = "someValue";

    System.out.println(s2.equals(s1));
    System.out.println("someOtherValue".equals(s1));
}

Simulating C# ref parameter in Java

Andrei Rinea — Sun, 17 Nov 2013 20:13:48 +0000

As I was saying a few posts ago (Beginning Java for .NET Developers), on the 8th slide, there are no ref and no out method parameter modifiers.

These are rarely used in .NET anyway so you can’t really complain of their lack in Java. Furthermore, some of their legitimate uses, such as the static TryParse methods on value types are not applicable in Java. Why? Because in Java the primitives (int, long, byte etc. – the equivalent of the basic value types in .NET) are not part of the type hierarchy and they have reference-type wrappers (Integer etc.) which would solve the issue of returning the result in case of ‘TryParse’ style of parsing. How’s that? It’s like :

public static Integer tryParseInt(String intString) {
    try {
        return Integer.parseInt(intString);
    } catch (NumberFormatException e) {
        return null;
    }
}

No need for a ‘out’ parameter or ‘ref’. But! Let’s try and simulate ‘ref’ using a generic class written this way :

public class Ref {
    private T value;

    public Ref() {
    }

    public Ref(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return value == null ? null : value.toString();
    }
}

Now, suppose we have a class PhoneNumber that expects a number as [firstPart]-[secondPart] (both being integer, positive numbers). This class could look like :

public class PhoneNumber {

    private final int firstPart;
    private final int secondPart;

    private final static int NOT_FOUND = -1;

    public PhoneNumber(int firstPart, int secondPart) {
        this.firstPart = firstPart;
        this.secondPart = secondPart;
    }

    public int getFirstPart() {
        return firstPart;
    }

    public int getSecondPart() {
        return secondPart;
    }

    @Override
    public String toString() {
        return Integer.toString(firstPart) + "-" + Integer.toString(secondPart);
    }
}

We will also suppose that another allowed string representation of a phone number would be “private” (irrespective of the casing). We want to create a static tryParse method on that class. If the given string is not a valid phone number we could return null. But in case of the “private” value we would be also forced to return null. There would be an ambiguity. Therefore we would need some kind of disambiguation. One way would be to use the Ref class defined above like so :

public static boolean tryParse(String phoneNumberString, Ref phoneNumber) {
    if (phoneNumberString == null || phoneNumberString.isEmpty()) return false;
    if (phoneNumber == null) throw new IllegalArgumentException();

    phoneNumber.setValue(null);
    if (phoneNumberString.toLowerCase().equals("private")) {
        return true;
    }
    int dashIndex = phoneNumberString.indexOf('-');
    if (dashIndex == NOT_FOUND || dashIndex == 0 || dashIndex == phoneNumberString.length() - 1) {
        return false;
    }

    String firstPartString = phoneNumberString.substring(0, dashIndex);
    String secondPartString = phoneNumberString.substring(dashIndex + 1, phoneNumberString.length());
    int firstPart;
    int secondPart;

    try {
        firstPart = Integer.parseInt(firstPartString);
        secondPart = Integer.parseInt(secondPartString);
    } catch (NumberFormatException e) {
        return false;
    }

    phoneNumber.setValue(new PhoneNumber(firstPart, secondPart));
    return true;
}

An example of using that code could be

    public static void main(String[] args) {
        String s1 = "555-1234";
        String s2 = "555";
        String s3 = "saldkfjasdf";
        String s4 = "PRIVATE";
        String s5 = "";
        String s6 = null;

        Ref pn1 = new Ref();
        Ref pn2 = new Ref();
        Ref pn3 = new Ref();
        Ref pn4 = new Ref();
        Ref pn5 = new Ref();
        Ref pn6 = new Ref();

        boolean b1 = PhoneNumber.tryParse(s1, pn1);
        boolean b2 = PhoneNumber.tryParse(s2, pn2);
        boolean b3 = PhoneNumber.tryParse(s3, pn3);
        boolean b4 = PhoneNumber.tryParse(s4, pn4);
        boolean b5 = PhoneNumber.tryParse(s5, pn5);
        boolean b6 = PhoneNumber.tryParse(s6, pn6);

        System.out.println("Parsing '" + s1 + "' : " + b1 + ", Ph# : " + pn1);
        System.out.println("Parsing '" + s2 + "' : " + b2 + ", Ph# : " + pn2);
        System.out.println("Parsing '" + s3 + "' : " + b3 + ", Ph# : " + pn3);
        System.out.println("Parsing '" + s4 + "' : " + b4 + ", Ph# : " + pn4);
        System.out.println("Parsing '" + s5 + "' : " + b5 + ", Ph# : " + pn5);
        System.out.println("Parsing '" + s6 + "' : " + b6 + ", Ph# : " + pn6);
    }

Upon running this piece of code we would receive :

Parsing '555-1234' : true, Ph# : 555-1234
Parsing '555' : false, Ph# : null
Parsing 'saldkfjasdf' : false, Ph# : null
Parsing 'PRIVATE' : true, Ph# : null
Parsing '' : false, Ph# : null
Parsing 'null' : false, Ph# : null

This way we were able to simulate a ref parameter. However some might argue that this is not the only solution and we could have defined another class called ParseResult encapsulating a boolean representing the success of parsing and a T representing the parsed value (in case the parsing succeeded). Of course we could do this, it would be a good alternative. However, for the C# / .NET developers the Ref would be closer to their existing knowledge.

Regarding the out parameter things are not so bright. That’s because of two things : first, the called method should be enforced to set at least once a value to the out parameter on each execution path and in C# this is enforced by the compiler while in Java I see no way to enforce it. Second, the solution (if one would exist) should restrict the called method to only set the value but not read it while the method caller should be able to read and write.

In conclusion at least we can simulate ref with Ref. This pattern is also used in EventArgs and other derived classes, in .NET.

Preparing the development environment for Java – Windows and Ubuntu

Andrei Rinea — Sat, 16 Nov 2013 19:49:16 +0000

Unlike .NET development where everything is streamlined and well-aligned, starting from the OS, the framework, the tools, the IDE and all others being written by one company, in Java development you’ll experience “freedom”(1) of choice. I’ll start with a gentle introduction which the experienced may very well skip to avoid getting bored.

In order to get started developing in Java we’ll need the following :

An OS. I’ll showcase Windows and Ubuntu (Linux).
A Java JRE. This is the most basic component required to run Java programs.
A Java JDK. The JDK or Java SDK (IBM calls it that way) typically includes the JRE plus a compiler, tools for running various types of Java programs, packaging tools, extra class libraries and many more.
An IDE – Integrated Development Environment. This is typically an MDI (Multi-Document Interface) application which provides certain convenience features for the developer :
- Syntax highlighting – keywords are displayed in a certain color, local variables in another etc.
- Code completion – instead of having to type the whole keyword, or class identifier, a member and so on, an autocompletion prompt will appear (usually triggered by the user typing a dot or other notable event) easing your typing and avoiding typos.
- Interactive debugging – Allowing the user to control the execution of the program by inserting breakpoints, stepping over, into or out of code, watching expressions (variables, fields etc.), modifying internal data or even (very few IDEs allow) stepping back.
- Tracing – in case you need to inspect internal data but breaking into the debugger cancels the bug or triggers other unwanted condition or the data changes too fast, you can watch expressions in a specially designed tool window without interrupting the flow of the debugged program
- Source control integration – allows the user to send/push/checkin/etc changes to file(s) into a repository, obtaining the latest version, comparing versions, merging, branching and many more operations
- Visual designers – For UI modules or elements most IDEs offer some kind of preview of the developed interface, showing the developer pretty much how things will look and behave without needing to recompile, run and browsing to that particular interface
- Packaging and deployment – Features for creating a package of the application, be it JAR, WAR, DLL, ZIP, APK etc. Furthermore many IDEs will help you push a site to a webhosting provider, cloud service and so on.
- .. and a whole lot more but let’s try to keep things shorter

The OS

There’s not much to cover, in my opinion, here. I guess if you reached the level of developer you’ll be able to install an OS. In fact just reading this article on a PC usually means that you already have an OS installed. Both Windows and Ubuntu have a simple install process, ship as a CD or ISO image that you can boot from a USB drive, a DVD, or insert into a Virtual Machine.

In my experience I’ve used Windows 8.1 64 bit and Ubuntu 13 in a VMware virtual machine. Recommended hardware specs, IMHO would be :

1.5GHz+ Quad-core CPU
4 GB RAM
a decent SSD

Sure, these aren’t the bare minimum requirements. All presented here could run on a single-core 1GHz CPU with 1GB RAM and 5400rpm HDD. The recommended specs are here to tell you where the comfort zone begins.

Java 7 (the latest at the time of this writing) supports Windows down to XP SP3 and Ubuntu since 10. The details of the system requirements are quite interesting, the minimum amount of RAM being 64 MB.

Since Java has this promise of Write Once Run Everywhere (contradicted in practice by almost all my Java fellow developers but let’s skip that part) I’ve had installed both OS’es so I can see how well this goes.

One notable part is that Ubuntu (like most of the *NIX platforms) is not so friendly when installing certain pieces of software even with the advent of apg-get, rpm and so on.

JRE

Windows does not come by default with any JRE or JDK, the java support being null. Ubuntu 13 comes pre-loaded with OpenJDK JRE. This is just the JRE and not a JDK in spite of its name. Furthermore it will not support JavaFX and IntelliJ IDEA IDE will pretty much reject it. So, IMHO, Ubuntu has, at least for me, no Java support out-of-the-box either.

JDK

Since we have to install a JDK anyway (which typically includes a JRE) I chose the ‘original’ vendor, Oracle (former being Sun but acquired a few years ago by Oracle). Typically the Oracle JDK has the widest support for Java technologies (such as JavaFX) and it’s well maintained. Others, such as IBM, does not even support the #1 OS on the market, Microsoft Windows. The Ubuntu Software Center, which simplifies installing of software, having a graphical interface, does not encourage the installing of the Oracle JDK. More on this shortly.

Windows has a clean experience, you just go to the JDK downloads page (you don’t need to bookmark this link, just type ‘download jdk’ in your favorite search engine, such as WPEngine review, get the first Oracle link and choose JDK when confronted with JDK, JREs and others). Select your platform (Windows x64 in my case), download the .EXE file, run it, next -> next -> finish.
Be careful that recently Oracle has started to bundle some crapware – like Ask Toolbar extension along with the JDK, uncheck the necessary boxes :

Let’s get back to Ubuntu now. There are two ways to install the Oracle JDK on Ubuntu, that I know of and tried : the hard one and the easy one. The hard one means doing it manually all the way, by downloading the .tar.gz package from Oracle, unpacking it, placing the files in the right directories, editing the JAVA_HOME environment variable, setting up alternative aliases and many more manual steps that are prone to mistyping and hair pulling during and after the process. If for some reason you want to know the details or you are constrained to use this route, then follow this link (“don’t worry” there are “only” 17 steps).

The easy one is described at ‘Install Java JDK 7 on Ubuntu 12.04 (JavaFX is included in the installation)‘. Basically you just open up a terminal window and :


	sudo add-apt-repository ppa:webupd8team/java
	sudo apt-get-update
	sudo apt-get install oracle-jdk7-installer

The first command adds a new APT repository so the third command will be able to get the Oracle JDK 7 Installer. The second command updates all APT packages so all dependencies will be up to date. Finally the third command will install the Oracle JDK 7 Installer. This will self-start after download and will display a text-GUI which will do all those 17 steps in the manual way described above. The bulk of the work will be downloading the .tar.gz from Oracle and will display a kind of progress bar. Finally the JDK will be installed and operational.

On both OS’es listed above the JDK will be operational without needing to restart the OS or do anything else. Regardless of the OS open up a terminal window (Win-R -> CMD [ENTER] for Windows) and type:

java -version

This will test that the java executable, part of the JRE is correctly installed, accessible in the PATH and if these conditions are met, it will display the exact version similar to :

[Windows]

java version "1.7.0_25"
Java(TM) SE Runtime Environment (build 1.7.0_25-b17)
Java HotSpot(TM) 64-Bit Server VM (build 23.25-b01, mixed mode)

[Ubuntu]

java version "1.7.0_45"
Java(TM) SE Runtime Environment (build 1.7.0_45-b18)
Java HotSpot(TM) 64-Bit Server VM (build 24.45-b08, mixed mode)

Notice that the versions differ slightly (update 25 vs update 45) but this is irrelevant. The same features are present, the newer one just has a few more bugfixes.

Do the same for

javac -version

This will test the same about the Java compiler (that’s what the final c stands for). The compiler will probably be less verbose but that’s not an issue.
Having finished this, we’re left just with installing the IDE.

IDE

There are three popular Java IDEs available (and countless other less heard-of) :

Eclipse seems bloated to me and a bit alien, NetBeans ok-ish but coming from a .NET development background with many years of ReSharper (Visual Studio plug-in developed by JetBrains, makers of IntelliJ IDEA), I’ve chosen IntelliJ IDEA. Pretty much the same keyboard shortcuts, same behavior, feeling. Of course I’ve tried them all and there were a few advantages which NetBeans had over IntelliJ IDEA, mainly at JavaFX templates and JavaFX autocompletion support. But that’s pretty much from the fact that both JavaFX and NetBeans are being developed by the same company, Oracle.

On Windows NetBeans and IntelliJ IDEA provide smooth installers while Eclipse provides a simple archive that you just extract somewhere and just run eclipse.exe (you might create a shortcut somewhere to ease startup the next times).

On Ubuntu you can install any of the three main IDEs via Ubuntu Software Center but you’ll get old versions. For Eclipse it’s 3.8.1 vs 4.3.1 (significant differences, I assure you), for NetBeans it’s 7.0.1 vs 7.4 (this was quite touchy since 7.0.1 doesn’t include JavaFX support, and I played with JavaFX for a while) and finally, for IntelliJ IDEA it’s 12.1.0 vs 12.1.6

JetBrains had the most care of updating the Ubuntu Software Package and they have much better technical support for it. Therefore I just installed it using Ubuntu Software Center. For NetBeans I had to download it manually, tried to start the .sh file directly but there was a glitch, it seemed to require chmod-ing to make it executable. I thought you could just ship it executable directly from within the .tar.gz but my Linux skills are quite lacking so it could be either way. In the end it starts and works. Eclipse did not get tested.

Of course, subjectively, I had a lot of glitches and misunderstandings working on Ubuntu after 18 years of using Windows. Things ranging from having the control icons in the left side of the title bar (a la Mac), snapping windows to the edges of the monitor involves keeping them there for, what seems like, 500ms in order to stay snapped. At least the bash tab autocomplete works quite well.

All in all things went ok, I’ve developed a toy app on JavaFX (on Windows), JAR’d it and dragged it over in the Ubuntu machine and worked excellent. Maybe it’s because the app is extremely simple or maybe that promise of Write Once Run Everywhere is respected in the most cases…

While toying around in IntelliJ I’ve assembled the most common (at least for me) commands and their associated shortcuts. Most mature IDEs offer these features or similar ones. Here is my set :

Force completion – CTRL-Space
Type lookup (independent of current imports) – CTRL-ALT-Space
Line-comment selection – CTRL-/
Increase / decrease indent – TAB / SHIFT-TAB
Quick-fix / Intent – ALT-ENTER. Really often used!
Reformat file – CTRL-ALT-L
Duplicate line – CTRL-D
Cut current line (“delete to clipboard”) – SHIFT-DEL without selection
Debug project – SHIFT-F9
Step over – F8
Step into – F7
Step out – SHIFT-F8
Resume – F9
Go to type (class) – CTRL-N
Go to file – CTRL-SHIFT-N
Go to declaration – CTRL-B
Go to implementation – CTRL-ALT-B

For more shortcuts consult the official “cheatsheet” from JetBrains.

At this moment I consider to have at least two development environments set up and ready to run. In the next posts I’ll tackle some Java syntax and platform peculiarities with examples and cautionary tales.

LATER UPDATE :
Regarding Ubuntu 13, there are two (or more?) clashing keyboard shortcuts : CTRL-ALT-L, which should reformat the current source file but instead is caught at the OS level and locks the OS prompting for the user’s password. The other clash is CTRL-ALT-T, which should surround the selection with a template (for example try-catch or try-finally etc) but it’s also caught at the OS level and starts a new terminal window instead.
In order to disable this shortcuts in Ubuntu go to “Start” (press the Win key), type “System settings”, open it, then open the keyboard window, switch to “Shortcuts”. Here, select the “Launchers” category and “Launch terminal” command. Press backspace and the shortcut is cleared. Then do the same, in the “System” category at the “Lock screen” command.
_________________________
(1) – There’s enough freedom of choice on Windows / .NET too. What really bothered me is that this freedom means usually having a lot of components developed in every other imaginable way/style and assembling them together is sometimes harder than solving a murder mistery. Things get better over time with the help of Maven, Apache Software Foundation and even Oracle.

Beginning Java for .NET Developers

Andrei Rinea — Fri, 15 Nov 2013 11:12:07 +0000

I’ve always wanted to learn another language and platform and being a long-time .NET developer Java seemed the closest to my knowledge and one which would seem easy to learn based on what I already knew.

I’ve put off this for various reason along the last 3-4 years, most of which laziness was chief.

Recently some colleagues moved from our project to another project that involves Java modules and since .NET is not a first-class citizen in my employer’s eyes I thought maybe it could serve me as a kind of an ‘insurance’ – to learn Java.

I’ve obtained (..) some ebooks (Effective Java and Thinking in Java), downloaded JDK, a few IDEs (IntelliJ IDEA and NetBeans, no Eclipse for me, thanks) and started doing HelloWorld’s and stuff like that. I noticed JavaFX (which is quite similar to WPF on which I currently work)

I’ve came across two nice comparisons of Java and .NET, written in a constructive manner (i.e. not “mine is better, na nanana”) :

Java / C# comparision
Java for C# Programmers by Cristoph Nahr

Using these two articles I compiled (yes, that’s the original meaning of the word :P) a PowerPoint slideshow.

Then I thought there might be other (.NET developer) colleagues that might be interested in my research and gave an internal presentation based on the slideshow and expanding each item by talk.

I thought I should share it with everyone so here it is (download here) :

I’ve written about Java / C# differences before, and I might continue that series in the near future, with practical examples and counter-examples.

Building Client (JavaScript) Custom Validation in ASP.NET MVC 4 using jQuery

Andrei Rinea — Fri, 28 Jun 2013 15:41:25 +0000

Introduction

I was recently asked by some students of mine how exactly is client custom validation done in ASP.NET MVC (4). I did this once before unobtrusive validation and jQuery in ASP.NET MVC 2.0 but then I lost contact with the implementation details.

In ASP.NET MVC 4 (this started in MVC 3) there is jQuery unobtrusive validation that works hand-in-hand with Data Annotations (a set of validation attributes that can decorate properties or even (view)model classes). I just remembered that you need to create a ValidationAttribute subclass and also implement IClientValidatable on it. Also you must decorate a property of the (View)Model with this attribute.

On the client side you need to write JavaScript code that provides a validation adapter and a validation function.

Let’s suppose we’d want to create an URL shortening service and on the “Add URL” page we’d have three fields :
– Original URL (textbox)
– Use custom slug (checkbox)
– Custom slug (textbox)

The “Original URL” textbox would be mandatory and the input format should be of a fully-qualified URL (for example “http://blog.andrei.rinea.ro” :P)

The custom slug textbox would be mandatory ONLY if the “Use custom slug” checkbox would be checked. This is the tough part since validating this field requires knowledge of another field’s value (the checkbox in this case). And by tough I mean having to write actual code because there is no out-of-the-box validator for this (not on the server-side nor on the client-side).

This small tutorial will asume that you have knowledge of the ASP.NET MVC platform and C#. I will not go into detail on matters such as what is the MVC pattern, what is the controller, view etc.

Implementation – server side

Let’s start by creating a new ASP.NET MVC 4 web project (select “Internet site” template).
We’ll create a UrlController controller with an action called Add :

using System.Web.Mvc;

namespace MVC4_jQuery_Unobtrusive_Custom_Validation.Controllers
{
    public class UrlController : Controller
    {
        [HttpGet]
        public ActionResult Add()
        {
            return View();
        }

        [HttpPost]
        public ActionResult Add(AddUrlViewModel userInput)
        {
            if (ModelState.IsValid)
            {
                // store the data
                // ...
                return RedirectToAction("Index", "Home");
            }
            return View();
        }
    }
}

I think the controller code is pretty straight-forward. So now let’s create the view and the viewmodel :

@model MVC4_jQuery_Unobtrusive_Custom_Validation.ViewModels.AddUrlViewModel


Add a new URL shortening
@using (Html.BeginForm())
{
    
        
            Original URL : 
            
                @Html.TextBoxFor(m => m.OriginalUrl)
                @Html.ValidationMessageFor(m => m.OriginalUrl)
            
        

        
            @Html.LabelFor(m => m.UseCustomSlug, "Use a custom slug")
            @Html.CheckBoxFor(m => m.UseCustomSlug)
        

        
            Custom slug : 
            
                @Html.TextBoxFor(m => m.CustomSlug)
                @Html.ValidationMessageFor(m => m.CustomSlug)
            
        
    
    
       
}

using System.ComponentModel.DataAnnotations;

namespace MVC4_jQuery_Unobtrusive_Custom_Validation.ViewModels
{
    public class AddUrlViewModel
    {
        [Required]
        [Url]
        public string OriginalUrl { get; set; }

        public bool UseCustomSlug { get; set; }
        
        public string CustomSlug { get; set; }
    }
}

We’ll need to create a validation attribute which will be used in decorating the “CustomSlug” property of the viewmodel. We’ll create another folder, called ‘Validation’ and a new class that we’ll call ‘RequiredIfTrueAttribute’ :

using System;
using System.ComponentModel.DataAnnotations;

namespace MVC4_jQuery_Unobtrusive_Custom_Validation.Validation
{
    public class RequiredIfTrueAttribute : ValidationAttribute
    {
        public string BooleanPropertyName { get; set; }

        protected override ValidationResult IsValid(object value, ValidationContext validationContext)
        {
            if (GetValue(validationContext.ObjectInstance, BooleanPropertyName))
            {
                return new RequiredAttribute().IsValid(value) ?
                    ValidationResult.Success :
                    new ValidationResult(FormatErrorMessage(validationContext.DisplayName));
            }
            return ValidationResult.Success;
        }

        private static T GetValue(object objectInstance, string propertyName)
        {
            if (objectInstance == null) throw new ArgumentNullException("objectInstance");
            if (string.IsNullOrWhiteSpace(propertyName)) throw new ArgumentNullException("propertyName");

            var propertyInfo = objectInstance.GetType().GetProperty(propertyName);
            return (T)propertyInfo.GetValue(objectInstance);
        }
    }
}

As we can see we made use of reflection in order to get the boolean property’s value. Since we can only specify the property as a string, we are stuck with using reflection. Don’t worry about the performance impact, it’s minimal.

In case that the propery is set to true we delegate the validation logic to a RequiredAttribute instance (I chose in this case aggregation over inheritance, which is the most flexible approach – inheriting would have meant deriving from the RequiredAttribute and overriding the IsValid method and then using the base.IsValid etc. etc.)

Let’s run the site and see how things go. Being lazy I haven’t included a link in the header of the page so we’ll just ‘hack’ the address to point to http://localhost[:some-port]/Url/Add.

If we try to submit the form as it is :

As we can see the custom slug is not set as invalid since we did not opt in for a custom slug by checking the “Use a custom slug” checkbox. If we do check this checkbox and retry submitting the form we’ll get this :

Implementation – client side

Well this is fine, that is, the server-side validation. If you ran the sample you might have noticed that a full post is made for the validation errors to be displayed on the page. It works as we intended. Now it’s time to do the same for the client-side. In the case of the ‘Original URL’ field things are handled out-of-the-box. For our new custom validation attribute we’ll need to write some javascript using jQuery.

First we’ll enable the client side validation by including the jQuery validation scripts at the view level (“at the top of the file, right beneath the @model directive) :

@section scripts
{
    @Scripts.Render("~/bundles/jqueryval")
}

Although the unobtrusive client-side validation is enabled at the web.config level :

Well, running the app now, yields basically the same results but at least for the ‘Original URL’ field the validation is done at the client-side first (never ever rely only on the client-side validation and not doing the same on the server! Javascript can be turned off or a malicious user could bypass it one way or the other). If we do check the checkbox and hit ‘Save’ then only the server-side validation is being run. Let’s add some client-side validation for this too.

Next we’ll have to implement IClientValidatable on the RequiredIfTrueAttribute class. This means adding a ‘GetClientValidationRules’ method to the class which will provide the metadata for the client-side script to run with :

public IEnumerable GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
{
    var modelClientValidationRule = new ModelClientValidationRule
    {
        ValidationType = "requirediftrue",
        ErrorMessage = FormatErrorMessage(metadata.DisplayName)
    };
    modelClientValidationRule.ValidationParameters.Add("boolprop", BooleanPropertyName);
    yield return modelClientValidationRule;
}

In case you haven’t stumbled upon the yield keyword before have a look on its MSDN page. Basically it creates an inner class that is an enumerator and returns an instance of it, which will enumerate all the values you specify, in this case one value, that instance of the ModelClientValidationRule.

We should take note of two things at this step :

the validation type property allows only lowered case letters because of a limitation in the HTML 5 specifications, this will be rendered as an attribute on the HTML input element
We should provide the error message value as a result of the FormatErrorMessage method call and not provide the ErrorMessage property’s value because in this (current) way we give the validation rendering mechanism a chance to include the property name as part of the validation message. In our case we haven’t included “{0}” in the error message at the attribute decoration level but we could have done it.

This is not all but let’s run the site now just to inspect the html page source code. Notice the data-val-requirediftrue and data-val-requirediftrue-boolprop on line 59 :

These two new attributes hold the error message for this rule and the validation parameter. Now we will implement javascript code to make use of these attributes. We will add a new javascript file in the Scripts folder, file called ‘RequiredIfTrueValidation.js’. We will also inclued this file in the view :

@section scripts
{
    @Scripts.Render("~/bundles/jqueryval")
    @Scripts.Render("~/Scripts/RequiredIfTrueValidation.js")
}

… and the javascript file contents :

jQuery.validator.addMethod('requirediftrue', function (value, element, params) {
    var checkboxId = $(element).attr('data-val-requirediftrue-boolprop');
    var checkboxValue = $('#' + checkboxId).first().is(":checked");
    return !checkboxValue || value;
}, '');

jQuery.validator.unobtrusive.adapters.add('requirediftrue', {}, function (options) {
    options.rules['requirediftrue'] = true;
    options.messages['requirediftrue'] = options.message;
});

Javascript analysis

Let’s have a deeper look on the javascript file. In the first chunk of code there is the validation function and in the second chunk we wire up an ‘adaptor’ for the jQuery unobtrusive validation engine.

Line 8 adds the rule and sets its parameter to the ‘true’ value. This true value is useless in our case (it will be passed as the ‘params’ parameter value on line 1 later) but the line is required in order for the rule to be added to the rules collection.

Line 9 sets the error message for this rule (in case it’s going to be broken).

Line 2 gets the checkbox id from the validated textbox. Notice the attribute name that I was telling you earlier. This validating function (defined on line 1, inline) will be called by the validation engine with the validated textbox value as the ‘value’ parameter value, the textbox instance itself as the ‘element’ parameter value and the value from line 8 as the ‘params’ parameter value. Now, after we get the checkbox id, on line 2, we proceed on line 3 to get the checkbox element and read its checked state. The “first()” function call is necessary because jQuery will always return an array regardless if you use a (unique) id selector – which in fact can only result in one or zero element(s).

Finally on line 4 we return the validation result (true meaning ‘is valid’ and false otherwise). We decide this value either by the fact that the checkbox is not checked (“!checkboxValue”) or, the checkbox is checked and the ‘value’ – that is the text in the textbox – is not empty (empty string is evaluated as ‘false’ and non-empty, non-null string is evaluated as ‘true’ in javascript).

Let’s run the site and find out things run as they should. (no screenshot necessary for this, I can’t show how the server is NOT called 😉 – maybe a video but for now I feel lazy). You can place a breakpoint at the action level and see how the server is not called.

Finally let’s add a finishing touch, by toggling the display of the ‘custom slug’ field through the checkbox :

@model MVC4_jQuery_Unobtrusive_Custom_Validation.ViewModels.AddUrlViewModel

@section scripts
{
    @Scripts.Render("~/bundles/jqueryval")
    @Scripts.Render("~/Scripts/RequiredIfTrueValidation.js")

    
}

Add a new URL shortening
@using (Html.BeginForm())
{
    
        
            Original URL : 
            
                @Html.TextBoxFor(m => m.OriginalUrl)
                @Html.ValidationMessageFor(m => m.OriginalUrl)
            
        

        
            @Html.LabelFor(m => m.UseCustomSlug, "Use a custom slug")
            @Html.CheckBoxFor(m => m.UseCustomSlug)
        

        
            Custom slug : 
            
                @Html.TextBoxFor(m => m.CustomSlug)
                @Html.ValidationMessageFor(m => m.CustomSlug)
            
        
    
    
       
}

Let’s start with line 10. This tells jQuery to get the checkbox and attach an event handler for the click event. This handler (line 11) will toggle the visibility of the ‘customSlugRow’ table row (notice I’ve added an id to the tr element on line 33) based on the checked state of the checkbox. In jQuery the ‘this’ reference will point to the element that has the event handler, in this case the checkbox.

Finally on line 9 we set the initial visibility of the row based on the value of the checkbox. Don’t assume that this will always be ‘unchecked’. If the viewmodel comes with the UseCustomSlug set to true (initially not) then the ‘CustomSlug’ should not be hidden.

Summary

In this tutorial we’ve seen how to create custom javascript/jQuery unobtrusive client-side validation. We’ve created a validation attribute class inheriting from (System.ComponentModel.DataAnnotations.)ValidationAttribute and we’ve implemented the IClientValidatable interface in order to send validation metadata to the view. We’ve, then, created a validator adapter (a javascript function that sets up the rule validation function) and the rule validation function.

Have fun jQuerying but don’t forget to check out the Stackoverflow jQuery-tagged question and the jQuery Learning Center because you’ll surely end up needing that information! m.CustomSlug)

You can download the project code.

Bing it on, Reactive Extensions! – story, code and slides

Andrei Rinea — Sat, 01 Jun 2013 19:55:54 +0000

I held a presentation at UBISOFT Buchares headquarters for the RONUA local programmers user group recently as I’ve announced earlier.
Here’s the contents, step-by-step, final code and slides.

————- [scroll way down for the downloads]

I was recently tasked with rewriting an app component by leveraging Reactive Extensions. I knew little about Rx (the short form of Reactive Extensions) and all I remembered was that it has two interfaces IObservable and IObserver and it seemed dull at that time.

Basically the component enables search without needing to hit ENTER or a “Go!” button, although provides for these. After the user finishes typing an async request goes to the data store and searches for the phrase entered and fetches the results. In the original implementation the component used a lot of timers, event handlers, private fields all making up a nice spaghetti bowl of code.

Let’s do this step by step and see how our little (demo) app develops. Fire up Visual Studio 2012 and start a new WPF project (.NET 4.5 preferrably). The very next thing we’ll install Rx. Right click on the project in the Solution Explorer and select “Manage NuGet Packages” (you can also use the Package Manager Console if you like it better). Search online for “Reactive Extensions”.

In the result lists (this requires a functional internet connection) select ‘Reactive Extensions – WPF Helpers‘ (the nice thing about NuGet packages is that it automatically resolves and installs all the dependencies). Accept the license(s) (you know what’s the most common lie told these days? “I have read and accepted the terms of the license” :P).

In our demo we will use Bing as the data store which we’ll target through our searches (sorry, Google was too difficult to setup, offered less search requests per month and no C# demo code. Thanks Google, thanks again.). In order to do this you will need a Microsoft Account (I guess we all have one these days). Go to http://www.bing.com/developers/ and then select “Search API” -> Start now (this will lead you to https://datamarket.azure.com/dataset/5BA839F1-12CE-4CCE-BF57-A49D98D29A44 ). There are paid subscriptions and a free subscription. Hit signup and go through the process (leave a comment if you are unable to go through this process).

In the end you will need to obtain the (Primary) Account Key and the Customer ID. These are available under “My Account” -> Account Information ( https://datamarket.azure.com/account ). We’ll use these later so save them. Also, don’t share them with other people because these are your credentials. Also visit “My Data” ( https://datamarket.azure.com/account/datasets ) and click on “Bing Search API”‘s “Use” link (far right, https://datamarket.azure.com/dataset/explore/bing/search ). Capture the “URL for current expressed query” : “https://api.datamarket.azure.com/Bing/Search/v1/Web“. We’ll also need these later.

Finally just below the subscription list there is a “.NET C# Class library” link (https://datamarket.azure.com/dataset/explore/getproxy/5ba839f1-12ce-4cce-bf57-a49d98d29a44) which will get you a “BingSearchContainer.cs” file. Download this file into the project’s folder and include it in your project. At this point the project will not compile as it is missing a reference to System.Data.Services.Client. Add this reference and compile the project.

Now let’s build the UI. I must say that for the sake of the demo we will not implement this little app by abiding to all good practices and patterns, such as MVVM. If you do end up implementing this for production purposes please take care to abide to all good practices. Getting back to our development, let’s open MainWindow.xaml and prepare a simple layout with a thin row above, on which we’ll place a textbox, two buttons and a “busy indicator”. On the second row (the most of the app space, we’ll place a listbox with results :

The Grid “GrdBusy” is set to Hidden and not “Collapsed” in order to avoid having the buttons shift left-right. It also requires a width in order to be drawn on the screen.
The weird d:DataContext is an attached property that lets the IDE (ReSharper uses this) know what kind of objects will be fed into the “LstResults” listbox.

Now let’s go in the code behind (this sounds anti-pattern but remember it’s just a quick demo – otherwise we would have had a ViewModel and so on) and declare two private constants with the account key and customer id (we’ll need these to do the actual search).

Let’s also build a small method that takes in a string and returns an IEnumerable (WebResult is a class in the Bing namespace), let’s call it SearchBing. At this point the MainWindow class should look like :


using System;
using System.Collections.Generic;
using System.Linq;

using Bing;

namespace BingItOn
{
    public partial class MainWindow
    {
        private const string AccountKey = @"";
        private const string CustomerId = @"";

        public MainWindow()
        {
            InitializeComponent();
        }

        private IEnumerable SearchBing(string searchPhrase)
        {
            var uri = new Uri(@"https://api.datamarket.azure.com/Bing/Search/v1/Web");
            var container = new BingSearchContainer(uri);
            container.Credentials = new NetworkCredential(CustomerId, AccountKey);
            var query = container.Web(searchPhrase, null, null, null, null, null, null, null);
            return query.Take(10).ToArray();
        }

        private void OnUrlNavigate(object sender, RequestNavigateEventArgs e)
        {
            Process.Start(e.Uri.ToString());
        }
    }
}

Step 1 – let’s have the app search async and display results as we type.

Let’s create a “SetupSubscriptions” void instance method that we’ll call from the constructor after InitializeComponent(); In this method we’ll create a new ‘Observable’. That is an instance of a class that implements IObservable. This thin interface has one method : Subscribe. This enables us to subscribe with a method which will be called back (callback) whenever the sequence, because a sequence of data is what an IObservable models, produces a new item. In case of an event observable the item will be an encapsulation of the event sender and the event arguments (‘object sender, EventArgs e’ rings any bells?). We’ll select the new text and then we’ll subscribe to this observable like so :


public MainWindow()
{
    InitializeComponent();
    SetupSubscriptions();
}

private void SetupSubscriptions()
{
    var textChangedObservable = Observable.FromEventPattern(TxtSearch, "TextChanged");
    var textObservable = from evt in textChangedObservable select ((TextBox)evt.Sender).Text;
    textObservable.Subscribe(OnTextChanged);
}

private void OnTextChanged(string text)
{
    var data = SearchBing(text);
    LstResults.Items.Clear();
    foreach (var result in data)
    {
        LstResults.Items.Add(result);
    }
}

Run the app (if you have aggresive firewall software you’ll be prompted to accept this little app’s request to connect externally) and notice how things happen synchronously, sluggishly. Type a character, wait for the bing results, type another character and so on. This is not so nice. Let’s make it async.

We do this by creating an observable of async web results and we’ll combine the text observable (with a ‘inner join’) with this new observable. We’ll also change the OnTextChanged method to OnResultsArrived and its contents. Sounds complicated but it’s not really. Let’s see how :


private void SetupSubscriptions()
{
    var textChangedObservable = Observable.FromEventPattern(TxtSearch, "TextChanged");
    var textObservable = from evt in textChangedObservable select ((TextBox)evt.Sender).Text;
    var searchBingFunc = new Func>(SearchBing);
    var searchBingObservable = Observable.FromAsyncPattern>(
        searchBingFunc.BeginInvoke, searchBingFunc.EndInvoke);
    var combinedObservable = from text in textObservable
                             from result in searchBingObservable(text)
                             select result;
    combinedObservable.Subscribe(OnResultsArrived);
}

private void OnResultsArrived(IEnumerable results)
{
    LstResults.Items.Clear();
    foreach (var result in results)
    {
        LstResults.Items.Add(result);
    }
}

Upon the first run we get hit with an InvalidOperationException at the first line of code of the OnResultsArrived because we’re not on the UI thread but on a worker thread. Resist the urge to Dispatcher.Invoke (or BeginInvoke) into this. We’ll change the Subscription code from combinedObservable.Subscribe(OnResultsArrived) to combinedObservable.ObserveOn(this).Subscribe(OnResultsArrived).

Run the app again. Now things work a bit better but still sluggish (the results presentation is the culprit) and more than this, a search request is made for each keystroke (or at least any command that changes the text). We can easily prevent this with a little… Reactive Extension! Called Throttle.

step 2 – let’s start the search only if the user stopped typing

We’ll apply Throttle on the textObservable in the combinedObservable definition in SetupSubscriptions like so :


var combinedObservable = from text in textObservable.Throttle(TimeSpan.FromSeconds(0.5))
                         from result in searchBingObservable(text)
                         select result;

Running the app again shows much better performance and less requests to the server(s). What Throttle essentially does is waiting for the sequence to calm down and if after 0.5 seconds no more changes have been made, it stops filtering and allows the item to pass out of the sequence. Neat, ha?

We have one more nice extension that we can chain after Throttle and that’s DistinctUntilChanged. This allows to pass only distinct results. So if we type “test” in the textbox and then quickly (in less than those 500 milliseconds) type another “t” and then quicly delete it there won’t be requests made for “testt” and then another one for “test” again.


var combinedObservable = from text in textObservable
                                          .Throttle(TimeSpan.FromSeconds(0.5))
                                          .DistinctUntilChanged()
                         from result in searchBingObservable(text)
                         select result;

step 3 – let’s drop an ongoing search if in the meantime we need to start another one

Now we’re finally seeing the beauty of reactive extensions! By simply combining observable (either chaining them or joining them) and/or applying filters and modifiers we’re obtaining a lot of functionality with little code.
It’s more elegant, easier to understand (after the learning curve albeit), easier to test and less prone to bugs since the functionality is outsourced to the Rx libs which are carefully written by the guys at Microsoft and thoroughly tested.

The searchBingObservable(text) in the combined observable definition is a single-value observable that ‘spits’ out a single result at most once in its life, that is an “instance” of IEnumerable. (I used the quotes because a closer to the truth expression would have been an “instance of a class that implements IEnumerable, array of WebResult to be more precise”).

The .TakeUntil(anotherSequence) extension method found in Rx filters a sequence in a way that it lets pass everything until its parameter (‘anotherSequence’) produces an item. This way we’d be ignoring the results when they’d came (effectively cancelling the request on the server(s) is not possible in a HTTP(S) system). We’ll just add TakeUntil in the mix like so :

private void SetupSubscriptions()
{
    var textChangedObservable = Observable.FromEventPattern(TxtSearch, "TextChanged");
    var textObservable = from evt in textChangedObservable select ((TextBox)evt.Sender).Text;
    var searchBingFunc = new Func>(SearchBing);
    var searchBingObservable = Observable.FromAsyncPattern>(
        searchBingFunc.BeginInvoke, searchBingFunc.EndInvoke);
    var tamedTextObservable = textObservable.Throttle(TimeSpan.FromSeconds(0.5)).DistinctUntilChanged();
    var combinedObservable = from text in tamedTextObservable
                                from result in searchBingObservable(text).TakeUntil(tamedTextObservable)
                                select result;
    combinedObservable.ObserveOn(this).Subscribe(OnResultsArrived);
}

Everything’s fine until someone trips over the wireless cable (kidding, the net goes down whatsoever). In that case the exception will take down the whole app although it shouldn’t.

step 4 – Exception handling

When a sequence (observable) encounters an error it calls OnError on its subscriber(s) and then it terminates, i.e. it won’t produce anything anymore. It’s faulted. Therefore in such a case we’ll choose to present the error and redo the subscriptions :

   //... 
   combinedObservable.ObserveOn(this).Subscribe(OnResultsArrived, OnError);
}

private void OnError(Exception obj)
{
    MessageBox.Show("An error has occured." + Environment.NewLine + Environment.NewLine + obj);
    SetupSubscriptions();
}

step 5- let’s implement the busy indicator

We’ll just define a helper method that toggles the busy indicator state and call it from SearchBing, OnResultsArrived and OnError methods (at their start) accordingly (true for SearchBing and false for the others) :

private void SetBusyIndicatorState(bool state)
{
    Dispatcher.BeginInvoke(new Action(() => { GrdBusy.Visibility = state ? Visibility.Visible : Visibility.Hidden; }));
}

Let’s run. It works, not a state-of-the-art like an animated spinner or something but that would be beside the point of this demo anyway.

step 6 – let’s implement the Go! button (the force search button)

We’ll start by observing the button click event and then merging this observable with the tamed text input. We’ll also increase significantly the throttle timespan in order to … observe (pun intended) the effect of hitting ENTER (or mouse-clicking the button) :

//...
var tamedTextObservable = textObservable.Throttle(TimeSpan.FromSeconds(3.5)).DistinctUntilChanged();
var forceSearchButtonObservable = from text in Observable.FromEventPattern(BtnForceSearch, "Click") select TxtSearch.Text;
var combinedObservable = from text in tamedTextObservable.Merge(forceSearchButtonObservable)
                            from result in searchBingObservable(text).TakeUntil(tamedTextObservable)
                            select result;
//...

Running the application, typing ‘test’ (for example) and quickly hitting ENTER we’ll see that the search commences instantly (or almost). However we’ll also observe that after we get the results another query is issued for the same text and, of course, has the same results.

The essence of the issue is that the expression “tamedTextObservable.Merge(forceSearchButtonObservable)” will produce an item (search text) at the ENTER keypress and another one later from the tamed observable. The quick fix is to add an “DistinctUntilChanged” at its end. This fixes it until…

The boss comes requesting that hitting ENTER even after the results have been loaded for the current expression will redo the search, just like a Refresh (F5) would do in a browser. Now we’re stuck we need to remove the “DistinctUntilChanged” but we’d then be back to the double search issue that we had later. It may seem we can’t outsmart this.

But after a few hours of headbanging it hit me : we’ll switch from string (the type produced by the sequences and accepted by the search method) to a custom type that we’ll call SearchRequest :

public class SearchRequest
{
    public string Text { get; set; }
    public bool Force { get; set; }
}

Instead of just producing the TxtSearch’s .Text value we’ll be producing instances of this SearchRequest class filling the TextBox’s Text property value in the Text property and setting Force to true only if produced by the force button click. We’ll also use this opportunity to treat the case when the textbox becomes empty.


private void SetupSubscriptions()
{
    var textChangedObservable = Observable.FromEventPattern(TxtSearch, "TextChanged");
    var textObservable = from evt in textChangedObservable select new SearchRequest { Text = TxtSearch.Text };
    var searchBingFunc = new Func>(SearchBing);
    var searchBingObservable = Observable.FromAsyncPattern>(
        searchBingFunc.BeginInvoke, searchBingFunc.EndInvoke);
    var tamedTextObservable = textObservable.Throttle(TimeSpan.FromSeconds(3.5)).DistinctUntilChanged();
    var forceSearchButtonObservable = from text in Observable.FromEventPattern(BtnForceSearch, "Click")
                                        select new SearchRequest { Text = TxtSearch.Text, Force = true };
    var combinedObservable = from request in tamedTextObservable.Merge(forceSearchButtonObservable).DistinctUntilChanged()
                                from result in searchBingObservable(request).TakeUntil(tamedTextObservable)
                                select result;
    combinedObservable.ObserveOn(this).Subscribe(OnResultsArrived, OnError);
}

//...

private IEnumerable SearchBing(SearchRequest searchRequest)
{
    if (string.IsNullOrWhiteSpace(searchRequest.Text)) return Enumerable.Empty();
    SetBusyIndicatorState(true);
    var container = new BingSearchContainer(new Uri(Url))
    {
        Credentials = new NetworkCredential(CustomerId, AccountKey)
    };
    var query = container.Web(searchRequest.Text, null, null, null, null, null, null, null);
    return query.Take(10).ToArray();
}

We’ll run the app and see that not much has changed. That’s because now the DistinctUntilChanged at the end of tamedTextObservable definition is using the Equals of the SearchRequest class and the default implementation of a class is to compare the reference values and not the semantic value. We’ll also override GetHashCode since this is a good practice that can defend us from weird bugs. Let’s implement this cleverly placing priority for the case when the request is forced :

internal class SearchRequest
{
    public string Text { get; set; }
    public bool Force { get; set; }

    public override bool Equals(object obj)
    {
        var older = this;
        var newer = (SearchRequest)obj;
        if (newer == null || newer.Text != older.Text) return false;
        return !newer.Force;
    }

    public override int GetHashCode()
    {
        return (Text ?? string.Empty).GetHashCode() ^ Force.GetHashCode();
    }
}

This reminds of a strange case when ‘this’ can be null in an instance context but I won’t treat it in the Equals overriding. Run the app. Problem fixed! This feels good.

step 7 – let’s implement the stop button

This will need to do several things : clear the textbox, clear the results and stop any ongoing search if any. Although there probably are many ways to implement this at this stage of development I will choose, what I think to be, a simple one : I will handle the click event and clear the textbox and, separately, I will observe the click event and use it (indirectly) in the TakeUntil of the async observable to stop an ongoing search. I will also use this opportunity to set the throttle time at a more decent value, such as 0.7 seconds.

private void SetupSubscriptions()
{
    var textChangedObservable = Observable.FromEventPattern(TxtSearch, "TextChanged");
    var textObservable = from evt in textChangedObservable select new SearchRequest { Text = TxtSearch.Text };
    var searchBingFunc = new Func>(SearchBing);
    var searchBingObservable = Observable.FromAsyncPattern>(
        searchBingFunc.BeginInvoke, searchBingFunc.EndInvoke);
    var tamedTextObservable = textObservable.Throttle(TimeSpan.FromSeconds(0.7)).DistinctUntilChanged();
    var forceSearchButtonObservable = from click in Observable.FromEventPattern(BtnForceSearch, "Click")
                                        select new SearchRequest { Text = TxtSearch.Text, Force = true };
    var stopButtonObservable = from click in Observable.FromEventPattern(BtnStopSearch, "Click")
                                select new SearchRequest { Text = string.Empty };
    var anyInputObservable = tamedTextObservable.Merge(forceSearchButtonObservable).Merge(stopButtonObservable);
    var combinedObservable = from request in anyInputObservable.DistinctUntilChanged()
                                from result in searchBingObservable(request).TakeUntil(anyInputObservable)
                                select result;
    combinedObservable.ObserveOn(this).Subscribe(OnResultsArrived, OnError);
}

//...

private void OnStopRequest(object sender, RoutedEventArgs e)
{
    TxtSearch.Clear();
}

This app can be refined much more and finally ditched for a good ol’ browser :))) but for now let’s call it a wrap!

Here’s the final code (VS 2012 / .NET 4.5 solution)
BingItOn solution

and the slides from the presentation:
Bing it on Reactive Extensions

Want to learn more? Try the best resource for Rx that I’ve used to develop this tiny intro : http://introtorx.com

Bing it on, Reactive Extensions!

Andrei Rinea — Fri, 10 May 2013 09:18:50 +0000

Next Tuesday (May 14th, 2013) I will be presenting a small demo of how Reactive Extensions can help you out in a desktop application.

I’ll develop a small WPF app that will do internet searching via Bing.

Anyone in Bucharest is free to drop by and watch my demo or my colleague’s demo (Alexandru Gatej will be presenting “Aspects of plan caching and recompilation in Microsoft SQL Server”).

Location and time :

Beginning at 18:30 (Alexandru’s presentation will go first) at UBISOFT Romania ( <- click for map ), 2 Expozitiei Boulevard, district 1, Bucharest. Hope to see many people!

Windows Phone 8 – Samsung ATIV S

Andrei Rinea — Wed, 17 Apr 2013 15:12:59 +0000

After two and a half year of struggling with the crappy Android OS on Samsung Galaxy S I’ve finally decided that ‘enough is enough’.

I’ve wanted a small tablet so I can read (blogs and so on) easily so I was a bit into Samsung Galaxy Note II. Along with the fact that this too is an Android phone (OS which corrupts its own system files and lost my whole user data, lags horribly and so on) several fellow colleagues from RONUA (a local programming user group) warned me against as they already are owners.

One told me that approximately 50% of the phone calls he can’t hear the other party nor he can be heard and the other one told me he is experiencing approximately a complete OS freeze once per day. He is only able to restart the device by removing the battery and reinstering it.

I then looked for another-OS, large-display and low-SAR phone in the market. iOS ‘simply works’, I can’t deny but there was no large screen phone available, no low-SAR phone and nonetheless objective-C sucks incredibly bad.
Ironically I found another Samsung, the ATIV S.

Image source : Engadget

Windows development is my main job plus I’ve heard that the apps ecosystem in the Windows Phone marketplace is quite poor. Therefore I thought to myself : ‘maybe I could also write an app for it too!’. Having already tried development on Android and being quite ~~outraged~~ surprised by its quirks.

I bit the bullet and bought the ATIV S from eMAG (a local retailer).

The first thing that surprised me was the curiosity of the shipping consultant (the guy that brings the product’s box, unboxes it and tests it in front of you). He was quite curious and said he’s never seen a Windows phone before.

Nice display, nice case and so on. Tried to insert the SIM card at home from the old phone but, to my shame, I did not pay attention to the fact that I needed a microSIM not a ‘standard’ SIM. So I had to wait till the next day to get to Vodacrap (Vodafone) to get it replaced.

I also found out that the contacts that Android told me that were saved on the Google Account were not. In fact I could not even access them via web. I simply had to manually move once again contacts. Thanks again Google, thank you to Linux (Android, whatever, same shthing).

The phone boots fast (20-30 sec compared to 2min30..3min of Galaxy S) and whatever you do it will not lag AT ALL no matter what. Combine with the fast and fluid animations this does indeed make up a very nice user experience.
The real nice thing is, however, the battery. A 2300 mAH battery combined with the battery saver mode will allow me to talk, text, browse websites, check in on FourSquare, etc etc and recharge it every three … three and a half days.

So far I didn’t had to use a kind of app and not find something in the marketplace. There are even Google Maps. Sure, Instagram is a missing thing for some but not for me. And even for that there is something in development as far as I’ve heard.

In another case, having a pretty quiet week and on average one phonecall per day I managed to go well beyond 5 days between recharges. I haven’t seen another smartphone reach these levels. Well at least not without Mugen Power batteries.

‘Bling’ features include NFC (who has / will use this anyway?), Bluetooth 3.0 and a microSD card slot (had one on the Galaxy S but never had the need to use it..).

The only things that I would consider lacking but by no means a ‘deal-breaker’ would be :

A larger than 5 inch screen
Easy to find leather cases (I found only one but not in the same city, I had to have it shipped)
4G / LTE connectivity

The camera is just as good as a phone camera can be, IMHO and at least it does have a LED ‘flash’ unlike Galaxy S. Not as good as Lumia 920’s of course but good enough to take some easy photos in the sunshine..

Now I will give Windows Phone 8 development a chance and see how this goes..

Windows Explorer contextual menu gotcha

Andrei Rinea — Fri, 08 Mar 2013 11:22:21 +0000

Recently I had to extract the public key from a signed .NET assembly and I needed to run the sn.exe tool in order to obtain it. That required opening a command prompt and then setting the current directory to the one in which the assembly resided.

Typically I did :

Win+R (Run)
cmd
Enter
F: [ENTER] (or whatever the drive was)
CD and either type the directory (using the TAB autocomplete or not) or copy the folder path and pasting it into the command prompt [ENTER]

Then I thought how can I simplify this little tedious task, which I sometimes do many times a day. After looking for Microsoft PowerToys which is no longer available I found out a little gem hidden in Windows Explorer. This is what my contextual menu looks like normally :

But just pressing (and keeping pressed) SHIFT before the right-click will give you this :

Selecting this command will do the opening of the command prompt and setting the drive and path in one click.

Of course, the next thing is to add the path to SN.EXE in the Environment Variable PATH in order to be able to execute it “anywhere”.

I hope this helps at least some of us

Some more Android development peculiarities

Andrei Rinea — Tue, 29 Jan 2013 23:22:18 +0000

There is a baked in logging class called, intuitively, Log. For some strange reason the authors chose to name its methods, most of them, with one letter. That is :

Log.d(..); // debug level
Log.e(..); // error level
...

Until you hit

...
Log.wtf(..);
...

This one’s funny and I appreciate their sense of humor as it goes up to renaming WTF to “What a Terrible Failure”. Like we’re so dumb that we can’t figure what they really had in mind

Another peculiarity is that in an activity (this akin to a Page / Form / whatever) you have some methods that you can/should override such as onCreate(). Everywhere is stated that the first thing you should write in the overriding method is a call to the super (that is base) class’s method. If it is really all that important and vital why didn’t the class designers go with a template method in first place?

That is a design pattern, that in this case, would go like so :

public class Activity {

    // ...

    private void onCreateInternal(Bundle savedInstanceState) {
        //vital stuff
        onCreate(savedInstanceState);
    }

    protected void onCreate(Bundle savedInstanceState) {
    }

    // ...

}

Take note of another difference between C# and Java : the methods and classes are virtual/unsealed by default. So the onCreate method in my example above is overrideable in any subclass. Also in Java terminology the base class is called the superclass.

Other differences of terminology include :

A namespace is called a package
By default an import (which is akin to a using directive) imports by default just the specified type and not the whole package (namespace). You need to use a wildcard to import the whole package
The closest thing to an assembly is called a JAR (Java ARchive).
Eclipse by default is set to autocompile. That is whenever you hit CTRL-S (Save) to a Java file the project is (re)compiled. This sounds terrible but it isn’t! You can’t even notice. Either there is an incremental compilation either the performance of the compiler is incredible.
Unlike Visual Studio, Eclipse presents the import block collapsed by default. I wish I had this in VS… Just like a mobile app fan would say “there’s an app for that”, I bet for VS “there’s a plugin for that”
In Java if you want to call the super (base) class’s constructor from the current class’s constructor you will write “super(…);” in the constructor’s body. When I first saw this I said to myself Fu-Kin-Su-Pa (er… “great”, that is). “Now I have the liberty to call the base/super constructor from wherever inside the constructor I want”. Well, no. It’s either the first line or it isn’t.

Well, I’ll rant more as I go learning Android development.

My goal is to get to know enough so I can do it in Xamarin via C# but first I must understand the underlying things in order to go a level of abstraction above.

In the next episode(s) : I am indebted with a follow-up from my presentation held at RONUA last year.

Java / C# differences part 1 of n

Andrei Rinea — Tue, 29 Jan 2013 17:56:11 +0000

Recently I’ve been toying around with Android development (since I own an Android “smart” phone for over 2 years now) and mobile development is all the rage now. Moreover, I’ve been trying to do new things lately since even the pragmatic programmer guide advises us to learn a new language each year (kind of aggressive if you ask me).

Anyway I will try to show what a C# developer (almost 8 years now) discovers by doing Java development on Eclipse for Android.

For today :

leaving a member of a class without an access modifier defaults to internal instead of private :

// C#
void Test() // private method
{
}

// Java
void test() { // internal method
}

Overriding a method does not require any kind of keyword or special ceremony. You can use the @Override annotation but this is optional. You can get burned this way easily.

// C#
public override bool Equals(object other)
{
    return _id == other._id;
}

// Java; WRONG! DO NOT USE
public bool equals(Person other) {
    return this.id == other.id;
}

//Correct
public bool equals(Object other) {
    return this.id == other.id;
}

Overriding requires that you use the same method signature (that is, the same return type, the same parameter types and order). If you accidentally mistake the signature (Person instead of Object) you will overload instead of overriding with unknown effects.

In other “news”, Android development has a lot of similarities with WPF :

You have activities (similar to pages in Silverlight/WPF).
These are XML-defined.
There are a few base-layout controls (viewobjects) like LinearLayout (StackPanel), GridLayout and so on.
You must not access UI elements from other threads than the main / UI thread.
The layout viewobjects have similar properties to the layout controls in WPF/Silverlight : width/height which can be specified absolutely or relatively and so on.

The lack of properties baked in the language is annoying regardless of the features of Eclipse (generate getters and setters). The auto-complete feature is far from Visual Studio and there is no “ReSharper” to easily import missing types. Yes there is F2 but still..

The lack of delegates makes multithreading a pain (you know where this pain is located) and so is the wiring of the handlers for clicking buttons and all.

Oh well, I’ll carry on and be back with new opinions as I go.

Efficiently serving binary content from SQL Server in ASP.NET MVC – local user group talk

Andrei Rinea — Wed, 07 Nov 2012 10:22:51 +0000

This will be a local user group talk that I’ll be having, in Bucharest on Tuesday 13th of November.

Storing large binary objects (usually image files) in the RDBMS has been a blessing but for some is unconceivable. We will explore different ways to do this, from worse to best and we will take advantage of a new feature introduced by SQL Server 2012.

The location is TeamNet Int’l HQ – Sema Parc, Splaiul Independenţei nr. 319, clădirea RiverView, etaj 8
Except an ID there is nothing else that you need to bring in order to participate to the event.
Further geographical details.

The most popular way to get there is by taking the subway as there is a station right near the building.

The official announcement can be found on RONUA’s site.

See you there!

——–

Later edit : It’s been great! Not too many people but keen to learn new stuff. Here’s two pictures from the talk. Notice a new generation of programmers forming

Type check and inheritance – and a nice ReSharper tip

Andrei Rinea — Thu, 25 Oct 2012 10:55:43 +0000

Let’s suppose you have three classes in a simple hierarchy :

public class A
{
}

public class B : A
{
}

public class C : A
{
}

Now suppose you receive an instance of one of these classes (you don’t know the exact type to which this instance belongs). How can you determine programatically if the instance is of a type inheriting from A or it is of type A exactly?

Normally I would do the following :

var instance = ObtainInstanceFromSomeWhere(); // this method will not return null
var instanceIsExactlyOfTypeA = typeof(A) == instance.GetType();
var instanceIsOfTypeAOrAnInheritingType = typeof(A).IsAssignableFrom(instance.GetType());

All these work and are nice and dandy. However ReSharper showed me a nicer alternative to the last statement :

var instanceIsOfTypeAOrAnInheritingType = typeof(A).IsInstanceOfType(instance);

Now, pro’lly, many of you knew about this method but I didn’t!
Hopefully it will help someone..

CallerMemberName – an easier way to do INotifyPropertyChanged AND MORE

Andrei Rinea — Fri, 24 Aug 2012 09:56:29 +0000

In WPF, when applying the MVVM (an arhitectural pattern) we often need to implement the INotifyPropertyChanged on certain classes (ViewModel classes), which means something like this :


public class PersonViewModel : INotifyPropertyChanged
{
    private string _name;
    public string Name
    {
        get { return _name; }
        set
        {
            if (_name == value) return;
            _name = value;
            NotifyPropertyChanged("Name");
        }
    }

    private void NotifyPropertyChanged(string propertyName)
    {
        var evt = PropertyChanged;
        if (evt != null) evt(this, new PropertyChangedEventArgs(propertyName));
    }

    public event PropertyChangedEventHandler PropertyChanged;
}

In case you’re wondering why I copied the PropertyChanged value to the local variable called “evt” and then tested it for null is that you can have race conditions, in general, triggering events (i.e.: you test the attribute value, it is not null and before you trigger it some other thread sets it to null and bang, NullReferenceException when you trigger it). More details on this CodeProject.

The next step is to pull the NotifyPropertyChanged method and PropertyChanged event into a base class (let’s call it ViewModelBase) and you’ve eliminated redundancy between several ViewModel classes.

The not-so-nice part is having the call to NotifyPropertyChanged stringly-typed. That means that if later you rename (via Visual Studio or ReSharper) the Name property to “FullName” the call will still pass “Name” as the argument.

Some blog posts around the web show how you can use a Func to make it type-safe (refactor safe etc).

More or less they’re doing the same thing :


public abstract class ViewModelBase : INotifyPropertyChanged
{
    public event PropertyChangedEventHandler PropertyChanged;

    protected void NotifyPropertyChanged(Expression propertyAccessor)
    {
        var evt = PropertyChanged;
        if (evt == null) return;
        var propertyName = propertyAccessor.GetName();
        evt(this, new PropertyChangedEventArgs(propertyName));        
    }
}

public static class Utils
{
    public static string GetName(this LambdaExpression expression)
    {
        MemberExpression memberExpression;
        if (expression.Body is UnaryExpression)
        {
            var unaryExpression = (UnaryExpression)expression.Body;
            memberExpression = (MemberExpression)unaryExpression.Operand;
        }
        else if (expression.Body is MemberExpression)
        {
            memberExpression = (MemberExpression)expression.Body;
        }
        else
        {
            return null;
        }
        return memberExpression.Member.Name;
    }
}

This is definitely nicer, not-redundant and type-safe. It does have the drawback of having some runtime performance penalty associated with the reflection of the expression. You could cache the property name string in a private field but then you’d have to write more code in the ViewModel classes which would… suck. In practice this performance penalty is negligible so you can just ignore this.

Then came .NET 4.5 and among other improvements a new mechanism has been introduced : CallerMemberName.

Historically some folks tried to get programatically the name of the caller method by inspecting the StackTrace (for example using System.Environment.StackTrace) but this is prone to errors since in Release mode the compiler could eliminate some methods by inlining them and you’ll be screwed. Plus the penalty would be higher than reflecting an expression.

The new mechanism in .NET 4.5 is type-safe, has no runtime performance penalty and it’s more elegant. Here’s how you can use it :

public abstract class ViewModelBase : INotifyPropertyChanged
{
    protected void NotifyPropertyChanged([CallerMemberName] string propertyName = null)
    {
        var deleg = PropertyChanged;
        if (deleg != null)
        {
            deleg(this, new PropertyChangedEventArgs(propertyName));
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;
}

public class PersonViewModel : ViewModelBase
{
    private string _name;
    public string Name
    {
        get { return _name; }
        set
        {
            if (_name == value) return;
            _name = value;
            NotifyPropertyChanged();
        }
    }
}

I’ve recently built a very small GuidGen utility (which as the name implies generates GUIDs, copies it in the Windows Clipboard and stores a history of past generated GUIDs). You can browse some of the code and check out the project.

Much nicer, isn’t it?

Funny thing, this new mechanism can be used for non-UI tasks. For example if you have a project that uses and RDBMS and you use stored procedures. Let’s say you have one method in a repository class for each stored procedure, and even more, the method’s name matches the stored procedure’s name :


public VerificationResult VerifyUser(VerificationData verificationData)
{
    if (EmailValidator.IsEmailInvalid(verificationData.EmailAddress)) throw new FormatException("emailAddress");

    var result = CreateNewCommand("VerifyUser").GetEnumResult(
        CreateEmailAddressParameter(verificationData.EmailAddress),
        CreateUniqueIdentifierParam("@VerificationCode", verificationData.VerificationCode));

    return new VerificationResult(result);
}

Observe on line 5 how the call to CreateNewCommand passes a string which matches the current method’s name. This can also be simplified (and become refactor-safe) using the new CallerMemberName mechanism.

So you can’t really say that CallerMemberName is useful only for UI tasks 🙂

OUTPUT clause in UPDATE statements

Andrei Rinea — Sun, 19 Aug 2012 00:14:07 +0000

Sometimes you need to update data in a table and then update data in another table but based on a filter condition found from the first table. Specifically have you had to do this in the past?


-- ...

UPDATE Users
SET    Verified     = 1
FROM   Logins
WHERE  EmailAddress = @EmailAddress

DECLARE @UserId INT;

SELECT TOP 1
       @UserId = UserId
FROM   Logins
WHERE  EmailAddress = @EmailAddress

UPDATE  Users
SET     State = 2 -- Verified
WHERE   Id = @UserId

-- ...

This is not only inefficient (from an execution plan perspective) but also prone to race conditions and requires more code. The simpler and safer alternative is to use the OUTPUT clause of the UPDATE.

Here’s how :

DECLARE @UserIdTable TABLE ( Id INT );

UPDATE Users
SET    Verified     = 1
OUTPUT UserId
INTO   @UserIdTable
FROM   Logins
WHERE  EmailAddress = @EmailAddress

DECLARE @UserId INT = SELECT TOP 1 Id FROM @UserIdTable;

UPDATE  Users
SET     State = 2 -- Verified
WHERE   Id = @UserId

In the above code sample I take advantage of the new declare and initialize syntax introduced in SQL Server 2008. The OUTPUT clause has been introduced in SQL Server 2005 so nothing here is really news.

Another simplification that I hoped it was possible was to avoid the declaration of the local table variable and just push the OUTPUT into the local variable (@UserId) but it seems you can’t.

I found out about the OUTPUT clause recently from Remus Rusanu’s blog post about implementing queues with tables. These have, usually, high concurrency and any race condition that might occur will occur. OUTPUT is usually the best way to solve it.

Prefix cast or as-cast?

Andrei Rinea — Tue, 14 Aug 2012 09:09:49 +0000

I read today a nice article, from Kathleen Dollard, called To “as” or not to “as”. This is a pain-point for me on which I stumble often, so I decided to write this little rant.

I particularly liked a paragraph from the above-cited article :

One of the things that makes hard bugs hard is when there is a disconnect in time or space between the cause and the symptom. Time is time, space is lines of code, assembly placement, etc. Code can be written to minimize these disconnects. One of the ways to do that is to fail quickly. When application state becomes incorrect, yell about it immediately and rarely continue with the application in an invalid state. A null-reference exception at an unexpected time just makes code more difficult to debug.

I couldn’t express this as good as Kathleen did. Make no mistake I am quite biased in this comparison (direct-cast vs. as-cast). I kind of hate the abuse of the as operator.

Very often people turn to as instead of the direct (prefix) cast because:

They fear the InvalidCastException (strange, they don’t seem to fear the NullReferenceException)
They feel the syntax more fluent, closer to the human language.

I would consider the only valid case to use the as-cast is, just like Kathleen states, when a null value result is valid for the rest of the execution of the code. For the rest of the cases it’s just wrong.

This also promotes (doesn’t necessarily causes but promotes) bad practices like this :


public static void OnButtonClick(object sender, EventArgs e)
{
    var button = sender as Button;
    if (button == null)
    {
        return;
    }
    if (button.Tag == "somevalue")
    {
        // do something
    }
    // ...
}

In this example the event handler (which could be attached to more than one distinct button) simply forces under the rug a situation which would be abnormal (the sender not being a button) instead of releasing it so the developers could find it easier and debug it. A saner approach is :


public static void OnButtonClick(object sender, EventArgs e)
{
    var button = (Button)sender;
    if (button.Tag == "somevalue")
    {
        // do something
    }
    // ...
}

This brings me to another advantage of the prefix-cast : it produces shorter, clearer code.

In other cases the as abuse does more harm, hiding the source of a bug :


public void ProcessData(Entity entity)
{
    var person = entity as Person;
    UpdatePersonStatistics(person);
    // .. more code
}

public void UpdatePersonStatistics(Person person)
{
    NormalizeData(person);
    // .. more code
}

public void NormalizeData(Person person)
{
    person.Name = person.Name.Substring(0, 50);
    person.Address = person.Address.Substring(0, 100);
    // .. more code
}

Of course this is a contrived example full of bad practices but for now let’s focus on the as usage. Suppose the ProcessData method receives an instance of Category by mistake. Since Category inherits Entity the compiler will not complain.

The result is that there will be a NullReferenceException two methods further, in the NormalizeData method. If the cast was done with a prefix cast the error was a little bit easier to spot. This is confusing two-fold :

The name of the exception suggests that a null reference was somehow obtained but in fact a real instance of Category was passed, not a null
The error does not originate from the NormalizeData code but from the caller of the ProcessData

Summary

Use as only if a null result of the conversion makes sense for the flow of the execution. Otherwise use prefix cast.

ReSharper hidden features – Generate Delegating Members

Andrei Rinea — Mon, 30 Jul 2012 15:59:36 +0000

A frequently-used design pattern is the Decorator. This is also known as a mixin (or they might not be the very same thing but certainly they are related).

Typically you might need to create a class that implements a certain interface and uses another class that implements that exact interface but you need to provide some additional feature(s). An example would be a class that adds transactional behavior to an existing data-access class (a naive example) :


public interface IDataAccess
{
    void AddCustomerInvoice(Invoice invoice, User user);
}

public class DataAccess : IDataAccess
{
    public void AddCustomerInvoice(Invoice invoice, User user)
    {
        InsertInvoice(invoice, user);
        UpdateCustomerDebt(user, invoice.Total);
    }

    // ... the rest of the implementation
}

public class TransactionalDataAccess : IDataAccess
{
    private readonly IDataAccess _dataAccess;

    public TransactionalDataAccess(IDataAccess dataAccess)
    {
        if (dataAccess == null)
        {
            throw new ArgumentNullException();
        }
        _dataAccess = dataAccess;
    }

    public void AddCustomerInvoice(Invoice invoice, User user)
    {
         using(var tx = new TransactionScope())
         {
             _dataAccess.AddCustomerInvoice(invoice, user);
             tx.Complete();
         }
    }

    // ... the rest of the implementation
}

Another type of example would be the Adapter design pattern. An example would be providing access to a (static) class (that may be out of your control) in a mock-able manner. That is, implement another class, non-static, which implements a defined interface and eases unit-testing :


public class StorageManager
{
    public void StoreData(string key, byte[] data)
    {
         if (string.IsNullOrWhiteSpace(key))
         {
              throw new ArgumentNullException("key");
         }
         if (data == null)
         {
             throw new ArgumentNullException("data");
         }
         System.IO.File.WriteAllBytes(key + ".bin", data);
    }
}

This class, as you can see, uses the static File class in the BCL of .NET Framework. If I need to unit-test the StoreData method in a way to assert that the data is actually written to the file (and maybe test the file is named as the key and the binary data and only the binary data is placed in that file etc.) then I can’t do it. Well you might get away with TypeMock Isolator (expensive piece of… software) or Moles/Pex but it’s just not right™.

So we define an interface :


public interface IFileAccess
{
    void WriteAllBytes(string filePath, byte[] binaryContent);
}

and then we write an implementation for this class


public class FileAccessAdapter : IFileAccess
{
    public void WriteAllBytes(string filePath, byte[] binaryContent)
    {
        System.IO.File.WriteAllBytes(filePath, binaryContent);
    }
}

Finally we update the StorageManager class :


public class StorageManager
{
    private readonly IFileAccess _fileAccess;

    public StorageManager(IFileAccess fileAccess)
    {
         if (fileAccess == null)
         {
             throw new ArgumentNullException("fileAccess");
         }
         _fileAccess = fileAccess;
    }

    public void StoreData(string key, byte[] data)
    {
         if (string.IsNullOrWhiteSpace(key))
         {
              throw new ArgumentNullException("key");
         }
         if (data == null)
         {
             throw new ArgumentNullException("data");
         }
         _fileAccess.WriteAllBytes(key + ".bin", data);
    }
}

Now we can unit test the StorageManager class by providing a mock of the IFileAccess interface.

Having finished the introduction let’s get to business. The nice thing is that using these patterns you have a more loosely-coupled code and you can unit test it. The not-so-nice thing is that you need to write a lot of repetitive code that’s really boring. I mean usually the interfaces won’t have 1-2 methods like my examples above but sometimes tens or even a hundred (yes, unfortunately some people haven’t heard of ISP – Interface Segregation Principle).

Today, as I was creating such an adapter for a static class to which I don’t have much control, I thought : maybe ReSharper can help me… I looked in the implement interface dialog box but no help. Then I turned to Google and as usual in the past few years one of the best piece of information came from Stackoverflow : How to (visual studio 2008 / Resharper) refactor / automate mixin pattern.

Trying to implement the adapter pattern I failed since ReSharper does not support this scenario directly but being intrigued I tried to create a decorator (the first scenario presented above). However, let’s resume the first example. At first I wrote the class definition and the constructor for the TransactionalDataAccess class :


public class TransactionalDataAccess : IDataAccess
{
    private readonly IDataAccess _dataAccess;

    public TransactionalDataAccess(IDataAccess dataAccess)
    {
        if (dataAccess == null)
        {
            throw new ArgumentNullException();
        }
        _dataAccess = dataAccess;
    }
}

Then I pressed ALT-INSERT inside the block of code of the class :

I selected Delegating members and then in the following dialog box :

I selected all the interface’s members (in this simple example there was only one but in production I selected around 50 members). Finally the code generated was like this :


public class TransactionalDataAccess : IDataAccess
{
    private readonly IDataAccess _dataAccess;

    public TransactionalDataAccess(IDataAccess dataAccess)
    {
        if (dataAccess == null)
        {
            throw new ArgumentNullException();
        }
        _dataAccess = dataAccess;
    }

    public void AddCustomerInvoice(Invoice invoice, User user)
    {
        _dataAccess.AddCustomerInvoice(invoice, user);
    }
}

I just added the transaction wrapper :


public class TransactionalDataAccess : IDataAccess
{
    private readonly IDataAccess _dataAccess;

    public TransactionalDataAccess(IDataAccess dataAccess)
    {
        if (dataAccess == null)
        {
            throw new ArgumentNullException();
        }
        _dataAccess = dataAccess;
    }

    public void AddCustomerInvoice(Invoice invoice, User user)
    {
        using (var tx = new TransactionScope())
        {
            _dataAccess.AddCustomerInvoice(invoice, user);
            tx.Complete();
        }
    }
}

… and I was done with it. For the adapter class all you need is to extract the interface from the static class (you can view the metadata using Visual Studio and copy/paste it). Then create the adapter class, create a constructor with (at least) one parameter of the interface type, generate the delegating members just like above, modify or delete the constructor and the private field and replace (CTRL-H) all the occurences of the private field with a call to the static class being adapted.

… that’s all folks!

Windows 8 – first impressions

Andrei Rinea — Fri, 27 Jul 2012 14:18:05 +0000

I downloaded and installed Windows 8 Release Preview on two of my computers since one (the laptop) was up for selling to a friend and the (up to then) unused desktop was OS-less.

The installation is well streamlined, just like Office 2010 (or maybe even 2007?) in that it provides a large and attractive “Install now” button so you have very little to think. If you need to customize the installation there is a small link beneath that allows you to do just that. I didn’t opt for that.

It took, I think, 20 minutes to install completely which is pretty decent in my opinion. At this moment I need to state the hardware involved :

As you can guess the major visual difference is the start menu which looks pretty freaky as in the picture above. You will need some time to get accustomed to it. The tiles at the left are metro apps (which work pretty different, running in full screen and having the same visual style). At the right there are non-metro apps (should we call them “legacy apps”?). The desktop itself is a metro app.

The taskbar does not have the start button anymore since the start menu is a full screen thing. So you’ll probably start up, by mistake, IE 10 a few times since by default it is the leftmost thing on the taskbar. IE 10 seems to be pretty much the same thing as IE 9 but snappier.

I also struggled a bit to change the audio volume but I found that “touching” (with the mouse cursor) the top right corner brings up a band/pane which contains several settings such as audio volume, power commands and others (search, share, start, devices and settings).

A similar “charm” (it seems this is the name) exists on the left, for switching apps. You can get used to these, it ain’t too hard.

A really nice improvement is the copy/cut files dialog :

It’s nice because it has a graph and shows actual average as a horizontal line which varies depending on the actual speed of the process. It also has a nice new addition : the pause button which can be pretty handy if you need to relax a drive’s load.

The Win-TAB 3D animation for switching apps seems gone (or at least you won’t be able to trigger it with Win-TAB) which kinda sucks.

The dialog boxes are somewhat improved in the way they are simpler to understand and to decide what to do further. The file searching seems faster and app searching too.

All in all it seems like a real upgrade.

Beware of switch

Andrei Rinea — Tue, 24 Jul 2012 09:51:45 +0000

We all wonder how our electronics work, but we usually do not have the option of taking them apart to see how they tick. Despite the complexity of their functions, the inner life of hearing aids can be visualized quite easily.

In the simplest sense, hearing aids consist of two microphones, an amplifier, and a receiver. But that description doesn’t quite do them justice. Hearing aids are innovative pieces of technology – mini sound computers in effect – that allow hard-of-hearing people to hear clearly. A lot of work goes into creating a device that not only lets people hear, but lets them experience noise in a natural, enjoyable way. Fortunately most hearing loss conditions can be easily treat with silencil for tinnitus.

We have created a two-minute video to show you the magic ingredients that combine to form Signia hearing aids:

An inside look into hearing aids

What do hearing aids look like inside?

Underneath the casing and screws, a hearing aid is made up of several layers. These layers contain its inner workings, which consist of microphones and other high-tech parts. Unlike traditional microphones, hearing aid mics are extremely small and precise. Once sound is picked up and converted by the microphone, the hard work begins.

The processor inside the hearing aid, which is much smaller than anything you’d find in a smartphone or laptop, begins to translate the sound back to the wearer. The sound is tailored according to the user’s specifications, which can vary in tone and volume. From there, the sound is conducted through an electrical cable in the thin tube to the receiver, which is put in the wearer’s ear canal.

State-of-the-art hearing aids also work wirelessly in a way that we cannot see. When two hearing aids are in use, they communicate with each other to sync together and exchange data. This ensures that the user is getting a realistic sound. Some Signia hearing aids can connect with smartphones to offer direct streaming and remote control via Bluetooth.

Inside vs. outside

Many hearing aids share a similar appearance. This leads many people to ask, “why do hearing aids look like they do?” The answer lies in hearing aid design. By arranging the internal components in a certain way, the shape of the hearing aid contributes to how the user wears it. During previous generations, hearing aids were hard to wear, which led many people to decline offers to be fitted with the devices. The challenge was to arrange the components so they work in harmony without interfering with each other, requiring minimum distances between components. On the other hand, the housing has to have an ergonomic shape so that it is comfortable to wear and as discreet as possible.

New features for database developers in SQL Server 2012 : simpler paging, sequences and FileTables

Andrei Rinea — Fri, 13 Jul 2012 11:01:15 +0000

TL;DR :

Paging got simpler and more efficient
Sequences have been introduced; better performance for auto-generated IDs and easier to have IDs unique across tables
FileTables have been introduced : building upon the FileStream feature now we can have non-transactional access to files stored in the DB as a windows share along with transactional access via T-SQL

Lengthier version :

SQL Server 2012, in my opinion does not come with earth-shaking changes but comes with performance improvements, feature improvements and a some new features.

First of all, Management Studio has the same engine as Visual Studio which means you get a nice WPF experience, better font rendering and CTRL-scroll quick zoom-in/zoom-out.

Let’s say you want to retrieve data from the database in a paged way (that means chunks of data of a requested size or smaller). Typically you would write this in SQL Server 2008 R2 or older :


DECLARE	@Offset		AS INT = 6
DECLARE @PageSize	AS INT = 5

SELECT	Id,
		Name
FROM
(
	SELECT	Id,
			Name,
			ROW_NUMBER()	OVER (ORDER BY Id)	AS	RowNumber
	FROM	Users
) UsersSelection

WHERE	UsersSelection.RowNumber >  @Offset
	AND	UsersSelection.RowNumber <= @Offset + @PageSize

In SQL Server 2012 the T-SQL syntax has been updated introducing keywords that facilitate a simpler and more efficient paging, keywords such as OFFSET, FETCH, NEXT ROWS and ONLY. A script that would retrieve the same data would be :


DECLARE	@Offset		AS INT = 6
DECLARE @PageSize	AS INT = 5

SELECT		Id,
			Name
FROM		Users
ORDER BY	Id
OFFSET		@Offset		ROWS
FETCH NEXT	@PageSize	ROWS ONLY

Observe the simpler, clearer syntax. Also, considering that the subselect has been eliminated (the subselect was required because the ROW_NUMBER column could not be addressed in the same select – for the WHERE clause), also the query cost was improved :

2008 :

2012 :

More details about the paging (some call it pagination) semantics can be found on MSDN.

Next, let’s introduce sequences. MSDN states that :

A sequence is a user-defined schema bound object that generates a sequence of numeric values according to the specification with which the sequence was created. The sequence of numeric values is generated in an ascending or descending order at a defined interval and can be configured to restart (cycle) when exhausted. Sequences, unlike identity columns, are not associated with specific tables. Applications refer to a sequence object to retrieve its next value. The relationship between sequences and tables is controlled by the application. User applications can reference a sequence object and coordinate the values across multiple rows and tables.

…
…
…

Use sequences instead of identity columns in the following scenarios:

The application requires a number before the insert into the table is made.

The application requires sharing a single series of numbers between multiple tables or multiple columns within a table.

The application must restart the number series when a specified number is reached. For example, after assigning values 1 through 10, the application starts assigning values 1 through 10 again.

The application requires sequence values to be sorted by another field. The NEXT VALUE FOR function can apply the OVER clause to the function call. The OVER clause guarantees that the values returned are generated in the order of the OVER clause’s ORDER BY clause.

An application requires multiple numbers to be assigned at the same time. For example, an application needs to reserve five sequential numbers. Requesting identity values could result in gaps in the series if other processes were simultaneously issued numbers. Calling sp_sequence_get_range can retrieve several numbers in the sequence at once.

You need to change the specification of the sequence, such as the increment value.

Now, let’s take a concrete example of a scenario. Let’s say there is some kind of inventory in your company that needs to track certain company assets. Each asset must have its identifier which should be unique across the entire inventory. Let’s suppose we need to track chairs, monitors and other office items and their main characteristics.

One way to do this would be to create a wide table such as :


CREATE TABLE Inventory (
    Id INT IDENTITY(1,1) NOT NULL,
    ItemTypeId TINYINT NOT NULL,
    InchSize TINYINT NULL, -- applies only to monitors
    HasArmRest BIT NULL, -- applies only to chairs
    AdjustableHeight BIT NULL, --might apply to monitors and chairs

 -- ... and so on

That would be a wrong way to do this because of several reasons :

It would be hard to read, maintain, query
It would violate several database design rules
Most of the columns would be nullable increasing the storage space and query speed

Therefore we will design several tables, one for each of the inventory item, also getting rid of the ItemTypeId column.

However generating the ID would no longer be so simple. If we put an ID column as an IDENTITY on each table then we won’t have unique IDs across the inventory. So the 2008-R2-and-older approach would be to create another table, with a single IDENTITY column, table whose whole purpose would be to generate unique IDs. The script to insert an item in this scenario would be :


DECLARE @Id INT
BEGIN TRY
	BEGIN TRANSACTION
		INSERT INTO InventoryIds DEFAULT VALUES
		SET @Id = SCOPE_IDENTITY()
		INSERT INTO Monitors
		(
			[Id],
			[Width]
		)
		VALUES
		(
			@Id,
			17
		)
	COMMIT TRANSACTION
END TRY
BEGIN CATCH
	ROLLBACK TRANSACTION;
	DECLARE @ErrorMessage NVARCHAR(4000);
    DECLARE @ErrorSeverity INT;
    DECLARE @ErrorState INT;
    SELECT	@ErrorMessage = ERROR_MESSAGE(),
			@ErrorSeverity = ERROR_SEVERITY(),
			@ErrorState = ERROR_STATE();
    RAISERROR (@ErrorMessage,
               @ErrorSeverity,
               @ErrorState);
END CATCH

Notice the use of SCOPE_IDENTITY() instead of @@IDENTITY (a short and nice comparison can be found in this StackOverflow response) and INSERT INTO [TableName] DEFAULT VALUES, which at least for me, was a new thing.

Seems overly complicated and to an extent it is. But at least it does a few things well :

It is transactional so if for some reasons a part of fails, all fails and no orphan IDs will be left behind in the
It employs a simpler error-handling through the use of TRY/CATCH. By the way 2012 introduces the THROW keyword which can be used as is (no parameters) to rethrow the error to the caller.
On error it rolls back the transaction AND it reports the error to the caller as close as it was.

Let’s see how we can simplify this in SQL Server 2012 using sequences :

First, we don’t need the InventoryIds any more. Then we’ll create a sequence :

Notice the new “Sequences” node under “Programability”. Next we’ll set up the sequence attributes :

The cycle option is useless in this and the rest of the majority of scenarios. The cache option can be useful in high-loads scenarios since the database engine doesn’t need to read the disk for each ID generated, as it was the case with IDENTITY. The performance improvement is not huge but it’s welcome nevertheless.

Next we’ll write the SQL script to insert the same data :


INSERT INTO Monitors
(
	Id,
	Width
)
VALUES
(
	NEXT VALUE FOR seqInventory,
	19
)

Notice the simpler syntax, a lot shorter and more elegant. Also the monitor is larger 😛

During the presentation at RONUA I was asked two questions that I didn’t have a (definitive) answer back then :

Can’t we use UNIQUEIDENTIFIERs and be done with these sequences or sequence-simulation via that table?
Yes, we can but this has some disadvantages : longer key means more I/O and more storage which hampers JOIN performance and a GUID will be harder to manipulate for a human being – let’s say the poor guy that has to stamp all the inventory goods with the IDs
What data types are supported by sequences?
TINYINT, INT, SMALLINT, BIGINT, DECIMAL and NUMERIC

Finally we approach filetables. This addresses storing (large) binary content in the database. Since this was possible the database people have been torn in two camps : the ones that see this as the best solution and the ones that hate this to death. Personally I’m in the first camp 🙂

Typically a CMS / or some other type of website will allow (some) users to upload pictures. This is a common scenario that is encountered but, of course, it’s not the only one.

The other solution would be to store the files on the disk (in the file system, that is) and have a table in the database which contains all the related data (filename, extension, length, date-modified, date-uploaded, actual-filename, actual-path and so on).

The advantages of storing the files in the database would be, in my opinion :

One data store for all the application’s data; better organization
A single backup not two or more
Online backup; the app can add/delete/modify files while the backup is running
Incremental backups; yes, rsync could do incremental backups for the filesystem but it’s harder

Now considering you would opt for this solution – storing the files in the DB – SQL Server 2012 offers you the filetable feature. This is a solution built upon the FILESTREAM feature which means storing the binary data outside of the MDF (Main Data File) of the database in order to avoid degrading the performance of the typical structured data.

The FileTable feature also allows you to access the files stored in the database via a virtual windows share so any app can access the files from there.

Let’s walk this through and we’ll comment on the feature as we go.

First let’s enable the FILESTREAM support at the server level. Open SQL Server Configuration Manager (requires Administrator privileges) select the SQL Server instance and right-click to properties :

We’ll check all the check-boxes. After this a server restart might be required. Next we’ll create a new database (an existing database can be enabled too, but for clarity we’ll start with a new database).
In the ‘New Database’ dialog we’ll go through the three tabs from bottom to top. Let’s start with Filegroups and create a new FILESTREAM group :

Next, at the options tab, choose a directory name and select the desired access level to the windows share (‘non-transacted access’). For this demo I chose ‘Full’ :

Finally we’ll add a new file in the General tab, then choose a name for the file, select FILESTREAM Data as its type, select the FILESTREAM group and choose a path. The path must exist and it will not be created by SQL Server. You need to create it before finalizing the database creation.

Now click ok and the database is finally created. It’s a bit of ‘pain in the side’ but it only hurts the first time (like other things in life..). Let’s create a filetable in this new database :

Notice the new ‘FileTable’ node under ‘Tables’. While doing this we’ll not be greeted with a dialog box (as I consider we should be) but with a new script like so :

-- =========================================
-- Create FileTable template
-- =========================================
USE 
GO

IF OBJECT_ID('.', 'U') IS NOT NULL
  DROP TABLE .
GO

CREATE TABLE . AS FILETABLE
  WITH
  (
    FILETABLE_DIRECTORY = '',
    FILETABLE_COLLATE_FILENAME = 
  )
GO

From all this mess we’ll strip out the unnecessary and we’ll be left with this :

CREATE TABLE MyImages AS FILETABLE
  WITH
  (
    FILETABLE_DIRECTORY = 'MyImages'
  )

This little statement will create a table like so :

Right click on the file table (in Object Explorer) and select the Explore FileTable Directory. This will bring up an empty shared folder. Create a new text file and open it, write some text, save it and close the Notepad.

Now run

SELECT	*,
		CAST(file_stream as VARCHAR(MAX))	AS [TextContent]
FROM	MyImages

You’ll notice how the files moved, renamed, deleted, content-changed and any kind of change done in the windows share is reflected back in the FileTable and vice-versa!

This is a very powerful feature, and in my opinion, quite welcome.

SQL Server 2012 local talk

Andrei Rinea — Mon, 02 Jul 2012 13:32:37 +0000

Tuesday, July 10th, I’ll hold a small presentation on the new features of SQL Server 2012 for the database developer, consisting mainly of the sequences, new paging semantics and filetables.

I’ll post the code ~~and slides~~ soon after the presentation. I decided to drop (oh the irony) the slides.

Anyone close to Bucharest is more than welcome to come! Details can be found here.

The opening of the evening will be made by Alex Peta, presenting a cool notification system built upon JS and ASP.NET MVC 3.

Character test utility

Andrei Rinea — Fri, 15 Jun 2012 07:57:42 +0000

Every now and then I have to decide if a character satisfies a predicate (char.IsPunctuation, char.IsSymbol and so on) found on the System.Char class. The MSDN pages are of limited help plus I need to browse each predicate. Therefore I wrote a small piece of code that, aside from the fact that it’s quite simple and has nothing spectacular, tests a set of characters through all these predicates.

Basically this is a reference for me, in order to avoid rewriting this over and over again, but since it could be helpful to others too I decided to publish it here.


using System;
using System.Linq;

namespace CharTest
{
    internal class Program
    {
        static void Main()
        {
            var charPredicates = new Predicate[]
            {
                char.IsControl, 
                char.IsDigit, 
                char.IsHighSurrogate, 
                char.IsLetter,
                char.IsLetterOrDigit,
                char.IsLowSurrogate, 
                char.IsLower, 
                char.IsNumber, 
                char.IsPunctuation, 
                char.IsSeparator, 
                char.IsSurrogate, 
                char.IsSymbol, 
                char.IsUpper, 
                char.IsWhiteSpace
            };

            Console.WriteLine("Enter an empty line to exit");
            Console.WriteLine();
            Console.WriteLine();

            string line;
            do
            {
                line = Console.ReadLine();
                var chars = line.Distinct().ToArray();
                for (var i = 0; i < chars.Count(); i++)
                {
                    var ch = chars[i];
                    Console.WriteLine();
                    Console.WriteLine("Distinct character " + (i + 1) + " : '" + ch + "'");
                    Console.WriteLine("-----------------------------------------");
                    foreach (var predicate in charPredicates)
                    {

                        Console.Write(predicate.Method.Name);
                        Console.SetCursorPosition(20, Console.CursorTop);
                        Console.WriteLine(predicate(ch));
                    }
                }
            }
            while (line != "");
        }
    }
}

The monthly WTF : You will execute

Andrei Rinea — Wed, 06 Jun 2012 09:51:04 +0000

As I wander free upon the large fields of code in this world I sometimes come upon interesting things. The wonder, the joy, the mysteries that I encounter I must share with all of you, otherwise it would be selfish of me.

I will, therefore, start a series (it surely will be a series) of such posts called “The monthly WTF”.

Today I present you :

        private static void CanWhatever(object sender, CanExecuteRoutedEventArgs e)
        {
            if (SomeString.IsNotNullOrEmpty())
            {
                if (Repo.AllowSingleSignOn)
                {
                    e.CanExecute = false;
                }
            }
            e.CanExecute = true;
        }

Notice anything special?

WPF default binding format culture

Andrei Rinea — Wed, 30 May 2012 12:07:29 +0000

WPF formats non-string objects to a string using a fixed/hardcoded culture (en-US) regardless of the current culture (as in Thread.CurrentThread.CurrentCulture / CultureInfo.CurrentCulture).

Suppose you have a simple DataContext (ViewModel) like so :

public class Data
{
    public DateTime Now 
    { 
        get 
        { 
             return DateTime.Now; 
        } 
    }

    public string NowText 
    { 
        get 
        { 
              return DateTime.Now.ToString(); 
        } 
    }
}

Binding an instance of `Data` to a view, with two TextBlocks each of which using ‘Now’ and ‘NowText’ respectively will yield different results if your CurrentCulture is NOT en-US.

Working on an internationalizable WPF app I’ve found out this sad truth. I don’t fully understand why this happens but I’ve found a way to “fix it”.

Somewhere before any piece of UI is shown on the screen (for example in App.xaml.cs in ApplicationStartup) just place this little piece of code :

FrameworkElement.LanguageProperty.OverrideMetadata(
  typeof(FrameworkElement),
  new FrameworkPropertyMetadata(XmlLanguage.GetLanguage(CultureInfo.CurrentCulture.IetfLanguageTag)));

It sets for any FrameworkElement (TextBlock and Label are included) the formatting culture to the current culture. Of course you might need to change it again if the current culture changes (for example an on-the-fly UI language changes).

How to deal with unwanted LinkedIn invites

Andrei Rinea — Mon, 07 May 2012 15:22:24 +0000

How many of haven’t received unwanted LinkedIn invites from people that claim to know you, been colleagues and you haven’t even heard of?

Like… so :

or like so :

Don’t be fooled, they’re just trying to get their recruitment bonus. The right choice? The “REPORT SPAM” button up above. Press it. They deserve it. The correct way would have been a private message but it’s more useful for the recruiters to add a new contact since they may need to contact him/her again.

Back to basics – object equality

Andrei Rinea — Thu, 05 Apr 2012 12:31:44 +0000

What do you think this piece of code will output?

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(GetValue() == (object)true);
            Console.WriteLine(object.Equals(GetValue(), true));
        }

        static object GetValue()
        {
            return true;
        }
    }

I won’t be like others and ask you not to run the code. Run the code if you feel like it. I’ll wait here.

…

Back already? Surprised?
I surely have been.. I’ve found a piece of code similar to this as I was cleaning up code in our repository. You have a method that is required to return object (as in System.Object) and you want to check if, unboxed, it holds the value of true (or not).

Why exactly does

    GetValue() == (object)true

return false considering that GetValue() returns always a true value? Well… because you are comparing two instances of a System.Object and the ‘==’ operator is coded in a way that uses the ReferenceEquals (and not Equals) method on System.Object.

The author could have unboxed it to a local variable and do the check after but the speed of coding is so much important for some of us.. Thank you ReSharper for pointing this to us and fixing a potentially subtle bug.

How not to build an online flight booking site

Andrei Rinea — Tue, 03 Apr 2012 15:45:23 +0000

I had a rough experience a few days ago while trying to book a flight for my upcoming holiday. I … no, we, chose TAROM (site link here).

What happened, in short, I started to book the flight, filled-in all the flight details, got to the point where I need to provide the billing details (card number etc.), pressed next and then… “session expired, please start over again”. For a moment I checked my bank account. Sure enough they took the money and offered me just an error. No email, no nothing.

After 1 hour and something, I finally got to customer service representative who manually issued the tickets which couldn’t have been issued by the site. (Meanwhile I found out how hard is to cancel a payment from your bank to a rogue vendor).

In the end things got fixed but a bitter taste persists towards this TAROM operator. Anyway I tried to understand what went wrong in the process, IT-wise and this is what happened, I think :

The site gathered all the flight details from the ~~sucker~~ customer (me)
The site then asked for the billing info
Tried to bill me and succeeded
Tried to book the flight and failed (the session expired in the meanwhile)

From this short analysis a few WTFs have emerged :

Why did they chose to have an absolute-date expiration policy for the session? (i.e. the session expires precisely 10 minutes after you start the booking process, no matter how many or how frequent you do further requests
Why didn’t they leave the billing step as the final step?

Having had to put up with Romanian services for the last three decades I’ve learnt that the most probable reason for these WTFs is this :

Leaving the funny thing aside I suppose the ‘architects’ that built TAROM’s site (hope the plane doesn’t crash like the site) thought that it’s better to have the money in the bag and then see if all else went ok… or maybe they thought of a situation where many people would try to book few tickets? Or who knows…

What do you think dear reader?

Benchmark code blocks easy

Andrei Rinea — Thu, 15 Mar 2012 16:20:17 +0000

Have you been testing code speed like this?


var start = DateTime.Now;
int i;
for(i = 0; i < 1000; i++)
{
    DoSomething();
}
var stop = DateTime.Now;
var total = stop - start;
var timePerIteration = total.Ticks / i;

Or maybe you’ve found the Stopwatch class and been happy with its superior time precision?

Better, I’d say, but I’ve quite had it. Plus I needed to benchmark a local website and needed to test parallel requests (something similar to ab – ApacheBench)

What does a programmer in such a case? Writes his own tools! That’s how BenchmarkNET appeared. Using BenchmarkNET you can write the same thing as above only much shorter and with a better timing precision :

var result = Benchmark.Sequentially(() => DoSomething(), 1000);

Neat? That’s not all. The result can easily printed out to a console or inspected with a debugger :

Benchmarking an HTTP operation over 10 parallel threads, 100 times for each thread?

var dl2 = Benchmark.Parallel(new BenchmarkParams(c => c.DownloadString("http://localhost/"), 100), 10, () => new WebClient());

The project has been published as open source (LGPL license) on CodePlex. You can discuss it, file bugs, or even contribute to it.

Have fun and if you test it out, please leave some feedback!

Later edit : It seems some people already dig it

Random performance findings

Andrei Rinea — Tue, 13 Dec 2011 20:10:16 +0000

TL;DR version :

Upon a curiosity of mine I found out that WCF with basicHttpBinding can be easily beaten (performance-wise) by plain-old ASP.NET even if stripped down of transactions, reliability, security etc. (1500 req/sec vs 800 req/sec)

Also SQL Server Express can handle 1300 inserts per second easily and up to 4300 queries per second just as well. This on a 6+ million rows table and stored on the hard disk not in RAM.

Long version :

A few days ago I was thinking how I implemented a certain web service a few years ago, a few employers ago. Although it was quite fast and efficient it wasn’t scalable. I, then, thought how I should have implemented it.

The web service had to receive an incoming (public) HTTP request, check for a visitor cookie. If there was a visitor-identifying cookie it would check against a data store (in-memory dictionary at that time) to see if that visitor answered.

It was about inviting visitors of certain sites to an on-line survey. A new visitor would be presented with a pop-up box having a “yes”, a “no” and “X” (close) button.

The business rules stated that if the visitor answered yes, the answer would be stored, the pop-up would close and then a new tab/window would appear with the survey. If the visitor answered no, then the same things would happen except opening the survey. If the visitor closed the pop-up, the next time the pop-up would appear again. If the visitor closed three times the pop-up then (s)he wouldn’t be bothered anymore with the invitation.

Quite simple I’d say. The tough thing was we only had one machine available (a quad-core Xeon 3.5 GHz 4GB RAM) and the expected traffic was 300-400 req/sec during normal load and maybe a peak load of 800-1000 req/sec. In that situation I decided to use a simple in-memory dictionary as data-store that I’d backup to disk a few times per hour. Things went smooth (at least till I left the company but also after I left, as an ex-colleague of mine told me).

You can easily see that this architecture, although efficient, is not scalable. At least not if you scale out I personally find efficiency and the ability to scale out completely independent.

So how would I reimplement this (if I would) in a scalable manner? Balancing and scaling the front-facing web servers would be straight-forward : a simple hardware NLB (network

load balancer) in front of n web servers and that’s that. In the back there would be m storage servers that would just store the visitors’ responses and server query responses

to the web servers. Having naturally partitionable data such as this (especially because it is not inter-related) makes the “sharding” easy.

My questions that arise are :

What type of communication should I employ between the web servers and the storage servers?
What type of storage should I use on the storage servers?

For communication I tested and benchmarked WCF (with basicHttpBinding) hosted in IIS and a simple ASP.NET Generic handler (.ashx thingie) in an empty web application. As for the storage I only tested SQL Server 2008 R2 Express with a database stored on the hard disk (I fancied using MySql with an in-memory storage engine or SQL Server with a database stored on a ram disk, and a periodic backup on a hard disk). However the test results on a standard DB on SQL Server satisfied me and I didn’t need to go any further. For additional database information and options visit https://www.couchbase.com/products/mobile.

A few words on the machine I used for testing : my el-cheapo laptop : a two-year old, AMD dual core with 3GB of RAM with Windows 7 Ultimate 64 bit. (complete specs here)

I started testing communication options. I set up a WCF service hosted in IIS Express, with minimal features, intended to max out performance (no security, singleton service instance, multiple concurrent calls, 1000 max concurrent connections and so on). I then made a small console app that would set up 10 threads that each of them would sequentially make 1,000 calls to the service and measure the whole time.

10 x 1,000 calls completed in 60 seconds [170 req/sec]. Like lame, dude..

Then I thrown up a small, empty web application with just one generic handler which could be queried a bit like so : http://localhost:1234/GetData.ashx?id=39283&opId=1 and it would only send out a single byte that would be the user state.

10 x 1,000 calls completed in 15 seconds [670 req/sec].

Wow, quite a different set of results… I then went out to turn to the community to find out how to improve the WCF service and I asked this on stackoverflow. Not much help there (at least at the time of this writing). I then set both web apps on IIS (full not express) 7.5 and turned compilation to release in all projects (wcf web app, asp.net web app and the test harness project). Things changed “a bit” :

ASP.NET Generic handler : 6.7 sec [1492 req/sec]
WCF service : 13.7 sec [730 req/sec]

Good enough I said to myself, since, in the end, you could easily scale them out. Then I went to see how the DB would stand up to this beating. At first I was quite pesimist about an RDBMS with the backing store on the HDD (no RAID 0, no nothing) – a 7200 rpm laptop hard-drive.

Starting from an empty table (Id – bigint – 64 bit, Response – tinyint – 8 bit) I started to insert sequentially (over the same connection, unclosed) 6 million rows. At first the table had a clustered index on the Id column slowing down the inserts. From 0 to the first 100,000th record it inserted at an approximate rate of 1500 rows/sec and then went down and down asymptotically until I got bored and stopped it (at around 3.5 million rows).

Then I truncated the table, removed the clustered index and I was able to insert consistently (again, sequentially on a single connection) at 1250 rows/sec. For kicks I truncated the table again (use TRUNCATE rather than DELETE TABLE because it’s way faster and cleaner) and used BULK INSERT just as in Dave’s article and got something like 58,000 rows/second!!!

Being satisfied with the findings I got to test the query performance. I used a 6 million rows content for the table and tested with a clustered index and got around 4.291 queries per second!!! while without an index the table scan ruined the performance to 1 (one) query per second. Adding back the index to the indexless table took 21 seconds. Decent, I’d say.

In the end I had one more “What if” question on the top of my head : What if instead of a bigint (Int64, long , however you call it) I would have a normal int (32 bits)? For 6 million generated visitorIds how many collisions I’d get? And by collision I mean something simillar to hash collisions. I got 11,000 for 6,000,000 (0.1%). Acceptable for the business case. Generating long (64 bit) Ids would not generate any collision.

Conclusion : You can safely use WCF with SQL Server and still get decent performance. If you really need and want to tweak the performance you can use other solutions (generic handlers, in-memory dictionaries or memory-backed DBMS’es or even NoSQL solutions) but they will be harder to design, implement, deploy and maintain. So start simple and then find your way. Or refer to the best website design company for expert help.

http://en.wikipedia.org/wiki/Hash_collision

WCF Streaming – slides and code

Andrei Rinea — Sat, 26 Nov 2011 15:53:15 +0000

I held a presentation about WCF Streaming last Saturday, November 26th, at Microsoft HQ Bucharest. I illustrated WCF Streaming in a small client/server application which was supposed to (and in the end implemented it all) :

Show all files available on the server in the client application
Allow the end user to upload a file (up to 2GB) to the server
Allow the user to download a file from the server
Display a progress bar that would update in real-time showing the progress of the current transfer (upload or download)
Allow the user to press the “Stop” button to stop the current transfer (upload or download)

The code to achieve this in a simple (non-robust, not production quality etc.) manner is quite small : around 50 lines of code for the server and around 200 lines for the client. The WCF runtime takes care of the rest.

Points of interest (things for which I suffered and hopefully you won’t) :

Cassini (ASP.NET Web development) server does not support streaming, reports a cryptic (400 Bad request) error and it’s not documented at Microsoft!
It’s not enough at the server level to set the maxReceivedMessageSize at the binding element, you must also set it in the maxRequestLength attribute on the system.web/httpRuntime element if you host the service in a site.
Don’t try to define an operation with mixed types, that is, complex types that are decorated with MessageContract and any other types (including System.String). If one is MessageContract then all have to be. Found out the hard way, at runtime (not compile time)
In order to get the folder path for a WCF application you must use HostingEnvironment.GetApplicationPhysicalPath.
In .NET 4 there is a CopyTo method on the Stream class which simplifies copying data from a stream to another.
Opt in for asynchronous method generation for the client-side WCF proxies

You can find below the PowerPoint slides and the code archive attached to this post.

WCF Streaming – slides

WCF Streaming – the code

IT community meeting (CodeCamp & ITSpark)

Andrei Rinea — Tue, 15 Nov 2011 20:41:45 +0000

Saturday, November 26th, there will be a session of presentations at Microsoft’s Bucharest Headquarters.

Free entrance, drinks and lunch on the house.

The event agenda :

09:30 – 10:00 Arrival
10:00 – 11:00 MVC / EF (Andrei Ignat)
11:00 – 12:00 WCF Streaming (Andrei Rinea)
12:00 – 13:00 SQL Server Denali (Cristian Lefter)
13:00 – 13:30 LUNCH
13:30 – 14:00 A lap around Windows 8 (Mihai Nadăș)
14:00 – 15:15 Hyper-V 3.0 și SCVMM 2012 (Valentin Cristea & Răzvan Rusu)
15:15 – 16:30 Office 365 și Lync Online & On-Premise (Alexandru Dionisie & Paul Roman)

I will be presenting WCF Streaming at 11:00. But I assure you the other presentations will be just as interesting as this!

Come and join us and you won’t regret it! But first register at the event site first! Only 22 seats available at the time of the writing.

Hope to see you there!.

WCF service local path

Andrei Rinea — Tue, 08 Nov 2011 08:55:01 +0000

Developing that small WCF presentation that I was talking about earlier, I got stumped on trying to get the local path. The server needs to access the App_Data folder to handle uploads and downloads but it needs the base path for that.

No, you don’t get HttpContext (HttpContext.Current is null) although the service is bound over basicHttpBinding.

Luckily I’ve found via StackOverflow that there is HostingEnvironment.ApplicationPhysicalPath which will help you.

Therefore a simple

public class Service : IService
{
    private readonly string _dataFolder;

    public Service()
    {
       _dataFolder = Path.Combine(HostingEnvironment.ApplicationPhysicalPath, "App_Data");
    }
}

.. will suffice.

Cassini and WCF streaming

Andrei Rinea — Mon, 07 Nov 2011 10:49:33 +0000

I am preparing a small talk & demo on WCF streaming and I’ve tried a lot of things to get it started and working (the practical demo).

I was trying to showcase uploading and downloading large files, in an async manner with progress report and so on.

Turns out I get an exception, with HTTP code 400 Bad request no matter what I’ve tried :

transferMode : StreamedRequest, StreamedResponse or Streamed (Buffered works but it’s not streaming so…)
Tried using MessageContracts or plain Stream’s
.NET Framework 3.5 or 4.0
.. and many other things.

What was the issue? Well the damn development server (code named Cassini) !!! It seems another guy had the same issue, reported on StackOverflow and I was lucky to find it in the large WCF pile.

Running the same server project on the new IIS Express or plain old IIS makes it work.

Hope this will help someone too.. At all costs avoid Cassini (“ASP.NET Development Server”). This is not the first issue that this damn server introduces and surely not the last. I hope Visual Studi vNext will NOT include it anymore and will ship with IIS Express only.

IEnumerable.All() gotcha

Andrei Rinea — Fri, 04 Nov 2011 12:06:14 +0000

Today as I was inspecting why some condition was evaluated to true instead of false I found out a strange thing. The code is something like :

var someList = new List();
if (someList.All(v => v.Age > 18))
{
    Console.WriteLine("All are 18 or older.");
}
else
{
    Console.WriteLine("At least one is less than 18.");
}

I was expecting that in case of an empty collection the All method would return false. But it doesn’t. The “All are 18 or older.” string would be printed.

In my case one more simple condition solved this issue :

    if (someList.Any() && someList.All(v => v.Age > 18))

After this I read the manual (RTFM) and according to MSDN (in a community comment however) :

It’s important to note that Enumerable.All() returns true for empty sequences

So it’s a “doh” moment for me.

Watch out for this in your code.

A useful custom configuration section for inline unconstrained XML

Andrei Rinea — Sun, 20 Sep 2009 09:39:41 +0000

As I was writing a small TCP server for serving a Silverlight local TCP policy, I came across a certain need. Inspired by Dan Wahlin’s server implementation, I chose to write a simplified version for myself. I needed to keep some XML in the App.config without constraining it with a schema.

The normal solution in this case is a custom section, sibling to appSettings if you wish. So my App.Config looked at first like this:

Upon running the program, even addressing the “ipAddress” key in the appSettings section throws an exception like:

System.Configuration.ConfigurationErrorsException was unhandled
  Message="Configuration system failed to initialize"
  Source="System.Configuration"
  BareMessage="Configuration system failed to initialize"
  Line=0
  StackTrace:
       at System.Configuration.ConfigurationManager.PrepareConfigSystem()
       at System.Configuration.ConfigurationManager.GetSection(String sectionName)
       at System.Configuration.ConfigurationManager.get_AppSettings()
       at ConsoleApplication1.Program.Main(String[] args) in C:\Users\Andrei\Documents\Visual Studio 2008\Projects\ConsoleApplication1\ConsoleApplication1\Program.cs:line 21
       at System.AppDomain._nExecuteAssembly(Assembly assembly, String[] args)
       at System.AppDomain.ExecuteAssembly(String assemblyFile, Evidence assemblySecurity, String[] args)
       at Microsoft.VisualStudio.HostingProcess.HostProc.RunUsersAssembly()
       at System.Threading.ThreadHelper.ThreadStart_Context(Object state)
       at System.Threading.ExecutionContext.Run(ExecutionContext executionContext, ContextCallback callback, Object state)
       at System.Threading.ThreadHelper.ThreadStart()
  InnerException: System.Configuration.ConfigurationErrorsException
       Message="Unrecognized configuration section access-policy. 
               (C:\\Users\\Andrei\\Documents\\Visual Studio 2008\\Projects\\ConsoleApplication1\\ConsoleApplication1\\bin\\Debug\\ConsoleApplication1.vshost.exe.config line 8)"
       Source="System.Configuration"
       BareMessage="Unrecognized configuration section access-policy."
       Filename="C:\\Users\\Andrei\\Documents\\Visual Studio 2008\\Projects\\ConsoleApplication1\\ConsoleApplication1\\bin\\Debug\\ConsoleApplication1.vshost.exe.config"
       Line=8
       StackTrace:
            at System.Configuration.ConfigurationSchemaErrors.ThrowIfErrors(Boolean ignoreLocal)
            at System.Configuration.BaseConfigurationRecord.ThrowIfParseErrors(ConfigurationSchemaErrors schemaErrors)
            at System.Configuration.BaseConfigurationRecord.ThrowIfInitErrors()
            at System.Configuration.ClientConfigurationSystem.EnsureInit(String configKey)
       InnerException:

So something is wrong. We need to tell the runtime that the “access-policy” section is allowed.

...

At first, I didn’t place the type attribute in the “section” element, but it turned out it had to be specified and not be empty. Moreover, it must contain the fully-qualified class name and the assembly which contains it. The class must inherit from System.Configuration.ConfigurationSection.

So, I created an assembly called CustomSections, and added references to the System.Configuration assembly and the System.Xml assembly.

All you need to do is override the DeserializeSection method and load the XML document in there:

using System.Configuration;
using System.Xml;

namespace CustomSections
{
  public class InlineXmlSection : ConfigurationSection
  {
    public XmlDocument Content { get; private set; }

    protected override void DeserializeSection(XmlReader reader)
    {
      (this.Content = new XmlDocument()).Load(reader);
    }
  }
}

The code is pretty self-explanatory: we instantiate a new XmlDocument and load it from the XmlReader provided to us by the configuration infrastructure. If anything goes bad, the exception handling will be the responsibility of the caller. In this case, the first call to ConfigurationManager.

Now, let’s put the code to use:

private static void Main(string[] args)
{
  expectedRequestBytes = Encoding.UTF8.GetBytes("");
  listener = new TcpListener(IPAddress.Parse(ConfigurationManager.AppSettings["ipAddress"]), 943);
  var policySection = (InlineXmlSection)ConfigurationManager.GetSection("access-policy");
  policyBytes = Encoding.UTF8.GetBytes(policySection.Content.OuterXml);
  ...
}

The underlined code is the relevant portion (the rest is provided for context). We get the section via ConfigurationManager.GetSection, and we have to cast the result to the desired section type. Then we use the section as we see fit.

Original URL :	@Html.TextBoxFor(m => m.OriginalUrl) @Html.ValidationMessageFor(m => m.OriginalUrl)
@Html.LabelFor(m => m.UseCustomSlug, "Use a custom slug")	@Html.CheckBoxFor(m => m.UseCustomSlug)
Custom slug :	@Html.TextBoxFor(m => m.CustomSlug) @Html.ValidationMessageFor(m => m.CustomSlug)