GoonDocks Blog

Sitefinity: Refreshing the Cache

Gabe Sumner — Mon, 18 Aug 2008 00:39:52 GMT

Inside the "Properties" of each Sitefinity page there is an option for enabling "Page Caching".

Setting this option to "Yes" will make a dramatic difference in performance. In fact, unless you have a strong reason for not doing so, you should enable page caching on all of your Sitefinity pages. Web pages served from cache do not require expensive database interactions or code processing. Everything is pre-fetched & pre-rendered. The web page will load almost instantly.

If you need information about enabling, configuring or using caching in Sitefinity, please visit the following resources:

Stale Pages & Old Caches

Page caching is great, but it can result in stale web pages. Server-side caching essentially involves creating a "static" version of a "dynamic" web page. In order for page caching to be effective we need a reliable way of expiring and refreshing the cache when the underlying web page has changed.

Sitefinity automatically refreshes the cache each time pages are edited in the administration. In many cases, this is good enough. However, there are situations when a page is updated outside the Sitefinity administration. One example of this is Blog comments. When a new blog comment is posted, the page has changed outside of the administration. This means the cache is not refreshed and the old web page will continues to be displayed.

This behaviour is an�acknowledged Sitefinity bug and will be addressed in a future version of Sitefinity.

Updating the Cache with New Blog Comments

In the meantime, I discovered a way to refresh the cache when a new Sitefinity blog comment is posted. This work-around involves putting a very small UserControl into your Blog ControlTemplate. This UserControl does not display anything. Instead, it simply checks for a "PostBack". If "IsPostBack" is "true" then we assume a new Blog comment has been posted and the cache is expired & refreshed.

Here is how to implement this work-around.

Create ~/Goondocks/UserControls/CacheExpire.ascx

    
            <%@�Control�Language="C#"�AutoEventWireup="true"�CodeFile="CacheExpire.ascx.cs"�Inherits="Goondocks_UserControls_CacheExpire"�%>�
        
            �
        
            �
        
            �

�

Create ~/Goondocks/UserControls/CacheExpire.ascx.cs

    
            using�System; �
        
            using�System.Web; �
        
            using�System.Web.UI; �
        
            �
        
            public�partial�class�Goondocks_UserControls_CacheExpire�:�System.Web.UI.UserControl �
        
            { �
        
            ����protected�void�Page_Prerender(object�sender,�EventArgs�e) �
        
            ����{ �
        
            ��������//�Only�evaluate�if�this�is�a�postback. �
        
            ��������if�(IsPostBack�==�true) �
        
            ��������{ �
        
            ������������//�Only�evaluate�if�the�form�is�valid. �
        
            ������������if�(Page.IsValid�==�true) �
        
            ������������{ �
        
            ����������������//�Expire/Refresh�Cache �
        
            ����������������Telerik.DataAccess.CacheDependencyHandler.Current.Notify(typeof(Telerik.Cms.ICmsPage)); �
        
            ������������} �
        
            ��������} �
        
            ����} �
        
            }�

�

    
            <%@�Register�src="~/Goondocks/UserControls/CacheExpire.ascx"�tagname="CacheExpire"�tagprefix="uc1"�%>�
        
            �
        
            �
        
            �

�

Add the "CacheExpire" UserControl tag in ~/Sitefinity/ControlTemplates/Blogs/ContentViewSingleItem.ascx

    
            <uc1:CacheExpire�ID="CacheExpire1"�runat="server"�/>�
        
            �
        
            �
        
            �

The <uc1:CacheExpires> tag can be inserted almost anywhere inside the "ContentViewSingleItem.ascx" page.� I personally�put this tag inside the <sfWeb:CommentsList> block.

ASP.NET: Supporting Casual Exploration & Discovery

Gabe Sumner — Sat, 16 Aug 2008 16:54:59 GMT

Many of us who now primarily use ASP.NET began web programming with another technology.� In many cases, our first exposure to a technology didn't come from a job, but rather from personal projects.� The platform we choose was based entirely on what was accessible to us at the time.�

In my case, this meant PHP, Apache, MySQL and UNIX.� Each of these technologies remains completely free, yet very capable.� Building on this technology doesn't require the purchase of an IDE, server license or database server.� The barrier to entry remains low.�

I was eventually given the opportunity to learn ASP.NET in a business setting and now prefer ASP.NET as a web development platform.� However, I continue to feel a great affinity towards the�LAMP community that helped me get started.��

