In the previous TechTip, I showed you a couple of string methods, which were somewhat similar to RPG BIFs. This time, I’ll show you how to discover what’s available and introduce a couple of object-oriented languages concepts.

Start firing up Visual Studio, because this is going to be a hands-on TechTip! I’ll explain a few more string methods, so that you can get familiar with the way Visual Studio can help you choose the right tool for the job, or, in other words, the right method for the job.

If you haven’t been following this series, go back to the previous TechTip and copy-paste the full code to a new Console Application project. This TechTip from earlier in this series explains how it’s done.

Now position the cursor below the string aTextTest = "Hi everyone!"; line and type, not copy/paste, the following:

int myStringLen = aTextTest.L

You’ll see Visual Studio making its magic and offering contextualized suggestions to help you speed up the work:

Figure 1: Visual Studio offers contextual help.

In this case, the help comes in the form of a list of methods and properties of the String object type. Because I typed an “L” after the dot, the first item of the list that starts with an “L” is highlighted. But that’s not what I’m looking for; I want to find the Length property, in order to store the aTextTest string length in the myStringLen variable.

Let me just explain the symbols used on this list: a purple symbols indicate that the item is a method, and a black wrench tells us that the item is a property. In some cases, there’s an arrow, pointing down, next to them. This indicates that this method/property is inherited from the parent object of the object (String in this case). As I explained in the prequel to this series, a class (the blueprint of an object) can be extended. This extension class will inherit methods and properties of its parent class, unless otherwise specified (more on this later in the series). In other words, the String object inherits from its parent all the methods you see on the list with an arrow next to the cube, which identifies the item as a method.

Having said that, let’s find and select the Length property. Just use the mouse or the down arrow of your keyboard to highlight the item with the wrench (yes, Length is the String’s only property) and press Enter (or left-click). End the line with a semi-colon and you’re done. This will store the current length of the aTextTest in the myStringLen variable. Keep in mind that if the aTextTest is changed, this value will not be automatically updated.

Now let’s use some other String methods. Position the cursor below the Console.WriteLine(aTextTest.Substring(0, 2)); line, open a new line and (again) type, not copy/paste, the following:

Console.WriteLine("The first 'e' in '" + aTextTest + "' is in position " + aTextTest.i

As you’d expect, a list of methods and properties is shown. Select the highlighted item, IndexOf, and press Enter. Because this is a method, you’ll need a pair of parentheses in front of it. Type “(“ and a funny thing will happen: Visual Studio adds the closing parenthesis and shows you a popup explaining what IndexOf does, what its parameters are, and so on, as shown in Figure 2.

Figure 2: Visual Studio performs “magic” by showing method description and parameters.

Let’s analyze this piece of information. The first line, int string.IndexOf(char value), tells us that the IndexOf method is part of the string object and will return an int (if you don’t remember the way variables are declared, I explained it here). It also tells us that this “version” of the method accepts a char as its only parameter. However, there are eight other versions of this method, as you can see from the information on the top left corner of the popup.

This might sound confusing, especially because it’s not possible in RPG, but it’s a “feature” of object-oriented (OO) programming languages: you can have different pieces of code doing different things with the same name and different parameters. How and why, you ask? Well, the how part is simple: in order to “know” which “version” of the method you want to use, the compiler looks at the parameters—namely, how many there are and what their types are. If it finds a match—i.e., a version of the method with the same number of parameters and the same types in the right order—it’ll execute that piece of code. The why part should be easy to guess: if you have different parameters, you might have to process them differently to perform whichever task the method needs to perform. This is called overloading, and it’s a fundamental OO concept. I’ll be building overloaded methods later in this series, and the concept will be made clearer then.

Let’s go back to the code. Complete the line of code so it looks like this:

Console.WriteLine("The first 'e' in '" + aTextTest + "' is in position " + aTextTest.IndexOf("e"));

Note that if instead of aTextTest.IndexOf("e"), I decided to type aTextTest.IndexOf("one"). This would still work because, even though the compiler considers “e” to be a char value and “one” to be a string value, there are methods with both signatures. A method’s signature is composed of its name and parameter list.

Finally, add these two lines below it:

Console.WriteLine("The last 'e' in '" + aTextTest + "' is in position " + aTextTest.LastIndexOf("e"));

Console.WriteLine("The total length of the string is " + myStringLen);

If you look it up (you can find all of string’s methods on this link), you’ll see that LastIndexOf returns the position of the last occurrence of the value of the parameter (which can be a char, a string, and so on).

Here’s the complete code at this time:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace ExploringDataTypes

{

   class Program

   {

       static void Main(string[] args)

       {

           int integerTest = 0;

           decimal usedForCurrency = 0;

           float aDifferentNumberFormat = 0.01234567890F;

           double andYetAnotherOne = 0.01234567890D;

           bool boolTest = true;

           int aDifferentInteger = 1 + 3;

           bool aDifferentBool = (usedForCurrency == integerTest);

          string aTextTest = "Hi everyone!";

           int myStringLen = aTextTest.Length;

           Console.WriteLine("integerTest's value is " + integerTest

               + ", usedForCurrency holds " + usedForCurrency

               + ", aDifferentNumberFormat's value is " + aDifferentNumberFormat

               + ", while andYetAnotherOne stores " + andYetAnotherOne);

           Console.WriteLine();

           Console.WriteLine(aTextTest);

           Console.WriteLine(aTextTest.ToUpper());

           Console.WriteLine(aTextTest.Substring(0, 2));

           Console.WriteLine("The first 'e' in '" + aTextTest + "' is in position " + aTextTest.IndexOf("e"));

           Console.WriteLine("The last 'e' in '" + aTextTest + "' is in position " + aTextTest.LastIndexOf("e"));

           Console.WriteLine("The total length of the string is " + myStringLen);

           Console.ReadKey();

       }

   }

}

If you run the program, the output should look like this:

Figure 3: Here’s our program’s output.

To sum it up, here’s what was discussed in this TechTip:

• Visual Studio’s contextual help is a great asset, designed to help you program faster and easier.
• Objects have methods (prefixed with symbols in the object items’ list provided by Visual Studio) and properties (prefixed with wrenches), and both can be inherited from the object’s parent object.
• A method can have multiple “versions” with the same name and different parameters. This is called overloading, and it’s a fundamental OO concept.
• The compiler identifies which “version” of the method to use by its signature—i.e., its name and list of parameters.

The next TechTip will continue to use strings to introduce OO and C# concepts before I move on to (even more) complex objects. Until then, feel free to comment on this series on the comments section below or in the usual Linkedin groups.