Introduction to C# Joes 2 Pros Book Review Insights From a Fellow Programmer

I came across Rick Morelan’s Introduction to C# Joes 2 Pros because I had already worked through his SQL Server books in the same series and found them genuinely useful. At the time, I was writing C# applications that talked to SQL Server databases on a daily basis, and the idea of learning C# from someone who understood the database side of things appealed to me. Most C# books I had encountered were written by pure application developers who treated databases as an afterthought—a connection string here, a quick query there. Morelan’s background in SQL Server training suggested he might approach C# from a perspective that aligned more closely with how I actually used the language: as the application layer sitting on top of relational data. The Joes 2 Pros branding also gave me confidence because his SQL books had taken a practical, exercise-heavy approach that worked well for me. At around 300 pages, it looked like a focused introduction rather than an exhaustive reference, which was exactly what I wanted.

Learn more about Introduction to C# Joes 2 Pros on Wikipedia

As an Amazon Associate, I earn from qualifying purchases.

Introduction to C# Joes 2 Pros (C# Exam Prep 70-536) by Peter Bako

By Peter Bako

As an Amazon Associate, I earn from qualifying purchases. This comes at no extra cost to you.

View on Amazon

Bottom Line

Rick Morelan’s Introduction to C# Joes 2 Pros is a beginner-level C# programming guide from an author best known for his SQL Server training. The book covers fundamental syntax, data types, control flow, and basic object-oriented concepts through short, exercise-driven chapters. It is strongest when connecting C# concepts to database operations, reflecting Morelan’s background, but it lacks the depth and polish of more established C# introductions. Useful as a supplementary resource for database professionals moving into application development, but not sufficient as a sole learning resource for serious C# study.

A Database Developer’s Gateway to C#

The Joes 2 Pros series has a distinctive format that carries over from Morelan’s SQL books. Each chapter is relatively short—typically 15 to 25 pages—and built around a progression from explanation to guided exercises to independent practice problems called “skill checks.” The book opens with environment setup (installing Visual Studio Express and creating your first console application) and moves through variables, data types, operators, conditional statements, loops, arrays, methods, and introductory classes.

What distinguishes this book from other beginner C# texts is Morelan’s constant use of analogies rooted in database thinking. When introducing variables, he draws explicit parallels to SQL Server column data types—comparing a C# int to a SQL INT, a C# string to a SQL VARCHAR. When covering arrays, he likens them to result sets with a single column. These comparisons are genuinely helpful if you are coming from a database background because they anchor new concepts to familiar ones. However, if you have no SQL experience, these analogies will sail right past you, which limits the book’s audience more than its title suggests.

The exercise-driven format is the book’s strongest feature. Morelan does not just show you code and explain it; he asks you to predict what output a code snippet will produce before running it, then has you modify it and predict again. This predict-then-verify cycle is an effective learning technique that forces active engagement. The skill check problems at the end of each chapter are well-designed, starting easy and building in complexity. Chapter 7’s skill checks on nested loops, for example, start with a simple multiplication table and build to generating a triangle pattern of asterisks.

The OOP Chapters: Ambition Exceeding Execution

The final third of the book attempts to introduce object-oriented programming, and this is where things get rocky. Morelan covers class creation, properties, constructors, and basic inheritance across about four chapters. The class creation chapter uses a Employee class as its running example, with properties like FirstName, LastName, and Salary—clearly inspired by database table design, which is both a strength and a weakness.

It is a strength because the example feels immediately relevant to anyone building data-driven applications. Mapping a database row to a C# object is something you will actually do in production code. But it is a weakness because OOP is about more than data containers. The chapters on inheritance use a Manager class extending Employee, adding a Department property and overriding a GetDetails method. The example is clear enough, but Morelan does not adequately explain why you would use inheritance versus simply adding a nullable Department column—I mean property—to the base class. The “when” and “why” of OOP design decisions are almost entirely absent.