This being said, it can be very hard to be an ASP.NET developer who participates in these communities.� The prevailing thought seems to be that ASP.NET is a completely unreasonable choice.� David Heinemeier Hansson with 37signals.com put it very bluntly:

I would have a hard time imagining hiring a programmer who was still on Windows for 37signals. If you don't care enough about your tools to get the best, your burden of proof just got a lot heavier.

I have felt this burden and it's easy to become resentful of this mindset.� Once the resentment wears off, I'm simply left saddened.� ASP.NET is a solid web development platform with some respectable advantages.� It's not perfect (nothing is), but it's certainly worth a look.� ASP.NET experience should certainly not be a liability.�

Recently, Rick Strahl wrote an article entitled "ASP.NET gets no Respect".� In addressing this topic he writes:

The obvious question is whether all of this should concern us at all, or whether we should just be happy we've found our development platform that we're happy with and go on our merry way. It does matter to some degree to me. Like most people I want to be using a framework that has merit and is popular and maybe more importantly that I don't have to fight to justify my use of everywhere I go.

I very much agree!� But how do you begin to combat the preconceptions many programmers have developed against M$ technologies?�

I think it would also help if Microsoft spent a little more effort to push the Microsoft platform outside of the already converted. Most of the advertising for ASP.NET and .NET and developer tools in general tends to be targeted at .NET developers, which is just preaching to the choir. What's really needed is more of a push to gain the hearts of those outside of the already converted circle. This is not easy and has to be done sensibly and not in the ram rod fashion that Microsoft 'case studies' often employ.

Rick is correct, "case studies" certainly won't help.� It will be assumed anything Microsoft writes will be biased.� To even begin to reach this audience we need to first understand the preconceptions that are already in place.� Rick highlights one of them in his article:

But the problem is one of perception: Micro$oft is by default associated with big dollar signs, and "Microsoft is always after your money".

This perception is very strong.� It doesn't help that many ASP.NET product tutorials and sample projects assume a full-version of Visual Studio and administrative control of a dedicated web server.� A curious developer is given the immediate impression that it takes several thousand dollars to even evaluate ASP.NET.� As a result, a negative M$ stereotype is reinforced.��

My most recent experience with this is Silverlight.� I typed "Silverlight Getting Started" into Google and was greeted with the following page:

Please note, I'm doing this from home on my personal time.� Right off the bat, I'm told I need "Visual Studio 2008".� My home computer doesn't have "Visual Studio 2008".� Do I need to make a purchase for the opportunity to "play" with Silverlight?� I'm not even sure what Silverlight is.� I read somewhere it's simply the M$-version of Flash.�� Do I really need it?� Do I care that much?�

It's important to recognize that many talented programmers refine their skills in their personal time instead of on the company dime.� The LAMP platform & community does a wonderful job of nurturing casual exploration & discovery.� It's no surprise this proves a fertile environment for start-ups.� I understand the loyalty these programmers later feel towards the platform that helped them get started.

To overcome the stigma being applied to ASP.NET we need to celebrate casual exploration & discovery.� As a community we cannot assume everyone is using Visual Studio, MS-SQL, IE, Office, etc.� When viewed from the outside, this looks like "dogma" & "lock-in" and it's not attractive.� It also becomes prohibitively expensive to get started.

Engaging these casual programmers may require foregoing immediate profit in favor of cultivating a wider-community.� The value of this community should not be understated though.� These are programmers who are passionate enough about technology that they spend their free-time doing research.� These are good people to have in your corner.� These programmers will go on to advise the companies they work for.� As a result, the technologies that helped nurture them will infiltrate (and are infiltrating) large organizations.��

Enabling CAPTCHA for Sitefinity Blog Comments

Gabe Sumner — Sun, 10 Aug 2008 14:23:29 GMT

Since this blog launched I have deleted hundreds of SPAM comments from my various posts.� These comments say nothing & merely link to some other web site.� In most cases it's obvious the comments were made by an automated SPAM bot.� Cleaning this garbage off my web site has been a weekly chore for me.
�
With Sitefinity 3.2 Telerik introduced a new�SpamProtector control.� This control can be placed onto any page or form to provide various SPAM-fighting capabilities.� Two methods of SPAM protection are offered by this control; auto-detection & CAPTCHA.

