Professional DotNetNuke Module Programming and over one million other books are available for Amazon Kindle. Learn more

Vous voulez voir cette page en français ? Cliquez ici.

Sign in to turn on 1-Click ordering.
More Buying Choices
Have one to sell? Sell yours here
Start reading Professional DotNetNuke Module Programming on your Kindle in under a minute.

Don't have a Kindle? Get your Kindle here, or download a FREE Kindle Reading App.

Professional DotNetNuke Module Programming [Paperback]

Mitchel Sellers , Shaun Walker
4.0 out of 5 stars  See all reviews (1 customer review)
List Price: CDN$ 59.99
Price: CDN$ 37.79 & FREE Shipping. Details
You Save: CDN$ 22.20 (37%)
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
Usually ships within 2 to 4 weeks.
Ships from and sold by Gift-wrap available.


Amazon Price New from Used from
Kindle Edition CDN $31.26  
Paperback CDN $37.79  
Save Up to 50% on "For Dummies" Books
Lighthearted but not lightweight, For Dummies books are great references not only for tackling new subjects but also for brushing up on subjects with which you're already familiar. Get results while saving up to 50%. See more.
Join Amazon Student in Canada

Book Description

Feb. 6 2009 Wrox Programmer to Programmer
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.

Customers Who Bought This Item Also Bought

Product Details

Product Description

From the Back Cover

Professional DotNetNuke® Module Programming

As the force behind the creation of new functionality to DotNetNuke Web sites, DotNetNuke modules are reusable programming components that offer a way to extend the basic DotNetNuke framework. With this resource, you'll learn the best practices for DotNetNuke module development, and you'll gain a clear understanding of the development techniques needed to work within the DotNetNuke framework.

This book begins with a look at development within DotNetNuke. The book walks you through DotNetNuke setup, terminology, development environment setup, and options for .NET project setup. You'll gradually move on to discussions of more advanced module programming concepts, such as optional interfaces and DotNetNuke user controls. A scenario-based model introduces other extension methods (such as authentication providers and skin objects), and demonstrates how to communicate with the API. Real-world examples throughout serve to enhance your grasp of ways to successfully market and distribute a completed DotNetNuke module.

What you will learn from this book

  • How to properly create requirements for a DotNetNuke module project

  • How to create modules that support static text localization

  • Why it is important to adhere to the API, and how to take full advantage of it

  • How to tightly and safely integrate custom code with the framework

  • Techniques for packaging, installing, and debugging modules

  • Tips for dealing with third-party components and controls

  • Tips for working with both DotNetNuke 4.x and 5.x

  • Implementation details for various Ajax frameworks, including jQuery and ASP.NET Ajax

l An understanding of alternative integration options such as authentication providers and skin objects

Who this book is for

This book is for DotNetNuke users of all levels of experience who are looking to expand their expertise. A knowledge of DotNetNuke is not required, but will be helpful.

Wrox Professional guides are planned and written by working programmers to meet the real-world needs of programmers, developers, and IT professionals. Focused and relevant, they address the issues technology professionals face every day. They provide examples, practical solutions, and expert education in new technologies, all designed to help programmers do a better job.

Inside This Book (Learn More)
Browse Sample Pages
Front Cover | Copyright | Table of Contents | Excerpt | Index | Back Cover
Search inside this book:

Customer Reviews

5 star
3 star
2 star
1 star
4.0 out of 5 stars
4.0 out of 5 stars
Most helpful customer reviews
4.0 out of 5 stars Not a bad book,but could explain a few areas more Sept. 5 2010
By Jake
Format:Paperback|Verified Purchase
Thought the book takes you through the various steps in module development and through a bit of a backgrounder, it still wasn't detailed enough for the 1st time DNN module developer. The book seems to assume you are familiar enough with DNN methods in module design and at points, leaves you scratching your head on what you were really doing.

