Какие глобально есть типы данных в C#?

Типы данных в C#

C# — это строго типизированный язык программирования, разработанный Microsoft. Система типов включает два основных категории: типы значений (Value Types) и ссылочные типы (Reference Types).

1. Основные категории типов

// VALUE TYPES (хранятся в стеке)
int age = 25;           // Целое число
float height = 1.75f;   // Число с плавающей точкой (4 байта)
double weight = 70.5;   // Число с плавающей точкой (8 байт)
decimal price = 99.99m; // Высокая точность для денег
bool isActive = true;   // Логическое значение
char letter = 'A';      // Один символ

// REFERENCE TYPES (хранятся в куче)
string name = "John";   // Строка (неизменяемая)
object data = 123;      // Базовый класс для всех типов
int[] numbers = {1, 2, 3};  // Массив
List<int> list = new List<int>(); // Коллекция

2. Детальная классификация типов

A. Целочисленные типы (Integral Types)

sbyte sb = -128;           // Знаковое 8-bit (-128 до 127)
byte b = 255;              // Беззнаковое 8-bit (0 до 255)
short s = -32768;          // Знаковое 16-bit
ushort us = 65535;         // Беззнаковое 16-bit
int i = -2147483648;       // Знаковое 32-bit (наиболее используемое)
uint ui = 4294967295;      // Беззнаковое 32-bit
long l = -9223372036854775808;  // Знаковое 64-bit
ulong ul = 18446744073709551615; // Беззнаковое 64-bit

B. Типы с плавающей точкой

float f = 3.14f;    // 32-bit, точность ~6-9 цифр
double d = 3.14159; // 64-bit, точность ~15-17 цифр (по умолчанию)
decimal dec = 19.99m; // 128-bit, высокая точность для денег

C. Булевский и символьный типы

bool flag = true;       // true или false
char symbol = 'Z';      // Один Unicode символ (2 байта)

D. Ссылочные типы

string text = "Hello";           // Строка (неизменяемая)
object anything = 123;           // Может хранить любой тип
MyClass instance = new MyClass(); // Пользовательский класс
int[] array = new int[5];        // Массив
List<string> list = new List<string>(); // Обобщённая коллекция
Dictionary<string, int> dict = new Dictionary<string, int>(); // Словарь

3. Таблица всех встроенных типов

print("===== ВСЕ ТИПЫ ДАННЫХ В C# =====");

print("INTEGRAL TYPES (целые числа):");
print("sbyte: -128 до 127");
print("byte: 0 до 255");
print("short: -32,768 до 32,767");
print("ushort: 0 до 65,535");
print("int: -2,147,483,648 до 2,147,483,647");
print("uint: 0 до 4,294,967,295");
print("long: -9,223,372,036,854,775,808 до 9,223,372,036,854,775,807");
print("ulong: 0 до 18,446,744,073,709,551,615");

print("\nFLOATING-POINT TYPES (с плавающей точкой):");
print("float: 32-bit, ±1.5E-45 до ±3.4E38");
print("double: 64-bit, ±5E-324 до ±1.7E308");
print("decimal: 128-bit, для денежных операций");

print("\nBOOLEAN & CHAR:");
print("bool: true или false");
print("char: Unicode символ");

print("\nREFERENCE TYPES (ссылочные):");
print("string: текст (неизменяемый)");
print("object: базовый класс");
print("arrays: массивы");
print("classes: пользовательские классы");
print("interfaces: интерфейсы");
print("delegates: делегаты (указатели на функции)");
print("events: события");

4. Различия между Value и Reference Types

// VALUE TYPE (копируется при присвоении)
int x = 10;
int y = x;  // y получит копию значения 10
y = 20;     // x остаётся 10, y становится 20

print($"x={x}, y={y}");  // x=10, y=20

// REFERENCE TYPE (копируется ссылка)
MyClass obj1 = new MyClass { Value = 10 };
MyClass obj2 = obj1;  // obj2 указывает на тот же объект
obj2.Value = 20;      // Меняется объект, на который указывают обе ссылки

print($"obj1.Value={obj1.Value}, obj2.Value={obj2.Value}");  // 20, 20

// Сравнение:
int a = 10, b = 10;
print(a == b);  // true (сравниваются значения)

