Customer Reviews

Expert Service-Oriented Architecture in C#: Using the Web Services Enhancements 2.0

5 star:		(9)
4 star:		(4)
3 star:		(4)
2 star:		(2)
1 star:		(2)

 

 

At the time of this writing, the two topics arguably getting the most press, causing the most stir and generating the most buzz for web services aficionados are service-oriented architectures (SOA) for general audiences, and more specifically within Microsoft circles, Web Services Enhancements 2.0. Author Jeffrey Hasan (of whose work I'm a big fan, notably for his work in "Performance Tuning and Optimizing ASP.NET Applications" (...) paints a masterful picture of both topics in this outstanding work. This is a must-have if you've caught the WSE bug (pun accidentally intended) and need a practical guide to building better web services.

The material assumes a fair amount of .NET experience on the part of the developer, so the focus isn't on presenting exhaustive code examples and then describing them line by line; the intent is to give the seasoned .NET programmer a primer on how to make their apps more effective and more available to the rest of the world.

Using Microsoft .NET's associated technologies for XML Web services development, SOA is presented as being a maturation process for organizational web services, implementing a high level of abstraction, and therefore, a greater degree of universal appeal by promoting broad component reusability. WSE 2.0 is then tackled, diving into the major areas of consideration for SOAP messaging (security, encryption, routing, reliability, policy creation/enforcement etc.). Hasan describes the importance and role of SOA within large, disparate systems, preaching the gospel of interface-based systems and use of service agents (mid-tier objects managing communications between web services, business components and type/operation interfaces). This builds on the same concept discussed by Microsoft's Yasser Shohoud as a major building block for advanced web services development in his seminal book, "Real World XML Web Services" (...).

Hasan also offers a refreshing, pragmatic discussion on the debatable misconception of the true "benefits" of loosely-coupled web services within enterprise-grade distributed applications, presenting a decent case for tight coupling in certain situations.

The book's prime example of an evolving stock quote service is appreciated a lot more than weak "Hello World" examples, and discrete enough to exhibit most of the advanced features of WSE 2.0 with a SOA slant. Although one of the prime tenets for WSE 2.0 is to facilitate web services in a transport-agnostic manner, many of the examples are geared toward SOAP messaging using HTTP, to the enjoyment of ASP.NET developers - something that's largely missing in the market today, with many current examples being WinForms apps. Desktop developers may grunt at the lack of representation in the book's examples for using other protocols (i.e., TCP, SMTP, etc.), but it's a minor price to pay.

Also, the book does sufficiently and consistently make mention of WSE 2.0 development for those of us not married to Visual Studio .NET environments, even though the preference of the author appears to prefer using the IDE.

This book is wonderfully written, using a voice that makes topics that can be quite difficult to wrap one's brain around easier to grasp. The chapters are very logically arranged. However, the book's major selling point is the working code and practicality of its theories, boasting a heavy dollop of both that experienced devs will appreciate and quickly put to use. With only a sparse amount of syntax-centric documentation, Microsoft Hands-On Labs, articles, and in-print books available at the moment for WSE 2.0 programming, this book is easily the leading resource for concepts and code today on the subject.

On that note, the chapter on the future of messaging with Indigo was an unexpected but welcome treat. I also found myself using the book's appendix more than I do most, which consists of a well-rounded collection of top platform-neutral papers on WS-* initiatives. Very nice touch.

This is an advanced book, but not so far out there that a developer with a few months of .ASMX work logged won't be able to pick it up without sacrificing their social lives and/or sanity. The book's writing style, arrangement of content and oft-brutal honesty (i.e., working with X.509 certificates in WSE 2.0 is pretty easy, but still far from completely painless; VS.NET's Add Web Reference option can royally screw up your proxy classes, et al.) make this a real winner and a great addition to your library.

As Web Services start getting implemented, most of the work on understanding and implementing useful services has been dominated by developers in the Java/J2EE world. But Microsoft has built a parallel world around its C#/.NET platform. This book, then, can be seen as part of its response.

Hasan rolls out the now plentiful Web Services standards; like WS-Security, WS-Policy and WS-Addressing. He shows how these are implemented in .NET. But his book is more than a simple exposition of these standards. He puts all these within the context of a Service Oriented Architecture, where the programming language is (unsurprisingly) C#.

He tries a little re-education here. Many programmers meeting Web Services for the first time often have prior acquaintance with SOAP. What often ends up happening is that they then conceive of implementing a Web Service as a set of remote procedure calls, using SOAP to access the RPCs. Hasan shows that this is seriously non-optimal. Far better is a looser coupled message passing and processing design. It is within this context that most of the book is presented.

Along the way, he introduces WS Enhancements 2.0. This is used to define and deliver vital features for real world business applications. Features like secure messaging.

All that remains is for you to write an application.

I needed a book on the Web Services Enhancements (WSE) so I pre-ordered this one (there's not much else available). My expectations were low but to my great surprise this has turned out to be THE most useful computer book I have read all year. It currently sits on my desk next to Ingo Rammer's .NET Remoting (if you know this book, you'll know this is high praise).

As for specifics: this book is a solid reference on building Web Services/SOA solutions using the newly released WSE 2.0. My SOA project has demanding requirements: strict security and policy using certificates and role-based authorization. Plus we need to track messages in case of system failures. This book gave me all the information I needed to design and get started on my project. (It also has a 10 or 12 page references section on other books and articles that was very helpful).

For those who need it, the book provides an excellent discussion on XML messages, and how to construct schemas for custom data types. The book references design patterns and shows you how to use VS .NET tools to auto-generate proxy/stub classes based on your schemas. XML schemas = qualified custom types, and qualified types = fewer bugs! The second half of the book is solid WSE 2.0, reviewing all of the major specs that it implements using detailed code examples that I will use as templates for my own project.

This book is impressive because it provides an end-to-end discussion, from architecting the messages, and the services, to implementing security, policy, routing, addressing and even secure conversation. I came away with a clear understanding of the concepts and a solid understanding of how WSE 2.0 works, and how to implement it in my project. This book teaches, and it makes a great reference. I HIGHLY recommend this book: it will change your whole approach to building Web services, and it will save you valuable time.

The whole Web Service community is all abuzz about 'message-oriented' services versus 'RPC-style' services, and Hasan devotes a whole chapter to design patterns for building such things.

The thing is that there is no such thing as a 'message-oriented' Web Service, and so Chapter 3 is based on a fictional service type.

In the end, they're all Web Services, and rather than a clearly defined distinction between two discrete service types, there is actually a whole, finely graduated spectrum of parameter passing from simple stack parameters (RPC-style) to simple user-defined data types (RPC plus) to complex serializable objects (not-quite-messaged-oriented) to non-compliant document attachments (message-oriented plus), with any number of possibilities in between.

So those who insist that their designs are superior and more loosely coupled, or that they're providing "an integrated set of message endpoints" (p.37) simply because they're 'message-oriented', well, they're simply full of crap.

For a small example of how full of crap, look at page 28, "Finally, you learned that the Web method uses literal encoding and a document style, which are both required settings for exchanging SOAP messages." Where do I start in picking this apart? First of all SOAP messages are perfectly capable of RPC/Encoded as opposed to Document/Literal, but that's a nit. Second of all 'Document' and 'Literal' both have very specific technical meanings which, if explained here, WOULD actually illuminate the message vs. RPC debate, but no explanation is forthcoming. Not here, not elsewhere in the book. 'Document,' in particular, refers to the way the 'message' element in the WSDL file is declared, using either the 'type' attribute or the 'element' attribute, but you won't get that explanation in this book.

For a clear and factual and not-full-of-crap description of the ways you can pass data to and from a Web Service, read Chapter 15 of Richard Monson-Haefel's J2EE Web Services. Or to get right at the essence of Document/RPC Literal/Encoded settings, take a look in Chapter 5 at p. 137, where it's beautifully and simply and factually spelled out. That's the real deal, and even though it's not .NET, us .NET types will still derive immense amounts from it.

I should finish by saying that the rating retains three stars because the writeups on WSE 2.0 are pretty good. If you ignore all the airy-fairy (and mostly invalid) design pattern proclamations, and focus on the mechanics of XML Encryption and X.509 authentication, this book will still retain some value.

Jeffrey Hasan sure knows his stuff regarding WSE 2.0 and .NET. His examples and explanations are concise, complete and relevant. However: I am not at all impressed at how he approaches SOA in certain aspects. The major mistake he makes in approaching this delicate yet very popular theme, is the suggestion to create a .NET class to share types between service provider and service consumer (why not call them endpoints anyway??). This in my opinion breaks with one of the most (if not THE most) important desgn rules of service orientation: share the contract, not the class. The contract should NOT be in the form of a (proprietary) format like a .NET assembly, since this breaks with the idea that an SOA is applied to enable communication in a heterogenous environment. Use XSD instead!
Although the author clearly states that the option he presents is perhaps not the best, he keeps using it throughout the book in all the examples. It is a shame he misses the point here.

Apart from this (major) flaw, it is a great book for anyone who wants to learn more about WSE.

Developing distributed applications has become an increasingly indigenous part of a present-day developer's software life cycle. XML web services provide us an easier and standardized way to facilitate distributed communications. Service orientation takes this to another level, i.e. standardizing loose coupling of these services via contracts. Hasan's book provides answers for today's enterprise needs to learn and formulate their existing distributed communication frameworks as they shift towards Service Oriented Architecture.

This book is about technology we can implement today; it's neither a superficial overview of terminologies nor is it a manager's guide or executive summary. Expert Service-Oriented Architecture in C# is the answered prayer of various developers like me who were looking for a book which comprehensively addresses SOA in Microsoft.NET and couldn't find much help. There are only a handful of books out there on this thriving discipline, Service Oriented Architecture, and most of them fall short in technical implementation details. Most importantly it answered my own skepticism of having another fancy TLA (three lettered acronym) and how can it change the way we program distributed apps today. You'll have to read it to get the answer. Hasan acquired Masters degree from one of the top 10 US schools and you'll see the academic excellence in his writing. His technical fluency, vocabulary and in-depth explanation are salient features what give this cutting edge technology book priority over its counterparts, if there are any.

Expert Service-Oriented Architecture isn't just a good read about SOA but as title depicts, also a great reference for WSE 2.0. Individual chapters are categorized in a way that each chapter covers a topic of interest; WS-Security, Policy Frameworks, WS-Addressing & Routing, Design Patterns and so on. Therefore it provides excellent reference for WSE 2.0, a fairly new release from Microsoft providing support for latest developments in Web Services arena. Examples in this book are simplified but not trivial, simpler but not marginal and the style shows them coming from a software developer who encounter real world application architecture challenges. Jeffery touched various important topics concisely which a developers encounters either in practice or theory; for instance RPC vs. document literal invocation, web services building blocks, digital signing with x.509 certificate, integrating web services and MSMQ, XML schema definition etc. The last chapter, beyond WSE 2.0, I found very interesting since it addresses Microsoft's new breed of communications infrastructure built around the Web services architecture code name "Indigo". WSE 2.0 is here for a relatively small period of time till indigo kicks in with support for secure, reliable, and transacted messaging along with interoperability. However, future proofing the applications is what Hasan explained in this book and you have to read it to know it like Emerson said "Nature and Books belong to the eyes that see them".

Don't let the title of this book fool you. It's mostly about WSE. You will find some useful SOA techniques here but you will not find much how and why, tradeoffs, etc. that you would really expect to find in a more generic SOA title. The SOA that you get out of this book is all based around WSE.

If you are new to WSE then this book will serve you quite well. It goes into a lot of detail about how to set things up to get a WSE server and client running. It also outlines the WS-* specs that WSE is built on pretty well, although you will need much more information about the WS-* specs if you really want to understand them well.

If you are a WSE veteran that has been through all the lousy WSE documentation and have Google'd up all you can about WSE, then this book will be nothing more than a review and maybe a reference for you.

The book is laid out fairly well. Most of the how-tos are step by step guides to implementing the code. These how-tos can get a little tedious because sometimes they are just a reiteration of some fairly obvious code. The author's style is easy to follow and he ties the ideas and themes together. One fairly obvious omission from the chapters on security is how expertly WSE uses the policy documents to provide security without writing a lot of the manual WSE security code. Security and policy interaction is probably the least understood part of WSE. A solid chapter on how WSE uses the policy documents to set up security would have made this book invaluable.

I currently run a .NET user group so I know first hand that two of the most requested topics at my meetings are SOA (Service Oriented Architecture) and WSE (Web Service Enhancements) version 2.0.

Unfortunately this demand is hard to supply because there are simply very few speakers or books addressing these topics. This book delivers on both topics!

First of all, the title of the book is right on the money. Jeffrey Hasan does a great job explaining SOA concepts by demonstrating how WSE 2.0 allows you to implement them. Most tech books I read are not balanced, either it is too conceptual with no implementation details, or it only has implementation details and doesn't flesh out the concepts. This book is very well balanced.

You do not have to be a web services guru to read this book but it certainly helps to have some web service experience. This book would be useful for any developer/architect interested in the details of SOA/WSE and the future promise of indigo.

A major bonus that is included with this book is over 20 pages of great references so that you can dig even deeper into the topics covered in the book. The only thing missing from the book is the CD with all of the samples included.

I found the book to be very readable, and does a very nice job moving you from the traditional web service, to a message oriented one and then finally to a service oriented web service. That section of the book is one of the best at explaining why simply having web services does not mean you have an SOA.

I would strongly recommend this book, and it gets my personal highest honor, which means it is carried in my laptop case, so I always have it.

The web used to be so simple. You had a bunch of pages, and like magic you could hyper-link to an entirely different page. Then it made a lot of sense to back the web site with a database. That way a standard page could pull up different data as needed. Kind of like this page, where the book title and description changes within a standard template.

Then came web services companies that supply some particular kind of service. The first of these (or at least the first that most of us got exposed to) were companies that checked, authorized and/or billed credit cards so we could do e-commerce. The companies in this business established standards. And now the world has established standards for such service oriented architectures (SOA). As of the moment the world doesn't quite agree on what these standards should be. Two of the standards are incorporated in IBM's Websphere, and the J2EE.

This book is on the Microsoft version on the way it should be done, called Web Services Enhancements or WSE and specifically the 2.0 version. If this is what you are thinking of using, or have been directed to use, this book provides a great introduction to the Microsoft approach. It a beginners book so far as SOA/WSE is concerned, but you should have some experience in .NET and in programming.

This is the only book I am aware of that will show you how to correct all the inherent design issues (in terms of reaching an SOA) in using the 'default' Microsoft implementation of Web Services. It is astounding how many of my consulting customers I see who either don't know the WSE exists or know it exists but are reluctant to introduce change and stick with RPC style intrinsic Web Services in the base .NET releases. They lose SO MUCH and it is my job typically to move them to where this book describes (and I use it daily).

To do SOA correctly, it takes a shift in mindset that Microsoft does not really educate you on. Even the WSE documentation does not cover this. There must be other sources but I have not found them (to be clear I mean with such a Microsoft Focus - there are others but they don't have the details about the WSE 2.0 we need and he even shows how this can be done without the WSE in the beginning of the book - but I recommend using the WSE 1,000%).

For an SOA the XML-Schema is so important for both input and output of your richly defined services. As this book describes, UML is a create starting point (and the best tool I have found is an amazing tool called `Sparx Enterprise Architect' which goes from UML to XSD seamlessly).

1) If you are going to try to use Web Services, consider the SOA approach (they are absolutely not the same. WEB SERVICES != SOA by default)

2) This book will literally walk you through how you can make WEB SERVICES == SOA

3) It is not easy. Many are used to just adding a project and throwing an attribute on a method. You have MUCH more work to do, but the benefits are described in this book and they are well worth the effort unless you are doing trivial things with these technologies.

I know for a fact this will all get easier with VS 2005 (now a release candidate!) but for now, we must resort to these techniques (they are not all THAT bad). I know of at least one company that will make all this much easier (cannot say due to NDA but email me and I will see if I can get permission).

My clients often don't even know where to start, and they also fail to understand the importance of the WS-I for interoperability and what exactly an SOA is. Many believe it is just Web Services. I spend as much time educating as coding. Although this book is not really about interoperability, the WSE 2.0 SP3 today is required to reach WS-I interoperability (see the patterns and practices sample app on this), which is another reason you want this book.

In addition to this book (think in terms of 'Operational' - Code, 'Tactical' - Mid-Level Planning, and 'Strategic' - Longer Term Company Strategy) this is both an Operational and Tactical book. The strategic level leads us to Indigo. Well WSE 2.0 and WSE 3.0 are promised to get us there. So if you are still not using WSE 2.0, wow, just the fact you are not using the TCP channel and loosing all that potential performance is enough. But you are also not on the `train' of compliance Microsoft has made very clear and you are outdated, plain and simple. WS-I compatibility and a true SOA are motivations enough. If you are not using WSE 2.0 today (or 3.0 if you are using VS 2005) then you are loosing massive amounts in 'opportunity cost' and likely real cost.

See my recommend book list for more options and again, feel free to contact me for more info.

Kind Regards,
Damon Carr, CTO