Professional DotNetNuke Module Programming Paperback – Feb 24 2009
Customers Who Bought This Item Also Bought
No Kindle device required. Download one of the Free Kindle apps to start reading Kindle books on your smartphone, tablet, and computer.
Getting the download link through email is temporarily not available. Please check back later.
To get the free app, enter your mobile phone number.
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.
Top Customer Reviews
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.
Most Helpful Customer Reviews on Amazon.com (beta)
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.
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.
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.
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.
Look for similar items by category
- Books > Computers & Technology > Internet & Social Media
- Books > Computers & Technology > Microsoft > Development > .NET
- Books > Computers & Technology > Programming > Software Design, Testing & Engineering > Software Development
- Books > Computers & Technology > Software
- Books > Computers & Technology > Web Development > Programming
- Books > Computers & Technology > Web Development > Web Services
- Books > Textbooks > Computer Science & Information Systems > Programming Languages