Martin on .Net

Announcing MVC3 Validation Groups

2012-01-15T00:05:00.001Z

I’ve recently had to organise the validation for long/multipart forms. Ordinarily, you’d divide the form up into smaller models and create a wizard style user journey. But in this case the UI design called for the user to arbitrarily jump back and forth between pages in the wizard and other restrictions meant that we couldn’t persist each sub-page on change. What we needed were validation groups!
As this work involved a bit of the old copy-paste-adapt from the standard MVC code, it’s a bit complicated to go into the fine details of how to replicate the functionality for yourself. So I’ve setup a codeplex project with a reusable library all ready to go! (Of course all the source code is up there as well!)

How to use

Download the latest release. (Get the latest Example Site as well to see a preconfigured MVC3 Website and example integration)
Add a reference to ‘McjDevelopment.Mvc3ValidationGroups.dll’ to your MVC3 project
Copy ‘jquery.validate.unobtrusive.validationgroups.js’ to your ‘scripts’ folder
Decorate your view models with the [ValidatorGroup] attribute specifying the validation groups that that field belongs to (space delimited)
Update your view to use ‘jquery.validate.unobtrusive.validationgroups.js’ immediately after ‘jquery.validate.unobtrusive.js’ (or ‘jquery.validate.unobtrusive.min.js’)
Update your view to include where you want each groups Validation Summary to appear
Amend your ‘Action’ buttons and links to include ‘data-val-valgroup-name’ attribute and specify which validation groups should be triggered by the user clicking on that element
Amend you’re controller to check the appropriate validation groups when called. (this implementation shows a common action being called with uses the clicked button name to select the validation group, an alternative is to us JS to dynamically alter the form’s action location)
Test validation groups!

Ektron: Finding “Missing” Content in the Index on 64bit Windows

2011-11-01T10:27:00.000Z

When content is created on an Ektron with a large content id (commonly on eSync enabled workareas) it may corrupt the content id.

For example if a new content item has an id of 6442451035 it will actually be indexed with a contentid of 2147483739. This is because the original id is larger than an unsigned integer can hold.

          1: long contentId = 6442451035;

         2: Console.WriteLine((uint)contentId); //2147483739

You can then query your public index to see if content has been misindexed by running a query to find your content

SELECT Filename, Path, ContentID64, ContentLanguage FROM <<PUBLIC_CATALOG>>..SCOPE() WHERE contentid64=6442451035 OR contentid64=2147483739

If the content is not indexed at all, you won’t find any content and the issue is something else. However, if you get a result but the CONTENTID64 value is wrong, then you should be able to fix the problem.

To fix this you can follow the following procedure:

Download Updated QLXFilters (and check that they are newer than your current dlls!)
Backup QLXFilter.dll from c:\windows\system32 and c:\windows\sysWoW64 on the server
Stop the Indexing Service
Replace the dlls with the updated versions
Start the Indexing Service
Run a full SearchConfigUI, if you have assets missing from the current server please untick Documents from the advanced tab.
Select Re-index existing Catalogues - this may affect the stability of you website.
After this has completed please check the Docs to Index on the indexing service and ensure that this has finished indexing.
After this is complete please run your query and you should now see the results return correctly.

Persisting the Page Title across Update Panel Post backs

2011-08-16T10:57:00.001+01:00

