David Hayden

Enterprise Library 5 ConfigurationSourceBuilder and Fluent Interfaces - DAAB Example

I am not a huge fan of XML for configuration, but I also don’t want to go crazy with fluent interfaces when a bit of XML will do the trick. Hard to say when I prefer one over the other at times so it is always nice to have the option of XML or a fluent interface.

One of the nice features in Enterprise Library 5 is the option of a fluent interface to configure your application blocks. I have briefly played with the fluent interface to configure the Data Access Application Block, which is probably one of the simplest to configure. I am not qualified to judge the implementation of the fluent interface at this point so I will mainly just point out some quick findings and show some code.

ConfigurationSourceBuilder

ConfigurationSourceBuilder seems to be the main class involved with building configuration information using a fluent interface. It looks to me that each block adds an extension method to this class to fluently configure that application block. In the case of the Data Access Application Block, it adds an extension method, called ConfigureData(), to ConfigurationSourceBuilder that allows you to fluently configure the DAAB. Once you are done configuring all blocks, you essentially build the configuration source and then use it to populate your container.

That is clear as mud without an example, so here is a quick bit of code using ConfigurationSourceBuilder, ConfigureData(), DictionaryConfigurationSource, and EnterpriseLibraryContainer to set-up the IoC Container and use it to get at the default database as well as a named instance:

var builder = new ConfigurationSourceBuilder();

// Extension Method
builder.ConfigureData()
      .ForDatabaseNamed("Test")
        .ThatIs.ASqlDatabase()
        .WithConnectionString("...")
        .AsDefault()
      .ForDatabaseNamed("Test2")
        .ThatIs.ASqlDatabase()
        .WithConnectionString("...");

// Create ConfigurationSource
var configSource = new DictionaryConfigurationSource();
builder.UpdateConfigurationWithReplace(configSource);

// Set Container
EnterpriseLibraryContainer.Current
  = EnterpriseLibraryContainer.CreateDefaultContainer(configSource);

// Get Default Database
var database = EnterpriseLibraryContainer.Current
         .GetInstance<Database>();

// Get Named Instance of Database
var database2 = EnterpriseLibraryContainer.Current
         .GetInstance<Database>("Test2");

Pretty straightforward really. If the EnterpriseLibraryContainer throws you a bit, read a little about IServiceLocator at EnterpriseLibraryContainer and IServiceLocator in Enterprise Library 5. This is just Microsoft Patterns & Practices attempt to let you use the IoC Container of your choice ( Autofac, Ninject, Windsor, StructureMap, etc. ) from within Enterprise Library.

Conclusion

I want to play with the fluent interface in Enterprise Library 5 a lot more, but indeed, I already love the simplicity of it compared to what we had to do in the past to configure various application blocks in code. Between this and the new GUI Configuration Editor in EntLib 5, things have certainly changed a bit with regards to configuration.

For those developers who have yet to consider fluent interfaces or don’t see the value, the XML configuration is still there and I doubt that it will be going anywhere anytime soon.

Hope this helps.

David Hayden

IResultSetMapper in Enterprise Library 5 DAAB

Hopefully you have read my other posts on Enterprise Library 5 DAAB for a bit of background as this post is going to be very quick and to the point:

• Database Accessors in Enterprise Library 5 DAAB - Database.ExecuteSprocAccessor
• EnterpriseLibraryContainer and IServiceLocator in Enterprise Library 5
• Database.ExecuteSqlStringAccessor and LINQ in Enterprise Library 5 DAAB
• IRowMapper via MapBuilder and Mapping Properties in EntLib 5 DAAB

IResultSetMapper

As mentioned before with regards to IRowMapper in Enterprise Library 5 DAAB, there are times when you need a bit more control over how to map the results being returned from the database to individual entities and/or the entire resultset.

When you need to control the binding to individual entities, IRowMapper is your savior. IRowMapper helps you map an individual IDataRecord to the entity to which it binds. When you need control at the ResultSet level, IResultSetMapper is your guy. IResultSetMapper works at the IDataReader level and allows you to control looping through the IDataReader as well as custom databinding of each IDataRecord if you so choose.

