# Object

***

**1. Create an Object Instance**

```csharp
Person person = new Person();
```

**2. Access Object Properties**

```csharp
string name = person.Name;
```

**3. Set Object Properties**

```csharp
person.Name = "John Doe";
```

**4. Use Object Methods**

```csharp
person.Greet(); // Outputs "Hello, John Doe!"
```

**5. Create a Anonymous Object**

```csharp
var person = new { Name = "John Doe", Age = 30 };
Console.WriteLine(person.Name); // Outputs "John Doe"
```

**6. Use Reflection to Access Object Members**

```csharp
Type type = typeof(Person);
PropertyInfo property = type.GetProperty("Name");
string name = (string)property.GetValue(person);
```

**7. Use Extension Methods**

```csharp
public static void PrintName(this Person person) {
  Console.WriteLine(person.Name);
}
person.PrintName(); // Outputs "John Doe"
```

**8. Use Object Literals**

```csharp
var person = new { Name = "John Doe", Age = 30 };
Console.WriteLine(person.Name); // Outputs "John Doe"
```

**9. Use Value Tuples**

```csharp
(string Name, int Age) person = ("John Doe", 30);
Console.WriteLine(person.Name); // Outputs "John Doe"
```

**10. Use Deconstruction**

```csharp
var (name, age) = person;
Console.WriteLine(name); // Outputs "John Doe"
```

**11. Use Object Type Casting**

```csharp
object obj = person;
Person typedPerson = (Person)obj;
Console.WriteLine(typedPerson.Name); // Outputs "John Doe"
```

**12. Use As Operator**

```csharp
Person typedPerson = obj as Person;
if (typedPerson != null) {
  Console.WriteLine(typedPerson.Name); // Outputs "John Doe"
}
```

**13. Use Is Operator**

```csharp
if (obj is Person typedPerson) {
  Console.WriteLine(typedPerson.Name); // Outputs "John Doe"
}
```

**14. Use Pattern Matching**

```csharp
switch (obj) {
  case Person typedPerson:
    Console.WriteLine(typedPerson.Name); // Outputs "John Doe"
    break;
}
```

**15. Use Null Conditional Operator**

```csharp
string name = person?.Name; // Returns "John Doe" or null if person is null
```

**16. Use Coalesce Operator**

```csharp
string name = person.Name ?? "Unknown"; // Returns "John Doe" or "Unknown" if person.Name is null
```

**17. Check Object Equality**

```csharp
bool areEqual = object1 == object2; // Compares object references
```

**18. Check Object Inequality**

```csharp
bool areNotEqual = object1 != object2; // Compares object references
```

**19. Use Object Reference Assignment**

```csharp
Person person1 = person2; // Assigns reference to person2 to person1
```

**20. Use Object Cloning**

```csharp
Person clonedPerson = (Person)person.Clone();
```

**21. Use Object Serialization**

```csharp
string json = JsonConvert.SerializeObject(person);
```

**22. Use Object Deserialization**

```csharp
Person deserializedPerson = JsonConvert.DeserializeObject<Person>(json);
```

**23. Use Reflection to Create Object Instances**

```csharp
Type type = typeof(Person);
Person person = (Person)Activator.CreateInstance(type);
```

**24. Use Reflection to Invoke Object Methods**

```csharp
Type type = typeof(Person);
MethodInfo method = type.GetMethod("Greet");
method.Invoke(person, null); // Outputs "Hello, John Doe!"
```

**25. Use Reflection to Set Object Properties**

```csharp
Type type = typeof(Person);
PropertyInfo property = type.GetProperty("Name");
property.SetValue(person, "Jane Doe");
```

**26. Create a Generic Class**

```csharp
public class GenericCollection<T> {
  private List<T> items = new List<T>();
}
```

**27. Use a Generic Method**

```csharp
public static void PrintCollection<T>(GenericCollection<T> collection) {
  foreach (T item in collection.Items) {
    Console.WriteLine(item);
  }
}
```

**28. Create a Delegate**

```csharp
public delegate void PrintMessageDelegate(string message);
```

**29. Use a Delegate**

```csharp
PrintMessageDelegate printMessage = (message) => Console.WriteLine(message);
printMessage("Hello, World!"); // Outputs "Hello, World!"
```

**30. Create an Event**

```csharp
public class Person {
  public event EventHandler NameChanged;
}
```

**31. Raise an Event**

```csharp
public class Person {
  public void ChangeName(string newName) {
    Name = newName;
    NameChanged?.Invoke(this, EventArgs.Empty);
  }
}
```

**32. Subscribe to an Event**

```csharp
public class Program {
  private static void HandleNameChanged(object sender, EventArgs e) {
    Console.WriteLine("Name changed!");
  }
  public static void Main() {
    Person person = new Person();
    person.NameChanged += HandleNameChanged;
    person.ChangeName("John Doe"); // Outputs "Name changed!"
  }
}
```

**33. Use a Disposable Object**

```csharp
public class DisposableObject : IDisposable {
  public void Dispose() {
    // Cleanup code
  }
}
```

**34. Use a Using Statement**

```csharp
using (DisposableObject disposableObject = new DisposableObject()) {
  // Use disposableObject
}
```

**35. Use a Lock**

```csharp
lock (person) {
  // Thread-safe code
}
```

**36. Use a Monitor**

```csharp
Monitor.Enter(person);
try {
  // Thread-safe code
}
finally {
  Monitor.Exit(person);
}
```

**37. Use Interlocked Operations**

```csharp
Interlocked.Increment(ref counter);
```

**38. Use a ReaderWriterLock**

```csharp
using (ReaderWriterLockSlim lock = new ReaderWriterLockSlim()) {
  lock.EnterReadLock();
  try {
    // Thread-safe read code
  }
  finally {
    lock.ExitReadLock();
  }
}
```

**39. Use a ConcurrentDictionary**

```csharp
ConcurrentDictionary<string, int> dictionary = new ConcurrentDictionary<string, int>();
```

**40. Use a BlockingCollection**

```csharp
BlockingCollection<int> collection = new BlockingCollection<int>();
```

**41. Use a Semaphore**

```csharp
Semaphore semaphore = new Semaphore(1, 1);
```

**42. Use a Mutex**

```csharp
Mutex mutex = new Mutex();
```

**43. Use a SpinLock**

```csharp
SpinLock spinLock = new SpinLock();
```

**44. Use a CountdownEvent**

```csharp
CountdownEvent countdownEvent = new CountdownEvent(1);
```

**45. Use a Barrier**

```csharp
Barrier barrier = new Barrier(3);
```

**46. Use a WaitHandle**

```csharp
WaitHandle waitHandle = new AutoResetEvent(false);
```

**47. Use a Timer**

```csharp
Timer timer = new Timer(Callback, null, 1000, 1000);
```

**48. Use a Thread**

```csharp
Thread thread = new Thread(ThreadCallback);
thread.Start();
```

**49. Use a ThreadPool**

```csharp
ThreadPool.QueueUserWorkItem(ThreadCallback);
```

**50. Use a BackgroundWorker**

```csharp
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += new DoWorkEventHandler(Worker_DoWork);
worker.RunWorkerAsync();
```