Cfrtjryk

Please see my factory design pattern:

public interface IMySerializer

{

    void Serialize<T>(string path, T obj);

    T Deserialize<T>(string path);

}



public class MyXmlSerializer: IMySerializer {

    public void Serialize<T>(string path,T obj)

    {

        XmlSerializer serializer = new XmlSerializer(typeof(T));

        using(TextWriter tw=new StreamWriter(path))

        {

            serializer.Serialize(tw,obj);

        }

    }

    // deserialize as well.

}



public class MyBinarySerializer : IMySerializer {

    public void Serialize<T>(string path, T obj) {

        var bf=new BinaryFormatter();

        Stream fs=File.OpenWrite(path);

        bf.Serialize(fs, obj);

        fs.Close();

    }

    // deserialize as well.

}



public class SerializerFactory

{

    public enum SerializerType

    {

        None=-1,Json,Binary,Xml

    }

    public static void Serialize<T>(SerializerType type,string path,T obj)

    {

        switch(type)

        {

            case SerializerType.Json:

                new MyJsonSerializer().Serialize(path, obj);

                break;

            case SerializerType.Binary:

                new MyBinarySerializer().Serialize(path, obj);

                break;

            case SerializerType.Xml:

                new MyXmlSerializer().Serialize(path, obj);

                break;

            default:

                throw new ArgumentException("Select serializer type");

                break;

        }

    }

}

It is convenient because I implement them only once and call them easily without knowing about serialization procedures.

The first question: can I use factory design pattern when I completely have the same constructors with the same parameters?

The second one: If I intend to utilize other functions for example, other bunch of methods in the serialization classes in the future, can the factory handle it?

I do not know precisely when factory pattern really works and where it is suitable to apply it. I am afraid of changing in the future.

Factories

Factories create the class, they do not execute it's purpose too. A car factory creates the car, it does not then also drive the car for you. The factory simply gives you the instance of a serializer, nothing more.

public enum SerializerType

{

    None=-1,

    Json,

    Binary,

    Xml

}



public class SerializerFactory

{

    public static IMySerializer GetSerializer(SerializerType type)

    {

        switch (type)

        {

            case SerializerType.Json:

                return new MyJsonSerializer();

            case SerializerType.Binary:

                return new MyBinarySerializer();

            case SerializerType.Xml:

                return new MyXmlSerializer();

            default:

                throw new ArgumentOutOfRangeException($"Parameter '{nameof(type)}' was not a valid enumeration value.");

        }

    }

}

If the construction of your serializers gets much more involved consider whether it would be beneficial to follow the Factory Pattern more closely.

Serialize vs SerializeToFile

Serialize<T>() traditionally would return a string. You're serializing the object directly to a file. So you have 2 choices here.

• Continue with serializing directly to the file and call your method SerializeToFile to prevent confusion. Just know that if you want to serialize to something other than a file later you're going to have to change a lot of things.


• Pull the saving to a file out of the serializer classes and do it separately, keeping the name of the function as Serialize.

I highly recommend #2.

Formatting Consistent, Using, Etc.

• You're bouncing between curly brackets {} being on the same line and on the next line. Generally it's separate line, unless it's a script. Given the MyBinarySerializer doesn't inherit from MonoBehavior one can assume it's not a script (or question why it is one).


• What happens if MyBinarySerialzier.Serialize() throws an exception. Will the file stream be closed? If the class implements IDisposable like Stream does, use a using statement.


• Never used a BinaryFormatter but from your usage of it, it seems like something you can probably create an instance of when you create MyBinarySerializer and reuse. Ignore this if that's not the case, but it's something to keep in mind.

Example:

public class MyBinarySerializer : IMySerializer

{

    // Always good to make classes that aren't getting assigned again as 'readonly' to show the intention that this is the only time it's instantiated.

    private readonly BinaryFormatter Formatter = new BinaryFormatter();



    public void Serialize<T>(string path, T obj)

    {

        using (Stream fs = File.OpenWrite(path))

        {

            Formatter.Serialize(fs, obj);

        }

    }

}