Summary: For about 1 million active users and 150 million stored activities, I keep it simple: Use a relational database for storage of unique activities (1 record per activity / “thing that happened”) Make the records as compact as you can. Structure so that you can quickly grab a batch of activities by activity ID … 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
Most examples I’ve seen use a variant of the Command-Pattern for this. Every user-action that’s undoable gets its own command instance with all the information to execute the action and roll it back. You can then maintain a list of all the commands that have been executed and you can roll them back one by … Read more
I’m currently playing around with the Boost.Enum proposal from the Boost Vault (filename enum_rev4.6.zip). Although it was never officially submitted for inclusion into Boost, it’s useable as-is. (Documentation is lacking but is made up for by clear source code and good tests.) Boost.Enum lets you declare an enum like this: BOOST_ENUM_VALUES(Level, const char*, (Abort)(“unrecoverable problem”) … Read more
A design pattern is a common way of solving a recurring problem. Classes in all design patterns are just normal classes. What is important is how they are structured and how they work together to solve a given problem in the best possible way. The Facade design pattern simplifies the interface to a complex system; … Read more
The difference may seem slight, but even with the ServiceLocator, the class is still responsible for creating its dependencies. It just uses the service locator to do it. With DI, the class is given its dependencies. It neither knows, nor cares where they come from. One important result of this is that the DI example … Read more
The Decorator Pattern is used for adding additional functionality to an existing object (i.e. already instantiated class at runtime), as opposed to object’s class and/or subclass. It is easy to add functionality to an entire class of objects by subclassing an object’s class, but it is impossible to extend a single object this way. With … Read more
Abstract Factory is a very central design pattern for Dependency Injection (DI). Here’s a list of Stack Overflow questions where application of Abstract Factory has been accepted as the solution. To the best of my understanding, these questions represent real concerns or problems that people had, so that should get you started with some real-life … Read more
it solves this concrete problem: you have a, b, c, d of 4 different types. all over your code you have something like: a.Process(); b.Process(); c.Process(); d.Process(); why not have them implement IProcessable, and then do List<IProcessable> list; foreach(IProcessable p in list) p.Process(); this will scale much better when you add, say, 50 types of … Read more
Hope this helps. It describes the various types of factories. I used the Head First Design Patterns book as my reference. I used yuml.me to diagram. Static Factory Is a class with a Static Method to product various sub types of Product. Simple Factory Is a class that can produce various sub types of Product. … Read more