int age = 25;
age = 26; // Значення змінилося
Console.WriteLine($"Вік: {age}"); // Виведе: Вік: 26

public class MathConstants
{
    public const double Pi = 3.14159265359;     public const int MaxIterations = 100;
    public const string AppName = "MyApp";
}

// Використання
double circumference = 2 * MathConstants.Pi * radius;

public class Configuration
{
    public readonly DateTime StartTime;
    public readonly string UserId;
    public readonly int[] AllowedPorts;

    public Configuration(string userId)
    {
        StartTime = DateTime.Now; // Ініціалізація під час виконання        UserId = userId;
        AllowedPorts = new int[] { 80, 443, 8080 };
    }
}

// Використання
var config = new Configuration("user123");
Console.WriteLine($"Застосунок запущено: {config.StartTime}");
// config.StartTime = DateTime.Now; // ПОМИЛКА: не можна змінити після ініціалізації

public void ProcessOrder(int orderId, string customerName)
{
    int totalAmount = 0;
    bool isValid = true;
    DateTime createdDate = DateTime.Now;

    // Використання
    if (isValid)
    {
        totalAmount = CalculateTotal(orderId);
    }
}

public class Customer
{
    private int _customerId;
    private string _firstName;
    private DateTime _registrationDate;

    public Customer(int customerId, string firstName)
    {
        _customerId = customerId;
        _firstName = firstName;
        _registrationDate = DateTime.Now;
    }
}

public class Product
{
    public int ProductId { get; set; }
    public string ProductName { get; set; }
    public decimal Price { get; set; }
    public bool IsAvailable { get; set; }
}

public class Constants
{
    public const int MaxLoginAttempts = 3;
    public const double Pi = 3.14159265359;
    public const string ApplicationName = "MyApplication";
    public const int DefaultTimeout = 30;

    // ❌ Неправильно (не використовуйте)
    // public const int MAX_LOGIN_ATTEMPTS = 3;
}

public class DatabaseConfig
{
    private const string ConnectionStringKey = "DefaultConnection";
    private const int MaxRetryCount = 5;
    private const double CacheExpirationMinutes = 15.0;
}

public class ServiceClient
{
    private readonly HttpClient _httpClient;
    private readonly string _apiBaseUrl;
    private readonly TimeSpan _requestTimeout;

    public ServiceClient(HttpClient httpClient, string apiBaseUrl)
    {
        _httpClient = httpClient;
        _apiBaseUrl = apiBaseUrl;
        _requestTimeout = TimeSpan.FromSeconds(30);
    }
}

public class Configuration
{
    public readonly string Environment;
    public readonly DateTime StartupTime;
    protected readonly int MaxConnections;

    public Configuration(string environment)
    {
        Environment = environment;
        StartupTime = DateTime.UtcNow;
        MaxConnections = 100;
    }
}

public class AppSettings
{
    public static readonly string DefaultCulture = "uk-UA";
    public static readonly TimeSpan SessionTimeout = TimeSpan.FromMinutes(20);
    private static readonly ILogger Logger = LoggerFactory.Create();
}

// Приклади використання
byte pixelValue = 255;
int temperature = -15;
long worldPopulation = 8_000_000_000L; // Підкреслення для читабельності
uint hexColor = 0xFF5733;

float gravity = 9.81f;
double pi = 3.141592653589793;
decimal price = 19.99m; // Для фінансових розрахунків
decimal preciseValue = 0.123456789012345678901234567m;

bool isActive = true;
bool hasErrors = false;

// Використання в умовах
if (isActive && !hasErrors)
{
    Console.WriteLine("Система працює коректно");
}

char letter = 'A';
char digit = '5';
char unicodeChar = '\u0041'; // 'A' в Unicode
char emoji = '😊';

Console.WriteLine($"Символ: {letter}, Код: {(int)letter}"); // A, Код: 65

string greeting = "Привіт, світ!";
string name = "Анна";
string fullGreeting = greeting + " Мене звати " + name;

// Інтерполяція рядків
string message = $"Вітаю, {name}! Сьогодні {DateTime.Now:dd.MM.yyyy}";
Console.WriteLine(message);

// Десяткові (Decimal)
int decimal1 = 42;
int decimal2 = 1_000_000; // Підкреслення для читабельності

