# String

***

**1. Basic String Concatenation**

```csharp
string name = "John";
string lastName = "Doe";
string fullName = name + " " + lastName; // "John Doe"
```

**2. Multiline Strings Using Verbatim String Literals**

```csharp
string verbatimString = @"This is a 
multiline 
string.";
```

**3. String Interpolation Using Verbatim String Literals**

```csharp
string verbatimString = $@"The current time is {DateTime.Now}.";
```

**4. Converting Strings to Uppercase and Lowercase**

```csharp
string upperString = "JOHN".ToLower(); // "john"
string lowerString = "john".ToUpper(); // "JOHN"
```

**5. Removing Leading and Trailing Whitespace**

```csharp
string trimmedString = "    John Doe    ".Trim(); // "John Doe"
```

**6. Comparing Strings**

```csharp
string str1 = "John";
string str2 = "John";
bool areEqual = str1.Equals(str2); // true
```

**7. Finding the Length of a String**

```csharp
string longString = "This is a long string.";
int length = longString.Length; // 24
```

**8. Splitting a String by a Delimiter**

```csharp
string words = "John,Mary,Bob";
string[] wordArray = words.Split(','); // { "John", "Mary", "Bob" }
```

**9. Joining a String Array**

```csharp
string[] words = { "John", "Mary", "Bob" };
string joinedString = string.Join(",", words); // "John,Mary,Bob"
```

**10. Replacing a Substring**

```csharp
string oldString = "John Doe";
string newString = oldString.Replace("Doe", "Smith"); // "John Smith"
```

**11. Searching for a Substring**

```csharp
string haystack = "This is a haystack.";
int index = haystack.IndexOf("haystack"); // 8
```

**12. Extracting a Substring**

```csharp
string longString = "This is a long string.";
string extractedString = longString.Substring(8, 5); // "long"
```

**13. Converting a String to a Char Array**

```csharp
string word = "Hello";
char[] charArray = word.ToCharArray(); // { 'H', 'e', 'l', 'l', 'o' }
```

**14. Converting a Char Array to a String**

```csharp
char[] charArray = { 'H', 'e', 'l', 'l', 'o' };
string word = new string(charArray); // "Hello"
```

**15. Checking if a String Contains a Substring**

```csharp
string haystack = "This is a haystack.";
bool containsNeedle = haystack.Contains("needle"); // false
```

**16. Using StringBuilders for Efficient String Concatenation**

```csharp
StringBuilder builder = new StringBuilder();
builder.Append("This is a").Append(" long").Append(" string."); // "This is a long string."
```

**17. Converting Strings to and from Primitive Types**

```csharp
int number = int.Parse("123"); // 123
string numberString = number.ToString(); // "123"
```

**18. Using String.Format for Custom String Formatting**

```csharp
string message = string.Format("The total is {0:C}", 123.45); // "The total is $123.45"
```

**19. Using Regular Expressions for Complex String Matching**

```csharp
string pattern = "([0-9]+)[-.][0-9]+";
Match match = Regex.Match("123-456", pattern); // Match object for "123-456"
```

**20. Using String.IsNullOrEmpty and String.IsNullOrWhiteSpace**

```csharp
string emptyString = null;
string whitespaceString = " ";

bool isEmpty = string.IsNullOrEmpty(emptyString); // true
bool isWhitespace = string.IsNullOrWhiteSpace(whitespaceString); // true
```

**21. Using StringComparison for Case-Insensitive String Comparisons**

```csharp
string str1 = "JOHN";
string str2 = "john";

bool areEqual = string.Equals(str1, str2, StringComparison.InvariantCultureIgnoreCase); // true
```

**22. Using StringBuilder for Efficient String Pooling**

```csharp
StringBuilder builder = StringBuilderCache.Acquire();
builder.Append("This is a");
builder.Append(" long");
builder.Append(" string.");
string pooledString = StringBuilderCache.GetStringAndRelease(builder); // "This is a long string."
```

**23. Using String.SplitOptions for Fine-Grained String Splitting**

```csharp
string words = "John, Mary, Bob";
string[] wordArray = words.Split(',', StringSplitOptions.RemoveEmptyEntries); // { "John", "Mary", "Bob" }
```

**24. Using String.JoinOptions for Fine-Grained String Joining**

```csharp
string[] words = { "John", "Mary", "Bob" };
string joinedString = string.Join(",", words, StringJoinOptions.RemoveEmptyEntries); // "John,Mary,Bob"
```

**25. Using String.EqualsOrdinal for Ordinal String Comparisons**

```csharp
string str1 = "JOHN";
string str2 = "john";

bool areEqual = string.EqualsOrdinal(str1, str2); // false
```