There’s a fun bug with AsyncPostbacks blanking out the Page Title (http://stackoverflow.com/questions/627378/page-losing-title-after-updatepanel-asyncpostback), the recommended fix is to rebind the page title on each Async Postback or to use the declarative page title attribute in the aspx. My fix is to fix a JS bug in JS:

        1: $(function(){

       2:     var prm = Sys.WebForms.PageRequestManager.getInstance();

       3:     if (!(prm)) return;

       4:     document.orginalTitle=document.title;

       5:     instance.add_endRequest(function(s, e){

       6:         if (document.title.replace(/\s/g,"").length==0)

       7:             document.title=document.orginalTitle;

       8:     });

       9: });

This JS code will ensure that the page title is persisted across ajax requests, with no changes to the server side code. If you don’t have JQuery available (for shame!) then just move the function body into a code block which will execute on the GET request/first view of the page.

Ektron: Treating Office Files as Normal DMS Assets

2011-08-04T16:53:00.001+01:00

One of the features of Ektron is tight office integration allowing the editing of office files directly from the workarea. However, in some circumstances you may want to treat these as normal DMS assets (like PDF files) as their the end results of an offline publishing process.

The Ektron support fix for this is to modify the workarea files (detailed below), which would then need to be re-applyed with every upgrade. This is easy enough to do (if you remember to do it with each upgrade), but I would prefer a more unobtrusive fix which is applied via configuration.

The Manual Fix (Ektron Supported)

Edit /workarea/edit.aspx and comment out the following lines (~line 2110):

        1: var isOffice = document.getElementById("isOfficeDoc");

       2:  

       3: if ((isOffice != null) && (isOffice.value == "true") && (ShowMultipleUpload() || !IsBrowserIE()))

       4: {

       5:     g_initialPaneToShow = 'dvSummary';

       6:     var contentTabHeader = document.getElementById("dvContent");

       7:     var contentTabContent = document.getElementById("_dvContent");

       8:     if (contentTabHeader != null)

       9:        contentTabHeader.style.display="none";

      10:     if (contentTabContent != null)

      11:        contentTabContent.style.display="none";

      12: }

Also, comment out the following lines of /workarea/edit.aspx.vb (~line 1945)

       1: If (isOfficeDoc.Value = "true") Then

       2:     phContent.Visible = False

       3:     phEditContent.Visible = False

       4: End If

The workarea will now treat office files in the same manner as PDF DMS Assets.

The Unobtrusive Fix (Unsupported)

Looking at what the official fix achieves does, it all hangs on the value of the “isOffice” hidden field being ‘true’. Realising this it’s an (almost) trivial task to create an HttpModule to manipulate the control tree of the edit page to get the same effect. The major advantage of this is that it won’t require modification of Ektron files and can be disabled by simply unregistering the module within the web.config.

       1: using System;

       2: using System.Reflection;

       3: using System.Web;

       4: using System.Web.UI;

       5: using System.Web.UI.HtmlControls;

       6:  

       7: namespace MartinOnDotNet.Support

       8: {

       9:     /// <summary>

    /// Force OfficeDocuments to be treated as normal DMS Assets

    /// </summary>

    public class OfficeDocumentFixModule : IHttpModule

    {

  

        /// <summary>

        /// Initializes a module and prepares it to handle requests.

        /// </summary>

        /// <param name="context">An <see cref="T:System.Web.HttpApplication"/> that provides access to the methods, properties, and events common to all application objects within an ASP.NET application</param>

        public void Init(HttpApplication context)

        {

            if (context == null) throw new ArgumentNullException("context");

            context.PreRequestHandlerExecute += new EventHandler(OnPreRequestHandlerExecute);

        }

  

        private void OnPreRequestHandlerExecute(object sender, EventArgs e)

        {

            HttpContext current = HttpContext.Current;

            if (current == null

                || current.Handler == null

                || current.Request == null

                || !current.Request.Url.AbsolutePath.EndsWith("/workarea/edit.aspx", StringComparison.OrdinalIgnoreCase)) return;

  

            Page page = current.Handler as Page;

            page.PreInit += new EventHandler(OnPreInit);

  

        }

  

        /// <summary>

        /// Always return false regardless of actual value

        /// </summary>

        public class AlwaysFalseHiddenField : System.Web.UI.HtmlControls.HtmlInputHidden

        {

            /// <summary>

            /// Gets or sets the value associated with the <see cref="T:System.Web.UI.HtmlControls.HtmlInputControl"/> control.

            /// </summary>

            /// <value></value>

            /// <returns>

            /// The value associated with the <see cref="T:System.Web.UI.HtmlControls.HtmlInputControl"/>.

            /// </returns>

            public override string Value

            {

                get

                {

                    return "false";

                }

                set

                {

                    base.Value = value;

                }

            }

        }

  

  

  

        /// <summary>

        /// Called when the Page load event fires

        /// </summary>

        /// <param name="sender">The sender.</param>

        /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>

        private void OnPreInit(object sender, EventArgs e)

        {

            Page page = sender as Page;

            if (page == null) return;

            PropertyInfo officeDocProperty = page.GetType().GetProperty("isOfficeDoc", BindingFlags.Instance | BindingFlags.NonPublic);

            if (officeDocProperty == null) return;

  

            HtmlInputHidden hil = officeDocProperty.GetValue(page, null) as HtmlInputHidden;

            AlwaysFalseHiddenField fhil = new AlwaysFalseHiddenField();

            fhil.ID = hil.ID;

            fhil.Name = hil.Name;

            fhil.Value="false";

            page.PreRenderComplete += (s, ea) =>

                {

                    hil.Value = "false";

                };

            officeDocProperty.SetValue(page, fhil, null);

  

        }

  

  

        /// <summary>

        /// Disposes of the resources (other than memory) used by the module that implements <see cref="T:System.Web.IHttpModule"/>.

        /// </summary>

        public void Dispose()

        {

            //throw new NotImplementedException();

        }

  

  

    }

}

Simply wire up the module in web.config and job’s a good ‘un.

Experiments with ADO.Net, Extension Methods and Anonymous Methods

2011-07-14T11:50:00.001+01:00

As much as at pains me to admit it, an ORM Framework is not the answer to all data access problems. Sometimes the quickest, easiest and most maintainable approach is back-to-basics flat ADO.Net. For those developers whose (development) life began with Entity Framework, NHibernate or SubSonic. This is a fairly typical example of an ADO.Net method (in a well structured code base):

        1: private static IEnumerable<ContentAwaitingApproval> GetPendingApprovals(long approvalGroupId)

       2: {

       3:     List<ContentAwaitingApproval> approvals = new List<ContentAwaitingApproval>();

       4:     using (SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings[Properties.Settings.Default.ConnectionStringName].ConnectionString))

       5:     {

       6:         using (SqlCommand cmd = conn.CreateCommand())

       7:         {

       8:             cmd.CommandText = "SELECT ContentId, LanguageId, Status FROM Approvals WHER ApprovalGroupID=@groupId";

       9:             cmd.Parameters.AddWithValue("groupId", approvalGroupId);

      10:             cmd.Connection.Open();

      11:             using (SqlDataReader dr = cmd.ExecuteReader())

      12:             {

      13:                 while (dr.Read())

      14:                 {

      15:                     approvals.Add(new ContentAwaitingApproval

      16:                     {

      17:                         ContentId = dr.GetInt64(0)

      18:                         ,

      19:                         LanguageId = dr.GetInt32(1)

      20:                         ,

      21:                         Status = dr.GetString(2)

      22:                     });

      23:                 }

      24:             }

      25:         }

      26:     }

      27:     return approvals;

      28: }

What’s occuring:

Create a list to contain the results
Create a new connection object (using a connection string defined in the configuration file)
Create a SQL Command object
Set the parameterised query text (if this is a stored procedure then you need to set the CommandType to StoredProcedure)
Set any parameters the query requires
Open the connection to the database
Execute the query
Read through all the results record by record
For each record add a new entry to the results list
Close the reader,command and connection and dispose objects
Return the results list

So, out of 11 steps only 4 actually related to the functionality of the method. The other 7 are all boiler plate, repeat each time, steps that are required for ADO.Net. If you want to add more detailed exception handling then that’s even more boiler plate code messing up your coding zen. When you look at it like that, it’s easy to start reaching from the ORM toolbox.

But wait, ORM isn’t the only thing that’s happened over the last 10 years! We’ve now got refactoring tools, extension methods and anonymous methods! What can these modern day miracles do for us?

Well, for starters we can tidy up that SqlConnection initializer to get something a bit cleaner and maybe some configuration validation code in place:

       1: private static SqlConnection ToConnection(this string connectionStringName)

       2: {

       3:     if (connectionStringName.IsNullOrWhiteSpace()) throw new ArgumentException("Connection String Name cannot be empty", "connectionStringName");

       4:     ConnectionStringSettings cns = ConfigurationManager.ConnectionStrings[connectionStringName];

       5:     if (cns == null) throw new ArgumentException("Connection String Name '{0}' cannot be found".ToFormattedString(connectionStringName), "connectionStringName");

       6:     return new SqlConnection(cns.ConnectionString);

       7: }

