Blog (pg. 16)

If your site runs on an ASP.NET server and does not support the classic SSI method of including files for output.

i.e.

<!--#include virtual="/myinclude.asp" -->

Then you may wish to implement your own version of SSI.

In my particular example, I am reading from a HTML file on the server and processing the content before rendering it to the client. I don't see any reason however, why this technique could not be applied in the 'Render' phase of any ASP.NET page.

Essentially, the following function will look for any server side include code in the HTML it is about the render. It will then attempt to process the files that have been included and then swap out the content in the original HTML.

Public Function RunSSI(ByVal htmlContent As String) As String
        'look for SSI
        While htmlContent.Contains("<!--#include virtual=")
                Dim startOfSSI As Integer = htmlContent.IndexOf("<!--#include virtual=")
                Dim LengthOfSSI As Integer = htmlContent.IndexOf("-->", startOfSSI) + "-->".Length - startOfSSI

                Dim ssiText As String = htmlContent.Substring(startOfSSI, LengthOfSSI)
                Dim ssiFile As String = ssiText.Substring(ssiText.IndexOf("virtual=""") + "virtual=""".Length, ssiText.IndexOf("""", ssiText.IndexOf("virtual=""") + "virtual=""".Length) - (ssiText.IndexOf("virtual=""") + "virtual=""".Length))

                'execute the file
                Dim contentResponse As String
                Try
                        Dim wc As New Net.WebClient()
                        Dim URL As String = ""
                        If ssiFile.startsWith("/") Then
                                URL = Request.Url.AbsoluteUri.Replace(Request.Url.AbsolutePath, ssiFile)
                        Else
                                URL = ssiFile
                        End If

                        contentResponse = wc.DownloadString(URL)
                Catch ex As Exception
                        contentResponse = "<!--SSI Processing Error: " & ex.Message & " " & """" & URL & """-->"
                End Try
                'now replace the include with the response
                htmlContent = htmlContent.Remove(startOfSSI, LengthOfSSI)
                htmlContent = htmlContent.Insert(startOfSSI, contentResponse)

        End While

        Return htmlContent
End Function

