What do you think?
Rate this book
Concurrency in .NET: Modern patterns of concurrent and parallel programming
Concurrency in .NET teaches you how to build concurrent and scalable programs in .NET using the functional paradigm. This intermediate-level guide is aimed at developers, architects, and passionate computer programmers who are interested in writing code with improved speed and effectiveness by adopting a declarative and pain-free programming style.
- GenresProgrammingSoftware
568 pages, Paperback
Published July 13, 2018
10 people are currently reading
49 people want to read
Ratings & Reviews
Friends & Following
Create a free account to discover what your friends think of this book!
Community Reviews
Displaying 1 - 4 of 4 reviews
May 26, 2019
I had recently read Java Concurrency in Practice. I picked up this one in part hoping to see corresponding treatment for .NET. The book did not deliver.
On a surface level, a part of it talked about rather basic and abstract ways of dividing a task to be executed in parallel, and how it can improve overall performance. Those parts seemed needlessly elaborate using many words with comparatively little substance.
The other thread in the book is showing code samples presenting various tools in the standard library to implement those, like mailbox processors in F# or TPL. This was comparatively the strongest suit of the book.
Both threads suffered considerably from poor editing. It was so bizarre, I had to double check if I wasn't reading early access edition. I wasn't. This includes swapping descriptions of parts of the source code, text referring to aspects of code samples that weren't there, as well as confused descriptions of some of the basic concepts, e.g., accumulator as used in functional implementations of various recursive algorithms.
My favourite will probably remain expression of "performance and speed," appearing several times in one of the chapters, as if they were different things. There was nothing in the book or that chapter suggesting that should be the case.
I had read a number of Manning books, and I was never disappointed, but this is beneath my basic expectations towards a book on technical subject.
Then again, I don't think I would give it more than 3 stars regardless. The Java-related book I mentioned earlier made a point of explaining to the reader some basic principles that they could use to implement their own concurrency primitives. While some of it is actually present here as well, it lacks presentation of fundamentals, like how virtual machine's memory model interacts with concurrency.
In that way, this book seemed to lack depth outside of the code samples.
On a surface level, a part of it talked about rather basic and abstract ways of dividing a task to be executed in parallel, and how it can improve overall performance. Those parts seemed needlessly elaborate using many words with comparatively little substance.
The other thread in the book is showing code samples presenting various tools in the standard library to implement those, like mailbox processors in F# or TPL. This was comparatively the strongest suit of the book.
Both threads suffered considerably from poor editing. It was so bizarre, I had to double check if I wasn't reading early access edition. I wasn't. This includes swapping descriptions of parts of the source code, text referring to aspects of code samples that weren't there, as well as confused descriptions of some of the basic concepts, e.g., accumulator as used in functional implementations of various recursive algorithms.
My favourite will probably remain expression of "performance and speed," appearing several times in one of the chapters, as if they were different things. There was nothing in the book or that chapter suggesting that should be the case.
I had read a number of Manning books, and I was never disappointed, but this is beneath my basic expectations towards a book on technical subject.
Then again, I don't think I would give it more than 3 stars regardless. The Java-related book I mentioned earlier made a point of explaining to the reader some basic principles that they could use to implement their own concurrency primitives. While some of it is actually present here as well, it lacks presentation of fundamentals, like how virtual machine's memory model interacts with concurrency.
In that way, this book seemed to lack depth outside of the code samples.
January 15, 2020
I never got to the end of this book because of how poorly it was written. Every explanation is done in a long-winded manner that only serves to confuse me more than it does explain things. The first chapter starts off with an explanation about the difference between parallelism and concurrency; it took this author an entire chapter to confuse me about the concept, and it took the authors of The Pragmatic Programmer (which I started reading a while after) only one paragraph. I was forced to seek external sources just to understand the simple concept.
There are a litany of errors, ranging from typos to copy-pasted links and sentences. I took to pulling out an orange highlighter every time I read just so I could record all the errors. Most don't hamper your understanding, which is good, but the real issue is that it speaks to the quality of the book and its editing. If they can't even catch such simple errors, how can I trust the book?
The book states early on that a knowledge of F# is not necessary to read, and that you can get along just fine. Yet every chapter, half the pages will be in F# and expect me to understand what the language is doing. And if you are going to read the book, do yourself a favor and don't read the appendix on F#; it will only serve to confuse you and in some spots give false information.
I really wanted to like the book, I have purchased many Manning publications in the past, but there was just too much wrong with it. I may try again some day when I have more time on my hands to really focus in and do web-searches for all the concepts, but I imagine I won't get a full benefit from the book until I know F# in depth.
There are a litany of errors, ranging from typos to copy-pasted links and sentences. I took to pulling out an orange highlighter every time I read just so I could record all the errors. Most don't hamper your understanding, which is good, but the real issue is that it speaks to the quality of the book and its editing. If they can't even catch such simple errors, how can I trust the book?
The book states early on that a knowledge of F# is not necessary to read, and that you can get along just fine. Yet every chapter, half the pages will be in F# and expect me to understand what the language is doing. And if you are going to read the book, do yourself a favor and don't read the appendix on F#; it will only serve to confuse you and in some spots give false information.
I really wanted to like the book, I have purchased many Manning publications in the past, but there was just too much wrong with it. I may try again some day when I have more time on my hands to really focus in and do web-searches for all the concepts, but I imagine I won't get a full benefit from the book until I know F# in depth.
August 8, 2020
One the best books I've read in a while about concurrency and frameworks out there in .NET. Big plus for F# examples and very helpful annotations.
February 23, 2022
Good book about modern C# vs F# concurrency.
Displaying 1 - 4 of 4 reviews