Use Cases

Use Cases

Real-World Applications

1. High-Performance APIs

Problem

Traditional JSON APIs struggle with large payloads and high throughput.

Solution

[ApiController]
[Route("api/[controller]")]
public class DataController : ControllerBase
{
    [HttpPost("bulk")]
    public async Task<IActionResult> BulkUpload(
        [FromBody] IEnumerable<DataItem> items)
    {
        using var stream = new MemoryStream();
        await FlexonEncoder.EncodeAsync(items, stream);
        
        // 60-80% smaller payload size
        // 2-3x faster processing
        await _storage.StoreAsync(stream.ToArray());
        
        return Ok();
    }
}

2. Game Development

Problem

Game state serialization needs to be fast and compact.

Solution

public class GameState : IFlexonSerializable
{
    public Vector3 PlayerPosition { get; set; }
    public Dictionary<string, GameObject> Objects { get; set; }
    public List<Event> PendingEvents { get; set; }

    public void Save()
    {
        using var file = File.Create("save.flexon");
        FlexonEncoder.Encode(this, file);
    }

    public static GameState Load()
    {
        using var file = File.OpenRead("save.flexon");
        return FlexonDecoder.Decode<GameState>(file);
    }
}

3. IoT Applications

Problem

IoT devices have limited bandwidth and processing power.

Solution

public class SensorData
{
    public string DeviceId { get; set; }
    public DateTime Timestamp { get; set; }
    public double Temperature { get; set; }
    public double Humidity { get; set; }
    public byte[] RawReadings { get; set; }
}

// Efficient binary format
// Native DateTime support
// Direct binary data handling
var encoded = FlexonEncoder.Encode(sensorData);
await mqttClient.PublishAsync("sensors/data", encoded);

4. Real-Time Trading

Problem

Trading systems require minimal latency and high throughput.

Solution

public class TradeOrder
{
    public string Symbol { get; set; }
    public decimal Price { get; set; }
    public int Quantity { get; set; }
    public OrderType Type { get; set; }
    public DateTime Timestamp { get; set; }
}

public class TradingSystem
{
    private readonly FlexonStreamWriter _writer;
    
    public async Task ProcessOrder(TradeOrder order)
    {
        // Sub-millisecond serialization
        await _writer.WriteAsync(order);
        await _writer.FlushAsync();
    }
}

5. Configuration Management

Problem

Complex configuration files need validation and efficiency.

Solution

{
  "type": "object",
  "properties": {
    "server": {
      "type": "object",
      "properties": {
        "host": {
          "type": "string",
          "format": "hostname"
        },
        "port": {
          "type": "integer",
          "minimum": 1024,
          "maximum": 65535
        }
      }
    },
    "database": {
      "type": "object",
      "properties": {
        "connectionString": {
          "type": "string",
          "pattern": "^Server=.+;Database=.+$"
        }
      }
    }
  }
}

public class ConfigurationManager
{
    public async Task<T> LoadConfig<T>(string path)
    {
        var schema = await File.ReadAllTextAsync("config.schema.json");
        
        using var file = File.OpenRead(path);
        return await FlexonDecoder.DecodeWithSchema<T>(
            file, schema);
    }
}

6. Log Processing

Problem

Log processing requires efficient storage and quick analysis.

Solution

public class LogProcessor
{
    private readonly FlexonBatchWriter _writer;
    
    public async Task ProcessLogs(IEnumerable<LogEntry> logs)
    {
        foreach (var batch in logs.Batch(1000))
        {
            await _writer.WriteAsync(batch);
            
            if (_writer.BytesWritten > 1024 * 1024)
            {
                await _writer.FlushAsync();
            }
        }
    }
}

7. Data Migration

Problem

Large-scale data migration needs efficiency and validation.

Solution

public class DataMigrator
{
    public async Task MigrateData(
        string source, 
        string destination)
    {
        using var reader = new FlexonStreamReader(source);
        using var writer = new FlexonStreamWriter(destination);
        
        while (reader.HasMore)
        {
            var chunk = await reader.ReadNextAsync();
            var transformed = TransformData(chunk);
            await writer.WriteAsync(transformed);
        }
    }
}

8. Mobile Applications

Problem

Mobile apps need efficient data storage and transfer.

Solution

public class MobileSync
{
    public async Task SyncData(
        IEnumerable<DataItem> items)
    {
        // Compress data for network transfer
        using var stream = new MemoryStream();
        await FlexonEncoder.EncodeAsync(
            items, 
            stream, 
            new FlexonOptions 
            { 
                EnableCompression = true,
                CompressionLevel = CompressionLevel.Optimal
            });
            
        await _api.SyncAsync(stream.ToArray());
    }
}

9. Machine Learning

Problem

ML models need efficient data format for training.

Solution

public class ModelTrainer
{
    public async Task PrepareTrainingData(
        IEnumerable<TrainingExample> examples)
    {
        using var writer = new FlexonStreamWriter("training.flexon");
        
        foreach (var batch in examples.Batch(100))
        {
            var features = ExtractFeatures(batch);
            await writer.WriteAsync(features);
        }
    }
}

10. Distributed Systems

Problem

Distributed systems need reliable data exchange.

Solution

public class DistributedNode
{
    public async Task BroadcastState(NodeState state)
    {
        var options = new FlexonOptions
        {
            EnableValidation = true,
            Schema = _stateSchema,
            EnableCompression = true
        };
        
        var encoded = await FlexonEncoder
            .EncodeAsync(state, options);
            
        await _messageQueue.PublishAsync(
            "node/state", 
            encoded);
    }
}