Using the same example from before with IRowMapper, below is an example of creating a custom IResultSetMapper, MyResultSetMapper, that loops through the entire resultset and returns IEnumerable<Contact>. Note that in this case I don’t really need control at the IDataReader level, but I did it for the sake of illustration.

class Program
{
 static void Main(string[] args)
 {
 var database = EnterpriseLibraryContainer.Current.GetInstance<Database>();
 var contacts = database.ExecuteSqlStringAccessor<Contact>
 ("SELECT Id, Email FROM Contacts", new MyResultSetMapper());

 foreach (var contact in contacts)
 Console.WriteLine(string.Format("{0}: {1}", contact.Id, contact.Email));

 Console.ReadLine();
 }
}

public class MyResultSetMapper : IResultSetMapper<Contact>
{
 public IEnumerable<Contact> MapSet(System.Data.IDataReader reader)
 {
 var contacts = new List<Contact>();

 while (reader.Read())
 contacts.Add(new Contact { Id = reader.GetInt32(0), Email = reader.GetString(1)});

 return contacts;
 }
}

public class Contact
{
 public int Id { get; set; }
 public string Name { get; set; }
 public string Email { get; set; }
}

There is a part of me that wants to use an iterator from within MyResultSetMapper as shown below, but I do not like to use yield return for deferred execution from within an open database connection, which is an expensive resource. Opinions may vary.

public class MyResultSetMapper : IResultSetMapper<Contact>
{
 public IEnumerable<Contact> MapSet(System.Data.IDataReader reader)
 {
 while (reader.Read())
 yield return new Contact { Id = reader.GetInt32(0), Email = reader.GetString(1)});
 }
}

The results of each entity are the same as when we used a custom IRowMapper in the last Enterprise Library 5 DAAB Tutorial:

Conclusion

Although I am sure I will write other Enterprise Library 5 DAAB Tutorials in the future, I think we hit most of the interesting changes. Time to move on to other changes in Enterprise Library 5.

Hope this helps.

David Hayden

IRowMapper via MapBuilder and Mapping Properties in EntLib 5 DAAB

Let’s start to kick it up a notch when talking about the new Database Accessors in Enterprise Library 5 DAAB. So far I have only been talking about the basics in the following tutorials:

• - Database Accessors in Enterprise Library 5 DAAB - Database.ExecuteSprocAccessor
• - EnterpriseLibraryContainer and IServiceLocator in Enterprise Library 5
• - Database.ExecuteSqlStringAccessor and LINQ in Enterprise Library 5 DAAB

IRowMapper and IResultSetMapper in Enterprise Library 5 DAAB

Thus far all of the examples with Database.ExecuteSprocAccessor and Database.ExecuteSqlStringAccessor have assumed we are returning all the properties associated with an entity and have let the DAAB take care of managing the resultset and binding of each row to an entity.

This is fine and dandy in our safe little sandbox, but in the real-world we often need to get dirty and have more control of the binding. If you look at the overloads of ExecuteSprocAccessor and ExecuteSqlStringAccessor, you will notice the option of specifying an IRowMapper or an IResultSetMapper for that extra level of control.

In this tutorial we are going to look at IRowMapper, which gives us more control over handling the binding of each row in the resultset. Later we will take a look at IResultSetMapper, which gives us control over not only the binding of individual rows but the entire resultset.

IRowMapper and MapBuilder

In the real world we are not always returning all properties of an entity with each request to the database. In these cases we may need to provide a custom IRowMapper that specifies the subset of properties to be bound. The simplest way to create a custom IRowMapper is to use MapBuilder that comes with the DAAB. MapBuilder provides a fluent interface for specifying which properties are being bound to an entity and returns an IRowMapper when you call Build.