// Шістнадцяткові (Hexadecimal) - префікс 0x або 0X
int hex1 = 0x2A;        // 42 у десятковій
int hex2 = 0xFF;        // 255 у десятковій
int hex3 = 0x00_FF_00;  // 65280 (зелений колір у RGB)

// Двійкові (Binary) - префікс 0b або 0B
int binary1 = 0b101010;      // 42 у десятковій
int binary2 = 0b1111_1111;   // 255 у десятковій
int binary3 = 0b0000_1111_0000; // 240

Console.WriteLine($"Hex: {hex1}, Binary: {binary1}"); // Hex: 42, Binary: 42

// Float літерали (суфікс f або F)
float f1 = 3.14f;
float f2 = 2.5F;
float f3 = 1.23e-4f; // Наукова нотація: 1.23 × 10⁻⁴

// Double літерали (суфікс d або D опційний)
double d1 = 3.14;
double d2 = 2.5d;
double d3 = 1.23e10; // 1.23 × 10¹⁰

// Decimal літерали (суфікс m або M)
decimal m1 = 3.14m;
decimal m2 = 123.456M;
decimal m3 = 0.0001m;

bool isTrue = true;
bool isFalse = false;

char letter = 'A';
char newline = '\n';        // Escape-послідовність
char tab = '\t';
char backslash = '\\';
char quote = '\'';
char unicode = '\u0041';    // Unicode escape
char hex = '\x0041';        // Hexadecimal escape

string simple = "Привіт, світ!";
string withEscape = "Перший рядок\nДругий рядок";
string withQuotes = "Вона сказала: \"Привіт!\"";

// Без verbatim - потрібно екранувати
string path1 = "C:\\Users\\Anna\\Documents\\file.txt";

// З verbatim - простіше та зрозуміліше
string path2 = @"C:\Users\Anna\Documents\file.txt";

// Багаторядковий текст
string multiline = @"Перший рядок
Другий рядок
Третій рядок";

// Лапки подвоюються
string withQuotes = @"Вона сказала: ""Привіт!""";

// Однорядковий raw string
string json1 = """{"name": "Anna", "age": 25}""";

// Багаторядковий raw string
string json2 = """
{
    "name": "Anna",
    "age": 25,
    "city": "Kyiv"
}
""";

// Raw string з інтерполяцією (C# 11+)
string name = "Богдан";
int age = 30;
string interpolated = $$"""
{
    "name": "{{name}}",
    "age": {{age}}
}
""";
Console.WriteLine(interpolated);
// Виведе:
// {
//     "name": "Богдан",
//     "age": 30
// }

// Базові арифметичні операції
int a = 10;
int b = 3;

int sum = a + b;          // 13
int difference = a - b;   // 7
int product = a * b;      // 30
int quotient = a / b;     // 3 (цілочисельне ділення)
int remainder = a % b;    // 1

// Ділення з дробовою частиною
double preciseQuotient = (double)a / b;  // 3.333...
Console.WriteLine($"{a} / {b} = {preciseQuotient:F2}");

// Унарні оператори
int positive = +5;    // 5
int negative = -5;    // -5

// Приклад різниці
int a = 10;
int b = 10;

int result1 = a++ * 2;  // result1 = 10 * 2 = 20, потім a = 11
int result2 = ++b * 2;  // спочатку b = 11, потім result2 = 11 * 2 = 22

Console.WriteLine($"a={a}, result1={result1}");  // a=11, result1=20
Console.WriteLine($"b={b}, result2={result2}");  // b=11, result2=22

int counter = 0;

// Складені оператори присвоювання
counter += 5;   // counter = 0 + 5 = 5
counter *= 2;   // counter = 5 * 2 = 10
counter -= 3;   // counter = 10 - 3 = 7
counter /= 2;   // counter = 7 / 2 = 3
counter %= 2;   // counter = 3 % 2 = 1

Console.WriteLine($"Final counter: {counter}"); // 1

// Null-coalescing assignment (C# 8.0+)
string? name = null;
name ??= "За замовчуванням";  // Присвоює тільки якщо name == null
Console.WriteLine(name);       // "За замовчуванням"

name ??= "Інше значення";      // Не присвоює, бо name вже не null
Console.WriteLine(name);       // "За замовчуванням"

int x = 10;
int y = 20;

bool isEqual = x == y;          // false
bool isNotEqual = x != y;       // true
bool isGreater = x > y;         // false
bool isLess = x < y;            // true
bool isGreaterOrEqual = x >= 10; // true
bool isLessOrEqual = x <= 5;    // false

