CYBER WEEK SALE: Get 50% off your Pro annual membership using code [CYBER23](https://www.codecademy.com/checkout?periods=year&plan_id=proGoldAnnualV2&discountCode=CYBER23)


Learn how to write short programs with text. 

Working with Text

Often, we want to combine strings together, or combine strings with a value that we've saved to a variable. 

A common way to do is by using _string concatenation_. String concatenation is when we combine strings using the addition symbol (`+`), literally adding one string to another. 

```csharp
string yourFaveMusician = "David Bowie";
string myFaveMusician = "Solange";

Console.WriteLine("Your favorite musician is " + yourFaveMusician + " and mine is " + myFaveMusician + ".");
```

We write the first part of our string, end it with a double quote (`"`), include an addition symbol and then put our variable. However, there are a couple of things to pay attention to:

* If we want to concatenate a string with something that is another data type, C# will implicitly convert that value to a string. 
* Make sure that you include spaces and proper punctuation so that when it prints out, your variable strings aren't squished between the rest of the statement. Notice how we have to create a one character string at the end to include a period. 



String Concatenation

Working with text is a fundamental part of writing programs. Whether it's to provide instructions to a user, gathering data like a name or address, or writing a new form of poetry, text enables us to bring human language into computational form. 

In this lesson, we'll look at the two commonly used text data types in C#: char and string. By the end of this lesson, you will be able to manipulate textual data and write programs that take in user inputs and output customizable messages using variables, operators, and built-in methods. 

Introduction to Working with Text

Great job! You just learned about how to work with textual data in a few different ways: 
- How to save char and string values to a variable.
- Use the addition symbol (`+`) to concatenate strings.
- Interpolate strings for easier string construction.
- Find information about a string using `.Length` and `.IndexOf()`.
- Grab characters and parts of strings using bracket notation and `.Substring()`. 
- Use built-in methods such as `.ToUpper()` and `.ToLower()` to manipulate strings.

Now use what you've learned to write a short program! Some ideas:

- Write a program that randomly converts part of a text to uppercase and lowercase to look like [randomcase](http://www.unit-conversion.info/texttools/randomcase/). 
- Write a program that takes in a series of random words to construct an automated poem, in the style of e.e. cummings. 


Review

A _string_ is a group of characters surrounded by quotation marks, like `"https://codecademy.com"` or `"To be or not to be."` A string is just a collection of a smaller data type, _char_, which is a single character like "a" or "?".

To define a variable as a string, you write the data type, then the variable name. Then set it equal to the value, which is inside of quotation marks :

```csharp
string variableName = "puppy";
```

The variable is named `variableName`, it's of type `string`, and its value is `"puppy"`.

#### Escape Character Sequences
What happens when you need to include quotes in a string? You can use an escape sequence. An escape sequence places a backslash (`\`) before the inner quotation marks, so the program doesn't read them accidentally as the end of sequence. 

```csharp
string withoutSlash = "Ifemelu said, "Hello!"";

string withSlash = "Ifemelu said, \"Hello!\"";
```

We can use escape character sequences to create a newline. That means that when we print the string to the console, it will print that line below the rest. If printed on its own, it will create an empty line. To create a newline, use the character combination `\n`.
 
```csharp
string newLine = "Ifemelu walked \n to the park.";
```

For more on escape sequences, check out [Microsoft's Documentation](https://docs.microsoft.com/en-us/cpp/c-language/escape-sequences?view=vs-2017).

Building Strings

While string concatenation is easy to read, it can get annoying to write. Another option is _string interpolation_. String interpolation was introduced in C# 6 and it enables us to insert our variable values and expressions in the middle of a string, without having to worry about spaces and punctuation. 

```csharp
string yourFaveMusician = "David Bowie";
string myFaveMusician = "Solange";

Console.WriteLine($"Your favorite musician is {yourFaveMusician} and mine is {myFaveMusician}.");
```
Notice how we just have one string, which we append with the dollar sign symbol `$`. Make sure there isn't a space in between the `$` and the starting quotation mark `"`. Whenever we need to insert a variable, we surround it with braces `{}`.For more on string interpolation, [check out Microsoft's documentation](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/interpolated). 

In older documentation, you may come across a slightly similar syntax. This style is known as string formatting or composite formatting. Since the introduction of string interpolation, it is rarely used. But in case you come across it, [check out Microsoft's documentation](https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/strings/index#format-strings). 


String Interpolation

In addition to containing the value of a piece of text, strings also contain information about themselves. It can be useful to know these properties when working with strings. There are several built-in .NET methods that we can use to get more information about strings. 

#### Length
Since strings are composed of a set of characters, we can find out how many characters exist in a string with the `.Length` method. A common example is if we're building a form and need to make sure a user submission doesn't exceed a certain character length. 

```csharp
string userTweet = Console.ReadLine();

userTweet.Length; // returns the length of the tweet
```

We append the `.Length` property to a string that we have, such as a user's tweet. 

#### IndexOf
We can also find the position of a specific character or substring using `.IndexOf()`. This method is useful for searching to see if something exists in a string. 

If it does exist within a string, the method will return the _position_ of the search term in the larger string. Each character in a string has a unique position, like an address. Positions starts at 0 and increment by 1. 

```csharp
string word = "radio";

word.IndexOf("a"); // returns 1
```

Since positioning starts at 0, the second thing in the string will return a 1. If it doesn't exist in the string the method will return a -1. If we pass it an empty string, it will return 0. If it occurs more than once, it will return the first instance. 


Get Info About Strings

There are also built-in .NET methods that we can use to manipulate text data. Using these methods on a string doesn't change the string itself, but creates an entirely new one.

#### ToUpper, ToLower
We can quickly change the case of our strings using the methods `.ToUpper()` and `.ToLower()`. These methods are useful if we want to make our text look like an e.e. cumming's poem or make it appear like we forgot to turn off our caps lock key. 

```csharp
string shouting = "I'm not shouting, you're shouting".ToUpper();
Console.WriteLine(shouting);
// prints I'M NOT SHOUTING, YOU'RE SHOUTING.
```


Manipulate Strings

We can also use built-in .NET methods to grab parts of strings or specific characters in a string. 

#### Substring
`.Substring()` grabs part of a string using the specified character position, continues until the end of the string, and returns a new string. `.IndexOf()` is usually used first to get the specific character position. 

```csharp
string plantName = "Cactaceae, Cactus"; 
int charPosition = plantName.IndexOf("Cactus"); // returns 11
string commonName = plantName.Substring(charPosition); // returns Cactus
```
`.Substring()` is useful if we only want to use part of a string but keep the original data intact. So in this instance, we want to keep the string `plantName`, but just grab the `"Cactus"` portion of the string. We use `.IndexOf()` to find where `"Cactus"` starts, then use `.Substring()` with the position information to save `"Cactus"` to the new variable `commonName`. 

We can also pass `.Substring()` a second argument, which will determine the number of characters in the resulting substring. For example, the following code shows how we can use `.Substring()` with two arguments to specify the length of our substring:
```csharp
string name = "Codecademy"; 
int start = 2;
int length = 6;
string substringName = name.Substring(start, length); // returns 'decade'
```

#### Bracket Notation
Bracket notation is a style of syntax that uses brackets `[]` and an integer value to identify a particular value in a collection. In this case, we can use it to find a specific character in a string.

```csharp
string plantName = "Cactaceae, Cactus";
int charPosition = plantName.IndexOf("u"); // returns 15
char u = plantName[charPosition]; // returns u
```

Similar to the example above, we first use `.IndexOf()` to grab the character position, which in this case is 15. We then take the string value and append it with a set of brackets `[]` and place the `charPosition` value inside the brackets. 
