Advanced Examples

Advanced Examples

Overview

This guide provides advanced examples demonstrating FLEXON's powerful features and capabilities.

Custom Type System

1. Complex Data Structures

[FlexonType(TypeCode = 0x0A)]
public class GeometryCollection : IFlexonType
{
    public List<Shape> Shapes { get; set; }
    public Dictionary<string, Material> Materials { get; set; }
    public Transform WorldTransform { get; set; }

    public void Serialize(FlexonWriter writer)
    {
        writer.WriteList(Shapes);
        writer.WriteDictionary(Materials);
        writer.WriteValue(WorldTransform);
    }

    public void Deserialize(FlexonReader reader)
    {
        Shapes = reader.ReadList<Shape>();
        Materials = reader.ReadDictionary<string, Material>();
        WorldTransform = reader.ReadValue<Transform>();
    }
}

[FlexonType(TypeCode = 0x0B)]
public abstract class Shape : IFlexonType
{
    public string Name { get; set; }
    public Vector3 Position { get; set; }
    public Quaternion Rotation { get; set; }

    public abstract float CalculateVolume();
    public abstract bool ContainsPoint(Vector3 point);

    public virtual void Serialize(FlexonWriter writer)
    {
        writer.WriteString(Name);
        writer.WriteValue(Position);
        writer.WriteValue(Rotation);
    }

    public virtual void Deserialize(FlexonReader reader)
    {
        Name = reader.ReadString();
        Position = reader.ReadValue<Vector3>();
        Rotation = reader.ReadValue<Quaternion>();
    }
}

2. Version Migration

[FlexonType(TypeCode = 0x0C, Version = 2)]
public class Character : IFlexonType
{
    // Version 1 fields
    public string Name { get; set; }
    public int Level { get; set; }
    public Stats BaseStats { get; set; }

    // Version 2 fields
    public List<Ability> Abilities { get; set; }
    public Equipment[] EquippedItems { get; set; }

    public void Serialize(FlexonWriter writer)
    {
        writer.WriteString(Name);
        writer.WriteInt32(Level);
        writer.WriteValue(BaseStats);

        // Version 2 fields
        writer.WriteList(Abilities);
        writer.WriteArray(EquippedItems);
    }

    public void Deserialize(FlexonReader reader)
    {
        Name = reader.ReadString();
        Level = reader.ReadInt32();
        BaseStats = reader.ReadValue<Stats>();

        if (reader.Version >= 2)
        {
            Abilities = reader.ReadList<Ability>();
            EquippedItems = reader.ReadArray<Equipment>();
        }
        else
        {
            Abilities = new List<Ability>();
            EquippedItems = Array.Empty<Equipment>();
        }
    }
}

Advanced Serialization

1. Streaming Large Data

public class StreamProcessor
{
    private readonly IFlexonSerializer _serializer;
    private readonly int _bufferSize;

    public async Task ProcessLargeFile(string inputPath, string outputPath)
    {
        using var input = File.OpenRead(inputPath);
        using var output = File.Create(outputPath);
        
        var buffer = new byte[_bufferSize];
        var reader = new FlexonStreamReader(input, buffer);
        var writer = new FlexonStreamWriter(output, buffer);

        await foreach (var item in reader.ReadAsync<DataItem>())
        {
            var processed = await ProcessItem(item);
            await writer.WriteAsync(processed);
            await writer.FlushAsync();
        }
    }

    public async IAsyncEnumerable<T> StreamData<T>(
        Stream stream,
        [EnumeratorCancellation] CancellationToken ct = default)
    {
        var reader = new FlexonStreamReader(stream);
        
        while (!ct.IsCancellationRequested && !reader.EndOfStream)
        {
            yield return await reader.ReadAsync<T>(ct);
        }
    }
}

2. Compression Strategies

public class CompressionManager
{
    private readonly IFlexonSerializer _serializer;

    public byte[] CompressData<T>(T data, CompressionStrategy strategy)
    {
        var options = new FlexonOptions
        {
            EnableCompression = true,
            CompressionLevel = strategy switch
            {
                CompressionStrategy.Speed => CompressionLevel.Fastest,
                CompressionStrategy.Balance => CompressionLevel.Balanced,
                CompressionStrategy.Size => CompressionLevel.Optimal,
                _ => throw new ArgumentException("Invalid strategy")
            }
        };

        return _serializer.Serialize(data, options);
    }

