One good reason for preferring a singleton over a static class (assuming you have no better patterns at your disposal 😉 ), is swapping out one singleton instance with another. For example, if I have a logging class like this: public static class Logger { public static void Log(string s) { … } } public … Read more
The default solution to DI when you can’t wire up a concrete type at registration time is to use an Abstract Factory In your case, I would define an IFooFactory interface: public interface IFooFactory { Foo Create(DomainClass dc); } This will allow you to define a concrete implementation that knows about your infrastructure services. public … Read more
First of all, I would suggest you to read about the Abstract Factory pattern, for example here. Now I will try to explain why you would use this pattern. Normally, if you use the Factory pattern, you will create objects in a Factory. The problem arises when you have multiple implementation of a given class … Read more
The way I describe this difference to my colleagues is that state patterns are a more decentralized implementation of many stand alone encapsulated states whereas state machines are more monolithic. The monolithic nature of state machines means that a single state will be harder to reuse in a different machine and that it is harder … Read more
The core portion of the Builder pattern concerns the Abstract Builder and its subclasses (concrete builders). According to GoF’s Design Patterns, director simply “notifies the builder whenever a part of the product should be built”, which can be perfectly done by the client. The StringBuilder class in the Java API is an example of a … Read more
I will speak mainly from the perspective of using the abstraction to insulate application code from a particular logging framework. There are other factors that can affect one’s choice of logging framework or one’s choice of (and requirements for) an abstraction. I have spent a lot of time recently evaluating various logging frameworks as well … Read more
I think the following answer is more along the lines of what you are looking for: You should look at applying the Template Pattern (Template Method in “Design Patterns” [Gamma, el al]) In short it’s overall processing looks like this: If the arguments to the program are valid then Do necessary pre-processing For every line … Read more
Sounds like you’re after the mediator pattern – which can be thought of as a ‘manager’ of the objects that it deals with.
A while ago when I was assigned to work on such a system, I found this link in the Martin Fowler website: Martin Fowler – Accounting Patterns It contais some patterns for accounting software, such as accounting entries, transactions and adjustments. The architecture he describes is based on events. Never read it entirely, as the … Read more
I’ve referred to it as “asynchronous function queuing”, but its not quite a catchy name, and certainly not the formal name of the design pattern. What’s interesting is that, though I hadn’t seen this particular pattern used before, since Google adopted it for Google Analytics, its been adopted widely by different platforms looking to nab … Read more