Still, if you are going to plunge into DNN module creation, it is still fairly good book. Things that may not make some sense initially will come together with a bit more digging out on the Internet.
Was this review helpful to you?
Most Helpful Customer Reviews on (beta) 3.6 out of 5 stars  9 reviews
13 of 14 people found the following review helpful
4.0 out of 5 stars Good book, solid on the basics March 9 2009
By Johnny Spangle - Published on
Format:Paperback|Verified Purchase
I'd say the other reviewers are harsh bordering on unfair. I found the book very useful in picking up the fundamentals of DNN module development. It provided a good number of topics on which to search for more information; topics I would not have known existed (with any ease) without first reading this book.

I am no newbie to .NET development (10 years in the trade) but like many others out there, new to DNN. I needed something more than the documentation provided by DNN, which is patchy at best and useless at worst, and this book provided it.

I believe DNN is growing as an application and the literature support it will no doubt improve. Criticisms I would make of this book are as follows. At around 300 pages, there is scope to add more detail ... come on Mitchell, it's clear you know more, put it down on paper. Second, there a few careless errata (my favorite are VB files given a .cs extension) but on the other hand, this is by no means uncommon in Wrox books; I've read a few, I know.

So if you're interested in knowing more than the sdk documentation can tell you (and not just interested in showing off what you know already, other reviewers!) then this is pretty much your only option in book form. Buy it, search the forums and blogs, and you will be doing ok.
11 of 14 people found the following review helpful
1.0 out of 5 stars Shallow. Lacks fundamentals. March 5 2009
By Alexander - Published on
This is a shallow book. It lacks the depth one is looking for when doing serious module programming. The book spends too much time on basic issues - including how to install DotNetNuke and a comparison of versions 3/4/5.

But when more interesting topics arise, the author much too often simply writes 'XXX is beyond the scope of this book'.

The structure already shows the shortcomings: The author introduces module programming by example, e.g. by creating a simple, basic module (chapters 4-9). This is the kind of information you easily find browsing the web.