    public async Task CompressStream(
        Stream input,
        Stream output,
        CompressionStrategy strategy)
    {
        using var compression = new GZipStream(
            output,
            (CompressionLevel)strategy,
            true);

        var writer = new FlexonStreamWriter(compression);
        var reader = new FlexonStreamReader(input);

        await foreach (var item in reader.ReadAsync<dynamic>())
        {
            await writer.WriteAsync(item);
            await writer.FlushAsync();
        }
    }
}

3. Memory Optimization

public class MemoryOptimizer
{
    private readonly ArrayPool<byte> _arrayPool;
    private readonly ObjectPool<FlexonWriter> _writerPool;
    private readonly ObjectPool<FlexonReader> _readerPool;

    public async Task ProcessLargeDataSet<T>(
        IAsyncEnumerable<T> items,
        Func<T, Task> processor)
    {
        var buffer = _arrayPool.Rent(81920);
        try
        {
            var writer = _writerPool.Get();
            try
            {
                await foreach (var item in items)
                {
                    writer.Reset(buffer);
                    writer.WriteValue(item);
                    
                    var reader = _readerPool.Get();
                    try
                    {
                        reader.Reset(buffer);
                        var processed = reader.ReadValue<T>();
                        await processor(processed);
                    }
                    finally
                    {
                        _readerPool.Return(reader);
                    }
                }
            }
            finally
            {
                _writerPool.Return(writer);
            }
        }
        finally
        {
            _arrayPool.Return(buffer);
        }
    }
}

Performance Optimization

1. SIMD Operations

public class SimdProcessor
{
    private readonly IFlexonSerializer _serializer;

    public void ProcessVectors(Vector3[] vectors)
    {
        var options = new FlexonOptions { EnableSimd = true };
        
        if (Vector.IsHardwareAccelerated)
        {
            ProcessVectorsSimd(vectors);
        }
        else
        {
            ProcessVectorsScalar(vectors);
        }
    }

    private void ProcessVectorsSimd(Vector3[] vectors)
    {
        var count = vectors.Length;
        var vectorCount = count / 4;

        for (int i = 0; i < vectorCount; i++)
        {
            var v1 = new Vector<float>(
                new[] { 
                    vectors[i * 4].X,
                    vectors[i * 4 + 1].X,
                    vectors[i * 4 + 2].X,
                    vectors[i * 4 + 3].X
                });

            // Process with SIMD
            var result = Vector.Multiply(v1, new Vector<float>(2.0f));
            
            // Store results
            result.CopyTo(new[] {
                ref vectors[i * 4].X,
                ref vectors[i * 4 + 1].X,
                ref vectors[i * 4 + 2].X,
                ref vectors[i * 4 + 3].X
            });
        }
    }
}

2. Parallel Processing

public class ParallelProcessor
{
    private readonly IFlexonSerializer _serializer;
    private readonly ParallelOptions _options;

    public async Task ProcessBatch<T>(IEnumerable<T> items)
    {
        var partitioner = Partitioner.Create(items);
        
        await Parallel.ForEachAsync(
            partitioner,
            _options,
            async (partition, ct) =>
            {
                foreach (var item in partition)
                {
                    var binary = _serializer.Serialize(item);
                    await ProcessItem(binary, ct);
                }
            });
    }

    public async Task<List<TResult>> MapReduce<TSource, TResult>(
        IEnumerable<TSource> items,
        Func<TSource, Task<TResult>> map,
        Func<IEnumerable<TResult>, TResult> reduce)
    {
        var results = new ConcurrentBag<TResult>();
        
        await Parallel.ForEachAsync(
            items,
            _options,
            async (item, ct) =>
            {
                var result = await map(item);
                results.Add(result);
            });

        return new List<TResult> { reduce(results) };
    }
}

Real-world Scenarios

1. Game State Synchronization

public class GameStateManager
{
    private readonly IFlexonSerializer _serializer;
    private readonly ConcurrentDictionary<Guid, GameState> _states;

    public async Task BroadcastState(GameState state)
    {
        var options = new FlexonOptions
        {
            EnableCompression = true,
            CompressionLevel = CompressionLevel.Fastest
        };

        var binary = _serializer.Serialize(state, options);
        await BroadcastToClients(binary);
    }

