Head First C#, 5th Edition

Table of Contents (the real thing)

• How to use this Book Intro

  Your brain on C#. Here you are trying to learn something, while here your brain is doing you a favor by making sure the learning doesn’t stick. Your brain’s thinking, “Better leave room for more important things, like which wild animals to avoid and whether naked snowboarding is a bad idea.” So how do you trick your brain into thinking that your life depends on knowing C#?

  • “Who is this book for?”

  • “We know what you’re thinking”

  • “Metacognition: thinking about thinking”

  • “Here’s what YOU can do to bend your brain into submission”

  • “README.md”

  • “The technical review team”

  • “Acknowledgments”

• Chapter 1

  Want to build great apps...right now?

  With C#, you’ve got a modern programming language and a valuable tool at your fingertips. And with Visual Studio, you’ve got an amazing development environment with highly intuitive features that make coding as easy as possible. Not only is Visual Studio a great tool for writing code, it’s also a really effective learning tool for exploring C#. Sound appealing? Let’s get coding!

  • “Learn C#...and learn to become a great developer”

  • “Write code and explore C# with Visual Studio”

  • “Install Visual Studio Community Edition”

  • “Run Visual Studio”

  • “Create and run your first C# project in Visual Studio”

  • “You can use Visual Studio Code with Head First C#”

  • “Create and run your first project in Visual Studio Code”

  • “Set up Visual Studio Code for the next project”

  • “Let’s build a game!”

  • “Create a .NET MAUI project in Visual Studio”

  • “Run your new .NET MAUI app”

  • “MAUI apps work on all of your devices”

  • “Start editing your XAML code”

  • “Use a FlexLayout to make a grid of animal buttons”

  • “Write C# code to add the animals to the buttons”

  • “Run your app!”

  • “Visual Studio makes it easy to use Git”

  • “Add C# code to handle mouse clicks”

  • “Add a timer to your game’s code”

  • “Finish the code for your game”

• Chapter 2

  You’re not just an IDE user. You’re a developer.

  You can get a lot of work done using the IDE, but there’s only so far it can take you. Visual Studio is one of the most advanced software development tools ever made, but a powerful IDE is only the beginning. It’s time to dive in to C# code: how it’s structured, how it works, and how you can take control of it...because there’s no limit to what you can get your apps to do.

  • “Take a closer look at the files in your console app”

  • “Statements are the building blocks for your apps”

  • “Statements live inside methods”

  • “Your methods use variables to work with data”

  • “Generate a new method to work with variables”

  • “Add code that uses operators to your method”

  • “Use the debugger to watch your variables change”

  • “Use code snippets to help write loops”

  • “Use operators to work with variables”

  • “if statements make decisions”

  • “Loops perform an action over and over”

  • “Controls drive the mechanics of your user interfaces”

  • “Other controls you’ll use in this book”

  • “Create a new app to experiment with controls”

  • “Explore your new MAUI app and figure out how it works”

  • “Add an Entry control to your app”

  • “Add properties to your Entry control”

  • “Make your Entry control update a Label control”

  • “Combine horizontal and vertical stack layouts”

  • “Add a Picker control to display a list of choices”

• Unity Lab #1 Explore C# with Unity

  Welcome to your first Head First C# Unity Lab. Writing code is a skill, and like any other skill, getting better at it takes practice and experimentation. Unity will be a really valuable tool for that. In this lab, you can begin practicing what you’ve learned about C# in Chapter 1 and Chapter 2.

  • “Unity is a powerful tool for game design”

  • “Download Unity Hub”

  • “Use Unity Hub to create a new project”

  • “Your scene is a 3D environment”

  • “Unity games are made with GameObjects”

  • “Use the Move Gizmo to move your GameObjects”

  • “The Inspector shows your GameObject’s components”

  • “Add a material to your Sphere GameObject”

  • “Rotate your sphere”

  • “Get creative!”