�
By default the SpamProtector control is enabled on Sitefinity Blog Comments.� However, it is switched into "auto-detection" mode.� This mode uses various techniques & hidden text fields to trick automated bots into revealing themselves.� This is not always effective though and some sophisticated bots will be capable of circumventing detection.
�
Which leads us to�CAPTCHA detection.� We've all seen (and hate) the garbled images we're shown and asked to reproduce.� As annoying as this is for us, it's even more annoying for SPAM bots.� These images offer a significant hurdle to blog comment SPAM.�

Adding CAPTCHA in 2 Easy Steps

Step 1:� Load the following file into your favorite editor:
�
~/Sitefinity/ControlTemplates/Blogs/ContentViewSingleItem.ascx

Step 2: Find the existing <sf:spamprotector /> tag and add an EnableCaptcha="true" parameter.
�
�

You're done.� Your blogs posts will now be free(er) of blog comment SPAM.

Sitefinity "File Link" Control

Gabe Sumner — Sat, 09 Aug 2008 21:44:00 GMT

Sitefinity 3.2 comes with an "Images & Documents Module". This module makes it relatively easy to create & manage libraries of images, files & documents on your web site. I found this module to be a much easier than using FTP to manage my web site's files.

I now manage all files related to Goondocks through the Images & Documents module. This includes the images that appear on this article, as well as files available for download.

Caution: The Sitefinity "Images & Documents Module" stores files directly in the database. Some hosting packages offer generous hosting disk space but very limited database storage. If you have limited database storage I would caution you about relying heavily on the Images & Documents Module. With frequent use you will find your database size quickly growing. Alternately, Ivan, with Sitefinity,�posted some options for modifying the Images & Documents Module to use alternate storage methods. I have not personally experimented with the customizations he describes.�

Using Images & Documents in your Sitefinity Pages

Once a file is uploaded via the Images & Documents Module, Sitefinity creates a unique URL for accessing the file. Example:
�
http://www.goondocks.com/Libraries/Havasu%20Falls/before-the-falls.sflb
�
You can then insert a static anchor link into your web page to link to the file.
�
I wanted to go a step beyond this however. Rather than inserting a static link to my file, I wanted to place a control on my page that could be associated with a previously uploaded file. This method has the following advantages:�

The control-to-file association is based on an ID, not a URL. If the file name is changed, the URL will also change. This would cause a static link to break. By using an ID association, the control dynamically updates the URL and the association remains intact.
The control can render dynamic information about the underlying file (file type, file size, date created, date modified). You could statically reproduce all of this information in the page, but it would become outdated quickly.

To accomplish this I created a new Sitefinity "File Link" control. This control can be dropped onto any Sitefinity page. Once placed the "File Link" control can be associated with any existing file uploaded via the "Images & Documents Module". When the file association is in-place the control will render a "Download Box".

How To Use the "File Link" Control

Drop the "File Link" control onto your Sitefinity page.

Edit the "File Link" control and select the Images & Documents file you wish to associate with the control:

Click "I'm Done" and you now have a fully dynamic download-box for your file:

How To Download

This control and its source-code is included in the GoonDocks Sitefinity Controls.��

Sitefinity on a Virtual Private Server

Gabe Sumner — Mon, 21 Jul 2008 13:43:13 GMT

Goondocks.com has now been moved to a HostMySite.com Virtual Private Server.

Previously I had been using DiscountASP.net to host my Sitefinity-based web site.� For the record, I have absolutely no complaints with DiscountASP.net.� The service was solid and I was a happy customer.

This being said, I wanted a higher-level of control over my web site & hosting environment.� My new VPS hosting platform allows Remote Desktop, multiple web sites, my own IP address, dedicated resources, more file space.� The downside is my new VPS is also more expensive.

The goondocks.com web site has only been running on this new hosting environment for a few days but so far so good.� Based on my limited testing, the web site is running faster & better than ever.

Time will tell....

Now Upgraded to Sitefinity 3.2

Gabe Sumner — Mon, 05 May 2008 14:41:27 GMT

I am happy to announce, after a dozen attempts, I have managed to upgrade Goondocks.com to Sitefinity 3.2.

My advice to anyone attempting to upgrade from 3.1 is to go through this entire process on your local machine before you even attempt to do this in a live setting.� You will discover many controls have changed.� You will also discover the "ControlTemplate" changes you made for 3.1 may no longer be compatible with the updated 3.2 controls.