    public async Task ProcessStateUpdate(byte[] binary)
    {
        var update = _serializer.Deserialize<StateUpdate>(binary);
        
        if (_states.TryGetValue(update.GameId, out var state))
        {
            state.ApplyUpdate(update);
            await NotifyStateChanged(state);
        }
    }

    public async Task RecordReplay(GameReplay replay)
    {
        var options = new FlexonOptions
        {
            EnableCompression = true,
            CompressionLevel = CompressionLevel.Optimal
        };

        var binary = _serializer.Serialize(replay, options);
        await SaveReplay(binary);
    }
}

2. Scientific Data Processing

public class DataProcessor
{
    private readonly IFlexonSerializer _serializer;

    public async Task ProcessExperimentData(ExperimentData data)
    {
        var options = new FlexonOptions
        {
            EnableSimd = true,
            Schema = ExperimentSchema.Instance
        };

        // Process raw data
        var processed = await ProcessRawData(data);

        // Serialize results
        var binary = _serializer.Serialize(processed, options);
        await SaveResults(binary);
    }

    public async Task AnalyzeTimeSeries(TimeSeriesData data)
    {
        var options = new FlexonOptions
        {
            EnableCompression = true,
            UsePooledBuffers = true
        };

        var results = await PerformAnalysis(data);
        var binary = _serializer.Serialize(results, options);
        await PublishResults(binary);
    }
}

3. Financial Data Processing

public class FinancialDataProcessor
{
    private readonly IFlexonSerializer _serializer;
    private readonly ISecurityProvider _security;

    public async Task ProcessTransaction(Transaction transaction)
    {
        var options = new FlexonOptions
        {
            EnableValidation = true,
            Schema = TransactionSchema.Instance,
            EnableEncryption = true,
            EncryptionKey = await _security.GetKey()
        };

        var binary = _serializer.Serialize(transaction, options);
        await SaveTransaction(binary);
    }

    public async Task GenerateReport(ReportCriteria criteria)
    {
        var options = new FlexonOptions
        {
            EnableCompression = true,
            CompressionLevel = CompressionLevel.Optimal
        };

        var report = await GenerateReportData(criteria);
        var binary = _serializer.Serialize(report, options);
        await PublishReport(binary);
    }
}

Advanced Features

1. Custom Compression

public class CustomCompression : IFlexonCompression
{
    public byte[] Compress(byte[] data)
    {
        // Custom compression logic
        return CompressData(data);
    }

    public byte[] Decompress(byte[] compressed)
    {
        // Custom decompression logic
        return DecompressData(compressed);
    }
}

// Register custom compression
FlexonConfiguration.RegisterCompression(new CustomCompression());

2. Encryption Integration

public class EncryptionProvider : IFlexonEncryption
{
    private readonly IKeyVault _keyVault;

    public async Task<byte[]> Encrypt(byte[] data, string keyId)
    {
        var key = await _keyVault.GetKey(keyId);
        using var aes = Aes.Create();
        
        aes.Key = key;
        using var encryptor = aes.CreateEncryptor();
        return encryptor.TransformFinalBlock(data, 0, data.Length);
    }

    public async Task<byte[]> Decrypt(byte[] encrypted, string keyId)
    {
        var key = await _keyVault.GetKey(keyId);
        using var aes = Aes.Create();
        
        aes.Key = key;
        using var decryptor = aes.CreateDecryptor();
        return decryptor.TransformFinalBlock(encrypted, 0, encrypted.Length);
    }
}

3. Custom Validation

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

        if (value is BusinessObject obj)
        {
            // Validate business rules
            if (!ValidateBusinessRules(obj))
            {
                errors.Add(new ValidationError
                {
                    Path = "businessRules",
                    Message = "Business rules validation failed"
                });
            }
        }

        return new ValidationResult(errors);
    }
}

// Register custom validator
FlexonConfiguration.RegisterValidator(new BusinessRuleValidator());

Best Practices

1. Memory Management

   • Use buffer pooling for large operations
   • Implement proper disposal patterns
   • Monitor memory usage
   • Use appropriate buffer sizes

2. Performance

   • Enable SIMD when appropriate
   • Use parallel processing for large datasets
   • Implement proper batching
   • Profile your code

3. Security

   • Validate all input
   • Use encryption for sensitive data
   • Implement proper access control
   • Monitor for security events

4. Error Handling

   • Implement proper retry logic
   • Log all errors
   • Provide meaningful error messages
   • Handle version mismatches