Unity Basic Course: C# Strings (string)

In C#, strings are one of the most fundamental data types used for storing text. When developing games in Unity, strings are essential in various elements such as character names, dialogue, team names, and more. This tutorial will provide an in-depth explanation of the string type in C# and introduce how to use it in Unity.

What is a String?

A string is a collection of characters, represented by wrapping it in ‘single quotes’ or ‘double quotes’. In C#, a string is an instance of the System.String class. Strings are immutable data types, meaning once a string is created, it cannot be changed. Instead, when modification is needed, a new string is created and returned.

Declaring and Initializing Strings

There are several ways to declare and initialize a string. The most basic method is as follows:

string myString = "Hello, Unity!";

Here, myString is a string variable that stores the text “Hello, Unity!”.

Initializing Strings in Various Ways

Let’s look at different methods to initialize strings.

string emptyString = ""; // An empty string
string anotherString = new string('A', 10); // A string with the character 'A' repeated 10 times

String Operations

C# provides various methods for handling strings. The simplest way to concatenate strings is by using the plus (+) operator.

string firstName = "John";
string lastName = "Doe";
string fullName = firstName + " " + lastName; // "John Doe"

String.Format Method

To create more complex strings, you can use the String.Format method, which formats the values given as arguments into a string.

int score = 100;
string message = String.Format("Your score is {0}.", score); // "Your score is 100."

String Interpolation

Since C# 6.0, you can use string interpolation, which allows you to use variables directly within strings.

string message = $"Your score is {score}."; // "Your score is 100."

String Methods

The String class in C# provides various methods for working with strings. Here, we will look at some commonly used methods.

String Length

int length = myString.Length; // Returns the length of the string.

String Search

To check if a specific character is included in a string, you can use the Contains method.

bool containsHello = myString.Contains("Hello"); // true

Substring

You can extract a part of a string using the Substring method.

string sub = myString.Substring(7, 5); // "Unity"

String Split

If you want to split a string by a specific delimiter, you can use the Split method.

string[] words = "Unity, C#, String".Split(','); // ["Unity", " C#", " String"]

Changing Case of Strings

To convert all characters in a string to uppercase or lowercase, you can use the ToUpper and ToLower methods.

string upper = myString.ToUpper(); // "HELLO, UNITY!"
string lower = myString.ToLower(); // "hello, unity!"

Using Strings in Unity

In Unity, strings are needed in various places. For example, they can be used in UI text, log messages, dialogue systems, and more. Below are some examples of how to utilize strings in Unity.

Displaying Strings in UI Text

You can use Unity’s Text component to display strings on the screen.

using UnityEngine;
using UnityEngine.UI;

public class ScoreDisplay : MonoBehaviour
{
    public Text scoreText;
    private int score = 0;

    void Start()
    {
        UpdateScore();
    }

    public void UpdateScore()
    {
        scoreText.text = $"Current Score: {score}"; // Using string interpolation
    }
}

Printing Log Messages

You can use the Debug.Log method to print strings to the console.

Debug.Log("The game has started!"); // Output to the console

Creating a Dialogue System

You can implement a simple dialogue system using strings. Each part of the dialogue is stored as a string and displayed based on specific conditions.

public class Dialogue : MonoBehaviour
{
    private string[] dialogues = {
        "Hello! I am Character A.",
        "How can I assist you here?",
        "Have a great day!"
    };

    private int currentDialogueIndex = 0;

    public void ShowNextDialogue()
    {
        if (currentDialogueIndex < dialogues.Length)
        {
            Debug.Log(dialogues[currentDialogueIndex]);
            currentDialogueIndex++;
        }
    }
}

Practical Uses of String Formatting

String formatting is very useful for displaying various data in games. When dealing with scores, levels, item counts, etc., formatting can present this information more intuitively and clearly.

Scoreboard Example

Let’s examine an example of formatting and displaying a player’s score on a scoreboard.

using UnityEngine;
using UnityEngine.UI;

public class ScoreBoard : MonoBehaviour
{
    public Text scoreText;
    private int playerScore;

    public void AddScore(int points)
    {
        playerScore += points;
        UpdateScoreDisplay();
    }

    private void UpdateScoreDisplay()
    {
        scoreText.text = $"Player Score: {playerScore:N0}"; // Using thousand separators
    }
}

Useful Tips for Handling Strings

Here are a few useful tips when working with strings.

String Comparison

When comparing strings, you can use the String.Equals method or the == operator. If you want to ignore case during comparison, use String.Compare.

bool isSame = String.Equals("apple", "Apple", StringComparison.OrdinalIgnoreCase); // true

Creating Infinite Strings

If you want to repeat a string infinitely, you can use the String.Concat method. However, be cautious as this may increase memory usage, so use appropriately.

string repeated = String.Concat(Enumerable.Repeat("A", 1000)); // A string of 'A' repeated 1000 times

Conclusion

So far, we have covered the basic concepts of strings in C# and how to utilize them in Unity. Strings are essential elements in Unity development, used in various areas such as dialogue systems, scoreboards, and UI. I hope the contents discussed in this tutorial help you develop better games.