Enterprise Library 5 – what’s on your wish list?

We’ve started our planning of the Enterprise Library 5. This is your chance to send us suggestions, comments, screams... These may include ideas for new blocks, new providers for existing blocks, integration with new .NET Framework 4.0 features, improvements to the design-time experience, performance improvements, support of specific deployment/operations scenarios, documentation/training support etc.

I am going to use the same technique Tom employed several years ago soliciting feature requests for EntLib3. It seemed to work quite well then. So, imagine you have a sum of money that you can invest in developing EntLib 5. Say $100 (or should I index the amount to be more like a stimulus package? 🙂 In any case, when suggesting your features, decide how much of that $100 you want to spend for each feature. You can split $100 any way you want. If there is only one feature you want to spend all your money on, you can do it too. Please stay within the budget. Also, be specific – explain your scenario in detail, provide some context, make your case potentially appealing to other users of EntLib. Do remember, however, that EntLib has been and will be a general purpose library of reusable components that are architecture- and application domain-agnostic.

Once we gather your feedback, we will publish the list of feature requests and invite you to prioritize them.

Feel free to post your suggestions as comments on my blog or simply email me. Look forward to your propositions!


Comments (55)
  1. It’s that time again – the kick-off for the next major release of Enterprise Library. I can’t believe

  2. matthijs.krempel@hotmail.com says:

    I would like to see WPF integration for Validation.

    It was a pain to integrate the two.

  3. samstapin says:

    How about a scan feature on Unity (convention over configuration) similar to that on StuctureMap.  I did a project with a lot web pages using Unity and my Unity Configuration section is enormous.

  4. Here is my list:


    1. Multiple configuration sources for configuration sections?

    2. Merging of configuration files at the runtime?


    1. Integration with entity framework


    1. Integration with azure services

  5. Comienza el planning para la Enterprise Library 5.0

  6. Enterprise Library 5.0 is being planned, if you want to "be part" of the planning team you can do it!

  7. Planning on Enterprise Library 5 has started! See Gregori’s blog for more information if you want your

  8. MichaelGG says:

    My only comment, having looked at EntLib a few times and given up, is to make the config easier. The whole system is so unapproachable and complex seeming… It’s great to have Some Block use Another Block and need the Config Block to configure whatever etc etc. But a simplified, quick, get-going would be very helpful. For instance, look at, say, log4net. Minimal config impact, real simple, straightforward.

  9. sitty says:

    1. DAL Intergration with Entity Framework

    2. Simpler Config Files.

  10. Peter Ritchie says:

    I would spend the $100 on productizing Entlib.  Treat it as a product, provide better support for it (not just community-based) over several versions.  Don’t assume people will just take a drop and start modifying it for their needs; also assume people will use it as a product and not modify it.  These are the people that need support on how to use it, and technical support for it through their entire lifecycle.  If they run into a problem with it two years after its release and can’t get support for it, they’re not going to want to use the next version and get bitten by that again.

  11. IEnumerable says:

      I would include  some utility for helping the user create custom configurations. With no help, you are on the hook for multiple classes, xml section, and xml data elements for this. And it is not trivial.

       As in the URL I included with this post, a configuration wizard for creating elaborate configurations in the Web.config and App.config.  Visual Studio should include this as a feature.

    Also.. SQL server-based configuration could be improved.. or actually fleshed out do that you don’t need Allois Krous to get it to happen?

    I would ask others in this thread, have you not used the GUI that ships with, EntLibConfig.EXE,  to configure things? It really is not that complicated? I find most mistakes happen when people insist on Notepad over the GUI tool for editing configurations.

  12. MichaelGG says:

    RE: EntLibConfig — sure, it’s very handy. But the fact that I have to configure a "Configuration Block" just to get some trace statements is what scared me.

    Also, all that config that the GUI generates — ends up in my config! Now we’re responsible to make sure it’s correctly configured, setup, etc. when we go to deploy things. Maybe for big "enterprise" apps this is just one more cost that’s acceptable.

    WCF has the same issue if you decide to configure by config file. Sure, there’s a GUI, IntelliSense, etc. But managing a set of apps with 5 services that connect to each other becomes a major pain. Fortunately, WCF allows easy config via code.

    The difference with WCF is that it’s a major, powerful platform, so it can justify a bit of up front time. If I just want some cute parts the ent lib offers, and I just need some simple functionality, I’m not willing to invest the time to "figure it all out".

    Maybe we need a non-enterprise version of EntLib.

  13. Alois says:

    I would be all my money on a non broken version of the Entlib config tool.

    70$) The tool should be more generic and not break immediately when I add the first custom e..g logging filter or formatter. It should be able to display the nodes which do not have a .Design.dll in a meaningful manner. e.g. Key/value pairs.

    30$ It should be possible to configure the whole set of constraints via one xml file so we do no longer need this myriad of .Design.dlls. That would make it much easier to add new extensions which can be configured nicely.


      Alois Kraus

  14. cachet says:

    Here is my list:

    1. WPF & Silverlight integration for Validation

    2. DAL Intergration with Entity Framework

  15. i96danma says:

    $70: Simple way to do dynimic conf for, among others, end user configuration of logging.

    $30: An intermediate auth provider, complexity wise in between the exisitng rule provider and az man. An ACL implementation would be nice since there is ample supply of code and infrastructure

  16. rferj@hotmail.com says:

    Based on my experiences since the 3.0 version, I would include:

    1 – ODP.NET support on both the Data library and the Logging library.

    2 – Extended and improved support on the AzMan wrapper, mainly for the purposes of read tasks and operations and also for dealing with groups. The documentation for this feature also could be much better.

    3 – I would try to reduce the verbosity of the .config file generated for the enterprise library.


  17. c0sm0 says:

    I can’t speak for other parts of EntLib, but our organisation would benefit from Silverlight support for Validation.

  18. ewdev says:

    My list is:

    $50: Integrate the Resource Application Block from Enterprise Library Contribution.

    $30: Some form, of Query Application Block that allows for Commands and Parameters to be built from configuration OR integration with the Entity Framework

    $20: Unit tests that all work under Vista – or at least documented what permissions you have to set up to get them to work.


  19. devnet247 says:

    Having used the enterprise Library without nobody in the team having used it before,I found quite difficult to get started to configure for Real World use.It seems to be a "black art".

    $30 Improve Support  and we need  Examples,Examples .small simple applications would be fantastic. ,Books and apps out there for download are not that good and well out of date. Update your "Hands on Labs". What about a "101 Enterprise Library".

    Lets be honest if you want people to use it you got to teach them.

    $30  Config Files. We use 1 config File x Layer to separate the concerns and make more maintanable.I wish the Editor could handle this better.

    $40  In previous version you could generate stuff ,"Application Software factory" am I wrong? you cannot anymore.What about introducing some tool that you can generate stuff to integrate with DAL etc…

    using T4 templates that we can easily edit.  IN the real world we are still using DataReaders and populate object that way.Linq To Sql is sort of Dead,EntityFramework ,many companies dont have that luxury to convert massive big apps to use it.


  20. Here are my 100$

    20$ Make possible to have a centralized configurations for many applications. (Now you can do it but all the logs are written into the same file, the event log end up in the same source) The desired effect would be to have a central configuration file but each application have a unique event log source, each application have a log file…

    30$ Make easier and document how to extend the application block. The GAT/GAX addins are great to create new AB and some providers. But if you want to Add/remove some of the functionality you need to code some not documented methods/classes and debug the code to see how EntLib works under the hood.

    30$ Policy Injecton AB. Enhance the non-intrusive injection. Implement an interface or deriving from MarshalByRefObject is very restricitive.Maybe Dynamic types can help here…

    20$ Make Data Access AB compatible with Entity Framework.

  21. Guy kolbis says:

    Grigori Melnik, who is the PM for EntLib over in Patterns & Practices, posted about planning version

  22. suedeuno says:

    De-bloat EL. I don’t use it because there are open source alternatives that are much simpler and leave a smaller foot print.

  23. JonnyBoats says:

    40$ better documentation, videos etc.

    60$ a party for the hard working team that produces this great product!

    Thanks for all your hard work.

  24. Ken.Saraf says:

    30$ – validation block support for entity framework, simplified middle tier validation and WPF. All we need is a way to say: this is what we want to validate (any variable in any class), this is the message template and then we can choose to log it or send it back to client etc. Should be integrated with logging and exception block to simplify all this tedious work.

    10$- templates for exceptions block that will accept parameters so we won’t have to right the ame exceptions again and again with only one word changing.

    5$ – simplified logging API. Two lines of code for each log line is too much…

    30$ – Authentication & Authorization block with built in integration with ADAM, roles and permissions. Integrated with WCF security configurations.

    30$ – WCF block – for frendlier configuration client proxies and the like.

    And please don’t let us wait a year for that, We need it yesterday 🙂

    Thank you.

  25. First of all, thanks to all people who have provided their inputs to the EntLib5.0 backlog (please keep

  26. SpoonsJTD says:

    $20 Analysisdesignimplementation for what it would take to start creating ‘editions’ of EntLib, where an edition is a set of configs and providers specialized for certain environments, like …

    $80 An edition of entlib for SharePoint-as-a-platform application development

             * Config providers that use farm, web app, site collection, site storage for config

             * Solution(s) for deploying ent lib to a farm

             * Logging providerconfig that writes to SharePoint logs

             * SharePoint based configproviders for Security Block

             * Resource app block included in 5.0 and providers created to support SharePoint resource mechanisms


  27. prasadwt says:


    I would like to know whether can we implement the Ver5.0 in MOSS 2007?



  28. sergejus says:

    Hey Grigory. As we discussed during TechEd Developers EMEA 2008 (I’m that guy from Lithuania):

    40% – guidlines / API for using Validation Block inside LINQ-to-SQL, EntityFramework, ASP.NET MVC

    30% – UI tool for the Unity XML configuration + API for the convention over configuration

    20% – more intuitive UI tool for the EntLib configuration

    10% – get rid of outdated / rearely used application blocks

  29. vs2005junkie says:

    Provide default timestamp formatting for the Logging application block as described in your blog article:


    This will reduce one additional step in customizing/overriding our own timestamp tokens.  

  30. vs2005junkie says:

    Currently, the Enterprise Library configuration tool opens up external configuration files that are hooked in through an App.config or Web.config file.  However, when these changes are saved/re-committed back to the file, the information is not persisted back to the individual external configuration files specified in the configSource attribute.  Instead, the entire configuration file is replaced with the new settings, thus removing the configSource attributes for each of the configuration sections.

  31. freshr says:

    When writing logging trace listeners, why do I have to inherit from CustomTraceListener? This is an unfortuante limitation, as I might just be wanting to extend one of the existing trace listeners and end up having to write a facade instead of inheriting directly.

    Also, it should not be up to the trace listener itself to perform the filtering and formatting of log items. I think the single responsibility of a trace listener should be to take a message and write it verbatim to a stream or location.

    The following method is required in EVERY custom trace listener to get them to work with the rest of the framework… not pleasant.


           public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, object data)


               if (!(this.Filter == null || this.Filter.ShouldTrace(eventCache, source, eventType, id, null, null, data, null)))




               if (data is LogEntry && this.Formatter != null)


                   _eventLog.WriteEntry(this.Formatter.Format(data as LogEntry), GetEventLogEntryType(eventType), id, 0, new byte[] {});




                   _eventLog.WriteEntry(data.ToString(), GetEventLogEntryType(eventType), id, 0, new byte[] {});





    Thanks for asking for feedback!

  32. b3nj1m4n says:

    much greater support and documentation for purely programatic configuration.

    I really don’t like being restrained to config files and have run into situations where when 3rd party class libraries call my class libraries – they expect to find an entlib config file in the other guys class library – hence the need for programatic configuration my end – which appears to eliminate the problem. However, I find it’s not easy to avoid an app.config as almost all documentation resources depend on xml configuration.

  33. simon.hardy says:

    $40 – Online community similar to ASP .NET (http://www.asp.net/).  Include how-to videos, examples, support.

    $20 – Full integration into Visual Studio 2008+, so the relocation of the config tool and some VS Library entries with examples.

    $20 – Data Application Block integration with the Entity Framework.

    $10 – Silverlight validation.

    $10 – Ability to have a different config file for each block and merge them all at build/runtime.  If config integration into VS2008+ is achieved this could just be separating tabs under the existing VS GUI config file editor.

  34. LilKamisen says:

    In LAB, using Email Trace Listener:

    – add a credential configuration that allows the listener to log in using POP3 before sending using SMTP (needed by some SMTP servers)

    – add an SSL option to be able to send emails using a secure SMTP server

    Best regards!

  35. cramhead says:

    I agree with LilKamisen, i.e. EmailTraceListener what allow authentication and potentially ssl.

  36. Rhinof says:

    $70 – Activerecord  implementation.

    $20 – remove the policy injection block and merge it with the unity block.

    $10 – make config administration less painful.

  37. ANegm says:

    may be they mentioned before but for sure:

    1. WPF & Silverlight integration for Validation Application block.

    2. DAL Integration with Entity Framework

    3. make config administration less painful.

  38. DanAvni says:

    an expansion of the logging module to support this scenario:

    i have an application that uses multiple threads (some using regular threads and some using the thread pool). all of the threads log data to a log file leading to a spaghetti style log file (to follow the execution of a thread i need to find all of it’s entries in the log file which are among other entries from other threads).

    my solution: add a concept of context to the logging block or to the file listener specifically. each thread as it start will call the logging block and tell it to CreateContext and sent it some string as the ID of the context. when logging entries, the thread will be able to send a parameter specifying that the entry is related to some context ID (if no context is set a default context is used). entries to the default context will be sent to the file listeners immediately. entries to another context will be buffered until the context is closed, the app is closed or the the log file is rolled over. when any of these conditions occur, the entries are all sent to the file listener together. i want to emphasize that while i do want the data to be buffered in each context, i would still want each entry formatted according to the config file so i will see when each entry was created.

    the main idea is having all of the context written to the log file as a block and this way i will be able to add in the config to write some horizontal line between contexts written to the log file and my life would be much easier.

  39. bab5139 says:

    The validation block is unusable with third party object relational mappers and this should be addressed in the upcomming release.  

    It is unusuable for two reasons.  First, the validation block is really only effective when using attributes or configuration files.  Attributes cannot be added to the entities as the code is regenerated each time the data stucture is changed.  Configuration files are a waste as the meta data to supply the validation is already contained in the generated code and it would be a manual process to sync the two.  

    Either one of two things could be done.  Allow us to override the ValidatonFactory or provide a ValidorBuilder interface so we can provide the implementation.  The second would require a rework as ent 4 lib has internalized and privitized all of the validatorbuildercreators and helpers.  Therefore we can not create a validator that validates a property or field of a class with a lot of work.  

    BTW – start opening up the ent frameworks and let us supply our own implementation sometimes so we don’t have to rewrite your code.

  40. kasajian says:

    I think it would be useful to have a common service for decoupled components.

    So, instead of doing "IFoo foo = New Foo()"

    We need a service factor, so this will do the same thing: "IFoo foo = somefactory.create();", creating an instance of Foo.   However, when if IFoo and Foo are in separate assemblies, the client only has to reference the assembly containing IFoo, not Foo, thus breaking the build dependency in such a way that Foo no longer has to be build prior to the client that instantiates it.

    This can be currently done with Unity and putting the configuration file in app/web.config.   However, when I step through the code that to do just that, there seems to be a lot of stuff going.   To justify that code such as this:

    IFoo foo = new Foo();

    is now going to get replaced with 50+ lines of various interceptors, lifetime managers, etc., is simply not a feasible option as a standard to apply across the enterprise.

    One example we came up with is to add a factory class to the same assembly that contains IFoo that looks like this:

       public class FooFactory


           public static IFoo CreateInstance()


               return (IFoo)Activator.CreateInstance("FOO, Version=, Culture=neutral, PublicKeyToken=null", "Foo").Unwrap();



    Note that "Foo" is in quotes, which means it doesn’t need the assembly that contains class Foo to exist to build the assembly containing IFoo.  Thus building the client only requires IFoo’s assembly, and the assembly containing Foo can be built later.

    I’m sure you guys can do much better than the above, but without adding a lot more overhead, and may be it can even be driven through an XML file.   It’s okay to incur overhead the first time the class is instantiated, but not subsequent times.

    The bottom line is that we need a very fast an efficient way to do 5% of what Unity does.


  41. Kentzhou says:

    I expect two versions will be released for this 5.0:

    One is tradition version with no number 5.0, give it $70.

    One is the version for silverlight, give it $30.

  42. kevin@solutionswork.co.nz says:

    $100? WCF configuration improvements $60, WCF debugging $40.  WCF is incredibly powerful – I salute  the propeller heads that came up with the unified framework, but all day I curse the return to the text editor for development and run it and see if it works debugging – sounds like the 80s again (and yep – I’ve been developing for longer than that 🙂

    I am working on a SOA solution with ASP.Net presentation, SAP, GeoMedia & Trim backend application servers and a hole mess of security.

    WCF has extensibility has been used to exchange Kerberos tokens for SAP authentication tokens and injecting them in outbound SAP calls to allow single sign on across the boundaries.  SAP tokens have also been validated in WCF extension points to extract the username for delegation.

    The challenges have all been configuration and testing the results.  Better tools are required to validate the configuration before runtime and to allow debugging of the configuration at runtime. (how you could do this I have no idea) but the run and see if communication still works is such a primitive way of debugging the errors.

  43. rjperes says:


    It would be nice to have a configuration editor for Unity, like there are for all the other application blocks. It also would be nice if you could include the XSD files for all configuration sections, so that we can have intellisense on Visual Studio, if we don’t want to use the editors.


    Ricardo Peres

  44. rjperes says:

    What about externalizing the code generation, so that we can use it in another projects that require dynamic code generation, like LinFu and Spring.NET?


    Ricardo Peres

  45. rjperes says:

    Here is my last suggestion (for today, at least): what about a LINQ Application Block that would allow developers to create LINQ providers to heterogeneous data sources?

    Yes, I know there are already some out there (the LINQ IQToolkit comes to my mind), but that could be said for all other application blocks.


    Ricardo Peres

  46. The guys from the Enterprise Library development team are taking feature suggestions for the upcoming

  47. koistya says:

    – I’d like to see better integration capabilities of Validation Application Block with ASP.NET MVC validation mechanism.

    – Add more functionality into Unity and make it more like StractureMap

    – Update Data Application Block, so it could be more easly used with ADO.NET Entity Framework

    – Improve EntLib Configuration UI

    + create a sample ASP.NET MVC application with thorough EntLib integration, which could be served as Best Practices for ASP.NET MVC + EntLib applications.

  48. dikonikon says:

    I’d allocate 10$ of my budget to enhance Unity to support cyclic dependencies in containers, including simple mutual dependencies like the following. There are a lot of common use cases that require this, and at the moment Unity throws a stack overflow when these are defined.



             <type type="One" name="one">

               <lifetime type="singleton" />


                 <property name="TwoProp" propertyType="Two">

                   <dependency name="two" />




             <type type="Two" name="two">

               <lifetime type="singleton" />


                 <property name="OneProp" propertyType="One">

                   <dependency name="one" />







  49. horn@semantico.de says:

    – a version for silverlight !!!

    – remove the policy injection block and merge it with the unity block.

    – Unity Conig UI

  50. Christos Karras says:

    (These are based on my experience with EntLib 3.1 and parts of these may already be available in more recent versions)

    1. ($5) Package complete Enterprise Library as a single assembly (using ILMerge).

      Fully qualified references to .Net assemblies in XML config should reference the ILmerged assembly.

      The main benefit of this is that it would make upgrading to newer versions easier.

      (Instead of looking for 20 references spread in .csproj files, configuration files, build script

       configurations,…, there would be only one reference to update in all these locations)

    2. ($95) Reduce verbosity of configuration

      * Implement distinction between "behavior configuration" and "infrastructure configuration"

        For example, the following "table" contrasts the two types:


           Behavior configuration                   | Infrastructure configuration

           Security rules                           | Authentication server name

           IoC                                      | None

           Policy injection                         | None

           Validation rules                         | None

    Log format                               | None

           Log destination (file, email, event log) | Log file path, email address, smtp server


        * Put infrastructure configuration in .config files

        * Put behavior configuration in .Net code (using fluent interface/C# internal DSL)

        * Alternatively, allow users to decide which configuration they put in .config files

          and which configuration they put in .Net code

          (depending on what they want to allow to change at runtime)

        Environments "dconfig" is a great start, but it still produce verbose configuration files.

      * Minimize the need to repeat fully qualified assembly name in configuration nodes

        (Referencing .Net classes in the "behavior configuration" defined in .Net code instead

         of referencing them in XML would greatly help for this)

      * For infrastructure configuration, allow "Configuration by exception"

        (EntLibConfig GUI should only write values that are different from the defaults)

  51. zihotki says:

    $40 for fluent interfaces

    $30 for WCF

    and $30 for "101 Enterprise Library", e.g. many small samples

    and $100 from my pocket for improving community, site to be like asp.net one.

  52. How about Asymmetric encryption support?

  53. $60 – Entity Framework integration.

    $40 – Unity block for injection.

  54. Guy Bertental says:


    I would really like to see new important features in the Cache App Block like:

    1. cache items hierarchy – where i could group items in cache (or even groups of groups of items) under the same key and delete them all at once by this key.

    2. cache synch between load balanced servers while cache is stored in-proc per sever. the synch could be simply by deleting same item (or group of items) in other servers while it’s being deleted in the first server.

    Best regards,

    Guy Bertental

  55. Saied says:

    Start using it 🙂

Comments are closed.

Skip to main content