In-depth analysis of C # Wonderful book reviews

In-depth analysis of C # Wonderful book reviews

Detailed information page address: http://www.china-pub.com/196689

This is a pure C # language book. It has little to do with. NET Framework and has little to do with CLR. As the preface of this book says, the author's intention is to explain the C # language so that every programmer who loves C # can work with ease, the final position of this book is a book on C # language from 1.0-3.0, and it clearly shows a change in C #1.0-3.0 code style.

I started to pay attention to this book since I made a reservation in China-Pub, because I read the book catalog and found that this book is definitely an advanced book, it is definitely a book that every reader who wants to improve their mastery of C # And use C # For design must read, when China-Pub releases the first and second chapters of this book, I will download and read it immediately. The first and second chapters are just the first part of this book, it is also the most basic part of this book. But it is very rare that this book has attracted me since the first chapter. In the first chapter, there is no drag, no if... Else, without while, without the native type structure of C #, directly go into practice, first give an example of C #1.0, the next step is the transformation of some programming styles in this example at 2.0, and the advantage of C #2.0 for 1.0 improvement. The next step is to enter the 2.0 syntax stage on the basis of 3.0, from the first example, we can immediately learn that C # has changed from 1.0 to 3.0 syntax and is now in practice. At the end of chapter 1, I reviewed C # And. the birth history of the Net Framework provides a reference table to help you sort out some history. However, this part is not very interesting. I am more concerned about how to use C # in practice, C # is a pleasure to use C # development with the powerful Visual Studio IDE.

The second chapter of this book first reviewed several of the most important basic technologies from C #1.0, and the first technology was commissioned, the author uses four sentences to explain how to enable delegated tasks. for developers who are new to C # and find it hard to understand delegated tasks, this short section is enough to teach you what to delegate and what to use it. The most important thing is that during the delegation process, I mentioned the memory leakage caused by delegated instances that I have never seen in all Chinese C # books at this stage, although I have already seen this on some C # blogs on the Internet, this book has a concise summary, which will at least remind readers that the original C # Will also leak memory, in addition, it is not surprising that delegation will leak memory. Here, I would like to give some suggestions for improvement to the publishing house. When this book talks about some important concepts, it uses obviously different fonts to differentiate them, the printed fonts used are not clearly differentiated, which makes it easy for readers to ignore these details. It is hoped that the publisher will be able to mark more obvious marks in key points when translating books in the future.

Chapter 3 begins with the second part of this book, which explains the correct use of some advanced language features in C #2.0 practice, this chapter is also the most significant improved Generic Model in C #2.0. First, we will review the basic usage of generic basics and generics in practice. The most important thing is to deepen and improve the content starting from Section 3.3. The following content is definitely worth reading by every C # programmer. I spoke about some advanced features of C #2.0 generics, I also gave some practical code segments, the extensive knowledge I have explained in this book, and I have never thoroughly explained all the Chinese C # books I have read. It is definitely not a general discussion, it's all about getting the most out of the box. It makes me laugh, but the premise is that we must have good basic skills; otherwise, it will be difficult to read. At the end of this chapter, we will compare the generics between C #, C ++, and Java, and mention the shortcomings of C # generics and their advantages over Java generics, at least for readers, there will be a clear comparison.

The fourth chapter of this book is the one I personally think the book is the least worth reading, because this can be empty type has some introductions in any more comprehensive C # language book, and the basic introductions are enough to learn to use this feature. This book only adds some experience on this topic, and the most valuable one is Section 4.4, based on the experience of the author, this section introduces the null-type novel usage (although it is a novel usage, it is actually an experience). This part of content is meaningful for the project practice.

The fifth chapter mainly reviews the delegation in C #1.0 and makes improvements to the Delegation after C #2.0. In this chapter, we will lay a solid foundation for delegation, so that everyone can have a good foundation to understand lambda expressions when entering C #3.0 lambda. This chapter is very helpful, and in the last section, it explains the scope of variables captured by closures that are not thoroughly understood by C # programmers.