// Порівняння рядків
string str1 = "Hello";
string str2 = "World";
bool areStringsEqual = str1 == str2;  // false

// Порівняння дат
DateTime date1 = new DateTime(2024, 1, 1);
DateTime date2 = DateTime.Now;
bool isPastDate = date1 < date2;  // true (якщо зараз після 1 січня 2024)

bool isAdult = true;
bool hasLicense = false;

// Логічне І (AND) - обидва мають бути true
bool canDrive = isAdult && hasLicense;  // false

// Логічне АБО (OR) - хоча б один true
bool canEnter = isAdult || hasLicense;  // true

// Логічне НЕ (NOT) - інверсія
bool isChild = !isAdult;  // false

// Складні умови
int age = 25;
bool hasPermission = true;

if (age >= 18 && hasPermission)
{
    Console.WriteLine("Доступ дозволено");
}

// XOR - виключне АБО
bool option1 = true;
bool option2 = false;
bool exclusiveChoice = option1 ^ option2;  // true (тільки один з них true)

int? nullableValue = null;

// && short-circuit: другий вираз не виконається, якщо перший false
if (nullableValue != null && nullableValue.Value > 10) {
    // Безпечно: nullableValue.Value не викличеться, якщо nullableValue == null
}

// || short-circuit: другий вираз не виконується, якщо перший true
bool result = CheckCondition1() || CheckCondition2(); // Якщо CheckCondition1() повертає true, CheckCondition2() НЕ викликається

// Без short-circuit (& та |) - обидва операнди завжди обчислюються
bool result2 = CheckCondition1() & CheckCondition2(); // Обидва методи ЗАВЖДИ викликаються, незалежно від результату першого

condition ? valueIfTrue : valueIfFalse

int age = 20;

// Використання if-else
string status;
if (age >= 18)
{
    status = "Повнолітній";
}
else
{
    status = "Неповнолітній";
}

// Те саме з тернарним оператором
string status2 = age >= 18 ? "Повнолітній" : "Неповнолітній"; 
// Вкладені тернарні оператори (використовуйте обережно!)
int score = 85;
string grade = score >= 90 ? "A" :
               score >= 80 ? "B" :
               score >= 70 ? "C" :
               score >= 60 ? "D" : "F";
Console.WriteLine($"Оцінка: {grade}"); // "B"

// Практичний приклад
int itemCount = 5;
string message = $"У кошику {itemCount} {(itemCount == 1 ? "товар" : "товарів")}";
Console.WriteLine(message); // "У кошику 5 товарів"

string? name = null;

// Без null-conditional - NullReferenceException!
// int length1 = name.Length;  // ❌ Помилка під час виконання

// З null-conditional - повертає null
int? length2 = name?.Length;  // ✅ length2 = null
Console.WriteLine(length2 ?? 0);  // Виведе: 0

// Ланцюжок викликів
Person? person = GetPerson();
string? city = person?.Address?.City?.ToUpper();

// З масивами та колекціями
int[] numbers = null;
int? firstNumber = numbers?[0];  // null замість винятку

// З методами
string? result = person?.GetFullName()?.Trim();

string? userName = null;
string displayName = userName ?? "Гість";  // "Гість"
Console.WriteLine($"Вітаємо, {displayName}!");

// Ланцюжок null-coalescing
string? firstName = null;
string? lastName = null;
string? nickName = "Користувач123";
string name = firstName ?? lastName ?? nickName ?? "Анонім";
Console.WriteLine(name); // "Користувач123"

// З nullable value types
int? nullableInt = null;
int actualValue = nullableInt ?? 0;  // 0

// Комбінація з null-conditional
Person? person = GetPerson();
string city = person?.Address?.City ?? "Невідоме місто";

List<string>? items = null;

// Ініціалізація тільки якщо null
items ??= new List<string>();  // Створюється новий список
items ??= new List<string>();  // НЕ виконується, бо items вже не null

// Lazy initialization
private List<string>? _cache;
public List<string> Cache
{
    get
    {
        _cache ??= LoadDataFromDatabase();  // Завантажується тільки при першому доступі
        return _cache;
    }
}

// Приклад з налаштуваннями
Dictionary<string, string>? config = LoadConfig();
config ??= GetDefaultConfig();  // Використати дефолтні, якщо завантаження не вдалось

object obj = "Hello, World!";

