Исключения в C#: Stack Overflow, Access Violation и Out of memory

void InfiniteRecursion()
{
    InfiniteRecursion(); // Приведет к StackOverflowException
}
 
try
{
    InfiniteRecursion();
}
catch (Exception) // Не поймает StackOverflowException
{
    // Этот код никогда не выполнится
}

try
{
    throw new StackOverflowException();
}
catch (Exception)
{
    // Этот блок выполнится
}

public static void RecursiveMethod(int depth)
{
    try
    {
        RuntimeHelpers.EnsureSufficientExecutionStack();
        // Если стека недостаточно, будет выброшено исключение
        // InsufficientExecutionStackException, которое можно перехватить
        
        if (depth <= 0) return;
        RecursiveMethod(depth - 1);
    }
    catch (InsufficientExecutionStackException)
    {
        Console.WriteLine("Стек почти исчерпан!");
    }
}

Span<byte> span;
if (CanAllocateOnStack(size))
    span = stackalloc byte[size];
else
    span = new byte[size];

try {
    var appDomain = AppDomain.CreateDomain("...");
    appDomain.DoCallBack(() => {
        var thread = new Thread(() => InfiniteRecursion());
        thread.Start();
        thread.Join();
    });
    AppDomain.Unload(appDomain);
}
catch (AppDomainUnloadedException) { }

[DllImport("kernel32.dll", SetLastError = true)]
static extern IntPtr AddVectoredExceptionHandler(IntPtr FirstHandler, 
    VECTORED_EXCEPTION_HANDLER VectoredHandler);
 
static unsafe VEH Handler(ref EXCEPTION_POINTERS e)
{
    if (e.ExceptionRecord->ExceptionCode == ExceptionStackOverflow)
    {
        e.ExceptionRecord->ExceptionCode = 0x01234567; // Подмена кода
        return VEH.EXCEPTION_EXECUTE_HANDLER;
    }
    return VEH.EXCEPTION_CONTINUE_SEARCH;
}

HandleSO(() => InfiniteRecursion());
HandleSO(() => InfiniteRecursion());

[DllImport("msvcrt.dll")]
static extern int _resetstkoflw();
 
static T HandleSO<T>(Func<T> action)
{
    Kernel32.AddVectoredExceptionHandler(IntPtr.Zero, Handler);
    Kernel32.SetThreadStackGuarantee(ref size);
    try
    {
        return action();
    }
    catch (Exception e) when ((uint)Marshal.GetExceptionCode() == 0x01234567)
    {
        _resetstkoflw(); // Восстанавливаем состояние стека
        return default(T);
    }
}

int FactorialTailRecursive(int n, int accumulator = 1)
{
    if (n <= 1) return accumulator;
    return FactorialTailRecursive(n - 1, n * accumulator);
}

[MethodImpl(MethodImplOptions.NoInlining)]
void NoInlineMethod() { /* ... */ }
 
[MethodImpl(MethodImplOptions.AggressiveInlining)]
void AggressiveInlineMethod() { /* ... */ }

async Task RecursiveAsync(int n)
{
    if (n <= 0) return;
    await Task.Yield(); // Возвращаем управление
    await RecursiveAsync(n - 1); // Это не приведет к переполнению стека
}

// Создание потока с меньшим размером стека (512 KB)
var thread = new Thread(ThreadMethod, 512 * 1024);
thread.Start();

0:000> !clrstack
OS Thread Id: 0xd98 (0)
        Child SP               IP Call Site
000000000012e678 00007ffbf26e5e31 [HelperMethodFrame: 000000000012e678] System.Runtime.CompilerServices.RuntimeHelpers.EnsureSufficientExecutionStack()
000000000012e780 00007ffb341a04bd ConsoleApp.Program.RecursiveMethod(Int32)
000000000012e7f0 00007ffb341a04bd ConsoleApp.Program.RecursiveMethod(Int32)
... много одинаковых строк...
000000000012f7f0 00007ffb341a04bd ConsoleApp.Program.RecursiveMethod(Int32)
000000000012f840 00007ffb341a03cd ConsoleApp.Program.Main(System.String[])

