C# for RPGers: Making Stuff Happen, Part 1 - Introducing Flow Control in C#

Programming - Other
  • Smaller Small Medium Big Bigger
  • Default Helvetica Segoe Georgia Times

Now that you know a few things about declaring variables and using methods, let’s see how to make decisions in C#, using logical operators and the IF statement.

It’s time to move to a new topic: decision making. In order to do that, you’ll need to know how to declare variables and use methods in C#. If you’re not entirely sure how to do that, go back a few TechTips to get comfortable with these things.

If Statements and Comparison Operators

Before we actually begin, let me briefly remind you how to create a variable and assign a value to it. For instance, let’s say there’s an integer variable (declared somewhere else) named myNumber. Assign the value 24 to it:

myNumber = 24;

You remember this, right? It’s similar to RPG’s way of assigning a value to variable, so there’s nothing “new” here. However, when it comes to comparing myNumber with something else using an IF statement, things start to get a bit different. In RPG free-format, you’d write basically the same thing as in the assignment statement plus the IF:

If (myNumber = 12);

I’ve added the opening and closing parentheses for readability’s sake, as they’re not mandatory in RPG. C#’s syntax requires that you explicitly distinguish between assignment and comparison. How? Well, as I explained in greater detail in a previous TechTip, you use a single equals sign (=) to assign a value to a variable, but you have to use a double equals sign (==) when you want to compare something. Here’s C#’s equivalent to the RPG code above:

if (myNumber == 12);

Note that you’re required to use not only the double equals sign, but also the pair of parentheses, because unlike RPG’s version, C#’s IF statement requires the condition being evaluated to be enclosed in parentheses.

The body of C#’s IF statement is also different from its RPG counterpart. RPG’s version is implicitly delimited by the IF statement and its matching ENDIF statement. In C#, the “body” of an IF statement is delimited by curly braces ({}), just as in any other code block, as shown in previous TechTips. Having said that, it’s time to show the complete syntax of an IF statement in C#:

            if (myNumber == 12)


                // do something if myNumber is equal to 12,

                // in other words, do something

                // if the condition above evaluates to true




                // do something else if myNumber is not equal to 12

                // in other words, do something

                // if the condition above evaluates to false


Introducing the Equals Method

Comparing strings (and more generally, objects) in C# is slightly different. I won’t go into the details of why just yet, because you need to know a few more things about C# first, but I promise I’ll get back to it later in the series. For now, let’s focus on the how.

Let’s say there’s a string variable named myString. If I want to use it in an IF statement, I shouldn’t use the regular comparison operator (==), because a string is actually an object, so to compare its value with something else, I should use the Equals method. This method takes the value-to-compare as argument. Here’s an example of an IF statement that “does something” if myString is equal to “Another string” or “does something else” if it isn’t:

            if(myString.Equals("Another string"))


                // do something




                // do something else


It’s important to remember that some data types are objects, and others are not. The so-called primitive data types (int, double, float, and so on) can be compared to a value using the double equals sign, while the complex data types (strings, arrays, collections, and objects in general) shouldn’t, even though C# won’t complain if you use the double equals sign. The problem is that you won’t actually be comparing the value, but something else. I’ll explain this in depth later in this series.

Logical Operators and Composed Conditions

As you probably know, usually a simple is equal to comparison is not enough. C# offers all the usual logical operators, albeit some are a little peculiar. Let’s briefly review the list and then see an example:

  • >, <, >=, <= — This is the usual set of operators for greater/smaller than comparisons, and C#’s implementation is akin RPG’s. Note, however, that you shouldn’t use them with strings and other objects!
  • ==, != — You already know what the double equals sign is for, so it shouldn’t be too difficult to guess what “!=” does. It’s the not equals, C# style. Now you’re probably wondering if there’s a NotEquals method for comparing objects. Well, there isn’t, but there’s something else you can use: the negation operator, explained next.
  • ! — This is equivalent to RPG’s NOT operator. Simply put it before a condition, and it flips that condition’s Boolean value. For instance, writing !myString.Equals("Another string") is the negation of the equality between the myString variable and the "Another string" value.
  • &&, ||— These are C#’s equivalent to AND and OR, respectively.

Let’s wrap up with another IF example, using some of these operators:

            if((myNumber >= 22) && (!myString.Equals("Some string")))


                // do something if myNumber is greater or equal than 22

                // AND

                // myString is NOT EQUAL to "some string"


What’s Next?

That’s all the time I have today! Next time, I’ll talk about C#’s equivalent to the SELECT-WHEN RPG control flow structure and a kind of shorthand version of the IF statement!