// Проста перевірка типу
if (obj is string) {
    Console.WriteLine("obj є рядком");
}

// Pattern matching з оголошенням змінної (C# 7+)
if (obj is string text) {
    Console.WriteLine($"Рядок: {text.ToUpper()}");
    // text доступна тільки в цьому блоці
}

// Перевірка на null
object? nullableObj = null;
if (nullableObj is null)  // Еквівалент: nullableObj == null
{
    Console.WriteLine("Об'єкт null");
}
if (nullableObj is not null)  // C# 9+
{
    Console.WriteLine("Об'єкт не null");
}

// Property pattern (C# 8+)
if (obj is string { Length: > 5 } longText)
{
    Console.WriteLine($"Довгий рядок: {longText}");
}

// Приклад з успадкуванням
Animal animal = new Dog();
if (animal is Dog dog)
{
    dog.Bark();  // Метод специфічний для Dog
}

object obj = "Hello";

// З оператором as
string? str = obj as string; if (str != null)
{
    Console.WriteLine($"Довжина: {str.Length}");
}

// З явним приведенням (cast) - НЕБЕЗПЕЧНО
try
{
    int number = (int)obj;  // InvalidCastException!
}
catch (InvalidCastException ex)
{
    Console.WriteLine("Неможливо привести до int");
}

// Безпечний підхід з as
int? number = obj as int?;  // null, без винятку
if (number.HasValue)
{
    Console.WriteLine($"Число: {number.Value}");
}
else
{
    Console.WriteLine("Не є числом");
}

// typeof - отримання Type об'єкта
Type stringType = typeof(string);
Console.WriteLine($"Тип: {stringType.Name}");
Console.WriteLine($"Простір імен: {stringType.Namespace}");

Type genericType = typeof(List<int>);
Console.WriteLine($"Generic: {genericType.Name}");

// Порівняння типів
object obj = "Hello";
if (obj.GetType() == typeof(string))
{
    Console.WriteLine("obj є рядком");
}

// sizeof - розмір типу (тільки для value types)
int intSize = sizeof(int);           // 4 байти
long longSize = sizeof(long);        // 8 байтів
double doubleSize = sizeof(double);  // 8 байтів
bool boolSize = sizeof(bool);        // 1 байт

Console.WriteLine($"int: {intSize}, long: {longSize}, double: {doubleSize}");

// Для користувацьких структур
unsafe
{
    int pointSize = sizeof(Point);  // Залежить від визначення Point
}

string variableName = "test";
Console.WriteLine(nameof(variableName));   // "variableName"
Console.WriteLine(nameof(Console));        // "Console"
Console.WriteLine(nameof(String.Length));  // "Length"

// Практичне використання: валідація параметрів
public void SetName(string name)
{
    if (string.IsNullOrEmpty(name))
    {
        throw new ArgumentException(
            $"Параметр не може бути порожнім",
            nameof(name)  // Замість "name" як рядка
        );
    }
}

// PropertyChanged events
public class Person : INotifyPropertyChanged
{
    private string _name;
    public string Name
    {
        get => _name;
        set
        {
            _name = value;
            OnPropertyChanged(nameof(Name));  // Безпечно від рефакторингу
        }
    }
}

// Приклад пріоритету
int result = 2 + 3 * 4;  // 14, не 20 (* має вищий пріоритет)
int result2 = (2 + 3) * 4;  // 20 (дужки змінюють порядок)

// Складний вираз
bool condition = x > 5 && y < 10 || z == 0;
// Еквівалент: ((x > 5) && (y < 10)) || (z == 0)

// З null-coalescing
string name = firstName ?? lastName ?? "Unknown";
// Виконується зліва направо

// Для ясності краще використовувати дужки
int complex = (a + b) * (c - d) / (e + f);

// Числова ієрархія: byte → short → int → long → float → double → decimal
int intValue = 100;
long longValue = intValue;      // int → long (безпечно)
float floatValue = intValue;    // int → float
double doubleValue = floatValue; // float → double

Console.WriteLine($"int: {intValue}, long: {longValue}, double: {doubleValue}");

double doubleValue = 123.456;
int intValue = (int)doubleValue; // Явне приведення, втрата дробової частиниConsole.WriteLine($"double: {doubleValue}, int: {intValue}");
// Виведе: double: 123.456, int: 123

