Singletons, Extensions and Naming Conventions helpers

[meowzin644]

First; I did search for the things I'm saying here but I couldn't find anything so pardon me if they are repetitive.

I wanted to know if there are any interest on creating extensions for creating default instances for a specific configuration and simplification for the usage.

Something like what we have for Json. YamlSerializer.Serialize(...) and YamlSerializer.Deserialize(...)

I have a few helpers and wrappers to simplify all of that using extensions and stuff like that.

new SerializerBuilder().WithNamingConvention(UnderscoredNamingConvention.Instance)

// to something like

new SerializerBuilder().WithNamingConvention(YamlNamingConventions.Underscored)

Often is useful to have a single instance of a serializer to use throughout the application and I end up doing this for JSON, XML and whatnot.

We end up having something a little bit easier such as

YamlSerializer.Serialize(object); // using default configuration.

YamlSerializer.Serialize(object, o => { 
     // custom configuration 
}); 

And for the extensions, same thing using a singleton instance of the configuration itself or named configurations if you want to add different ways of doing things.

object.SerializeYaml() // with default

object.SerializeYaml(o => {
    // custom configuration
}) // with default

If you don't do anything, default, or adding new configurations.

YamlSerializer.Configurations.Add("my-custom-name", o => {
    // custom configuration
})

// and then

YamlSerializer.Serialize(object, "my-custom-name")

// and using extensions

object.SerializeYaml("my-custom-name") 

[EdwardCooke]

I believe the builder classes are thread safe so you could pass around a single instance of that object and just call build when you need a serializer/deserializer. You can call build as many times as you want.

Does that help at all?

[meowzin644]

I understand that, the reason I'm going for a singleton wrapper around an extension is for simplicity and readability.

I have this class, for example. Along with that I can add simple extension methods SerializeToYaml and DeserializeFromYaml without having to setup anything other than at the startup of the application, the rest becomes way easier to read.

var configuration = File.ReadAllText("c:\file.yml").DeserializeFromYaml<Configuration>();

It's something to keep things smaller without losing the original features.

public static class YamlSerializer
{
    private const string DEFAULT_INSTANCE_NAME = "__DEFAULT_INSTANCE_NAME__";

    private static readonly Dictionary<NamingConvention, INamingConvention> _namingConventions = new()
    {
        { NamingConvention.Lowercase, LowerCaseNamingConvention.Instance },
        { NamingConvention.Uppercase, UnderscoredNamingConvention.Instance },
        { NamingConvention.PascalCase, PascalCaseNamingConvention.Instance },
        { NamingConvention.CamelCase, CamelCaseNamingConvention.Instance },
        { NamingConvention.SnakeCase, UnderscoredNamingConvention.Instance },
        { NamingConvention.SlugCase, HyphenatedNamingConvention.Instance }
    };

    private static readonly Dictionary<string, ISerializer> _serializers = new()
    {
        { DEFAULT_INSTANCE_NAME, new SerializerBuilder().WithNamingConvention(UnderscoredNamingConvention.Instance).Build() }
    };

    private static readonly Dictionary<string, IDeserializer> _deserializers = new()
    {
        { DEFAULT_INSTANCE_NAME, new DeserializerBuilder().WithNamingConvention(UnderscoredNamingConvention.Instance).Build() }
    };

    public static void OverrideDefault(NamingConvention namingConvention)
    {
        _serializers[DEFAULT_INSTANCE_NAME] = new SerializerBuilder().WithNamingConvention(_namingConventions[namingConvention]).Build();
        _deserializers[DEFAULT_INSTANCE_NAME] = new DeserializerBuilder().WithNamingConvention(_namingConventions[namingConvention]).Build();
    }

    public static void AddConfiguration(string name, ISerializer serializer, IDeserializer deserializer)
    {
        ValidateConfigurationName(name);

        _serializers.Add(name, serializer);
        _deserializers.Add(name, deserializer);
    }

    public static void AddConfiguration(string name, NamingConvention namingConvention)
    {
        ValidateConfigurationName(name);

        _serializers.Add(name, new SerializerBuilder().WithNamingConvention(_namingConventions[namingConvention]).Build());
        _deserializers.Add(name, new DeserializerBuilder().WithNamingConvention(_namingConventions[namingConvention]).Build());
    }

    public static string Serialize(object graph)
    {
        return _serializers[DEFAULT_INSTANCE_NAME].Serialize(graph);
    }

    public static string Serialize(object graph, string configurationName)
    {
        if (!_serializers.TryGetValue(configurationName, out var serializer))
            throw new ConfigurationNotFoundException(configurationName);

        return serializer.Serialize(graph);
    }

    public static T Deserialize<T>(string yaml)
    {
        return _deserializers[DEFAULT_INSTANCE_NAME].Deserialize<T>(yaml);
    }

    public static T Deserialize<T>(string yaml, string configurationName)
    {
        if (!_deserializers.TryGetValue(configurationName, out var deserializer))
            throw new ConfigurationNotFoundException(configurationName);

        return deserializer.Deserialize<T>(yaml);
    }

    private static void ValidateConfigurationName(string name)
    {
        if (_serializers.ContainsKey(name) || _deserializers.ContainsKey(name))
            throw new DuplicateConfigurationException(name);
    }
}

[EdwardCooke]

Sorry, not at a computer right now. But. Your code wouldn’t be thread safe so you couldn’t use that in multiple places at the same time. However. If you change your dictionary to be a deserializerbuilder and then in your deserialize methods you use the dictionary just like you have, then call build and return that deserializer you should be good with your default instances like you are wanting.

Right now I’m not sure we would want to put something like this in the library since it’s still really easy to do.