Error Handling

Error Handling

Overview

FLEXON provides comprehensive error handling to help you debug and resolve issues during serialization, deserialization, and validation.

Exception Types

FlexonException

Base exception for all FLEXON-related errors.

try
{
    var result = serializer.Deserialize<Person>(data);
}
catch (FlexonException ex)
{
    Console.WriteLine($"FLEXON error: {ex.Message}");
}

FlexonSerializationException

Thrown during serialization/deserialization errors.

try
{
    byte[] binary = serializer.Serialize(data);
}
catch (FlexonSerializationException ex)
{
    Console.WriteLine($"Serialization failed: {ex.Message}");
    Console.WriteLine($"Type: {ex.SourceType}");
    Console.WriteLine($"Path: {ex.Path}");
}

FlexonValidationException

Thrown when data fails schema validation.

try
{
    var result = serializer.Deserialize<Person>(data);
}
catch (FlexonValidationException ex)
{
    foreach (var error in ex.ValidationErrors)
    {
        Console.WriteLine($"{error.Path}: {error.Message}");
    }
}

Error Handling Patterns

1. Try-Parse Pattern

public static class FlexonExtensions
{
    public static bool TryDeserialize<T>(
        this FlexonSerializer serializer,
        byte[] data,
        out T result,
        out List<ValidationError> errors)
    {
        result = default;
        errors = new List<ValidationError>();

        try
        {
            result = serializer.Deserialize<T>(data);
            return true;
        }
        catch (FlexonValidationException ex)
        {
            errors = ex.ValidationErrors;
            return false;
        }
    }
}

2. Result Pattern

public class FlexonResult<T>
{
    public bool Success { get; }
    public T Value { get; }
    public List<ValidationError> Errors { get; }

    public static FlexonResult<T> Ok(T value) =>
        new(true, value, null);

    public static FlexonResult<T> Error(List<ValidationError> errors) =>
        new(false, default, errors);
}

public static class FlexonSerializer
{
    public FlexonResult<T> TryDeserialize<T>(byte[] data)
    {
        try
        {
            var result = Deserialize<T>(data);
            return FlexonResult<T>.Ok(result);
        }
        catch (FlexonValidationException ex)
        {
            return FlexonResult<T>.Error(ex.ValidationErrors);
        }
    }
}

Validation Errors

Error Types

public enum ValidationErrorType
{
    Required,
    Type,
    Format,
    Range,
    Pattern,
    Custom
}

public class ValidationError
{
    public ValidationErrorType Type { get; set; }
    public string Path { get; set; }
    public string Message { get; set; }
    public object InvalidValue { get; set; }
}

Custom Validation

public class CustomValidator : IFlexonValidator
{
    public ValidationResult Validate(object value)
    {
        var errors = new List<ValidationError>();

        // Custom validation logic
        if (!IsValid(value))
        {
            errors.Add(new ValidationError
            {
                Type = ValidationErrorType.Custom,
                Message = "Custom validation failed"
            });
        }

        return new ValidationResult(errors);
    }
}

Error Recovery

1. Default Values

public class Person
{
    [FlexonDefault("Unknown")]
    public string Name { get; set; }

    [FlexonDefault(0)]
    public int Age { get; set; }
}

2. Error Tolerance

var options = new FlexonOptions
{
    ErrorMode = ErrorMode.Tolerant,
    OnError = (sender, args) =>
    {
        Console.WriteLine($"Warning: {args.Message}");
    }
};

3. Data Migration

public class DataMigrator
{
    public byte[] Migrate(byte[] oldData, int fromVersion, int toVersion)
    {
        try
        {
            return MigrateInternal(oldData, fromVersion, toVersion);
        }
        catch (FlexonException ex)
        {
            // Log error and return fallback
            return CreateFallbackData();
        }
    }
}

Logging and Diagnostics

1. Error Logging

public class FlexonLogger
{
    private readonly ILogger _logger;

    public void LogError(FlexonException ex)
    {
        _logger.LogError(ex, "FLEXON error occurred");
        
        if (ex is FlexonValidationException validationEx)
        {
            foreach (var error in validationEx.ValidationErrors)
            {
                _logger.LogError("Validation error at {Path}: {Message}",
                    error.Path, error.Message);
            }
        }
    }
}

2. Performance Logging

public class PerformanceLogger
{
    public async Task LogOperation(string operation, Func<Task> action)
    {
        var sw = Stopwatch.StartNew();
        try
        {
            await action();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Operation {Op} failed", operation);
            throw;
        }
        finally
        {
            sw.Stop();
            _logger.LogInformation("Operation {Op} took {Ms}ms",
                operation, sw.ElapsedMilliseconds);
        }
    }
}

3. Debug Information

public class DebugInfo
{
    public string Operation { get; set; }
    public string Path { get; set; }
    public Type ExpectedType { get; set; }
    public Type ActualType { get; set; }
    public object Value { get; set; }
}

public class FlexonDebugger
{
    public DebugInfo GetDebugInfo(FlexonException ex)
    {
        return new DebugInfo
        {
            Operation = ex.Operation,
            Path = ex.Path,
            ExpectedType = ex.ExpectedType,
            ActualType = ex.ActualType,
            Value = ex.Value
        };
    }
}

Best Practices

1. Error Prevention

   • Use schema validation
   • Implement custom validators
   • Test error cases

2. Error Handling

   • Catch specific exceptions
   • Log errors appropriately
   • Provide meaningful messages

3. Recovery

   • Use default values
   • Implement fallbacks
   • Consider data migration

4. Monitoring

   • Log errors and performance
   • Track error rates
   • Monitor system health