Blog posts by Greg Brant2011-09-11T12:00:00.0000000Zhttps://world.optimizely.com/blogs/Greg-Brant/Optimizely WorldEPiServer and MvcMiniProfiler - Profiled Base Classes<p>So far we've had <a href="http://blog.gregbrant.com/post/EPiServer-and-MvcMiniProfiler-A-first-look.aspx">a basic introduction to MvcMiniProfiler and how to get it working with EPiServer</a>, we've also looked at <a href="http://blog.gregbrant.com/post/EPiServer-and-MvcMiniProfiler-A-Profiled-DataFactory.aspx">a version of DataFactory that gives profiling data about its calls</a>.</p>
<p>This time I'm going to look at giving easier access to stepping the profiler, not that it's exactly hard to begin with, as well as building some basic profiling into some base classes so that there is always a minimum of profiling in your pages.</p>
<p>This is all work in progress or <em>thinking in code</em> if you will. It hasn't been road tested much and I'm not sure it's the right recipe, so please feel free to leave feedback in the comments.</p>
<h2>Stepping The Profiler</h2>
<p>Stepping the profiler is usually achieved with a call to MvcMiniProfiler.MiniProfiler.StepStatic or MvcMiniProfiler.MiniProfiler.Current.Step. This might get a bit bloated so let's see if we can shorten it some. As I see it, there are three places we're going to want to step the profiler from:</p>
<ol>
<li>Page Templates</li>
<li>Master Pages</li>
<li>User Controls</li>
</ol>
<p>So what about hanging a <em>Step</em> method off each of these types:</p>
<p> </p>
<pre class="language-csharp"><code>using System;
using System.Web.UI;
using MvcMiniProfiler;
namespace EPiServer.MiniProfiler
{
public static class ProfilerExtensions
{
public static IDisposable StepProfilerEx(this PageBase page, string name, ProfileLevel level = ProfileLevel.Info)
{
string typeName = page.GetType().Name;
return MvcMiniProfiler.MiniProfiler.StepStatic(string.Format("{0} {1}", typeName, name), level);
}
public static IDisposable StepProfilerEx(this MasterPage page, string name, ProfileLevel level = ProfileLevel.Info)
{
string typeName = page.GetType().Name;
return MvcMiniProfiler.MiniProfiler.StepStatic(string.Format("{0} {1}", typeName, name), level);
}
public static IDisposable StepProfilerEx(this UserControl control, string name, ProfileLevel level = ProfileLevel.Info)
{
string typeName = control.GetType().Name;
return MvcMiniProfiler.MiniProfiler.StepStatic(string.Format("{0} {1}", typeName, name), level);
}
}
}</code></pre>
<p class="brush: c-sharp;">Here I've added three Extension Methods to a class which combines the type name of the caller along with the user-defined step name. This gives us a clue as to where the code is being executed, the resultant profile looks something like this:</p>
<p class="brush: c-sharp;"><img style="border-style: initial; border-color: initial; display: block; margin-left: auto; margin-right: auto;" src="http://blog.gregbrant.com/image.axd?picture=2011%2f9%2fStepProfilerEx.PNG" alt="" /></p>
<h2 class="brush: c-sharp;">Profiled Base Classes </h2>
<p class="brush: c-sharp;">My next idea is to provide profiled versions of the page events such as OnLoad and OnPreRender as well as profiled versions of the EPiServer API methods like PageBase.GetPage. The full code can be <a href="http://blog.gregbrant.com/file.axd?file=2011%2f9%2fProfilerExtensions.zip">downloaded in this zip file</a>, but for illustrative purposes part of my ProfiledTemplatePage might look like this:</p>
<p class="brush: c-sharp;"> </p>
<pre class="language-csharp"><code>using System;
using System.Web.UI.WebControls;
using EPiServer.Core;
using MvcMiniProfiler;
namespace EPiServer.MiniProfiler
{
public abstract class ProfiledTemplatePage : TemplatePage
{
private string typeName;
public MvcMiniProfiler.MiniProfiler Profiler
{
get { return MvcMiniProfiler.MiniProfiler.Current; }
}
public ProfiledTemplatePage()
{
// Store the name of the current type for profiling steps.
typeName = this.GetType().Name;
}
public IDisposable StepProfiler(string name, ProfileLevel level = ProfileLevel.Info)
{
return Profiler.Step(string.Format("{0} {1}", typeName, name), level);
}
#region Profiled events
protected virtual void OnLoadProfiled(EventArgs e) { }
protected virtual void OnLoadCompleteProfiled(EventArgs e) { }
protected internal virtual void OnPreRenderProfiled(EventArgs e) { }
// Other profiled events here...
#endregion
#region PageBase overrides
public override PageData GetPage(PageReference pageLink)
{
using (StepProfiler("GetPage"))
return base.GetPage(pageLink);
}
// Other profiled EPiServer methods here...
#endregion
#region Control overrides
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
using (StepProfiler("OnLoadProfiled"))
OnLoadProfiled(e);
}
protected override void OnLoadComplete(EventArgs e)
{
base.OnLoadComplete(e);
using (StepProfiler("OnLoadCompleteProfiled"))
OnLoadCompleteProfiled(e);
}
// Wrap other events here...
protected override void OnPreRender(EventArgs e)
{
base.OnPreRender(e);
using (StepProfiler("OnPreRenderProfiled"))
OnPreRenderProfiled(e);
// Logic to add Profiler Includes to the <head> of the page.
string html = MvcMiniProfiler.MiniProfiler.RenderIncludes().ToHtmlString();
Page.Header.Controls.Add(new Literal
{
Mode = LiteralMode.PassThrough,
Text = html
});
}
#endregion
}
}</code></pre>
<p>This is a pretty big code snippet as it stands so I've left out many of the events and methods, it's worth noting that OnPreRender wraps the OnPreRenderProfiled method but then adds the profiler includes to the <head> of the page. There are similar classes in the form of ProfiledUserControl and ProfiledMasterPage, ProfiledTemplatePage is the only one to render the includes to the head.</p>
<p>Using the code is pretty obvious, you inherit from the base class and override the Profiled versions of events:</p>
<pre class="language-csharp"><code>using System;
using System.Web.UI.HtmlControls;
using System.Web.UI.WebControls;
using EPiServer.Core;
using EPiServer.MiniProfiler;
namespace EPiServer_MiniProfiler.Templates
{
public partial class News : ProfiledTemplatePage
{
protected override void OnLoadProfiled(EventArgs e)
{
NewsItems.DataSource = GetChildren(CurrentPageLink);
using (StepProfiler("Binding news list"))
NewsItems.DataBind();
}
}
}</code></pre>
<p> </p>
<h2>Work In Progress</h2>
<p>I'm not 100% about this implementation as it's not a like-for-like replacement for TemplatePage. It might be easy for a developer who is new to the project to simply use OnLoad rather than OnLoadProfiled. The other thing is that Auto-Wireup events such as Page_Load are triggered within the built-in OnLoad events. This raises the idea of implementing a Page_LoadProfiled but I'm not sure this isn't just throwing <em>good</em> code after bad.</p>
<pre class="language-csharp"><code>protected virtual void OnLoadProfiled(EventArgs e)
{
CallEvent("Page_LoadProfiled", e);
}
private void CallEvent(string eventName, EventArgs e)
{
var t = this.GetType();
var method = t.GetMethod(eventName);
if (method != null)
method.Invoke(this, new[] { e });
}</code></pre>
<p>As I've said, these are some first thoughts on building profiling data into your EPiServer working practices and I haven't tried them out enough to be sure of their worth.</p>
<h2>Next Time</h2>
<p>Next time we'll look at locking down the trace information so that it's only visible to the people you want to see it.</p>2011-09-11T12:00:00.0000000ZBlog postEPiServer and MvcMiniProfiler - A Profiled DataFactory<p><a href="http://blog.gregbrant.com/post/EPiServer-and-MvcMiniProfiler-A-first-look.aspx">Last time we took a quick look into MvcMiniProfiler</a>, how to get it up and running on EPiServer and the basics of profiling code.</p>
<p>This time, we'll take a look at the DataFactory and profiling it's use.</p>
<h2>ProfiledDataFactory</h2>
<p>A lot of the time, when you're not working with the CurrentPage PageData object, you're working with the EPiServer DataFactory to obtain and manipulate PageData objects. ProfiledDataFactory is a simple wrapper around the default DataFactory; I've implemented all the methods which aren't marked with the Obsolete attribute so the class is a drop-in replacement for EPiServer.DataFactory. As a side note, if EPiServer employed Dependency Injection or was more losely coupled, we might have been able to replace the default DataFactory throughout the framework. (double click the code to select it as plain text)</p>
<p> </p>
<pre class="language-csharp"><code>using System.Collections.Generic;
using EPiServer.Configuration;
using EPiServer.Core;
using EPiServer.DataAbstraction;
using EPiServer.DataAccess;
using EPiServer.Security;
using MvcProf = MvcMiniProfiler;
namespace EPiServer.MiniProfiler
{
public sealed class ProfiledDataFactory
{
private static ProfiledDataFactory _instance = new ProfiledDataFactory();
public static ProfiledDataFactory Instance
{
get { return _instance; }
}
public PageReference Copy(PageReference pageLink, PageReference destinationLink)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory Copy"))
return DataFactory.Instance.Copy(pageLink, destinationLink);
}
public PageReference Copy(PageReference pageLink, PageReference destinationLink, bool allowThreading)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory Copy"))
return DataFactory.Instance.Copy(pageLink, destinationLink, allowThreading);
}
public PageReference Copy(PageReference pageLink, PageReference destinationLink, bool publishOnDestination, bool allowThreading)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory Copy"))
return DataFactory.Instance.Copy(pageLink, destinationLink, publishOnDestination, allowThreading);
}
public PageReference Copy(PageReference pageLink, PageReference destinationLink, AccessLevel requiredSourceAccess, AccessLevel requiredDestinationAccess, bool publishOnDestination, bool allowThreading)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory Copy"))
return DataFactory.Instance.Copy(pageLink, destinationLink, requiredSourceAccess, requiredDestinationAccess, publishOnDestination, allowThreading);
}
public PageData CreateLanguageBranch(PageReference pageLink, ILanguageSelector selector)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory CreateLanguageBranch"))
return DataFactory.Instance.CreateLanguageBranch(pageLink, selector);
}
public PageData CreateLanguageBranch(PageReference pageLink, ILanguageSelector selector, AccessLevel access)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory CreateLanguageBranch"))
return DataFactory.Instance.CreateLanguageBranch(pageLink, selector, access);
}
public void Delete(PageReference pageLink, bool forceDelete)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory Delete"))
DataFactory.Instance.Delete(pageLink, forceDelete);
}
public void Delete(PageReference pageLink, bool forceDelete, AccessLevel access)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory Delete"))
DataFactory.Instance.Delete(pageLink, forceDelete, access);
}
public void DeleteChildren(PageReference pageLink, bool forceDelete)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory DeleteChildren"))
DataFactory.Instance.DeleteChildren(pageLink, forceDelete);
}
public void DeleteChildren(PageReference pageLink, bool forceDelete, AccessLevel access)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory DeleteChildren"))
DataFactory.Instance.DeleteChildren(pageLink, forceDelete, access);
}
public void DeleteLanguageBranch(PageReference pageLink, string languageBranch)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory DeleteLanguageBranch"))
DataFactory.Instance.DeleteLanguageBranch(pageLink, languageBranch);
}
public void DeleteLanguageBranch(PageReference pageLink, string languageBranch, AccessLevel access)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory DeleteLanguageBranch"))
DataFactory.Instance.DeleteLanguageBranch(pageLink, languageBranch, access);
}
public void DeleteVersion(PageReference pageLink)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory DeleteVersion"))
DataFactory.Instance.DeleteVersion(pageLink);
}
public void DeleteVersion(PageReference pageLink, AccessLevel access)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory DeleteVersion"))
DataFactory.Instance.DeleteVersion(pageLink, access);
}
public PageDataCollection FindAllPagesWithCriteria(PageReference pageLink, PropertyCriteriaCollection criterias, string languageBranch, ILanguageSelector selector)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory FindAllPagesWithCriteria"))
return DataFactory.Instance.FindAllPagesWithCriteria(pageLink, criterias, languageBranch, selector);
}
public PageDataCollection FindPagesWithCriteria(PageReference pageLink, PropertyCriteriaCollection criterias)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory FindPagesWithCriteria"))
return DataFactory.Instance.FindPagesWithCriteria(pageLink, criterias);
}
public PageDataCollection FindPagesWithCriteria(PageReference pageLink, PropertyCriteriaCollection criterias, string languageBranch)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory FindPagesWithCriteria"))
return DataFactory.Instance.FindPagesWithCriteria(pageLink, criterias, languageBranch);
}
public PageDataCollection FindPagesWithCriteria(PageReference pageLink, PropertyCriteriaCollection criterias, string languageBranch, ILanguageSelector selector)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory FindPagesWithCriteria"))
return DataFactory.Instance.FindPagesWithCriteria(pageLink, criterias, languageBranch, selector);
}
public PageDataCollection GetChildren(PageReference pageLink)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory GetChildren"))
return DataFactory.Instance.GetChildren(pageLink);
}
public PageDataCollection GetChildren(PageReference pageLink, ILanguageSelector selector)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory GetChildren"))
return DataFactory.Instance.GetChildren(pageLink, selector);
}
public PageDataCollection GetChildren(PageReference pageLink, ILanguageSelector selector, int startIndex, int maxRows)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory GetChildren"))
return DataFactory.Instance.GetChildren(pageLink, selector, startIndex, maxRows);
}
public PageData GetDefaultPageData(PageReference parentPageLink, int pageTypeID)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory GetDefaultPageData"))
return DataFactory.Instance.GetDefaultPageData(parentPageLink, pageTypeID);
}
public PageData GetDefaultPageData(PageReference parentPageLink, string pageTypeName)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory GetDefaultPageData"))
return DataFactory.Instance.GetDefaultPageData(parentPageLink, pageTypeName);
}
public PageData GetDefaultPageData(PageReference parentPageLink, int pageTypeID, ILanguageSelector selector)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory GetDefaultPageData"))
return DataFactory.Instance.GetDefaultPageData(parentPageLink, pageTypeID, selector);
}
public PageData GetDefaultPageData(PageReference parentPageLink, string pageTypeName, ILanguageSelector selector)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory GetDefaultPageData"))
return DataFactory.Instance.GetDefaultPageData(parentPageLink, pageTypeName, selector);
}
public IList<PageReference> GetDescendents(PageReference pageLink)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory GetDescendents"))
return DataFactory.Instance.GetDescendents(pageLink);
}
public PageDataCollection GetLanguageBranches(PageReference pageLink)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory GetLanguageBranches"))
return DataFactory.Instance.GetLanguageBranches(pageLink);
}
public PageReferenceCollection GetLinksToPages(PageReference pageLink)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory GetLinksToPages"))
return DataFactory.Instance.GetLinksToPages(pageLink);
}
public PageData GetPage(PageReference pageLink)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory GetPage"))
return DataFactory.Instance.GetPage(pageLink);
}
public PageData GetPage(PageReference pageLink, ILanguageSelector selector)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory GetPage"))
return DataFactory.Instance.GetPage(pageLink, selector);
}
public PageProviderBase GetPageProvider(PageReference pageLink)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory GetPageProvider"))
return DataFactory.Instance.GetPageProvider(pageLink);
}
public PageProviderBase GetPageProvider(string remoteSiteName)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory GetPageProvider"))
return DataFactory.Instance.GetPageProvider(remoteSiteName);
}
public PageDataCollection GetPages(IList<PageReference> pageLinks, ILanguageSelector selector)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory GetPages"))
return DataFactory.Instance.GetPages(pageLinks, selector);
}
public PagePath GetParents(PageReference pageLink)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory GetParents"))
return DataFactory.Instance.GetParents(pageLink);
}
public Settings GetSettingsFromPage(PageReference pageLink)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory GetSettingsFromPage"))
return DataFactory.Instance.GetSettingsFromPage(pageLink);
}
public Settings GetSettingsFromPage(PageReference pageLink, bool fallbackToStartPageId)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory GetSettingsFromPage"))
return DataFactory.Instance.GetSettingsFromPage(pageLink, fallbackToStartPageId);
}
public bool IsCapabilitySupported(PageReference pageLink, PageProviderCapabilities capability)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory IsCapabilitySupported"))
return DataFactory.Instance.IsCapabilitySupported(pageLink, capability);
}
public bool IsWastebasket(PageReference pageLink)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory IsWastebasket"))
return DataFactory.Instance.IsWastebasket(pageLink);
}
public PageDataCollection ListDelayedPublish()
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory ListDelayedPublish"))
return DataFactory.Instance.ListDelayedPublish();
}
public PageVersionCollection ListPublishedVersions(PageReference pageLink)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory ListPublishedVersions"))
return DataFactory.Instance.ListPublishedVersions(pageLink);
}
public PageVersionCollection ListVersions(PageReference pageLink)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory ListVersions"))
return DataFactory.Instance.ListVersions(pageLink);
}
public PageVersionCollection ListVersions(PageReference pageLink, string languageBranch)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory ListVersions"))
return DataFactory.Instance.ListVersions(pageLink, languageBranch);
}
public PageVersion LoadPublishedVersion(PageReference pageLink)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory LoadPublishedVersion"))
return DataFactory.Instance.LoadPublishedVersion(pageLink);
}
public PageVersion LoadPublishedVersion(PageReference pageLink, string languageBranch)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory LoadPublishedVersion"))
return DataFactory.Instance.LoadPublishedVersion(pageLink, languageBranch);
}
public PageVersion LoadVersion(PageReference pageLink)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory LoadVersion"))
return DataFactory.Instance.LoadVersion(pageLink);
}
public void Move(PageReference pageLink, PageReference destinationLink)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory Move"))
DataFactory.Instance.Move(pageLink, destinationLink);
}
public void Move(PageReference pageLink, PageReference destinationLink, AccessLevel requiredSourceAccess, AccessLevel requiredDestinationAccess)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory Move"))
DataFactory.Instance.Move(pageLink, destinationLink, requiredSourceAccess, requiredDestinationAccess);
}
public void MoveToWastebasket(PageReference pageLink)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory MoveToWastebasket"))
DataFactory.Instance.MoveToWastebasket(pageLink);
}
public void ResetCounters()
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory ResetCounters"))
DataFactory.Instance.ResetCounters();
}
public PageReference ResolvePageFolder(int pageFolderId)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory ResolvePageFolder"))
return DataFactory.Instance.ResolvePageFolder(pageFolderId);
}
public PageReference Save(PageData page, SaveAction action)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory Save"))
return DataFactory.Instance.Save(page, action);
}
public PageReference Save(PageData page, SaveAction action, AccessLevel access)
{
using (MvcProf.MiniProfiler.StepStatic("ProfiledDataFactory Save"))
return DataFactory.Instance.Save(page, action, access);
}
}
}</code></pre>
<p class="brush: c-sharp;">All we need to do now is replace and calls to <em>DataFactory.Instance</em> with <em>ProfiledDataFactory.Instance</em>.</p>
<p class="brush: c-sharp;"> </p>
<pre class="language-csharp"><code>protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
NewsItems.DataSource = <strong>ProfiledDataFactory</strong>.Instance.GetChildren(CurrentPageLink);
NewsItems.DataBind();
}</code></pre>
<p> </p>
<p class="brush: c-sharp;">This will give us profile information like so:</p>
<p><img style="display: block; margin-left: auto; margin-right: auto;" src="http://blog.gregbrant.com/image.axd?picture=2011%2f7%2fProfiledDataFactoryGetChildren.PNG" alt="Profile data showing call to ProfiledDataFactory.Instance.GetChildren" /></p>
<h2>Caveat</h2>
<p>A lot of the DataFactory methods such as GetPage are duplicated within the PageBase class. These methods simply wrap calls to DataFactory.Instance.GetPage and the like. <strong>If you use these methods, they won't provide any profile information because they're not using the ProfiledDataFactory</strong>. As I mentioned earlier, if EPiServer allowed us to replace DataFactory.Instance with anything that implements an IDataFactory interface or an object which inherited from PageStoreBase, we'd be able to plug this ProfiledDataStore in throughout our EPiServer application.</p>
<h2>Next Time</h2>
<p>In the next post, we'll explore replacing some of the EPiServer base classes for pages and user controls to get some basic profiling infrastructure within your application.</p>2011-08-09T13:00:00.0000000ZBlog postEPiServer and MvcMiniProfiler - A first look<p>It wasn't long after I started using EPiServer that I notices <a href="http://msdn.microsoft.com/en-us/library/94c55d08.aspx" target="_blank">Page Output for ASP.NET Trace</a> doesn't work with the CMS (I even took the time to file a bug with EPiServer but I can't find it now to link to :( ). After some messing around I discovered the only way to show Trace page output is by ending the response prematurely, for example sticking a Response.End() in the PreRender, but that's not a good idea, right... The other alternative is to use trace.axd which isn't a disaster but it's not entirely convenient.</p>
<p><a href="http://code.google.com/p/mvc-mini-profiler/" target="_blank">MvcMiniProfiler</a> is a new tool by the good folks over at <a href="http://stackexchange.com/" target="_blank">Stack Exchange</a> which gives a really easy and clean API for tracing within your page requests, it works for the main request and any AJAX calls. Many EPiServer projects require some bespoke data access beyond that usual EPiServer Pages and Properties model, to this end, MiniProfiler has a custom SqlConnection which provides profiling info for your queries that can be used with all of your favourite data access technologies.</p>
<p>In this post, I'm going to walk you through the basics of getting MvcMiniProfiler up and running with EPiServer.</p>
<h2>NuGet</h2>
<p>First of all, you'll need to <a href="http://nuget.org/" target="_blank">install NuGet from NuGet.org</a> or the Visual Studio Extension Manager. We'll need this for two things, installing MvcMiniProfiler but before that we'll need to upgrade our EPiServer project to .NET 4.0.</p>
<p><img style="display: block; margin-left: auto; margin-right: auto; border: 0px initial initial;" src="http://blog.gregbrant.com/image.axd?picture=2011%2f7%2fNuGetExtensionManager600.png" alt="Installing NuGet from the Visual Studio Extension Manager" /></p>
<p>You could upgrade from .NET 3.5 to 4.0 manually but luckily for you, there's a package on the <a href="http://nuget.episerver.com/" target="_blank">EPiServer NuGet gallery</a> that will do it for you in a couple of seconds. Once you've got NuGet installed, edit the Package Manager Settings and add the EPiServer feed (http://nuget.episerver.com/feed/packages.svc) as a source.</p>
<p><img style="display: block; margin-left: auto; margin-right: auto; border: 0px initial initial;" src="http://blog.gregbrant.com/image.axd?picture=2011%2f7%2fEPiServerNuGetPackageSource.png" alt="Adding the EPiServer Package Source to NuGet" /></p>
<p><span>Next select All in the Package Source menu </span><img style="display: block; margin-left: auto; margin-right: auto; border: 0px initial initial;" src="http://blog.gregbrant.com/image.axd?picture=2011%2f7%2fPackageSourceSelectAll.png" alt="Select all in the package Manager source menu" /><span> then type the following at the Package Manager prompt:</span></p>
<pre class="language-csharp"><code>PM> Install-Package EPiServerCMS6ToNetFour</code></pre>
<p>Hit return and a couple of seconds later, your app will be upgraded to .NET 4.</p>
<p>Now that we're running on the right platform, we can install MvcMiniProfiler. This package is on the official NuGet feed (but if your Package Source is still set to All you're golden) so install it with the following:</p>
<pre class="language-csharp"><code>PM> Install-Package MiniProfiler</code></pre>
<h2>Basic Setup</h2>
<p>Now that NuGet has taken care of downloading the required DLLs and added a reference to your project we're ready to start profiling. Note that the new DLLs are in a <em>packages</em> folder in the directory above your web application. There is also a packages.config in the root of your application; you might want to add these to source control. </p>
<p>Getting MvcMiniProfiler up and running is really easy, all we need to do is four simple things; first, start the profiler when a request starts, then stop it when a request ends. The Application class (Global.asax) has the perfect events for this. I personally like to add a CodeBehind to my Global.asax, so here's my code:</p>
<p>Global.asax</p>
<pre class="language-xml"><code><%@ Application Language="C#" Inherits="EPiServer_MiniProfiler.Global"
CodeBehind="Global.asax.cs" %></code></pre>
<p>Global.asax.cs</p>
<pre class="language-csharp"><code>using System;
using System.Web;
using MvcMiniProfiler;
namespace EPiServer_MiniProfiler
{
public class Global : EPiServer.Global
{
void Application_BeginRequest(object sender, EventArgs e)
{
MiniProfiler.Start();
}
void Application_EndRequest(object sender, EventArgs e)
{
MiniProfiler.Stop();
}
}
}</code></pre>
<p>Thirdly, we need to profile some code. This is done in a really clever way, making use of <a href="http://msdn.microsoft.com/en-us/library/system.idisposable.aspx" target="_blank">IDisposable</a> and the <a href="http://msdn.microsoft.com/en-us/library/yh598w02.aspx" target="_blank">using statement</a>. Create a new EPiServer template and in the OnLoad event, add the following code:</p>
<pre class="language-csharp"><code>protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
using (MiniProfiler.StepStatic("Some long running step"))
{
// Do some work here
Thread.Sleep(123);
}
}</code></pre>
<p>Last but not least we need to render the generated JavaScript to the page. This is made super easy, simply add the following to the <head> of your page:</p>
<pre class="language-csharp"><code><%= MvcMiniProfiler.MiniProfiler.RenderIncludes().ToHtmlString() %></code></pre>
<h2>Usage</h2>
<p>Now build your project and visit your template. In the top left hand corner you should see a little tab like this:</p>
<p><img style="display: block; margin-left: auto; margin-right: auto; border: 0px initial initial;" src="http://blog.gregbrant.com/image.axd?picture=2011%2f7%2fMiniProfilerTab.png" alt="The MvcMiniProfiler tab" /></p>
<p>and clicking the tab will show the non-trivial events that were profiled, like so:</p>
<p><img style="display: block; margin-left: auto; margin-right: auto; border: 0px initial initial;" src="http://blog.gregbrant.com/image.axd?picture=2011%2f7%2fMiniProfilerNonTrivialEvents.png" alt="MiniProfiler showing all non-trivial events." /></p>
<h2>AJAX Tracing</h2>
<p>As I mentioned earlier, AJAX requests are profiled as well, to demonstrate this lets add a WebMethod to our template and a little bit of JavaScript to call it.</p>
<p>I've added the following WebMethod to the CodeBehind of my template, which incidentally is Default.aspx in the root of the application.</p>
<pre class="language-csharp"><code>[WebMethod]
public static string Hello()
{
using (MvcMiniProfiler.MiniProfiler.StepStatic("WebMethod Hello"))
{
Thread.Sleep(321);
return DataFactory.Instance.GetPage(PageReference.StartPage).PageName;
}
}</code></pre>
<p>Then we need to call this from our browser, to do this I'm using jQuery (from the Google CDN) and a simple ajax call. Add the following to the <head> of your template:</p>
<pre class="language-xml"><code><script type="text/javascript"
src="https://ajax.googleapis.com/ajax/libs/jquery/1.6.1/jquery.min.js"></script>
<script type="text/javascript">
$(function () {
$.ajax({
type: "POST",
url: "Default.aspx/Hello",
data: "{}",
contentType: "application/json; charset=utf-8",
dataType: "json",
success: function (msg) {
// Replace the div's content with the page method's return value.
$("#Result").text("AJAX: " + msg.d);
}
});
});
</script></code></pre>
<p>and then add a div to the <body> of the page to receive the result of the AJAX call:</p>
<pre class="language-xml"><code><div id="Result">
</div></code></pre>
<p>Build the project and refresh the page and you should see an extra trace notification stack up in the top left corner like so:</p>
<p><img style="display: block; margin-left: auto; margin-right: auto; border: 0px initial initial;" src="http://blog.gregbrant.com/image.axd?picture=2011%2f7%2fMiniProfilerAJAXTab.png" alt="MvcMiniProfiler tab showing AJAX request" /></p>
<p>You can inspect the profile of this AJAX request by clicking on it just like the main page request.</p>
<h2>Next time</h2>
<p>We haven't really touched on anything EPiServer specific here but I hope you like what you've seen. MvcMiniProfiler is a quick and easy way to add profiling to your pages and has a really nice API in the form of IDisposable <em>steps</em> which you use to denote sections of your page. </p>
<p>You can find out more about MvcMiniProfiler on the <a href="http://code.google.com/p/mvc-mini-profiler/" target="_blank">Google Code page</a>, on <a href="http://marcgravell.blogspot.com/2011/06/profiling-with-knobs-on.html" target="_blank">Marc Gravell's blog</a>, and on <a href="http://stackoverflow.com/questions/tagged/mvc-mini-profiler" target="_blank">Stack Overflow</a>.</p>
<p>Next time I'm going to introduce a few EPiServer-specific bits and pieces that will help you get from zero to profiled pages much quicker.</p>2011-07-26T20:07:00.0000000ZBlog postGetPropertyValue with a Default Value - PageData Extensions Method<p>A while ago I blogged some code for <a href="http://blog.gregbrant.com/post/PageData-extension-methods.aspx">a couple of extension methods for the PageData type</a>. An obvious addition that I've been using for a while now but didn't cover in the first post allows you to supply the default value. This works nicely for reference types where <em>default(T) == null</em> and/or where you have a specific default value you want to use.</p>
<h2>Reference Type Defaults</h2>
<p>For reference types, the default() keyword returns a null reference and as such the previous implementation of GetPropertyValue will return null when the PageData doesn't have the property requested.</p>
<p>Lets say we've got a <em>Post</em> class:</p>
<pre class="language-csharp"><code>public class Post
{
public int Id { get; set; }
public int UserId { get; set; }
public string Title { get; set; }
public string Body { get; set; }
}</code></pre>
<p>and we try to retrieve a property of the CurrentPage that doesn't exist:</p>
<pre class="language-csharp"><code>Post post = CurrentPage.GetPropertyValue<Post>("NonexistentProperty");
if (post == null)
Debug.WriteLine("default(Post) == null");</code></pre>
<p>This override of GetPropertyValue takes an extra argument of type T which is used as the default return value (instead of <em>default(T)</em>):</p>
<pre class="language-csharp"><code>/// <summary>
/// Gets the value of a property.
/// </summary>
/// <typeparam name="T">The type to cast the value to.</typeparam>
/// <param name="propertyName">The name of the property to fetch.</param>
/// <param name="defaultValue">The default value.</param>
/// <returns>Returns the value of the property or the suplied defaultValue.</returns>
public static T GetPropertyValue<T>(this PageData pageData, string propertyName, T defaultValue)
{
if(pageData == null)
throw new ArgumentNullException("pageData");
if(string.IsNullOrEmpty(propertyName))
throw new ArgumentException("You must specify a property name", "propertyName");
if (pageData.Property[propertyName] != null &&
pageData.Property[propertyName].Value != null)
{
return (T)pageData.Property[propertyName].Value;
}
else
{
return defaultValue;
}
}</code></pre>
<h2>Value Type Defaults</h2>
<p>All value types have a <a href="http://msdn.microsoft.com/en-us/library/25tdedf5(v=VS.100).aspx">default of <em>zero</em></a></p>
<p><img style="display: block; margin-left: auto; margin-right: auto;" src="http://blog.gregbrant.com/image.axd?picture=2011%2f7%2fDefaultZeroForValueTypes.PNG" alt="" /></p>
<p>For example, the default of the DateTime value type is 01/01/0001 00:00:00 and the default of int is 0.</p>
<p>Using the version of GetPropertyValue that returns default(T) can lead to code like this:</p>
<pre class="language-csharp"><code>DateTime updated = CurrentPage.GetPropertyValue("LastUpdated");
if (updated == default(DateTime))
updated = DateTime.Now;
</code></pre>
<p>but with this new method we can do the following and save ourselves a little more repetative code:</p>
<pre class="language-csharp"><code>DateTime updated =
CurrentPage.GetPropertyValue<DateTime>("LastUpdated", DateTime.Now);</code></pre>2011-07-19T12:16:00.0000000ZBlog postPageData extension methods<p>Over the last two years of using EPiServer a pattern has emerged when working with a <a href="http://sdk.episerver.com/library/cms5/html/T_EPiServer_Core_PageData.htm">PageData</a> object in a CodeBehind file. I've found that often, it's not enough to simply use the <EPiServer:Property /> control to display a property, sometimes you want to show or hi
<script src="http://blogengine.winvps/editors/tiny_mce3/themes/advanced/langs/en.js" type="text/javascript"></script>
de an entire region (like an <asp:Panel /> or <asp:PlaceHolder /> ) based on weather a property has a value or not. For example, you might have a basic content template which you need to work both with and without a header image.</p>
<p style="text-align: center;"><img src="http://blog.gregbrant.com/image.axd?picture=2010%2f10%2ftemplate+with+header.PNG" alt="Layout with image" /><br />Layout with header</p>
<p style="text-align: center;"><img src="http://blog.gregbrant.com/image.axd?picture=2010%2f10%2ftemplate+without+header.PNG" alt="Layout without image" /><br />Layout without image</p>
<p style="text-align: left;">When accessing a property of a page that is optional, you can't just dive in and access the value of the property as the property data might be null, so accessing the Value property of it will throw a NullReferenceException. So the usual pattern is to check the property is not null, check the value of the property is not null and then use the value:</p>
<pre class="language-csharp"><code>if (CurrentPage.Property["Foo"] != null &&
CurrentPage.Property["Foo"].Value != null)
{
// Do something
}</code></pre>
<p style="text-align: left;">This can lead to loads of repetitive and messy code in your CodeBehind so I came up with the following extension method to help ease the constant pain of obtaining a property value:</p>
<pre class="language-csharp"><code>/// <summary>
/// Gets the value of a property.
/// </summary>
/// <typeparam name="T">The type to cast the value to.</typeparam>
/// <param name="propertyName">The name of the property to fetch.</param>
/// <returns>Returns the value of the property or default(T).</returns>
public static T GetPropertyValue<T>(this PageData me, string propertyName)
{
if (me.Property[propertyName] != null &&
me.Property[propertyName].Value != null)
{
return (T)me.Property[propertyName].Value;
}
else
{
return default(T);
}
}</code></pre>
<p>Which you can then use like this:</p>
<pre class="language-csharp"><code>string foo = CurrentPage.GetPropertyValue<string>("Foo");</code></pre>
<p>If you imagine, in some complex templates you can repeat this conditional pattern five or ten times, this one method can clean your code up a bunch and make it much more readable!</p>
<p><strong>The trouble with databinding</strong></p>
<p>We've been using that extension method in the office for around six months now; I don't think I've accessed a property directly since, but the other day I was doing some databinding and I realised I don't like the way we usually access Properties when binding against a collection of PageData using an <asp:Repeater />.</p>
<p>As I see it, you have two options. Firstly, you can bang a load of server controls in the ItemTemplate and then Find them in the ItemDataBound event, cast the DataItem of the RepeaterItemEventArgs to PageData and bind all your controls there, or you can cast the Container.DataItem to PageData in the front end and get to the properties that way. This means we don't have to go through the lengthy process of finding controls but it does mean casting the Container.DataItem every time. So how can we combine the Extension method from before with the simplicity of binding in the aspx rather than the codebehind?</p>
<p><strong>Extending the object</strong></p>
<p>Within the <ItemTemplate>, Container.DataItem is of type object, so the only way we can add custom code to that is by creating an extension method for object itself, and as such, extending every object in our application. </p>
<pre class="language-csharp"><code>public static T GetPropertyValue<T>(this object me, string propertyName)
{
// try to cast the current object to PageData to access it's properties
PageData data = me as PageData;
if(null == data) return default(T);
if (data.Property[propertyName] != null &&
data.Property[propertyName].Value != null)
{
return (T)data.Property[propertyName].Value;
}
else
{
return default(T);
}
}</code></pre>
<p>Not a good idea, I hear you say; and I agree! For a start it pollutes the entire application with a method that you only want on objects of one type. Secondly, other developers might try to use it on non-PageData objects thinking it works somehow works for them and last, I didn't like the duplication of the logic, but that's easily fixed, right. It's just a terrible idea and I wasn't happy with the prospect but I allowed myself to continue messing around to see where I got.</p>
<p>My next thought was, what if we move the object version of the extension method into a separate namespace away from core namespace of the application and away from all the other objects. We can then just import the namespace in the aspx, either through an <%@ Import %> tag or in the <namespaces> tag in the web.config. I did that and I also removed the duplicated code, like so:</p>
<pre class="language-csharp"><code>namespace Application.Extensions.UI
{
public static class PageDataExtensionsUI
{
public static T GetPropertyValue<T>(this object me, string propertyName)
{
PageData data = me as PageData;
if(null == data) return default(T);
return data.GetPropertyValue<T>(propertyName);
}
}
}</code></pre>
<p>You can then call it on the Container.DataItem when DataBinding:</p>
<pre class="language-xml"><code><asp:Repeater runat="server">
<ItemTemplate>
<p><%# Container.DataItem.GetPropertyValue("Foo") %></p>
</ItemTemplate>
</asp:Repeater>
</code></pre>
<p>This blew right up in my face wiith a big fat StackOverflowException which, it turns out, is down to <a href="http://stackoverflow.com/questions/3879975/forcing-the-use-of-a-specific-overload-of-a-method-in-c" target="_blank">how the C# compiler resolves extension methods</a>, favouring those in more local namespaces to those further afield. </p>
<p>This is an easy fix though, because extension methods are just static methods with a little weird syntax, so I changed the way the PageData version of the method is called and it all works great.</p>
<pre class="language-csharp"><code>namespace Application.Extensions.UI
{
public static class PageDataExtensionsUI
{
public static T GetPropertyValue<T>(this object me, string propertyName)
{
PageData data = me as PageData;
if(null == data) return default(T);
return PageDataExtensions.GetPropertyValue<T>(data, propertyName);
}
}
}</code></pre>
<p><strong>In Conclusion</strong></p>
<p>I haven't done much data binding since writing this code to know how it works in practice and it hasn't spread beyond the project I implemented it to have any of the other team members run into it.</p>
<p>I'm still not entirely convinced it's the right way to go but only time will tell.</p>2010-10-06T17:51:00.0000000ZBlog postEPiServer Certified Developer #712<p>Back in July I popped down to London with a colleague, Stephen, to take the <a href="http://www.episerver.com/en/Products/EPiServer-CMS-6/">EPiServer CMS</a> certification test which we both passed qualifying <a href="http://www.twentysixdigital.com/">twentysix as a Premium Solutions Partner</a>.</p>
<p><img style="float: left; margin: 0 12px;" src="http://blog.gregbrant.com/image.axd?picture=2010%2f10%2fecdlogo.png" alt="EPiServer certified developer logo" />Today, our certificates arrived and I'm proud to say <a href="http://world.episerver.com/System/Users-and-profiles/Community-Profile-Card/?encryptedcurrentid=4lJ6NhXVQoz%2Blv7QY5JCYYFuTg7wr1hkHuNHmXqKuM4%3D" target="_blank">I am EPiServer Certified Developer #712</a> and <a href="http://world.episerver.com/System/Users-and-profiles/Community-Profile-Card/?encryptedcurrentid=kXuZ4tRTHu/srfi16n1iJcLcSLPaN1yVCidtdnqOAZF2/TxBPCRBUA%3D%3D" target="_blank">Stephen is ECD #712</a>:</p>
<p style="text-align: center; clear: both; margin: 12px; width: auto;"><img src="http://blog.gregbrant.com/image.axd?picture=2010%2f10%2fEPiServer+Cert.jpg" alt="My ECD Certificate" /></p>
<p>I've been using EPiServer for nearly two years now, having taken the basic developer training at the end of January 2009 and in that time I've worked on some <a href="http://www.aggregate.com/" target="_blank">large</a> and <a href="http://www.gatwickairport.com/" target="_blank">exciting</a> sites but the prospect of the certification, the possiblity of failing it and the peer pressure that comes with was quite daunting. In the two years I've created two or three sites which I would call a <em>Standard</em> build, comprising a single web and/or database server, no mirroring, no custom page providers no use of add-ons or 3<sup>rd</sup> party integrations. </p>
<p>I've also created a few sites which weren't standard, integrating with bespoke and off-the-shelf 3<sup>rd</sup> party systems. Mirrored and load-balanced deployments. Deployments which use SQL Server clusters and most recently, I've written a Page Provider to integrate <a href="http://www.nopcommerce.com" target="_blank">nopCommerce</a> into a CMS 6 site.</p>
<p>On top of all this I've done the usual amount of hacking around in the SDK, re-written and extended a few of the EPiServer controls to add additional functionality (Such as Alternating Item Templates in the PageList and NewsList control [post to follow]).</p>
<p><strong>Tips for passing the exam</strong></p>
<p>It was quite hard to find a good exam guide for the certification and we found a lot of blog posts saying how hard the test was which I don't entirely agree with. It wasn't a walk in the park but it was fairly straight forward.</p>
<p><strong>Read the Developers Guide</strong></p>
<p>I can't link you straight to it because of the funky JavaScript navigation (you can find it easily from <a href="http://sdk.episerver.com/library/cms6/index.aspx" target="_blank">the SDK documentation</a>).The developer guide is a gold mine!</p>
<p>If there are areas EPiServer you haven't worked with before but you have a decent understanding of the core functionality, you can pick up a lot from these documents. A few of the questions I knew instantly as I'd re-read and revised all the articles in this section, some of these questions were on functionality I'd never used.</p>
<p style="text-align: center; clear: both; margin: 12px; width: auto;"><img src="http://blog.gregbrant.com/image.axd?picture=2010%2f10%2fcms6+dev+guide.PNG" alt="" /></p>
<p><strong>Read the Tech Notes</strong></p>
<p>Same goes for the <a href="http://world.episerver.com/Documentation/Categories/Products/EPiServer-CMS/" target="_blank">Tech Notes</a> as does the Developer Guide, read them all. The're not as long or detailed as the articles in the Dev Guide but they helped me answer a few questions.</p>
<p><strong>Re-read the editor and administrator manuals</strong></p>
<p>When someone is asking how to achieve something in the CMS from a user point of view, I sometimes find I'm not the best person to ask, while I do Develop EPiServer sites I don't spend hours in the Editor working with trees of pages, workflows and all the other gubbinz that make up the CMS. To this end, I'm glad I gave the <a href="http://world.episerver.com/Documentation/Items/Manuals/EPiServer-CMS/Editor-Manuals---EPiServer-CMS-60/" target="_blank">Editor Manual</a> and the <a href="http://world.episerver.com/Documentation/Items/Manuals/EPiServer-CMS/Administrator-Manuals---EPiServer-CMS-60/" target="_blank">Administrator Manual</a> another read.</p>
<p><strong>Read the internet</strong></p>
<p>I'm not suggesting you read all of the internet, but if you're reading this, the chances are you've already Googled for tips on passing the exam. Here are some that we found:</p>
<p> </p>
<ul>
<li><a href="http://mint.litemedia.se/2008/11/29/episerver-cms-5-certified-developer/" target="_blank">http://mint.litemedia.se/2008/11/29/episerver-cms-5-certified-developer/</a></li>
<li><a href="http://blog.fredrikhaglund.se/blog/2008/11/30/how-to-become-a-episerver-ceritified-developer/" target="_blank">http://blog.fredrikhaglund.se/blog/2008/11/30/how-to-become-a-episerver-ceritified-developer/</a></li>
<li><a href="http://robert.secondbrain.com/collection/70301/EPiServer-Certification" target="_blank">http://robert.secondbrain.com/collection/70301/EPiServer-Certification</a></li>
<li><a href="http://stackoverflow.com/questions/556221/does-anyone-have-any-episerver-exam-tips" target="_blank">http://stackoverflow.com/questions/556221/does-anyone-have-any-episerver-exam-tips</a></li>
</ul>
<p> </p>
<p>Good luck!</p>2010-10-05T09:40:00.0000000ZBlog post