MyClass c1 = new MyClass { Value = 10 };
MyClass c2 = new MyClass { Value = 10 };
print(c1 == c2);  // false (разные объекты!)
print(ReferenceEquals(c1, c2));  // false - разные ссылки

5. Nullable типы (Nullable Types)

// Обычный тип значения не может быть null
int x = null;  // ОШИБКА!

// Nullable типы могут быть null
int? y = null;  // OK - Nullable<int>
int? z = 10;    // OK - может содержать значение

// Проверка и использование
if (y.HasValue)
{
    print(y.Value);  // Получить значение
}
else
{
    print("Значение null");
}

// Оператор ?? (null-coalescing)
int result = y ?? 0;  // Если y null, использовать 0

// C# 8.0: Non-nullable reference types
string? nullableString = null;  // Может быть null
string nonNullableString = "hello";  // НЕ может быть null

6. Структуры (Structs) — Value Types

// Структура — это value type
public struct Point
{
    public int X { get; set; }
    public int Y { get; set; }
}

Point p1 = new Point { X = 10, Y = 20 };
Point p2 = p1;  // Копируется всё содержимое
p2.X = 30;      // p1 не изменилась

print($"p1.X={p1.X}, p2.X={p2.X}");  // 10, 30

// Встроенные структуры:
DateTime dt = DateTime.Now;  // Структура
TimeSpan ts = TimeSpan.FromHours(1);  // Структура
Guid id = Guid.NewGuid();  // Структура

7. Перечисления (Enums) — Value Types

// Enum — специальный value type для именованных констант
public enum Color
{
    Red = 0,
    Green = 1,
    Blue = 2
}

public enum Status
{
    Pending,
    Active,
    Inactive
}

Color myColor = Color.Red;
Status myStatus = Status.Active;

print(myColor);      // Red
print((int)myColor); // 0

// Перебор
foreach (Color color in Enum.GetValues(typeof(Color)))
{
    print(color);  // Red, Green, Blue
}

8. Коллекции

// Массивы
int[] numbers = new int[5];  // Массив из 5 нулей
int[] initialized = { 1, 2, 3, 4, 5 };

// Обобщённые коллекции (Generics)
List<int> list = new List<int> { 1, 2, 3 };
Dictionary<string, int> ages = new Dictionary<string, int>
{
    { "Alice", 30 },
    { "Bob", 25 }
};
HashSet<string> unique = new HashSet<string> { "apple", "banana" };
Queue<int> queue = new Queue<int>();
Stack<int> stack = new Stack<int>();

// LINQ (Language Integrated Query)
var evenNumbers = numbers.Where(n => n % 2 == 0).ToList();
var mapped = numbers.Select(n => n * 2).ToArray();

9. Неявное и явное преобразование типов

// Неявное преобразование (безопасное)
int x = 10;
long y = x;  // int автоматически преобразуется в long
float f = 3.14f;
double d = f;  // float преобразуется в double

// Явное преобразование (может потерять данные)
long big = 999999999999;
int small = (int)big;  // Явное приведение типа

// Проверка перед преобразованием
string text = "123";
if (int.TryParse(text, out int number))
{
    print(number);  // 123
}
else
{
    print("Ошибка преобразования");
}

10. Практические рекомендации

print("===== РЕКОМЕНДАЦИИ =====");

print("\n1. Используйте правильные типы:");
print("   - int для целых чисел (по умолчанию)");
print("   - decimal для денежных операций");
print("   - double для научных вычислений");
print("   - bool для логики");
print("   - string для текста");

print("\n2. Предпочитайте Nullable типы для отсутствующих значений:");
print("   int? age = null;  // Вместо -1 или 0");

print("\n3. Используйте обобщённые типы (Generics):");
print("   List<T> вместо ArrayList");

print("\n4. Структуры для маленьких данных:");
print("   struct Point { int X; int Y; }");
print("   Классы для больших и сложных объектов");

print("\n5. Используйте const для констант:");
print("   const int MaxSize = 100;");

Итог

Value Types (16 встроенных):

• Целочисленные: sbyte, byte, short, ushort, int, uint, long, ulong
• С плавающей точкой: float, double, decimal
• Логический и символьный: bool, char
• Структуры и перечисления

Reference Types:

• string, object, массивы, классы, интерфейсы, делегаты

Для Data Science в C#:

• Используйте List<T> вместо массивов
• Dictionary<K, V> для отображений
• LINQ для обработки данных
• NumSharp для численных вычислений