You may not have realized it thus far, but we have been using MapBuilder indirectly the entire time. Since we have not specified a custom IRowMapper, the DAAB has been using MapBuilder<Contact>.BuildAllProperties(), which creates an IRowMapper that expects all properties to be returned by the data access request.

In the case below, however, we have chosen to only return the Id and Email for each contact and have skipped Name. In this case we need to specify a custom IRowMapper. We can do so quite easily by using MapBuilder and specifying all properties are to be bound except for Name. The code is shown below.

class Program
{
 static void Main(string[] args)
 {
  var database = EnterpriseLibraryContainer.Current
        .GetInstance<Database>();

  var contacts = database.ExecuteSqlStringAccessor<Contact>
   ("SELECT Id, Email FROM Contacts", 
   MapBuilder<Contact>
    .MapAllProperties()
    .DoNotMap(c => c.Name)
    .Build());

  foreach (var contact in contacts)
   Console.WriteLine(string.Format
    ("{0}: {1}", contact.Id, contact.Email));

  Console.ReadLine();
 }
}

public class Contact
{
 public int Id { get; set; }
 public string Name { get; set; }
 public string Email { get; set; }
}

If you inspect each Contact in the foreach loop you will see that the Id and Email were properly bound and the Name is null:

In cases where there are a lot of properties but you are only binding a few, you may want to choose to MapNoProperties() and then add individual properties to be bound.

Conclusion

Now of course you do not need to use MapBuilder to create an IRowMapper. You can create your own implementation of IRowMapper by hand. MapBuilder is just a quick and convenient method of doing so when all you need to do is specify a subset of the properties to be bound.

Looking forward to the ETA of Enterprise Library 5 and Unity 2 on April 14, 2010!

Hope this helps.

David Hayden

Database.ExecuteSqlStringAccessor and LINQ in Enterprise Library 5 DAAB

This post was created based on a few questions I received during a presentation at a local Florida .NET Developer Group in regards to using Dynamic SQL with the DAAB Accessors. In a recent post on Enterprise Library 5, Database Accessors in Enterprise Library 5 DAAB - Database.ExecuteSprocAccessor, I mainly focused on using stored procedures when using the new DAAB Accessors and really didn’t give any air time to using Dynamic SQL. I also didn’t elaborate much on LINQ which I was also saving for a future post.

Given these recent questions, I will talk briefly about using Dynamic SQL and LINQ and how they play a part in the new Database.ExecuteSprocAccessor and Database.ExecuteSqlStringAccessor Extension Methods on the Database Class in Enterprise Library 5.

Database.ExecuteSqlStringAccessor

Many an O/R Mapper has been created using the Data Access Application Block underneath the covers, and, of course, none would be complete without being able to generate Dynamic SQL in the background. Just like with stored procedures, the DAAB allows one to execute ADO.NET CommandType.Text SQL statements pretty easily without having to be concerned with connection management and the ever-changing best practices for working with databases at a low-level.

When looking at the new DAAB Accessors in Enterprise Library 5, there is a particular extension method just for executing Dynamic SQL, called ExecuteSqlStringAccessor. It allows you to pass in a string as simple as “SELECT Id, Name, Email FROM Contacts”, have it execute on the database of your choice, and obtain the strongly-typed results returned from the simple method call.

Shown below is an example of such a database call that uses the new Database.ExecuteSqlStringAccessor Extension Method to return all the contacts from the Contacts Table in our database.

class Program
{
  static void Main(string[] args)
  {
    var database = EnterpriseLibraryContainer.Current.GetInstance<Database>();

    var sql = "SELECT Id, Name, Email FROM Contacts";

    var contacts = database.ExecuteSqlStringAccessor<Contact>(sql);
  }
}

public class Contact
{
  public int Id { get; set; }
  public string Name { get; set; }
  public string Email { get; set; }
}

The variable contacts above is of type IEnumerable<Contact> and contains all the contacts from the Contacts Table in the database.

LINQ To Objects

Since the results from Database.ExecuteSqlStringAccessor and Database.ExecuteSprocAccessor are of IEnumerable<T>, we can use LINQ To Objects on the results to further filter, sort, and in general, massage the data to are needs.

