C# Cheat Sheet

1. Variables


int x = 10; // integer variable
double y = 20.5; // floating-point variable
char name = 'A'; // character variable

2. Data Types


int, float, char, double, long, short, unsigned

3. Operators


+, -, \*, /, %, ==, !=, >, <, >=, <=, &&, ||, !

4. Control Structures


if (condition) { code }
if (condition) { code } else { code }
switch (expression) { case value: code; break; }
for (init; condition; increment) { code }
while (condition) { code }
do { code } while (condition);

5. Loops


for (int i = 0; i < 10; i++) { code }
while (i < 10) { code; i++; }
do { code; i++; } while (i < 10);

6. Arrays


int[] scores = {90, 80, 70, 60};
char[] names = {'J', 'o', 'h', 'n'};

7. Methods


int Add(int a, int b) { return a + b; }
void Greet(string name) { Console.WriteLine("Hello, " + name); }

8. Classes


public class Person {
    private string name;
    public Person(string name) { this.name = name; }
    public void Display() { Console.WriteLine("Name: " + name); }
}

9. Objects


Person person = new Person("John Doe");
person.Display(); // prints "Name: John Doe"

10. Inheritance


public class Animal {
    public void Sound() { Console.WriteLine("The animal makes a sound."); }
}
public class Dog : Animal {
    public void Sound() { Console.WriteLine("The dog barks."); }
}

11. Polymorphism


public class Animal {
    public virtual void Sound() { Console.WriteLine("The animal makes a sound."); }
}
public class Dog : Animal {
    public override void Sound() { Console.WriteLine("The dog barks."); }
}
Animal animal = new Dog();
animal.Sound(); // prints "The dog barks."

12. Encapsulation


public class Person {
    private string name;
    public Person(string name) { this.name = name; }
    public string GetName() { return name; }
}

13. Abstraction


public abstract class Animal {
    public abstract void Sound();
}
public class Dog : Animal {
    public override void Sound() { Console.WriteLine("The dog barks."); }
}

14. Interface


public interface IPrintable {
    void Print();
}
public class Document : IPrintable {
    public void Print() { Console.WriteLine("Printing document..."); }
}

15. Exception Handling


try { code } catch (Exception e) { code }

16. File Input/Output


using System.IO;
File.WriteAllText("example.txt", "Hello, World!");

17. Networking


using System.Net;
using System.Net.Sockets;
TcpClient client = new TcpClient();

18. Multithreading


using System.Threading;
Thread thread = new Thread(new ThreadStart(MyMethod));
thread.Start();

19. Lambda Expressions


Func<int, int> add = x => x + 1;

20. LINQ


using System.Linq;
var numbers = new List<int> { 1, 2, 3, 4 };
var evenNumbers = numbers.Where(n => n % 2 == 0);

21. Nullable Types


int? nullableInt = null;

22. Tuples


var tuple = (1, "Hello");
Console.WriteLine(tuple.Item2); // prints "Hello"

23. String Interpolation


string name = "John";
Console.WriteLine($"Hello, {name}!");

24. String Methods


string str = "Hello, World!";
string upper = str.ToUpper();

25. Collections


List<int> numbers = new List<int> { 1, 2, 3 };
Dictionary<int, string> map = new Dictionary<int, string>();

26. Generics


public class GenericClass<T> {
    public T Value { get; set; }
}

27. Attributes


[Obsolete("This method is obsolete.")]
public void OldMethod() { }

28. Properties


public class Person {
    public string Name { get; set; }
}

29. Indexers


public class MyCollection {
    private int[] array = new int[10];
    public int this[int index] {
        get { return array[index]; }
        set { array[index] = value; }
    }
}

30. Events


public event EventHandler MyEvent;
MyEvent?.Invoke(this, EventArgs.Empty);

31. Delegates


public delegate void MyDelegate(string message);

32. Async/Await


public async Task MyMethodAsync() {
    await Task.Delay(1000);
}

33. Using Statements


using (var stream = new FileStream("file.txt", FileMode.Open)) { }

34. Extension Methods


public static class MyExtensions {
    public static int Square(this int number) { return number * number; }
}

35. Reflection


Type type = typeof(Person);
var properties = type.GetProperties();

36. Dynamic Types


dynamic obj = new ExpandoObject();
obj.Name = "John";

37. Using LINQ with SQL


using (var context = new MyDbContext()) {
    var users = context.Users.Where(u => u.IsActive).ToList();
}

38. JSON Serialization


using System.Text.Json;
string json = JsonSerializer.Serialize(myObject);

39. XML Serialization


using System.Xml.Serialization;
XmlSerializer serializer = new XmlSerializer(typeof(MyClass));

40. File Handling


File.WriteAllText("example.txt", "Hello, World!");
string content = File.ReadAllText("example.txt");

41. Console Input/Output


Console.WriteLine("Enter your name:");
string name = Console.ReadLine();

42. StringBuilder