try
{
    Marshal.WriteByte((IntPtr)1000, 42);
}
catch (AccessViolationException)
{
    Console.WriteLine("Поймали исключение!");
}

try
{
    var bytes = new byte[] {42};
    Marshal.Copy(bytes, 0, (IntPtr)1000, bytes.Length);
}
catch (AccessViolationException)
{
    Console.WriteLine("Поймали исключение!");
}

unsafe static void WriteByte(IntPtr ptr, byte val)
{
    try
    {
        *(byte*)ptr = val;
    }
    catch (NullReferenceException)
    {
        throw new AccessViolationException();
    }
}

static void Copy(...)
{
    Marshal.CopyToNative((object)source, startIndex, destination, length);
}
[MethodImpl(MethodImplOptions.InternalCall)]
static extern void CopyToNative(object source, int startIndex, IntPtr destination, int length);

// Прямое обращение через указатель
unsafe
{
    *(byte*)1000 = 42; // Выбросит NullReferenceException
}

while (isRunning)
{
    try
    {
        action();
    }
    catch (Exception e)
    {
        log.Error(e);
    }
    WaitForNextExecution(...);
}

unsafe void DangerousMethod(byte* ptr)
{
    // Нет никакой проверки, что ptr указывает на валидную память
    *ptr = 42;
}

unsafe void UnsafeGCIssue()
{
    var array = new byte[100];
    fixed (byte* ptr = array)
    {
        // Сохраняем указатель
        SavePointer(ptr);
    }
    
    // После выхода из fixed блока, GC может переместить array
    // и ptr станет невалидным
}
 
// Где-то позже:
unsafe void UsePointer()
{
    byte* ptr = GetSavedPointer();
    *ptr = 42; // Потенциальный AccessViolation!
}

class DangerousResource : IDisposable
{
    IntPtr nativeHandle;
    
    ~DangerousResource()
    {
        // Если nativeHandle невалиден, AccessViolation убьет процесс
        Marshal.FreeHGlobal(nativeHandle);
    }
    
    public void Dispose()
    {
        Marshal.FreeHGlobal(nativeHandle);
        nativeHandle = IntPtr.Zero;
        GC.SuppressFinalize(this);
    }
}

[DllImport("kernel32.dll")]
static extern bool ReadProcessMemory(
    IntPtr hProcess,
    IntPtr lpBaseAddress,
    byte[] lpBuffer,      // Неправильно! Должен быть [Out] byte[]
    int dwSize,
    out int lpNumberOfBytesRead);

private IntPtr _nativeResource;
 
// Поток 1
void ReleaseResource()
{
    var temp = _nativeResource;
    _nativeResource = IntPtr.Zero;
    NativeMethods.ReleaseHandle(temp);
}
 
// Поток 2
void UseResource()
{
    // Между проверкой и использованием ресурс может быть освобожден
    if (_nativeResource != IntPtr.Zero)
    {
        // Внезапный AccessViolation из-за гонки данных
        NativeMethods.UseHandle(_nativeResource);
    }
}

class SafeNativeResource : SafeHandle
{
    private readonly object _lock = new object();
    
    public override bool IsInvalid => handle == IntPtr.Zero;
    
    public SafeNativeResource(IntPtr handle) : base(IntPtr.Zero, true)
    {
        SetHandle(handle);
    }
    
    public void UseResource(Action<IntPtr> action)
    {
        lock (_lock)
        {
            if (IsInvalid)
                throw new ObjectDisposedException("Resource");
                
            action(handle);
        }
    }
    
    protected override bool ReleaseHandle()
    {
        if (handle != IntPtr.Zero)
        {
            NativeMethods.ReleaseHandle(handle);
            return true;
        }
        return false;
    }
}

