A must book for everyone who are looking for distributed data processing in .NET world with amazing technology Orleans. A masterpiece!!! Kudos to the writers who did excellent job here to show the technology with very clear and detailed coding examples. 5 star, Highly recommended!!! Must BUY!!!

I've read this cover to cover and downloaded the samples to look through the code.You definitely need to have a working knowledge of C#, but then I'd assume you wouldn't try to tackle Orleans without that.The book is really clear. It provides relevant information about architecture, but unlike many resources on actor type systems, it also provides details on how to actually make a decent program, starting with the basics, then going onto more advanced topics.It's far superior to trying to read the docs. There is a good tutorial on Pluralsight, but that doesn't go into the depth required to really 'know' orleans like this book does.A genuine 5* book.EDIT: Further to my previous review, I've been actively using Orleans for about a month. I keep going back to this book and it almost always has the answers. It really is fantastic.

As a member of the Orleans team, I was excited to see Bhupesh’s book come out, as I know from talking with the growing Orleans community that folks wanted new books and docs and samples. We spent some time during the development of Orleans 3.6 working on re-organizing our samples and being more tactical about the docs we’d put out. This book complements those efforts, demonstrates some of the more complicated topics when developing with Orleans, and informs folks of various design decisions the Orleans team made on the road to creating a truly performant, enterprise-grade, distributed programming framework. In fact, my favorite part of the book was how, early on, the author refers to Orleans in the way I refer to it in every conversation – Orleans is “distributed .NET.”The first few chapters do a fantastic job laying the groundwork on what distributed application development is, and it iterates through some of the patterns and challenges developers face when building distributed apps. Patterns like caching and CQRS are discussed, and the author lays significant ground establishing the fact that distributed systems are complex. Then, Orleans is introduced and shown, from an architectural viewpoint rather than a code-first stance, how Orleans solves many of the challenges distributed developers face. Possibly my biggest surprise of the book was during this introduction to Orleans, when the author carefully lays out some of the important concepts developers need to consider when choosing Orleans and does a fantastic job of summarizing why the Orleans team made some of the decisions. What’s more is the author takes the time to discuss not only when Orleans is an appropriate technology, but even when it isn’t appropriate. This helps the reader understand from an opinionated, honest viewpoint if the tech is right for them.From there, the book explores nearly every important concept a developer needs to be familiar with when developing distributed apps with Orleans. Using an easy-to-follow example of building a hotel software system (a great paradigm for a sample app, as we’ve all had to check into a hotel at some point!), the reader is shown how to implement the basics of the Orleans virtual actor model using cloud-native Grain implementations to persist object state. With regards to persistence, the example not only shows how to use the Cosmos DB persistence provider for world-class data distribution, but the example also goes on to show how to implement a fully custom storage persistence class for Orleans, without being intimidating or complex. One immediately sees the power and versatility of Orleans persistence.After this deep exploration into Orleans data persistence, the latter chapters go into great exploration of how to perform reminders in Orleans, goes into fantastic exploration of how to achieve pub/sub using Orleans observers, and summarizes Orleans streaming into a few-line demo that anyone can follow. Streaming with SignalR and Orleans has always been an intimidating topic for new developers, but the example in this book on achieving event-driven using Orleans streams is second-to-none.The last section takes the reader on a journey of deploying Orleans to Azure AKS and App Service, and carefully lays out all the individual steps required to make an Orleans cluster in the cloud. I would love to see an update to the book one day that includes a discussion of Azure Container Apps, but I know the timing of the book made including this somewhat difficult (the two had a very-closely aligned release date, accidentally).For anyone getting started with Orleans, this book is great. It takes you from Orleans Day 1 through some very complicated topics but is never intimidating. In spite of a few spelling or auto-corrective errors in the code, I didn’t notice any issues with the code examples. Just be careful if you copy them letter-for-letter, as there are some places where auto-capitalization might be breaking some of the type names. I noticed IObserver being changed to Iobserver, for example.

Perfect for developers starting out with OrleansThis book gives a good introduction to the challenges of building distributed applications and how Orleans can address some of the complexities.If you are a beginner at building distributed applications with Orleans then this book is for you. It covers all of the major functional pieces of Orleans and provides some guidance on how best to use Orleans.It would have been useful to have included more content around good actor designs and anti-patterns to avoid.If the Orleans documentation is not to your liking then this book would good place to start learning Orleans and well worth the money.If you are already an experienced developer with Orleans then this book won't teach you much you don't already know.

This is a good concise introduction to the virtual actor library of Orleans. If you're unfamiliar with actor pattern or working with clusters this resource can get you started. While it does not go to deeply into the async/await details of the Orleans scheduler and things like long running tasks it does give you a feel for how to use actors to accomplish a goal. The patterns section is rather mundane, but good as a refresher for developers who have forgotten some of the basic best practices.