Extending ASP.NET

Page Framework Lifecycle

• Page.InitializeCulture where you can explicitly handle the UICulture and Culture for localization, e.g. from Profile;
• Page.OnPreInit, Page_PreInit, where you can dynamically set the Page.Theme or Page.MasterPageFile;
• Control.LoadControlState, Control.SaveControlState to explicitly handle new state management functionality;
• Other new page events, like OnInitComplete, OnPreLoad, OnLoadComplete, OnPreRenderComplete, OnSaveStateComplete etc.

Server Controls Runtime

When creating custom controls you can compile your controls into assemblies that are added to the application's Bin directory or in ASP.NET 2.0, you can add code file(s) to the application's App_Code directory. In this case ASP.NET 2.0 will dynamically compile the control. You can also in ASP.NET 2.0 reuse tag prefixes when registering controls from multiple namespaces. So it is possible to create several controls in several namespaces that all contribute to the same tag prefix.

<%-- Register the controls defined in an assembly that resides in the Bin directory --%>
<%@ Register TagPrefix="Demos" NameSpace="DemoControls" Assembly="MyDemoControls" %>

<%-- Register the controls defined in code that resides in the App_Code directory --%>
<%@ Register TagPrefix="Demos" NameSpace="DemoControls" %>

<Demos:ControlFromBinAssembly runat="server" ID="CustomControl1" />
<Demos:ControlFromCodeFile runat="server" ID="CustomControl2" />

Control Classes

