Jaycent Drysdale

List paging via LINQ to Objects

2009-07-13T11:01:00Z

The various grid controls shipped with asp.net provides plug and play data paging on its underlying data source. Its quiet simple to get a paged view of your data by setting a few properties on the grid before calling the Bind() method to connect your grid to the data. This scenario works well in most situations. On occasions where the paging logic needs to reside outside of the UI layer, a more custom paging mechanism is required.

In this post, I'll examine a simple way to implement a custom paginging mechanism via LINQ to objects, removing the paging logic from the UI component and placing it at a lower level layer, maybe in a controller class (MVC) or in a presenter class in an MVP pattern.

Lets imagine we have just retrieved a list of 5,000 rows of data from a product catalog table living in a SQL Server 2005 database, via a datatable object. The data retrieved is broken out into the following columns:

ProductId (int)
Name (string)
Description (string)
Price (decimal)
Category (string)

We first need to convert this datatable object to a strongly typed list of product summaries (each row in the datatable = a product summary)

Lets define a product summary class that we can map each product to:

public class ProductSummary
{
      public int ProductId { get; set; }
      public string Name { get; set; }
      public string Description { get; set; }
      public decimal Price { get; set; }
      public string Category { get; set; }
}

We will also define another method that takes the datatable object and convert it into a strongly typed list of ProductSummary Instances.

public List<ProductSummary> ConvertTableToList(DataTable aDataTable)
{
     List<ProductSummary> _lst = new List<ProductSummary>();
     foreach (DataRow aDataRow in aDataTable.Rows)
     {
          ProductSummary aSummary = new ProductSummary();
          aSummary.Category = aDataRow["category"].ToString();
          aSummary.Description = aDataRow["description"].ToString();
          aSummary.Name = aDataRow["name"].ToString();
          aSummary.Price = (decimal)aDataRow["price"];
          aSummary.ProductId = (int)aDataRow["productid"];
          _lst.Add(aSummary);
     }
     return _lst;
}

So far we have created a class ProductSummary that will hold a row of data from our datatable. We have also defined a method called ConvertTableToList that will take our datatable object and convert it into a list of Productsummary objects.

public static List<ProductSummary> GetProducts(int? page, int? pageSize)
{
     //default to page 1 if no page supplied
     int _page = (page.HasValue) ? page.Value : 1;

     DataTable dt = PupulateDataTable() //replace PopulateDataTable() with your logic to retrieve the data from the underlying data store

     //if no page size specified, set page size to total # of rows in data table
     int _pagesize = (pageSize.HasValue) ? pageSize.Value : dt.Rows.Count;

     List<ProductSummary> lst = ConvertTableToList(dt);

     //paging logic
     return lst.Skip((_page - 1) * _pagesize).Take(_pagesize).ToList();
}

And here is how we might access a page of data from an asp.net web form page code-behind using the method defined above.
Assume that our paging method was defined in a class called Products. Here we are retrieving page one, and we are telling the method to return 50 rows of data per page.

List<ProductSummary> products = Products.GetProducts(1, 50);
foreach (ProductSummary aSummary in products)
{
     Response.Write(string.Format("{0} {1} [{2}]","<li>",aSummary.Name, aSummary.Category));
}
products = null;

Generate RSS/Atom feeds using FeedManager.dll

2009-01-01T13:06:00Z

FeedManager is a custom RSS/Atom Syndication generator that allows for quick and efficient generation of RSS/Atom feeds. Just reference the dll in your web applications, then write a few lines of code to expose your data to external applications/web sites.

The rsstoolkit exists for generating syndicated feeds on the fly, but if, like me, you have had issues porting the toolkit between project types and have to keep messing with web.config settings to get it to work, then the feedmanager.dll approach might work for you.

Here's how to get started:

Download the cutsom FeedManager.dll here.
Add a reference to the dll from your solution, or simply copy the file to your application's Bin directory
Open up a web page, and in the code behind, create an instance of the FeedManager.FeedCreator class
Set Properties on the FeedCreator class (title, author etc)
Add FeedItems to the FeedCreator class. This will typically be data obtained from a dataset.
Call the GenerateFeed() Method on the FeedManager.FeedCreator class to generate your feed.

    protected void Page_Load(object sender, EventArgs e)
    {
       using (FeedManager.FeedCreator aFeed = new FeedManager.FeedCreator(FeedType.RSS))
       {
          aFeed.FeedUrl = "http://www.solid2.com";
          aFeed.FeedTitle = "My RSS Feed Title";
          aFeed.FeedDescription = "My RSS Feed Description";
          aFeed.FeedCopyright = "(c) 2009. All rights reserved";
          aFeed.FeedImage = "http://contoso/image.jpg";

          //add items to the feed
          aFeed.AddItem(new FeedItem(Guid.NewGuid().ToString(), "first Item", "first summary", "Lorem ipsum dolor sit amet.", "thefirstlink", "1.aspx", DateTime.Now.ToString(), "Jaycent", "info@solid2.com"));
          aFeed.AddItem(new FeedItem(Guid.NewGuid().ToString(), "second Item", "second summary", "Lorem ipsum dolor sit amet.", "thesecondlink", "http://www.solid2.com", DateTime.Now.ToString(), "Jaycent", "info@solid2.com"));
          aFeed.AddItem(new FeedItem(Guid.NewGuid().ToString(), "third Item", "third summary", "Lorem ipsum dolor sit amet.", "thethirdlink", "http://www.solid2.com", DateTime.Now.ToString(), "Jaycent", "info@solid2.com"));
          aFeed.AddItem(new FeedItem(Guid.NewGuid().ToString(), "fourth Item", "fourth summary", "Lorem ipsum dolor sit amet.", "thefourthlink", "http://www.solid2.com", DateTime.Now.ToString(), "Jaycent", "info@solid2.com"));
          aFeed.AddItem(new FeedItem(Guid.NewGuid().ToString(), "fifth Item", "fifth summary", "Lorem ipsum dolor sit amet.", "thefifthlink", "http://www.solid2.com", DateTime.Now.ToString(), "Jaycent", "info@solid2.com"));
          aFeed.AddItem(new FeedItem(Guid.NewGuid().ToString(), "sixth Item", "sixth summary", "Lorem ipsum dolor sit amet.", "thesixthlink", "http://www.solid2.com", DateTime.Now.ToString(), "Jaycent", "info@solid2.com"));

          //generate the feed, send results to browser window.
          aFeed.GenerateFeed();
       }
    }

Navigate to the page to view the ouput!

Play around with setting the FeedType setting in the constructor between Feedtype.RSS and FeedType.Atom. View the source of the generated file to examine the difference in the output. For an excellent comparison article for ATOM vs RSS, see Aaron Brazell article here.

Download the feedManager.dll here
For source code, contact info@solid2.com or jaycentdrysdale@hotmail.com

Happy new year, and happy programming!

System.Data.GenericClient : A custom Data Access Component

2008-02-20T10:18:00Z

Developers often find themselves having to connect to data in a variety of datasources ranging from MS Access to large scale relational databases such as Oracle, SQL Server, MySql etc. Each different datasource type typically requires importing a different .Net provider-specific namespace for working wth a specific database. For instance, to connect to an Oracle Database the consuming application needs to import the System.Data.OracleClient Namespace and untilize classes such as OracleCommand, OracleDateReader etcettera. To connect to SqlServer applications developers import the System.Data.SqlClient namespace into their applications and program against the classes provided by the namespace. The net effect of having multpile provider specific namespaces is that your DAL components are rarely ever portable, with each different database type normally requiring provider specific code.

System.Data.GenericClient is a simple but generic custom built data access component that solves some of the issues outlined above. System.Data.GenericClient provides a very simple but familiar API that can be configured declaratively in an application configuration file as well as programmatically in your DAL. Below I'll take a look at using System.Data.Generic to connect to various datasources using a consistent API.

Here's what you need to do to get started using System.Data.GenericClient in your applications:

Download the zip file at the link provided below . Extract the contents, then add a reference in your application to the extracted System.Data.GenericClient.dll file.
Open up your aspplications config file and declare an appsettings entry as shown below:
<appSettings>
<add key="System.Data.GenericClient.DefaultConnectionStringName" value="mysqlConnectionString" />
</appSettings>
Declare a connectionstring entry. Make sure the name of this connection string matches the appsettings entry value specified above. In this case, the connectionstring entry name should be specified as "mysqlConnectionString. Provide a valid MySql Connection string. See example below:

<connectionStrings>
      <add name="mysqlConnectionString"
       connectionString="Network Address=serveradress;
       Initial Catalog='mydb';User Name='sa';Password='pwd'"
       providerName="MySql.Data.MySqlClient" />
</connectionStrings>
Write data access logic to connect to the database. Below is an example of how to return a datatable object from the datasource

using (System.Data.GenericClient gClnt = new GenericClient())
{
     gClnt.Command.CommandType = CommandType.Text;
     gClnt.Command.CommandText = "select * from employees";
     using (DataTable dt = gClnt.ExecuteDataTable())
     {
          this.dataGridView1.DataSource = dt;
     }
}

The code snippet above shows how simple it is to use System.Data.GenericClient to access data from mySQL in a provider independent format. For each aditional datasource your application needs to connect to, specify a valid connection string in the applications configuration file as outlined above, then specify a valid command text or stored procedure on GenericClient's command object.

See below for a list of operations supported by the GenericClient object:

public virtual int ExecuteNonQuery()
Use this method to execute an update, insert or delete operation on the underlying datasource
public virtual string ExecuteXML()
Use this method to execute a query on the underlying datasource. Returns data in xml format
public virtual DataTable ExecuteDataTable()
Use this method to execute a query on the underlying datasource. Returns a datatable object
public virtual object ExecuteScalar()
Use this method to execute a query on the underlying datasource. Returns a scalar object

System.Data.GenericClient remains a work in progress. In addition to the features highlighted above, you will find other features in the namespace. These and other features will be further refined and documented in future updates.

File Download: System.Data.GenericClient.zip

Want a copy of the source code? Send email to jaycentdrysdale@hotmail.com

File System search via LINQ to Objects

2008-02-15T16:21:00Z

LINQ provides a standard way for developers to query data in diverse locations, ranging from in memory objects, XML data, or relational data living in an SQL Server Database.Lets take a look at a scenario where we use Linq to objects to query a directory on the local drive for files that match a given extension, and show the results in a Datagrid control.

Here is the plan of action for the application

Create a function to return a list of all the files in a directory. We will call this method GetFiles, it will take one string parameter representing the base search directory, and will return a strongly typed list of FileInfo Objects.
Use Linq to Objects to filter the returned list for files that matches a user-specified file extension.
Bind the results to a grid

Lets start by taking a look at the GetFiles function:

public static System.Collections.Generic.List<FileInfo> GetFiles(string sPath, string sFileExtension)
{
DirectoryInfo _dirInfo = new DirectoryInfo(sPath);
return System.Linq.Enumerable.ToList(_dirInfo.GetFiles(string.Format("*{0}",sFileExtension), SearchOption.AllDirectories));
}

The GetFiles() function uses objects from the System.IO namespace to do the heavy lifting of searching the file system. Results are returned in a strongly typed list of FileInfo Objects.

Next we will look at the code that calls the GetFiles method defined above, and uses Linq to filter the list for the given file type. You would typically put this code in the click event for a button control on a windows form.

//get all files contained in the path supplied by the user
System.Collections.Generic.List<FileInfo> _theFiles = GetFiles(c:\myDirectory, ".doc");

//we now have a list of files...next we use LINQ to query the file list and sort the results by name
var _files = from file in _theFiles
orderby file.Name
select file;

this.dataGridView1.DataSource = _files.ToList();

And there you have it. Note the use of the orderby clause to sort the results before you bind the results to the grid.

Extension Methods: A simple example

2008-02-12T10:23:00Z

If you've been developing software for any significant lenght of time, chances are you have compiled(for want of a better word) a repository of helper functions that have, over time, become valuable to you as you make your way through various applications. Extension Methods allow us to extend our custom and existing CLR types to include new functionality. These new functionality might already exist in the form of helper functions scattered throughtout our applications. For example, You might have a helper function that converts a string value to Proper Case. Extension methods allow us to "add" this ToProperCase() functionality to the primitive System.String type as if it were a built in method of the type.

In this post, I'll share with you a simple example of how I used extension methods to extend the sealed System.DateTime native type to include a
ToFriendlyDateString() method. Extension Methods are new in the .Net Framework 3.5.

