Rating:  - Extremely readable developer's guide to developing ASP.NET
I cannot say enough good about this text. I find the author very readable and literate. The examples are clearly written and well commented.
The concepts/tasks involved in developing real ASP.NET applications (vs. simply a series of script based pages) is a long needed next step for developers coming from a more script-based background. And for developers used to writing desktop applications it draws on the techniques we have learned then expands them into using ASP.NET 2.0 to create full strength ASP.NET web applications.
The examples well commented and consistent. Because examples are given in both VB.NET and C#, I even have learned enough C# to be dangereous...but I will do that in private and wash my hands afterwards... ;)
The techniques presented will serve me well for years to come and also increased my understanding of the .NET Object Model...
Thanks to Jeff for a wonderful reference I will use for a long time. Can't wait to see what comes next...
Rating: - One of the few books that takes you beyond the API.
I found this book, while looking around for a book that goes beyond writing 20 line sample pages, and examines how a well-designed ASP.NET application should be built.
Although I did not come from an ASP background, this book does emphasize how one's thinking should change when making the move from ASP (or any similar technology, such as PHP), to ASP.NET. If the point of this book had to be summed up in a single sentence, it could be the author's claim that "an ASP.NET application is more than just a bunch of pages", as many ASP sites seem to be.
The beginning of the book is only for those who still need to be converted to OOP, and it argues the case for designing classes for your business objects, instead of just passing around a bunch of strings or integers. From there, other ideas, built on top of that start, are introduced, like creating an object-relational data layer, so that your business code can deal with objects, their properties and methods, instead of SQL statements, results sets, and fields.
There are other topics covered in the book, like server controls, or HTTP handlers, but the author's argument for a layered or multi-tier design is the most significant, because it is what almost every other ASP.NET book lacks.
This book is light on its coverage of ASP.NET's API, or C#/VB syntax. Pick up any of the dozen books on ASP.NET to learn the syntax, and the API. This is an idea book. It doesn't cover every little detail, but it gives you an understanding of how, in principle, a manageable web application can be be designed.
Rating: - Changing the way you think
I must confess that I have not tried very hard to be a better developer, and maybe that's because after using the old ASP for so many years, I thought I already knew everything. When I started a job last year at a new shop, it was clear that I had a lot to learn.
This book helps me get the bigger picture. The first part on object-oriented programming I think gets to just enough detail to make you understand it without overwhelming you. It's still tricky and I had to read it slowly (twice), but hey, I've been writing scripts for a lot of years going back to Perl. Lots of new tricks for this old dog!
The second part has a lot of goodies. I'm especially thrilled with the chapter on HttpHandlers and HttpModules because now I see potential for so many different uses outside of simple pages. The handler for checking the referrers of image requests is a long standing problem. I also like the chapters on the ASP.NET v2 features, especially the Membership API. I read the Homer/Sussman/Howard book about the beta version, and it's neat to see these put into action with practical examples here. Membership and Profile are great features, but I know from the projects I'm on that they're better applied to existing systems with our own providers.
The last part has some great topics, especially the one on the many development environments. On one hand, I praise the author for explaining the pitfalls of Visual Studio 2003, but I curse him for teasing us with the 2005 version. Word is that we only have to wait another couple of weeks to use it in production, but what an improvement!
While some of the topics can be a little thin here and there, I think the book does what it sets out to do in the preface: It gets beginners up to speed with practical advice and understanding so that they can move on beyond the "beginner" title.
Rating:  - Skip it, there is nothing "Real World" about this book.
Recommendation: Skip it, there is nothing "Real World" about this book. It loses focus and seems to be assembled from notes by the author. It definitely will not help you create real world applications. There are passing notes about ASP.NET 2.0 in this book, and since there are not many .NET 2.0 books available yet, this may be the only reason it got published. This book will bore advanced programmers, and steer beginners down the wrong path.
The Good:
One part of the book does stand out: "Example: Protecting Your Images from Bandwidth Leeching". This section provides two useful utilities. One for protecting against people embedding images from your site on theirs. Two, implementing image based security to keep out automated sign ups. Consider downloading Chapter 8: HttpHandlers and HttpModules from Safari Bookshelf, but this chapter does not make the book worth purchasing.
The Bad:
The book starts with a light introduction to object-oriented development, maybe too light. "Assessing Your Needs and Requirements" mentions the need and spends no time on it. Agile programming is mentioned, but there is no mention of user stories. Completely leaves the reader to seek out other sources.
The author mentions ObjectSpaces which may never ship, but does not mention options currently available such as NHibernate. This is probably because the author's data access methodology does not intend to utilize O/R mapping. If you are going to bring it up, do a better treatment of it than a passing mention to ObjectSpaces.
The authors justification of layers is based on old school thought. Not that layering is wrong, but it should not be based on breaking your company into separate user interface, business and database teams. Organizations employing this method tend to move slowly. Later, the author presents a more reasonable assumption by sharing data and processes between project groups. Should have spent more time on Service Oriented Architecture and dropped the earlier division of labor speech.
The topic on "The POP Forums Architecture" seems mostly dedicated to pushing and bragging about the authors software, POP Forums. Examples are given how POP Forums does things, but then the author says, "don't worry, you don't need to understand". He also mentions showing how to build a less adequate, but simpler, data access layer later in the book.
A data caching technique is given that is rendered useless by .NET 2.0. The author comes back several chapters later to inform you of this and then briefly presents Microsoft's updated replacement strategy.
The data access method presented is too simplistic. The data access code is integrated with the business logic in the same class. This should at least be broken out into a separate persistence class. Getting multiple records also will not scale when child relationships are introduced into the model. The author should have introduced O/R mappers or explained his methods used in POP Forums. There also is no validation of the objects before storage into the database. Very poor.
The first three chapters in "The ASP.NET Architecture" section do a good job describing ASP.NET's architecture and how things work, even if only at a high level. Server Controls is a little light, but should provide enough information to get started. Web Services as Objects is misleading, this is only a high level overview of web services with the statement, "don't treat web services as object remoting." After this the section falls apart, the last three chapters are too high level to be useful. The reader will need to seek out more information.
The book is dedicated to ASP.NET but there is no mention of NUnitASP in the testing chapter, only NUnit.
Maybe by section three I am just getting bored with this book. But this entire section is too high level to be useful. I think the author was trying to meet a page minimum.
Rating: - Finally someone who gets it
I grew tired of seeing books covering every aspect you could ever want to know about ASP.NET without teaching you a thing. Following 5 steps to building a datagrid is wonderful, but teach why I'm doing something. The fact that this book focuses on 'why' and not just 'how' is great. The fact that the book is written from a background and understanding of coming from scripting classic ASP to truly understanding OOP is even better. Highly recommended.
|