• Chapter 3

  Great developers keep their code and data organized.

  What’s the first thing you do when you’re creating an app? You think about what it’s supposed to do, whether you’re solving a problem, creating a game, or just having fun. But it’s not always obvious how individual statements fit into your app’s bigger picture...and that’s where classes come in. They let you organize your code around the features you’re creating and the problems the app needs to solve. Classes can help you organize your data too, by using them to create objects that represent any “thing” your app needs to know about—and the classes that you design serve as “blueprints” for the objects used in your app.

  • “Classes help you organize your code”

  • “Some methods take parameters and return a value”

  • “Let’s build an app that picks random cards”

  • “Create an app with a Main method”

  • “Use Quick Actions to remove unnecessary using lines”

  • “Convert between namespace styles”

  • “Use the new keyword to create an array of strings”

  • “Build a paper prototype for a classic game”

  • “Build a MAUI version of your random card app”

  • “Reuse your CardPicker class”

  • “Add a using directive to use code in another namespace”

  • “You use a class to build an object”

  • “A better solution for Ana...brought to you by objects”

  • “An instance uses fields to keep track of things”

  • “Use intuitive class and method names”

  • “Build a class to work with some guys”

  • “Use the C# Interactive window or csi to run C# code”

• Chapter 4

  Data and objects are the building blocks of your apps.

  What would your apps be without data? Think about it for a minute. Without data, your programs are...well, it’s actually hard to imagine writing code without data. You need information from your users, and you use that to look up or produce new information to give back to them. In fact, almost everything you do in programming involves working with data in one way or another. In this chapter, you’ll learn the ins and outs of C#’s data types and references, see how to work with data in your program, and even learn a few more things about objects (guess what...objects are data, too!).

  • “A variable’s type determines what kind of data it can store”

  • “C# has several types for storing integers”

  • “Let’s talk about strings”

  • “A literal is a value written directly into your code”

  • “Casting lets you copy values that C# can’t automatically convert to another type”

  • “C# does some conversions automatically”

  • “Use reference variables to access your objects”

  • “References are like sticky notes for your objects”

  • “Multiple references and their side effects”

  • “Two references mean TWO variables that can change the same object’s data”

  • “Objects use references to talk to each other”

  • “Arrays hold multiple values”

  • “null means a reference points to nothing”

  • “Use the string? type when a string might be null”

  • “Welcome to Sloppy Joe’s Budget House o’ Discount Sandwiches!”

  • “Grid controls”

  • “Create the Sloppy Joe’s menu app and set up the grid”

  • “Use the SetValue method to change a control’s semantic properties”

• Unity Lab #2 Write C# Code for Unity

  Unity isn’t just a powerful, cross-platform engine and editor for building 2D and 3D games and simulations. It’s also a great way to get practice writing C# code. In this lab, you’ll get more practice writing C# code for a project in Unity.

  • “C# scripts add behavior to your GameObjects”

  • “Add a C# script to your GameObject”

  • “Write C# code to rotate your sphere”

  • “Add a breakpoint and debug your game”

  • “Use the debugger to understand Time.deltaTime”

  • “Add a cylinder to show where the Y axis is”

  • “Add fields to your class for the rotation angle and speed”

  • “Use Debug.DrawRay to explore how 3D vectors work”

  • “Run the game to see the ray in the Scene view”

  • “Rotate your ball around a point in the scene”

  • “Use Unity to take a closer look at rotation and vectors”

  • “Get creative!”

• Chapter 5

  Ever wished for a little more privacy?

  Sometimes your objects feel the same way. Just like you don’t want anybody you don’t trust reading your journal or paging through your bank statements, good objects don’t let other objects go poking around their fields. In this chapter, you’re going to learn about the power of encapsulation, a way of programming that helps you make code that’s flexible, easy to use, and difficult to misuse. You’ll make your objects’ data private, and add properties to protect how that data is accessed—and you’ll keep your objects’ important data from leaking out to other objects so they don’t accidentally misuse it.

  • “Let’s help Owen roll for damage”

  • “Create a console app to calculate damage”

  • “Design a MAUI version of the damage calculator app”

  • “Use Debug.WriteLine to print diagnostic information”

  • “Use encapsulation to control access to your class’s methods and fields”

  • “Private fields and methods can only be accessed from instances of the same class”

  • “Why encapsulation? Think of an object as an opaque box...”

  • “Let’s use encapsulation to improve the SwordDamage class”

  • “Write a console app to test the PaintballGun class”

  • “Auto-implemented properties simplify your code”

  • “Use a private setter to create a read-only property”

  • “Use a constructor with parameters to initialize properties”

  • “Specify arguments when you use the new keyword”

  • “Initialize fields and properties inline or in the constructor”