For example purposes only, let’s go ahead and use LINQ’s Skip, Take, and Single operations to illustrate grabbing a particular Contact from the results:

var contact = database.ExecuteSqlStringAccessor<Contact>(sql).Skip(1).Take(1).Single();

Now before you get too excited :), remember that this is LINQ To Objects and only acting on the results being returned by the SQL Query. Hence the paging is not happening on the Database, but in memory. Therefore to page an entire Database Table in this manner you would have to return all the results from the entire table and then do the LINQ operations in memory. If you have very few records in your table, this may not be such a big deal. However, for a large number of records this would be frightening!

Other LINQ Providers, like LINQ To SQL and Entity Framework, act differently in that they are working with IQueryable<T> and thus transforming the Query Expressions to a more meaningful SQL respresentation that offers a more efficient and better performing solution that in most cases occurs on the database. Please do not confuse the two or your data access layer will be a huge bottleneck for your application.

Conclusion

This was just a simple introduction to Database.ExecuteSqlStringAccessor for executing Dynamic SQL just as we just scratched the surface on Database.ExecuteSprocAccessor before. Now that you get the idea, next time we need to discuss those situations where we have to start using MapBuilder, IRowMapper, IResultSetMapper, and IParameterMapper. That’s where the fun begins!!

Hope this helps.

David Hayden

InjectionFactory in Unity - Register Delegate to Create Object

I think everyone who has used Unity for inversion of control and dependency injection will be very happy to see the new InjectionFactory in Unity 2. Before when you wanted to register a factory ( function / delegate ) with Unity to create an object you had to use the StaticFactoryExtension. Using static factories was way behind the times in terms of what other containers, like Autofac, Windsor, Ninject, etc., could do using simple inline lambda expressions.

InjectionFactory in Unity 2

Microsoft Patterns & Practices has been working diligently on Unity 2 and Enterprise Library 5 and we are seeing all kinds of usability being added to these products. With InjectionFactory one can now use a simple lambda expression when specifying a factory for creating an object. Here is some code using Unity 2 and InjectionFactory to create an instance of IPaymentProcessor using a simple lambda expression:

class Program
{
 static void Main(string[] args)
 {
  var container = new UnityContainer();

  container.RegisterType<IPaymentProcessor>(
   new InjectionFactory ((c) => new PaymentProcessor())
  );

  var processor = container.Resolve<IPaymentProcessor>();
 }
}

public interface IPaymentProcessor { }

public class PaymentProcessor : IPaymentProcessor { }

I think we can all agree that this is much, much better than the previous StaticFactoryExtension. Of course, you can still specify a static method on a class as a factory to create the object:

class Program
{
 static void Main(string[] args)
 {
  var container = new UnityContainer();

  container.RegisterType<IPaymentProcessor>(
   new InjectionFactory ((c) => PaymentProcessorFactory.Create())
  );

  var processor = container.Resolve<IPaymentProcessor>();
 }
}

public static class PaymentProcessorFactory
{
 public static IPaymentProcessor Create()
 {
  // Pretend Some Algortithm Here...
  return new PaymentProcessor();
 }
}

public interface IPaymentProcessor { }

public class PaymentProcessor : IPaymentProcessor { }

Note that you can also pass in the instance of the IUnityContainer into the factory method as well. In fact, you probably will want to use the UnityContainer to create PaymentProcessor as opposed to using the new keyword. Let’s change the code above to use Unity to resolve PaymentProcessor:

class Program
{
 static void Main(string[] args)
 {
  var container = new UnityContainer();

  container.RegisterType<IPaymentProcessor>(
   new InjectionFactory ((c) => PaymentProcessorFactory.Create(c))
  );

  var processor = container.Resolve<IPaymentProcessor>();
 }
}

public static class PaymentProcessorFactory
{
 public static IPaymentProcessor Create(IUnityContainer container)
 {
  // Pretend Some Algortithm Here...
  return container.Resolve<PaymentProcessor>();
 }
}

