Need help designing class factory

Question

Hi,

I have certain classes that have common feature - class factory that I need to put into base class.

// This class needs to be designed
public class Base
{
    // this function is no good because it returns object, and needs to return derived class
    static object Create(byte[] data)
    {
        MemoryStream ms = new MemoryStream(data);
        BinaryFormatter sf = new BinaryFormatter();

        object result = sf.Deserialize(ms);
        ms.Close();

        return result;
    }

    public virtual byte[] Serialize()
    {
        MemoryStream ms = new MemoryStream();
        BinaryFormatter bf = new BinaryFormatter();
        bf.Serialize(ms, this);
        byte[] result = ms.ToArray();
        ms.Close();
        return result;
    }

}

// for this class Create() must return Derived1
public Derived1 : Base
{
}

// for this class Create() must return Derived2
public Derived2 : Base
{
}

I need to be able to use derived class factory like that

Derived1 d1 = Derived1.Create(data1);

Derived2 d2 = Derived2.Create(data2);

Please advice solution. The templates are ok

UPDATE

I update the code and showed how objects are serialized and deserialized

Answer 1

public class Base<T>
{
    public static T Create(byte[] data)
    {
        // create instance of T from data
    }
}

public Derived1 : Base<Derived1>
{
}

public Derived2 : Base<Derived2>
{
}

Answer 2

Your design is fine, you just need just add a Template(with class constraint)

public class Base<T> where T: class
{
  public   static T Create(byte[] data)
  {
    MemoryStream ms = new MemoryStream(data);
    BinaryFormatter sf = new BinaryFormatter();

    T result = sf.Deserialize(ms) as T;
    ms.Close();

    return result;
  }
}

public Derived1 : Base<Derived1>
{
}

public Derived2 : Base<Derived2>
{
}

Answer 3

If what you want is to create a persisten object using dot Net Serialization you could use the following code to achieve the same result. Notice that the CSSerialize defines the two methods for serializing objects using a BinaryFormatter and a SoapFormatter:

namespace TheCompany.Common
{
    public interface IGenericFormatter
    {
        T Deserialize<T>(Stream serializationStream);
        void Serialize<T>(Stream serializationStream, T graph);
    }
    public class GenericFormatter<F> : IGenericFormatter where F : IFormatter, new()
    {
        private IFormatter _Formatter = new F();
        public T Deserialize<T>(Stream serializationStream) { return (T)_Formatter.Deserialize(serializationStream); }
        public void Serialize<T>(Stream serializationStream, T graphObject) { _Formatter.Serialize(serializationStream, graphObject); }
    }
    public class GenericBinaryFormatter : GenericFormatter<BinaryFormatter> { }
    public class GenericSoapFormatter : GenericFormatter<SoapFormatter> { }

    public static partial class CSSerialize
    {
        public static T Clone<T>(T source)
        {   
            Debug.Assert(typeof(T).IsSerializable);
            if (!typeof(T).IsSerializable) { throw new SerializationException(ExceptionMessages.ObjectNoSerializable); }

            T result;
            IGenericFormatter formatter = new GenericBinaryFormatter();            
            using(MemoryStream stream = new MemoryStream())
            {                
                formatter.Serialize(stream, source);
                stream.Seek(0, SeekOrigin.Begin);
                result = formatter.Deserialize<T>(stream);
            }
            return result;
        }
        public static T CloneXml<T>(T source)
        {
            T result;
            DataContractSerializer serializer = new DataContractSerializer(typeof(T));
            using (MemoryStream memory = new MemoryStream())
            {
                serializer.WriteObject(memory, source);
                memory.Position = 0;
                result = (T)serializer.ReadObject(memory);             
            }
            return result;
        }       
    }
}