long bigNumber = 3000000000L;
int smallerNumber = (int)bigNumber; // Ризик переповнення!
Console.WriteLine($"long: {bigNumber}, int: {smallerNumber}");

// Приведення між float та decimal потребує явної конверсії
decimal decimalValue = 19.99m;
double fromDecimal = (double)decimalValue;
float fromDecimal2 = (float)decimalValue;

// Конверсія рядків у числа
string numberStr = "42";
int number = Convert.ToInt32(numberStr);
double doubleNum = Convert.ToDouble("3.14");
bool boolValue = Convert.ToBoolean("true");

Console.WriteLine($"int: {number}, double: {doubleNum}, bool: {boolValue}");

// Конверсія з перевіркою null
string nullStr = null;
int fromNull = Convert.ToInt32(nullStr); // Поверне 0, а не викличе виняток!

// Конверсія між числовими типами
decimal decValue = 123.45m;
int intFromDec = Convert.ToInt32(decValue); // 123 (округлення)

// Робота з різними системами числення
string hexString = "FF";
int fromHex = Convert.ToInt32(hexString, 16); // 255
string binary = Convert.ToString(255, 2);     // "11111111"
Console.WriteLine($"Hex FF = {fromHex}, Decimal 255 = {binary} (binary)");

try
{
    string validNumber = "123";
    int result1 = int.Parse(validNumber);
    Console.WriteLine($"Результат: {result1}"); // 123

    string invalidNumber = "abc";
    int result2 = int.Parse(invalidNumber); // FormatException!
}
catch (FormatException ex)
{
    Console.WriteLine($"Помилка формату: {ex.Message}");
}
catch (OverflowException ex)
{
    Console.WriteLine($"Переповнення: {ex.Message}");
}

string input = "456";
if (int.TryParse(input, out int result))
{
    Console.WriteLine($"Успішна конверсія: {result}");
}
else
{
    Console.WriteLine("Не вдалося сконвертувати");
}

// Використання з некоректним значенням
string badInput = "xyz";
if (int.TryParse(badInput, out int badResult))
{
    Console.WriteLine($"Результат: {badResult}");
}
else
{
    Console.WriteLine($"'{badInput}' не є коректним числом"); // Це виведеться
}

// Inline оголошення out змінної (C# 7+)
if (double.TryParse("3.14159", out var pi))
{
    Console.WriteLine($"Число π ≈ {pi}");
}

// Value types - копіювання значення
int a = 10;
int b = a;    // Копіюється значенняb = 20;       // Змінюється тільки b
Console.WriteLine($"a = {a}, b = {b}"); // a = 10, b = 20

// Reference types - копіювання посилання
int[] array1 = new int[] { 1, 2, 3 };
int[] array2 = array1;  // Копіюється посилання, не дані!array2[0] = 999;        // Змінюється спільний об'єкт
Console.WriteLine($"array1[0] = {array1[0]}, array2[0] = {array2[0]}");
// Виведе: array1[0] = 999, array2[0] = 999

// Boxing - value type → reference type
int value = 42;
object boxed = value; // Boxing: int → object (алокація в heap!)

Console.WriteLine($"Boxed value: {boxed}");

// Unboxing - reference type → value type
int unboxed = (int)boxed; // Unboxing: object → int

Console.WriteLine($"Unboxed value: {unboxed}");

// Без var - явне оголошення
int number = 42;
string message = "Привіт";
List<string> names = new List<string>();

// З var - неявне типізування
var number2 = 42;              // Компілятор виводить: int
var message2 = "Привіт";       // Компілятор виводить: string
var names2 = new List<string>(); // Компілятор виводить: List<string>

// Анонімний тип - var обов'язковий
var person = new
{
    Name = "Олена",
    Age = 28,
    City = "Київ"
};

Console.WriteLine($"{person.Name}, {person.Age} років, м. {person.City}");

// Масив анонімних типів
var people = new[]
{
    new { Name = "Іван", Age = 30 },
    new { Name = "Марія", Age = 25 },
    new { Name = "Петро", Age = 35 }
};

foreach (var p in people)
{
    Console.WriteLine($"{p.Name}: {p.Age}");
}

var numbers = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

// LINQ запит з анонімним типом
var evenSquares = from n in numbers
                  where n % 2 == 0
                  select new { Number = n, Square = n * n };

foreach (var item in evenSquares)
{
    Console.WriteLine($"{item.Number}² = {item.Square}");
}

