Why I Don't Loop Through Dispose

Quite often graphical classes have a lot of disposing to do, e.g.:

public void Dispose() {
    foreBrush.Dispose();
    backBrush.Dispose();
    someBrush.Dispose();
    …
}

One might be tempted to optimize that a bit:

public void Dispose() {
    foreach(IDisposable element in new IDisposable[] { foreBrush, backBrush, someBrush, … }) {
        element.Dispose();
    }
}

I personally find this code a bit easier to maintain and it serves same purpose. But I never really use it due to one serious drawback - it is not recognized by code analysis.

Code analysis that is part of Visual Studio Professional (and higher) does not recognize operation of this loop and thus it reports CA2213: Disposable fields should be disposed violation. While it is clear that violation is invalid, it still means that our loop goes completely unchecked.

If we add one more disposable field to class at some future time, first scenario would give us notice and we would be aware of forgotten dispose. After quick check we add dispose of that field and all is nice.

In second case we have taken responsibility of disposal ourselves and Visual Studio is not capable of checking the loop. There is nobody to check that all fields are disposed and if we forget to dispose it, it will be up to garbage collection to do it.

This will usually not be a major issue because resources will be released at some time. If we take some OS resource (e.g. file handle) it might be a bit annoying for rest of system but again nothing critical.

However, under rare circumstances, it might become important. Call me lazy, but I would rather have a bit uglier code that is automatically validated than have beautiful code that I need to check myself.

In the Year 2013

As always, first post of a year is reserved for a bit of statistics.

This year I have slowed-down posting a bit with only 74 posts since January. As usual 40% of posts is programming related, followed by 25% of Windows posts. Rest is such a mishmash of everything that I wont even go into analyzing it.

Traffic-wise it was a fantastic year - another 25% increase is greatly appreciated. Unfortunately huge 66% of traffic comes from places unknown so it is really doubtful whether it is even worth tracking this. Assuming same distribution of unknown locations as ones that were recognized, USA leads with 60% of visits. After that there is 20% visits from Germany and 15% from India. Other 216 countries cover the rest.

Google Chrome leads the pack with 40% visitors. Next one is Internet Explorer with 25% followed closely by Firefox. All other browsers are in traces. Mostly users came with desktop browsers (more than 95%).

Vast majority of search traffic to blog came in search for Windows 8.1 product key, probably because of my Installing Windows 8.1 (or 8) without a product key post. Another huge chunk were ones searching for VHD Attach and MagiWOL.

Pingdom claims 99.93% uptime (6h down) which is definitely helped by CloudFlare. While free CloudFlare account is not a perfect solution, it is definitely helping with site’s speed. For next year I will need to think of some other improvements.

And that’s all folks!

Variable Parsing Au Bash

Every command-line processor has a way to allow for embedded variables. Those familiar with DOS will recognize percent encoded variables, e.g. “echo I am %USERNAME%”. Those more familiar with Unixoids will be more relaxed around dollar variables, e.g.: “echo I am $USERNAME”. Either way gives possibility to combine fixed text with some external value. I personally prefer bash-style so I will continue with it.

If we try to parse “User $USERNAME is working on $OS using $NUMBER_OF_PROCESSORS processors.”, this is really easy for human to tackle. Even on first glance, we know that result should be “Joe is working on Windows NT using 1024 processors.”. Making computer recognize that is a bit more involved.

Well, generic solution is really simple. Just make an function that will extract all variables from string and ask us what values might those be:

string ParseVariables(string text) {
    var res = ParseVariablesStateMachine(text, **delegate(string variable)** {
        **return Environment.GetEnvironmentVariable(variable);**
    });
    return res;
}

As you can see from above code, we call into ParseVariablesStateMachine method giving it whole input text alongside with a callback delegate. Function will take care of parsing variables out and ask us what each value should be via delegate function. In our example we do simple environment variable lookup but this can be modified to return almost anything.

This delegate will return value back into calling method and that method will continue string processing until next variable comes along. At that time it will repeat call to our delegate; rinse and repeat. At the end it will return value composed of all these variables in one nice string.

One way to tackle this problem is by using a simple state machine (yes, name was kinda giving it away). We definitely have starting state, we have state where we found inner variable, and state where variable is being processed. Code may look something like this (heavily redacted):

string ParseVariablesStateMachine(string text, Func<string, string> variableCallback) {
    var state = ParsingState.Default;
    for (int i = 0; i < text.Length; i++) {
        switch (state) {
            case ParsingState.Default:
                if (text[i] == '$') { state = ParsingState.VariableStart; }
                break;

            case ParsingState.VariableStart:
                state = ParsingState.NormalVariable;
                break;

            case ParsingState.NormalVariable:
                if (!char.isLetterOrDigit(text[i])) {
                    variableCallback.Invoke(text.substring(variableStart, variableLength));
                    state = ParsingState.Default; //search for next variable
                }
                break;
        }
    }
    return parsedString;
}

Full example source is available for download.

