This book was written to provide insight into the development
techniques needed (and the options available) to work within the
DotNetNuke framework. Emphasis is placed on the available methods
to extend the framework, as well as the situations and rules
governing when each respective extension model should be used.
Along with this emphasis on selecting the right extension method,
the book stresses the importance of leveraging the framework in as
many areas as possible, and ultimately using the framework to the
advantage of the developer, rather than merely working with it.
One current weakness of the DotNetNuke framework is developer
documentation. The framework provides developers with numerous
amazing methods to extend the framework and build truly robust
applications, but as of this writing, minimal API documentation
exists, and overall development topics are scattered all over the
Internet. Many community members have helped to supplement this
lack of developer content by writing blog articles and technical
tutorials to help teach the individual concepts, but because there
is no central repository, it can be tedious and difficult to find
just what you need.
This book helps truly identify and document some excellent new
features that are supported starting with DotNetNuke 5.0. The
inclusion of jQuery exposes developers to a great JavaScript
library that will enable interactive and animated interfaces to be
created easily. The new Module Packaging system (discussed in
detail in Appendix D) provides module developers and skin designers
with many much-needed options when it comes to deploying
applications. This book was written to expose this information, and
to function as a key resource for the development community.
This book assumes that the reader has a working knowledge of
standard ASP.NET development techniques and terminologies. Samples
in the book are provided in both C# and Visual Basic (VB) to enable
readers with diverse backgrounds to fully understand the concepts
presented. Users do not need to have a comprehensive understanding
of DotNetNuke prior to using this book because the early chapters
discuss the configuration of both DotNetNuke and the development
environment, and careful consideration has been taken to ensure
that DotNetNuke-specific terminology is explained as the book
progresses.
Readers already familiar with DotNetNuke 4.x development will
find this book valuable because it introduces many of the new
features of the latest software version, although some of the
beginning chapters for these readers will be redundant because the
overall concepts of environment configuration and basic interface
elements have not changed from 4.x to 5.x. Differences between
versions 4.x and 5.x are pointed out as appropriate.
As the title implies, this book primarily covers development
techniques within the DotNetNuke 5.x platform. The chapters point
out similarities and differences between the 4.x and 5.x platforms,
enabling readers to apply some newer concepts to the older
technology. Although this book primarily focuses on the concept of
module development, it discusses other extension models as well,
such as skin objects and authentication providers. Also covered in
this book are recommended practices for successful integration with
the framework.
This book begins with an introduction to development within
DotNetNuke. The discussions walk you through DotNetNuke setup,
terminology, development environment setup, and options for .NET
project setup.
The book then presents a scenario-based model to introduce basic
concepts of module development. This is accomplished by building a
simple guestbook module that demonstrates how individual portions
interact with one another. The discussion lays the foundation for
the most basic elements of development within DotNetNuke. Later in
the book, you learn about the more advanced module programming
concepts, such as optional interfaces and DotNetNuke user controls.
This discussion additionally introduces other extension methods,
such as authentication providers and skin objects, as well as best
practices.
In short, the main content of the book creates a working model
that guides you through the most common development scenarios; at
the same time, it provides the detail needed to tightly integrate
custom code with the framework.
The appendixes provide supplemental information to what is
contained in the chapters. This is material that, while not
critical to an understanding of the individual chapters, is
nonetheless important. The appendixes include items such as
community resources and general DotNetNuke configuration items, as
well as a detailed look at the new module manifest and a few key
integration API points that are not well documented overall.