Chapter 6 reviews the evolution of C # 1.0-c #2.0 iterators, from C #1.0 compiling complex code implementation iterators to C #2.0 adding the yield return keyword, it is very basic to generate the iterator code in the compiler. It is the content that every C # programmer should have mastered until the first practice starts in section 6.3. Here are a few examples of smooth and vigorous development, this chapter introduces the new iterator mode in the last section of this chapter, that is, the new implementation mode that may be introduced in the library in the future, very happy.

Chapter 7 provides a unified explanation of other new features in the C #2.0 syntax. Each new feature is short in length, but it is clearly explained, I believe that readers can also learn some new experiences and understandings from them.

Chapter 8 begins to explain the new features of C #3.0 in order to guide the most innovative LINQ language in C, all of the above is to lay a solid foundation for the subsequent LINQ. This chapter mainly describes some of the most basic automatic implementation attributes, implicit types, objects, and set initiators in section 3.0, implicit array and anonymous type. In fact, these technologies keep up with Microsoft. net Framework update programmers should have been very familiar with, each basic C # book is very clear about these basic explanations, readers familiar with the technical points in this chapter can skip this chapter. Chapter 9 begins with the climax of this book. This part explains the new features in C #3.0, and the difficulty gradually increases, after all, because C #3.0 integrates the foundation of C #1.0, the improvement of C #2.0 has reached the station of functional programming. Now, due to the increasing popularity of parallelism, anders has already seen this point, so the C # function is also an inevitable development, and at the same time introduces the extremely important technology of LINQ, laying a solid foundation for the next generation of Plinq, if you are a C # enthusiast, you must be familiar with the new features of C #3.0. However, the difficulty of this chapter makes an intermediate programmer feel that they will not spend their time in this chapter, the technical points of this chapter are both very basic and important. If the foundation is solid enough, I believe other readers will learn how to use C #3.0 for design in this chapter, the most difficult part of this chapter is in the last section. If the reader has a C ++ background, it will be much easier to understand this section, this is because the general type of C ++ is enhanced and complex.

Chapter 10 is the last chapter of the basics of LINQ. This chapter introduces the extension method. First, this chapter introduces some tips for using the extension method. Next, we will go to the most meaningful part of the extension method, it is also the essential significance of LINQ, that is, stream operations on data, such
VaR collection = enumerable. Range (0, 10)
. Where (x => X % 2! = 0)
. Reverse ();
Such forms must be compared:
VaR collection = enumerable. Reverse (
(Enumerable. Where (
(Enumerable. Range (0, 10 ),
X => X % 2! = 0 ));
This form is easy to understand. The above Code is based entirely on human thinking, while the latter requires people to read the code in Reverse Thinking Mode. This chapter reminds readers that not all static helper classes should be extension methods, but should be used rationally. Writing extension methods should always be a conscious decision, instead of getting used to it.

Chapter 5 introduces the main drama of this book, "LINQ". This chapter is also a difficult chapter in the book. With the foundation above as a foreshadowing, it is easier to understand this chapter, this chapter is also the most important thing to learn about in LINQ. Of course, it is still the style of the book. Starting from the basic syntax features, it has been gradually complicated until all the syntax features of the linq toobject have been explained, of course, these syntax features can be fully used in the following functions .......

Chapter 5 naturally explains other providers of LINQ together. Due to the study in Chapter 11, this chapter only introduces other providers and implements step-by-step learning, similarly, I agree with the author. To learn about LINQ, please read the best book "LINQ in action" in LINQ. This book has already been introduced by the Turing Program Design Series of the people's post and telecommunications Publishing House, and the translation quality is also very high. This book is also the best book I personally think to learn about LINQ.

Chapter 2 is a summative chapter of this book. In general, this book is a very good learning book with C # language features. It is definitely worth reading and has said so many advantages of this book, I also talk about the shortcomings of this book. I personally think that there are too few technical knowledge points in this book. Based on the author's understanding of the C # language, if he can add more programming skills using C # in the book, this book can be perfect. In any case, this book is a book that every intermediate C # programmer must read at a higher level. I personally strongly hope that the second edition of this book will continue its connotation, I will give a deep explanation of C #4.0.