Modifying ParseVariablesStateMachine mathod to parse DOS-style variables is exercise left to a reader. It is actually simpler than bash-style parsing because we know when variable ends based on closing percent sign.

PS: Full example also covers extended variable style (e.g. ${USERNAME}.).

Asus RT-AC56U

As I was getting tired of crowded 2.4 GHz band in my neighborhood, I started looking into newest 802.11ac routers. I was after something small, dual band, and with support for Tomato (or DD-WRT) firmware (history taught me that manufacturer’s firmware sucks).

One device that fitted description was Asus RT-AC56U. Having owned Asus’s WL-500g, WL-300g, and still owning WL-330gE I was quite confident that hardware will be good, LEDs will be blue, and original firmware will be rubish. I also expected to get unbrickable device with a lot of community support. [2014-04-19: Of course I have managed to brick this one. I should learn to keep my mouth shut.]

Hardware-wise this is AC1200 category, dual-band (2.4 GHz and 5 GHz), dual-stream router with 4 gigabit ethernet ports and two USB ports (one is 3.0). All is driven by BCM4708, dual core 1 GHz CPU (down-clocked to 800 MHz), 256 MB of RAM, and 128 MB of flash. As home routers go, this is a beast. Not the fastest beast, but beast nevertheless.

As I plugged it in, I was enchanted. This is my first home router where I didn’t need to open a case and modify LED brightness myself. It is nice subdued blue light that won’t light-up your house like a Christmas tree. It is just perfect intensity. And yes, I am easily amused. :)

I haven’t been checking Asus firmwares for a while so it came as a surprise how open it has become. Yes, it has always been an open source but best thing you could count on was to get raw sources every few months. Asus now bases firmware on AsusWRT source code that is obtainable few days after firmware gets published. It even contains (accurate) setup instructions for compiling that code yourself.

I am pleasantly surprised with this development and it shows results. While usually only firmwares worth having on router were DD-WRT and Tomato, now we must take Merlin into consideration too. Probably due to all that liveliness, Asus own firmware actually doesn’t suck. Mind you it is not as good as any of these alternatives but it is actually possible to use it without swearing.

Setup of a device is quite simple and practically leads you by hand toward getting your Internet connection. Beginners will probably leave it there and be happy. Advanced users have many more things to configure, whether it is IPv6, disk sharing, or VPN. Most settings can even be applied without losing connection. Really nice.

Not all things are perfect unfortunately. For one, 2.4 GHz stability and range is between bearable and just awful. Irony would have it that, in my household, Asus’ own N56VJ laptop (Atheros AR9485WB) is almost unusable even just two meters away. For a minute it would have low speed connection (i.e. 2-3 Mbps), then it would just stall for a few seconds, recovering to 2-3 Mbps in ten seconds or so. Then it would stall again, repeating the cycle. And it is not because of location; kiddie WL-330gE router handles the very same location without any issue…

Asus team is looking at it and there are promises of a new firmware that might make things better but I wouldn’t hold my breath here. I have tried their newest beta firmware and results are just marginally better. I have tried completely alternative firmwares and everything is as bad as with original one. 2.4 GHz devices I have with Intel and Broadcom chipset are behaving much better but nowhere near how they should. I would say that this is more probably a design issue that might or might not be dealt with in a newer hardware revisions. Those who already bought one are probably out of luck.

All taken in consideration, I am very satisfied with purchase. Most devices I have are 5 GHz capable and they work wonderfully through my whole apartment. In furthest location I still have download speed exceeding 50 Mbps. Maybe it would go faster but my Internet pipe cannot handle it. Whether it will be as good when 5 GHz band gets congested as 2.4 GHz one well see in future, but I will enjoy it while it lasts.

Would I recommend it to someone else strictly depends on how bad do they need 2.4 GHz. If you are shooting toward 5 GHz this device is probably best bang-for-buck. For $120 you get a really capable CPU, lots of memory, and a variety of firmwares that can give you whatever functionality you desire. For somebody who likes tinkering with network this is god-given.

Alternative Boolean Syntax

I got into discussion with a friend on what is the best way to express boolean-like value in a C# initializer. Whole discussion was spurred by following piece of code (ok, not exactly this one, but similar enough):

var x = new FieldCollection(**true**);

This perfectly valid line has a magic boolean argument whose function is not immediately clear. Syntax-wise code is fine but readability does suffer. Neither one liked how this looked and we went into discussion about refactoring. First one was introducing an enumeration class:

var x = new FieldCollection(**FieldDuplicate.Allow**);

This is an usual approach to readability argument. Create an enumumeration that has (more or less) reasonable names and then use that as an argument. It allows for better readability at cost of a bit more coding.

But C# has something I find better. You can use named arguments to have greater visibility without any extra coding:

var x = new FieldCollection(**allowDuplicates: true**);

Maybe it is not as clean as a dedicated enumeration but I find it works for me. It doesn’t require any code changes inside of a class. It doesn’t require an extra enumeration declaration. And it works even when you don’t have access to code of a class. All that is needed is a bit of discipline upon calling code.

And programmers always have abundance of discipline… :)