|
| .NET Multithreading | 
 enlarge | Author: Alan Dennis
Publisher: Manning Publications
Category: Book
Buy Used: $149.56
Used (2) from $149.56
Avg. Customer Rating:  10 reviews
Sales Rank: 675827
Format: Illustrated
Media: Paperback
Number Of Items: 1
Pages: 360
Shipping Weight (lbs): 1.3
Dimensions (in): 8.7 x 7.8 x 0.8
ISBN: 1930110545
Dewey Decimal Number: 005.2
EAN: 9781930110540
ASIN: 1930110545
Publication Date: January 1, 2003
Availability: Usually ships in 1-2 business days
Condition: Moderate wear to outside. Overall solid. Ships next business day. Outstanding customer service and unconditional return policy.
|
| Editorial Reviews:
Product Description
With an understanding of the .NET framework, stable and robust multithreaded applications can be developed with minimal effort. Covering the topics related to multithreaded development, this book not only focuses on how a task is performed but also on the more important question of why these tasks are performed. The strengths and weaknesses of each approach to multithreading are analyzed so that programmers and developers can choose the appropriate approach based on their particular constraints. Complete coverage of multithreading development using the .NET framework in both Visual Basic .NET and C# is provided in addition to detailed analyses of threads, delegates, asynchronous execution, threadpools, and locks.
|
| Customer Reviews: Read 5 more reviews...
 Good starter for multithreading November 12, 2005
1 out of 3 found this review helpful
The book is a good starting point for multithreading. Especially helpful were the topics on wait handles and windows forms.
The chapter on Designing with threads was definitely to short.
I didn't like the mix of VB.Net and C#.
 Amazing Work and Best to Date on this Hard Subject September 9, 2004
8 out of 14 found this review helpful
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
 Good effort.... August 14, 2004
7 out of 8 found this review helpful
While I applaud the author for being the only one (that I know of) to write a book on .NET multithreading, this book has a few shortcomings. Namely, the book doesn't provide complete source for all the samples in both C# and VB, which forces the reader to understand BOTH languages, and the structure of the material does not really provide enough depth in some areas such as GUI multithreading. The book does provide useful information though.
BT
 Pretty bad July 6, 2004
9 out of 13 found this review helpful
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.
 No enough depth June 19, 2004
7 out of 9 found this review helpful
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.
|
|
|
| |
