Customer Reviews

Murach's C#

5 star:		(25)
4 star:		(9)
3 star:		(2)
2 star:		(1)
1 star:		(0)

 

 

This is actually my third C# book, after Programming in the Key of C# by Charles Petzold and Programming C# by Jesse Liberty. I'm learning C# as my first programming language, basically just for fun and out of an interest in programming. I bought Murach's C# as a way to reinforce the basics that I've already learned, and it's doing a good job of that. And I suppose if you are already a programmer and are learning C# (but already know C++ or Java, etc.), then this book is a good intro. But is this really a good book for a beginner to start with?

I'd have to say no. It seems more like a good book to go back to once you already know some things about C#. As I read the chapter in which the "C# Essentials" are introduced, I felt like that's all that was happening: they were being introduced. Here is what the data types are, here is what an if statement is, etc. One page for each topic, and then the authors move on. Furthermore, they introduce some methods of the Math class before they even cover what methods are (or how static methods differ from instance methods, and so on). If I were reading this book as my first intro to C#, I think I'd be very confused. I feel like I can understand what's being said only because I've read two other books on the subject already.

One advantage this book has over all other books I've seen is that it takes the time (two chapters) to introduce you to Visual Studio (the development environment for C#). This is great since programmers will presumably be using this IDE as opposed to an external text editor, for example.

Two complaints I have about the book are these:

1. The paired page format is nice, but at the same time it leads to a lot of redundancy. Often the points made on the left-hand page are repeated in bullets on the right-hand side. Sometimes there's a bit of new information on the right side, so I still felt obliged to read it anyway.

