Event Tracing for Windows (ETW) has been around for a while now, but many (if not most) developers have never used it. I’ve primarily used it for performance tracing, and it’s flexible enough to be used for logging regular application events as well.
In part 2 of this series I made a case that switching from Stateless Single-Responsibility Objects to delegates and static methods lets us write simple, pure functions and lets us remove a lot of boilerplate. Nevertheless, there was still one bit of boilerplate I hadn’t yet removed. It dealt with encapsulating dependencies to a method […]
In my previous post on the Stateless Single-Responsibility Object (SSRO) approach to C# application composition I reviewed the concept and its shortcomings. To recap: You end up with a ton of classes splitting up semi-related logic across multiple files. This is necessary to conform to the classname == filename convention. In order to mock, you […]
Functional code is easier to test than code with state or side effects. However, most developers spend the majority of their time in traditional, imperative languages. There’s plenty of value in those imperative languages, but these days when I use one, I also try to bring in applicable functional concepts. In this post I will […]
It’s one thing to develop and test a Windows application; it’s quite another to bundle it up into a nice executable that installs correctly on all the different Windows versions that you need to support. I’d like to guide you through the process that I wish I had when I was creating my first installer.
Any realistic application is hard to test. Often much of the complexity is unavoidable, but sometimes things are harder than they need to be.
I’ve recently been working on a .NET web application. We are mainly a Mac-based development shop at Atomic, so I’m working on this application in a virtual machine. My weapons of choice are VMWare Fusion and Visual Studio 2012 (not much of a choice), but that is neither here nor there. Our application uses the […]
I’ve been happily using the Ninject Dependency injection library on my C# project for over a year. In order to keep my project even reasonably organized, I quickly started using Modules to group together my dependencies. For the most part in my project, my Modules correlate to the first layer of namespaces beneath the project […]
I ran into a situation the other day where I had to turn on/off the visibility of a text run in WPF, and I discovered that text runs do not have a visibility property. Whenever I run into a situation where I need to add functionality to a control, I always turn to attached properties […]
Writing C#.Net async code can be a bit of a challenge, and writing tests around the code can frequently cause much pain and agony. In fact, conventional wisdom around the Internet seems to be that writing async tests is hard enough that it’s okay to avoid it. I disagree. Writing tests has enough benefits (most […]