// ✅ Добре - тип очевидний
var customer = new Customer();
var customers = new List<Customer>();
var name = customer.GetFullName();

// ✅ Добре - зменшує повторення
var dictionary = new Dictionary<string, List<ProductCategory>>();

// ❌ Погано - тип неочевидний
var data = GetData();
var value = Calculate();
var result = Process();

// ❌ Погано - може бути неочевидний числовий тип
var number = 10;  // int? long? short?
int explicitNumber = 10; // Краще для чіткості

#nullable enable

public class Person
{
    // Non-nullable - має бути ініціалізована
    public string FirstName { get; set; } = string.Empty;
    public string LastName { get; set; } = string.Empty;

    // Nullable - може бути null
    public string? MiddleName { get; set; }
    public string? Email { get; set; }

    public Person(string firstName, string lastName)
    {
        FirstName = firstName;
        LastName = lastName;
    }

    public string GetFullName()
    {
        // Компілятор попереджає про можливий null
        if (MiddleName != null)
        {
            return $"{FirstName} {MiddleName} {LastName}";
        }

        return $"{FirstName} {LastName}";
    }
}

#nullable enable

string nonNullable = "Hello";
string? nullable = null;

// ⚠️ Попередження: Можливе присвоювання null до non-nullable
// nonNullable = nullable;

// ✅ OK - перевірка на null
if (nullable != null)
{
    nonNullable = nullable;
}

// ⚠️ Попередження: Можливе розіменування null
// int length = nullable.Length;

// ✅ OK - перевірка на null
int? length = nullable?.Length;

#nullable enable

public class UserService
{
    private string? _cachedName;

    public void Initialize()
    {
        _cachedName = LoadNameFromDatabase();
    }

    public string GetName()
    {
        // Ми знаємо, що Initialize() був викликаний і _cachedName не null
        // Але компілятор цього не знає

        // ⚠️ Попередження без !
        // return _cachedName;

        // ✅ OK з оператором !
        return _cachedName!;
    }

    private string LoadNameFromDatabase()
    {
        return "Anna";
    }
}

#nullable enable

public class OrderProcessor
{
    public void ProcessOrder(string? orderId)
    {
        // ❌ Попередження: orderId може бути null
        // Console.WriteLine(orderId.ToUpper());

        // ✅ Варіант 1: Перевірка на null
        if (orderId != null)
        {
            Console.WriteLine(orderId.ToUpper());
        }

        // ✅ Варіант 2: Null-conditional operator
        Console.WriteLine(orderId?.ToUpper() ?? "NO ORDER");

        // ✅ Варіант 3: Null-coalescing operator
        string safeOrderId = orderId ?? "UNKNOWN";
        Console.WriteLine(safeOrderId.ToUpper());

        // ✅ Варіант 4: Pattern matching (C# 9+)
        if (orderId is not null)
        {
            Console.WriteLine(orderId.ToUpper());
        }
    }
}

#nullable enable

public class DataService
{
    // Список non-nullable рядків (сам список теж non-nullable)
    public List<string> NonNullableList { get; set; } = new();

    // Список nullable рядків
    public List<string?> NullableItemsList { get; set; } = new();

    // Nullable список non-nullable рядків
    public List<string>? NullableList { get; set; }

    // Nullable список nullable рядків
    public List<string?>? FullyNullable { get; set; }

    public void Example()
    {
        NonNullableList.Add("Hello");
        // NonNullableList.Add(null); // ❌ Помилка компіляції

        NullableItemsList.Add("Hello");
        NullableItemsList.Add(null); // ✅ OK

        // Треба перевірити список на null перед використанням
        int? count = NullableList?.Count;
    }
}

int a = 5;  // 0000 0101 в двійковому
int b = 3;  // 0000 0011 в двійковому

// Бітове І (AND)
int andResult = a & b;  // 0000 0001 = 1
Console.WriteLine($"{a} & {b} = {andResult}");

// Бітове АБО (OR)
int orResult = a | b;   // 0000 0111 = 7
Console.WriteLine($"{a} | {b} = {orResult}");

// Виключне АБО (XOR)
int xorResult = a ^ b;  // 0000 0110 = 6
Console.WriteLine($"{a} ^ {b} = {xorResult}");

// Бітове НЕ (NOT)
int notResult = ~a;     // 1111 1010 = -6 (доповняльний код)
Console.WriteLine($"~{a} = {notResult}");

