Developing Service-Oriented AJAX Applications on the Microsoft® Platform (PRO-Developer) |  | Author: Daniel Larson
Publisher: Microsoft Press
List Price: $39.99
Buy New: $6.44
as of 11/22/2009 03:14 CST details
You Save: $33.55 (84%)
New (45) Used (19) from $6.34
Seller: outlook_books
Rating:  10 reviews
Sales Rank: 119989
Media: Paperback
Pages: 320
Number Of Items: 1
Shipping Weight (lbs): 1.5
Dimensions (in): 8.8 x 7.3 x 1.3
ISBN: 0735625913
Dewey Decimal Number: 005.2
EAN: 9780735625914
ASIN: 0735625913
Publication Date: November 12, 2008
Availability: Usually ships in 1-2 business days
| |
| Features:
|
| Also Available In:
|
| Similar Items:
| |
| Editorial Reviews:
Product Description
Make your rich Internet applications easier to write, manage, and update by leveraging ASP.NET AJAX, the Microsoft AJAX Library, and the Windows(r) mmunication Foundation Web programming model. With extensive code samples and guidance from an AJAX expert, you ll learn to separate the Web services API layer and user interface a service-oriented approach that allows you to easily add features and integrate components as your application evolves. Discover how to: Employ an architecture pattern that highlights the Web services API Tap the AJAX Library framework, extensions, namespaces, and runtime controls Enable authentication, profiles, and authorization using AJAX application services Apply JavaScript models for object-oriented development and XSLT for client-side rendering Use the AJAX Library event-based programming model and component-based JavaScript architecture Deploy Web services and AJAX controls to Windows SharePoint Services(r) 3.0 and Microsoft Office SharePoint(r) Server 2007
|
| Customer Reviews:
Showing reviews 1-5 of 10
 After this book you will hate Ajax, WCF and SOA May 22, 2009
