In 2006, Microsoft announced a new data framework, ADO.NET vNext. This has since become the ADO.NET Entity Framework (EF) and was released with .NET 3.5/Visual Studio 2008 SP1 in August of 2008. The Entity Framework is an entry from Microsoft into the object relational mapping (ORM) space. ORMs are data frameworks aimed at bridging the gap between data stores (databases) and applications. Entity Framework is an example of an ORM; Linq to SQL, nHibernate, Wilson ORM, and many others are also available for the .NET platform. All have attractive features and provide a way to abstract the database from the application to make it easier for developers to program an application based on business needs and not the database schema.

The Entity Framework's Entity Data Model (EDM) is composed of several elements and is ultimately based on Dr. Peter Chen's Entity Relationship (ER). ER is the conceptual representation of business elements and the relationships they have with each other. The EDM is what really differentiates the Entity Framework from other ORM products. The EDM builds a layer of abstraction above the ER model, but preserves the concepts of entities and their relationships.

What the Entity Framework does provide is a consistent way to program against a model that is abstracted away from the way the data is actually stored. As applications have evolved, the data is no longer necessarily stored in a manner that is easy to conceptualize in an application. Data is often optimized for speed, indexing, and other considerations for the actual data store technology, which can create a problem — often referred to as an impedance mismatch — when you're trying to efficiently create applications around the data model. This is where EF becomes a valuable tool to the developer because it abstracts the complex data storage schemas from the developer. The developer can then simply concern herself with the business entity model when architecting solutions.

The actual data model for the Beer House is pretty straightforward, so we will not be dealing with this issue as you might have to in more complex applications. All the entity mappings in the Beer House are one-to-one, instead of being an entity composed of related data in many tables.

The EDM (see Figure 3-5) consists of two concepts: entities and relationships. An entity is a thing, such as an article or an article category. A relationship is an association, such as the category an article belongs or a list of comments for the article. Article Categories, Comments, and Articles are all entities or things; the association they have to each other is the relationship. Typically, you can think of these as tables and foreign key relationships, and often this is how the model will be generated.

Figure 3.5. Figure 3-5

A group of entities is called an EntitySet, which is a collection of entities such as Articles, Categories, and Comments. The EntitySet class implements IList, ICollection, IList(of TEntity), ICollection(of TEntity), IEnumerable(of TEntity), IEnumerable, and IListSource. By implementing these interfaces, it provides a rich set of members to manage a collection of entities in a fashion familiar to those used to working with generics. Similarly, AssociationSets are a collection of associations. An EntityContainer wraps a group of entities and associations.

Select a, a.Comment
From ArticlesModel.Articles as a
Where a.Comment.Count > 0

Using lArticlectx As New ArticlesEntities()

Dim queryString As String = _
                "SELECT VALUE Article FROM Articles " & _
                "AS Article WHERE Article.Approved = @as"

Dim ArticleQuery As New ObjectQuery(Of Article)(queryString, _
                                lArticlectx)

' Add parameters to the collection.
ArticleQuery.Parameters.Add(New ObjectParameter("as", True))

Dim lArticles As ObjectResult(Of Article) =
ArticleQuery.Execute(MergeOption.NoTracking)

        Dim lArticle As Article
        For Each lArticle In lArticles
            Console.WriteLine("Title: {0}", lArticle.Title)
Next

LINQ to Entities

Since Language Integrated Query (LINQ) was introduced with the release of .NET 3.5, there have been many implementations of LINQ, such as LINQ to Objects, LINQ to XML, LINQ to SQL, LINQ to DataSets, and so on. Entity framework has its own implementation of LINQ as well, LINQ to Entities. LINQ to Entities is a very thin layer built on top of Object Services that takes advantage of the ObjectQuery class to perform queries.

LINQ to SQL was the first LINQ extension released that allowed developers to interact with SQL Server. The big difference is LINQ to Entities does not talk directly to the database but instead queries the Entity Framework that does the talking. This means that LINQ to Entities can talk to any data store as long as there is an EF provider for the platform. LINQ queries are converted to expression trees and executed against the Object Services layer and return an IQueryable(of T) result (see Figure 3-6).

Figure 3.6. Figure 3-6

The EF ObjectServices layer exposes a conceptual view of the data, which is ideal for LINQ queries to manipulate. This gives the developer a Transact SQL-like programming experience in the application and development environment. LINQ also adds lambda expressions, making for an even richer development experience. Because the queries are written in the application, the developer has development aides, such as IntelliSense, compile-time syntax checking, and so forth, to make building queries against the Entity Model much easier. LINQ to Entities gives the developer the ability to create strongly typed queries that will have any errors in syntax caught by the compiler.

To perform LINQ to Entities, the application must reference System.Core.dll and System.Data.Entity.dll. It must also import the System.Linq and System.Data.Objects namespaces. Of course, the application must either contain or reference an Entity Data Model as well.

Many of the LINQ to SQL concepts are supported by LINQ to Entities, but there are a few instances where things are done slightly differently or are not supported at all.

The LINQ standard query operators are supported, so query results can be shaped, filtered, sorted, and grouped. Common operators like Select, Where, Join, and OrderBy, and the aggregate and set operators are all supported. For more details read more about standard query operators on MSDN at http://msdn.microsoft.com/en-us/library/bb738551.aspx.

A LINQ to Entities query is executed by creating an expression tree that is executed by EF against the data source. All EF queries are executed using deferred execution, meaning that they must be either explicitly executed or are not executed until they are used. The concept of implicit and deferred execution is important to understand when discussing ORM frameworks. You will also hear the term lazy loading in reference to deferred loading. This means that data is not actually loaded or queried from the database until it is explicitly requested.

In the following example, a Linq to SQL statement is used to load an article's comments into a ListView control, using deferred execution.

Using linqToSqlContext as new L2SDataContext()

lvComments.DataSource = linqToSqlContext.Articles.First().Comments
lvComments.DataBind()

End Using

Using the same pattern with an EF model will result in 0 comments being returned because EF does not support lazy loading. Instead, you must explicitly load the comments as illustrated in the following snippet because you have to tell EF you want to include an article's comments:

Using EFContext as new EFDataContext()

lvComments.DataSource = EFContext.Articles.Include("Comments").First().Comments
lvComments.DataBind()

End Using

Or

Using EFContext as new EFDataContext()

Dim lArticle as List(of Articles) = EFContext.Articles
lArticle.Comments.Load()
lvComments.DataSource = lArticle.Comments
lvComments.DataBind()

End Using

The reason for this is to make developers aware that they are accessing the database. The first example eagerly loads the list of comments when the article is retrieved. The second example explicitly loads the list of comments only when they are needed. Eagerly loading typically results in fewer hits on the database, which makes DBAs happy but can put more pressure on system memory because more data is loaded that may not be used; it also causes the extra data to travel across the wire. Explicit loading ultimately results in more hits on the database but uses less memory as well as resulting in a lighter load being sent across the wire. Ultimately, the choice is up to you, based on your system design and overall demands.

Because queries are deferred, multiple queries can be executed at once. The query variable actually stores the commands, as they are added and not executed until the command is iterated over. For example, you could designate a query to retrieve a list of articles, another to retrieve a list of categories and yet another query to get a list of approved comments against the same DataContext. These queries will not be executed until at least one is explicitly executed; that causes all three to be exectuted against the data store simultaneously. If you look at the connection string generated by the Entity Data Model Wizard, you will see that it sets MultipleActiveResultSets= true. MultipleActiveResultSets (MARS) allows applications to execute more than one SQL statement on a connection in the same request. EF leverages MARS by executing any statements that need to be executed in a single transaction, thus increasing application performance.

Immediate execution is done whenever a scalar query is executed, Avg, Max, Sum, Min, and so forth. These queries require all the query results to be returned so that the scalar value can be calculated. Immediate execution can also be forced by calling one of the enumeration methods: ToArray, ToDictionary and ToList. These methods return the results to a corresponding collection object.

Extending Entity Framework in an N-Tier Environment

The Visual Studio Entity Framework experience provides a helpful visual Designer to create and manage the Entity Model. The wizard creates a strongly typed ObjectContext and one or more custom entity classes derived from EntityObject. These objects can be easily extended using the partial class model, introduced in .NET 2.0.

While it may not be obvious at first glance, the Entity Framework is easily integrated into a standard n-tier model. The Entity Framework itself sits on top of the actual data access layer, ADO.NET 3.5. Above the Entity Framework sits a custom business layer. But the bridge between the Entity Framework and the business logic layer is a thin layer of customized objects that further customize the Entity Framework services.

The n-tier architecture used in the Beer House consists of a custom ObjectContext class generated by the Entity Model Wizard, a series of entity repositories, and custom entity classes generated by the wizard and extended. The Repository model is similar to the Active Record model, except the entity just holds data that composes an object, for example a SiteMapInfo in the SiteMap. Instead of the entity also containing members responsible for retrieving records from the database, the Repository class contains members responsible for interacting with the database, such as doing standard CRUD operations. The Entity Data Model Wizard creates a series of classes that represent each of the entities and a derived ObjectContext with some basic members for interacting with EF. The classes the wizard generates are all marked partial, as are some of the class members. For example, each property in an entity has an OnChanging and OnChanged partial method. These partial methods can be extended or defined in your own partial class. The following code example demonstrates the generated SiteMapInfo's SiteMapId property code.

<Global.System.Data.Objects.DataClasses.EdmScalarPropertyAttribute(
EntityKeyProperty:=true, IsNullable:=false),
         Global.System.Runtime.Serialization.DataMemberAttribute()>  _
        Public Property SiteMapId() As Integer
            Get
                Return Me._SiteMapId
            End Get
            Set
                Me.OnSiteMapIdChanging(value)
                Me.ReportPropertyChanging("SiteMapId")
                Me._SiteMapId =
Global.System.Data.Objects.DataClasses.StructuralObject.SetValidValue(value)

Me.ReportPropertyChanged("SiteMapId")
                Me.OnSiteMapIdChanged
            End Set
        End Property
        Private _SiteMapId As Integer
        Partial Private Sub OnSiteMapIdChanging(ByVal value As Integer)
        End Sub
        Partial Private Sub OnSiteMapIdChanged()
        End Sub

The two partial members are stubbed out in the generated class and marked as partial. These methods can be defined in your extension class, most likely to add some sort of validation to the process of changing the value. For example if the SiteMapId is out of an expected range of numbers, maybe a description is too long or a phone number is unacceptable. In the following example the SiteMapId has to be greater than 0; if it is a negative value, an ArgumentException is thrown. This exception can then be caught and handled appropriately, rather than letting the invalid data get caught by the database or, worse yet, committed to the database.

Public Class SiteMapInfo

        Private Sub OnSiteMapIdChanging(ByVal value As Integer)
            If value < 0 Then
                Throw New ArgumentException("The SiteMapId cannot be less than 0.")
            End If
        End Sub

    End Class