**26. Using String.ToUpperOrdinal and String.ToLowerOrdinal for Ordinal Case Conversions**

```csharp
string upperString = "JOHN".ToUpperOrdinal(); // "JOHN"
string lowerString = "john".ToLowerOrdinal(); // "john"
```

**27. Using String.CompareOrdinal for Ordinal String Comparison**

```csharp
int result = string.CompareOrdinal("JOHN", "john"); // 1
```

**28. Using String.Intern to Pool String Objects**

```csharp
string internedString = string.Intern("Hello"); // Returns the existing string object for "Hello"
```

**29. Using String.Concat to Efficiently Concatenate Strings**

```csharp
string s1 = "Hello";
string s2 = "World";

string concatenatedString = string.Concat(s1, " ", s2); // "Hello World"
```

**30. Using String.TrimStart and String.TrimEnd to Trim Whitespace**

```csharp
string trimmedString = "    Hello World    ".TrimStart(); // "Hello World    "
trimmedString = trimmedString.TrimEnd(); // "Hello World"
```

**31. Using String.Replace with Multiple Occurrences**

```csharp
string replacedString = "Hello World".Replace(" ", "_"); // "Hello_World"
```

**32. Using String.Split with Range**

```csharp
string[] splitArray = "Hello World".Split(' ', 1); // { "Hello" }
```

**33. Using String.Substring with Negative Start Index**

```csharp
string truncatedString = "Hello World".Substring(-3); // "rld"
```

**34. Using String.CompareTo for String Comparison**

```csharp
int comparisonResult = "Hello".CompareTo("World"); // -1
```

**35. Using String.Equals with StringComparison.OrdinalIgnoreCase**

```csharp
bool isEqual = "Hello".Equals("hello", StringComparison.OrdinalIgnoreCase); // true
```

**36. Using String.IsNullOrEmpty for Null or Empty Strings**

```csharp
bool isEmpty = string.IsNullOrEmpty(""); // true
```

**37. Using String.IsNullOrWhiteSpace for Null, Empty, or Whitespace Strings**

```csharp
bool isWhiteSpace = string.IsNullOrWhiteSpace(" "); // true
```

**38. Using String.Contains for Substring Search**

```csharp
bool containsSubstring = "Hello World".Contains("World"); // true
```

**39. Using String.Trim to Remove Leading and Trailing Whitespace**

```csharp
string trimmedString = "   Hello World   ".Trim(); // "Hello World"
```

**40. Using String.ToUpper and String.ToLower for Case Conversion**

```csharp
string upperString = "hello".ToUpper(); // "HELLO"
string lowerString = "HELLO".ToLower(); // "hello"
```

**41. Using String.StartsWith and String.EndsWith for Prefix and Suffix Checks**

```csharp
bool startsWithHello = "Hello World".StartsWith("Hello"); // true
bool endsWithWorld = "Hello World".EndsWith("World"); // true
```

**42. Using String.IndexOf and String.LastIndexOf for Substring Search**

```csharp
int indexOfHello = "Hello World".IndexOf("Hello"); // 0
int lastIndexOfWorld = "Hello World".LastIndexOf("World"); // 6
```

**43. Using String.Remove and String.Insert for String Manipulation**

```csharp
string removedString = "Hello World".Remove(6, 5); // "Hello"
string insertedString = "Hello World".Insert(6, "!"); // "Hello! World"
```

**44. Using String.Format for String Formatting**

```csharp
string formattedString = string.Format("Hello {0}!", "World"); // "Hello World!"
```

**45. Using String.Join to Concatenate Strings**

```csharp
string joinedString = string.Join(" ", "Hello", "World"); // "Hello World"
```

**46. Using String.Split to Split Strings**

```csharp
string[] splitArray = "Hello World".Split(' '); // { "Hello", "World" }
```

**47. Using String.Replace to Replace Substrings**

```csharp
string replacedString = "Hello World".Replace("World", "Universe"); // "Hello Universe"
```

**48. Using String.TrimStart and String.TrimEnd to Remove Leading and Trailing Whitespace**

```csharp
string trimmedString = "  Hello World  ".TrimStart().TrimEnd(); // "Hello World"
```

**49. Using String.PadLeft and String.PadRight to Pad Strings with Characters**

```csharp
string paddedString = "Hello".PadLeft(10, '*'); // "******Hello"
string paddedString2 = "Hello".PadRight(10, '*'); // "Hello******"
```

**50. Using String.Compare to Compare Strings**

```csharp
int comparisonResult = string.Compare("Hello", "World"); // -1
```