Here are the steps involved in the Goondocks.com upgrade:�

Backup web files.
Backup database.
Disable web server
FTP "Sitefinity" directory.
FTP "bin" directory.
FTP "RadControls" directory.
FTP updated "web.config" file.
Re-add customizations to the "web.config" file.
Delete "/bin/RadChart.NET2.dll" file.
Delete "/bin/RadEditor.NET2.dll" file.
Restart web server.
Access web site.
Pray.
Use wizard, re-setup the connection to the database.
Login to Sitefinity with my existing username/password.

At this point my existing pages were viewable; although my web site looked horrible.� Sitefinity 3.2 introduces several updated versions of the 3.1 controls.� In some cases these updated controls were not compatible with my 3.1 Control Templates.

Work through the web site.
Update Master Templates as needed.
Update Control Templates as needed.
Update stylesheets as needed.
Replace old controls as needed.�
Replace the Blog posts control.

At this point all of my Sitefinity 3.1 blog posts were missing.�

Execute raw SQL against my database.�

I now had some of my blog posts back.� For some reason approximately 10 blogs posts had simply disappeared.� Upon investigation I discovered these blogs posts were missing an entry in the "sf_CmsContentVersion" table.

To fix this I manually inserted the values.� I used the "sf_CmsContentBase" table as a reference.� Using that table I was able to see which blog posts were missing.� I was also able to get the ID's and dates.

Each time I inserted a value in this table I needed to find the blog post in the Sitefinity Admin.� The title was blank.� I needed to click "Edit" and then "Save".� This fixed the blog post and made it look normal.

Ok, I now have all my blog posts, but the search-engine friendly blog URLs are gone.� The URL column in the "sf_CmsContentBase" table is "NULL".

Click through the Sitefinity Admin and re-save each blog post.

I then noticed that some of my blog URLs had changed.� For example I had a blog post titled "Sitefinity - Please, No More Modules!".

The old URL was: /08-04-19/sitefinity_-_please_no_more_modules_.aspx
The new URL was: /08-04-19/sitefinity_-_please_no_more_modules.aspx

Notice the missing "underscore" at the end.� To fix this I directly altered the "URL" column in the "sf_CmsContentBase" table.

All my blog posts now appear and the existing search-engine friendly URLs are working fine.� However, my "Tags" & "Categories" links aren't working.

The Blog controls are completely updated.� You need to remove your existing Blogs, Categories, Tags, and Archive controls and drop updated versions of these controls onto your page.� Configure the controls as needed.

Note the query string values that are being used between these controls.� The "Blog" control defaults to "BlogTagID" while the Tag control defaults to "CntTagID".� These obviously do not match and this will result in your Tag & Category links not working.

There are still a few lingering problems, but this web site is mostly functioning again.�

This upgrade process has been horrid.� I hope to never go through anything like this again.� I pity anyone�trying to follow in my foot-steps.� I've already written about this however and Telerik expressed their commitment to addressing these issues in the future.� For the moment, I am going to let the issue drop.

All of this being said, I'm really enjoying some of the new Sitefinity 3.2 features.� After I've had some time to "live" with these new features I will write-up of Sitefinity 3.2 review.� For now, I'm simply thankful to be through the upgrade.

Auto-generate a Web Admin Interface using LINQ to SQL

Gabe Sumner — Wed, 30 Apr 2008 03:00:00 GMT

Like a lot of web programmers, I spent years using PHP to create web applications. One of the tools I frequently used in conjunction with PHP was phpMyAdmin . This helpful web-based tool allowed me to easily manage my MySQL databases via a web browser.

After reading Scott Guthrie's "Binding UI using the ASP:LinqDataSource Control" article I became intrigued�by the idea of building a phpMyAdmin-like inteface that could utlize any "LINQ to SQL Class". In theory this seemed simple, in practice it involved a lot reflection .

I have a very early build of this running and�have provided the code below. Comments are sprinkled throughout the code and explain what is happening. Here is how to create this:

Step 1: Create the ASPX page