The code generated by the wizard creates two types of classes, a custom ObjectContext class with some helper methods to facilitate interacting with the Entity Model and a EntityObject for each entity. Figure 3-7 shows these relationships.

Figure 3.7. Figure 3-7

The custom ObjectContext class not only wraps up all the members of the ObjectContext but also provides read-only properties that represent an ObjectQuery of each of the entities in the model. This makes querying each of the entity types fairly trivial as well as making LINQ queries much simpler. The following example shows the property that represents a collection of SiteMapInfos in the database:

Public ReadOnly Property SiteMaps() As Global.System.Data.Objects.ObjectQuery(
Of SiteMapInfo)
Get

If (Me._SiteMaps Is Nothing) Then
                    Me._SiteMaps = MyBase.CreateQuery(Of SiteMapInfo)("[SiteMaps]")
                End If
                Return Me._SiteMaps
End Get
End Property
Private _SiteMaps As Global.System.Data.Objects.ObjectQuery(Of SiteMapInfo)

In this code, SiteMaps is of type ObjectQuery(Of SiteMapInfo). The CreateQuery call processes the ESQL statement "[SiteMaps]" to return a collection of SiteMapInfo objects. The Get accessor also checks to see if the collection has already been built before it makes the query to the database, adding a little performance gain.

If you are familiar with basic LINQ syntax, the next example should be easy. The property exposes the data as an ObjectQuery(T), which can be further manipulated or used as is. ObjectQuery(T) is a query that uses the ObjectContext connection and metadata information to perform a query against an entity model. Before an ObjectQuery(T) actually executes the query against the entity model it can be further transformed, such as adding a Sort By or Where clause to the query. In the example, Categories is exposed as an ObjectQuery(T), and you can see how to retrieve a list of active SiteMapInfos using basic LINQ syntax.

Public Function GetSiteMapNodes() As List(Of SiteMapInfo)

Dim lSiteMapNodes As List(Of SiteMapInfo)

SiteMapctx.SiteMaps.MergeOption = MergeOption.NoTracking
lSiteMapNodes = (From lSiteMapNode In SiteMapctx.SiteMaps _
            Where lSiteMapNode.Active = True _
Order By lSiteMapNode.SortOrder).ToList()

Return lSiteMapNodes

End Function

In the example, I set the MergeOption to NoTracking, which means that the entities returned will not be attached to the context. This is important when returning collections of entities that will not need to have their state tracked by the context. This is common when caching content, and I will show this in practice later as I explore how a repository will be architected and results cached.

As I continue explaining how the Entity Framework can be leveraged in theBeerHouse application, I will continue to expand the model into a true n-tier architecture by extending the generated entity objects and creating corresponding object repositories to manage the queries to and from the database.

While there are command-line tools to generate a model for the Entity Framework, Visual Studio 2008 SP1 has a built-in wizard that takes care of making all the necessary code for a valid model. Once you have a model built with the wizard, you have a graphical surface to manage the model from, making it easy to apply updates and customize the model.

To add an Entity Model to a website, WPF application, or class library, first you add a new ADO.NET Entity Data Model to the project. This is added just like any new item, by right-clicking the root node or folder in the project and selecting Add New Item from the context menu (or by using the keyboard shortcut Ctrl+Shift+A) to open Visual Studio's Add New Item dialog (see Figure 3-8). For theBeerHouse application I am going to add the model to the class library I am creating to hold the business side of the application.

Figure 3.8. Figure 3-8

You will find the ADO.NET Entity Data Model item in the Common items, but you can probably find it more quickly by selecting the Data node in the Categories tree on the left side of the dialog.

Once you select the model type, give it a valid name. In this case, I am adding the SiteMap table that will be the foundation of all the navigation in the site and naming it SiteMapModel.

Click the Add button on the New Item dialog to start the Entity Data Model Wizard. In the first window (see Figure 3-9), select the option Generate From Database.

The next screen in the wizard builds the connection string needed by the Entity Framework to connect to the data source. If you already have a valid Entity Framework connection string available, you will see it in a drop-down at the top of the window. If you do not have a connection string or you need to create a new one, click the New Connection button to open the Connection Properties dialog (see Figure 3-10).

This should be a familiar dialog if you have ever set up a connection string from a Microsoft development tool like SQL Management Studio or Visual Studio. To use this dialog, enter the server name or address. If you are connecting to a database on your development machine, you can use (local) or just a "." as shown in Figure 3-10. Note that you can connect to a database file if you are using SQL Express. The connection string will be slightly different, but because the wizard creates it for you, there is nothing you need to do different in the rest of the wizard. Just use the connection dialog to make the connection to your SQL Express database the way you normally would.

Figure 3.9. Figure 3-9

Figure 3.10. Figure 3-10

Once you have created the connection string to the data source, you will notice the name has been predefined and consists of the server name, a period, the name of the database, another period, and dbo.

The Entity Connection String (outlined in Figure 3-11) shows you the real connection string used by the Entity Framework to connect to the data source.

Figure 3.11. Figure 3-11

Notice that there is more information in this connection string than in a traditional .NET connection string. The Wizard will ultimately place a copy of the model's connection string in either web.config (if being added directly to a web site project) or app.config (if being added to a Class Library or non-web application project) as shown in the following snippet:

<connectionStrings>
<add name="TheBeerHouseEntities"
connectionString="metadata=res://*;provider=System.Data.SqlClient;
provider connection string="Data Source=.;
Initial Catalog=TheBeerHouseVB;
Integrated Security=True;
MultipleActiveResultSets=True""
providerName="System.Data.EntityClient"/>
</connectionStrings>

An Entity Framework connection string is actually composed of a series of semicolon-delimited values; metadata, provider, and provider connection string. The metadata pair specifies a pipe-delimited list of directories, files, and resources that contain metadata and mapping information for the Entity Framework. The wizard typically creates a generic value for this "res://*". This value tells the Entity Framework to load any possible values from the application, including all referenced assemblies and anything else that might be in the bin folder.

Typically, the metadata will point to a file resource containing the EDM and metadata mapping; these values can be stored as a resource in an assembly. In this case, the values need to be supplied in the following format: res://<assemblyFullName>/<resourceName>. assemblyFullName would be the same complete format you would use to register an assembly in the references section of the web.config file; assembly file name, version, culture, and PublicKeyToken. The resourceName value points to the specific resource embedded in the assembly.