void RiskyComOperation()
{
    var comObject = GetComObject();
    
    // Регистрация обратного вызова
    comObject.RegisterCallback(OnCallback);
    
    // Предполагаем, что объект больше не нужен
    Marshal.ReleaseComObject(comObject);
    
    // Но COM-объект всё ещё может вызвать наш метод,
    // что приведёт к AccessViolation, если внутри
    // мы обращаемся к самому объекту
}
 
void OnCallback(int data)
{
    // Обращение к уже освобожденному объекту = AccessViolation
}

[StructLayout(LayoutKind.Sequential)]
struct ComplexStruct
{
    public IntPtr Handle;
    public string Text;  // Строка — ссылочный тип!
}
 
[DllImport("native.dll")]
static extern bool ProcessStruct(ref ComplexStruct data);
 
void BadMarshalingExample()
{
    var data = new ComplexStruct
    {
        Handle = GetSomeHandle(),
        Text = "Данные для обработки"
    };
    
    ProcessStruct(ref data);
    // Нативный код может неправильно интерпретировать строку
    // и вызвать AccessViolation
}

[StructLayout(LayoutKind.Sequential)]
struct SaferStruct
{
    public IntPtr Handle;
    
    [MarshalAs(UnmanagedType.LPStr)]  // Явное указание типа
    public string Text;
}

// Делегат для обратного вызова из нативного кода
delegate void NativeCallback(IntPtr data);
 
[DllImport("native.dll")]
static extern void RegisterCallbackFromNative(NativeCallback callback);
 
void InitializeNativeLibrary()
{
    // Регистрируем колбэк, который будет вызываться из нативного потока
    RegisterCallbackFromNative(OnNativeCallback);
}
 
void OnNativeCallback(IntPtr data)
{
    // Код выполняется в нативном потоке!
    // Доступ к управляемым объектам должен быть синхронизирован
}

void OnNativeCallback(IntPtr data)
{
    // Переносим выполнение в пул потоков .NET
    Task.Run(() => ProcessDataSafely(data));
}

var arr4gb = new int[int.MaxValue/2];

var largeArr = new int[int.MaxValue]; // Всё равно OutOfMemory

// Упрощённый код из реализации string.Concat
if (totalLength > 0x7FFFFFFD)
{
    throw new OutOfMemoryException();
}

LimitMemory(64.Mb());
try
{
    while (true)
        list.Add(new byte[size]);
}
catch (OutOfMemoryException e)
{
    Console.WriteLine(e);
}

List<byte[]> keepAlive = new List<byte[]>();
for (int i = 0; i < 1000; i++)
{
    if (i % 3 == 0)
    {
        // Создаём большой объект и храним его
        keepAlive.Add(new byte[86 * 1024]);
    }
    else
    {
        // Создаём и сразу "забываем" большой объект
        var temp = new byte[86 * 1024];
    }
}

GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce;
GC.Collect();

// Наивная реализация кэша без ограничения размера
private static Dictionary<string, object> _cache = new Dictionary<string, object>();
 
public static object GetItem(string key)
{
    if (!_cache.ContainsKey(key))
    {
        _cache[key] = LoadExpensiveItem(key);
    }
    return _cache[key];
}

private static MemoryCache _cache = new MemoryCache(new MemoryCacheOptions
{
    SizeLimit = 1024 // Ограничение размера в МБ
});
 
public static object GetItem(string key)
{
    if (!_cache.TryGetValue(key, out var item))
    {
        item = LoadExpensiveItem(key);
        _cache.Set(key, item, new MemoryCacheEntryOptions
        {
            Size = GetApproximateSize(item),
            SlidingExpiration = TimeSpan.FromMinutes(10)
        });
    }
    return item;
}

// Неоптимальный вариант - каждая итерация создаёт строку
for (int i = 0; i < 1000000; i++)
{
    string message = $"Текущее значение: {i}";
    ProcessMessage(message);
}
 
// Оптимизированный вариант
var builder = new StringBuilder();
for (int i = 0; i < 1000000; i++)
{
    builder.Clear();
    builder.Append("Текущее значение: ").Append(i);
    ProcessMessage(builder.ToString());
}

