I have been doing .NET development for quite a while now. Sometimes people ask me how is it possible that I still find it interesting. Well, the answer is easy: I'm super D.R.Y. If you are not familiar with the term, you should look it up, but it
So let's say you have your own DbContext descendant with a couple of DbSet
properties that contain your entities and you also want to configure some of your entities. If you know EF, you probably know how to do this (and why to do it like this). Here's an
Dependency injection is awesome. I have written a lot of posts that start the same way; mostly because dependency injection is awesome. I'm not going into the details of why (I have already done that in those posts), let's just assume I'm right :) When using dependency injection, there is a
I have a little tool in the VS Marketplace called Dependency Injection Toolset. The idea behind the tool was to help developers who apply dependency injection regularly by making it easier to code constructor injection. The original version of the tool basically did two things: * Could generate a constructor for
Dependency injection is probably the best thing in software development since slide bread. I often blog about related things and I also have a Visual Studio extension to help those who apply the principles in practice. Guard clauses in constructors An important piece of best-practice is that whenever you use
My speciality is backend, but sometimes I have to do frontend as well. I don't really like it, but I guess that's life. Sometimes I even have to do frontend with ancient technologies like WPF. Again, I guess that's life. So a colleague of mine came to me wanting to
Dependency injection is awesome. And Autofac is probably the best DI-container out there. It's like magic :) I really like to fiddle around with special registration concepts, like here, here or here. Or down below :) Keyed service registration and resolving Autofac has a great set of features called implicit relationship types.
I'm not much of a UI guy, but sometimes I have to take part in projects that are front-end heavy. And sometimes this means desktop front-end (there's still a surprisingly heavy demand for these kinds of application). The application I've been working on lately is riddled with pages and menus
Sometimes I do these posts where I describe an interesting question on SO. And sometimes I do posts about dependency injection and dependency injection containers. Well, this time, these two series cross-over (the Avengers of blog posts :) ). So Autofac has a number of nice features described as implicit relationship types.
Yes, you've read it right: in this post I will show you how to inject arguments to method calls and create something like a 'method call' scope. It's not perfect and there are a lot of things that still need to be considered more carefully, but I was really excited
I teach courses about general OO design. One of the classes involves going through all the GoF design patterns. For the last couple of years, I have a new appreciation for the Chain of responsiblity pattern. As I see it, every middleware based arhitecture is kinda-sorta a Chain of responsiblity,
I have a little tool published at the VS Marketplace called DependenyInjectionToolset. It's not much; all it does is what its name says: * If you have a constructor parameter that is of an interface type or abstract class type, you can create a private readonly field. * You can generate a
So a while back I was presented with an interesting task. It is not uncommon that if you have some code, it starts to evolve over time. You introduce changes — and with the changes a new version of your code is born. And this presents many challenges. The challenge that