But the metadata value can be used to specify the location of particular resources that define the Entity Model. For example, the CSDL (Conceptual Schema Definition Language), SSDL (Store Schema Definition Language), and MSL (Mapping Specific Language) files. When the wizard generates the model for you, the content of these files is stored in the Designer file, .edmx. Unless you plan on generating the CSDL, SSDL, and MSL at the command line, you will never have to deal with these model definition files. In fact, it is in your best interest to not modify the content of these sections; remember that they are generated sections in the Designer file when using the wizard, because they are not well documented and very interrelated. The wizard generates a Designer file that contains each of these sections for the model. You can read more detail on these sections on MSDN (http://msdn.microsoft.com/en-us/library/bb399604.aspx); because intimate knowledge of these sections is not needed to work with Entity Framework I will not pursue them any further. Any changes you want to make to these sections can be done through the Designer in Visual Studio and will be done correctly.

The provider pair specifies the type of provider for the Entity Framework to use. Remember Entity Framework is not database-specific, and various providers are available to work with it. When working with SQL Server, this value is System.Data.SQLClient, which is the familiar namespace we have been using since the beginning of .NET to connection to SQL Server.

The Provider Connection String pair is where the value of the more traditional connection string is located. So, if you have an existing connection string to connect to the database, you can still use that; you would need to place it in this section of the Entity Framework-specific connection string.

At the bottom of the wizard, check the box to Save entity connection settings in App.Config as. That stores the connection string in the config file of the application, which will save you work later because the wizard will create the correct connection string instead of you having to do it.

Clicking the Next button takes you to the Choose Your Database Objects page (see Figure 3-12), which displays a list of tables, views, and stored procedures you can use to build the model. For this example, you are going to build a model around the site map, so expand the Tables node and scroll down the list of tables till the SiteMap table is displayed. Check the node so that it will be used to build the model. If there were more tables to add to the model, you would check them as well. You will do this in later chapters.

Figure 3.12. Figure 3-12

At the bottom of the page, specify the name of the Entity Model, in this case enter SiteMapModel. This will be used to identify the Entity Model and context for the site map. Click Finish to create the model. When the model has been created, the Designer will be displayed, showing a list of entities in the model. This looks a lot like the class diagram that was introduced with Visual Studio 2005, as shown in Figure 3-13.

Before you save the model, rename the entity something other than SiteMap to avoid confusion with the SiteMap already built into the .NET framework. I chose SiteMapInfo. It is also smart to change the Entity Set Name. The wizard will call it SiteMapSet, which just does not sound natural; I changed it to SiteMapInfos.

You can change both of these values by selecting the SiteMap entity in the Model Designer and pressing F4. This opens the entity's properties, which allows you to modify these properties as shown in Figure 3-14.

Figure 3.13. Figure 3-13

Figure 3.14. Figure 3-14

Additionally, you can change the property names in the entity by bringing up their property window or clicking on the name itself in the Designer. You can change even more of a property's values in the Properties window (see Figure 3-15), accessed by selecting the property in the Designer and pressing F4.

Figure 3.15. Figure 3-15

Each property has a getter and a setter, and the access modifier can be changed from the default Public to Internal, Private, or Protected. It is interesting to note the getter and setter of a property can have differing access modifiers.

To make the Entity Framework check for optimistic concurrency on the property, change the Concurrency Mode to Fixed.

You can also set a default value for the property, which you should do for the Active field in the tables. This field is used to indicate if a record has been deleted, so it should be set to true. As I review more entities in the site, you will see that there are a few other fields that should have default values. These default values are assigned to the properties backing property. For example Active's backing property, _Active : Private _Active As Boolean = true.

Active is a new field added to each of the tables in the database from previous versions of the BeerHouse. I was taught early in my career when dealing with records in a database to rarely actually delete a record from the database. In many cases, there are legal reasons for this, but practically it can make running your application much easier. A common scenario is that a user accidentally deletes a record from the database; if you physically deleted the record from the database, you would have to either go through a full database restore to return the record or reenter the record. The first resolution is a major task that may or may not be allowed by the system DBAs. The latter method often means you have corrupted data, since the original data is gone along with any relationships and activity trail. If you add the extra Active field to a table, you can simply flip the bit to true or false. If a record needs to be restored, this can be done with a simple operation, instead of a major one.

The Documentation property gives you a place to store a long description and a summary for the entity. Entity Key is true if the field is part of the primary key of the associated table(s). Typically, you will want to let the wizard determine this for you.

The Name property is the Name used to access the value of the field. For example, you may have a field name that is not the friendliest of names or more commonly the name of a relationship. Later I will explain the architecture of the Articles module, which has a relation between the Articles table and the Categories table. There is only one category per article, so renaming the property to Category makes more sense.

Nullable indicates if the field accepts null values or not. This actually sets the EdmScalarPropertyAttribute's IsNullable property. This basically indicates that the database field can accept null as a valid value.

Finally, the Type property indicates what type of object is represented by the property. For example, value types like String and Integer or any custom object you may want to use.

I want to step ahead a little and talk about customizing relationships in the Designer. Because the SiteMap consists of just one table, I am going to use the model for the Articles module. I will go over this model in detail in Chapter 5, but for now I want to focus on the relationships.

When an entity has a relationship to another entity a Navigational Property is generated. This will be initially defined as the name of the foreign entity. So, in the case of an Article, it has a many-to-one relationship to Categories and a one-to-many relationship to Comments. Just like the names of the entities, the name of the Navigational Property can be changed. Just click on the name in the entity and change it to the desired name. The Navigational Property can also be opened and the name changed there as well.

Notice the other Navigation properties are disabled (see Figure 3-16). That's because they are tied to the underlying data store and should not be changed in the Designer.

Figure 3.16. Figure 3-16

After customizing any values in the entity Designer, save the model. Behind the Designer is a code-behind file (in this case, SiteMapModel.Designer.vb) that contains a custom ObjectContext class and a custom EntityObject class to represent any entities.

Back in the Data Connection step of the wizard, it asks the developer to designate the Model Namespace value, for the SiteMap model, I designated SiteMapEntities as the name. This value is used as the name of the custom ObjectContext class the wizard generates.

Partial Public Class SiteMapEntities
    Inherits Global.System.Data.Objects.ObjectContext

Each model has one class that derives from System.Data.Objects.ObjectContext, SiteMapEntities in this case. The System.Data.Objects.ObjectContext class actually does the heavy lifting to interact with the Entity Framework. The ObjectContext class has numerous methods and properties and the SavingChanges event. I'll explain many of these as I review how the repositories work.

The following table describes the class's methods.

Here's a look at the properties of the ObjectContext class:

The SavingChanges event occurs when changes are saved to the data source.

Public Sub New()
            MyBase.New("name=SiteMapEntities", "SiteMapEntities")
            Me.OnContextCreated
End Sub

Public Sub New(ByVal connectionString As String)
            MyBase.New(connectionString, "SiteMapEntities")
            Me.OnContextCreated
End Sub

Public Sub New(ByVal connection As
Global.System.Data.EntityClient.EntityConnection)
            MyBase.New(connection, "SiteMapEntities")
            Me.OnContextCreated
End Sub

Private _SiteMapctx As SiteMapEntities
Public Property SiteMapctx() As SiteMapEntities
Get
                If IsNothing(_SiteMapctx) Then
                    _SiteMapctx = New SiteMapEntities(GetActualConnectionString())
                End If

                Return _SiteMapctx
End Get
Set(ByVal Value As SiteMapEntities)
                _SiteMapctx = Value
End Set
End Property


Public Sub New(ByVal sConnectionString As String)
            ConnectionString = sConnectionString
            CacheKey = "SiteMap"
End Sub

Public Sub New()
            ConnectionString = Globals.Settings.DefaultConnectionStringName
            CacheKey = "SiteMap"
End Sub

Public ReadOnly Property SiteMapInfos()
As Global.System.Data.Objects.ObjectQuery(Of SiteMapInfo)
            Get
                If (Me._SiteMapInfos Is Nothing) Then
                    Me._SiteMapInfos = _
                       MyBase.CreateQuery(Of SiteMapInfo)("[SiteMapInfos]")
                End If
                Return Me._SiteMapInfos
            End Get
End Property
Private _SiteMapInfos As Global.System.Data.Objects.ObjectQuery(Of SiteMapInfo)

Public Sub AddToSiteMaps(ByVal siteMapInfo As SiteMapInfo)
            MyBase.AddObject("SiteMaps", siteMapInfo)
        End Sub

Public Class SiteMapEntities

        Private Sub SiteMapEntities_SavingChanges(ByVal sender As Object,
ByVal e As System.EventArgs) Handles Me.SavingChanges
            Dim typeEntries = (From entry _
         In Me.ObjectStateManager.GetObjectStateEntries(EntityState.Added Or
 EntityState.Modified) _
        Where TypeOf entry.Entity Is IBaseEntity).ToList()

            For Each ose As System.Data.Objects.ObjectStateEntry In typeEntries

                Dim lBaseEntity As IBaseEntity = DirectCast(
ose.Entity, IBaseEntity)

                If lBaseEntity.IsValid = False Then
                    Throw New BeerHouseDataException(
String.Format("{0} is Not Valid", lBaseEntity.SetName), "", "")
                End If

            Next

        End Sub
    End Class

The Active Record pattern contains a series of methods that interact with the database. These methods (I call them worker methods) make the record's object active, so to speak. An active record places all the worker methods in the entity object, which means that it is all one self-contained class, but that can lead to architecture issues as the application grows. This is a very popular pattern to use and keeps things pretty simple to manage. There are fewer objects to instantiate and manage; the problem that arises is separating concerns. Because all the business methods are built into the class, you cannot separate these from the values in the record itself.

Imports System.Web
Imports System.Web.Caching
Imports System.Security.Principal

Namespace BLL

Public MustInherit Class BaseRepository
Implements IDisposable

Private disposedValue As Boolean = False        ' To detect redundant calls

        ' IDisposable
        Protected MustOverride Sub Dispose(ByVal disposing As Boolean)

#Region " IDisposable Support "
        ' This code added by Visual Basic to correctly implement the
disposable pattern.
        Public MustOverride Sub Dispose() Implements IDisposable.Dispose

Private disposedValue As Boolean = False        ' To detect redundant calls

        ' IDisposable
        Protected Overrides Sub Dispose(ByVal disposing As Boolean)
            If Not Me.disposedValue Then
                If disposing Then

                    If IsNothing(_SiteMapctx) = False Then
                        _SiteMapctx.Dispose()

End If

                End If

            End If
            Me.disposedValue = True
        End Sub

        ' This code added by Visual Basic to correctly implement the
disposable pattern.
        Public Overrides Sub Dispose()

            Dispose(True)

            GC.SuppressFinalize(Me)
        End Sub

Public Const DefPageSize As Integer = 50
Protected Const MAXROWS As Integer = Integer.MaxValue

#Region " Properties "

        'Needs to be definable in the config file and stored in the app cache
        Private _enableCaching As Boolean = True
        Private _cacheDuration As Integer = 0

        Protected Property EnableCaching() As Boolean
            Get
                Return _enableCaching
            End Get
            Set(ByVal value As Boolean)
                _enableCaching = value
            End Set
        End Property

        Protected Property CacheDuration() As Integer
            Get
                Return _cacheDuration
            End Get
            Set(ByVal value As Integer)

_cacheDuration = value
            End Set
        End Property

        Private _cacheKey As String = "CacheKey"
        Public Property CacheKey() As String
            Get
                Return _cacheKey
            End Get
            Set(ByVal Value As String)
                _cacheKey = Value
            End Set
        End Property

#End Region

#Region " Cache "

        Protected Shared ReadOnly Property Cache() As Cache
            Get
                Return HttpContext.Current.Cache
            End Get
        End Property

        Protected Shared Sub CacheData(ByVal key As String, ByVal data As Object)
            If Not IsNothing(data) Then
                Cache.Insert(key, data, Nothing, _
                    DateTime.Now.AddSeconds(120), TimeSpan.Zero)
            End If
        End Sub

        Protected Sub PurgeCacheItems(ByVal prefix As String)
            prefix = prefix.ToLower
            Dim itemsToRemove As New List(Of String)

            Dim enumerator As IDictionaryEnumerator = Cache.GetEnumerator()
            While enumerator.MoveNext
                If enumerator.Key.ToString.ToLower.StartsWith(prefix) Then
                    itemsToRemove.Add(enumerator.Key.ToString)

End If
            End While

            For Each itemToRemove As String In itemsToRemove
                Cache.Remove(itemToRemove)
            Next
        End Sub

#End Region

Private _connectionString As String = "Set the ConnectionString"
Public Property ConnectionString() As String
Get
                Return _connectionString
End Get
Set(ByVal Value As String)
                _connectionString = Value
End Set
End Property

Protected Function GetActualConnectionString() As String
Return ConfigurationManager.ConnectionStrings(ConnectionString).ConnectionString

End Function

Public Sub New(ByVal sConnectionString As String)
ConnectionString = sConnectionString
CacheKey = "SiteMap"
End Sub

Public Sub New()

    ConnectionString = Globals.Settings.DefaultConnectionStringName

CacheKey = "SiteMap"

End Sub

Protected Shared ReadOnly Property CurrentUser() As IPrincipal
Get
                Return HttpContext.Current.User
        End Get
End Property

Protected Shared ReadOnly Property CurrentUserName() As String
Get
                Dim userName As String = String.Empty
                If CurrentUser.Identity.IsAuthenticated Then
                    userName = CurrentUser.Identity.Name
                End If
                Return userName
        End Get
End Property

Protected Shared ReadOnly Property CurrentUserIP() As String
Get
                Return HttpContext.Current.Request.UserHostAddress
        End Get
End Property

Protected Shared Function EncodeText(ByVal content As String) As String
            content = HttpUtility.HtmlEncode(content)

content = content.Replace("  ", "   ").Replace("
", "<br>")
            Return content
End Function

Protected Shared Function ConvertNullToEmptyString(ByVal input As String) As String
            If String.IsNullOrEmpty(input) Then
                Return String.Empty
            Else
                Return input
            End If
End Function

Examining a Repository

It all starts with a BaseRepository class that contains some common properties and methods that will be used by all the repositories in the BLL. It is marked as MustInherit, (abstract in C#), meaning that it cannot be instantiated on its own and must be inherited by another class and it can be instantiated. The BaseRepository class only provides common helper properties and methods that help you work with data.

The next class in the hierarchy is the BaseArticleRepository class, which contains one key member, Articlesctx. The Articlesctx property wraps around an ArticlesEntities object ArticlesEntities is a customized ObjectContext object created by the Entity Framework Wizard. The Articlesctx property wraps around a private variable. The property checks to see if an ArticlesEntities context has already been created, and if not, creates one and returns it. The structure and relationship of these classes is illustrated in Figure 3-18.

Private _Articlesctx As ArticlesEntities
Public Property Articlesctx() As ArticlesEntities
Get
If IsNothing(_Articlesctx) Then
               _Articlesctx = New ArticlesEntities(GetActualConnectionString())
            End If
            Return _Articlesctx
         End Get
         Set(ByVal Value As ArticlesEntities)
            _Articlesctx = Value
         End Set
End Property

The reason why there is a BaseArticleRepository class is that the news module consists of three entity types: Article, Category, Comment. I have created a targeted repository for each entity. In this example, I am showing the ArticleRepository class. The ArticleRepository class contains a series of methods to interact with the Entity Framework and database to retrieve, insert, update, and delete articles. I will detail the members in Chapter 5. The BaseArticleRepository holds common members used by each of the child repositories. In this case, it is a set of constructors and the ArticleContext object. Each of these members is used by the child repositories.

Figure 3.18. Figure 3-18

The Entity Framework Model Wizard generates a series of partial classes that can be extended to integrate custom logic and properties. Each entity in the Entity Model is derived from the System.Data.Objects.DataClasses.EntityObject class. This ensures each entity contains some base members that allow it to interact with the EF Object Services.

The Article class consists of a partial class distributed across two files. The Entity Framework Wizard generates the core class that consists of properties, methods, and events related to the data that represents a news article. All custom entities inherit from EntityObject and extend its functionality. The entity's class is adorned with attributes that describe it to the Entity Framework.

<Global.System.Data.Objects.DataClasses.EdmEntityTypeAttribute(
NamespaceName:="ArticlesModel", Name:="Article"), _
     Global.System.Runtime.Serialization.DataContractAttribute(
IsReference:=True), _
     Global.System.Serializable()> _
    Partial Public Class Article
        Inherits Global.System.Data.Objects.DataClasses.EntityObject

Each entity contains at least a series of properties that represent data. They are prefixed with a series of attributes that describe the property to the Entity Framework. Examining the code sample that follows for the ArticleID property, you can see it is an EntityKeyProperty and is not nullable. I assume that you are familiar with how tables are defined in SQL Server, so looking at these attributes, you can quickly ascertain this property probably represents at least one of the primary key fields in a table. In this case, it is the primary key in the database, and it is the primary key of the entity as well. Remember, an entity does not have to actually have a one-to-one mapping with database tables.

The setter portion of the property has some features I want to discuss. First, there are a couple of extra methods defined below it: OnArticleIDChanging and OnArticleIDChanged. These are both marked as partial methods, meaning that you can create another partial class to extend these methods and give them body. Typically, if you had some sort of custom validation logic that needed to be executed, extending these methods would be a good idea.

<Global.System.Data.Objects.DataClasses.EdmScalarPropertyAttribute(
EntityKeyProperty:=True, IsNullable:=False), _
Global.System.Runtime.Serialization.DataMemberAttribute()> _
Public Property ArticleID() As Integer
Get
                Return Me._ArticleID
End Get
Set(ByVal value As Integer)
                Me.OnArticleIDChanging(value)
                Me.ReportPropertyChanging("ArticleID")
                Me._ArticleID =
Global.System.Data.Objects.DataClasses.
StructuralObject.SetValidValue(value)
                Me.ReportPropertyChanged("ArticleID")
                Me.OnArticleIDChanged()
End Set
End Property
Private _ArticleID As Integer
Partial Private Sub OnArticleIDChanging(ByVal value As Integer)
End Sub
Partial Private Sub OnArticleIDChanged()
End Sub

This example creates the body of the OnArticleIdChanging method in a custom extension to the Article class to validate the value is 0 or greater. If it is not, a new ArgumentException is thrown explaining the issue.

Private Sub OnArticleIDChanging(ByVal value As Integer)
If value < 0 Then
Throw New ArgumentException("The ArticleId cannot be less than 0.")
    End If
End Sub

The next items to note are the calls to the ReportPropertyChanging and ReportPropertyChanged methods in the Set accessor of the ArticleID property. The ReportPropertyChanging method is part of the EntityObject class and is called to notify the IEntityChangeTracker that the value is about to change, so it can cache the initial value. Similarly, the ReportPropertyChanged method is called to commit the cached value and call the EntityMemberChanged method. This collectively works with the state manager to manage the current state of the entity. So, when the SaveChanges method is called on the entity context, it will know which entities to commit to the database.

The next thing to examine in the generated code is how references are handled. In the case of an article, it needs to belong to a category, which is a many to one foreign key relationship. This is indicated by the EdmRelationshipNavigationPropertyAttribute attribute. This attribute does the linking between the entity and the related entity. In this case, it defines the foreign key relationship to the category. The Category property manages the value of the category entity to which the article belongs.

<Global.System.Data.Objects.DataClasses.EdmRelationshipNavigationPropertyAttribute(
"ArticlesModel", "FK_tbh_Articles_tbh_Categories", "tbh_Categories"), _
Global.System.Xml.Serialization.XmlIgnoreAttribute(), _
Global.System.Xml.Serialization.SoapIgnoreAttribute(), _
Global.System.Runtime.Serialization.DataMemberAttribute()> _
Public Property Category() As Category
Get
                Return CType(Me,
Global.System.Data.Objects.DataClasses.IEntityWithRelationships)
.RelationshipManager.GetRelatedReference(Of Category)(
"ArticlesModel.FK_tbh_Articles_tbh_Categories", "tbh_Categories").Value
End Get
        Set(ByVal value As Category)
                CType(Me,
Global.System.Data.Objects.DataClasses.IEntityWithRelationships)
.RelationshipManager.GetRelatedReference(Of Category)(
"ArticlesModel.FK_tbh_Articles_tbh_Categories", "tbh_Categories").Value = value
        End Set
End Property

<Global.System.ComponentModel.BrowsableAttribute(False), _
Global.System.Runtime.Serialization.DataMemberAttribute()> _
Public Property CategoryReference() As
Global.System.Data.Objects.DataClasses.EntityReference(Of Category)
Get
                Return CType(Me,
Global.System.Data.Objects.DataClasses.IEntityWithRelationships)
.RelationshipManager.GetRelatedReference(Of Category)(
"ArticlesModel.FK_tbh_Articles_tbh_Categories", "tbh_Categories")
End Get
Set(ByVal value As Global.System.Data.Objects.DataClasses.EntityReference(
Of Category))
                If (Not (value) Is Nothing) Then
                    CType(Me,
Global.System.Data.Objects.DataClasses.IEntityWithRelationships)
.RelationshipManager.InitializeRelatedReference(Of Category)(
"ArticlesModel.FK_tbh_Articles_tbh_Categories", "tbh_Categories", value)
                End If
End Set
End Property

The CategoryReference property is of type EntityReference(Of Category . An EntityReference represents the navigational relationship between an article and a category in this case. If the relationship were one-to-many, it would have an associated EntityCollection property, which is the case for article comments. But since the article can only belong to one category, the Category property is simply a single category entity.

<Global.System.Data.Objects.DataClasses.EdmRelationshipNavigationPropertyAttribute(
"ArticlesModel", "FK_tbh_Comments_tbh_Articles", "tbh_Comments"), _
Global.System.Xml.Serialization.XmlIgnoreAttribute(), _
Global.System.Xml.Serialization.SoapIgnoreAttribute(), _
Global.System.Runtime.Serialization.DataMemberAttribute()> _
Public Property Comments() As
Global.System.Data.Objects.DataClasses.EntityCollection(Of Comment)
Get
                Return CType(Me,
Global.System.Data.Objects.DataClasses.IEntityWithRelationships)
.RelationshipManager.GetRelatedCollection(Of Comment)(
"ArticlesModel.FK_tbh_Comments_tbh_Articles", "tbh_Comments")
End Get
Set(ByVal value As Global.System.Data.Objects.DataClasses.EntityCollection(
Of Comment))
                If (Not (value) Is Nothing) Then
                    CType(Me,
Global.System.Data.Objects.DataClasses.IEntityWithRelationships)
.RelationshipManager.InitializeRelatedCollection(Of Comment)(
"ArticlesModel.FK_tbh_Comments_tbh_Articles", "tbh_Comments", value)
                End If
End Set
End Property

Notice the difference between the Comments property and the Category property is comments are a one-to-many relationship and, thus, require a collection of comments. In short, an EntityCollection represents the many end of the relationship.

Public Interface IBaseEntity
        ReadOnly Property IsValid() As Boolean
        Property SetName() As String

        ReadOnly Property CanEdit() As Boolean
        ReadOnly Property CanRead() As Boolean
        ReadOnly Property CanDelete() As Boolean
        ReadOnly Property CanAdd() As Boolean

    End Interface

Public ReadOnly Property IsValid() As Boolean Implements IBaseEntity.IsValid
Get
If String.IsNullOrEmpty(URL) = False And _
                    String.IsNullOrEmpty(RealURL) = False And _
                    String.IsNullOrEmpty(Title) = False Then
                    Return True
                End If
                Return False
End Get
End Property

<Global.System.Data.Objects.DataClasses.EdmScalarPropertyAttribute(
EntityKeyProperty:=True, IsNullable:=False), _
Global.System.Runtime.Serialization.DataMemberAttribute()> _
Public Property SiteMapId() As Integer
Get
                Return Me._SiteMapId
End Get
Set(ByVal value As Integer)
                Me.OnSiteMapIdChanging(Value)
                Me.ReportPropertyChanging("SiteMapId")
                Me._SiteMapId =
Global.System.Data.Objects.DataClasses.StructuralObject.SetValidValue(Value)
                Me.ReportPropertyChanged("SiteMapId")
                Me.OnSiteMapIdChanged()
End Set
End Property
Private _SiteMapId As Integer
Partial Private Sub OnSiteMapIdChanging(ByVal value As Integer)
End Sub
Partial Private Sub OnSiteMapIdChanged()
End Sub

Private Sub OnSiteMapIdChanging(ByVal value As Integer)
If value < 0 Then
                Throw New ArgumentException("The SiteMapId cannot be less than 0.")
End If
End Sub

Public ReadOnly Property AverageRating() As Double
            Get
                If Me.Votes >= 1 Then
                    Return CDbl(Me.TotalRating) / CDbl(Me.Votes)
                Else
                    Return 0.0
                End If
            End Get
End Property

When adding a new Web Form (Page) to an ASP.NET website, Visual Studio automatically adds the corresponding code-behind file with a class for the page that inherits from System.Web.UI.Page. When building an application like theBeerHouse, there is always common code that each page uses. Adding redundant code is a sign of poor programming because it adds unnecessary maintenance to the application.

In the previous edition of the book, a BasePage class was leveraged to contain those common members. This class inherits from System.Web.UI.Page and, thus, inherits all the features of the Page class needed by the BasePage class. As you examine the code of theBeerHouse site, there will be other page classes that inherit from the BasePage class. For example, there is an ArticlePage class that contains common members related to article management.

Public Class BasePage
        Inherits System.Web.UI.Page

I am going to review a few of the new members I have added to the BasePage class since the last edition. The first members manage moving Hidden Fields (think ViewState) to the bottom of the page. A hidden field is used by pages to hold values that need to be passed back to the server but not displayed to the user. The reason they exist is because the web is stateless, meaning that each request or action against the site is a completely independent action. Cookies and hidden fields are used to link requests from the server's perspective.

ViewState is unique to ASP.NET and is used to hold a variety of values, typically for web controls, but it is not limited to that duty. One of the problems with the ViewState is that it can get very bloated very quickly. It is also rendered at the top of the content. There are two problems with this; it hurts search engine optimization and it hurts perceived client-side performance.

I have seen a few studies that show search engines tend to only index the topmost parts of the content of a page. This means that if the content you want to get indexed has been pushed down the page by a large ViewState, it might not be indexed because the ViewState counts towards those precious bytes.

Large ViewState aside, page content is rendered as it is received by the browser, and hidden fields at the top of the page only hinder this by being at the front of the content stream. There are many factors that play into how fast content is rendered, but that is way outside the scope of this book. However, moving these hidden fields to the bottom of the page is important to help rendering and on-page SEO. There are drawbacks to this technique because there are many instances where ASP.NET AJAX is involved because it relies on the ViewState being present to properly function. So, if you have the ViewState moved to the bottom of the page and have issues with AJAX functioning properly, then return the ViewState to the top of the page.

Since hidden fields are injected into the content rendered by the page typically at the top of the content by ASP.NET the request has to be intercepted right after it has been rendered by the page and any controls but before it is sent down the wire. The Page class has a Render method that can be overwritten, which provides the opportunity needed to massage the content.

The BasePage class has a MoveHiddenFields Boolean property that tells the custom Render method if it should move the hidden fields to the bottom of the page. One problem I have seen with moving the hidden fields is that some controls do not execute correctly because they are looking for those fields during the page load event processing. For example, the FCKEditor does not function if the hidden fields are moved.

Private _moveHiddenFields As Boolean = True
Public Property MoveHiddenFields() As Boolean
            Get
                Return _moveHiddenFields
            End Get
            Set(ByVal Value As Boolean)
                _moveHiddenFields = Value
            End Set
End Property

Private Function MoveHiddenFieldsToBottom(ByVal html As String) As String
            Dim sPattern As String = "<input type=""hidden"".*/*>|
<input type=""hidden"".*></input>"
            Dim mc As MatchCollection = Regex.Matches(html, sPattern, _
                 RegexOptions.IgnoreCase & RegexOptions.IgnorePatternWhitespace)

Dim sb As New StringBuilder

            For Each m As Match In mc

                sb.AppendLine(m.Value)
                html = html.Replace(m.Value, String.Empty)

            Next

            Return html.Replace("</form>", sb.ToString & "</form>")
End Function

If MoveHiddenFields is true the custom Render method calls the MoveHiddenFieldsToBottom method, passing the string that contains the HTML to be rendered in the browser. This method uses a regular expression to match all the hidden fields and loop through them, removing them and appending them to a StringBuilder. Once the loop is done, all the hidden fields have been stripped from the HTML, but the last line of the method inserts them back in at the very bottom of the <form> tag. It is important to insert the hidden fields before the form tag close because they need to be included in the post back to the server managed by the form.

Protected Overrides Sub Render(ByVal writer As System.Web.UI.HtmlTextWriter)

            Dim stringWriter As New System.IO.StringWriter
            Dim htmlWriter As New HtmlTextWriter(stringWriter)
            MyBase.Render(htmlWriter)
            Dim html As String = stringWriter.ToString()

            If MoveHiddenFields Then

                html = MoveHiddenFieldsToBottom(html)

            End If

            writer.Write(html)

End Sub

Finally, the Render method writes the optimized HTML to the HTMLTextWriter, which ultimately sends the content down the wire to the client. The overall process incurs negligible overhead to optimize the page content.

The next element I want to discuss is the PrimaryKeyId property. This a common pattern used to check for the existence of a primary key being passed in the URL or stored in the page's ViewState. It first checks to see if the value has been stored in the ViewState, and if not, it then checks to see if it was passed in the URL's QueryString. If either of those criteria is not met, then it returns 0. This value will be used in pages to retrieve content, such as an article, from the database.

Public Property PrimaryKeyId(ByVal vPrimaryKey As String) As Integer
            Get
                If Not IsNothing(ViewState(vPrimaryKey)) AndAlso
 IsNumeric(ViewState(vPrimaryKey)) Then
                    Return CInt(ViewState(vPrimaryKey))

ElseIf Not IsNothing(Request.QueryString(vPrimaryKey))
AndAlso IsNumeric(Request.QueryString(vPrimaryKey)) Then
                    ViewState(vPrimaryKey) = CInt(Request.QueryString(vPrimaryKey))
                    Return CInt(Request.QueryString(vPrimaryKey))
                End If
                Return 0
            End Get
            Set(ByVal Value As Integer)
                ViewState(vPrimaryKey) = Value
            End Set
End Property

In this example, the ArticleId property of the ArticlePage class calls the PrimaryKeyId property to retrieve the value.

Public Property ArticleId() As Integer
Get
                Return PrimaryKeyId("ArticleId")
End Get
Set(ByVal Value As Integer)
                PrimaryKeyId("ArticleId") = Value
End Set
End Property

There are other members of the BasePage class that will be used as the balance of the book is presented. There are also helper classes or what I think of as utility classes that are also used to contain common methods. The reason they are important is these methods are not page-specific (meaning tied to a specific page) and might need to be used in other classes. For example, the site takes advantage of user controls and Web Parts as part of its UI architecture. They will need to access some of these methods, too.

The ListView control is new in ASP.NET 3.5 and combines the functionality of the Repeater, GridView, and Datalist controls but adds the capability to page and sort the data naturally. While it is not as lightweight as the Repeater or DataList control, it is pretty close and adds the paging and sorting capabilities built into the GridView control. Editing capabilities are also available with the ListView control, but I will not leverage this feature. All these features make it a very rich tool to display tables of data on the web.

Most examples and demos of the ListView control show how to bind the control to one of the DataSource controls. While the previous edition of this book leveraged the ObjectDataSource control and there is an EntityDataSource control, I will not use them to bind data. This technique is often not done in high-demand production sites and reduces an n-tier architecture to a flat model by making databinding line of sight to the database. Since it is very easy to bind collections to a ListView from a business layer, I have opted to use this technique.

Once data is bound to a ListView, it is displayed in an ordered fashion by using templates. If you have ever used a Repeater, a DataList, or templates to build the layout of a GridView, this will seem like second nature. There are a few new twists to the template model used in the Repeater and DataList controls, but they are minor. The ListView offers a rich set of possible templates to control how data is displayed to the end user.

The ListView displays data using a set of templates, allowing declarative and code-behind databinding. It actually uses a nested layout structure where everything starts with the LayoutTemplate and proliferates from there. The only real requirement for the LayoutTemplate is that it contains at least one control marked as a placeholder.

For the administration pages of theBeerHouse application, I use a table to create the layout of the ListView control. The first row of the table contains the header row of the data. In the example, there are Title, Edit, and Delete column. These columns are mapped to the Title property of the bound entities, followed by a column that contains image buttons that will either link to a page to edit the record or delete the record from the database.

<asp:ListView ID="lvSiteMap" runat="server">
<LayoutTemplate>
            <table cellspacing="0" cellpadding="0" class="AdminList">
    <THead>
                    <tr class="AdminListHeader">
                            <td>Title</td>
    <td>Edit</td>

    <td>Delete</td>
</tr>
    </THead>
    <TBody>
<tr id="itemPlaceholder" runat="server"></tr>
    </TBody>
</table>

</LayoutTemplate>
</asp:ListView>

The next row is changed to a server control by adding the runat="server" attribute. It has the ID of itemPlaceholder, which is important because this tells the ListView to use this control to add items to the list. In this case, the item templates should be a table row <tr> with the appropriate table cells <td>.

<EmptyDataTemplate>
<tr>
<td colspan="3"><p>Sorry there are no Categories available at this time.</p></td>
</tr>
</EmptyDataTemplate>
<ItemTemplate>
<tr>
<td class="ListTitle"><a href='<%# String.Format(
"AddEditSiteMap.aspx?categoryid={0}", Eval("siteMapid")) %>'>
<%# Eval("Title") %></a>
</td>
<td><a href="<%# String.Format(
"AddEditSiteMap.aspx?categoryid={0}", Eval("siteMapId")) %>">
<img src="../images/edit.gif" alt="" width="16" height="16"
class="AdminImg" /></a>
</td>
<td><asp:ImageButton runat="server" ID="ibtnDelete" ImageAlign="Middle"
 ImageUrl="~/Images/Delete.gif" AlternateText="Delete Node" /></td>
</tr>
</ItemTemplate>

The actual templates are declaratively defined as the table row to fill the placeholder control designated in the LayoutTemplate. The first template is the EmptyDataTemplate. It defines what is displayed if there are no records returned from the data source. Figure 3-19 shows an example of how this page looks.

Figure 3.19. Figure 3-19

The next template is the ItemTemplate, it defines how data is displayed in each row. An AlternatingItemTemplate that defines the layout for every other row is also available, giving you a chance to change the visual appearance on every other row.

The template use declarative databinding, which is code embedded between <%# %>. The data is actually bound to the ListView in the code-behind. The binding methods take advantage of the Using syntax that uses an object that implements the IDisposable interface to clean up its resources in a transparent fashion. In the example, a CategoryRepository is created and the GetCategories method is called to bind the records to the ListView.

Private Sub BindCategories()

        Using Categoryrpt As New CategoryRepository

            lvCategories.DataSource = Categoryrpt.GetCategories()
            lvCategories.DataBind()

       End Using

End Sub

I think it is important to note a difference between the previous edition of the book, where data was retrieved in small chunks or pages of data and this version. The former version involved getting a matching row count for the full set of records matching the query results and doing math behind the scenes. This was done to reduce the amount of data carried across the wire from the database, but this approach causes more hits on the database.

I like to cache data in memory to reduce the number of times I need to hit the database. The ListView has the logic baked into it to correctly calculate the number of pages, how to display the navigation in the DataPager, and so forth. So, I think trying to duplicate this effort is not a productive use of time.

Manipulating the records displayed in the ListView is important to make it effective; this is typically done by paging and sorting the data. The ListView provides built-in mechanisms to help make developing these routines easy.

ASP.NET 3.5 added the DataPager control, which is a complementary control designed to page through the ListView control contents. It is added to the LayoutTemplate in the position in which you want it to appear. I tend to add it at the bottom, but you are not limited to that. It can actually be added outside the ListView control all together, the DataPager control has a PageControlId property that needs to be set to the id of the ListView.

<div class="pager">
<asp:DataPager ID="pagerBottom" runat="server" PageSize="15">
            <Fields>
                    <asp:NextPreviousPagerField ButtonCssClass="command"
 FirstPageText="«" PreviousPageText="<" RenderDisabledButtonsAsLabels="true"
ShowFirstPageButton="true" ShowPreviousPageButton="true"
ShowLastPageButton="false" ShowNextPageButton="false" />
<asp:NumericPagerField ButtonCount="7" NumericButtonCssClass="command"
CurrentPageLabelCssClass="current"
NextPreviousButtonCssClass="command" />
<asp:NextPreviousPagerField ButtonCssClass="command" LastPageText="»"
NextPageText=">" RenderDisabledButtonsAsLabels="true"
ShowFirstPageButton="false" ShowPreviousPageButton="false"
ShowLastPageButton="true" ShowNextPageButton="true" />
</Fields>
</asp:DataPager>
</div>

The DataPager control causes the ListView control to post back to the server and cause the PagePropertiesChanged event to be executed. In PagePropertiesChanged, the data needs to be rebound to the control; the ListView takes care of rendering the proper page.

Private Sub lvSiteMap_PagePropertiesChanged(ByVal sender As Object,
ByVal e As System.EventArgs) Handles lvSiteMap.PagePropertiesChanged
BindSiteMapNodes()
End Sub

The ListView content can be sorted as well. The only requirement is to add a postback control (Button, LinkButton, or ImageButton,) with the CommandName of "Sort" and a CommandArgument with the name of the sort criteria. The ListView automatically handles changing the sort order from ascending to descending. The same PagePropertiesChanged event used to manage paging. The ListView has the SortExpression and SortDirection properties that can be used to build the query to retrieve the data. I hope you see why I chose not to retrieve just the page of records that will displayed and instead chose to cache the full recordset to be manipulated by the ListView.

ASP.NET 3.5 has added the ASP.NET AJAX framework to the user interface tools that can be quickly integrated in a site to build rich user interfaces. The framework is a set of JavaScript methods built to mirror the .NET Framework in organization, classes, and methods that help build client-side functionality. It has a set of web controls: ScriptManager, ScriptManagerProxy, UpdatePanel, Timer, and UpdateProgress.

Each page that needs to use the ASP.NET AJAX framework must have a ScriptManager control. When a master page is used the content page must have a ScriptManagerProxy control, so the content page can leverage the ScriptManager on the master page.

The UpdatePanel control is the poor man's JavaScript helper, it allows blocks of content to be contained in the UpdatePanel control and all requests are automatically converted to AJAX instead of a traditional postback. This means that you do not have to lift a finger to change an existing page that performs postbacks to the server to change those postbacks to an asynchronous operation. This means the user will not have to see the page flicker associated with the postback.

The ListView control works naturally inside an UpdatePanel control, making the paging and sorting methods work asynchronously. Once the page is working an UpdatePanel just needs to be added with the ListView embedded in the panel's ContentTemplate.

[f0000.xxx]    [f0000.xxx]    [f0000.xxx]    [f0000.xxx]    [f0000.xxx]
    [f0000.xxx]    [f0000.xxx]    [f0000.xxx]<asp:UpdatePanel runat=
"server" ID="uppnlComments">
<ContentTemplate>
<asp:ListView ID="lvComments" runat="server">
<LayoutTemplate>

Nothing more is required; the UpdatePanel will make the postback to the server; that, in turn, causes the normal page request to be performed on the server. The updated content is then parsed by the UpdatePanel, and it manages updating the ListView content based on the server's response. It is that simple! I will go over some more involved AJAX scenarios in later chapters.

In the previous edition of theBeerHouse application, FormViews were used to bind data to edit and insert records into the database. In this edition, I am going to slim things down a bit in the user interface and take more control in the code-behind. The edit form is laid out in a table, with the appropriate controls used to represent the data. These can be a TextBox, CheckBox, DropDownList, and so forth. When possible, controls and extenders from the ASP.NET AJAX control toolkit are used. At the bottom of the form is a series of buttons to perform inserting, updating, deleting, or canceling.

The ASP.NET AJAX Control Toolkit is a set of controls and control extenders that Microsoft produces the toolkit and maintains it on CodePlex at www.codeplex.com/AjaxControlToolkit. It is a community project though which anyone, including you, can suggest changes and report bugs. The source code of the entire toolkit is available for downloading, so you can make changes and examine how the controls are built. Figure 3-20 shows how the AddEdit form for the Category entity looks.

Figure 3.20. Figure 3-20

The administrative form's code-behind is responsible for retrieving the entity, displaying the data, updating the data, and storing it. All this responsibility is handled by five methods: the Page Load event handler, ClearItems, the Bind Entity method, and the Cancel and Submit event handlers. The page also inherits from the AdminPage class or possibly a descendant of the AdminPage class.

The AdminPage contains a PreInit event handler that sets the MoveHiddenFields to false. This is done because the FCKEditor is used on many of the administration pages and does not work when the hidden fields are moved.

Private Sub Page_PreInit(ByVal sender As Object,
ByVal e As System.EventArgs) Handles Me.PreInit

MoveHiddenFields = False

End Sub

The remaining properties of the AdminPage are to help manage primary keys that I detailed earlier.

In the Page Load event handler checks to see if a primary key was passed to the form, and if so, then binds the entity to the controls; if not, it clears the form.

Protected Sub Page_Load(ByVal sender As Object,
ByVal e As System.EventArgs) Handles Me.Load

If Not IsPostBack Then

            If CategoryId > 0 Then
                BindCategory()
            Else
                ClearItems()
            End If

        End If

    End Sub

The ClearItems method is called when the form is being loaded to add a new entity to the database. Notice the last item in the method sets the status literal control text to instruct the user what to do. The status control is used to provide feedback to the user as to the status of the form.

Private Sub ClearItems()

        ltlCategoryID.Text = String.Empty
        ltlAddedDate.Text = String.Empty
        txtTitle.Text = String.Empty
        txtImportance.Text = String.Empty
        txtDescription.Text = String.Empty
        txtImageUrl.Text = String.Empty
        ltlUpdatedDate.Text = String.Empty
        iLogo.Visible = False

        ltlStatus.Text = "Create a New Category."

    End Sub

The bind method, BindCategory in the example, retrieves the entity that corresponds to the primary key value passed to the page. It then binds the data to the appropriate controls as needed.

Private Sub BindCategory()

        Using Categoryrpt As New CategoryRepository

            Dim lCategories As Category = Categoryrpt.GetCategoryById(CategoryId)

            If Not IsNothing(lCategories) Then

                ltlCategoryID.Text = lCategories.CategoryID
                ltlAddedDate.Text = lCategories.AddedDate
                ltlAddedBy.Text = lCategories.AddedBy
                txtTitle.Text = lCategories.Title
                txtImportance.Text = lCategories.Importance
                txtDescription.Text = lCategories.Description

                If String.IsNullOrEmpty(lCategories.ImageUrl) = False Then
                    txtImageUrl.Text = System.IO.Path.GetFileName(
lCategories.ImageUrl)
                    iLogo.ImageUrl = lCategories.ImageUrl

Else
                    iLogo.Visible = False
                End If

                cbActive.Checked = lCategories.Active
                ltlUpdatedDate.Text = lCategories.UpdatedDate
                ltlUpdatedBy.Text = lCategories.UpdatedBy

                ltlStatus.Text = String.Format("Edit The Category - {0}.",
 lCategories.Title)
            Else
                CategoryId = 0
                ltlStatus.Text = "Create a New Category."
            End If

        End Using

    End Sub

The Submit button's click event manages changing, updating or creating a new entity. First, it gets a copy of the existing version of the entity if a primary key value has been supplied.

Then each field gets updated if the value has been changed. This is done because the Entity Framework will create a SQL Update command that updates only the changed fields, making it perform slightly better.

Private Sub UpdateCategory()
        Using Categoryrpt As New CategoryRepository

            Dim lCategory As Category

            If CategoryId > 0 Then
                lCategory = Categoryrpt.GetCategoryById(CategoryId)
            Else
                lCategory = New Category()
            End If

            lCategory.Title = txtTitle.Text
            lCategory.Importance = CInt(txtImportance.Text)
            lCategory.Description = txtDescription.Text

            lCategory.ImageUrl = GetItemImage(fuImageURL, txtImageUrl)
            lCategory.Active = cbActive.Checked

            lCategory.UpdatedBy = UserName
            lCategory.UpdatedDate = Now

            If lCategory.CategoryID = 0 Then
                lCategory.Active = True
                lCategory.AddedBy = UserName
                lCategory.AddedDate = Now
            End If

            If Not IsNothing(Categoryrpt.AddCategory(lCategory)) Then

IndicateUpdated(Categoryrpt, "Category", ltlStatus, cmdDelete)

                cmdUpdate.Text = "Update"
                IndicateUpdated(Categoryrpt, "Category", ltlStatus, cmdDelete)
                Dim sURL As String = SEOFriendlyURL( _
                    Settings.Articles.CategoryUrlIndicator & "/" &
lCategory.Title, ".aspx")
                Dim sRealURL As String =
String.Format("BrowseArticles.aspx?Categoryid={0}", lCategory.CategoryID)

                CommitSiteMap(lCategory.Title, sURL, sRealURL, _
                    lCategory.Description.Substring(0,
If(lCategory.Description.Length >= 200, 199, lCategory.Description.Length - 1)), _
                    If(String.IsNullOrEmpty(lCategory.Title) = False,
lCategory.Title, String.Empty), "Category")

            Else
                IndicateNotUpdated(Categoryrpt, "Category", ltlStatus)
            End If

        End Using

   End Sub

After the fields have been updated, the UpdatedBy and UpdatedDate values are set to the current username and the current time. It then checks to see if it is a new entity or an update to an entity by checking the CategoryId value. If it is greater than 0, then the entity's repository Update method is called. If not then the entity is added to the database by calling the AddCategory method.

Based on the result of the Add or Update method, the status message is updated to reflect the outcome.

When the Cancel button is clicked, it causes the response to be sent to the entity's list administration page.

Private Sub btnCancel_Click(ByVal sender As Object,
ByVal e As System.EventArgs) Handles cmdCancel.Click
        Response.Redirect("ManageCategories.aspx")
End Sub

Clicking the Delete button calls the Delete method of the entity's repository class. According to the outcome of the Delete method, the page's status is updated to let the user know what happened.

Protected Sub cmdDelete_Click(ByVal sender As Object,
ByVal e As System.EventArgs) Handles cmdDelete.Click

        Using Categoryrpt As New CategoryRepository
            If Categoryrpt.DeleteCategory(CategoryId) Then
                Response.Redirect("ManageCategories.aspx")
            Else
                ltlStatus.Text = "Sorry the Category was not Deleted."
            End If
        End Using

    End Sub

Search engines are known for penalizing sites for duplicate content, which can commonly happen when multiple URLs can retrieve the same content. While search engines have gotten a lot better, accounting for common duplications, such as www and non-www access, it helps to have only one true URL for content.

It has long been known that having the proper content on a page helps you get better search engine visibility. In the early days of the Internet, sites could rely on the content of their header tags to get them reasonable visibility in most cases. That is not as true today but is still a very relevant task that should be done for each page in a site. This includes having valid, targeted content in the page's Title, and META tags.

The Title Tag

The Title tag is one of the most important pieces of the page because it is one of the primary factors search engines use to determine the content of the page. It is also used as the page's clickable text in the search engine results and is displayed at the top of the browser every time it is displayed. The text of the Title tag should be compelling, relevant, and less than 65 characters long. Search engines typically do not display more than 65 characters in their results.

Figure 3-22 shows the results for my blog on live.com. I have highlighted the Title tag used to link to my blog from the result list.

Figure 3.22. Figure 3-22

Viewing the source of my blog's home page, you will see the same text contained in the Title tag.

<head>
<title>Chris Love's Official Blog - Professional ASP.NET</title>
</head>

All Title tags in the site should be unique and should never start with "Welcome to... ." If you do a quick search for "Welcome to" you will see how many sites are indexed for that term. The title should include content that describes the page's content and is targeted to specific keyword phrases if at all possible. Generic terms like "Welcome to" just reduce the relevance of the page. Avoiding this common mistake could be the difference between a first page listing and a fifth page listing.

The Description META Tag

The Description META tag no longer carries the significance it once had with place in search engine results, but it is very important for each page to have a unique description. The content of the Description META tag is often used by search engines as the description in the search results. Having a relevant description will help a site get more visitors from search engines. If this tag is not added to a page, the search engine is forced to assume the description from other sections of the page, thus taking it out of your control.

Searching for "Chris Love" on Live.com returns the following result. I have highlighted the content located in the title tag of my blog, Figure 3-23. Notice how it appended more content from the page to help add more content to the result? I will talk more about this shortly.

Figure 3.23. Figure 3-23

Viewing the source of my blog's home page, you can see the Description META tag and see where Live.com gathered the initial content for the description in the search result.

<meta name="description" content="Chris Love's official Blog,
I cover ASP.NET programming related issues." />

<meta name="keywords" content="ASP.NET, VB.NET, C#, Silverlight,
SQL Server, SharePoint" />

<META NAME="robots" CONTENT="index, nofollow"/>

<H1>Planning an Architecture</H1>
<H2>Search Engine Optimization Techniques</H2>
<H3>Page Level Optimizations</H3>
<H4>Use Header Tags</H4>

Building web applications has long meant leveraging the QueryString to pass parameters to the application. For example, to retrieve an article in theBeerHouse application an ArticleId parameter would be added to the URL, ShowArticle.aspx?articleid=28. While this is not terribly bad, it can quickly become a long series of parameters. There is a great deal of competition in the market to garner search engine visibility for targeted keywords. It is equally important to reduce potential attack surfaces for potential hackers to hit. URL Rewriting can help in both of these cases.

Creating friendly URLs is pretty easy in ASP.NET, but it does require the use of a custom httpModule. An httpModule is registered with the ASP.NET application and allows developers to create an event handler or a series of event handlers to hook into the ASP.NET life cycle.

In short, httpModules are classes that implement the IhttpModule interface, which requires methods to handle the Init and Dispose methods. Each module must also be registered in the site's web.config file, in the httpModules section. Once the module is registered the ASP.NET engine will call the Init method when the application first starts. The Dispose method is called when the application is closed.

<httpModules>
<add name="URLRewrite" type="URLRewrite"/>
<add name="ScriptModule" type="System.Web.Handlers.ScriptModule,
System.Web.Extensions, Version=3.5.0.0, Culture=neutral,
PublicKeyToken=31BF3856AD364E35"/>
</httpModules>

In the Init method, you are not limited to what you can do, but generally event handlers are wired to specific life cycle events. For the case of URL rewriting, it is advisable to intercept the request in the AuthorizeRequest event.

Public Sub Init(ByVal context As System.Web.HttpApplication)
Implements System.Web.IHttpModule.Init
AddHandler context.AuthorizeRequest, AddressOf AuthorizeRequest
End Sub

This provides the capability to intercept the request, check to see if the requested URL should be rewritten, rewrite the requested URL using the RewritePath method if necessary, and proceed with the request. For theBeerHouse application, URL rewriting leverages the list of entities in the site's site map, stored in the database. Each module that creates a potential URL in the site must be responsible for storing its URLs in the SiteMap database table.

Maintaining an up-to-date map of theBeerHouse application is important for two reasons: breadcrumbs and search engines. Breadcrumbs are a way to provide the user a sense of where they are and how to easily navigate back up the tree. Letting search engines know what the site currently consists of is important so that your content gets indexed. It is also helpful to leverage a custom site map so that URL rewriting can be done easily.

To maintain a central site map for the site, it should be stored in a table in the site's database, Figure 3-24. The table needs to store the URL, the actual URL on the site, a title, description, keywords, a reference to a parent URL, what type of node it is, and a value to indicate its order with sibling nodes. Of course, the table should have a SiteMapId primary key and fields that indicate if the node is active, and when it was added or updated and by whom.

Figure 3.24. Figure 3-24

There are two URL-related fields: the URL and the RealURL. The URL field holds the path from the site's domain that will be publically available. In other words, this will be the URL used by visitors to access the page but not necessarily the URL to the item in the site. For example, articles will be accessed by requesting a URLEncoded version of the article's title suffixed with the .aspx extension. This URL is mapped to the traditional ShowArticle.aspx?ArticleId=X url that was used in the previous edition of theBeerHouse application.

<siteMap defaultProvider="TBHSiteMapProvider" enabled="true">
<providers>
<add name="TBHSiteMapProvider" type="TheBeerHouse.TBHSiteMapProvider"
 securityTrimmingEnabled="true"/>

</providers>
</siteMap>

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
   <url>
      <loc>http://www.example.com/</loc>
      <lastmod>2005-01-01</lastmod>
      <changefreq>monthly</changefreq>
      <priority>0.8</priority>
   </url>
</urlset>

Custom SiteMap File httpHandler

When the search engine spider comes to your site, it will begin its quest by asking for the latest sitemap.xml file. You can, and typically will, register another site map file name with each search engine, if you want; in that case, it will ask for that file. No matter, the spider tries to consume the up-to-date site map file. Since the website is a living application that changes its composure at any time, maintaining a static file is not feasible. Because the site map information is stored in the database, it can be retrieved as needed to compose the site map file.

A custom httpHandler is an ideal way to compose the required XML from the information stored in the database. A custom httpHandler is one of the core elements used to compose content in ASP.NET. In fact the Page class is actually an httpHandler. A custom httpHandler is a class that implements the IHttpHandler interface and can either register as the handler for specific requests, or a generic handler, the .ashx file, that is requested directly from the client.

Imports System.Linq
Imports System.Xml.Linq
Imports System.Web
Imports TheBeerHouse.BLL
Imports <xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">

Public Class SiteMapsHandler
    Implements IHttpHandler

The IHttpHandler interface requires two methods are implemented by the class: IsReusable and ProcessRequest. The IsReusable property indicates to the ASP.NET engine if the httpHandler can be used simultaneously by more than one request. In other words, is there anything in the handler that has to be mutually exclusive with other requests. For requests that produce static output, this can be true; with dynamic requests, this can vary depending on what the handler is performing.

The ProcessRequest method is invoked by the ASP.NET engine to begin actual processing and composition of the content sent to the client. A reference to the current context is passed to ProcessRequest; this gives the handler access to the Request and Response objects.

Public Sub ProcessRequest(ByVal context As System.Web.HttpContext)
Implements System.Web.IHttpHandler.ProcessRequest

        BaseContext = context
        CreateSiteMap()

        Response.Flush()
        Response.End()

End Sub

The site map handler composes the site map content in a method called CreateSiteMap. Since the site map format is XML, the Response.ContentType or MIME type is set to "application/xml". Before composing the XML content, a request is made to the database to retrieve the site map nodes by creating a SiteMapRepository and retrieving a List(of SiteMapInfo) entities.

In VB.NET the map is composed using XML Literals; in C#, it requires a little more complex coding using the LINQ XDocument classes.

Using XML Literals is a very intuitive way to compose and parse XML content in .NET that were introduced with VB 9 (.NET 3.5). With XML Literals XML can be processed in a declarative manner in a VB class member. Instead of having to deal with unnatural classes, XML is managed in its natural format, making it much easier to see XML structure in the code.

Note

Site map files can contain no more than 50,000 URLs and can be no more than 10MB in size, which can be an issue for large sites. HTTP compression (GZIP or Deflate) can be used to reduce the size of the files as they are transported to the spider. The SiteMap.org protocol allows for multiple site map files to be specified by providing a site map index file that lists all the site map files. There can be no more than 1000 index files, and the index file itself cannot exceed 10MB in size.

<?xml version="1.0" encoding="UTF-8"?>
<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
   <sitemap>
      <loc>http://www.example.com/sitemap1.xml.gz</loc>
      <lastmod>2004-10-01T18:23:17+00:00</lastmod>
   </sitemap>
   <sitemap>
      <loc>http://www.example.com/sitemap2.xml.gz</loc>
      <lastmod>2005-01-01</lastmod>
   </sitemap>
</sitemapindex>

To create a site map using XML Literals, it is ideal to paste the required components of a valid site map into the code itself, then manipulate the code snippet to produce the desired dynamic output. The XML content is set to an XDocument object, xSiteMap. The site map XML is composed by integrating a LINQ query using declarative syntax much as you would do in ASP.NET to integrate server-side coding using the <% %> syntax. The LINQ query is a select statement executed on the list of SiteMapInfo entities, returning a list of <url> elements that compose the resulting site map file.

VB.NET

Private Sub CreateSiteMap()

        Response.ContentType = "application/xml"

        Dim lsiteMapNodes As List(Of SiteMapInfo)

        Using siteMaprpt As New SiteMapRepository
            lsiteMapNodes = siteMaprpt.GetSiteMapNodes
        End Using

        Dim xSiteMap As XDocument = <?xml version="1.0" encoding="UTF-8"?>
        <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
                   <%= From lSiteMapNode In lsiteMapNodes.AsEnumerable _
            Select <url>
                <loc><%= lSiteMapNode.URL %></loc>
                <lastmod><%= lSiteMapNode.DateUpdated %></lastmod>
                <changefreq>weekly</changefreq>
                <priority>0.8</priority>
                  </url> %>
        </urlset>

        Response.Write(xSiteMap.ToString)

    End Sub

Finally, the xSiteMap content is written to the Response content by calling the ToString method.

Composing the content in C# is not quite as simple because it requires more formal use of the LINQ to XML classes. I call the special classes in the LINQ namespace related to XML "X classes" because they are all prefixed with X followed by the object type: XDocument, XElement, and XAttribute, for example.

C#

private void CreateRSSFeed()
      {
         TheBeerHouseSection Settings = Helpers.Settings;
         this.Response.ContentType = "application/xml";
         using (ArticleRepository lArticlectx = new ArticleRepository())
         {
            List<Article> lArticles = lArticlectx.GetActiveArticles();

var xRss = new XDocument(new XDeclaration("1.0", "utf-8", "yes"),
new XElement("rss",
                     new XAttribute("version", "2.0"),
                       new XElement("channel",
                       new XElement("title",
"The Beer House Articles"),
                       new XElement("link", "http://www.TheBeerHouseBook.com/"),
                       new XElement("description",
                          "RSS Feed containing The Beer House News Articles."),

               from item in lArticles
                  select
                     new XElement("item",
                         new XElement("title", item.Title),
                         new XElement("description", item.Abstract),
                         new XElement("link",
Helpers.SEOFriendlyURL(Settings.Articles.URLIndicator +
"/" + item.Title, ".aspx")),
                         new XElement("pubDate",
item.ReleaseDate.ToString())
               )
              )
            )
           );
            this.Response.Write(xRss.ToString());
         }
         this.Response.Flush();
         this.Response.End();
      }

Once the content of the document is composed, the request is wrapped up by flushing the content to the browser and ending the response.

Before this handler can respond to the request for sitemap.xml, it has to be registered in the httpHandlers section of the web.config file. All the request for the sitemap.xml file are GET requests, so the verb should reflect that and the path is set to "sitemap.xml", limiting the scope of this handler to only that resource name.

<add verb="GET" path="sitemap.xml" validate="false"
type="TheBeerHouse.SiteMapsHandler, TBHBLL, Version=3.5.0.1,
Culture=neutral, PublicKeyToken=null"/>

Once the handler is registered the only thing left is to verify that the sitemap.xml file is properly composed and served. Retrieving the file in a browser should produce the desired content as shown in Figure 3-25.

Because the site map handler composes the XML from the database, each time a spider requests the document you can be assured that the content is up to date, ensuring that your site is properly indexed by each search engine.

Figure 3.25. Figure 3-25

In the "Design" section of this chapter, I talked about various search engine optimization techniques that should be employed to help the site earn better search engine placement. Two of those techniques involved search-engine-friendly URLs and 301 redirecting requests going to one version of the domain instead of both the www alias and the actual domain name. Both of these tasks can be handled in a custom httpModule called URLRewrite.

If you are not familiar with httpModules, they are part of the foundation of the ASP.NET model and provide a means to hook into the ASP.NET pipeline to intercept requests and modify them according to your business rules. In this case, the module will intercept the request, analyze the requested URL, and reroute it as necessary.

A custom httpModule implements the IHttpModule interface, which consist of two methods: Init and Dispose. The Dispose method is the same as I discussed earlier; it is called when the module is being destroyed and allows you to release any resources that may be opened by the module. In the case of the URLRewrite module, there are no ongoing resources in use, so this method will be empty.

Imports Microsoft.VisualBasic
Imports System.IO
Imports TheBeerHouse.BLL
Imports System.Web
Imports System.Text.RegularExpressions

Public Class URLRewrite
    Implements IHttpModule

There is one variable declared in the module, wwwRegex, a regular expression used to match the requested URL to see if "www." has been used. If you are not familiar with regular expressions or feel a little intimidated with the syntax, I encourage you to investigate them further. They are a great way to parse text efficiently. Another nice thing is they are essentially language agnostic, meaning that they are used with just about every platform and programming language. There are a few subtle differences across languages, but they seem to be minor.

This regular expression looks for a URL string that contains "http://www." or "https://www.", which is important because this is a way to catch SSL and non-SSL requests. The expression looks almost exactly like the pattern I am trying to catch. The first deviation is the ? after https. This tells the regular expression parser to look for 0 or 1 of the previous characters. The next deviation is ., which is simply an escape character "" to tell the parse to look for a period.

Private Shared wwwRegex As New Regex("https?://www.",
RegexOptions.IgnoreCase Or RegexOptions.Compiled)

The next parameter combination is the regular expression options for the Regex object. In this case, Regex is instructed to ignore the case of the characters it is matching and to compile the expression. Compiling the expression means that it will be part of the assembly and perform slightly faster. The RegexOptions Enum can be ORed together, as shown in the example. There are many other options available for regular expressions that can be used to control how an expression performs its matching.

The Init method is called by the ASP.NET engine the first time a request is made to the website. This method is called only once, and it is typically used to register event handlers. In the URLRewrite module, I am registering a single event handler to intercept the BeginRequest event. There are over 20 events in the ASP.NET page life cycle. I talk about these and many more concepts related to httpModules in a WROX BLOX, Leveraging httpModules for Better ASP.NET Applications, which is available from the WROX website.

Public Sub Dispose() Implements System.Web.IHttpModule.Dispose

    End Sub

    Public Sub Init(ByVal context As System.Web.HttpApplication)

Implements System.Web.IHttpModule.Init
        AddHandler context.BeginRequest, AddressOf BeginRequest
    End Sub

All the events in the ASP.NET page life cycle have the standard Microsoft event signature: an Object named sender and an EventArgs object named e. The sender object is the application, an HttpApplication object. The BeginRequest method uses this parameter by casting the sender to an HttpApplication object named app. I then create local variables for the Request and Response objects as well to save some coding.

Following the declaration of those variables the method declares a series of variables; sRequestedURL, bWWW, and redirectURL. The sRequestedURL variable holds the URL requested by the user, converted to lower case. This is important because all string comparisons are case sensitive. The bWWW Boolean variable is a flag that indicates if there was a match to the regular expression to catch requests made using the www. prefix. The redirectURL variable is initially set to an empty string and will ultimately be set to the real URL if the method needs to perform a 301 redirect.

Private Sub BeginRequest(ByVal sender As Object, ByVal e As EventArgs)
        Dim app As HttpApplication = CType(sender, HttpApplication)
        Dim Request As HttpRequest = app.Request
        Dim Response As HttpResponse = app.Response

        Dim sRequestedURL As String = Request.Url.ToString.ToLower

        Dim bWWW As Boolean = wwwRegex.IsMatch(sRequestedURL)
        Dim redirectURL As String = String.Empty
        If bWWW Then
            redirectURL = wwwRegex.Replace(sRequestedURL,
String.Format("{0}://", Request.Url.Scheme))
        End If

        Rewrite(app)

    End Sub

If there was a match to the regular expression, then the RegEx object is used to perform a quick replace to remove the www. from the URL and set the updated version to redirectURL. The next section of code checks to see if the redirectURL contains any text, and if so, then proceeds to do a 301 redirect. Before the redirect, it does another check to see if the URL ends with "default.aspx," which is important because you need to minimize the use of default.aspx as the home page. Again, this is to avoid duplicate content penalties.

So, why did I check for this in the BeginRequest method? In this case, the 301 redirect is being sent back to the client without default.aspx appended, which means the search engine will only see the actual domain as the URL. The file name is appended only on the server. If this were checked, say in the regular expression, it would cause an infinite loop because the module would be continually sending 301 redirect notices to the browser or spider because each request would keep having default.aspx appended to the end of the URL. Figure 3-27 shows an example of the expected result.

Figure 3.27. Figure 3-27

This still leaves us with a potential hole in the module to allow duplicate content to be indexed by the search engine. Unfortunately, without mapping every request through the ASP.NET engine, it leaves to the URL the responsibility to not use any links to the home page of the site with default.aspx file appended. This takes discipline, and there is no good answer as to how to avoid this without investing in a third-party ISAPI filter.

The last piece of the duplicate content checking code actually performs the 301 redirect. The RedirectLocation of the Response object is set to the redirectURL variable. The StatusCode property of the Response is set to 301. The StatusCode refers to the HTTP Status code returned to the client (a browser or search engine spider) that lets the client know how the request was processed. For example, a normal request returns a status of 200; one where the user is not authenticated to access the resource returns a 403 status code. This tells the client what to do next. In the case of a 301 status code, the client knows it should look for the Location header to see where the URL has been permanently moved to. Search engines see this and know not to index the first URL and instead index the new URL.

Finally, if the requested URL does not need to be redirected from the www version, it still needs to be checked against the site map. The Rewrite method accepts the requestedPath and a reference to the HttpApplication object.

Private Sub Rewrite(ByVal app As HttpApplication)

        Using lSiteMapRst As New SiteMapRepository()
            Dim lSiteMap As SiteMapInfo =
lSiteMapRst.GetSiteMapInfoByURL(
Path.GetFileName(app.Context.Request.RawUrl))

            If Not IsNothing(lSiteMap) Then
                HttpContext.Current.RewritePath(lSiteMap.RealURL)
            End If
        End Using

    End Sub

The logic in the Rewrite method is wrapped in a using statement, where a new SiteMapRepository object is created. In the using statement the GetSiteMapInfoByURL method is called, passing the file name of the requested resource. The reason the file name is used instead of the domain portion of the URL is that should be the same value for every request.

The GetSiteMapInfoByURL method makes a simple LINQ query over the SiteMap and returns either the first match to the requested URL or nothing. The return statement wraps the LINQ query in () and called the FirstOrDefault method, which returns the first object matching returned from the data source or null if there are no matches in the database. If just First was used and there were no matches, it would throw an exception; FirstOrDefault manages that scenario.

Public Function GetSiteMapInfoByURL(ByVal URL As String) As SiteMapInfo

            Return (From lai In SiteMapctx.SiteMaps _
                Where lai.URL = URL).FirstOrDefault

        End Function

The next line of code checks to see if a match was found; if there was, then the requested path is rewritten by calling the RewritePath method. This method does not do a 301 redirect; it actually transforms the requested URL to the desired URL and lets the ASP.NET engine continue processing the request. In essence, it tricks the engine into thinking the client requested a URL they didn't. The only trick you need to have is a way to transform the requested URL to the URL you want ASP.NET to process. There are several ways to manage this; I have found that, for larger sites, it is easier to do this with a database table maintaining various types of information that makes up a page and using that as the ultimate transform. Regular expressions are also very popular.

Implementing good search engine practices not only helps the site garner better search engine placement but also makes the overall user experience on the site better. In the base page class, there are several properties to manage the page description, keywords, and other META tag members.

In ASP.NET, there are two basic types of controls: web and HTML. While the web controls garner the vast majority of attention, the HTML controls are very useful. For search engine optimization purposes, the HtmlMeta control renders a META tag used for description, keywords, and other tags. The BasePage class contains a method that creates an HtmlMeta control and adds it to the page's header, composing it with the appropriate tag name and value. It takes care to work with both a master page and a page without a master template.

Public Sub CreateMetaControl(ByVal sTagName As String, ByVal TagValue As String)

            Dim meta As New HtmlMeta()
            meta.Name = sTagName

meta.Content = TagValue

            If Not IsNothing(Master) AndAlso Not IsNothing(Master.Page) Then
                Master.Page.Header.Controls.Add(meta)
            Else
                Page.Header.Controls.Add(meta)
            End If

End Sub

Similarly, retrieving the value of a META tag is just as important. This is done by interrogating the page for the metatag control. This is done by using the FindControl method and returning the content of the control.

Public Function GetMetaValue(ByVal sTagName As String) As String

            Dim meta As HtmlMeta

            If Not IsNothing(Master) Then
                meta = Master.Page.Header.FindControl(sTagName)
            Else
                meta = Page.Header.FindControl(sTagName)
            End If

            If Not IsNothing(meta) Then
                Return meta.Content
            End If

            Return String.Empty

End Function

The BasePage class contains targeted properties to get and set the values of these metatags. The setter creates the META tag by calling the CreateMetaControl method. It gets the value by calling the GetMetaValue method.

Protected Property PageKeyWords() As String
            Get
                Return GetMetaValue("KEYWORDS")
            End Get
            Set(ByVal value As String)
                CreateMetaControl("KEYWORDS", value)
            End Set
End Property