The book is short on fundamentals. As an example, take the definition of a module in the chapter on 'Under the DotNetNuke Hood' on page 31:
"Modules are the key pieces of functionality that exist inside DotNetNuke installations. Tabs create the page structures needed to house the functionality; and, in the end, modules actually implement the desired result. DotNetNuke has many core modules available... (list of some modules follows)"
Sorry, but this is supposed to be a book about module programming, the reader deserves much more precision and thoughtfulness (this section (and the whole book) really contains no more in-depth discussion of what a module is and what the guiding principles behind DotNetNuke's module architecture are).

Headings often sound better than their content. An example: Chapter 9 (Packaging, installing, debugging) contains a section titled: 'Distribution and Testing Considerations'. This could certainly be an important issue. But the author devotes 12 lines to it and mainly reiterates a single idea: Testing should occur on multiple DotNetNuke installations with varied settings.
3 of 3 people found the following review helpful
5.0 out of 5 stars Very helpful, usable information to do DNN module programming Aug. 30 2009
By Dale Warner - Published on
I bought this book to overcome the shortage of information that is packaged with the DNN source code. DNN has been changing so fast that the documentation describing how to program (at least that I could find online) struggles to keep up. This book is useful, clear, and accurate - I would recommend it for anyone that already has C# / VB experience that needs to understand how to create and deploy modules under DotNetNuke. Worth the price.
5 of 6 people found the following review helpful
3.0 out of 5 stars Good but not Great Feb. 22 2009
By Keith E. Rowley - Published on
Professional DotNetNuke Module programming falls in-between targeting beginners who need to know how to do things in the simplest way possible, and targeting professionals, who need a comprehensive overview of the API and best practices for using it.

The author stresses using the Web Application Project model rather that the Web Site Project model, and while this may be best practice for professional module developers wanting to distribute pre-compiled code, it is much more difficult to debug and is an overall slower development process.

At only 306 pages including the index it doesn't feel like as good a value as other wrox books in the same price range. For instance, Professional ASP.NET 3.5: In C# and VB (Programmer to Programmer) which I would highly reccomend has 1673 pages including the index and costs about the same amount.

Overall, being new to DotNetNuke programming, I found this book to be usefull to get an overview of the way the framework works and reccomended practices for integrating new modules into the existing framework. However, this book fell short in providing the level of quality and detail I have come to expect from Wrox books. 3 stars.
2 of 2 people found the following review helpful
4.0 out of 5 stars Great in concepts, lacking in details July 28 2011
By Lynn - Published on
Format:Paperback|Verified Purchase
Professional DotNetNuke Module Programming provides a great overview of what can be done in DotNetNuke. By the end of the book you will know what module programming is used for, what sorts of techniques module programming employs, and when to use these techniques. The multitude of code examples in the book in both VB.Net and C#.Net also show you how to code your module and implement these techniques. One of the truly great things about the book is the choice of the GuestBook for the code example, referenced mainly in chapters 4-10. The example uses many different DotNetNuke module techniques in a scenario that makes sense, rather than just hacking together techniques for the sake of showing them in the book. So, while the coding can get tiresome, I encourage you to go through all of the example code and try to implement it yourself. You will learn a lot!

Where I find the book lacking is in the details. Oftentimes they forget to include the "why" or leave out important information in what seems like a hurried attempt to get the book out the door.

The coverage of the manifest (.dnn) file provides an excellent example of where details would have been helpful to the reader. The whole explanation of what the control-keys do is left out. Scattered throughout the book are explanations, but it never talks about the need to have the control key left blank for the primary view, for example. Also, nowhere in the book was an explanation of control-type and what that means. Later on when the authors discuss different techniques for Module Communication in Chapter 13, they do not say how the different techniques affect the manifest, nor do they mention the running GuestBook example and say which of the techniques it used. Further, in Chapter 13 the code examples are very light. Therefore, it becomes difficult to implement the different techniques for Module Communication given the information provided.

Localization techniques provide another example of where details are left out or come up much later. The dnn:Label control is presented, but there is no good explanation of all the ways it differs from the asp:label control. The definition of "implicit localization" is not clear in Chapter 8, though as you read through the book there are more clues, but nothing concrete.

Style display has a similar lack of detail in the descriptions. The authors use several different techniques for displaying components and it is not clear at the time they are used or why they were chosen. There are some CSS classes that they hard code such as "SubHead". There is no mention of why this technique is used. Further for both the hardcoded classes and the skin messages such as "Yellow Warning", there is no discussion as to whether or not these classes are part of all skins or just the DotNetNuke skins.

Another time saver in learning the material would be some more integration in the requirements explanation in Chapter 4 between the requirements and dotnetnuke. Perhaps, a diagram of what files /components were going to be created in the IDE, what each did, and which components could talk to which other components. The author goes right into building the DAL without giving us a real understanding of how all of the components fit together. Further, there was no picture of what the page looked like after writing. I only was given one "module" to install and "both" GuestBook controls showed up on the same page. But, this was not the effect that I wanted. I would have liked to have been able to add the two modules separately. No discussion was given on this.

There are other small issues that I would like the author to clean up. In Chapter 8, code listing 8-1-3, the authors should not be using this.ModuleId, but should instead be getting the ModuleId from the other module. Chapter 10, which is a great explanation of different module interfaces, falls short on the last interface IPropertyAccess . Unlike all other code examples in the book, it uses only a "VB" example for "space reasons". However, the example is not even in terms of the GuestBook as all other relevant examples are. The authors leave that exercise for the reader. I have to assume the authors were lazy and did not feel like writing this code example themselves, although it would have really helped the reader. I would have also liked an explanation of when in the lifespan of a page, when the settings collection becomes available and whether or not it is possible to share settings between modules in the same manifest.

So, while this book is a good overview of what DotNetNuke is capable of, it takes more time to weed through than I would have liked due to the lack of details, or details in places other than where I expected to see them. If you want an overview of DotNetNuke programming, that goes beyond the current free videos on the DotNetNuke site, this book provides a great introduction.

About the author: I am a technologist from Pittsburgh, PA that has performed all roles in a development organization. I believe that great people, processes, and architecture lead to great products. The example in this book was the first DotNetNuke module that I have written. I used the first release of version 6 of DotNetNuke Community Edition to write it.
Search Customer Reviews
Only search this product's reviews

Look for similar items by category