# Char

***

**1. Character Input**

```csharp
char input = Console.ReadKey().KeyChar;
```

**2. Character Comparison**

```csharp
if (char.ToUpper('a') == 'A')
{
    // Do something
}
```

**3. Character Conversion**

```csharp
int asciiCode = (int)'A'; // Returns 65
char character = (char)65; // Returns 'A'
```

**4. Character Formatting**

```csharp
string formattedString = string.Format("{0:C}", 'A'); // Returns "$A"
```

**5. Character Escaping**

```csharp
string escapedString = "Hello \"World\""; // Escapes the double quote
```

**6. Character Iteration**

```csharp
foreach (char c in "Hello World")
{
    // Do something with the character
}
```

**7. Character Array Manipulation**

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

**8. Character Search**

```csharp
int index = "Hello World".IndexOf('l'); // Returns 2
```

**9. Character Replacement**

```csharp
string replacedString = "Hello World".Replace('l', 'r'); // Returns "Herro World"
```

**10. Character Removal**

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

**11. Character Counting**

```csharp
int count = "Hello World".Count(c => c == 'l'); // Returns 3
```

**12. Character Validation**

```csharp
bool isValidChar = char.IsLetter('A'); // Returns true
```

**13. Character Case Conversion**

```csharp
char upperChar = char.ToUpper('a'); // Returns 'A'
char lowerChar = char.ToLower('A'); // Returns 'a'
```

**14. Character Comparison (Unicode)**

```csharp
if (char.Compare('À', 'à') == 0)
{
    // Do something
}
```

**15. Character Unicode Encoding**

```csharp
byte[] bytes = System.Text.Encoding.UTF8.GetBytes("À");
```

**16. Character Unicode Decoding**

```csharp
string str = System.Text.Encoding.UTF8.GetString(bytes); // Returns "À"
```

**17. Character Byte Representation**

```csharp
byte[] bytes = "À".ToUtf8Bytes();
```

**18. Character String Representation**

```csharp
string str = "À".ToUtf8String();
```

**19. ASCII Code Retrieval**

```csharp
int asciiCode = (int)'A'; // Returns 65
```

**20. Unicode Code Point Retrieval**

```csharp
int codePoint = char.ConvertToUtf32('À', ' '); // Returns 201
```

**21. Character Category Determination**

```csharp
UnicodeCategory category = char.GetUnicodeCategory('À'); // Returns UppercaseLetter
```

**22. Character Culture-Specific Comparison**

```csharp
if (char.Compare('À', 'à', CompareOptions.IgnoreCase) == 0)
{
    // Do something
}
```

**23. Character Invariant Culture Comparison**

```csharp
if (char.InvariantCompare('À', 'à') == 0)
{
    // Do something
}
```

**24. Character Latinization**

```csharp
string latinizedString = "À".ToLatinUpper(); // Returns "A"
```

**25. Character Normalization**

```csharp
string normalizedString = "À".Normalize(); // Returns "a"
```

**26. Character Decomposition**

```csharp
string decomposedString = "À".Decompose(); // Returns "A\u0300"
```

**27. Character Composition**

```csharp
string composedString = "A\u0300".Compose(); // Returns "À"
```

**28. Character Line Break Determination**

```csharp
UnicodeLineBreakType lineBreakType = char.GetUnicodeLineBreakType('À'); // Returns LineBreak
```

**29. Character Word Break Determination**

```csharp
UnicodeWordBreakType wordBreakType = char.GetUnicodeWordBreakType('À'); // Returns MidNumLet
```

**30. Character Script Determination**

```csharp
UnicodeScript script = char.GetUnicodeScript('À'); // Returns Latin
```

**31. Character Numeric Value Retrieval**

```csharp
double number = double.Parse('3'); // Returns 3
```

**32. Character Symbol Unicode Retrieval**

```csharp
string symbol = char.GetSymbol(UnicodeCategory.CurrencySymbol, '€'); // Returns Euro
```

**33. Character Emoji Unicode Retrieval**

```csharp
string emoji = char.GetSymbol(UnicodeCategory.ModifierSymbol, '☺'); // Returns Smiling Face
```

**34. Character Directionality Determination**

```csharp
UnicodeBidiCategory directionality = char.GetUnicodeBidiCategory('À'); // Returns LeftToRight
```

**35. Character Character Type Determination**

```csharp
UnicodeCharacterType characterType = char.GetUnicodeCharacterType('À'); // Returns UppercaseLetter
```

**36. Character Mirroring Determination**

```csharp
bool isMirrored = char.IsMirrored('À'); // Returns false
```

**37. Character Is Surrogate Pair Determination**

```csharp
bool isSurrogatePair = char.IsSurrogatePair('À', ' '); // Returns false
```

**38. Character Is High Surrogate Pair Determination**

```csharp
bool isHighSurrogate = char.IsHighSurrogate('À'); // Returns false
```

**39. Character Is Low Surrogate Pair Determination**

```csharp
bool isLowSurrogate = char.IsLowSurrogate(' '); // Returns false
```

**40. Character Midpoint Between Two Characters**

```csharp
char midpoint = char.GetMidpointCharacter('a', 'z'); // Returns 'n'
```

**41. Character Source Code Escape**

```csharp
string escapedString = "À".ToSourceCodeEscapedString(); // Returns "\u00C0"
```

**42. Character Japanese Era Name Retrieval**

```csharp
string eraName = char.GetJapaneseEraName(8); // Returns "Showa"
```

**43. Character Pinyin Tone Value Retrieval**

```csharp
int toneValue = char.GetPinyinToneNumber('à'); // Returns 4
```

**44. Character Surrogate Pair Retrieval**

```csharp
char[] surrogates = char.ConvertFromUtf32('À', 0); // Returns ['À', '0']
```

**45. Character Character Name Retrieval**

```csharp
string characterName = char.GetName('À'); // Returns "LATIN CAPITAL LETTER A WITH GRAVE"
```

**46. Character Round Trip Conversion**

```csharp
char originalCharacter = 'À';
char restoredCharacter = char.ConvertFromUtf32(char.ConvertToUtf32(originalCharacter, 0), 0); // Returns 'À'
```

**47. Character Symbol Lookup**

```csharp
string symbol = char.GetSymbol(UnicodeCategory.ModifierSymbol, '\u263A'); // Returns White Smiling Face
```

**48. Character Surrogate Pair Check**

```csharp
bool isSurrogatePair = char.IsSurrogatePair('À', '\u0300'); // Returns true
```

**49. Character String Concatenation**

```csharp
string concatenatedString = string.Concat('À', '\u0300'); // Returns "À"
```

**50. Character String Comparison**

```csharp
bool areEqual = 'À' == '\u00C0'; // Returns true
```