public interface IPaymentProcessor { }

public class PaymentProcessor : IPaymentProcessor { }

Conclusion

Lots of interesting changes coming to Unity 2 and Enterprise 5. Hopefully they will be released around mid-to-late April along with Visual Studio 2010. Check my presentations for upcoming Enterprise Library and Unity Presentations in Florida. As soon as the  code stabilizes I will create screencasts on Patterns & Practices Guidance.

Hope this helps.

David Hayden

Automatic Factories in Unity 2 - Unity 2 Tutorials and Samples

In Unity 2 there is the concept of Automatic Factories to allow classes or services to defer instantiation of their dependencies to the last possible moment. This is particularly useful when the dependency is expensive to create and is not always used by the service. Think of it as lazy loading of dependencies just like we have lazy loading in O/R Mappers.

I mentioned similar functionality in Autofac in the following tutorial: Auto-Generated Factories in Autofac for Lazy Instantiation - LazyDependencyModule. I recommend you read that tutorial as it talks more about the concepts, etc., whereas here I will only mention a few comments and show you an example. Autofac also goes a bit further than Unity 2 by supporting Lazy<T> and Lazy<T,TMetadata> when using Autofac with the .NET Framework 4.

Automatic Factories in Unity 2

The example below shows Unity resolving a NewsController with a dependency on Func<Publisher> in its constructor. The idea here is that we are pretending that Publisher is expensive to create and we only want to resolve it on demand at time of use when the News is being published.

We do not have to register Func<Publisher> in the UnityContainer. Unity will automatically create a delegate matching that signature for us at runtime. The delegate will essentially do a container.Resolve<Publisher> on our behalf, allowing us to lazy load the Publisher without having a dependency on the container itself.

Here is some Unity 2 sample code:

class Program
{
 static void Main(string[] args)
 {
 var container = new UnityContainer();
 var controller = container.Resolve<NewsController>();

 controller.Publish(new News());

 Console.ReadLine();
 }
}


public class NewsController
{
 private readonly Func<Publisher> _getPublisher;

 public NewsController(Func<Publisher> getPublisher)
 {
 _getPublisher = getPublisher;
 }

 public void Publish(News news)
 {
 _getPublisher().Publish(news);
 }
}

public class Publisher
{
 public void Publish(News news)
 {
 Console.WriteLine("Published...");
 }
}

public class News { }

That's all there is to it. With a few small changes the Publisher is now being resolved on demand just when you need it.

Conclusion

I'll be giving a number of presentations on Enterprise Library 5 and Unity 2 this year at various Florida Code Camps and Florida .NET Developer Groups. First up is the South Florida Code Camp and then later I have presentations scheduled for IASA Tampa, Sarasota .NET Developer Group, and more to come.

Hope this helps.

David Hayden

Microsoft MVP Award Renewed for 2010!

Always exciting to receive an email from Microsoft on being re-awarded the Microsoft MVP award in Visual C#! This is my 5th year being an MVP and 2009 was a really active year for me in the community. In addition to my regular blogging, I presented 20+ sessions to the Florida .NET Developer Community and started my first Florida .NET Developer Group, the Tampa ASP.NET MVC Developer Group.

As for 2010, I already have presentations scheduled for the upcoming year. In January, I will be doing an ASP.NET MVC Bootcamp at the Orlando .NET Developer Group, and I have 3 presentations scheduled at various groups on Enterprise Library 5. In addition to those subjects, you can expect presentations on C# 4, F#, Code Contracts, and other topics.

I hope to have a Day of Patterns & Practices in Tampa, Florida again this year, which is a day long event on various guidance packages, factories, and other guidance coming out of Microsoft Patterns & Practices. Expect a good talk on Enterprise Library 5, Web Client Software Factory, and Prism at the event.

I have some other ideas ping-ponging around in my head for the next year which I will mention at a later time. For now, I wish you all a safe, happy, and healthy 2010!