Valeriy Reshetnikov (Gaithersburg, MD United States)
2 out of 3 found this review helpful
I always thought the good book has to be based on the little more than excellent technical knowledge, may be some writer's talent is required? This book contains the great technical knowledge about Ajax, WCF, SOA and many other related things, as well as all signs of the author's helplessness to organize it in appropriate manner: infinite repetitions and reiterations; innumerable references to following chapters, unnecessary using of (yes, it's new!) other technologies, etc., etc. Plus push-into-sleep language. After third chapter you start to feel you hate Ajax, WCF, SOA and all other related things in this book.
As usual, small details impact us most of all. For example,
(A) From the book (page 44):
public void Create(string catalog)
{
var dataImplementation =
new DataAccess(HttpContext.Current.User);
dataImplemenation.CreateCatalog(catalog);
}
(B) From book's source code:
public void Create(string catalog)
{
DataAccess dataImplemenation =
new DataAcces(HttpContext.Current.User);
dataImplemenation.CreateCatalog(catalog);
}
Of course, dynamic C# (var dataImplementation = ...) does not compile in the VS2008 SP1 without DLR framework! But what the reason we have to use dynamic C# here at all?
It is my first negative review, and the last thing which push me to write: it is a coincidence I found when I repeatedly went through reviews of this book (when I finished third chapter): many positive reviews were wrote by people from the same state where author from. I do not mean anything and, of course, it is a coincidence. I just want to point your attention to interesting situations sometimes happen.
I may recommend this book only for people who like the dullish language of the technical documentations or Oracle Press books. For me I took a several lessons:
1) very careful buy the first book of the former diploma-with-honor students;
2) I will compare where the author and book reviewers from;
3) do not skip one-star rated reviews, as I did before :)
The Info About Integration of Sharepoint and WCF Really Worked For Me May 17, 2009
William Henkel (Denver, CO)
For me, there are two kinds of (tech) info that I need; firstly, a piece of info, like maybe a code snippet, that I need 'right now' to solve some issue at hand, and for this, I usually goggle around. Secondly, I need info to learn some topic, like starting from 'square one', then letting the stream of info sink into the `gray matter' as I advance through the subject. For this, a book(s) is usually the best way to go for me.
As a Sharepoint developer at a state university, there is a looming MOSS project that may call for a service oriented approach to build and present data from a warehouse. In particular, a WCF architecture may be desirable over web services. However I wasn't able to find a lot of info regarding how to implement WCF in MOSS. Well, here's where Larson's book, chapter 11 in particular, came to the rescue. For example, as Larson details how to deploy the AJAX Runtime through the ScriptManager control, he points out that Sharepoint is not your typical web application and proceeds to discuss 'Sharepoint-esq' solutions through code examples. Larson continues to build on the presented info by providing code for a chat application that implements WCF in MOSS.
This book has been a big help to me - 4 stars, bordering on 5.
 Good Information, Disjointed Source Code Examples March 9, 2009
Mark Phillips (NY, NY United States)
1 out of 1 found this review helpful
This book contains some excellent information about ASPNET AJAX and WCF. However the downloadable source code does not match the examples in the book and some do not work. If the reader intends to go step by step with the author, he cannot quickly move from the book to observe a running application that demonstrates what is being taught. The source code presentation in relation to the books presentation is disjointed and a serious problem. If the source code were more compatible with the flow of the book, I would give this book a higher rating. (Note, I am only on Ch 03, but find this extremely frustrating)
 highly focused - read the title January 27, 2009
M. Robbins (Colorado)
1 out of 1 found this review helpful
Daniel Larson has written an excellent book about Developing Service-Oriented AJAX Applications on the Microsoft Platform. The title is long because the book is highly focused on the creation of web applications cleanly architected for the Service-Oriented model. This is a rifle - not a shotgun - approach to this important topic.
He maps us through the labyrinth of choices in the DOT-NET framework, keeping us on a path to highly maintainable, scalable, extensible and reliable web applications that offer those benefits because of their service-orientation. He is disciplined enough to avoid the temptation of shortcuts such as server-side controls and the famous UpdatePanel Control that employ AJAX quickly but with a price to pay later during code revision and application maintenance. But, Larson is not motivated by purism for purism's sake. He explains that other methods may be our best choice for adding AJAX function to existing applications. But, when the application is new and the Windows Communication Foundation (WCF, DOT-NET 3.0, 3.5) is at hand, Daniel makes the case for Service-Orientation.
Larson describes how to use the newest Microsoft AJAX (JavaScript) engine that can now be cleanly installed on the client-side of a web application where it can handle cross-browser issues and maximize code reusability. The latest version even handles page history so your application does not break the back button of the user's browser. Unbroken back-button is a big usability advantage in itself. But, for a truly rich user interface you may have to turn to additional JavaScript Engines that specialize in manipulation of the DOM. Larson's focus is on the plumbing, the data-exchange foundation of your web application and that is a key part of this book's disciplined focus. Being able to architect your data connections letting Microsoft Dot-Net provide for server-side programming while Microsoft's AJAX engine provides for client-side (Javascript) programming enables us developers to focus more time on solving business problems and less on time technical problems.
A focused book like this is wonderful if its focus is on exactly what you are trying to do. Otherwise, it will likely miss your target. If you do not want to separate client-side code from server side code and are happy with some of the complex Microsoft controls, or if you absolutely need their functionality, then you may not find this book helpful since, frankly, there is no way to mix client-side and server-side in a blender and wind up with Service-Orientation. In simple web applications, complex controls can be amazing, witness all the wonderful examples on the ASP.NET website. But, if you need to move diverse data, extend your application on a dime and maintain it on a nickel, then you will need Service-Orientation and Daniel Larson's book is the shortest root from scratch paper to working application. One other example, mentioned earlier, where a Service-Orientation may be suboptimal is when you are "AJAX-enabling" an existing application.
If you are building a new web-application using Microsoft Windows Communication Foundation (WCF) and Microsoft AJAX then a Service-Orientation is likely to be in order and Daniel Larson's new book is an excellent roadmap from here to there. Even if you have excellent and comprehensive texts for the framework as well as your programming language, this book is worth its price to lead you through the maze efficiently, that is, if you value your time and need a service-oriented AJAX application.
A great book on developing AJAX websites on the MSFT platform December 30, 2008
James Shaw
1 out of 1 found this review helpful
MSFT has a tendency of providing a plethora of options to develop the same kind of application, and not all of them good. I really appreciate Daniel's calling out for the pure AJAX approach of developing today's websites, rather than using AJAH techniques like UpdatePanel, and at the same time he explained well the benefits: REST responses' cachability, decoupling of the services and UI, the re-usability of the services, etc. Around the same time I have also reached the same conclusion myself, after much frustration with the lack/difficulty of direct control from server controls and their post-back model, AJAX control toolkit (which until recently is still a server programming experience) and UpdatePanel.
Overall this book is excellent; there's some minor room for improvements like the index doesn't seem complete; I find myself spending more time than I should searching for stuff in the book since index is pretty thin. Also the only part I'm not as sure about what Daniel said is on the client-side data-binding using XSLT; it kind of defeats the purpose of compact response of the readily usable JSON data. The up-coming MS AJAX 4.0 has the client-side templating feature that parallels the server control's templating scheme; perhaps that's probably a better approach (granted I still have to study on these client-side data-binding options more).
MSFT is finally coming back on the right track and embracing programming in HTML, HTTP, and Javascript rather than the leaky abstraction that is the web form, and this book is very helpful in programming in this pure and more effective way.
Showing reviews 1-5 of 10
|
|
|
|
