public class Celebrity
{
    public string? Name { get; set; }
    public int Age { get; set; }

    public override string ToString() => $"{Name}: {Age}";

    public void Test()
    {
        var celebrity = new Celebrity { Name = "Jennifer Aniston", Age = 54 };
        ChangeCelebrity(celebrity);

        Console.WriteLine(celebrity);
    }

    static void ChangeCelebrity(Celebrity celebrity)
    {
        celebrity.Name = "Brad Pitt";
        celebrity.Age = 60;

        celebrity = new Celebrity { Name = "Angelina Jolie", Age = 48 };
    }
}

public record struct Celebrity2(string Name)
{
    public override string ToString() => Name;

    public void Test()
    {
        var celebrity = new Celebrity2("Jennifer Aniston");
        ChangeCelebrity(celebrity);

        Console.WriteLine(celebrity);
    }

    static void ChangeCelebrity(Celebrity2 celebrity)
    {
        celebrity.Name = "Brad Pitt";
        celebrity = new Celebrity2("Angelina Jolie");
    }
}

public async Task Test()
{
    try
    {
        await Task.Factory.StartNew<int>(() => throw new Exception())
            .ContinueWith(x => 2 * 2)
            .ContinueWith(x => Math.Sqrt(x.Result))
            .ContinueWith(x => Console.WriteLine(x.Result));
    }
    catch (AggregateException)
    {
        Console.WriteLine(nameof(AggregateException));
    }
    catch (Exception)
    {
        Console.WriteLine(nameof(Exception));
    }
}

abstract class A
{
    public abstract string GetName();
}

class B : A
{
    public override string GetName() => nameof(B);
}

class C : B
{
    public new string GetName() => nameof(C);
}

public void Test()
{
    A b = new B();
    A c = new C();
    Console.WriteLine(b.GetName() + c.GetName());
}

private object _lock = new();
private int _counter;

public async Task Test()
{
    Task.WhenAll(
        Increment(),
        Increment(),
        Increment());

    Console.WriteLine(_counter);
}

async Task Increment()
{
    lock (_lock)
    {
        await Task.Delay(1000);
        _counter++;
    }
}

public void Test()
{
    try
    {
        using (null)
        {
            Console.Write("I'm in");
            return;
        }

        Console.Write("I'm out");
    }
    catch (Exception)
    {
        Console.Write(nameof(Exception));
    }
}

public void Test()
{
    var double1 = 5.502247;
    var double2 = 5.492247;
    var decimal1 = 5.502247m;
    var decimal2 = 5.492247m;

    var result1 = double1 - double2;
    var result2 = decimal1 - decimal2;

    Console.Write(result1 == 0.01);
    Console.Write(" ");
    Console.Write(result2 == 0.01m);
}

public void Test()
{
    var thread1 = new Thread(Print);
    var thread2 = new Thread(Print);

    thread1.Start();
    thread2.Start();
}

void Print()
{
    var strArray = "Hello World";

    lock ("lock")
    {
        for (var i = 0; i < strArray.Length; i++)
        {
            Console.Write(strArray[i]);
            Thread.Sleep(100);
        }

        Console.Write(" ");
    }
}

public async Task Test()
{
    var threadId1 = Thread.CurrentThread.ManagedThreadId;

    var task1 = Task.Delay(500);
    await task1;

    var threadId2 = Thread.CurrentThread.ManagedThreadId;

    var task2 = Task.Delay(500);
    Thread.Sleep(1000);
    await task2;

    var threadId3 = Thread.CurrentThread.ManagedThreadId;

    Console.Write($"{threadId1 == threadId2} {threadId2 == threadId3}");
}

public void Test()
{
    var list = new List<int> { 1, 2, 3 };
    var capacity0 = list.Capacity;
        
    list.Add(4);
    var capacity1 = list.Capacity;

    list.Add(5);
    var capacity2 = list.Capacity;

    list.RemoveAt(0);
    var capacity3 = list.Capacity;

    Console.Write($"{capacity0} {capacity1} {capacity2} {capacity3}");
}

public void Test()
{
    Record r = new Record();
    Struct s = new Struct();
    RecordStruct rs = new RecordStruct();

    Console.Write($"{r.Dozen} {s.Dozen} {rs.Dozen}");
}

record Record(int Dozen = 12);

struct Struct
{
    public Struct(int dozen = 12)
    {
        Dozen = dozen;
    }

    public int Dozen { get; init; }
}

record struct RecordStruct(int Dozen = 12);

public void Test()
{
    var type = typeof(Celebrity);

    var isClonable = type.IsAssignableTo(typeof(ICloneable));
    var isEquatable = type.IsAssignableTo(typeof(IEquatable<Celebrity>));
    var isSerializable = type.IsAssignableTo(typeof(ISerializable));

    Console.Write($"{isClonable} {isEquatable} {isSerializable}");
}

record Celebrity(string Name, int Age);

public void Test()
{
    try
    {
        var doubleVar = 0 / 0.0;

        Console.Write(doubleVar == doubleVar);
    }
    catch (Exception)
    {
        Console.Write(nameof(Exception));
    }
}

public void Test()
{
    try
    {
        var cToken = new CancellationToken(canceled: true);

        Task.Run(() => Delay(cToken)).Wait();

        Console.Write("Completed");
    }
    catch (OperationCanceledException)
    {
        Console.Write("OperationCanceledException");
    }
    catch (AggregateException)
    {
        Console.Write("AggregateException");
    }
    catch (Exception)
    {
        Console.Write("Exception");
    }
}

private Task Delay(CancellationToken cToken)
{
    cToken.ThrowIfCancellationRequested();

    return Task.Delay(1000);
}

public void Test()
{
    try
    {
        var serviceProvider = new ServiceCollection()
            .AddScoped<INameProvider, NameProvider>()
            .AddSingleton<INameProvider, NameProvider2>()
            .BuildServiceProvider();

        var nameProvider = serviceProvider
            .CreateScope()
            .ServiceProvider
            .GetService<INameProvider>();

        Console.Write(nameProvider?.GetName() ?? "Null");
    }
    catch (Exception)
    {
        Console.Write("Exception");
    }
}

interface INameProvider
{
    string GetName();
}

class NameProvider : INameProvider
{
    public string GetName() => "Name";
}

class NameProvider2 : INameProvider
{
    public string GetName() => "Name2";
}

public void Test()
{
    var strEqual = (object)"14.01.2024" == (object)"14.01.2024";
    var dtEquals = (object)DateTime.Today == (object)DateTime.Today;
    var intEquals = (object)14012024 == (object)14012024;

    Console.Write($"{strEqual} {dtEquals} {intEquals}");
}

public void Test()
{
    try
    {
        var fullDay = TimeSpan.Parse("24:00:00");

        var days = fullDay.Days;
        var hours = fullDay.Hours;

        Console.Write($"{days}d {hours}h");
    }
    catch (Exception)
    {
        Console.Write("Exception");
    }
}

public class Increment
{
    private int _counter;

    public void Test()
    {
        Write(_counter++);
        Console.Write(_counter);
    }

    private void Write(int i)
    {
        Console.Write(i);
        Console.Write(_counter);
    }
}