f.lux - software to make your life better

Just came across a small piece of software, f.lux, that changes the color temperature for the displays when the night comes. It seems pretty interesting and the author says it is very helpful. I tend to agree, though some time to accommodate with the night settings might be needed.

On the f.lux page there is also a Sleep Research that might be worth reading.

The Open File Dialog Plurality

Open a Notepad instance and check how many threads the notepad.exe creates using the Task Manager. (If the Task Manager does not show the number of threads column in the Process tab, then enable it from the View > Select Columns... menu).

One thread and 1364 KB of memory (on a Windows 7 64 bits OS).

Now, in notepad open the Open File dialog (and keep it open), and check the number of threads again.

22 threads! And 9400 KB of memory.

Now cancel  the Open File dialog. A number of 18-21 number of threads will still be there!

Is this a waste of resources? Or is this an intended waste of resources?

WM_PAINT and WM_ERASEBKGND return values

It's funny that, the return values that represents that the message was processed for the WM_PAINT and WM_ERASEBKGND messages differ. From MSDN:

WM_PAINT:

• An application returns zero if it processes this message.

WM_ERASEBKGND:

• An application should return nonzero if it erases the background; otherwise, it should return zero.

So when you try to convince Windows not to repaint in any way one window (in which you render with OpenGL for example), you get some WndProc like this:

Bind to static ObservableCollection

Invoking anonymous methods in WPF

To execute some work on a Dispathcer, synchronously, the Dispatcher.Invoke method is used, which takes a Delegate as an argument representing the work to be done.

However, as stated on MSDN, the Delegate class is the base class for delegate types. However, only the system and compilers can derive explicitly from the Delegate class or from the MulticastDelegate class. It is also not permissible to derive a new type from a delegate type. The Delegate class is not considered a delegate type; it is a class used to derive delegate types. - Hence the need for the explicit cast to a derived-from-Delegate type.

Most languages implement a delegate keyword, and compilers for those languages are able to derive from the MulticastDelegate class; therefore, users should use the delegate keyword provided by the language.

Here are a few ways to synchronously invoke an anonymous method:

by declaring a delegate type and casting the delegate to it:

Starting with version 3.5, .Net contains an Action class that is defined like:

so it can be used:

by casting a delegate to an Action:

by casting a lambda expression to an Action:

by creating an instance of Action passing a delegate to its constructor:

Removing EventHandler from itself

Lambda expression offers a great way to write less code for registering event handlers:

But what if we need to remove the event handler after the WriteLine call, from the event handler itself? It is possible, if the lambda expression delegate had a name:

One problem with this though, when initializing the handler variable, inside the code that initializes it, at the line button.Click -= handler we access the handler which at this point is not initialized yet! So, to fix this, simply initialize it with null first (which might look a little bit awkward):

Managed GetLastError

When p/invoking a native method from managed code, it's not ok to call GetLastError to check for an error, because internally the .Net engine can call other API native methods who might override the last error you actually want from the method you invoke. The solutions is Marshall.GetLastWin32Error.