Thank you.

David Hayden

EnterpriseLibraryContainer and IServiceLocator in Enterprise Library 5

This post is based on early source code of Enterprise Library 5 and is subject to change when Enterprise Library 5 is RTM.

Enterprise Library 5 has a new class, called EnterpriseLibraryContainer, which is a single, convenient access point to the Enterprise Library objects being used in your .NET application. EnterpriseLibraryContainer is nothing more than a facade class around IServiceLocator and your chosen IoC Container. By default, Enterprise Library will of course use Unity as its IoC of choice.

Before EnterpriseLibraryContainer and IServiceLocator

In Enterprise Library 4.1 one added the EnterpriseLibraryCoreExtension and other application block specific extensions to a Unity Container you created to populate the container with Enterprise Library objects and services.

IUnityContainer container = new UnityContainer();
container.AddNewExtension<EnterpriseLibraryCoreExtension>();
container.AddNewExtension<DataAccessBlockExtension>();

Database db = container.Resolve<Database>();

EnterpriseLibraryContainer in Enterprise Library 5

For your convenience, you now don’t have to create your own IoC container and populate the container with various Enterprise Library and Application Block extensions in Enteprise Library 5. Instead, you can now just access the EnterpriseLibraryContainer.Current Property and access your objects via it. The Current Property exposes IServiceLocator, which is a general interface supported by many IoC Containers, like Castle Windsor, Autofac, Ninject, Spring, StructureMap, etc.

var db = EnterpriseLibraryContainer.Current.GetInstance<Database>();
var contacts = db.ExecuteSprocAccessor<Contact>("FetchAllContacts");

Conclusion

Some nice changes appearing early on in Enterprise Library 5 to help make it easier to use in your applications. When Enterprise Library 5 gets a bit more stable I will create some Enterprise Library 5 Screencasts on PnPGuidance.

Hope this helps.

David Hayden

Database Accessors in Enterprise Library 5 DAAB - Database.ExecuteSprocAccessor

Enterprise Library 5 is still only available as preliminary source code on CodePlex so it is probably way too early for most people to start using it. I, however, like to get my hands dirty and dig through the source code to see all the new changes. Any code you see in this post is preliminary and subject to change. I am working from changeset 61455 in this post.

Data Access Application Block

The most popular application block in Enterprise Library is the Data Access Application Block. Developers use it as a means of accessing data from a large range of supported databases and a few O/R Mappers have used the DAAB as the ADO.NET Engine under the covers. I absolutely love the Data Access Application Block and have used it and customized it for years.

If you are familiar with the DAAB, you will know that its intent is to make accessing stored procedures convenient. Although the DAAB supports more than just stored procedures, many of the methods on the base Database Class, like ExecuteReader, ExecuteScalar, and ExecuteNonQuery, for example, have a common method signature that takes a stored procedure name and list of parameter values to make calling a stored procedure effortless:

public IDataReader ExecuteReader(string storedProcedureName,
					params object[] parameterValues)

When working with ADO.NET and stored procedures these methods have sheltered us from all the complexities of connection management and best practices around performance, exception handling, etc.

O/R Mapping

As time has progressed, however, software developers are often not thinking about database tables and rows in their applications, but collections and classes. A row in a Contacts Table, for example, is now often mapped to a Contact Class in your .NET Application and several rows are often mapped to a custom ContactCollection Class or collection-based class in the .NET Framework.

When using the Enterprise Library DAAB with custom classes, one has to map the results of an IDataReader or IDataRecord to these custom classes, whether it be a factory method on the class, a stand-alone class factory, heavy use of reflection in a generic class, etc. The ContactFactory Class below is a simplified version of something you might use in your applications.

public class Contact
{
 public int Id { get; set; }
 public string Name { get; set; }
 public string Email { get; set; }
}

public static class ContactFactory
{
 public static Contact Create(IDataReader dr)
 {
  return new Contact
  {
   Id = dr.GetInt32(0),
   Name = dr.GetString(1),
   Email = dr.GetString(2)
  };
 }
}

