New Community Website

Ordinarily, you'd be at the right spot, but we've recently launched a brand new community website... For the community, by the community.

Yay... Take Me to the Community!

The Community Blog is a personal opinion of community members and by no means the official standpoint of DNN Corp or DNN Platform. This is a place to express personal thoughts about DNNPlatform, the community and its ecosystem. Do you have useful information that you would like to share with the DNN Community in a featured article or blog? If so, please contact .

The use of the Community Blog is covered by our Community Blog Guidelines - please read before commenting or posting.

Module Development in DNN 4.x

I have now been working with DotNetNuke 4.x for nearly a year (if you include the development time with beta versions of VS2005), and I thought that it would be useful to discus the many options for developing modules.

There has been much debate in the ASP.NET developer community at large, since the release of VS2005 (Visual Studio 2005) and VWD (Visual Web Developer), concerning the new development paradigm for Websites introduced in VS2005/VWD.  As a result of demands from developers, Microsoft has recently added an add-on project type - Web Application Project or WAP.

Concurrent, with that debate, DotNetNuke Module Developers have debated, how they should their Modules.  In this Blog, I hope to give you an idea of the various methods available.

1. App_Code or Dynamic Compilation

The first methodology is the methodology used in the DNN 4.x Starter Kits.  This methodology basically extends the core Website project.  Modules are developed by placing the user controls (and other content files in the DesktopModules/[ModuleName] folder, and by placing the code files (Controller & Info classes and DataProvider classes) in the App_Code/[ModuleName] folder.

The advantages of this method are:
  • Inexpensive - this methodology is supported by VWD, which is a free download.  At present this is the only development methodology supported by VWD.
  • Simplicity, Ease of Use
  • Speed (RAD), the dynamic compilation means that changes can be made quickly to any code file and the website just needs to be refreshed - no need to build as the code is dynamically compiled.
  • As of 4.3.3 there is Increased support within the DotNetNuke core for this methodology
    • The Starter Kit can be used to create the Module files as a start in development
    • The Module Definitions module in the Host menu now allows a Dynamic Module to be "packaged" for release
The disadvantages of this method are:
  • IP - this methodology exposes all the Intellectual Property, so is not really feasible for commercial developers
  • Versioning - there is no single monolithic assembly for a Module so this provides a challenge for version control.

2. App_Code and PreCompile

VS2005 provides a Precompilation option.  This feature is not available in VWD - although it can be carried out using the command-line aspnet_compiler (available in the .NET SDK).

This option, from a development perspective, is much the same as the previous option.  However, this option does overcome both the disadvantages mentioned above.

There are two ways this can be done:
  1. Precompile the whole site (this is option is really only for those developers that are using DNN as a framework for a separate product, as all the code (core and modules) are precompiled into one or more assemblies.
  2. Precompile just the module.  While precompilation, by defination builds the whole site, with the appropriate settings it is possible to identify the assemblies that are part of your module and package them as a module package, for distribution

3. Web Application Projects (WAP)

This approach which has been developed by Bert Corderman and Vladan Strigo so I won't go into too much detail here.

This approach uses the new Web Application Project add-in for Visual Studio (not supported by VWD).  It follows fairly closely the approach used in DotNetNuke 3.x.  To fully utilize this approach developers must be prepared (at the moment) to do some manual post build and packaging tasks, although Bert and Vladan are working on ways to minise this through the use of MSBuild scripts and Web Deployment Projects (WDP).

At this time, I would catagegorize these approaches as promising, but not for novice developers.

They do satisfy the need for IP protection and version control, but they do lose somewhat the speed and ease-of-use that the first methodology offers.

We have been working with both Bert and Vladan to make sure that the DotNetNuke core can provide tools for this approach.

4. Hybrid Approach using Class Libraries

This approach is a variation of the first methodology, and is an approach that I have developed for my own personal modules.

The big difference between this approach and the first approach is that the code files (Info, Controller, Dataprovider etc) are in a Class Library, rather than in App_Code.

It overcomes (to some extent) the disadvantages of the dynamic compile approach in that the Business Layer and Data Layer IP is protected, and version control is supported.

The code files for the user controls are still left in the website and so the advantages/disadvantages of the dynamic compile methodology still exist for this approach.

In one module I am developing, I have however, taken this approach to the extreme, as the only IP (other than HTML layout for templating) in the website is the following:

namespace MyNamespace
    public partial class MyModule: MyModuleBase
        protected void Page_Load(object sender, EventArgs e)

Thats it.

The reason why this works is that everything is funnelled through the MyModuleBase class.

I will be blogging in the future on this particular Module, as it develops a number of new and intersting ideas.


Comment Form

Only registered users may post comments.


Aderson Oliveira (22)
Alec Whittington (11)
Alessandra Davies (3)
Alex Shirley (10)
Andrew Hoefling (3)
Andrew Nurse (30)
Andy Tryba (1)
Anthony Glenwright (5)
Antonio Chagoury (28)
Ash Prasad (37)
Ben Schmidt (1)
Benjamin Hermann (25)
Benoit Sarton (9)
Beth Firebaugh (12)
Bill Walker (36)
Bob Kruger (5)
Bogdan Litescu (1)
Brian Dukes (2)
Brice Snow (1)
Bruce Chapman (20)
Bryan Andrews (1)
cathal connolly (55)
Charles Nurse (163)
Chris Hammond (213)
Chris Paterra (55)
Clint Patterson (108)
Cuong Dang (21)
Daniel Bartholomew (2)
Daniel Mettler (181)
Daniel Valadas (48)
Dave Buckner (2)
David Poindexter (12)
David Rodriguez (3)
Dennis Shiao (1)
Doug Howell (11)
Erik van Ballegoij (30)
Ernst Peter Tamminga (80)
Francisco Perez Andres (17)
Geoff Barlow (12)
George Alatrash (12)
Gifford Watkins (3)
Gilles Le Pigocher (3)
Ian Robinson (7)
Israel Martinez (17)
Jan Blomquist (2)
Jan Jonas (3)
Jaspreet Bhatia (1)
Jenni Merrifield (6)
Joe Brinkman (274)
John Mitchell (1)
Jon Henning (14)
Jonathan Sheely (4)
Jordan Coopersmith (1)
Joseph Craig (2)
Kan Ma (1)
Keivan Beigi (3)
Kelly Ford (4)
Ken Grierson (10)
Kevin Schreiner (6)
Leigh Pointer (31)
Lorraine Young (60)
Malik Khan (1)
Matt Rutledge (2)
Matthias Schlomann (16)
Mauricio Márquez (5)
Michael Doxsey (7)
Michael Tobisch (3)
Michael Washington (202)
Miguel Gatmaytan (3)
Mike Horton (19)
Mitchel Sellers (40)
Nathan Rover (3)
Navin V Nagiah (14)
Néstor Sánchez (31)
Nik Kalyani (14)
Oliver Hine (1)
Patricio F. Salinas (1)
Patrick Ryan (1)
Peter Donker (54)
Philip Beadle (135)
Philipp Becker (4)
Richard Dumas (22)
Robert J Collins (5)
Roger Selwyn (8)
Ruben Lopez (1)
Ryan Martinez (1)
Sacha Trauwaen (1)
Salar Golestanian (4)
Sanjay Mehrotra (9)
Scott McCulloch (1)
Scott Schlesier (11)
Scott Wilkinson (3)
Scott Willhite (97)
Sebastian Leupold (80)
Shaun Walker (237)
Shawn Mehaffie (17)
Stefan Cullmann (12)
Stefan Kamphuis (12)
Steve Fabian (31)
Steven Fisher (1)
Timo Breumelhof (24)
Tony Henrich (3)
Torsten Weggen (3)
Tycho de Waard (4)
Vicenç Masanas (27)
Vincent Nguyen (3)
Vitaly Kozadayev (6)
Will Morgenweck (40)
Will Strohl (180)
William Severance (5)
What is Liquid Content?
Find Out
What is Liquid Content?
Find Out
What is Liquid Content?
Find Out