Revisiting Types, Methods, and Classes

Now that you’ve programmed the game’s mechanics and interactions with Unity’s built-in classes, it’s time to expand our core C# knowledge and focus on the intermediate applications of the foundation we’ve laid. We’ll revisit old friends—variables, types, methods, and classes—but we’ll target their deeper applications and relevant use cases. Many of the topics we’ll be covering don’t apply to Hero Born in its current state, so some examples will be standalone rather than being applied directly to the game prototype.

I’ll be throwing a lot of new information your way, so if you feel overwhelmed at any point, don’t hesitate to revisit the first few chapters to solidify those building blocks. We’ll also be using this chapter to break away from gameplay mechanics and features specific to Unity by focusing on the following topics:

• Intermediate...

Access modifiers

While we’ve gotten into the habit of pairing the public and private access modifiers with our variable declarations, like we did with player health and items collected, there remains a laundry list of modifier keywords that we haven’t seen. We can’t go into detail about every one of them in this chapter, but the five that we’ll focus on will further your understanding of the C# language and give your programming skills a boost.

This section will cover the first three modifiers in the following list, while the remaining two will be discussed later on in the Intermediate OOP section:

• const
• readonly
• static
• abstract
• override

You can find a full list of available modifiers at: https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/modifiers.

Let’s start with the first three access modifiers provided in the preceding list.

Constant and read-only properties...

Revisiting methods

Methods have been a big part of our code since we learned how to use them in Chapter 3, Diving into Variables, Types, and Methods, but there are two intermediate use cases we haven’t covered yet: method overloading and using the ref and out parameter keywords.

Overloading methods

The term method overloading refers to creating multiple methods with the same name but with different signatures. A method’s signature is made up of its name and parameters, which is how the C# compiler recognizes it. Take the following method as an example:

public bool AttackEnemy(int damage) {}

The method signature of AttackEnemy() is written as follows:

AttackEnemy(int)

Now that we know the signature of AttackEnemy(), it can be overloaded by changing the number of parameters or the parameter types themselves, while still keeping its name. This provides added flexibility when you need more than one option for a given operation.

The RestartLevel...

Intermediate OOP

An object-oriented mindset is crucial to creating meaningful applications and understanding how the C# language works behind the scenes. The tricky part is that classes and structs by themselves aren’t the end of the line when it comes to OOP and designing your objects. They’ll always be the building blocks of your code, but classes are limited to single inheritance, meaning they can only ever have one parent or superclass, and structs can’t inherit at all. So, the question you should be asking yourself right about now is simple: “How can I create objects from the same template and have them perform different actions based on a specific scenario?”

To answer this question, we’ll be learning about interfaces, abstract classes, and class extensions.

Interfaces

One of the ways to gather groups of functionality together is through interfaces. Like classes, interfaces are blueprints for data and behaviors, but with one...

Namespace conflicts and type aliasing

As your applications get more complicated, you’ll start to section off your code into namespaces, ensuring that you have control over where and when it’s accessed. You’ll also use third-party software tools and plugins to save on time implementing a feature from the ground up that someone else has already made available. Both of these scenarios show that you’re progressing with your programming knowledge, but they can also cause namespace conflicts.

Namespace conflicts happen when there are two or more classes or types with the same name, which happens more than you’d think.

Good naming habits tend to produce similar results, and before you know it, you’re dealing with multiple classes named Error or Extension, and Visual Studio is throwing out errors. Luckily, C# has a simple solution to these situations: type aliasing.

Defining a type alias lets you explicitly choose which conflicting type...

Summary

With new modifiers, method overloading, class extensions, and object-oriented skills under our belts, we are only one step away from the end of our C# journey. Remember, these intermediate topics are intended to get you thinking about more complex applications of the knowledge you’ve been gathering throughout this book; don’t think that what you’ve learned in this chapter is all that there is to know about these concepts. Take it as a starting point and continue from there.

In the next chapter, we’ll discuss the basics of generic programming, get a little hands-on experience with delegates and events, and wrap up with an overview of exception handling.

Pop quiz—leveling up

1. Which keyword would mark a variable as unmodifiable but requires an initial value?
2. How would you create an overloaded version of a base method?
3. What is the main difference between classes and interfaces?
4. How would you solve a namespace conflict in one of your classes?
5. Don’t forget to check your answers against mine in the Pop Quiz Answers appendix to see how you did!

Join us on discord!

Read this book alongside other users, Unity game development experts and the author himself.

Ask questions, provide solutions to other readers, chat with the author via. Ask Me Anything sessions and much more.

Scan the QR code or visit the link to join the community.

https://packt.link/csharpwithunity