Spam really gets everywhere, the screenshot on the right is from the Tags box in the front page of DotNetKicks, a Digg-like online community dedicated to .Net programmers.
Spam really gets everywhere, the screenshot on the right is from the Tags box in the front page of DotNetKicks, a Digg-like online community dedicated to .Net programmers.
Unity is a pretty neat piece of work, it’s a simple and straightforward dependency injection container and it gets the job done, which is all you want from any implementation like this.
If someone’s trying to go beyond the “get an implementation instance for a given interface” examples found in most of the tutorials then proper dependency injection will be the way to go. This means returning the proper instance for the given interface, but also properly the objects that instance needs, and also the objects needed by those objects, and this could go on forever. Unity can do this almost automatically, but to do so it may need hints on how objects should be created, specially to choose the right constructor when multiple are available (by default will choose the fatest of them all).
One of the ways this problem is solved is using an attribute that indicates which constructor should be used (the same is valid for either properties and method calls), as shown below:
public class MyClass
{
public MyObject(SomeOtherClass myObjA)
{
...
}
[InjectionConstructor]
public MyObject(MyDependentClass myObjB)
{
...
}
}
The problem is: Unity, and all other dependency injection containers, want to solve a simple issue: reduce coupling between modules, classes, etc. That’s achieved by removing the dependency to the proper implementation, you only have to know the contract to use (the interface) and the dependency injection container will return the proper implementation, whatever that may be. But, by doing this we’re adding another dependency: to the dependency injection container implementation (like Unity), and while this is reasonable for the class that needs to use the container is not so reasonable for the classes the container will use.
Take the code sample above: MyClass is just a plain class, by adding the InjectionConstructor attribute we’re adding a needless dependency because that class will never use Unity, it will be used by Unity. For me using this can be a design flaw that goes against what dependency injection is supposed to achieve. A safer, but more time consuming, way to get around this is to explicitly configure those dependencies (either in design time or run time) instead of letting Unity try to figure them out.
Share this: |
|
|
|
|
|
“WCF started with a clear bias towards SOAP, WS-* protocols, and other heavyweight standards that were being popularized at the time but had not been ubiquitously adopted.
(…)
I didn’t believe though that you could force the world to use a single approach for building web services.”
Nicholas Allen
Windows Communication Foundation has to be one of the most interesting pieces of the .Net universe released in recent years, mostly for being a huge improvement over the previous web service model in .Net. So when one the minds behind WCF writes about the framework’s future it’s certainly worth a closer look.
Some time ago I wrote about GetHashCode method and now Paulo Morgado has also faced some “hash related” issues to deal with (also in Portuguese). Again, the reminder should be not rely heavily on GetHashCode.
Recently I ran into some unexpected, and rather strange, issues on an application server using the Enterprise Library 2.0 Cache Application Block. Apparently there were occurring some strange collisions while retrieving the data from CacheData (the table where the cached data is stored) where the same cache key was having multiple entries, something the Dictionary container where the data is stored isn’t too happy about. The guys at Patterns and Practices, for performance issues, don’t use the cache key as a primary key for that table, but a much more efficient and more easily “indexable” integer, which, in this case, is being calculated using the GetHashCode of the cache key. Usually the GetHashCodeimplementation isn’t a fully blown hash algorithm (unlike the more robust MD5 or SHA) so I allways doubted of the uniqueness, particularly in this case where the application server was moved from a 32 bit to a 64 bit architecture, nothing a quick trip do the good old MSDN wouldn’t confirm:
Remarks
The behavior of GetHashCode is dependent on its implementation, which might change from one version of the common language runtime to another. A reason why this might happen is to improve the performance of GetHashCode.
This basically means you shouldn’t trust GetHashCode, because the result for a given string can, and surely will, be different depending where you are calculating it, namely between 32 and 64 bit architectures. The main lesson to be learnt here is GetHashCode, either for String or any other type, should only be used for disambiguation of entities in runtime.
James Carr has compiled a pretty little list of Test Driven Development Anti-Patterns and posted it some time ago in his blog. I have to admit I’ve done some of them once or twice.
TDD Anti-Patterns [via ISerializable]
Technorati Tags: tdd, test driven development, unit testing
Jelle Druyts has released a neat little tool for Visual Studio that allows to easily design and visualize the configuration for a .Net solution, without messing around with ConfigurationSection and ConfigurationElement source files, which is quite handy when things become a bit more complicated. It’s still is in an early stage, but it looks rather promising.
Hey, now I can debug the .Net framework or, in other words, now I can’t blame the framework every time I have a problem.
.NET Framework Library Source Code now available – ScottGu’s Blog
The next version of Microsoft’s Enterprise Library will include several improvements on the existing blocks and, this is the cherry on the top, a lightweight Dependency Injection container (or Inversion of Control, if you prefer it this way), probably much like the core of Spring.NET.
Enterprise Library v4 Product Backlog
Technorati Tags: lightweight container, dependency injection, enterprise library, inversion of control, spring
A new year is now beginning and that usually means New Years Resolutions, so here are mine, just the geek oriented and in no particular order:
There’s nothing like turning your New Year resolutions public, or at least part of them…