Author: Benjamin Perkins, Jacob Vibe Hammer & Jon D. Reid
Audience: Complete beginners/ Beginners with OOP background
Reviewer: Mike James
C# is still important, perhaps still growing in importance, and we need books to get started.
However, writing a book on C# has quite a few problems. If you want it to be relevant to how C# programming is done you can't ignore Visual Studio, which changes quite rapidly. In addition the whole of the .NET infrastructure is undergoing a radical change to cross-platform, open source, and when you throw in the move to Universal Windows Apps things are even more unstable. The whole eco system is huge and sprawling and you can't really hope to capture it in a single book.
This particular book selects a range of topics that should be of interest to a majority of C# programmers. It is a very basic introduction to the language with some side detours. What it doesn't cover is anything that is going on in the open source world - that is there is no coverage of cross platform .NET Core, just a mention of Mono. It does have a chapter on Windows Store apps but it is so slight that it might as well have been omitted.
In short this is a very traditional approach to C#.
The book is divided into five sections, and the first The OOP Language is by far the largest and the most important. This is the part that will teach you C# from the ground up. This is a very traditional approach to teaching a language, but it really only works if the reader can already program in some language, not necessarily C#. After a look at Visual Studio and what C# and .NET are all about it then goes over how to use Visual Studio to create a small program.
Learning the language gets going proper in Chapter 3 where we meet all of the different types of data you can work with. This is complete and useful if you already know what an unsigned integer or double precision number is, but it will mean nothing to a complete beginner.
From here we move on to flow of control and again this isn't really suitable for the complete beginner. Introducing the ternary operator before the if is simply confusing. Next we have more on variables - type conversion and complex variables.
Chapter 6 is a little odd in that it introduces functions before classes. In C# most functions are methods and belong to objects, so introducing functions so early doesn't really put them into context. The introduction of struct functions is also very odd. Not only have we not been introduced to structs, the best context for understanding functions defined in a struct is to see the struct as a value type version of a class. The chapter ends with a look at delegates, but not lambda expressions which are simpler and far more useful. Chapter 7 doesn't move on to classes and objects, but instead takes a slight detour into debugging and error handling.
At last we reach Chapter 8 and object oriented programming - better late than never. When to introduce the idea of objects is one of the big problems any introductory book on programming has to solve, but Chapter 8 is far too late. There are so many ideas introduced earlier that really don't make sense if you don't understand class and object. Chapter 8 deals with the basics, but it continues the tendency to introduce ideas that aren't essential to mastering the topic in hand. In this case the detour into interfaces doesn't help understand classes.
Chapters 9 and 10 go into deeper waters with a detailed look at the different types of method you can define and how to use the tools in Visual Studio. There are some irrelevant, at this stage, detours into things like partial classes and methods, which the beginner really doesn't need to know about, but the biggest problem is that issues of inheritance and the type hierarchy i.e. casting, are more or less ignored. This isn't enough even for a beginner.
The final three chapters in Part I go into more or less irrelevant topics for the core language. Chapter 11 deals with using collections - an important topic but only after you have mastered C#. Generics in chapter 12 is an advanced topic. Chapter 13 ends with a collection of topics including event handling, anonymous types and, at last, lambda expression.
Part II: Windows Programming introduces the use of WPF and XAML. It is still difficult to know what the furture of WPF is but XAML seems fairly secure.
Part III:Cloud programming features Azure. Like the previos section it consists of two chapters one characterized basic the other advanced/
Part IV: Data Access had four chapters covering files; XML and JSON; LINQ; and SQL.
Part V: Additional Terchniques has a chatper on WCF - a fairly minority interest - and Univeral Apps, which isn't really enough to get you anywhere with the topic.
Overall this is a book that will not suit the beginner. If you are already happy with the ideas of programming and object-oriented programming in particular, then this might make a good introduction to the world of C#. Even in this case, however, it treats the ideas in less than perfect order and it misses out discussing things that are of practical importance - async and await for example. The practical part of the book might be useful if it covers something you are particularly interested in but its depth and choice of subject means that you are unlikely to need it for all of the topics covered. Its coverage of Univeral Apps is particularly weak and this might be a reason for waiting to see how things settle down in the .NET world before buying a book on C# 6.
For recommended C# titles see C# Books - Pick of the Shelf
To keep up with our coverage of books for programmers, follow @bookwatchiprog on Twitter or subscribe to I Programmer's Books RSS feed for each day's new addition to Book Watch and for new reviews.