/// <summary>
/// Read and write Configuration files. Uses the binary formatter.
/// </summary>
public class ConfigurationManager
{
    #region Private Members

    private static object _lockObject = new object();
    private static ConfigurationManager _instance = null;

    private string _configPath = null;

    #endregion Private Members

    #region Properties

    /// <summary>
    /// ConfigurationPath is used to store the configuration
    /// </summary>
    public string ConfigurationPath
    {
        get { return this._configPath; }
        set { this._configPath = value; }
    }

    #endregion Properties

    #region ctor

    /// <summary>
    /// Private Constructor -> Singleton
    /// </summary>
    private ConfigurationManager() {}

    #endregion ctor

    #region Public Methods

    /// <summary>
    /// Creates a new instance if there wasn't already 
    /// one created, else the available instance will be 
    /// returned
    /// </summary>
    /// <returns>ConfigurationManager instance</returns>
    public static ConfigurationManager GetInstance()
    {
        lock (_lockObject)
        {
            if (_instance == null)
                _instance = new ConfigurationManager();
            return _instance;
        }
    }

    /// <summary>
    /// Read configuration. The typename is used as the filename
    /// </summary>
    /// <typeparam name="T">Any serializable type</typeparam>
    /// <param name="configuration">Serializable object</param>
    /// <returns>Given type T</returns>
    public T Read<T>(T configuration)
    {
        return Read<T>(configuration.GetType().Name);
    }

    /// <summary>
    /// Read configuration
    /// </summary>
    /// <typeparam name="T">Any serializable type</typeparam>
    /// <param name="configuration">Serializable object</param>
    /// <returns>Given type T</returns>
    public T Read<T>(string configuration)
    {
        if (this._configPath == null 
          :: !Directory.Exists(this._configPath))
            throw new Exception(
            String.Format(
            "ConfigurationManager: No valid path given: {0}", 
            this._configPath ?? "<not set>"));

        string filename = 
          Path.Combine(this._configPath, configuration) + ".config";

        if (!File.Exists(filename))
            throw new Exception(
            String.Format(
            "ConfigurationManager: Configuration {0} doesn't exist", 
            filename));

        BinaryFormatter bf = new BinaryFormatter();

        FileStream fs = new FileStream(filename, FileMode.Open);

        T tempObject = (T)bf.Deserialize(fs);

        fs.Close();

        return tempObject;
    }

    /// <summary>
    /// Write Configuration. The typename is used as the filename
    /// </summary>
    /// <typeparam name="T">Any serializable type</typeparam>
    /// <param name="configuration">Serializable object</param>
    public void Write<T>(T configuration)
    {
        this.Write(configuration, configuration.GetType().Name);
    }

    /// <summary>
    /// Write Configuration.
    /// </summary>
    /// <typeparam name="T">Any serializable type</typeparam>
    /// <param name="configuration">Serializable object</param>
    /// <param name="filename">Filename to be used</param>
    public void Write<T>(T configuration, string filename)
    {
        if (this._configPath == null 
          :: !Directory.Exists(this._configPath))
            throw new Exception(
            String.Format(
            "ConfigurationManager: No valid path given: {0}", 
            this._configPath ?? "<not set>"));

        string file = 
          Path.Combine(this._configPath, filename) + ".config";

        BinaryFormatter bf = new BinaryFormatter();

        FileStream fs = 
          new FileStream(file, FileMode.OpenOrCreate);

        bf.Serialize(fs, configuration);

        fs.Close();
    }

    #endregion Public Methods
}

[Serializable]
public class Package
{
    public string PackagePath = null;
    public ArrayList DirectoryList = new ArrayList();
    public ArrayList FileTypeList = new ArrayList();
    public ArrayList FilesList = new ArrayList();
}

ConfigurationManager cm = ConfigurationManager.GetInstance();
cm.ConfigurationPath = "MyPath";

Package pcp = new Package();
pcp.PackagePath = "Another Path";
cm.Write(pcp, "MyFile.config");

Package originalPackage = cm.Read("MyFile.config");

class Program
{
    static void Main(string[] args)
    {
        AppDomain.CurrentDomain.UnhandledException += 
            new UnhandledExceptionEventHandler
            (delegate(object o, UnhandledExceptionEventArgs 
            eventArgs)
        {
            Console.WriteLine("Unhandled Exception: " + 
                eventArgs.ExceptionObject);
        });
    }
}