// Настраиваем режим работы GC программно
GCSettings.LatencyMode = GCLatencyMode.SustainedLowLatency;

// До .NET Core 3.0 это могло вернуть общую память хост-системы,
// а не лимит контейнера
Console.WriteLine($"Доступная память: {GC.GetGCMemoryInfo().TotalAvailableMemoryBytes / 1024 / 1024} МБ");

ThreadPool.SetMaxThreads(Environment.ProcessorCount * 2, Environment.ProcessorCount * 4);
ServicePointManager.DefaultConnectionLimit = Environment.ProcessorCount * 4;

// Добавление точек для профилирования
var snapshot1 = MemoryProfiler.TakeSnapshot();
DoSomethingMemoryIntensive();
var snapshot2 = MemoryProfiler.TakeSnapshot();
var diff = MemoryProfiler.Compare(snapshot1, snapshot2);

// Потенциальная утечка из-за замыкания на this
async Task ProcessDataAsync()
{
  var largeObjectInClosure = this.LargeObject;
  await DoSomethingAsync();
  // this.LargeObject удерживается в памяти всё время ожидания
  Console.WriteLine(largeObjectInClosure.ToString());
}

// Неэффективное использование строк
string result = "";
for (int i = 0; i < 100000; i++)
{
  result += GetDataChunk(i); // Каждая итерация создаёт новую строку
}

ReadOnlySpan<char> text = "Hello, World!".AsSpan();
ReadOnlySpan<char> greeting = text.Slice(0, 5); // Без выделения новой памяти

// Оптимизация для часто синхронно завершающихся операций
public ValueTask<int> GetValueAsync()
{
  if (_cache.TryGetValue(key, out var value))
      return new ValueTask<int>(value); // Нет аллокации Task<T>
      
  return new ValueTask<int>(LoadValueAsync());
}

// Простой пул буферов
public class BufferPool
{
  private ConcurrentQueue<byte[]> _buffers = new ConcurrentQueue<byte[]>();
  
  public byte[] Rent()
  {
      if (_buffers.TryDequeue(out var buffer))
          return buffer;
      return new byte[4096]; // Создаём новый, если пул пуст
  }
  
  public void Return(byte[] buffer)
  {
      Array.Clear(buffer, 0, buffer.Length);
      _buffers.Enqueue(buffer);
  }
}

// Запуск рискованной операции в отдельном процессе
public Result ExecuteRiskyOperation(Parameters parameters)
{
    var processInfo = new ProcessStartInfo
    {
        FileName = "RiskyOperationHost.exe",
        Arguments = JsonSerializer.Serialize(parameters),
        RedirectStandardOutput = true,
        UseShellExecute = false
    };
    
    using var process = Process.Start(processInfo);
    process.WaitForExit(timeout: 30000);
    
    if (process.ExitCode != 0)
        return Result.Failure("Операция завершилась с ошибкой");
        
    var output = process.StandardOutput.ReadToEnd();
    return JsonSerializer.Deserialize<Result>(output);
}

public async Task<T> ExecuteWithWatchdog<T>(Func<Task<T>> operation, TimeSpan timeout)
{
    using var cts = new CancellationTokenSource();
    
    // Запускаем сторожевой таймер
    var watchdogTask = Task.Delay(timeout, cts.Token)
        .ContinueWith(_ => default(T));
        
    // Запускаем основную операцию
    var operationTask = operation();
    
    // Ожидаем завершения любой из задач
    var completedTask = await Task.WhenAny(operationTask, watchdogTask);
    
    if (completedTask == operationTask)
    {
        cts.Cancel(); // Отменяем сторожевой таймер
        return await operationTask;
    }
    
    // Операция заняла слишком много времени
    throw new TimeoutException("Операция превысила лимит времени выполнения");
}

public class MemoryMonitor
{
    private readonly Timer _monitorTimer;
    private readonly long _criticalThresholdBytes;
    