The idea behind the ToFriendlyDateString() method is representing dates in a user friendly way. For example, when displaying a news article on a webpage,
you might want articles that were published one day ago to have their publish dates represented as "yesterday at 12:30 PM". Or if the article was publish today,
show the date as "Today, 3:33 PM".

The code snippet below shows the logic that will represent our extension method. Note the Namespace declaration, and the signature for the class definition. Note also the use of the this keyword when describing the input parameter for the ToFriendlyDateString() method. I'll eloberate on these later in this discussion.

namespace Utils
{
     public static class Extensions
        {
             public static string ToFriendlyDateString(this DateTime Date)
             {
                    string FormattedDate = "";
                    if (Date.Date == DateTime.Today)
                    {
                           FormattedDate = "Today";
                    }
                    else if (Date.Date == DateTime.Today.AddDays(-1))
                    {
                           FormattedDate = "Yesterday";
                    }
                    else if (Date.Date > DateTime.Today.AddDays(-6))
                    {
                           // *** Show the Day of the week
                         FormattedDate = Date.ToString("dddd").ToString();
                    }
                    else
                    {
                          FormattedDate = Date.ToString("MMMM dd, yyyy");
                    }

                   //append the time portion to the output
                  FormattedDate += " @ " + Date.ToString("t").ToLower();
                  return FormattedDate;
             }
        }
}

When creating extension methods, here are the rules

~~You must define a namespace for your class. Utils in the snippet above~~ (Namespaces are not a strict requirement, but good practice nevertheless)
The class that contain the extension method must be decorated with the static modifier, and its visibility must be public
The class must contain a static member, which will act as the extension method. This method must be public and must take one or more parameters, the first which must be a derivitive of the type you are extending. The first parameter definition must be preceeded by the this keyword

Extension methods are defined as static methods but are called by using instance method syntax. Their first parameter specifies which type the method operates on, and the parameter is preceded by the this modifier. Extension methods are only in scope when you explicitly import the namespace into your source code with a using directive. See example below showing how we might use the ToFriendlyDateString() method in our applications:

using Utils;

......

DateTime dt = new DateTime(2008, 2, 10, 8, 48, 20);
Console.WriteLine(dt.ToFriendlyDateString());

For further details on Extension Methods, check out this MSDN link: http://msdn2.microsoft.com/en-us/library/bb383977.aspx

Object Oriented Programming Refresher

2008-02-07T14:59:00Z

Recently I was challenged by a colleague who asked some very basic questions relating to object orient programming. I know these concepts very well, but sometimes you have to stop and think twice about them, especially if most often than not, you do not implement these concepts in your day to day programming activities. As developers, we often find ourselves in situations where the need to get things out the door and into production tend to encourage us to not think about doing things the right way, but instead, getting the work done in the least possible time. Object Oriented concepts are something every serious developer should know inside out. Sure you can get by without practicing it, but that approach might come back to haunt you down the road.

Classes are the foundation of Object Oriented Programming. Business Logic code should be seperated into groups of related classes that satisfy a business need. There should be a clear seperation of concerns. When planning a development strategy for our applications, we should at all times try to envision our applications as being seperated into three logical tiers. Strictly speaking, having three logical tiers doesnt dictate that our apps must to be deployed physically as a three tier app...all the tiers could live on one one physical machine, or they could be deployed accross three different machines. They could also be deployed on multiple machines in the enterprise, in what is known as an n-tier architecture. Our apps will perform much better when we distribute the processing requirements accross multiple machines...business logic components run on machine A, Data Access components run seperate machine, and the front end logic running on a clinet pc or web server somewhere else. Microsft Transaction Server, and now Enterpise Services can act as a broker for our components living in the data access and business logic tiers, and offer such services as transactions support, object pooling, which promotes better scaling applications.

So, what is an abstract class. What is a sealed class. What is the difference accessibility methods out there that I can apply to my classes and methods, and why do I need them? What are interfaces? when is it useful to use an interface? These are the questions that rolled through my head when I was first introduced to OOP years ago. Over time, as you develop more business level applications, the importance of these concepts become clearer.

