Building Websites with VB.NET and DotNetNuke 3.0

For more information:

In this chapter, we are going to walk you through creating a custom module for the CoffeeConnections portal. A custom module can consist of one or more custom web controls. The areas we will cover are:

  • Creating a private assembly project to build and debug your module
  • Creating View and Edit controls
  • Adding additional options to the module settings page
  • Implementing the IActionable, ISearchable, and IPortable interfaces
  • Using the Dual List Control
  • Creating a SQLDataProvider
  • Packaging your module
  • Uploading your module

Coffee Shop Listing Module Overview

One of the main attractions for the CoffeeConnections portal is that users will be able to search, by zip code, for coffee shops in their area. After searching, the users will be presented with the shops in their area. To allow the focus of this chapter to be on module development, we will present a simplified version of this control. We will not spend time on the ASP.NET controls used or validation of these controls, instead we will focus only on what is necessary to create your own custom modules.

Setting Up Your Project (Private Assembly)

The design environment we will be using is Visual Studio .NET 2003. The files used in DotNetNuke come pre-packaged as a VS.NET solution and it is the best way to create custom modules for DotNetNuke. Visual Studio will allow us to create private assemblies (PA) which will keep our custom module code separate from the DotNetNuke framework code.

A private assembly is an assembly (.dll or .exe) that will be deployed along with an application to be used in conjunction with that application. In our case, the main application is the DotNetNuke core framework. The private assembly will be a project that is added to the DotNetNuke solution (.sln). This will keep our module architecture separate from the DotNetNuke core architecture but will allow us to use Visual Studio to debug the module within the framework. Since building our modules in a PA allows us to have separation from the DotNetNuke core framework, upgrading to newer versions of DotNetNuke is a simple process.

Note: Even though the DotNetNuke framework is built using VB.NET, you can create your module private assemblies using any .NET language. Since your module logic will be compiled to a .dll, you can code in the language you like.

The DotNetNuke project is divided into many different solutions enabling you to work on different parts of the project. We have already seen the HTTP Module solution and the Providers solutions. Since we want to look at the default modules that have been packaged with DotNetNuke we will be using the DotNetNuke.DesktopModules solution.

Note: You can even create a new solution and add the DotNetNuke project to the new solution. You would then need to create a build support project to support your modules. We are using the DotNetNuke.DesktopModules solution so that you are able to look at the default modules for help in design process.

To set up your private assembly as part of the DotNetNuke.DesktopModules solution, take the following steps:

  1. Open up the DotNetNuke Visual Studio.NET solution file (C:\DotNetNuke\Solutions\DotNetNuke.DesktopModules\DotNetNuke.D esktopModules.sln).
  2. In the Solution Explorer, right-click on the DotNetNuke solution (not the project) and select Add | New Project:
  3. In Project Types, make sure that Visual Basic Projects is highlighted and select Class Library as your project type. Our controls are going to run in the DotNetNuke virtual directory, so we do not want to create a web project. This would create an additional virtual directory that we do not need.
  4. Your project should reside under the C:\DotNetNuke\DesktopModules folder. Make sure to change the location to this folder.
  5. The name of your project should follow the following convention. CompanyName.ModuleName. This will help avoid name conflicts with other module developers. Ours is named EganEnterprises.CoffeeShopListing. You should end up with a new project added to the DotNetNuke solution.
  6. You need to modify a few properties to allow you to debug our project within the DotNetNuke solution:
  7. Note: If you have installed URLScan, which is part of Microsoft’s IIS Lockdown Tool, you will have problem with folders that contain a period (.). If this is the case, you can create your project using an underscore instead of a period. Refer to for more information on the IIS Lockdown Tool.

    • In the CommonProperties folder, under the General section remove the Root namespace. Our module will be running under the DotNetNuke namespace, so we do not want this to default to the name of our assembly.
    • Delete the Class1.vb file that was created with the project.
    • Right-click on our private assembly project and select Properties.
  8. In the CommonProperties folder, under the Imports subsection, we want to add imports that will help us as we create our custom module. Enter each of the namespaces below into the namespace box and click on Add Import.
    • DotNetNuke
    • DotNetNuke.Common
    • DotNetNuke.Common.Utilities
    • DotNetNuke.Data
    • DotNetNuke.Entities.Users
    • DotNetNuke.Framework
    • DotNetNuke.Services.Exceptions
    • DotNetNuke.Services.Localization
    • DotNetNuke.UI

  9. Click OK to save your settings

When we run a project as a private assembly in DotNetNuke, the DLL for the module will build into the DotNetNuke bin directory. This is where DotNetNuke will look for the assembly when it tries to load your module. To accomplish this, there is a project called BuildSupport inside each of the solutions. The BuildSupport project is responsible for taking the DLL that is created by your project and adding it to the DotNetNuke solution’s bin folder.

To allow the BuildSupport project to add our DLL, we need to add a reference to our custom module project.

  1. Right-click on the reference folder located below the BuildSupport project and select Add Reference.
  2. Select the Projects tab.
  3. Double-click on the EganEnterprises.CoffeeShopListing project to place it in the Selected Components box.
  4. Click OK to add the reference.

Finally, we want to be able to use all of the objects available to us in DotNetNuke within our private assembly, so we need to add a reference to DotNetNuke in our project.

  1. Right-click on the reference folder located below the EganEnterprises.CoffeeShopListing private assembly project we just created and select Add Reference.
  2. Select the Projects tab.
  3. Double-click on the DotNetNuke project to place it in the Selected Components box.
  4. Click OK to add the reference.

Before moving on, we want to make sure that we can build the solution without any errors. We will be doing this at different stages in development to help us pinpoint any mistakes we make along the way.

After building the solution, you should see something similar to the following in your output window.

----------------------Done ---------------------
Build: 35 succeeded, 0 failed, 0 skipped

The number you have in succeeded may be different but make sure that there is a zero in failed. If there are any errors fix them before moving on.

More by Author

Must Read