StringBuilder sb = new StringBuilder();
sb.Append("Hello");
sb.Append(" World");

43. HashSet


HashSet<int> set = new HashSet<int> { 1, 2, 3 };

44. SortedSet


SortedSet<int> sortedSet = new SortedSet<int> { 3, 1, 2 };

45. Queue


Queue<int> queue = new Queue<int>();
queue.Enqueue(1);
queue.Enqueue(2);

46. Stack


Stack<int> stack = new Stack<int>();
stack.Push(1);
stack.Push(2);

47. Task Parallel Library


Parallel.For(0, 10, i => { /* code */ });

48. Thread Pool


ThreadPool.QueueUser WorkItem(state => { /* code */ });

49. CancellationToken


CancellationTokenSource cts = new CancellationTokenSource();
CancellationToken token = cts.Token;

50. Task


Task.Run(() => { /* code */ });

51. ValueTuple


var valueTuple = (1, "Hello");
Console.WriteLine(valueTuple.Item2); // prints "Hello"

52. String.Format


string formatted = string.Format("Hello, {0}!", "John");

53. String.Split


string[] parts = "a,b,c".Split(',');

54. String.Join


string result = string.Join(",", new[] { "a", "b", "c" });

55. String.Contains


bool contains = "Hello".Contains("ell");

56. String.IndexOf


int index = "Hello".IndexOf("e");

57. String.Substring


string sub = "Hello".Substring(1, 3); // "ell"

58. String.Replace


string replaced = "Hello".Replace("e", "a");

59. String.Trim


string trimmed = "  Hello  ".Trim();

60. String.Equals


bool isEqual = "Hello".Equals("hello", StringComparison.OrdinalIgnoreCase);

61. String.Compare


int comparison = string.Compare("a", "b");

62. String.ToCharArray


char[] chars = "Hello".ToCharArray();

63. String.IsNullOrEmpty


bool isNullOrEmpty = string.IsNullOrEmpty(null);

64. String.IsNullOrWhiteSpace


bool isNullOrWhiteSpace = string.IsNullOrWhiteSpace("   ");

65. String.Concat


string concatenated = string.Concat("Hello", " ", "World");

66. StringBuilder.AppendFormat


StringBuilder sb = new StringBuilder();
sb.AppendFormat("Hello, {0}!", "John");

67. String.Join with LINQ


var names = new List<string> { "John", "Jane" };
string result = string.Join(", ", names);

68. Dictionary


Dictionary<int, string> dict = new Dictionary<int, string>();
dict.Add(1, "One");

69. List.Sort


List<int> list = new List<int> { 3, 1, 2 };
list.Sort();

70. List.Reverse


list.Reverse();

71. List.Contains


bool exists = list.Contains(1);

72. List.IndexOf


int index = list.IndexOf(2);

73. List.Remove


list.Remove(1);

74. List.Clear


list.Clear();

75. Dictionary.ContainsKey


bool hasKey = dict.ContainsKey(1);

76. Dictionary.Remove


dict.Remove(1);

77. Dictionary.TryGetValue


if (dict.TryGetValue(1, out string value)) { /* code */ }

78. StringBuilder.Clear


sb.Clear();

79. StringBuilder.Length


int length = sb.Length;

80. StringBuilder.Capacity


int capacity = sb.Capacity;

81. StringBuilder.ToString


string result = sb.ToString();

82. Task.Delay


await Task.Delay(1000);

83. Task.WhenAll


await Task.WhenAll(task1, task2);

84. Task.WhenAny


var completedTask = await Task.WhenAny(task1, task2);

85. CancellationTokenSource.Cancel


cts.Cancel();

86. CancellationToken.ThrowIfCancellationRequested


token.ThrowIfCancellationRequested();

87. Using Statement with IDisposable


using (var resource = new Resource()) { /* code */ }

88. String.IsNullOrEmpty


bool isEmpty = string.IsNullOrEmpty("test");

89. String.IsNullOrWhiteSpace


bool isWhiteSpace = string.IsNullOrWhiteSpace("   ");

90. String.Format with Named Arguments


string formatted = string.Format("Hello, {name}!", new { name = "John" });

91. String.Concat with Multiple Arguments


string concatenated = string.Concat("Hello", " ", "World");

92. StringBuilder.Insert


sb.Insert(0, "Start: ");

93. StringBuilder.Remove


sb.Remove(0, 6); // removes "Start: "

94. StringBuilder.Replace


sb.Replace("World", "C#");

95. StringBuilder.AppendLine


sb.AppendLine("New Line");

96. StringBuilder.AppendFormat


sb.AppendFormat("Value: {0}", 10);

97. String.Join with IEnumerable


var names = new List<string> { "John", "Jane" };
string result = string.Join(", ", names);

98. StringBuilder.Append


sb.Append("Hello");

99. StringBuilder.ToString


string result = sb.ToString();

100. StringBuilder.Capacity


int capacity = sb.Capacity;