public class MyCompositionControl : CompositeControl { protected override void CreateChildControls() { Controls.Clear(); // Create control collection .. } // Additional implementation } Public Class MyCompositionControl Inherits CompositeControl Protected Overrides Sub CreateChildControls() Controls.Clear() ' Create control collection .. End Sub ' Additional implementation End Class

The CompositeControl is a WebControl and implements INamingContainer. The Controls collection calls EnsureChildControls. You would create all child controls in CreateChildControls. The base class provides design-time support, again ensuring the Controls collection is created.

You can enable a page developer to style your control by exposing top-level properties that delegate to the child control style properties. If you have many properties and controls, then consider exposing properties of type Style and applying these during render methods so that child controls do not persist these as view-state, but rather the parent handles state management of these complex properties.

Control Class and Property Meta-data

• LocalizableAttribute: Localization is enabled for all controls and objects, including static markup in a web application through the use of expressions, (both implicit and explicit). These features are 'layered' on a control at parse-time and you do not need to add any special handling to your control. During design-time, Visual Studio will 'push' values to a neutral resource for properties that are marked with the LocalizableAttribute.
• ThemeableAttribute: Page developers and developers performing customization can take advantage of themes to affect the stylistic appearance and to some extent the content of a page or site. All properties are by default theme-able, so if there are properties that you decide should not be theme-able, such as sensitive data properties or properties that are not style-based, mark them as Themeable(false).
• UrlPropertyAttribute: Where a control could be used in master-page for example, or other such types then Url type properties will potentially require re-basing (an image or a style sheet). In order to base the Url property value to the consuming page, e.g. a content-page in a master-page, content-page relationship the page framework will rebase that Url when marked with this attribute, and that the control developer uses the System.Web.UI.Control.ResolveClientUrl() method to render the correct client Url for the browser;
• WebResourceAttribute: Used to mark the assembly that contains an embedded resource, so that resource can be served in a request;
• FilterableAttribute: Used to mark control properties, or controls that wish to support the device filtering, declarative syntax in the page.

State Management

protected override void OnInit(EventArgs e) { base.OnInit(e); Page.RegisterRequiresControlState(this); } protected override object SaveControlState() { object o = base.SaveControlState(); // Additional implementation return new Pair(o, ViewIndex); } protected override void LoadControlState(object state) { Pair p = state As Pair; if (p != null) { base.LoadControlState(p.First); ViewIndex = (int)p.Second; } // Additional implementation } Protected Overrides Sub OnInit(ByVal e As System.EventArgs) MyBase.OnInit(e) Page.RegisterRequiresControlState(Me) End Sub Protected Overrides Function SaveControlState() As Object Dim o As Object = MyBase.SaveControlState() ' Additional implementation Return New Pair(o, ViewIndex) End Function Protected Overrides Sub LoadControlState(ByVal savedState As Object) Dim p As Pair = savedState If Not (p Is Nothing) Then MyBase.LoadControlState(p.First) ViewIndex = CInt(p.Second) End If End Sub

In ASP.NET 2.0, the control-state and view-state are combined in the hidden field in the page rendering. You can make a request to the page to encrypt the field, (Page.RegisterRequiresViewStateEncryption) if you need to round-trip potentially sensitive data.

Control and Page Adapters: Handling Behavior for Devices, Browsers or Markups

The HttpBrowserCapabilities creation process uses declarative browser files that reside in the install directory under Config\Browsers and/or the application's local App_Browsers directory. The following snippet shows a custom browser file that maps a custom adapter for a custom control; and in this example, the assembly containing the adapter is created from the App_Code directory of the application, as the type definitions are shown without being full qualified.

<!-- New browser node links into parent -->
<browser id="My_PIE_PPC" parentID="PIEnoDeviceID">
  <identification>
    <capability name="browser" match="Pocket IE" />
    <capability name="majorversion" match="4" />
  </identification>

  <!-- Define new text-writer for this browser and define control-adapter mapping -->
  <controlAdapters markupTextWriterType="MyNamespace.MyCustomTextWriter" >
    <adapter controlType="MyNamespace.MyControl" adapterType="MyNamespace.MyControlAdapter" />
  </controlAdapters>
</browser> 

During the page framework lifecycle, ASP.NET 2.0 attempts to look for an adapter on the control using the Control.ResolveAdapter method. If an adapter is returned, the page framework will call on the adapter methods instead of the control's lifecycle methods. As an extensibility developer you can extend the adapter base classes, e.g. ControlAdapter, WebControlAdapter and PageAdapter and define overrides for the lifecycle stages and other methods such as child control creation and postback handling.

• The base adapter classes call back on the control's equivalent method. It is typical therefore, to call on the base method in your adapter. This is not necessarily true of the Render method(s), as you could end-up with unwarranted markup behavior;
• Adapters can implement IPostBackEventHandler and IPostBackDataHandler to handle postback data and raise events;
• Adapters can implement view-state and control-state methods, LoadAdapterViewState, SaveAdapterViewState and LoadAdapterControlState, SaveAdapterControlState. These methods contribute to the control's behavior however;
• Adapters can implement CreateChildControls and handle data-binding calls;
• Alternatively you can prevent 'adaptation' for your custom control by returning null from Control.ResolveAdapter.

// Control public class MyControl : Control { // Example showing override of Render to control entire rendering protected override void Render(HtmlTextWriter writer) { Style s = new Style(); s.ForeColor = System.Drawing.Color.Green; writer.EnterStyle(s); writer.Write("Welcome custom control."); writer.ExitStyle(s); } // Additional implementation } // Adapter public class MyControlAdapter : ControlAdapter { // Example showing override of Render to control entire rendering protected override void Render(HtmlTextWriter writer) { Style s = new Style(); s.ForeColor = System.Drawing.Color.Red; writer.EnterStyle(s); writer.Write("Welcome custom control adapter."); writer.ExitStyle(s); } // Additional implementation } ' Control Public Class MyControl Inherits Control ' Example showing override of Render to control entire rendering Protected Overrides Sub Render(ByVal writer As HtmlTextWriter) Dim s As New Style() s.ForeColor = System.Drawing.Color.Green writer.EnterStyle(s) writer.Write("Welcome custom control.") writer.ExitStyle(s) End Sub ' Additional implementation End Class ' Adapter Public Class MyControlAdapter Inherits ControlAdapter ' Example showing override of Render to control entire rendering Protected Overrides Sub Render(ByVal writer As HtmlTextWriter) Dim s As New Style() s.ForeColor = System.Drawing.Color.Red writer.EnterStyle(s) writer.Write("Welcome custom control adapter.") writer.ExitStyle(s) End Sub ' Additional implementation End Class

Data Source and Data Bound Controls

• Represent one or more named views of data
• Each view provides an enumeration of objects
  • Essentially SELECT in SQL terms
• A view may also be able to perform editing operations on its collection of objects
  • Essentially UPDATE, INSERT, DELETE in SQL terms.
  • Capabilities model exposed as boolean properties
• Ability to trigger change events
• Ability to load data on-demand

public interface IDataSource {
  event EventHandler DataSourceChanged { add; remove; }
  DataSourceView GetView(string viewName);
  ICollection GetViewNames();
}

public abstract class DataSourceControl : 
  Control, IDataSource, IListSource {
  // Additional implementation
}

public abstract class DataSourceView {
  public virtual bool CanDelete { get; }
  // CanInsert, CanPage, CanSort, CanUpdate, ...

  public event EventHandler DataSourceViewChanged;
  public virtual int Delete (IDictionary keys, IDictionary oldValues, ...);
  public virtual bool Insert (IDictionary values, ...);
  public virtual int Update (IDictionary keys, IDictionary values, IDictionary oldValues, ...);
  public abstract IEnumerable Select(DataSourceSelectArguments arguments);
}

Web Resources

// Mark the assembly with the resource [assembly: WebResource("CustonmControlScript.js", "text/javascript")] public class CustomControl : WebControl { // Additional implementation protected override void OnPreRender(EventArgs e) { this.Page.ClientScript.RegisterClientScriptResource(typeof(CustomControl), "CustomControlScript.js"); this.Attributes.Add("onmouseover", "MouseOverScript()"); base.OnPreRender(e); } } ' Mark the assembly with the resource <assembly: WebResource("CustomControlScript.js", "text/javascript")> Public Class CustomControl Inherits WebControl ' Additional implementation Protected Overrides Sub OnPreRender(ByVal e As System.EventArgs) Me.Page.ClientScript.RegisterClientScriptResource(GetType(CustomControl), "CustomControlScript.js"); Me.Attributes.Add("onmouseover", "MouseOverScript()" MyBase.OnPreRender(e) End Sub End Class

Client Script Management

public class MyButton : Button { protected override void OnPreRender(EventArgs e) { String sScript = "function DoAlert(){alert('Hello World');}"; this.Page.ClientScript.RegisterClientScriptBlock(typeof(MyButton), "ScriptFunction", sScript, true); OnClientClick = "javascript:DoAlert();"; base.OnPreRender(e); } // Additional implementation } Public Class MyButton Inherits Button Protected Overrides Sub OnPreRender(ByVal e As System.EventArgs) Dim sScript As String = "function DoAlert(){alert('Hello World');}" Me.Page.ClientScript.RegisterClientScriptBlock(GetType(MyButton), _ "ScriptFunction", sScript, True) OnClientClick = "javascript:DoAlert();" MyBase.OnPreRender(e) End Sub ' Additional implementation End Class

Device, (device markup or browser) Filtering

<!-- Text property is defaulted to a value, reset given IE and also if the custom filter applies. --> 
<!-- The more specific the device-filter wins.. -->
<asp:Label runat="server" Id="WelcomeLabel" Text="Welcome to ASP.NET's Quickstarts" 
	IE:Text="Quickstarts" MyFilter:Text="Welcome" />

Callbacks

• Create a server-side call back event with a given signature in your custom control, (ICallbackEventHandler.PrepareCallbackEvent) that acts on an argument passed into the method<. You should call on a method that developers can override if they extend your custom control;
• Create a server-side method that generates the result for the call back, ICallbackEventHandler.RenderCallbackResult. You should call a method that developers can override if they extenf your control. The return result will be passed to client-side script defined by your custom control;
• Create client-side script that manages the return call or error. This will be generated through your custom control;
• Use the callback event reference hooked up to a client-side event in your custom control.

public class CustomControl : CompositeControl, ICallbackEventHandler { void ICallbackEventHandler.PrepareCallbackEvent(string eventArgument) { PrepareCallBackEvent(eventArgument); } String ICallbackEventHandler.RenderCallbackResult() { return RenderCallbackResult(); } private String _callbackEventArg; // Do work in a protected virtual methods so that derived controls can override protected virtual void PrepareCallBackEvent(string eventArgument) { _callbackEventArg = eventArgument; } protected virtual String RenderCallbackResult() { if (_callbackEventArg == "theArg") return = "Some data"; return "Only theArg allowed!"; } // Additional implementation // Client script functions that handle the callback private String sButtonCallBack = "function ButtonCallBack(result, context) { alert(result); }"; private String sButtonCallBackError = "function ButtonErrorCallBack(result, context) { alert(result); }"; protected override void OnInit(EventArgs e) { base.OnInit(e); // Additional implementation Page.ClientScript.RegisterClientScriptBlock(typeof(CustomControl), "ButtonCallBack", sButtonCallBack, true); Page.ClientScript.RegisterClientScriptBlock(typeof(CustomControl), "ButtonCallBackError", sButtonCallBackError, true); } // Additional implementation protected override void OnPreRender(EventArgs e) { // Set up the OnClick event to fire an out-of band call to the handler Attributes["OnClick"] = Page.ClientScript.GetCallbackEventReference(this, "'theArg'", "ButtonCallback", "null", "ButtonErrorCallback", true); base.OnPreRender(e); } } Public Class CustomControl Inherits CompositeControl Implements ICallbackEventHandler Private Sub PrepareCallbackEvent(ByVal eventArgument As String) Implements System.Web.UI.ICallbackEventHandler.PrepareCallbackEvent PrepareCallbackEvent(eventArgument) End Sub Private Function RenderCallbackResult() As String _ Implements System.Web.UI.ICallbackEventHandler.RenderCallbackResult Return RenderCallbackResult() End Function Private _callbackEventArg As String; Protected Overridable Sub PrepareCallback(ByVal eventArgument As String) _callbackEventArg = eventArgument End Sub Protected Overridable Function RenderCallbackResult() As String Dim result As String If (_callbackEventArg = "theArg") Then result = "Some data" Else result = "Only theArg allowed!" End If Return result End Function Private sButtonCallBack As String = _ "function ButtonCallBack(result, context){ alert(result);}" Private sButtonCallBackError As String = _ "function ButtonErrorCallBack(result, context){ alert(result);}" Protected Overrides Sub OnInit(ByVal e As System.EventArgs) MyBase.OnInit(e) Page.ClientScript.RegisterClientScriptBlock(GetType(MyControl), _ "ButtonCallBack", sButtonCallBack, True); Page.ClientScript.RegisterClientScriptBlock(GetType(MyControl), _ "ButtonCallBackError", sButtonCallBackError, True); End Sub ' Additional implementation Protected Overrides Sub OnPreRender(ByVal e As EventArgs) Me.Attributes("OnClick") = _ Page.ClientScript.GetCallbackEventReference(Me, _ "'theArg'", "ButtonCallback", "null", "ButtonErrorCallback", True) MyBase.OnPreRender(e) End Sub End Class

Page-state

ASP.NET 2.0 also enables the splitting up the single hidden field into several using the maxPageStateFieldLength attribute in configuration.

Server Controls Design-time

• Region-based editing. In ASP.NET 1.x you would use a ReadWriteControlDesigner to provide a single read/write area for your control on the design-surface. In ASP.NET 2.0 you can create editable, template-able and read-only regions (DesignerRegion types) for richer editing experiences. Regions can also provide tool-tips and highlighting. You can also handle click events on the control and interact with the regions;
• Painting on the design-surface. You can provide graphics on the design-surface for your control by indicating that the control supports painting and overriding OnPaint;
• Control-designer types can interact with the control more closely with accessors but also can take advantage of control features such as embedded resources like images;
• Task-based editing. Using DesignerActionLists you can provide a very visual, contextual task list for page developers to interact with. This advances the previous concept of DesignerVerbs;
• Improved and much simplified template-editing. Your control-designer can defer simply to the tool's template editing UI or you can create your own UI using regions. Adding template editing is now as simple as defining the TemplateGroups collection on the ControlDesigner;
• Several new convenient control-designer base classes, CompositeControlDesigner and ContainerControlDesigner for common scenarios.

namespace CustomControls { [Designer(typeof(MyDesigner)), ParseChildren(false), PersistChildren(true)] public class MyControl : WebControl { } public class MyDesigner : ContainerControlDesigner { private Style _style = null; public override string FrameCaption { get { /* Return a caption */"; } } public override Style FrameStyle { get { /* Return a Style for the frame*/ } } public override DesignerActionListCollection ActionLists { get { // Get the base collection and add my own list } } private sealed class MyList : DesignerActionList { // Additional members to handle the smart-tag public override DesignerActionItemCollection GetSortedActionItems() { // Create a collection and add DesignerActionTextItem, // DesignerActionPropertyItem and DesignerActionMethodItem types } } } } <Designer(GetType(MyDesigner)), ParseChildren(false), PersistChildren(true)> Namespace CustomControls <Designer(GetType(MyDesigner)), ParseChildren(False), PersistChildren(True)> _ Public Class MyControl Inherits WebControl End Class Public Class MyDesigner Inherits ContainerControlDesigner Private _style As Style = Nothing Public Overrides ReadOnly Property FrameCaption() As String Get ' Return a caption End Get End Property Public Overrides ReadOnly Property FrameStyle() As Style Get ' Return a style for the frame End Get End Property Public Overrides ReadOnly Property ActionLists() _ As System.ComponentModel.Design.DesignerActionListCollection Get ' Get the base collection and add my own list End Get End Property Private Class MyList Inherits System.ComponentModel.Design.DesignerActionList ' Members to handle the smart-tag .. Public Overrides Function GetSortedActionItems() _ As System.ComponentModel.Design.DesignerActionItemCollection ' Create a collection and add DesignerActionTextItem, ' DesignerActionPropertyItem and DesignerActionMethodItem types End Function End Class End Class End Namespace

Application Service Providers

• Membership
• Role Manager
• Session State
• Profile
• Site Navigation
• Site Counters
• Web Parts Personalization
• Web Events

Expression Builders

• Connection strings. Used to access connection-strings in configuration. <%$ connectionstrings: MyConnStr %>;
• Application settings. Used to access the application setting in configuration. <%$ appsettings: MyAppValue %>, and;
• Resources. Used as the foundation for building a multi-lingual site. <%$ resources: mykey %>.

Expression builders can also be constructed to support the no compile feature of ASP.NET 2.0. Instead of ASP.NET generating code through the expression builder during the generation of the page-class, the runtime instead instantiates the expression builder and evaluates the expression. The following example shows a pseudo ExpressionBuilder and ExpressionBuilderEditor. .

<!-- In configuration, add your expression builder. Here the type is defined in App_code -->
<expressionBuilders>
	<add expressionPrefix="Expr" type="CustomExpressions.CustomExpressionBuilder" />
</expressionBuilders>

Localization

The localization model in ASP.NET 2.0 allows the page developer to set implicit or explicit, declarative expressions. You can extend the resource expressions as described above and still use the underlying resource providers. More likely however, is extending localization to provide an alternative source for resource data rather than use ResX and it's resultant satellite assemblies. You can simply swap out the existing ResourceProviderFactory that is defined in configuration and supply a new one. The factory creates IResourceProviders for both global and local resources. The following pseudo code demonstrates a simple case (the custom factory must be defined in configuration).

<!-- Defines the type in configuration. This sample shows defining the type in the 
App_Code directory -->
<globalization resourceProviderFactoryType="CustomLocalizationProviders.CustomResourceProviderFactory" ../>

Compilation and Pre-compilation

Dynamic compilation includes for example, code separation files associated with web pages and user controls, code in the App_Code directory and abstract files such as ASPX, ASCX, RESX, and also, WSDL, XSD.

There are two forms of pre-compilation of sites for deployment as well as a pre-compilation mode that 'primes' the site. Pre-compiling for deployment can be performed in two ways that either allows specific updates to the compiled site or not. In both cases code is removed from the compiled site (target). Where no updates are selected, the declarative files like ASPX are removed too. Pre-compiling to prime a site means that ASP.NET will perform regular compilation of the entire site to avoid the first-time request penalty.

To precompile a site, you can use the aspnet_compiler.exe tool. This tool is located in the .NET Framework installation directory, for example %WINDIR%\Microsoft.NET\Framework\<version>. You can run the tool with a /? switch to see the list of available options. For example, to pre-compile a site in-place by specifying the virtual path to the application, use the following command line:

  > aspnet_compiler.exe -v /MyApp 

You can also extend the compilation processes in a number of ways; by contributing new file types or extensions to the compilation using BuildProviders, or by making specific content virtual so that the source is for example not on disk. The VirtualPathProvider provides this extensibility point.

Build Providers

The following snippet shows the mapping of a custom build provider for a new file type (extension: myext). When files with this extension are added to the App_Code directory only, The custom build provider is used to parse the file and 'hand back' code to ASP.NET. The custom build provider is also defined within the App_Code directory, but in a configured sub direcrory. This ensures that the type for the custom build provider will be available for use by the build system, when the custom file type is encountered in the main App_Code directory.

// In configuration, this build provider is defined in the App_code\CustomBuildProviders directory

<system.web>
  <compilation>
    <codeSubDirectories>
      <add directoryName="CustomBuildProviders"/>
    </codeSubDirectories>
    <buildProviders>
      <add extension=".myext" type="CustomBuildProviders.CustomBuildProvider"/>
    </buildProviders>
  </compilation>
<system.web>	

If you need to obtain a type in application code you can use the BuildManager.GetType method as assembly names are not predictable.

Virtual Path Provider

To use a virtual path provider, you need to register your virtual path provider with ASP.NET at an early point in the application's lifecycle, for example in a special static method you can define in code in the App_Code directory, called AppInitialize. Only specific types of web content can be virtualized in this manner. For example, code in the App_Code directory cannot be mapped to a VirtualPathProvider.

Virtual path providers, therefore, are used to serve requests for content based on a virtual path and when registered there may be a number of virtual path providers in use. It is possible that the web content in your application may be served by a number of virtual path providers. For example your custom virtual path provider and the in-built ASP.NET one that handles the regular file system. In this case you need to construct your virtual path provider in a manner that it hands off to the Previous virtual path provider, if it does not handle a specific virtual path.

The following snippet shows pseudo-code for a custom VirtualPathProvider

// For example, using code in the App_Code directory namespace CustomVirtualPathProviders { public sealed class CustomVirtualPathProvider : VirtualPathProvider { public static void AppInitialize() { CustomVirtualPathProvider myVpp = new CustomVirtualPathProvider(); HostingEnvironment.RegisterVirtualPathProvider(myVpp); } // Implement other methods that define file hashing and dependencies .. public override string GetFileHash(string virtualPath, IEnumerable virtualPathDependencies) { // Return a hash value based on the virtualPathDependencies // For unhandled dependencies, create a list of these, then defer to the Previous to // get it's hash and combine with this hash value } public override CacheDependency GetCacheDependency(string virtualPath, IEnumerable virtualPathDependencies, DateTime utcStart) { // If the custom virtual path provider handles the path or dependency and it can // create a CahceDependency create on and combine with that from the Previous // If the provider cannot create a cacheDependency and it handles one of the // dependencies, return null } public override bool FileExists(string virtualPath) { // If the custom virtual path provider handles the virtualPath and // it exists return true, otherwise defer to Previous } public override bool DirectoryExists(string virtualDir) { // If the custom virtual path provider handles the virtualDir and // it exists return true, otherwise defer to Previous } public override VirtualFile GetFile(string virtualPath) { // If the custom virtual path provider handles the virtualPath and // it exists then create a VirtualFile and return, otherwise defer to Previous // VirtualFile implements an Open method to return a Stream } public override VirtualDirectory GetDirectory(string virtualDir) { // If the custom virtual path provider handles the virtualDir and // it exists then create a VirtualDirectory and return, otherwise defer to Previous // VirtualDirectory implements enumerations of sub-dirs and files } internal class MyVirtualFile : VirtualFile { public MyVirtualFile(String virtualPath, .. ) : base(virtualPath) { .. } public override Stream Open() { .. } } } ' For example, using code in the App_Code directory Namespace CustomVirtualPathProviders Public NotInheritable Class CustomVirtualPathProvider Inherits VirtualPathProvider Public Sub AppInitialize() Dim myVpp As New CustomVirtualPathProvider() HostingEnvironment.RegisterVirtualPathProvider(myVpp) End Sub Public Overrides Function GetFileHash(ByVal virtualPath As String, _ ByVal virtualPathDependencies As System.Collections.IEnumerable) As String ' Return a hash value based on the virtualPathDependencies ' For unhandled dependencies, create a list of these, then defer to the Previous to ' get it's hash and combine with this hash value End Function Public Overrides Function GetCacheDependency(ByVal virtualPath As String, _ ByVal virtualPathDependencies As System.Collections.IEnumerable, _ ByVal utcStart As Date) As System.Web.Caching.CacheDependency ' If the custom virtual path provider handles the path or dependency and it can ' create a CahceDependency create on and combine with that from the Previous ' If the provider cannot create a cacheDependency and it handles one of the ' dependencies, return null End Function Public Overrides Function FileExists(ByVal virtualPath As String) As Boolean ' If the custom virtual path provider handles the virtualPath and ' it exists return true, otherwise defer to Previous End Function Public Overrides Function DirectoryExists(ByVal virtualDir As String) As Boolean ' If the custom virtual path provider handles the virtualDir and ' it exists return true, otherwise defer to Previous End Function Public Overrides Function GetDirectory(ByVal virtualDir As String) _ As System.Web.Hosting.VirtualDirectory ' If the custom virtual path provider handles the virtualDir and ' it exists return true, otherwise defer to Previous End Function Public Overrides Function GetFile(ByVal virtualPath As String) _ As System.Web.Hosting.VirtualFile ' If the custom virtual path provider handles the virtualPath and ' it exists then create a custom VirtualFile and return, otherwise defer to Previous ' VirtualFile implements an Open method to return a Stream End Function Private NotInheritable Class MyVirtualFile Inherits VirtualFile Sub New(ByVal virtualPath As String) MyBase.New(VirtualPath) End Sub Public Overrides Function Open() As System.IO.Stream ' Return a Stream End Function End Class End Class End Namespace