Inheritance is a pupular term among the OOP purists. So what is Inheritance, and how does it relate to OOP? Perhaps the best way to describe this would be to imagine a hypothetical situation where you are building an app that requires you to Mainatin a list of employee records. All employees must have an employeeID, they must have a first name, and they must have a departmentID etc. In addition, there are some employees that work on a part-time basis, and some that work full-time.

Looking at the above scenario, we have indentified the need for an employee class to service our application. but before we start building our employee class, we need to take a closer look at how that class will be implemented. There are common features that all employees have, but there are also some features that are specific to the full-time employee and others that are specific to the part-time employee. For instance, when we calculate the monthly pay for the full-time employee, the logic might be different from what we do when we calculate the salary of the guy that is employed part-time. It might help if we define a baseline Employee class that contain the common functionality, properties etc, and then further extend these classes in other derived classes to inplement the specific functionality. So at the root, we might create an employee class, and two derived classes: FullTimeEmployee and ParttimeEmployee. Both these classes will be based on the base Employee class and will inherit any functionality exposed, but will further provide indiviual methods that will be used to calculate an employee's salary.

By marking our employee class as Abstract, we are marking it as a class that cannot be instantiated directly...we are saying that this class exists only to be further refined through inheritance. The exact opposite scenario to that would be to mark our class as sealed, which would mean it cannot be further refined through inheritance.

The definition for our base employee class might look like this:

public abstract class Employee
{
}

The definiton for the derived classes might look like so:

public sealed class PartTimeEmployee:Employee
{}

public sealed class FullTimeEmployee:Employee
{}

Selected data and function members defined in the Employee class will be avaialable in both the derived classes. Data Members such as firstname, lastname, deptID, employeeID are common to all employees are defined on the Employee base class. The Employee base class will also contain a method called CalculateWages, which will contain no functionality, but will tell any class that implements the Employee class that it must implement a CalculateWages method. In the base class, the signature for the calculateWages Method might look like this:

public abstract decimal CalculateWages();

The CalculateWage() method in the base Employee class could alternatively be decorated with the virtual modifier instead of abstract. The difference is that the virtual modifier allows the base class to put implementation code in the method, and allows the derived class to decide wether or not it wants to override the implemementation provided by the base class. If the derived class wants to overide the method in the base class, it would implement the method using the following signature:

public override decimal CalculateWages()
{}

The scenario looked at above describes a very simple example of how we might implement a simple employee class in one of our applications. Of course, there is much more to object oriented programming, to much to be described in a single blog post. Of course, there are many different ways to implement OOP...for instance, the employee base class described above could be implemented as an interface instead of as an abstract class.

In Part 2 of this 4 part series, I'll take a look at other class modifiers, and also some of the accessibility options that we have available for exposing our classes to the outside world and what they mean for our classes. I'll also take a look at Interfaces, and how they can be used in the Employee list management scenario described in this article.

Anticipated new Data Types in Microsoft SQL Server 2008

2008-01-31T20:29:00Z

The next release of Microsoft SQL server, version 2008, promises a number of significant changes over its previous 2005 version release. From a Developers perspective, there is much anticipation over the new data types that we will get to play with in our stored procedures and other database objects. I’ll go through some of the new data types in this post.

New Date data types:
Date:-The new Date data type allows you to store dates without a time component from 0001-01-01 to 9999-01-01. This new type will lend itself well to situations where a date variable doesn’t need to have a time attached to it...like a date of birth field/variable. There is also the Time type, which as you might guess, stores a time value, minus a date portion. Already I'm seeing situations where these Data types would have saved me a few lines of code had hey been available earlier. Other new date types include DateTime2 and DatetimeOffset.

New HierarchyId data type
According to the Microsoft documentation, the Hierarchyid is a new data type that can store values that represent nodes in a hierarchy tree. This data type, which has a flexible programming model, can be implemented as a Common Language Runtime User-Defined Type (CLR UDT). The CLR UDT exposes several efficient built-in methods for creating and operating on hierarchy nodes. I am eagerly awaiting further details on the use of this new type, but at first glance, it seems we will now be able to store the hierarchical metadata that describes things like menu trees etc in a format that is easily retrievable. Building menus etc could be as easy as binding a treeview control to a field returned from a database or web-method call. I hope my understanding of this new type is not too far off from what it actually is. Time will tell.