So replace:

using (SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings[Properties.Settings.Default.ConnectionStringName].ConnectionString))

With

using (SqlConnection conn = Properties.Settings.Default.ConnectionStringName.ToConnection())

Next, that parameter mapping code can be easily refactored away into a reusable block and add some additional intelligence too:

       1: private static void AddParametersToCommand(IDictionary<string, object> parameters, SqlCommand cmd)

       2: {

       3:     if (parameters == null) return;

       4:     foreach (string key in parameters.Keys)

       5:     {

       6:         if (parameters[key] == null)

       7:         {

       8:             cmd.Parameters.AddWithValue(key, DBNull.Value);

       9:         }

      10:         else if (parameters[key].GetType().IsPrimitive)

      11:         {

      12:             cmd.Parameters.AddWithValue(key, parameters[key]);

      13:         }

      14:         else

      15:         {

      16:             cmd.Parameters.AddWithValue(key, "{0}".ToFormattedString(parameters[key]));

      17:         }

      18:  

      19:     }

      20: }

Finally, the per record processing can be made into delegate method, allowing you the opportunity to add additional exception information to the process:

       1: Func<SqlDataReader, bool> recordAction = (dr)=>{return true;};

       2:  

       3: using (SqlDataReader dr = cmd.ExecuteReader())

       4: {

       5:    int i = 0;

       6:    try

       7:    {

       8:        while (dr.Read() && recordAction(dr)) i++;

       9:    }

      10:    catch (Exception ex)

      11:    {

      12:        ex.Data["Record Ordinal"] = i;

      13:        throw;

      14:    }

      15: }

Combining all this can give us a set of reusable ADO.Net extension methods, which allow us to separate the business concern from the ADO.Net concerns, so the example code a the top of the page can become:

       1: private static IEnumerable<ContentAwaitingApproval> GetPendingApprovals(long approvalGroupId)

       2: {

       3:     List<ContentAwaitingApproval> approvals = new List<ContentAwaitingApproval>();

       4:     "SELECT ContentId, LanguageId, Status FROM Approvals WHER ApprovalGroupID=@groupId"

       5:         .ProcessRecords(

       6:             Properties.Settings.Default.ConnectionStringName

       7:             , new Dictionary<string, object> { { "groupId", approvalGroupId } }

       8:             , (dr) =>

       9:                 {

      10:                     approvals.Add(new ContentAwaitingApproval

      11:                     {

      12:                         ContentId = dr.GetInt64(0)

      13:                         ,

      14:                         LanguageId = dr.GetInt32(1)

      15:                         ,

      16:                         Status = dr.GetString(2)

      17:                     });

      18:                     return true;

      19:                 }

      20:             );

      21:     return approvals;

      22: }

Every single line (all 3 if the readability whitespace is removed) are focused on the business side of the query with minimal ADO.Net specific requirements (if you count the connection string name as a ADO.Net specific).

The full (experimental) extension method class is:

       1: using System;

       2: using System.Configuration;

       3: using System.Data.SqlClient;

       4: using System.Linq;

       5: using System.Collections.Generic;

       6: using MartinOnDotNet.TypeConversion;

       7:  

       8: namespace MartinOnDotNet.Data.SqlClient

       9: {

    /// <summary>

    /// Handy methods for handling SQL

    /// </summary>

    public static class SqlClientExtensions

    {

        private static SqlConnection ToConnection(this string connectionStringName)

        {

            if (connectionStringName.IsNullOrWhiteSpace()) throw new ArgumentException("Connection String Name cannot be empty", "connectionStringName");

            ConnectionStringSettings cns = ConfigurationManager.ConnectionStrings[connectionStringName];

            if (cns == null) throw new ArgumentException("Connection String Name '{0}' cannot be found".ToFormattedString(connectionStringName), "connectionStringName");

            return new SqlConnection(cns.ConnectionString);

        }

 

        public static void Execute(this string commandText, string connectionStringName)

        {

            commandText.Execute(connectionStringName, null);

        }

 

        public static void Execute(this string commandText, string connectionStringName, IDictionary<string, object> parameters)

        {

            PerformSqlAction<bool>(commandText, connectionStringName, parameters, (cmd) =>

            {

                cmd.ExecuteNonQuery();

                return true;

            });

        }

 

        public static T ExecuteScalar<T>(this string commandText, string connectionStringName)

        {

            return commandText.ExecuteScalar<T>(connectionStringName, null);

        }

 

        public static T ExecuteScalar<T>(this string commandText, string connectionStringName, IDictionary<string, object> parameters)

        {

            return PerformSqlAction<T>(commandText, connectionStringName, parameters, (cmd) =>

            {

                object value = cmd.ExecuteScalar();

                if (value == DBNull.Value) return default(T);

                return (T)value;

            });

        }

 

        public static void ProcessRecords(this string commandText, string connectionStringName, Func<SqlDataReader, bool> recordAction)

        {

            commandText.ProcessRecords(connectionStringName, recordAction);

        }

 

        public static void ProcessRecords(this string commandText, string connectionStringName, IDictionary<string, object> parameters, Func<SqlDataReader, bool> recordAction)

        {

            PerformSqlAction<bool>(commandText, connectionStringName, parameters, (cmd) =>

           {

               using (SqlDataReader dr = cmd.ExecuteReader())

               {

                   int i = 0;

                   try

                   {

                       while (dr.Read() && recordAction(dr)) i++;

                   }

                   catch (Exception ex)

                   {

                       ex.Data["Record Ordinal"] = i;

                       throw;

                   }

               }

               return true;

           });

        }

 

        private static void AddParametersToCommand(IDictionary<string, object> parameters, SqlCommand cmd)

        {

            if (parameters != null)

            {

                foreach (string key in parameters.Keys)

                {

                    if (parameters[key] == null)

                    {

                        cmd.Parameters.AddWithValue(key, DBNull.Value);

                    }

                    else if (parameters[key].GetType().IsPrimitive)

                    {

                        cmd.Parameters.AddWithValue(key, parameters[key]);

                    }

                    else

                    {

                        cmd.Parameters.AddWithValue(key, "{0}".ToFormattedString(parameters[key]));

                    }

 

                }

            }

        }

 

        public static bool HasResults(this string commandText, string connectionStringName)

        {

            return commandText.HasResults(connectionStringName, null);

        }

 

        public static bool HasResults(this string commandText, string connectionStringName, IDictionary<string, object> parameters)

        {

            return PerformSqlAction<bool>(commandText, connectionStringName, parameters, (cmd) =>

            {

                using (SqlDataReader dr = cmd.ExecuteReader())

                {

                    return dr.Read();

                }

            });

        }

 

        private static T PerformSqlAction<T>(string commandText, string connectionStringName, IDictionary<string, object> parameters, Func<SqlCommand, T> action)

        {

            if (commandText.IsNullOrWhiteSpace()) throw new ArgumentException("Command cannot be empty", "commandText");

            if (action == null) throw new ArgumentNullException("action");

            try

            {

                using (SqlConnection conn = connectionStringName.ToConnection())

                using (SqlCommand cmd = conn.CreateCommand())

                {

                    cmd.CommandText = commandText;

                    AddParametersToCommand(parameters, cmd);

                    conn.Open();

                    return action(cmd);

                }

            }

            catch (Exception ex)

            {

                ex.Data["Connection String"] = connectionStringName;

                ex.Data["Command"] = commandText;

                if (parameters != null)

                {

                    ex.Data["Parameters"] = parameters.Keys.Select(k => "{0} = '{1}'".ToFormattedString(k, parameters[k])).ToDelimitedString("\n");

                }

                throw;

            }

        }

    }

}