You will notice, that the SSI markup should be the 'virtual' version and that the code will only work with an absolute path (either http://... or /...).

For the avoidance of a permaloop and to help debugging any SSI which is not successfully processed is replaced with a comment stating the error and URL which it attempted to process.

When you have controls nested inside a databound control, you have two options to hook up their events to event handlers. One option is to handle the 'OnItemDataBound'/'OnRowDataBound' or equivalent event of the parent control, find the child control and then use 'AddHandler' to hook up the event handler. The second option is to declaratively put the name of the event handler sub in the markup of the child control and have 'AutoEventWireup' do the mapping for you. With some of the built in ASP.NET controls, you will see the events available to you in the Intellisense dropdown. For example, when nesting a repeater you will see 'OnItemDataBound', 'OnDisposed', 'OnInit' etc. When you have a UserControl inside the databound control you may have declared some custom events but none of these will appear in Intellisense. However, ASP.NET will apply the same rules when it comes to wiring up your events. All you need to do, is set an attribute on your custom control (in the markup) which consists of 'On' and the event name. ASP.NET will recognise the 'On' prefix, marry it up with the existing event declaration in the UserControl and will treat the value part of the attribute declaration as a named public/protected sub in the current context (i.e. the codebehind for the code infront you are working with). To exemplify this idea, the following shows a basic implementation: UserControl codebehind:

Namespace UserControls
    Partial Public Class ExampleUserControl
        Inherits System.Web.UI.UserControl

        Public Event ButtonClick(ByVal sender As Object, ByVal e As System.EventArgs)

        Private Sub btnCompare_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles btnClickMe.Click
            RaiseEvent ButtonClick(Me, EventArgs.Empty)
        End Sub
    End Class
End Namespace

Page codeinfront:

<%@ Register src="/UserControls/ExampleUserControl.ascx" tagname="ExampleUserControl" tagprefix="MyCtrls" %>

<asp:Repeater ID="rptExample" runat="server">
        <ItemTemplate>
            <MyCtrls:ExampleUserControl ID="ExampleUserControl1" runat="server" OnButtonClick="ButtonClickHandler"></MyCtrls:ExampleUserControl>
        </ItemTemplate>
    </asp:Repeater>

Page codebehind:

Protected Sub ButtonClickHandler(ByVal sender As Object, ByVal e As EventArgs)
        'handle the user control event
    End Sub

Of course, you need to have 'AutoEventWireup=True' in the web.config or @Page directive for this to work.

I seem to have a habit of changing classnames and/or namespaces as a project develops to make them more meaningful and to help make space for classes which would have benefited from another's name/namespace. When using the binary formatter to serialize an instance of an object, it is important to note that the type information (assembly, namespace, classname) is stored with the data; as opposed to how the XML formatter works, where it is up to the developer to pass in the type, as a parameter, to deserialize. This presents a problem when you rename a class/namespace, as the deserialization will fail. One such occurance was when I was developing my bespoke CMS system, I had a namespace of: CwCms.DataTypes This namespace contained the data types that each of my CMS controls would expose (to give a brief background, I have developed templateable CMS controls which deal with the persistence and editing of data, of a given custom type, by serializing the data using the binary formatter and then exposing the typed data though 'container.dataitem' to the developer when implementing the control on a site.) Anyway, I changed this namespace to 'CwCms.ControlDataTypes' to make it more descriptive, forgetting that I already had some content stored under the old namespace in the database. This of course broke all the content that I had so far and not being one to redo content work, I decided to hack together a snippet of code that would loop through the raw binary data stored in the CMS database and fix the namespace. Looking at the data in a hex editor, I can't say I had time to fully reverse engineer the format, but I got enough understanding to do the job. In summary here is what I noted: There is a 0x16byte header, followed by the size of the assembly name, followed by the assembly name. In my case there were then 5bytes to skip, followed by the size of the fully qualified class name, followed by the fully qualified class name (being the namespace and classname). Using this information, the following code replaces the target namespace with the new namespace, moves the data to create the new space for the longer namespace name and fixes the 'size of fully qualified classname':

Dim SIZEOF_HEADER As Integer = &H16
Dim SKIP_BYTES_AFTER_ASMNAME As Integer = 5

Dim oldNamespace As String = "CwCms.DataTypes"
Dim newNamespace As String = "CwCms.ControlDataTypes"

Dim sizeof_ASMname As Integer = rawCmsRecord.Value(SIZEOF_HEADER)
Dim start_of_classname_struct As Integer = SIZEOF_HEADER + 1 + sizeof_ASMname + SKIP_BYTES_AFTER_ASMNAME

Dim newRecord((rawCmsRecord.Value.Length - 1) + newNamespace.Length - oldNamespace.Length) As Byte
Dim offset As Integer = 0

For i As Integer = 0 To rawCmsRecord.Value.Length - 1
 'copy the bytes to the new record
 If i <> start_of_classname_struct Then
  newRecord(i + offset) = rawCmsRecord.Value(i)
 Else
  'weve reached the start of the classname struct. inject the custom stuff
  Dim sizeof_classname As Integer = rawCmsRecord.Value(start_of_classname_struct)
  Dim oldclassname As String = ""

  For i2 = i + 1 To i + sizeof_classname
   oldclassname &= ChrW(rawCmsRecord.Value(i2))
  Next

  oldclassname = Right(oldclassname, oldclassname.Length - oldNamespace.Length)

  Dim newFQCN As String = newNamespace & oldclassname
  offset = newFQCN.Length - sizeof_classname

  'overwrite the new length
  newRecord(i) = CByte(newFQCN.Length)

  'put the new classname on the end
  Dim ctr As Integer = 0
  For ctr = 1 To newFQCN.Length
   newRecord(i + ctr) = CByte(AscW(newFQCN(ctr - 1)))
  Next

  i += sizeof_classname
 End If
Next

rawCmsRecord.Value = newRecord
rawCmsRecord.Save()

As the format is not documented by Microsoft the format may change without notice and as I have mentioned this is only a quick interpretation of what I saw, to get the job done. Before implementing this code for yourself, check it will not break your data, I am not responsible!

Using the built in .NET validation, you can assign a 'validation group' to a set of validation controls, submit buttons and validation summary.

This creates a separation between different sets of controls on the page, so that only the relevant controls are validated for a specific submit button.

When you design your application as separate user control components, you may want to set a different validation group on the validators of the user control, depending on the context.

To allow this, I have exposed a 'ValidationGroup' property on the user control. This subsequently makes a recursive to all its child controls to set the validation group of all the validators.

This way, you can set the validation group of the user control instance as you would any other control and it will assign all of its contained validators to that group.

Code:

Public Property ValidationGroup() As String
 Get
  Return CStr(ViewState("ValidationGroup"))
 End Get
 Set(ByVal value As String)
  SetValidationGroupOnChildren(Me, value)
  ViewState("ValidationGroup") = value
 End Set
End Property

Private Sub SetValidationGroupOnChildren(ByVal parent As Control, ByVal validationGroup As String)
	For Each ctrl As Control In parent.Controls
		If TypeOf ctrl Is BaseValidator Then
			CType(ctrl, BaseValidator).ValidationGroup = validationGroup
		ElseIf TypeOf ctrl Is IButtonControl Then
			CType(ctrl, IButtonControl).ValidationGroup = validationGroup
		ElseIf ctrl.HasControls() And ctrl.Visible = True Then
			SetValidationGroupOnChildren(ctrl, validationGroup)
		End If
	Next
End Sub

Often in a project, you have code which runs when the application starts (such as in Program.cs or in your Global.asax file) which will set up all of your shared resources for the rest of the project, such as initializing global variables, configuring the BLL, connecting to a datasource etc. As mentioned above, their are places to put this code provided for you. When you are working within a unit test project you can also have some initialization code run when you run the tests. To do this, you create a test class with a static method and decorate it with the 'AssemblyInitializeAttribute'. I usually create a class called 'InitTestEnv.cs' which consists of something like the following:

using Microsoft.VisualStudio.TestTools.UnitTesting;
namespace YourSolutionNamespace.Test
{
    [TestClass]
    public static class InitTestEnv
    {
        [AssemblyInitialize]
        public static void Initialize(TestContext context)
        {
            //configure the BLL
            BLL.Configuration.EnableCaching = false;

            //connect it to a datasource
            if (!BLL.DataProviders.HasValidDatasource())
                BLL.DataProviders.SetDatasource(BLL.DataProviders.ProviderList.SqlDataProvider("connection string"));
        }
    }
}

  Normally, I would reference the ConfigurationManager classes and then share my 'connectionStrings.config' and 'appSettings.config' files from my UI layer to keep the tests in sync with the settings that will be deployed, but in the above example I have left this out.