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.
http://www.amazon.com/exec/obidos/tg/detail/-/0470171162/
Download File Size:5.77 MB
|