UserDefined Table type:
Again, the Microsoft documentation described this new type as follows: A user-defined table type represents the definition of a table structure. You can use a user-defined table type to declare table-value parameters for stored procedures or functions. You can use this table type to declare table variables that are to be used in a batch or in the body of a stored procedure or function. To ensure that the data in the table type meets specific requirements, you should create unique constraints and primary keys on the table type. Actually, this is a neat addition. If I understand this correctly, we can pass in an array (table) of parameter items into a stored procedure as a unit. So instead of passing in 50 individual parameters into a Stored Procedure, It’s now possible to pass in a single UDT type that holds all 50 parameter bits that need to get to the Query.

FILESTREAM storage
Now here is where it gets interesting. It’s now possible to store data directly to the file system on the server via the FILESTREAM data type. It allows you to store unstructured data directly in the file system. You can use the new storage type VARBINARY(MAX) FILESTREAM to define table columns and store large binary data as files in the file system instead of storing them as Binary Large Objects (Blobs). In addition, you can use T-SQL statements—SELECT, INSERT, UPDATE, or DELETE—to query and modify FILESTREAM data. You can use the rich set of streaming APIs provided by Win32 for better streaming performance, while maintaining transactional consistency. You can also apply SQL Server functionalities to FILESTREAM data such as triggers, full-text search, backup and restore, SQL permissions, Database Console Command (DBCC) checks, and replication.

Sparse Columns
Typically, if you have a column/field in your database table that is infrequently used, and contains a null value in most cases, the new Sparse Columns feature provides a more efficient way to represent these.

In wrapping up, its also worth mentioning that the UDT types, introduced in SQL Server 2005, have undergone some changes in the 2008 release. Previously UDT types were limited a size of 8K....that limitation has been removed.

Options for Database access outside of ADO.Net

2008-01-29T14:47:00Z

In the world of .NET programming, ADO.NET has become the De Facto standard for accessing database of all types (relational or otherwise). The purists among us will be quick to point out that ADO.Net should be the only option and that as developers we shouldn’t even be thinking about bypassing ADO.NET to get to our database. But the no-so-pure will be quick to point out the alternative methods for pulling data from our databases without writing a line of database code. If you are still reading this article, it means you, like your truly have had occasions in the past where bypassing ADO.Net makes sense, whether you are creating a small website for your wedding guest list, or just putting together a demo website of sorts.

The SqlDataSource Control:
The SqlDataSource control (in my mind, the grand-daddy of declarative data Access) allows for the definition of queries in a declarative way. You can connect the SqlDataSource to controls such as the Datalist, and give your users the option to edit and update data without requiring any ADO.NET code. While the sqlDatasource control handles the heavy lifting required to facilitate the communication, it's worth mentioning that behind the scenes, it uses ADO.NET to do this heavy-lifting. The sqlDatasource supports any database that has a full ADO.NET provider. Apart from the fact that the sqlDatasource connects you to your database with minimal code, it does provide more benefits to developers who are looking to provide functionality such as paging sorting of datagrids without having to write lines of code to achieve this. If you bind your datagrid directly to a sqlDatasource control, you have paging and sorting functionality right at your fingertips. You can get to it by setting a few properties on your grid control. However, with all its "niceties" the SqlDataSource is somewhat controversial, because it encourages you to place database logic in the markup portion of your page. Many will agree that there are times when the benefits of using this control far outweigh this particular drawback.

LINQ to SQL:
Linq provides us with cool new way of accessing data. The source of this data can range from anything from files in your computer file system, a collection of objects living in a generic list in server memory, or rows of data residing in a database table in on the North Pole. Linq comes in a variety of flavors (LINQ to objects, LINQ to XML, LINQ to entities, LINQ to SQL, LINQ to Dataset). With LINQ to SQL, you define a query using C# code (or the LinqDataSource control) and the appropriate database logic is generated automatically. LINQ to SQL supports updates, generates secure and well-written SQL statements, and provides some customizability. Like the SQLDataSource control, LINQ to SQL doesn’t allow you to execute database commands that don’t map to straightforward queries and updates
(such as creating tables). Unlike the SqlDataSource control, LINQ to SQL only works with SQL Server and is completely independent of ADO.NET.

Profiles:
The profiles feature, introduced in .Net Framework 2.0, allows you to store user-specific blocks of data in a database without writing
ADO.NET code. You specify what data you want to gather and store by configuring the appropriate elements in your applications configuration file.