• Chapter 6

  Sometimes you DO want to be just like your parents.

  Ever run across a class that almost does exactly what you want your class to do? Found yourself thinking that if you could just change a few things, that class would be perfect? With inheritance, you can extend an existing class so your new class gets all of its behavior—with the flexibility to make changes to that behavior so you can tailor it however you want. Inheritance is one of the most powerful concepts and techniques in the C# language: with it, you can avoid duplicate code, model the real world more closely, and end up with apps that are easier to maintain and less prone to bugs.

  • “Use a switch statement to match several candidates”

  • “When your classes use inheritance, you only need to write your code once”

  • “How would you design a zoo simulator?”

  • “Any place where you can use a base class, you can use one of its subclasses instead”

  • “A subclass can override methods to change or replace members it inherited”

  • “Build an app to explore virtual and override”

  • “A subclass can hide methods in the base class”

  • “Use the override and virtual keywords to inherit behavior”

  • “A class should do one thing”

  • “Build a beehive management system”

  • “Feedback drives your beehive management game”

  • “The Beehive Management System is turn-based... now let’s convert it to real-time”

  • “An abstract class is an intentionally incomplete class”

  • “Abstract properties work just like abstract methods”

  • “The Deadly Diamond of Death”

• Unity Lab #3 GameObject Instances

  C# is an object-oriented language, and since these Head First C# Unity Labs are all about getting practice writing C# code, it makes sense that these labs will focus on creating objects.

  • “Let’s build a game in Unity!”

  • “Create a new material inside the Materials folder”

  • “Spawn a billiard ball at a random point in the scene”

  • “Use the debugger to understand Random.value”

  • “Turn your GameObject into a prefab”

  • “Create a script to control the game”

  • “Attach the GameController script to the Main Camera”

  • “Press Play to run your code”

  • “Use the Inspector to work with GameObject instances”

  • “Use physics to keep balls from overlapping”

  • “Get creative!”

• Chapter 7

  Need an object to do a specific job? Use an interface.

  Sometimes you need to group your objects together based on the things they can do rather than the classes they inherit from—and that’s where interfaces come in. You can use an interface to define a specific job. Any instance of a class that implements the interface is guaranteed to do that job, no matter what other classes it’s related to. To make it all work, any class that implements an interface must promise to fulfill all of its obligations...or the compiler will break its kneecaps, see?

  • “The beehive is under attack!”

  • “We could use casting to call the DefendHive method…”

  • “An interface defines methods and properties that a class must implement…”

  • “Interfaces let unrelated classes do the same job”

  • “Get a little practice using interfaces”

  • “You can’t instantiate an interface, but you can reference an interface”

  • “Interface references are ordinary object references”

  • “The RoboBee 4000 can do a worker bee’s job without using valuable honey”

  • “What if we want different animals to swim or hunt in packs?”

  • “Use interfaces to work with classes that do the same job”

  • “Safely navigate your class hierarchy with is”

  • “C# has another tool for safe type conversion: the as keyword”

  • “Use upcasting and downcasting to move up and down a class hierarchy”

  • “Upcasting and downcasting work with interfaces too”

  • “Default implementations give bodies to interface methods”

  • “Data binding updates MAUI controls automatically”

  • “Polymorphism means that one object can take many different forms”