These provide DataReader, Scalar and Execute methods that all leverage the same generic ADO.Net method PerformSqlAction using best practise boiler plate code with detailed exception logging backed in.

Preventing spamming from a mail forwarding address

2011-07-08T20:38:00.001+01:00

My webhosting company (arvixe) recently suspended my account due to a flood of ‘Inbox Full’ emails being sent to a mail forwarding alias (which then forwarded to the same accounts, which were full – D’Oh!). After a bit of investigation it turns out some kind soul has been spoofing emails from that account.

Apparently, there’s a nice little DNS entry that you can add so that email servers can validate that the emails have only been sent from recognised servers. There’s a sweet little wizard which walks you through generating the record:

http://www.microsoft.com/mscorp/safety/content/technologies/senderid/wizard/default.aspx

Migrating from TFS 2008 to SVN 1.6 with tfs2svn

2011-05-10T23:28:00.001+01:00

This is tricky because tfs2svn stopped being updated when subversion 1.4 ruled the roost.

Here are the steps that I took:

Have a subversion repository ready to receive the project (including ‘pre-revprop-change’ hook – mine is a simple ‘exit 0’ batch file)
Install TortoiseSVN 1.6
Download Collabnets command line client for svn 1.6 (svn-win32-1.6.15.zip)
Install tfs2svn 1.1 (http://sourceforge.net/projects/tfs2svn/files/tfs2svn/1.1/tfs2svn.setup.msi/download) on my development VM
Extract the svn-win32 command line client and copy the contents of ‘bin’ folder over the contents in ‘C:\Program Files (x86)\Kevin Colyar\tfs2svn\libs\svn-win32-1.4.6\bin’
Checkout revision 104 of tfs2svn using TortoiseSVN (repository url: https://tfs2svn.svn.sourceforge.net/svnroot/tfs2svn)
Save the patch from http://sourceforge.net/projects/tfs2svn/forums/forum/772710/topic/4510118 as tfs2svn_update.patch (make sure all & are converted to & and all links have any <a> tags removed)
Using TortoiseSVN apply the patch to the trunk branch. All the files should be matched successfully. If not check for stray html encoding/links in patch file.
Open the tfs2svn.sln from trunk (upgrading the solution if using VS2008)
Build ‘tfs2svn.WinForms’ and copy the output over the contents of ‘C:\Program Files (x86)\Kevin Colyar\tfs2svn’ apart from the ‘libs’ folder.
Launch tfs2svn and fill in the fairly straightforward form and hit convert!

tfs2svn should now spin through your TFS repository and migrate each changeset to subversion (keeping the history). The few errors that I encountered (after applying the patch!) were easy to fix as they were missing folder (from svn) issues when a changeset included a branch or merge operation. Simply creating and committing the missing folder allowed the migration to continue.

Logging is the new Exception Swallowing

2011-05-03T15:22:00.000+01:00

For a long time now I’ve been stamping down hard on empty catch blocks in code, for obvious reasons. When I can dictate coding standards that’s pretty much top the list.

Every ‘catch’ block must (at a minimum) log or throw

I now realise I made a mistake with this rule...it should be:

Every ‘catch’ block must (at a minimum) throw or log

It’s a subtle (the wording – not the formatting) difference in the way we need to think about this rule but it’s one I think we don’t think about enough.

For example, this is a common pattern of code that I’m seeing during Code Review sessions:

        1: public bool PerformCriticalTask()

       2: {

       3:     try

       4:     {

       5:         CriticalFunctionalityTaskA();

       6:         CriticalFunctionalityTaskB();

       7:         CriticalFunctionalityTaskC();

       8:         return true;

       9:     }

    catch(Exception ex)

    {

        Logger.Log(ex);

    }

    return false;

}

  

public CriticalFunctionalityTaskA()

{

    try

    {

        //Do Important Stuff Here

    }

    catch(Exception ex)

    {

        Logger.Log(ex);

    }

}

  

public CriticalFunctionalityTaskB()

{

    try

    {

        //Do More Important Stuff Here

    }

    catch(Exception ex)

    {

        Logger.Log(ex);

    }

}

  

public CriticalFunctionalityTaskC()

{

    try

    {

        //Do The Most Important Stuff

    }

    catch(Exception ex)

    {

        Logger.Log(ex);

    }

}

It’s pretty clear that this Catch/Log pattern has become a developers default exception handling boiler plate code. It’s adding no value and actually making the troubleshooting processes more complicated and time consuming.

My response to this is simple…remove all exception handling!

In the vast majority of cases, if an exception is thrown the application is already broken and letting it limp along is an act of cruelty. The application should handle these critical failures as exceptional and handle all of these events the same way in an application scoped way (Custom Error Page for Web Applications, etc). By all means log the exception at the application scope level, it will have actual diagnostic value there(complete stack trace, etc).

Of course, there are exceptions to this policy such as when you can legitimately recover from the fault. But these cases are few and far between.

Base26 Number Encoding/Generate Excel Columns

2011-05-02T14:55:00.001+01:00

Ever needed to convert an Excel Column Letter to a number or vice versa? Here’s a couple of extension methods to do it:

        1: public static string ToLetterEncoded(this Int32 numberToEncode)

       2: {

       3:     if (numberToEncode <= 0) throw new ArgumentOutOfRangeException("numberToEncode", numberToEncode, "Value must be greater than zero");

       4:     numberToEncode--;

       5:     if (numberToEncode >= 0 && numberToEncode < 26)

       6:         return ((char)('A' + numberToEncode)).ToString();

       7:     else

       8:         return ToLetterEncoded(numberToEncode / 26) + ToLetterEncoded(numberToEncode % 26 + 1);

       9: }

       1: public static Int32 FromLetterEncodedInt32(this string letterEncodedNumber)

       2: {

       3:     if (letterEncodedNumber.IsNullOrWhiteSpace()) throw new ArgumentNullException("letterEncodedNumber");

       4:     char[] letters = letterEncodedNumber.ToUpperInvariant().ToCharArray().Reverse().ToArray(); //smallest column first

       5:     if (letters.Where(c => !char.IsLetter(c)).Any()) throw new ArgumentOutOfRangeException("letterEncodedNumber", "Encoded Number must only contain the letters A-Z");

       6:     int[] numbers = letters.Select(c => (((int)c - 'A') + 1)).ToArray();

       7:     Int32 columnNumber = 0;

       8:     for (int i = 0; i < letters.Length; i++)

       9:     {

      10:         columnNumber += (Int32)Math.Pow(26, i) * numbers[i];

      11:     }

      12:     return columnNumber;

      13: }

I’ve used Int32 to represent the type of integer that you’re en(de)coding, for easy find ‘n’ replace.

These will only work for positive integer (1 and over).

Ektron: High Indexing Service Processor Usage (Potential) Fix

2010-12-16T20:32:00.001Z

One of our larger client Ektron sites has had a history of poor performance that always seemed to be related to Indexing immediately after publishing content or syncing content to the live environment. The site heavily uses indexed smart form fields and indexed metadata fields for ordering/sorting lists of content.

The symptoms were:

High CIDAEMON processor usage (95-100% of a processor core)
Total Documents to Index in Indexing Service Manager getting stuck
Indexing Service ‘Service Too Busy’ exceptions
Analysing Crash Dumps of the CIDAEMON process shows the ‘hot’ thread stuck in the QLXFilter.dll module

After performing the basic performance optimisations (removing any unnecessary catalogs such as System and Web) there was no real performance improvements and as more content was added (at quite a high rate) the performance issues quickly became outages.

Fortunately, with support from Ektron, we managed to identify (and fix) the potential cause… a misconfiguration in one of the 3rd Party components the indexing service uses to parse the asset xml files. This file can be found in:

C:\Windows\System32\QLFiltXml.xml
C:\Windows\SysWOW64\QLFiltXml.xml (64 bit machines only)

Opening these files in IE (and collapsing to just Top Level nodes) showed the default filters only:

There should be a filter for each configured smart form with indexed fields:

You can identify which smart form corresponds which filter by checking the ‘Title’ element.

It appears the during the upgrade from v7.6.6->v8.0.1 something went wrong which prevented the Ektron Windows Service from correctly maintaining the configuration file.

Repairing the QLXFilter configuration

The steps to repair the file are fairly straightforward (but make sure Ektron support is at hand for any unforeseen complications!).

Delete all Catalogs from the Indexing Service (via Indexing Service Manager)
Stop the Indexing Service
Ensure that QLXFilter.dll is properly registered. Open a command prompt and execute
regsvr32 c:\Windows\System32\QLXFilter.dll

Locate your ‘FriendlyNamesDefinition.txt (check the ‘DefaultColumnFile’ property value of the ‘[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\ContentIndexCommon]’ key) and remove any of the non-standard columns (indexed smart form fields, etc).

A list of standard column definitions is:

              1: [Names]

             2: DateCreated (VT_FILETIME) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktDateCreated

             3: DateModified (VT_FILETIME) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktDateModified

             4: GoLiveDate (VT_FILETIME) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktGoLiveDate

             5: ExpiryDate (VT_FILETIME) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktExpiryDate

             6: ExpiryType (DBTYPE_I4) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktExpiryType

             7: TaxCategory (DBTYPE_WSTR | DBTYPE_BYREF) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktTaxCategory

             8: ContentID (DBTYPE_I4) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktContentID

             9: ContentLanguage (DBTYPE_I4) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktContentLanguage

            10: ContentType (DBTYPE_I4) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktContentType 

            11: FolderId (DBTYPE_I4) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktFolderId

            12: QuickLink (DBTYPE_WSTR | DBTYPE_BYREF) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktQuickLink

            13: FolderName (DBTYPE_WSTR | DBTYPE_BYREF) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktFolderName 

            14: MapLongitude (DBTYPE_R8) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktLongitude 

            15: MapLatitude (DBTYPE_R8) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktLatitude 

            16: MapAddress (DBTYPE_WSTR | DBTYPE_BYREF) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktAddress 

            17: EDescription (DBTYPE_WSTR | DBTYPE_BYREF) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktEDescription 

            18: Keywords (DBTYPE_WSTR | DBTYPE_BYREF) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktKeywords 

            19: Title (DBTYPE_WSTR | DBTYPE_BYREF) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktTitle 

            20: MetaInfo (DBTYPE_WSTR | DBTYPE_BYREF) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktMetaInfo

            21: CMSPath (DBTYPE_WSTR | DBTYPE_BYREF) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktCMSPath

            22: CMSSize (DBTYPE_I4) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktCMSSize

            23: InPerm (DBTYPE_I4) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktInPerm

            24: Searchable (DBTYPE_I4) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktSearchable

            25: description  (DBTYPE_WSTR | DBTYPE_BYREF) = d5cdd505-2e9c-101b-9397-08002b2cf9ae  Ektdescription

            26: MapDate (VT_FILETIME) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktMapDate

            27: ContentID64 (DBTYPE_I8) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktContentID64

            28: FolderId64 (DBTYPE_I8) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktFolderId64

            29: EProductType (DBTYPE_I4) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktProductType

            30: ESkuNumber(DBTYPE_WSTR | DBTYPE_BYREF) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktSkuNumber

            31: ESizeMeasure (DBTYPE_I4) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktSizeMeasure

            32: EHeight(DBTYPE_R8) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktHeight

            33: EWidth(DBTYPE_R8) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktWidth

            34: ELength(DBTYPE_R8) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktLength

            35: EWeight(DBTYPE_R8) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktWeight

            36: EWeightMeasure (DBTYPE_I4) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktWeightMeasure

            37: EUnitsInStock (DBTYPE_I4) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktUnitsInStock

            38: EUnitsOnOrder (DBTYPE_I4) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktUnitsOnOrder

            39: EReorderLevel (DBTYPE_I4) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktReorderLevel

            40: EPurchased (DBTYPE_I4) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktPurchased

            41: EImage(DBTYPE_WSTR | DBTYPE_BYREF) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktImage 

            42: ECurrencyId (DBTYPE_I4) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktCurrencyId 

            43: EListPrice (DBTYPE_R8) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktListPrice 

            44: ESalePrice (DBTYPE_R8) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktSalePrice 

            45: EBuyable (DBTYPE_I4) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktBuyable 

            46: xmlconfigid (DBTYPE_I8) = d5cdd505-2e9c-101b-9397-08002b2cf9ae Ektxmlconfigid

            47: DisabledTaxCategory (DBTYPE_WSTR | DBTYPE_BYREF) = d5cdd505-2e9c-101b-9397-08002b2cf9ae EktDisabledTaxCategory

Run the Ektron ‘SearchConfigUI’ utility to ‘Create New Catalogs’ (after checking all the settings are correct).
Once ‘SearchConfigUI’ has passed the ‘Updating XML Configuration for XML Content’ step then you can ensure that:
1. The QLFiltXml.xml file to ensure the correct filters have been installed
2. The FriendlyNamesDefinition.txt to ensure that your indexed properties have been restored
Once ‘SearchConfigUI’ has completed then you should be able to monitor the Indexing Service scanning the files in a more reasonable and consistent manner

The performance issue should now be fixed/reduced, hope this helps.

EKTRON: Diagnosing 8.0 Extension Strategy Loading Failures

2010-11-18T21:17:00.001Z

I’ve recently hit a problem with deploying Ektron Extensions (the 8.0 replacement for Plugins), essentially every time my Extension ‘Strategy’ was called the workarea would display an error similar to:

Value cannot be null. Parameter name: type

Fortunately, in the Application Event log (for the CMS400 Source) there’s a bit more information:

        1: Timestamp: 18/11/2010 18:43:01

       2: Message: Could not load the MartinOnDotNet.Helpers.Ektron.Extensions.Monitoring.UserMonitoringStrategy, MartinOnDotNet.Helpers.Ektron.Extensions.Monitoring implementation from the configuration file

       3: Category: Error

       4: Priority: -1

       5: EventId: 0

       6: Severity: Error

This shows that the declaration in the web.config is correct:

       1: <objectFactory>

       2:     <objectStrategies>

       3:         <add name="User">

       4:             <strategies>

       5:                 <add name="UserMonitoringStrategy"

       6:                          type="MartinOnDotNet.Helpers.Ektron.Extensions.Monitoring.UserMonitoringStrategy, MartinOnDotNet.Helpers.Ektron.Extensions.Monitoring"/>

       7:             </strategies>

       8:         </add>

       9:     </objectStrategies>

      10:     <objectImplementations>

      11:     </objectImplementations>

      12: </objectFactory>

Fortunately, the next logged error reveals another vital clue:

       1: Timestamp: 18/11/2010 18:43:22

       2: Message: Exception thrown from: /WorkArea/login.aspx

       3: Value cannot be null.

       4: Parameter name: type   at System.Activator.CreateInstance(Type type, Boolean nonPublic)

       5:    at Ektron.Cms.ObjectFactory.GetStrategyList[T](String objectName)

       6:    at Ektron.Cms.User.EkUser.get_StrategyList()

       7:    at Ektron.Cms.User.EkUser.OnBeforeLogin(UserData userData)

       8:    at Ektron.Cms.User.EkUser.logIn(String username, String Password, String ServerName, String Domain, String Protocol, Boolean autologin, AutoAddUserTypes AutoAddType, Boolean ForceLogin)    at System.Activator.CreateInstance(Type type, Boolean nonPublic)

       9:    at Ektron.Cms.ObjectFactory.GetStrategyList[T](String objectName)

      10:    at Ektron.Cms.User.EkUser.get_StrategyList()

      11:    at Ektron.Cms.User.EkUser.OnBeforeLogin(UserData userData)

      12:    at Ektron.Cms.User.EkUser.logIn(String username, String Password, String ServerName, String Domain, String Protocol, Boolean autologin, AutoAddUserTypes AutoAddType, Boolean ForceLogin)

      13: Last 1 events

      14: [EventName]: [Timestamp] - ([UserID],[VisitorID])

      15: OnBeforeUserLogin: 18/11/2010 18:43:01 - (0, b7461b16-72f8-4631-b180-29e128d87184)

      16:  

      17: Category: Error

      18: Priority: -1

      19: EventId: 0

      20: Severity: Error

The reference to ‘Activator’ means that the issue is the .Net cannot find the referenced strategy through the type description.

This is a bit puzzling as the declaration is correct, so I need a bit more information on what’s causing the problem and why I can’t see it in the log, so that means breaking out Reflector and digging into the API. Fortunately, the problem method (GetStrategyList<T>) is easy to find and fairly simple to understand. Here’s the code that’s failing:

       1: try

       2: {

       3:     type = Type.GetType(element2.Type, true);

       4: }

       5: catch (TypeLoadException)

       6: {

       7:     EkException.WriteToEventLog(string.Format("Could not load the {0} implementation from the configuration file", element2.Type), EventLogEntryType.Error);

       8: }

       9: strategy = (T) Activator.CreateInstance(type);

Essentially, the first log entry is written in response to the actual problem (but doesn’t record it!) and the second, more detailed error is caused by the failure to assign the type variable.

What we really need to get hold of is the original TypeLoadException and capture the reason for the failure. There are two ways to do this:

You could use the Visual Studio Exceptions dialog (Debug->Exceptions and check the ‘Thrown’ checkbox for System.TypeLoadException under ‘Common Language Runtime Exceptions) and use the debugger to inspect the error:
Create a test bed report to reproduce the strategy loading procedure with an increased amount of logging

My first brush attempt was using Option 1, but I found that it was a bit unreliable and would be limited to debugging my development machine. The second option is more work, but is reusable and direct. My weapon of choice for this type of report is a custom HttpHandler which can be added/removed through a simple configuration change:

       1: using System;

       2: using System.Configuration;

       3: using System.Web;

       4: using global::Ektron.Cms;

       5:  

       6: namespace MartinOnDotNet.Helpers.Ektron.Extensibilty

       7: {

       8:     /// <summary>

       9:     /// Diagnostic handler to test loading Extensions

    /// </summary>

    public class ValidateStrategiesHandler : IHttpHandler

    {

  

        /// <summary>

        /// Enables processing of HTTP Web requests by a custom HttpHandler that implements the <see cref="T:System.Web.IHttpHandler"/> interface.

        /// </summary>

        /// <param name="context">An <see cref="T:System.Web.HttpContext"/> object that provides references to the intrinsic server objects (for example, Request, Response, Session, and Server) used to service HTTP requests.</param>

        public void ProcessRequest(HttpContext context)

        {

            context.Response.ContentType = "text/plain";

            System.IO.TextWriter output = context.Response.Output;

            output.WriteLine("Configured Extension Strategy Test\n");

            ObjectFactorySection factorySection = (ObjectFactorySection)ConfigurationManager.GetSection("objectFactory");

            foreach (ObjectStrategyConfigElement strategies in factorySection.ObjectStrategies)

            {

                output.WriteLine("{0} (found {1})", strategies.Name, strategies.Strategies.Count);

                foreach (StrategyConfigElement strategy in strategies.Strategies)

                {

                    RenderStrategyLoadingOutcome(output, strategy);

                }

            }

            output.WriteLine("\nLoaded Assemblies");

            foreach (System.Reflection.Assembly ass in System.AppDomain.CurrentDomain.GetAssemblies())

            {

                output.WriteLine(ass.FullName);

            }

  

        }

  

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1804:RemoveUnusedLocals", MessageId = "type")]

        private void RenderStrategyLoadingOutcome(System.IO.TextWriter output, StrategyConfigElement strategy)

        {

            output.Write("\t{0,-20}\t{1,-40}\t", strategy.Name, strategy.Type);

            try

            {

                Type type = Type.GetType(strategy.Type, true);

                Type baseType = type.BaseType;

                output.WriteLine("{0}\tOK!", baseType.Name);

            }

            catch (Exception tle)

            {

                output.WriteLine("Failed! ({0}:{1})", tle.GetType().Name, tle.Message);

                System.Diagnostics.Trace.TraceError("Failed to Load Strategy '{0}'\n{1}", strategy.Type, tle.ToString());

            }

        }

  

       /// <summary>

       /// Gets a value indicating whether another request can use the <see cref="T:System.Web.IHttpHandler"/> instance.

       /// </summary>

       /// <value></value>

       /// <returns>true if the <see cref="T:System.Web.IHttpHandler"/> instance is reusable; otherwise, false.

       /// </returns>

       public bool IsReusable

       {

           // Return false in case your Managed Handler cannot be reused for another request.

           // Usually this would be false in case you have some state information preserved per request.

           get { return true; }

       }

    }

}

This can simply be registered in the system.webServer/handlers section of the web.config (assuming IIS 7 and Integrated Pipeline):

       1: <add name="Verify Strategy Handler"

       2:      verb="GET"

       3:      path="secure/validatestrategies.ashx"

       4:      type="MartinOnDotNet.Helpers.Ektron.Extensibilty.ValidateStrategiesHandler"

       5:      preCondition="integratedMode,runtimeVersionv2.0" />

This report can now be called using /secure/validatestrategies.ashx">http://<website>/secure/validatestrategies.ashx and will render a report similar to:

       1: Configured Extension Strategy Test

       2:  

       3: Content (found 1)

       4:     LoggingStrategy          MartinOnDotNet.Helpers.Ektron.Extensibilty.LoggingContentStrategy, MartinOnDotNet.Helpers.Ektron    ContentStrategy    OK!

       5:  

       6: User (found 1)

       7:     UserMonitoringStrategy    MartinOnDotNet.Helpers.Ektron.Extensions.Monitoring.UserMonitoringStrategy, MartinOnDotNet.Helpers.Ektron.Extensions.Monitoring    Failed! (TypeLoadException:Could not load type MartinOnDotNet.Helpers.Ektron.Extensions.Monitoring.UserMonitoringStrategy' from assembly MartinOnDotNet.Helpers.Ektron.Extensions.Monitoring'.)

       8:  

       9: Loaded Assemblies

      10: ** Ommitted as there's hundreds **

With the full exception logged to Trace.

What the report immediately showed was that the Extensions that had worked were in assemblies that were listed in the ‘Loaded Assemblies’ report. The ones that failed weren’t.

This is odd as the library was definitely in the websites /bin folder, and a little more digging and investigation revealed that the one of the class libraries dependencies couldn’t be resolved correctly due to version number mismatch. When that was fixed, the Strategies were loaded as expected! Result.

       1: Configured Extension Strategy Test

       2:  

       3: Content (found 1)

       4:     LoggingStrategy          MartinOnDotNet.Helpers.Ektron.Extensibilty.LoggingContentStrategy, MartinOnDotNet.Helpers.Ektron    ContentStrategy    OK!

       5: User (found 1)

       6:     UserMonitoringStrategy    MartinOnDotNet.Helpers.Ektron.Extensions.Monitoring.UserMonitoringStrategy, MartinOnDotNet.Helpers.Ektron.Extensions.Monitoring    UserStrategy    OK!

       7:  

       8: Loaded Assemblies

       9: ** Ommitted as there's hundreds **

Hopefully, this report/test bench handler will help others with similar issues.

Performance: Applying Output Cache Policies to a User Controls

2010-11-03T03:46:00.001Z

One of the great features in ASP.NET is the rich caching framework. I particularly like being able to:

Define caching policies in the configuration file and then assigning those policies to groups of pages (via the @OutputCache directive).
Cache User Control output for reuse on multiple pages (Partial Page Caching)

What I don’t like is the fact that you can’t combine the two! You have to hard code your user control cache directives either in the mark-up (as @OutputCache directive) or by applying an attribute (System.Web.UI.PartialCaching) to the code behind, both of which require at least the duration to be hardcoded.

This is a massive oversight, as best-practise ASP.Net dictates precompiling websites prior to production which means caching rules can’t be tweaked without frequent rebuild/deployment cycles.

Fortunately, we can work around the issue!

As with most of my workarounds, the trick is a new Extension Method to dynamically alter the UserControls Cache Policy:

        1: using System;

       2: using System.Linq;

       3: using System.Web.Configuration;

       4: using System.Web.UI;

       5:  

       6:  

       7: namespace MartinOnDotNet.Helpers.UI

       8: {

       9:     /// <summary>

    /// Useful extension methods for Controls

    /// </summary>

    public static class ControlExtensions

    {

  

  

        private static OutputCacheSettingsSection _outputCacheSettings = ((OutputCacheSettingsSection)WebConfigurationManager.GetSection(@"system.web/caching/outputCacheSettings"));

  

        /// <summary>

        /// Applies the cache policy.

        /// </summary>

        /// <param name="control">The control.</param>

        /// <param name="cachePolicyName">Name of the cache policy.</param>

        public static void ApplyCachePolicy(this UserControl control, string cachePolicyName)

        {

            if (control == null) throw new ArgumentNullException("control");

            if (string.IsNullOrEmpty(cachePolicyName)) throw new ArgumentNullException("cachePolicyName");

            if (_outputCacheSettings == null) return;

            OutputCacheProfile profile = _outputCacheSettings.OutputCacheProfiles.OfType<OutputCacheProfile>()

                .Where(p => string.Equals(p.Name, cachePolicyName, StringComparison.OrdinalIgnoreCase))

                .FirstOrDefault();

            if (profile == null || !profile.Enabled) return;

            control.CachePolicy.SetExpires(DateTime.Now.AddSeconds(profile.Duration));

            if (!string.Equals(profile.VaryByParam, "none", StringComparison.OrdinalIgnoreCase) && !string.IsNullOrEmpty(profile.VaryByParam))

                foreach (string key in profile.VaryByParam.Split(new char[]{';'},  StringSplitOptions.RemoveEmptyEntries))

                    control.CachePolicy.VaryByParams[key] = true;

            else

                control.CachePolicy.VaryByParams.IgnoreParams = true;

            if (!string.IsNullOrEmpty(profile.VaryByCustom)) control.CachePolicy.SetVaryByCustom(profile.VaryByCustom);

            if (!string.IsNullOrEmpty(profile.VaryByControl)) control.CachePolicy.SetVaryByCustom(profile.VaryByControl);

  

  

        }

  

    }

}

To use it each user control will need to have a line added to the OnInit override in the codebehind (*.ascx.cs):

       1: using System;

       2: using MartinOnDotNet.Helpers.UI;

       3:  

       4: namespace MartinOnDotNet.Helpers.BrandingDemo

       5: {

       6:     /// <summary>

       7:     /// Example of a cached usercontrol

       8:     /// </summary>

       9:     public partial class CacheExample : System.Web.UI.UserControl

      10:     {

      11:         /// <summary>

      12:         /// Raises the <see cref="E:System.Web.UI.Control.Init"/> event.

      13:         /// </summary>

      14:         /// <param name="e">An <see cref="T:System.EventArgs"/> object that contains the event data.</param>

      15:         protected override void OnInit(EventArgs e)

      16:         {

      17:             base.OnInit(e);

      18:             if (this.CachePolicy.SupportsCaching)

      19:                 this.ApplyCachePolicy("Test");

      20:         }

      21:    

      22:     }

      23: }

The ascx file will need a place holder @outputcache directive:

       1: <%@ Control Language="C#" AutoEventWireup="true" CodeBehind="CacheExample.ascx.cs"

       2:     Inherits="MartinOnDotNet.Helpers.BrandingDemo.CacheExample" %>

       3:  

       4: <%@ OutputCache Duration="1" VaryByParam="none" Shared="true" %>

       5:  

       6: <% = DateTime.Now.ToString("G") %>

The values in the directive act as defaults and will be overridden by parameters in the matching Cache Policy (Test, in the code above), apart from Shared which isn’t included in the config.

Finally, define you cache policy in the web.config file:

       1: <system.web>

       2:     <caching>

       3:         <outputCacheSettings>

       4:             <outputCacheProfiles>

       5:                 <add name="Test"

       6:                          duration="3600"

       7:                          varyByParam="none" varyByCustom="DATE:yyyyMMddHHmm"/>

       8:             </outputCacheProfiles>

       9:         </outputCacheSettings>

      10:     </caching>

      11: </system.web>

The varyByCustom attribute in the rule above refers to some custom code in the Global.asax using the GetVaryByCustomString method. In this case the code will vary by the current date in the given format making the cached version of the control rollover every minute. This is a bit wasteful, as the cache will hang on to each version of the control for 3600 seconds (an hour) but proves the principle works.

Happily, the outputCacheSettings element of the web.config file supports configSource so you can actually apply different profiles for different environments by using an external config file.

Happy Caching!