In wrapping up, it’s worth mentioning that none of options presented in this article is a replacement for ADO.NET, because none of them offers the full flexibility, customizability, and performance that hand-written database code offers. However, depending on the specific needs of your application, it may be
worth using one or more of these features to augment your ADO.Net centric data access layer.

Enhance your apps with the Integrated ASP.Net Pipleline

2008-01-23T17:32:00Z

The January publication of MSDN Magazine carried an article titled "Enhance your apps with Integrated ASP.Net Pipleline". While the subject of the article is not something that I would normally be super excited about, I decidede to spend at least 10 minutes perusing the article while commuting to work this morning (Been riding the train past couple of weeks). I recently installed Vista on my Notebook, and was keen to start looking into the features of IIS 7.0, which ships with microsoft's latest desktop operating system. As it turned out, the article touched on a subject that might be useful down the road as we take a leap into the world of PHP programming at work.

Its long been common knowledge that PHP could run under IIS, but not in a way that would make it feasible to run production apps...in other words, if you configure your PHP apps in IIS 6.0/5.0, the result would be a web site that runs very slow, if nothing else, due mainly to the lack of thread safety in PHP apps. Alternately, the app could be configured to run under IIS using CGI, but CGI is a resource hog (one process per request) and results in an app that scale poorly in IIS.

The latest version of IIS(7.0) now allows for the targeting of none .Net Framework apps. Through its "FasstCGI" component, core ASP.Net features can now be used declaratively in Apps written to target other Frameworks.

For example, IIS 7 allows PHP, Ruby, Perl etc to utilize the ASP.Net Integrated mode engine to take advantage of features like ASP.Net membership and forms authentication, login controls etc. The new ASP.Net Integrated Pipeline feature of IIS 7.0 also allows us the ability to leverage our .net skills in applying cool features such as URL-rewriting, Output caching to these none asp.net apps by writing modules that can be plugged directly into the request processing pipeline via IIS. If you are unfortunate enough to be still running a couple of classic ASP pages within your .net Framework application, you will be releieved to know that IIS7.0 now makes it possible for these classic ASP pages to utilize functionality that per previously unavailable under IIS 5.x/ 6.

If you are developing under Windows Vista, you already have acccess to IIS 7.0. On the Server end, IIS 7.0 will be realeased with windows Server 2008 in Late February. The FastCGI component will be avaialable with this release of windows Server 2008, under Vista, its available via Service pack 1.

Web.Config: Multiple file configurations

2007-07-12T15:06:00Z

ASP.NET Web.Config files provide a configuration system we can use to keep our applications flexible at runtime. In this article we will examine a simple technique for using the configuration system for the best results.

The < appSettings > element of a web.config file is a place to store connection strings, server names, file paths, and other miscellaneous settings needed by an application to perform work. The items inside appSettings are items that need to be configurable depending upon the environment, for instance, any database connection strings that will change as our applications are moved from a testing/staging server into a production environment.

Developers often find themselves having to take extra care not to overwrite web.config file as they move code from one environment to the next, typically from develeopment, to staging/testing, and finally to production. Let's take a look at a little known feature of the appSettings element that can give us even more flexibility (see source code in url below).

The appSettings element may contain a file attribute that points to an external file.If the external file is present, ASP.NET will combine the appSettings values from web.config with those in the external file. If a key/value pair is present in both files, ASP.NET will use the value from the external file.

This feature is useful when you keep user-specific or environment-specific settings in the external file. Let web.config contain those settings that are global to all the installed instances of your application, while each user or installed site contains their own settings in an external file. This approach makes it easier to move around global web.config changes and keep web.config checked into source control, while each developer can get their own settings separate.

One caveat to this approach is that the ASP.NET runtime does not detect when the external file changes. You’ll need to make changes to web.config itself for ASP.NET to launch a new version of the application with all changes in effect.

In the attached code snippet (see link below), lines 2 through 8 shows a typical implemention of a web.config file that points to an external configuration file. Lines 13 through 15 shows what the external file might look like.

http://www.solid2.com/jaycent/articles/code_display.aspx?codeid=adedb5b5-ca86-4dbe-9c5e-1a16dd45b292