• Chapter 8

  Data isn’t always as neat and tidy as you’d like it to be.

  In the real world, you don’t receive your data in tidy little bits and pieces. No, your data’s going to come at you in loads, piles, and bunches. You’ll need some pretty powerful tools to organize all of it—and lucky for us, C# has just the tools we need. Enums are types that let you define valid values to categorize your data. Collections are special objects that store many values, letting you store, sort, and manage all the data that your apps need to pore through. That way, you can spend your time thinking about writing apps to work with your data, and let the collections worry about keeping track of it for you.

  • “If a constructor just sets fields, use a primary constructor instead”

  • “A primary constructor can extend a base constructor”

  • “Enums let you work with a set of valid values”

  • “Enums let you represent numbers with names”

  • “Lists make it easy to store collections of…anything”

  • “Let’s build an app to store shoes”

  • “Generic collections can store any type”

  • “You can use collection expressions to create Lists”

  • “IComparable<Duck> helps your List sort its Ducks”

  • “Create an instance of your comparer object”

  • “Comparers can do complex comparisons”

  • “You can upcast an entire list using IEnumerable<T>”

  • “The Dictionary functionality rundown”

  • “CollectionView is a MAUI control built for displaying collections”

  • “ObservableCollection is a collection made for data binding”

  • “Use XAML to instantiate your objects for data binding”

  • “Modify your app to use a resource Dictionary”

  • “Modify the event handlers to use the resource Dictionary”

  • “Use what you’ve learned to build an app with two decks”

• Unity Lab #4 User Interfaces

  In the last Unity Lab you started to build a game, using a prefab to create GameObject instances that appear at random points in 3D space and fly in circles. This Unity Lab picks up where the last one left off, allowing you to apply what you’ve learned about interfaces in C# and more.

  • “Add a score that goes up when the player clicks a ball”

  • “Add two different modes to your game”

  • “Add game mode to your game”

  • “Add a UI to your game”

  • “Set up the Text that will display the score in the UI”

  • “Add a Button that calls a method to start the game”

  • “Make the Play Again button and Score Text work”

  • “Finish the code for the game”

  • “Get creative!”

• Chapter 9

  It’s a data-driven world...we all need to know how to live in it.

  Gone are the days when you could program for days, even weeks, without dealing with loads of data. Today, everything is about data, and that’s where LINQ comes in. LINQ is a feature of C# and .NET that not only lets you query data in your .NET collections in an intuitive way, but lets you group data and merge data from different data sources. You’ll use anonymous objects to manage your data in new and interesting ways. You’ll add unit tests to make sure your code is working the way you want. Once you’ve got the hang of wrangling your data into manageable chunks, you can use lambda expressions to refactor your C# code to make it easier to work with and more expressive.

  • “Jimmy’s a Captain Amazing superfan...”

  • “Use LINQ to query your collections”

  • “Use a LINQ query to finish the app for Jimmy”

  • “The var keyword lets C# figure out variable types for you”

  • “LINQ is versatile”

  • “Use a group query to separate your sequence into groups”

  • “Use join queries to merge data from two sequences”

  • “Use the new keyword to create anonymous types”

  • “Unit tests help you make sure your code works”

  • “Start writing your first test method”

  • “One project can only access public classes in another project”

  • “Use the Arrange-Act-Assert pattern to write an effective test”

  • “Write a unit test for the GetReviews method”

  • “Use the => operator to create lambda expressions”

  • “Use the ?: operator to make your lambdas make choices”

  • “LINQ queries are made up of methods”

  • “LINQ declarative syntax can be refactored into chained methods”

  • “Use the => operator to create lambda expressions”

  • “Explore the Enumerable class”

  • “Use yield return to create your own sequences”

• Chapter 10

  Sometimes it pays to be persistent.

  So far, all of your programs have been pretty short-lived. They fire up, run for a while, and shut down. But that’s not always enough, especially when you’re dealing with important information. You need to be able to save your work. In this chapter, we’ll look at how to write data to a file, and then how to read that information back in from a file. You’ll learn about streams, and how to store your objects in files with serialization, and get down to the actual bits and bytes of hexadecimal, Unicode, and binary data.

  • “.NET uses streams to read and write data”

  • “Different streams read and write different things”

  • “Use a StreamReader to read a file”

  • “Use the static File and Directory classes to work with files and directories”

  • “IDisposable makes sure objects are closed properly”

  • “Avoid filesystem errors with using statements”

  • “Use a MemoryStream to stream data to memory”

  • “What happens to an object when it’s serialized?”

  • “Use JsonSerializer to serialize your objects”

  • “JSON only includes data, not specific C# types”

  • “C# strings are encoded with Unicode”

  • “.NET uses Unicode to store characters and text”

  • “C# can use byte arrays to move data around”

  • “Use a BinaryWriter to write binary data”

  • “Use BinaryReader to read the data back in”

  • “Use StreamReader to build a hex dumper”

  • “Use Stream.Read to read bytes from a stream”

  • “Modify your hex dumper to read directly from the stream”

  • “Run your app from the command line”

