public class JsonSerializationProvider : ISerializationProvider
{
    public string ProviderName => "System.Text.Json";
    public string ContentType => "application/json";

    public string Serialize<T>(T obj)
    {
        return System.Text.Json.JsonSerializer.Serialize(obj);
    }

    public T Deserialize<T>(string data)
    {
        if (string.IsNullOrWhiteSpace(data))
            throw new ArgumentException("Data cannot be null or empty", nameof(data));
        
        return System.Text.Json.JsonSerializer.Deserialize<T>(data)!;
    }

    public string Serialize(object obj, Type type)
    {
        return System.Text.Json.JsonSerializer.Serialize(obj, type);
    }

    public object Deserialize(string data, Type type)
    {
        if (string.IsNullOrWhiteSpace(data))
            throw new ArgumentException("Data cannot be null or empty", nameof(data));
        
        return System.Text.Json.JsonSerializer.Deserialize(data, type)!;
    }

    public Task<string> SerializeAsync<T>(T obj, CancellationToken cancellationToken = default)
    {
        return Task.FromResult(Serialize(obj));
    }

    public Task<string> SerializeAsync(object obj, Type type, CancellationToken cancellationToken = default)
    {
        return Task.FromResult(Serialize(obj, type));
    }

    public Task<T> DeserializeAsync<T>(string data, CancellationToken cancellationToken = default)
    {
        return Task.FromResult(Deserialize<T>(data));
    }

    public Task<object> DeserializeAsync(string data, Type type, CancellationToken cancellationToken = default)
    {
        return Task.FromResult(Deserialize(data, type));
    }
}

using ktsu.SerializationProvider.Extensions;

// In your Startup.cs or Program.cs
services.AddSerializationProvider<JsonSerializationProvider>();

// Or register by instance
services.AddSerializationProvider(new JsonSerializationProvider());

// Or register by factory
services.AddSerializationProvider(serviceProvider => 
    new JsonSerializationProvider());

public class MyService
{
    private readonly ISerializationProvider _serializationProvider;

    public MyService(ISerializationProvider serializationProvider)
    {
        _serializationProvider = serializationProvider;
    }

    public async Task<string> SerializeDataAsync<T>(T data)
    {
        return await _serializationProvider.SerializeAsync(data);
    }

    public async Task<T> DeserializeDataAsync<T>(string json)
    {
        return await _serializationProvider.DeserializeAsync<T>(json);
    }
}

public interface ISerializationProvider
{
    string ProviderName { get; }
    string ContentType { get; }

    // Synchronous methods
    string Serialize<T>(T obj);
    string Serialize(object obj, Type type);
    T Deserialize<T>(string data);
    object Deserialize(string data, Type type);

    // Asynchronous methods
    Task<string> SerializeAsync<T>(T obj, CancellationToken cancellationToken = default);
    Task<string> SerializeAsync(object obj, Type type, CancellationToken cancellationToken = default);
    Task<T> DeserializeAsync<T>(string data, CancellationToken cancellationToken = default);
    Task<object> DeserializeAsync(string data, Type type, CancellationToken cancellationToken = default);
}

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
    public DateTime BirthDate { get; set; }
}

// Serialize
var person = new Person { Name = "John Doe", Age = 30, BirthDate = DateTime.Now };
string json = serializationProvider.Serialize(person);

// Deserialize
var deserializedPerson = serializationProvider.Deserialize<Person>(json);

// Async serialize
string json = await serializationProvider.SerializeAsync(person);

// Async deserialize
var person = await serializationProvider.DeserializeAsync<Person>(json);

// When you need to work with Type objects
Type personType = typeof(Person);
string json = serializationProvider.Serialize(person, personType);
object deserializedObject = serializationProvider.Deserialize(json, personType);

services.AddSerializationProvider<MyCustomSerializationProvider>();

services.AddSerializationProvider(new MyCustomSerializationProvider());

services.AddSerializationProvider(serviceProvider => 
    new MyCustomSerializationProvider(
        serviceProvider.GetRequiredService<ILogger<MyCustomSerializationProvider>>()
    ));

public class NewtonsoftJsonSerializationProvider : ISerializationProvider
{
    private readonly JsonSerializerSettings _settings;

    public NewtonsoftJsonSerializationProvider(JsonSerializerSettings? settings = null)
    {
        _settings = settings ?? new JsonSerializerSettings();
    }

    public string ProviderName => "Newtonsoft.Json";
    public string ContentType => "application/json";

    public string Serialize<T>(T obj)
    {
        return JsonConvert.SerializeObject(obj, _settings);
    }

    public T Deserialize<T>(string data)
    {
        if (string.IsNullOrWhiteSpace(data))
            throw new ArgumentException("Data cannot be null or empty", nameof(data));
        
        return JsonConvert.DeserializeObject<T>(data, _settings)!;
    }

    // Implement other interface methods...
}

public class XmlSerializationProvider : ISerializationProvider
{
    public string ProviderName => "System.Xml";
    public string ContentType => "application/xml";

    public string Serialize<T>(T obj)
    {
        var serializer = new XmlSerializer(typeof(T));
        using var stringWriter = new StringWriter();
        serializer.Serialize(stringWriter, obj);
        return stringWriter.ToString();
    }

    public T Deserialize<T>(string data)
    {
        if (string.IsNullOrWhiteSpace(data))
            throw new ArgumentException("Data cannot be null or empty", nameof(data));

        var serializer = new XmlSerializer(typeof(T));
        using var stringReader = new StringReader(data);
        return (T)serializer.Deserialize(stringReader)!;
    }

    // Implement other interface methods...
}