The Contact and ContactFactory Classes then get used in your data access layer in some sort of data access object ( DAO ), repository, or other datamapper class.

public class ContactsDAO
{
 private readonly Database _database;

 public ContactsDAO(Database database)
 {
  _database = database;
 }

 public Contact FetchById(int id)
 {
  Contact contact = null;

  using (IDataReader dr = _database.ExecuteReader("FetchContactById", id))
  {
   if (dr.Read())
    contact = ContactFactory.Create(dr);
  }

  return contact;
 }
}

Although your code will certainly be more robust and the strategy will vary, the spirit of the code above is pretty typical of most datamapper classes that use the DAAB to return classes and collections using the standard Database Class API. Given the tendency to write this type of code over and over again, the Enterprise Library Team has decided to create some Extension Methods on the Database Class in Enterprise Library 5 to help with this simple mapping.

Enterprise Library 5 DatabaseExtensions Class and ExecuteSprocAccessor

In the current preliminary release of Enterprise Library 5, you will find a DatabaseExtensions Class with a number of overloaded methods named CreateSprocAccessor<TResult>, ExecuteSprocAccessor<TResult>, CreateSqlStringAccessor<TResult>, ExecuteSqlStringAccessor<TResult>, etc.

Put succinctly, the Database Accessor Methods will perform data mapping for you to eliminate the need for the ContactFactory Class and looping through the IDataReader as shown above in the ContactsDAO Class. Because the methods return IEnumerable<TResult> you also have the ability to use LINQ To Objects on the results.

The best way to understand this is to rewrite the ContactsDAO FetchById Method to use the new Database Accessor Method, ExecuteSprocAccessor, in Enterprise Library 5:

public class ContactsDAO
{
 private readonly Database _database;

 public ContactsDAO(Database database)
 {
  _database = database;
 }

 public Contact FetchById(int id)
 {
  return _database.ExecuteSprocAccessor<Contact>
   ("FetchContactById", id).SingleOrDefault();
 }
}

Notice that the looping through IDataReader and the data mapping between the IDataReader and Contact Class have been completely removed by a single call to ExecuteSprocAccessor<TResult> and a single LINQ Method, called SingleOrDefault. This is amazingly convenient!!!!

I will not go into this in detail at this time because this could easily change, but this code is assuming some conventions between the results returned by the IDataReader and the Contact Class. It assumes the names of the properties on Contact are the names of the columns for the IDataReader and it assumes that all columns are being returned by the stored procedure. If this is not the case, you can tell it differently by passing a different IRowMapper<TResult> into one of the overloaded methods, which we will save for another post.

Conclusion

That is just a taste of the Database Accessors in the Enterprise Library 5 Data Access Application Block. The DAAB is not trying to be a full-fledged O/R Mapper, like LINQ To SQL and Entity Framework. The new DatabaseExtensions Class and Database Accessors are trying to help you eliminate some of the repetitive code used with the DAAB when a developer wants to return classes and collections instead of ADO.NET objects into your .NET Applications.

I will talk about the Database Accessors in more detail in future posts. You can also watch for screencasts to appear on PnPGuidance tagged as Enterprise Library 5.

Hope this helps.

Part II: Database.ExecuteSqlStringAccessor and LINQ in Enterprise Library 5 DAAB

David Hayden

Enterprise Library 5 Presentations for 2010

Enterprise Library 5 will have a number of significant changes in terms of usability, simplicity, use of dependency injection, and testability. Although there won't be any new application blocks in Enterprise Library 5, it will have a lot of bug fixes and enhancements.

As an FYI, I am organizing my presentation schedule for 2010, which includes many Enterprise Library 5 presentations, code samples, and tutorials. Check out my Florida developer presentations. I already have presentations scheduled for South Florida Code Camp 2010 and Sarasota .NET Developer Group. I am working on presentations for IASA Tampa and others.

Really looking forward to Enterprise Library 5.