Interfaces and abstract classes receive a combined chapter of about 15 pages, which is simply not enough. Morelan defines an IPrintable interface with a single Print method, implements it in two classes, and moves on. There is no discussion of interface segregation, no explanation of how interfaces enable dependency injection, and no real-world scenario showing why you would choose an interface over an abstract base class. For a topic this important to professional C# development, the coverage is too thin to be useful.

Writing Style and Craft

Morelan writes in a conversational, approachable style that feels like a classroom instructor talking to students. Sentences are short. Paragraphs are brief. Technical jargon is introduced gradually and always defined on first use. This makes the book very accessible to true beginners, though experienced developers may find the pace slow and the explanations over-simplified in places.

The book has noticeable rough edges in editing and production quality. I encountered several code listings with minor typos—a missing semicolon in one example, an inconsistent variable name in another—that a more rigorous technical review process would have caught. These are small issues individually, but in a book aimed at beginners who are still learning syntax rules, even one misplaced semicolon in a printed example can cause confusion and erode trust in the material. The layout and typography are also more basic than what you would find from a major publisher like O’Reilly or Wrox, which gives the book a self-published feel.

Emotional Impact

Reading this book felt like visiting a familiar restaurant that had added a new item to their menu. Morelan’s voice and teaching approach from the SQL books carried over, and there was comfort in that familiarity. The predict-then-verify exercises created small moments of satisfaction when I guessed correctly and productive frustration when I did not.

My strongest memory from the book is working through Chapter 5 on conditional statements, where Morelan builds a simple grading calculator that assigns letter grades based on numeric scores. He starts with a chain of if-else statements, then refactors to a switch statement, then asks you to extend it with plus and minus grades. That progression—from working code to better code to your own extension—captured the joy of incremental improvement that keeps me interested in programming. But I also remember frustration with the OOP chapters, where I felt Morelan was rushing through material that deserved twice the page count. The book ended just as it was getting to the topics I most wanted to explore.

Pros and Cons

What Works

• Database-to-code analogies: Morelan’s SQL Server background shines through in comparisons between C# data types and SQL column types, making this book uniquely accessible to database professionals transitioning to application development.
• Predict-then-verify exercises: The approach of asking you to predict output before running code is a proven learning technique that forces deeper engagement than simply typing and executing examples. The skill checks reinforce this with progressively challenging problems.
• Focused scope: At 300 pages, the book does not try to cover everything. It sticks to fundamentals and ensures you understand them before moving forward. Each chapter builds cleanly on the previous one with minimal assumed knowledge.

What Could Be Better

• Shallow OOP coverage: The object-oriented programming chapters feel rushed and incomplete. Inheritance, interfaces, and abstract classes are introduced but not explored with sufficient depth or real-world context. A developer finishing these chapters would understand the syntax of OOP but not the design thinking behind it.
• Production quality issues: Code typos, inconsistent formatting, and a generally basic layout detract from the book’s credibility. For a beginner audience that is learning to write syntactically precise code, the printed examples need to be flawless, and they are not always.

Who Should Read This

This book is best suited for SQL Server database administrators or developers who want to start learning C# and prefer a teaching style that connects new concepts to their existing database knowledge. It also works for complete programming beginners who want an exercise-heavy, low-intimidation introduction to coding concepts. Experienced developers, anyone looking for intermediate or advanced C# material, or readers without database backgrounds should look at alternatives like Murach’s C# or the Head First C# textbook instead. This is a narrow-audience book that serves that narrow audience reasonably well.

Final Thoughts

Rick Morelan’s move from SQL Server training into C# instruction makes conceptual sense—the two technologies are deeply intertwined in the Microsoft ecosystem, and helping database professionals cross into application development fills a genuine gap. The early chapters of this book do that well, leveraging Morelan’s strengths in clear, exercise-driven instruction. But the book runs out of runway before it can adequately cover the topics that would make its readers productive C# developers. I ended up treating it as a stepping stone—it got me comfortable with basic syntax and control flow, then I moved to more comprehensive resources for OOP and .NET framework depth. If Morelan had written a second volume covering OOP, LINQ, and database connectivity in the same exercise-driven style, the two books together would make a formidable learning package. As it stands, this is a solid start that needs a stronger finish.