Create the following ASPX file: ~/admin/LinqMyAdmin.aspx

    
            <%@�Page�Language="C#"�AutoEventWireup="true"�CodeFile="LinqMyAdmin.aspx.cs"�Inherits="LinqMyAdmin"�%>�
        
            �
        
            <!DOCTYPE�html�PUBLIC�"-//W3C//DTD�XHTML�1.0�Transitional//EN"�"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">�
        
            �
        
            <html�xmlns="http://www.w3.org/1999/xhtml"> �
        
            <head�runat="server"> �
        
            ����<title>LinqMyAdmin</title>�
        
            ����<link�href="./LinqMyAdmin.css"�rel="Stylesheet"�type="text/css"�/>�
        
            </head>�
        
            <body>�
        
            ����<form�id="form1"�runat="server"> �
        
            ����<div>�
        
            ��������<div�id="contentwrapper"> �
        
            ��������<div�id="contentcolumn"> �
        
            ������������<asp:PlaceHolder�ID="LinqPlaceHolder"�EnableViewState="true"�Visible="true"�runat="server"></asp:PlaceHolder>�
        
            ������������<h2�id="TableHeader"�runat="server"�/>�
        
            ������������<asp:GridView� �
        
            ����������������ID="TableGrid"� �
        
            ����������������PageSize�=�"20"�
        
            ����������������AllowPaging�=�"true"�
        
            ����������������AllowSorting�=�"true"�
        
            ����������������EnableViewState�=�"true"�
        
            ����������������AutoGenerateColumns�=�"true"�
        
            ����������������AutoGenerateDeleteButton�=�"true"�
        
            ����������������AutoGenerateEditButton�=�"true"�
        
            ����������������runat="server"> �
        
            ����������������<AlternatingRowStyle�CssClass="odd"�/>�
        
            ����������������<PagerStyle�CssClass="pager"�HorizontalAlign="Left"�/>�
        
            ������������</asp:GridView>�
        
            ��������</div>�
        
            ��������</div>�
        
            ��������<div�id="leftcolumn"> �
        
            ������������<h2>Tables</h2>�
        
            ������������<asp:Repeater�ID="TablesRepeater"�EnableViewState="false"�runat="server"> �
        
            ����������������<HeaderTemplate>�
        
            ��������������������<ul>�
        
            ����������������</HeaderTemplate>�
        
            ����������������<ItemTemplate>�
        
            ��������������������<li><a�href="linqmyadmin.aspx?table=<%#�Container.DataItem�%>"><%#�Container.DataItem�%></a></li>�
        
            ����������������</ItemTemplate>�
        
            ����������������<FooterTemplate>�
        
            ��������������������</ul>�
        
            ����������������</FooterTemplate>�
        
            ������������</asp:Repeater>�
        
            ��������</div>�
        
            ����</div>�������� �
        
            ����</form>�
        
            </body>�
        
            </html>�

Step 2: Create the Code-Behind