2. It is often difficult to tell which parts of the right-hand page correspond to the left-hand page. The left side is paragraphs of text, but they are not broken up to indicate that we should direct our attention to the right side. I often find myself reading the left side and getting too far ahead before I look to the right side (or vice versa, I continue reading the examples on the right side until I reach a point that I haven't read the explanatory text on the left yet, which can be confusing).

My ultimate opinion is that this book is a good reference or refresher for those who already know another language, or who want to 're-learn' C#. It is not the best book for a complete beginner.

For the beginner with no prior programming experience, I highly, highly, highly recommend Petzold's Programming in the Key of C#. He takes the time to explain everything in great detail, and you will learn so much. It is an excellent foundation for reading other books, such as Murach's C#.

All of Murach's books follow the same format: the left page of the open book provides the commentary for the illustrations on the right page. The examples and tutorials in the book are real-world and offer the best possible scenario for the student. I have over a dozen books on C#; if I had purchased this one first, I wouldn't have needed the others. Get this book if you need to learn C# in the shortest possible time.

This is an excellent book for the beginning C# programmer. The book uses a "paired-page" format where the page on the left gives descriptions of a concept and the page on the right provides examples, syntax, and additional information. Although this does lead to some repetition, overall it provides clearer explanations of concepts that are laid out in front of you all at once. It also makes it easier to go back, find, and review information read previously.

The book starts with a tour of C# which leans heavily on Visual Studio. The first three chapters cover using VS.NET and very little C# code is presented. In fact, explanations of how to work in Visual Studio are provided throughout the book. The next two sections, covering 12 chapters, cover the details of programming in C# and writing object oriented code. The coverage of OO is excellent and it will remove much of the mystery associated with OO programming. Database programming using ADO.NET is covered at a good level of detail in five chapters. The final section covers reading and writing files including using the .NET classes to read and write XML files.

In many ways this book provides a level of detail not found in other books with plenty of code samples to help clarify the material. The only thing not covered is ASP and web forms. I can highly recommend this book to anyone interested in learning C# or to anyone planning to teach a C# programming course. The book is well designed as a textbook for a programming class. It includes objectives, a summary, a list of important terms, and programming exercises at the end of each chapter. A student workbook and an instructor CD are available.

For several years now I've been successfully avoiding having to learn C#. Why? Because it basically only works with Microsoft, part of their .NET effort to tie everyone to their software. Why should I go learn something that is tied to just Microsoft systems?

Answer: Because someone came by and was willing to pay a rather large amount of money for a project but insisted on C#. Like the old joke, we know what we are, we just quibble about the price.

OK, so now I need to know C#, and I need to know it quickly. The solution to that problem (regardless of the language) is really simple - a Murach book.

Murach has developed a format that is hands down my favorite way of learning a new language. Basically the put every tidbit that you need to know on a pair of facing pages. Typically one page has a texual description of that tidbit. The facing page then says the same thing, but in a different way. Often this is a screenshot, sometimes a drawing or a table. The key is that the facing pages use different words, different techniques to cover the same point. I find that I read both, and very frequently find myself saying, 'Oh, that's what they were talking about.' The result is that I learn the point better, faster.

This new book covers the latest version of C#, Visual Studio and the .NET framework. It took me about two weeks to go through the book, the two weeks before this contract started. When I got started on the gig, I could hold my own with the other C# programmers. And that's all you can possibly ask of a book.

This was not my first programming language. I've worked in at least a dozen languages over the years. I've seen some complaints about this book that it isn't really suitable for a complete beginner. Perhaps that's true, I'm not really competent to say because I'm not a complete beginner. On the other hand, when I was a complete beginner they handed me an assembly language programming book and told me to go read it. This book is a hell of a lot easier than the way I started.

I make no secret of being a fan of Murach books. This is the 4th Murach book I have read and the best so far. Murach books have a distinctive feel about them because of the way they are layed out. Every left hand page is a narrative and every right hand page contains diagrams and bullet points relating to the
narrative. This is a format that works for me, especially in the more involved chapters where the narrative can be read and then the important points revisited on the facing page. These bullet points are also useful for using the book for reference in the weeks and months after initially reading it.

The book follows a fairly conventional layout by splitting itself into sections and each section containing a number of associated chapters. Each chapter starts with a brief introduction and then list of topics covered and the page number the topic starts on. At the end of the chapter there is a short perspective paragraph and bullet points summary of what was covered in the chapter, a list of terms introduced in the chapter and some exercises to perform.

The book uses the Microsoft C# IDE v7.1 as the development environment (but nearly all examples will work with v7.0) and MSDE 2000 as the database. The book contains a brief overview on how to install Visual Studio, MSDE, download the source files and attach the database used by the source files to MSDE. There are 7 chapters available for free viewing.

Pros: The space in margins for making notes, the print is clear and there are plenty of diagrams and figures to supplement the text, the format of the book with regard to the left right page combinations, the information in the book is accurate with the few errors being highlighted on the publisher's web site, as applications are developed throughout the book the additional code is clearly highlighted making it easy to pick up on the additions, concepts are introduced in a logical and simplified manner being added to as the book progresses.

Cons: All examples are done using only the Visual Studio (C#) .NET IDE

Conclusion
This book is definitely aimed at the complete newcomer to C#. No previous knowledge of the C#, te Visual Studio IDE nor databases is required. The book will give you a good grounding in the basics of C# but will leave you wanting more, not through any fault of the book but simply because the basic concepts of C# are covered in such detail that there simply isn't enough room in a book of this size to cover more advanced topics. I am certainly hoping for a murach's advanced C# book.

If I had to sum up this book the term I would use is Clear and Concise. The authors very rarely labour any points and move on at a brisk but understandable pace. The accolade I can award to the authors is that after 20 years of trying and failing to find any enjoyment in programming in C this book has finally
won me over and I have already had to catch myself typing C# syntax into my VB.NET projects.A postive addition to my bookcase.

This book presents the technical content in an easy to understand format. It has many real world type examples that have proven to be helpful in learning the basics.

I own three other Murach books now (Murach's Beginning Visual Basic .Net, VB.Net Database Programming, and ASP.Net Web Programming with VB.Net) and have found them all to be excellent initial learning tools and post learning reference books. All of the books are well written, laid out in a thoughtful manner which makes it easy to learn and easier to use as a reference. Murach calls this layout "paired pages" which simply means putting the explanation of the concept on the one page with the execution or examples of the concept on the opposite facing page. I was nervous about moving from VB.Net to C# before reading this book, but since reading the book I have quickly moved from intimidated to making C# my language of choice. The fact that this process took me only three days using this book should speak volumes about how effective it is as both a learning tool and reference.
The C# book covers the same basic items that the Murach VB.Net book covers, but after the basics it takes a divergent path. The VB.Net book included only the basic information on database programming where the C# book goes in to how to work with data by designing your own classes. For VB.Net developers that topic was covered in Murach's database programming book. The VB.Net book also had a basic over view of ASP.Net coding and web services using VB.Net the C# book took up that space in the book with the extra exploration of database programming, a longer section on working with XML files and some information on working with binary files.

My level of programming knowledge is not what I would call extensive, but I am no longer a beginner as I was with the first Murach book. I don't have any background in C, C++ or Java programming though so the style of C# programming is totally new to me.

In order to write this review I am revisiting several pieces of code that I have written in actual business applications. To be honest I feel that some material is not covered in enough depth. The information for String.Format() was incomplete and left out the R or r and X or x format specifiers. These two specifiers aren't commonly used, but I feel that beginning level books should make readers aware of their existence even if they are not covered in depth. Absent as well was any information on using checked to specifically check and catch overflow errors; example:

try
{
long d = checked((long)Convert.ToInt64(s));
lblPlayerUID.Text = String.Format("Q$, d);
}
catch (System.OverflowException exception)
{
lblPlayerUID.Text = exception.ToString();
btnSubmit.Enabled = false;
}

The book does an excellent job of showing you how to connect to databases using the IDE to create connections, adapters and datasets for you or for building all of those objects in code. It even goes through making a class for all of you data retrieval and modifications. In my opinion the extra database material is fantastic since most business applications will make use of some database component. Writing a database class cuts down on the amount of code one has to write and makes the code much more manageable.
The book also does an excellent job of covering the object oriented programming concepts with two chapters devoted to building and using classes including tips on how to use XML to document them. It also includes a full chapter on inheritance and another on interfaces, structures, and class libraries.

In summary the book makes good on its promise of being "the C# book you'd wish you'd bought first". It is written in the same excellent style that gives you code snippets and explanations on the way to building a complete application and then gives you the complete code for that application at the end of each chapter. It is the perfect blend of teaching text and reference text. It uses the Visual Studio IDE unlike many books that seem to imply that using the tool makes you less of a "real" developer or include it as an afterthought. The book covered OOP better than any book that I have used previously and explored classes beyond anything I had seen. Despite the depth in this area the material was written in a clear understandable manner that made learning the concepts easy. The practice exercises included in the book server to reinforce what you have been taught while making you apply those same concepts. I used Murach books to teach myself VB.Net, ASP.Net and Database Programming using VB.Net and their C# book is exceeding my expectations in that area as well. I only hope that they produce an ASP.Net

The tag line of Murach's C# is "The C# book you'll wish you'd bought first." That was certainly true for me. I decided to learn an Object Oriented (OO) programming language just for the fun of it. After purchasing another book and struggling through over 200 pages of worthless information, I admitted I had made a mistake. Murach's C# certainly was the book I should have bought in the first place. There are at least six reasons for this.

First, the quality of the writing is first rate. Murach and Lowe are no strangers to the English language. You can hardly say that about many authors in this field. The sentence structure is clean, descriptive, and short. They do not waste space with cute diversions, but present each concept as a tight paragraph. They understand the use of the topic sentence.

Closely related to the first point is the layout of the book. The text of a chapter is found on the even numbered pages with a clear example on the facing odd pages. For example on page 6 you find an explanation of Windows forms and Web forms. On page 7 is Figure 1-2 an example of a Windows form and a Web form. When they get into the coding examples the left hand text fully describes the example code found on the opposite page. Sometimes they must depart from this style when the example runs longer than a single page, but happily this is not often.

The third reason is the quality of these examples. They are lifted straight from real life business applications. Now I must admit that my interest lies closer to accounting systems then systems programming so I could be biased in my opinion, but I think the authors made a wise decision here. Almost everyone can relate on an intuitive level to making a purchase. Therefore, examples from inventory and customer order entry can be meaningful to any reader. Not everyone can relate to a security login example as one book used. In addition, the order entry example runs consistently through the entire book. They do not jump from examples of a deck of cards when they are talking about enumerations, to cats and dogs when they discuss classes. By the time you reach the midpoint of the book, you can build a fairly realistic, if small, order entry system. By the end you can build one for a fairly large firm.

C# is a powerful, large, and complex system. It is far more than just a language. The book does not attempt to show you everything you could do with C#. Its focus is business applications built on a database foundation. Murach goes into the details of how ADO.NET is used to make C# work in concert with SQL Server. You do not need access to SQL Server to develop these applications because the book gives you instructions on how to download and implement the free personal edition of SQL that Microsoft makes available to users of Visual Studio. You will need Visual Studio running on your computer if you are going to make effective use of this book.

The fifth reason is teaching style. They start with a meaningful division of the book into 26 chapters. This would be an excellent text for a two semester course on an introduction to programming at the college level. Each chapter lays out its objectives for the unit right up front. In fact each chapter starts with a table of contents. Every topic is presented using the left hand page as described above. The examples, on the right, flow naturally from the text. The chapters end with a topic called Perspective. It starts with a paragraph or two stating what the chapter was trying to accomplish. Then there is a chapter summary presented as a series of dot points. This is followed by a list of terms that were developed in the chapter. Next, is a topic called Objectives explaining what the reader should be able to do now. And finally are a series of Exercises where the student develops his business application.

The last reason why I think this is an excellent book is that it accomplished my objective. It taught me OO programming. This is not a trivial task. OO programming is both complex and comprehensive. If you are new to this field concepts like polymorphism, encapsulation, and inheritance can be daunting for the novice. Murach's C# allows you to master all of these and allows you to write meaningful programs in the language. That is not to say you are an expert after finishing the book, but you certainly are a journeyman programmer.

I'm still in the middle of this book,and It is great,easy to follow and understand,and most of all it is consistent and direct to the point.
I can't wait to finish it,actually I brought it with me to my work,to read it and use it in my projects.Although I'm an MCSD,but really this book helps me in better understanding .Net 2
Good work Murach

This is an excellent guide in using the latest version of C#, most effective for existing .NET 1.x developers looking to migrate their skill set up to v.2.0 code and concepts. The intent of the work isn't to teach C# from scratch, but more to give an overview of the major features .NET 2.0 offers. The book also serves a dual purpose - introducing the Visual Studio 2005 IDE and demonstrating how to make it work the best for you.

It sports chapters on working with ADO.NET for database programming, XML, I/O, Windows Forms controls, proper OOP fundamentals (inheritance, polymorphism), creating/using business objects within custom libraries, and deployment. In particular, the deployment chapter is particularly good, showing how to properly package and ship an complete application with an embedded database.

Joe Murach writes in a very friendly, succinct manner through very well-ordered chapters, making for a very welcome atmosphere for the busy developer looking to update their programming palette. The technical foundations are well-explain in concise fashion, and almost all have accompanying code and/or illustrations or screenshots. The book is a very quick read. Physically, it exhibits all the appreciated traits of the Murach library: it's printed on heavy, durable paper and bound with a sturdy spine that will sustain the quick flip-through or serious pounding in the middle of a project.

In criticism, I feel the book is a bit mis-titled - and in this instance, that's not necessarily a bad thing. The emphasis, rather than on the nuances of the updated language, is more on using VS2K5 to build Windows apps. I would have liked more information on developing MDI applications, as this is what most devs will ultimately work towards building. Also, while Chapter 23 - "How to Work with XML Files" was a good start, I found it to be a tad incomplete, lacking some of the more essential concepts like XSLT and integrating XML with ADO.NET.

But those minor concerns aside, this is a great book that you'll be able to read through quickly and visually, empowering you with the skills you'll need to build great .NET 2.0 desktop applications.