Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Silverlight + CRM Paperback – August 1, 2011
Featured titles for business communication. Sponsored by McGraw-Hill. Learn more.
About the Author
Top Customer Reviews
It's roughly 420 pages long and strikes a good balance between going into detail and covering all the relevant aspects of development.
It begins with an introduction to Silverlight and why it matters in CRM 2011 development. It progresses to Getting Started with Silverlight. There are a ton of books that cover Silverlight development and this isnt' meant to be the definitive guide to Silverlight. However it goes into enough depth that most experienced devs new to Silverlight will be able to get where they want or find the additional information they'd need to get them there.
The next chapter moves on to discuss the role of XAML in silverlight development. The same point I made in the last paragraph holds true here, it's a good introduction to XAML and if you need more information there's a ton of resources out there to find it.
Chapter 4 is where things directly related to CRM/Silverlight dev takes hold. It introduces the Silverlight toolkit and shows you basic scenarios into creating Silverlight controls. Without understanding this - there's not really anywhere to go w/ respect to CRM. so this chapter lays the groundwork for building Silverlight/xap resources which you can consume within CRM. After the basics of building controls, it moves on to the two most directly relevant topics - DataBinding and Navigation. If you're using CRM and Silverlight, it's virtually certain the scenario you're working with involves extracting existing CRM data and showing it somehow. Databinding is the mechanism that you'll use most often to take data and display it. Since one fo the main benefits of using CRM 2011 is the fact it gives you a 360 view of what you're modelling, linking is critical. Without it, you wouldn't be able to easily drill into things which would make crm less useful and flexible. Navigation isn't tremendously complicated, but it definitely needs covered. In fact, navigation is the first part that's directly related to CRM as opposed to standard silverlight scenarios.
From there he moves on to out of Browser support. This might seem like an area that's mostly reserved to edge cases, but it's not. Moreover, this out of browser support needs to be done right or it'll deluge users with a lot of warning feedback and can/will greatly diminish user experience. Not the most sexy or exciting topic, but one you need to be familiar with and the balance of coverage is right where it should be (letting you know what's necessary to get things right without boring you to death b/c of the subject matter).
The following chapter covers MEF which I have mixed feelings about. Honestly, it feels a little out of place and not necessarily a must have topic for CRM development. On the other hand, it's tremendously useful and the coverage is great. So even though it's not as directly applicable as other areas, it's no doubt a valuable chapter.
After the MEF discussion, it delves into some deeper aspects of Silverlight. He covers Usability which is particularly useful b/c Dave has been so heavily involved with CRM for so long. Usability is a broad topic and there are many universals, but Dave's background and experience add quite a bit to it and it's excellent guidance.
there's a short digression into SketchFlow that spans about 15 pages. If this chapter wasn't added it wouldn't detract from the book but I guess it still has its place. Once this discussion is over, things start moving quickly and get useful very fast.
It begins with discussing the interaction of the Page object model and data and how UI components work.
Next the discussion moves to OData. IMHO, this is probably the most useful and necessary chapter in the book. even if you're new to OData by the time the chapter is done, you'll be comfortable using it. It's concise but thorough and Yack did a superb job of this topic (which is absolutely critical to many CRM 2011 scenarios). After the intro, he moves into more advanced aspects of OData (titled unsurprisingly enough "OData Beyond the Basics"). One area that might be considered a digression is the coverage of the Async CTP. Digression or not, I'm very glad he brought it up and thinking about async operations is very important to usability. It's probably better described as "Icing" than a digression b/c it's definitely helpful material that adds a lot to the discussion.
WCF comes up next. In all but a few scenarios (where you query the Filtered views directly) you'll be interacting with CRM through the Web Service (OrganizationService or DiscoveryService primarily). There are many ways to interact with the services (using the sdk libraries, using a directly service reference or using the orgservicecontext) and there's really no way to develop with CRM without using WCF. Yes, WCF abstracts a lot of the raw stuff away and from a purely syntactical and coding POV, you hardly know WCF is there. However the more you know about WCF the better you'll be able to architect performant and secure applications.
The next two chapters conclude the discussion - Application Architectures and Silverlight Debugging. The last one doesn't need much discussion. The one before it though definitely does. Dave is one of the most well known names in the Microsoft CRM space. He's worked with countless clients and knows how to use CRM as both a traditional end user or a developer. This chapter is a wrap up of many best practices and pitfall avoidance techniques based on Dave's experience. So many CRM deployments fail b/c people for some reason develop CRM projects differently than they would traditional applications. Good software practices are good software practices and he drives that home. Although there are some subtle differences, things that make other software projects successful are completely applicable here. .NET is a mature framework and there's a ton of useful 3rd party libraries and frameworks. This discussion is concise and to the point, but a big part of what makes this book great.
I feel a little guilty giving it 4 stars instead of 5 and I wish there was a 4.5 rating I could give it. My only complaints about it are that I wish there were more samples as they really help see how things work and how to make them work. Particularly on the CRM side, I think the book would have greatly benefitted from more samples. Including them as resources and packaging and deployment were something that could have been covered in a little more depth. It's not that there's a deficiency by any regards, I just think a little more in this area would have driven the concepts home a lot better.
In any case, it's not a cheap book and not something that you'll typically find sitting around a Barnes and Noble. IMHO, it's a must have book for any serious CRM 2011 developer and after going through it - you'll be in a good place to start using silverlight and odata. You'll have the fundamental skills you need to find additional information if needed to do more complex tasks. The best compliment I can pay a book is to say that I'd buy it again and recommend it to others. I've ordered copies for each member of my development team and think anyone serious about CRM 2011 development should pick up a copy.
If you plan to use it in your implementation this book is an essential resource.
As per previous book, David explores real cases with pratical examples and full source code. The book starts from basic concepts up to a deep development using design patterns. Also, it's useful the chapter about Sketch tool that can help during the first phase of the project.
We had ordered this book from amazon. After using it I was disappointed of not having found the source code as promised by the author on [...]
The book is helpful and I appretiate that and the language is suitable for a light read. It is comparitavely a thin book and is more of a guide telling the developer where to head. Many ideas such as using Rx with Async CTP really great and helpful.