Rating: 
Summary: Presuming familiarity with core computer programming basics
Review: .NET Multithreading by Alan L. Dennis (a computer consultant and instructor of programming at the University of Phoenix Online) is an authoritative and "learner friendly" guide to performing multithreading applications with C# .NET or VB.NET. Presuming familiarity with core computer programming basics, the informed and informative text does not require any prior knowledge or experience in multithreading. Individual chapters address the life cycles of threads, how to concurrently control them, the ThreadPool class, delegates and exceptions, multithreading in J#, and a great deal more. To put it simply, .NET Multithreading is a first-rate resource for anyone looking to improve their software's performance through multithreading, and without having to invest too much time and energy in learning the mechanics of doing so.
Rating: 
Summary: Good coverage of topics - plenty of mistakes
Review: I bought this book to get a clear picture of what .NET has in terms of thread support. This book gives you that. It is reasonably well written, but the editors have failed badly because there are numerous typographical mistakes and inconsistencies between the text and the quoted code examples.Alan succeeds in getting the ideas across, but unfortunately the examples that can be downloaded from the web site are tough to find because the directory structure of the downloaded code does not correctly match the sections in the text that it is supposed to match to. I'd definitely still recommend getting the book. It should be mandatory reading for anyone switching to .NET programming, especially VB people who typically are not experienced with real enterprise application development.
Rating: 
Summary: Good overview
Review: I have done a lot of Symmetric Multi-Processing (SMP) work in Win32 and I was looking for a text that would show me the classes and design patterns used to build multi-threaded applications in the .NET Framework. This book was quite good for that purpose. If I had no exposure to multi-threaded programming prior to reading this book, I still think I would have found it very useful and probably a bit more challenging. This book has plenty of C# and VB.NET examples. However, as a veteran C++ programmer, I don't read VB.NET all that well (because it looks so clunky) so I found myself wishing that each example was shown fully in both languages as some other .NET books are beginning to do. Other than that, I recommend this one for anyone who wants to build robust, multi-threaded .NET applications. The author's language and approach to the material are both very good.
Rating: 
Summary: Light weight, without much depth
Review: I've been working with C# .NET and bought the book to see if it could shed some light on .NET threading. Unfortunately, the book lacks depth. The threading model in C# is a completely different model than Java. In java, threads are owned by parent thread or set as a daemon thread. In C#, the threading is client centric and designed for atomic processes. For example, the book doesn't cover examples where an application has persistent threads running as server processes to maximize object/thread reuse for stateful applications. Not all uses of threading is simplistic as the examples provided in the book. Overall, the book is a decent intro, but it's far from being thorough and complete. In server environments where you want a master thread to manage a pool of 20-100 threads, .NET simply isn't designed for it. The maximum threads in threadpool class is 25, which makes it totally inappropriate for many heavy-weight applications. For hard core programmers, the book is pretty useless and won't provide any insight.
Rating:
Summary: No enough depth
Review: The authors are obviously trying very hard to "delve" into the details of .NET multithreading, but their performance is really disappointing. My impression is that they have inadequate training in operating system essentials to go into the "threading" topic. The other day I picked up "Multithreaded Programming with Java" published by Prentice Hall PTR, which gave a thorough treatment on the fundamentals of threading. The difference between a real industry expert and a wannabe is too obvious. So is the difference between an established, respectable publisher and a new player.
Rating:
Summary: No enough depth
Review: The authors are obviously trying very hard to "delve" into the details of .NET multithreading, but their performance is really disappointing. My impression is that they have inadequate training in operating system essentials to go into the "threading" topic. The other day I picked up "Multithreaded Programming with Java" published by Prentice Hall PTR, which gave a thorough treatment on the fundamentals of threading. The difference between a real industry expert and a wannabe is too obvious. So is the difference between an established, respectable publisher and a new player.
Rating:
Summary: Good, but could be better
Review: The book gives a good explanation on .NET Threading. The problem is that the code-examples are alternated between VB.Net and C# along the book. As a C# developer, I don't like to read code in VB.Net. It made things more complicated to me. I suggest the author to release two different editions, one for each language. Or use all the code syntax in C# (which is considered the "main" .NET language).
Rating: 
Summary: Pretty bad
Review: This book is just plain bad. The source code is awful. Not only is it poorly formatted, sometimes incorrect and in an annoying mix of C# and VB.NET, but the examples are often horribly incomplete. I usually read programming books by skimming the source and text at the same time but I can't do that in .NET Multithreading because many of the examples are just snippets and are lacking in important information such as types. I was often forced to either slog through the text or hit MSDN to figure out what was going on. The other reviewers' comments on the lack of depth are right on the mark. You'll get enough information to write trivial little applications, but that's about it. To its credit, the book does do a decent job of warning you about multithreading problems, though I think it should do a better job of instilling a healthy sense of fear in threading newbies. If you really want to understand multithreading, I'd recommend reading Tannenbaum's OS book for the basics, followed by the MSDN literature for .NET specifics. It also helps to read a book on Win32 multithreading so you can understand what's going on underneath the .NET layer. You should also read Debugging Applications for Microsoft .NET and Microsoft Windows. I probably would not buy this book again.
Rating:
Summary: Pretty bad
Review: This book is just plain bad. The source code is awful. Not only is it poorly formatted, sometimes incorrect and in an annoying mix of C# and VB.NET, but the examples are often horribly incomplete. I usually read programming books by skimming the source and text at the same time but I can't do that in .NET Multithreading because many of the examples are just snippets and are lacking in important information such as types. I was often forced to either slog through the text or hit MSDN to figure out what was going on. The other reviewers' comments on the lack of depth are right on the mark. You'll get enough information to write trivial little applications, but that's about it. To its credit, the book does do a decent job of warning you about multithreading problems, though I think it should do a better job of instilling a healthy sense of fear in threading newbies. If you really want to understand multithreading, I'd recommend reading Tannenbaum's OS book for the basics, followed by the MSDN literature for .NET specifics. It also helps to read a book on Win32 multithreading so you can understand what's going on underneath the .NET layer. You should also read Debugging Applications for Microsoft .NET and Microsoft Windows. I probably would not buy this book again.
Rating:
Summary: Amazing Work and Best to Date on this Hard Subject
Review: This book pulls no punches. It gives you the facts that would take years to decipher from the many of MSDN articles, and tidbits, which often contradict each other. If you are doing ANYTHING with multithreading you need this.
For example, the ReaderWriterLock is often worth the extra few lines of code then the C# lock command (shorthand for the Monitor class). And you should try to never use lock(this) or lock(typeof(ClassWithStaticMember)).
That is just lazy coding as you lock the entire item from ALL threads. Even when you use Microsoft's attributes under the covers, they lock the entire class!
For scalable code, locks and critical sections need to be as small as possible. This book will make sure you understand what is happening and what ALL of your options are. I do not think any expert C# developer can call himself or herself an expert if they do not read this book in detail or have not gained the knowledge some other way.
My only criticism (and it is a small one) is...wait.. It IS in the book and I just missed it! Never mind. I though they left out this but MANNING and the Author didn't
* Synchronized contexts. You can use the SynchronizationAttribute to enable simple, automatic synchronization for ContextBoundObject objects.
* Synchronized property. A few classes, such as Hashtable and Queue, provide a Synchronized property that returns a thread-safe wrapper for an instance of the class. See Collections and Synchronization (Thread Safety).
* Synchronized code regions. You can use the Monitor class or compiler support for this class to synchronize only the code block that needs it, improving performance.
* Manual synchronization. You can use the various synchronization objects to create your own synchronization mechanisms.
The common language runtime provides a thread model in which classes fall into a number of categories that can be synchronized in a variety of different ways depending on the requirements.
Anyway, I am picky as heck and this book it simply fantastic. I use many sections as interview questions for new hires.
Kind Regards,
Damon Carr, Chief Technologist
agilefactor
www.agilefactor.com
| 