• Unity Lab #5 Raycasting

  When you set up a scene in Unity, you’re creating a virtual 3D world for the characters in your game to move around in. But in most games, things aren’t directly controlled by the player. So how do these objects find their way around a scene? In this lab, we’ll look at how C# can help.

  • “Create a new Unity project and start to set up the scene”

  • “Set up the camera”

  • “Create a GameObject for the player”

  • “Introducing Unity’s navigation system”

  • “Install the AI Navigation package”

  • “Things you’ll do with navigation”

  • “Set up the NavMesh”

  • “Make your player automatically navigate the play area”

• Chapter 11

  • “The life and death of an object”

  • “Use the GC class (with caution) to force garbage collection”

  • “Your last chance to DO something... your object’s finalizer”

  • “When EXACTLY does a finalizer run?”

  • “Finalizers can’t depend on other objects”

  • “A struct looks like an object...”

  • “Values get copied; references get assigned”

  • “Structs are value types; objects are reference types”

  • “The stack vs. the heap: more on memory”

  • “Use out parameters to make a method return more than one value”

  • “Pass by reference using the ref modifier ”

  • “Use optional parameters to set default values”

  • “A null reference doesn’t refer to any object”

  • “Non-nullable reference types help you avoid NREs”

  • “Nullable value types can be null...and handled safely”

  • “The null-coalescing operator ?? checks for nulls automatically”

  • ““Captain” Amazing...not so much”

  • “Records give your objects value equality automatically”

  • “Don’t modify records—copy them”

  • “Extension methods add new behavior to EXISTING classes”

  • “Extending a fundamental type: string”

• Chapter 12

  When you have to deal with error after error, it’s called “putting out fires.”

  Imagine: it’s a few years from now. You spent all that time working on your C# skills and continuing to learn and improve, and now you’re one of the most senior developers at a big tech company. Now you’re getting panicked phone calls in the middle of the night from your support team because your app crashes, or doesn’t behave like it’s supposed to. You want to spend your time writing code, not putting out fires! Because nothing pulls you out of the programming groove like having to fix a strange bug you don’t recognize. Luckily, C# has exception handling, which lets you write code to deal with problems that come up. Better yet, you can even plan for those problems, and keep things running when they happen.

  • “Your hex dumper reads a filename from the command line”

  • “When your program throws an exception, the CLR generates an Exception object”

  • “All Exception objects inherit from System.Exception”

  • “There are some files you just can’t dump”

  • “What happens when a method you want to call is risky?”

  • “Handle exceptions with try and catch”

  • “Use the debugger to follow the try/catch flow”

  • “Catch-all exceptions handle System.Exception”

  • “Use the right exception for the situation”

  • “Exception filters help you create precise handlers”

  • “The worst catch block EVER: catch-all plus comments”

  • “Temporary solutions are OK (temporarily)”

  • “Use NuGet to add a logging library to your app”

  • “Add logging to your ExceptionExperiment app”

• Unity Lab #6 Scene Navigation

  In the last Unity Lab, you created a scene with a floor (a plane) and a player (a sphere nested under a cylinder), and you used a NavMesh, a NavMesh Agent, and raycasting to get your player to follow your mouse clicks around the scene. In this lab, you’ll add to the scene with the help of C#.

  • “Let’s pick up where the last Unity Lab left off”

  • “Add a platform to your scene”

  • “Use bake options to make the platform walkable”

  • “Include the stairs and ramp in the NavMesh”

  • “Make the player navigate around the obstacles”

  • “Get creative!”

This NavMesh Obstacle carves a moving hole in the NavMesh that prevents the player going up the ramp. You’ll add a script that lets the user drag it up and down to block and unblock the ramp.