    public MemoryMonitor(long criticalThresholdMb, Action emergencyAction)
    {
        _criticalThresholdBytes = criticalThresholdMb * 1024 * 1024;
        _monitorTimer = new Timer(_ =>
        {
            var currentUsage = GC.GetTotalMemory(forceFullCollection: false);
            if (currentUsage > _criticalThresholdBytes)
            {
                // Принудительная сборка мусора
                GC.Collect(2, GCCollectionMode.Forced, true);
                GC.WaitForPendingFinalizers();
                
                // Проверяем снова после сборки мусора
                currentUsage = GC.GetTotalMemory(forceFullCollection: false);
                if (currentUsage > _criticalThresholdBytes)
                {
                    emergencyAction(); // Вызываем экстренное действие
                }
            }
        }, null, TimeSpan.Zero, TimeSpan.FromMinutes(1));
    }
}

public class CircuitBreaker
{
    private readonly TimeSpan _resetTimeout;
    private int _failureCount;
    private readonly int _failureThreshold;
    private DateTime _lastFailureTime;
    private readonly object _lock = new object();
    
    public CircuitBreaker(int failureThreshold, TimeSpan resetTimeout)
    {
        _failureThreshold = failureThreshold;
        _resetTimeout = resetTimeout;
    }
    
    public TResult ExecuteAction<TResult>(Func<TResult> action)
    {
        lock (_lock)
        {
            if (_failureCount >= _failureThreshold)
            {
                // Цепь разомкнута, проверяем возможность сброса
                if (DateTime.UtcNow - _lastFailureTime > _resetTimeout)
                {
                    _failureCount = 0; // Сбрасываем счетчик ошибок
                }
                else
                {
                    throw new CircuitBreakerOpenException("Цепь разомкнута");
                }
            }
        }
        
        try
        {
            return action();
        }
        catch
        {
            lock (_lock)
            {
                _failureCount++;
                _lastFailureTime = DateTime.UtcNow;
            }
            throw;
        }
    }
}

public async Task<T> ExecuteWithRetry<T>(Func<Task<T>> operation, int maxAttempts = 3)
{
    int attempt = 0;
    while (true)
    {
        try
        {
            return await operation();
        }
        catch (Exception ex) when (IsTransientException(ex) && ++attempt < maxAttempts)
        {
            // Экспоненциальный рост интервала между попытками
            var delay = TimeSpan.FromMilliseconds(Math.Pow(2, attempt) * 100);
            await Task.Delay(delay);
        }
    }
}
 
private bool IsTransientException(Exception ex)
{
    // Определяем, какие исключения считать временными
    return ex is TimeoutException 
        || (ex is IOException && !(ex is FileNotFoundException));
}

public static T Trampoline<T>(Func<T> bounce)
{
    while (bounce is Func<T>)
    {
        bounce = bounce();
    }
    return (T)bounce;
}
 
// Пример использования для факториала
public static object Factorial(int n, int acc = 1)
{
    if (n <= 1) return acc;
    return new Func<object>(() => Factorial(n - 1, n * acc));
}
 
// Вызов через трамплин
var result = Trampoline<object>(() => Factorial(10000));

public class ResourceScheduler
{
    private readonly ConcurrentDictionary<string, PriorityInfo> _resources = 
        new ConcurrentDictionary<string, PriorityInfo>();
        
    // Запрос ресурса с учётом приоритета
    public async Task<ResourceHandle> RequestResource(string resourceId, int priority)
    {
        var info = _resources.GetOrAdd(resourceId, _ => new PriorityInfo());
        
        // При нехватке ресурсов автоматически освобождаем 
        // ресурсы с низким приоритетом
        if (info.CurrentLoad > info.MaxLoad)
        {
            await ReleaseLowestPriorityResources(resourceId);
        }
        
        return new ResourceHandle(this, resourceId, priority);
    }
    
    private async Task ReleaseLowestPriorityResources(string resourceId)
    {
        // Логика освобождения ресурсов
    }
}