// Зсув вліво
int leftShift = a << 1;  // 0000 1010 = 10 (помножити на 2)
Console.WriteLine($"{a} << 1 = {leftShift}");

// Зсув вправо
int rightShift = a >> 1; // 0000 0010 = 2 (поділити на 2)
Console.WriteLine($"{a} >> 1 = {rightShift}");

using System;

public class BitwiseDemo
{
    public static void ShowBitwiseOperations()
    {
        int x = 12;  // 1100
        int y = 10;  // 1010

        Console.WriteLine($"x = {x,3} = {Convert.ToString(x, 2).PadLeft(8, '0')}");
        Console.WriteLine($"y = {y,3} = {Convert.ToString(y, 2).PadLeft(8, '0')}");
        Console.WriteLine(new string('-', 30));

        int andResult = x & y;
        Console.WriteLine($"x & y  = {andResult,3} = {Convert.ToString(andResult, 2).PadLeft(8, '0')}");

        int orResult = x | y;
        Console.WriteLine($"x | y  = {orResult,3} = {Convert.ToString(orResult, 2).PadLeft(8, '0')}");

        int xorResult = x ^ y;
        Console.WriteLine($"x ^ y  = {xorResult,3} = {Convert.ToString(xorResult, 2).PadLeft(8, '0')}");
    }
}

// Вивід:
// x =  12 = 00001100
// y =  10 = 00001010
// ------------------------------
// x & y  =   8 = 00001000
// x | y  =  14 = 00001110
// x ^ y  =   6 = 00000110

int number = 16;

// Множення на 2^n через зсув вліво
int multiplyBy2 = number << 1;   // 16 * 2 = 32
int multiplyBy4 = number << 2;   // 16 * 4 = 64
int multiplyBy8 = number << 3;   // 16 * 8 = 128

Console.WriteLine($"{number} << 1 = {multiplyBy2}");
Console.WriteLine($"{number} << 2 = {multiplyBy4}");
Console.WriteLine($"{number} << 3 = {multiplyBy8}");

// Ділення на 2^n через зсув вправо
int divideBy2 = number >> 1;     // 16 / 2 = 8
int divideBy4 = number >> 2;     // 16 / 4 = 4
int divideBy8 = number >> 3;     // 16 / 8 = 2

Console.WriteLine($"{number} >> 1 = {divideBy2}");
Console.WriteLine($"{number} >> 2 = {divideBy4}");
Console.WriteLine($"{number} >> 3 = {divideBy8}");

[Flags]
public enum FilePermissions
{
    None    = 0,      // 0000
    Read    = 1,      // 0001
    Write   = 2,      // 0010
    Execute = 4,      // 0100
    Delete  = 8,      // 1000

    // Комбіновані права
    ReadWrite = Read | Write,           // 0011 = 3
    ReadExecute = Read | Execute,       // 0101 = 5
    All = Read | Write | Execute | Delete  // 1111 = 15
}

public class PermissionDemo
{
    public static void Main()
    {
        // Встановлення прав
        FilePermissions userPermissions = FilePermissions.Read | FilePermissions.Write;
        Console.WriteLine($"User permissions: {userPermissions}");
        // Виведе: Read, Write

        // Перевірка наявності права
        bool canRead = (userPermissions & FilePermissions.Read) == FilePermissions.Read;
        bool canExecute = (userPermissions & FilePermissions.Execute) == FilePermissions.Execute;

        Console.WriteLine($"Can read: {canRead}");       // True
        Console.WriteLine($"Can execute: {canExecute}"); // False

        // Додавання права
        userPermissions |= FilePermissions.Execute;
        Console.WriteLine($"Updated permissions: {userPermissions}");
        // Виведе: Read, Write, Execute

        // Видалення права
        userPermissions &= ~FilePermissions.Write;
        Console.WriteLine($"After removing Write: {userPermissions}");
        // Виведе: Read, Execute

        // Перемикання права (toggle)
        userPermissions ^= FilePermissions.Delete;
        Console.WriteLine($"After toggling Delete: {userPermissions}");
        // Виведе: Read, Execute, Delete

        // Перевірка кількох прав одночасно
        bool hasReadAndExecute = (userPermissions & FilePermissions.ReadExecute) == FilePermissions.ReadExecute;
        Console.WriteLine($"Has Read AND Execute: {hasReadAndExecute}"); // True
    }
}