Create the following code-behind file: ~/admin/LinqMyAdmin.aspx.cs

    
            using�System; �
        
            using�System.Collections; �
        
            using�System.Data.Linq.Mapping; �
        
            using�System.Reflection; �
        
            using�System.Text.RegularExpressions; �
        
            using�System.Web; �
        
            using�System.Web.UI.WebControls; �
        
            �
        
            public�partial�class�LinqMyAdmin�:�System.Web.UI.Page �
        
            { �
        
            ����//�-------------------------------------------------------------------- �
        
            ����//�CHANGE�THE�FOLLOWING�LINE�TO�REFER�TO�YOUR�LinqDataContext�CLASS �
        
            ����//�-------------------------------------------------------------------- �
        
            ����string�LinqSQLClass�=�"Intranet.Data.NorthwindDataContext,�App_Code"; �
        
            ����Type�LinqContextType; �
        
            �
        
            ����///�<summary> �
        
            ����///�Executed�upon�Page�Load. �
        
            ����///�</summary> �
        
            ����protected�void�Page_Load(object�sender,�EventArgs�e) �
        
            ����{ �
        
            ��������string�TableName�=�Request.QueryString["table"]; �
        
            �
        
            ��������//�Display�a�list�of�available�Tables �
        
            ��������LinqContextType�=�System.Type.GetType(LinqSQLClass,�true); �
        
            ��������TablesRepeater.DataSource�=�GetAllTables(LinqContextType); �
        
            ��������TablesRepeater.DataBind(); �
        
            �
        
            ��������//�If�we�have�a�"table"�value�in�our�querystring,�then�display�the�table. �
        
            ��������if�(TableName�!=�null) �
        
            ��������{ �
        
            ������������DisplayTable(TableName); �
        
            ��������} �
        
            ����} �
        
            �
        
            ����///�<summary> �
        
            ����///�Gets�a�list�of�all�Tables�found�in�a�LinqContext �
        
            ����///�</summary> �
        
            ����///�<param�name="_Type">The�LinqContext�Type</param> �
        
            ����///�<returns>list�of�table�names.</returns> �
        
            ����private�ArrayList�GetAllTables(Type�_Type) �
        
            ����{ �
        
            ��������ArrayList�_Tables�=�new�ArrayList(); �
        
            ��������PropertyInfo[]�_AllProperties�=�_Type.GetProperties(); �
        
            ��������foreach�(var�_PropInfo�in�_AllProperties) �
        
            ��������{ �
        
            ������������//�LINQ�Tables�are�Generics�and�will�be�declared�as�type�System.Data.Linq.Table<TEntity> �
        
            ������������//�I�worked�a�long�time�to�create�a�generic�Table�Type�comparison.��Nothing�worked. �
        
            ������������//�So�I�ended�up�just�converting�the�type�to�a�string�and�searching�for�a�pattern.��:( �
        
            ������������if�(Regex.IsMatch(_PropInfo.PropertyType.ToString(),�@"^System.Data.Linq.Table")�==�true) �
        
            ������������{ �
        
            ����������������_Tables.Add(_PropInfo.Name); �
        
            ������������} �
        
            ��������} �
        
            ��������return�_Tables; �
        
            ����} �
        
            �
        
            ����///�<summary> �
        
            ����///� �
        
            ����///�</summary> �
        
            ����///�<param�name="TableName"></param> �
        
            ����private�void�DisplayTable(string�TableName) �
        
            ����{ �
        
            ��������//�We�don't�know�the�ContextTypeName�or�TableName�in�advance. �
        
            ��������//�Create�a�LinqDataSource�control�dynamically�and�add�it�to�our �
        
            ��������//�PlaceHolder�control. �
        
            ��������LinqDataSource�_linqSource�=�new�LinqDataSource(); �
        
            ��������_linqSource.ID�=�"LinqSource"; �
        
            ��������_linqSource.ContextTypeName�=�LinqSQLClass; �
        
            ��������_linqSource.TableName�=�TableName; �
        
            ��������_linqSource.EnableInsert�=�true; �
        
            ��������_linqSource.EnableDelete�=�true; �
        
            ��������_linqSource.EnableUpdate�=�true; �
        
            ��������_linqSource.AutoPage�=�true; �
        
            ��������_linqSource.AutoSort�=�true; �
        
            ��������_linqSource.EnableViewState�=�true; �
        
            ��������LinqPlaceHolder.Controls.Add(_linqSource); �
        
            �
        
            ��������//�Fetch�the�Primary�Keys�associated�with�the�current�table. �
        
            ��������string[]�_ID�=�GetTableKeys(TableName); �
        
            �������� �
        
            ��������//�Attach�our�LinqDataSource�to�our�DataGrid. �
        
            ��������TableHeader.InnerHtml�=�"Table�-&gt;�"�+�TableName; �
        
            ��������TableGrid.DataSourceID�=�"LinqSource"; �
        
            ��������TableGrid.DataKeyNames�=�_ID; �
        
            ����} �
        
            �
        
            ����///�<summary> �
        
            ����///�Get�all�properties�associated�with�our�LinqContext�Table. �
        
            ����///�</summary> �
        
            ����///�<param�name="TableName">The�TableName</param> �
        
            ����///�<returns>The�properties�associated�with�this�table</returns> �
        
            ����private�PropertyInfo[]�GetTableProperties(string�TableName) �
        
            ����{ �
        
            ��������//�All�we�currently�have�is�a�table�name;�"Customers"�(plural). �
        
            �
        
            ��������//�What�we�want�to�fetch�are�the�properties�associated�with�the �
        
            ��������//�model�that�is�associated�with�our�table.��That�model,�example, �
        
            ��������//�would�be�called�"Customer"�(singular).�� �
        
            �
        
            ��������//�We�find�the�connection�between�table�&�model�by�using �
        
            ��������//�reflection�on�the�table.��The�table�will�have�have�a�type �
        
            ��������//�of�System.Data.Linq.Table<Customer>.��The�"Customer�Type"�is� �
        
            ��������//�retrievable�by�looking�at�the�Generic�Arguments. �
        
            �������� �
        
            ��������//��Clear�as�mud?��Great,�let's�get�started... �
        
            �
        
            ��������Type�_TableType�=�LinqContextType.GetProperty(TableName).PropertyType; �
        
            ��������Type�_ModelType; �
        
            ��������PropertyInfo[]�_ReturnProperties�=�null; �
        
            �
        
            ��������//�Make�sure�we�have�a�Generic�Type �
        
            ��������if�(_TableType.IsGenericType�==�true) �
        
            ��������{ �
        
            ������������Type[]�_GenericArgs�=�_TableType.GetGenericArguments(); �
        
            �
        
            ������������//�Ensure�that�we�have�some�Generic�Arguments �
        
            ������������if�(_GenericArgs.Length�>�0) �
        
            ������������{ �
        
            ����������������//�Our�model�type�will�be�the�first�Arg. �
        
            ����������������_ModelType�=�_GenericArgs[0]; �
        
            ����������������_ReturnProperties�=�_ModelType.GetProperties(); �
        
            ������������} �
        
            ��������} �
        
            ��������return�_ReturnProperties; �
        
            ����} �
        
            �
        
            ����///�<summary> �
        
            ����///�Gets�the�primary�keys�associated�with�a�LinqContext�Table �
        
            ����///�</summary> �
        
            ����///�<param�name="TableName">The�Table�Name</param> �
        
            ����///�<returns>A�list�of�primary�keys�associated�with�the�table</returns> �
        
            ����private�string[]�GetTableKeys(string�TableName) �
        
            ����{ �
        
            ��������ArrayList�_Keys�=�new�ArrayList(); �
        
            ��������bool�_PrimaryKey�=�false; �
        
            �
        
            ��������//�Loop�through�each�property�found�in�the�Table�Model. �
        
            ��������foreach�(var�_PropInfo�in�GetTableProperties(TableName)) �
        
            ��������{ �
        
            ������������//�The�Primary�Key�flag�is�a�Custom�Attribute.��Get�all�Custom�Attributes �
        
            ������������//�associated�with�the�current�property. �
        
            ������������Object[]�_Objects�=�_PropInfo.GetCustomAttributes(true); �
        
            �
        
            ������������//�Reset�our�Primary�Key�flag. �
        
            ������������_PrimaryKey�=�false; �
        
            �
        
            ������������//�Loop�through�each�Custom�Attribute. �
        
            ������������foreach�(Object�_obj�in�_Objects) �
        
            ������������{ �
        
            ����������������//�The�attribute�we're�looking�for�is�"System.Data.Linq.Mapping.ColumnAttribute" �
        
            ����������������if�(_obj.GetType()�==�typeof(System.Data.Linq.Mapping.ColumnAttribute)) �
        
            ����������������{ �
        
            ��������������������ColumnAttribute�_Attribute�=�(ColumnAttribute)_obj; �
        
            ��������������������if�(_Attribute.IsPrimaryKey�==�true) �
        
            ��������������������{ �
        
            ������������������������_PrimaryKey�=�true; �
        
            ��������������������} �
        
            ����������������} �
        
            ������������} �
        
            �
        
            ������������if�(_PrimaryKey�==�true) �
        
            ������������{ �
        
            ����������������_Keys.Add(_PropInfo.Name); �
        
            ������������} �
        
            ��������} �
        
            �
        
            ��������return�_Keys.ToArray(typeof(string))�as�string[]; �
        
            ����} �
        
            }�

Step 3: Create the CSS

Create the following CSS file: ~/admin/LinqMyAdmin.css

    
            body�{ �
        
            ����background-color:�#FFFFFF; �
        
            ����font-size:�15px; �
        
            } �
        
            #contentwrapper�{ �
        
            ����float:�left; �
        
            ����width:�100%; �
        
            } �
        
            #contentcolumn�{ �
        
            ����margin-left:�200px;�/*Set�left�margin�to�LeftColumnWidth*/�
        
            } �
        
            #leftcolumn�{ �
        
            ����float:�left; �
        
            ����width:�200px;�/*Width�of�left�column*/�
        
            ����margin-left:�-100%; �
        
            } �
        
            #leftcolumn�ul�{ �
        
            ����list-style:�none; �
        
            ����margin-left:�5px; �
        
            ����padding-left:�0px; �
        
            } �
        
            #leftcolumn�li� �
        
            { �
        
            ����padding-left:�0px; �
        
            ����margin-left:�0px; �
        
            ����margin-bottom:�5px; �
        
            } �
        
            h2�{ �
        
            ����font-family:�Arial; �
        
            } �
        
            a:link�{ �
        
            ����color:#d42945; �
        
            ����text-decoration:none; �
        
            }��� �
        
            a:visited�{ �
        
            ����color:#d42945; �
        
            ����text-decoration:none; �
        
            }������� �
        
            a:hover,�a:focus�{ �
        
            ����color:#f03b58; �
        
            ����text-decoration:�underline; �
        
            } �
        
            table�{ �
        
            ����border:�solid�1px�#e5eff8; �
        
            } �
        
            th�{ �
        
            ����font-weight:�normal; �
        
            ����background:#f4f9fe; �
        
            ����text-align:�center; �
        
            ����border:�solid�1px�#e5eff8; �
        
            ����padding:.3em�1em; �
        
            } �
        
            thead�th�{ �
        
            ����background:#f4f9fe; �
        
            ����text-align:�center; �
        
            ����color:#66a3d3�
        
            }��� �
        
            tr.odd�td�{ �
        
            ����background:�#f7fbff�
        
            } �
        
            td�{ �
        
            ����color:�#678197; �
        
            ����border:�solid�1px�#e5eff8; �
        
            ����padding:.3em�1em; �
        
            ����text-align:�center; �
        
            } �
        
            .pager�td�{ �
        
            ����text-align:�left; �
        
            }������������

Access the page via the following URL: http://localhost/admin/LinqMyAdmin.aspx

I would not recommend putting this code on a public server or using production data. If you do happen to upload this code to a public server, be sure to secure access to the page.

Obviously this web application lacks a lot of functionality. What is amazing though is how much functionality I am getting "for free" because of ASP.NET's LinqDataSource and GridView. However, I find that I'm reaching the limit of what I can do dynamically. For example, weaving automatic foreign-key mappings into this code is proving difficult. I have some thoughts on how to overcome this, but have not yet found the time to experiment.

I hope to provide more updates later. Feedback is welcome!

Using ASP.NET Page Trace to View LINQ SQL

Gabe Sumner — Tue, 22 Apr 2008 03:00:00 GMT

I've often�found it helpful to use ASP.NET's Page Trace to identify performance problems with my dynamic pages.�However, database queries�are frequently responsible for performance problems.� Because of this,�I began displaying SQL�via the Page�Trace. This let me see the SQL being executed to render a page. It also let me see how much time the SQL was taking to execute.

As I began toying with LINQ to SQL I found myself missing the ability to see the SQL being executed to render my pages. As it turns out, it's very easy to have LINQ output the SQL to Page Trace.

First you need to create a VERY simple class that implements the "System.IO.TextWriter" class.� You can place this file in ~/App_Code/TraceTextWriter.cs

    
            using�System; �
        
            using�System.Web; �
        
            �
        
            public�class�TraceTextWriter�:�System.IO.TextWriter �
        
            { �
        
            ����public�override�System.Text.Encoding�Encoding �
        
            ����{ �
        
            ��������get�{�throw�new�NotImplementedException();�} �
        
            ����} �
        
            �
        
            ����public�override�void�WriteLine(string�value) �
        
            ����{ �
        
            ��������HttpContext.Current.Trace.Write("LINQ",�value); �
        
            ��������base.WriteLine(value); �
        
            ����} �
        
            }�

Next you need to set the LINQ�Log property to use an instance of this new TraceTextWriter class:

    
            TestDataContext�db�=�new�TestDataContext(); �
        
            TraceTextWriter�traceWriter�=�new�TraceTextWriter(); �
        
            db.Log�=�traceWriter; �
        
            �
        
            //�Execute�your�LINQ�queries�here.�

Now set Trace to "true" inside your "aspx" page:

    
            <%@�Page�Language="C#"�AutoEventWireup="true"�Trace="true"�%>�

Piece of cake! Now load the page in a web browser and you will see details similar to the following:

Now you can easily see the SQL LINQ is generating to render your pages; you can also use this�information to troubleshoot performance problems.� When you are done troubleshooting, simply set Trace to "false" to disable this output.

Thanks to Matt Berseth for posting information that helped me get started on this.