public class BulkheadPolicy
{
    private readonly SemaphoreSlim _semaphore;
    
    public BulkheadPolicy(int maxConcurrency)
    {
        _semaphore = new SemaphoreSlim(maxConcurrency);
    }
    
    public async Task<T> Execute<T>(Func<Task<T>> action)
    {
        if (!await _semaphore.WaitAsync(TimeSpan.FromSeconds(5)))
            throw new BulkheadRejectedException();
            
        try
        {
            return await action();
        }
        finally
        {
            _semaphore.Release();
        }
    }
}

public class MemoryLeakDetector
{
    private readonly Timer _timer;
    private readonly Dictionary<string, WeakReference> _objectTracker = 
        new Dictionary<string, WeakReference>();
    
    public MemoryLeakDetector(TimeSpan interval)
    {
        _timer = new Timer(_ => CheckForLeaks(), null, TimeSpan.Zero, interval);
    }
    
    public void TrackObject(string identifier, object instance)
    {
        _objectTracker[identifier] = new WeakReference(instance);
    }
    
    private void CheckForLeaks()
    {
        GC.Collect(2, GCCollectionMode.Forced);
        GC.WaitForPendingFinalizers();
        
        foreach (var entry in _objectTracker)
        {
            if (entry.Value.IsAlive)
            {
                // Объект всё ещё в памяти - потенциальная утечка
                LogPotentialLeak(entry.Key);
            }
        }
    }
}

public class ServiceDegradation
{
    private enum DegradationLevel
    {
        None, 
        Light, 
        Moderate, 
        Severe
    }
    
    private DegradationLevel _currentLevel = DegradationLevel.None;
    
    public void AssessDegradationLevel()
    {
        var availableMemory = GC.GetTotalMemory(false);
        var cpuUsage = GetCpuUsage();
        
        if (availableMemory < CriticalMemoryThreshold || cpuUsage > 95)
            _currentLevel = DegradationLevel.Severe;
        else if (availableMemory < LowMemoryThreshold || cpuUsage > 80)
            _currentLevel = DegradationLevel.Moderate;
        else if (availableMemory < WarningMemoryThreshold || cpuUsage > 60)
            _currentLevel = DegradationLevel.Light;
        else
            _currentLevel = DegradationLevel.None;
    }
    
    public bool ShouldExecuteFeature(FeatureImportance importance)
    {
        // Отключаем неприоритетные функции при высокой нагрузке
        return importance switch
        {
            FeatureImportance.Critical => true,
            FeatureImportance.High => _currentLevel != DegradationLevel.Severe,
            FeatureImportance.Medium => _currentLevel <= DegradationLevel.Moderate,
            FeatureImportance.Low => _currentLevel == DegradationLevel.None,
            _ => false
        };
    }
}

public class HealthMonitoringSystem
{
    private readonly Timer _checkTimer;
    private readonly List<IHealthCheck> _healthChecks = new List<IHealthCheck>();
    
    public HealthMonitoringSystem(TimeSpan checkInterval)
    {
        _checkTimer = new Timer(_ => PerformHealthCheck(), null, TimeSpan.Zero, checkInterval);
    }
    
    public void RegisterHealthCheck(IHealthCheck check)
    {
        _healthChecks.Add(check);
    }
    
    private async void PerformHealthCheck()
    {
        foreach (var check in _healthChecks)
        {
            var result = await check.CheckHealthAsync();
            if (!result.IsHealthy)
            {
                // Запускаем восстановительные действия для проблемного компонента
                await PerformRecoveryAction(check, result);
            }
        }
    }
    
    private async Task PerformRecoveryAction(IHealthCheck check, HealthCheckResult result)
    {
        // Попытка восстановить компонент
        if (check is IRecoverable recoverable)
        {
            await recoverable.RecoverAsync();
        }
        else if (result.Status == HealthStatus.Critical)
        {
            // Для критических проблем может потребоваться перезапуск
            RestartApplication();
        }
    }
}