对象工厂创建--- Singleton Object,SingleCall Object,Pool Object

对象分类

单例对象 Singleton Object，单例对象意指对象一旦产生就负责服务所有的系统要求，不会因为要求数量而产生一个以上的对象，这种对象通常要处理Thread同步化的问题。

SingCall Object 意指该对象为了服务单一要求所产生，当要求完成后，该对象就会被释放，在SingCall的模式下的要求数量和对象的数量成正比，在这种模式中，因为每个要求都由独立的对象处理，所以不需要考虑Thread同步问题。

Pool Object是由SingleCall演变而来，与SingleCall不同的是Pool并不会无限制地针对要求数量而产生对等数量的对象，而取代的是一个Pool池，在其中保持一定的数量。一般来说，池对象会创建特定数量的对象放在池中，当某要求到达时,Pool由池中取出一个对象来服务此要求，当要求完成后，对象并不会立即消灭，而是重新放回Pool池中，通过这种机制来减少对对象数量及加快对象的创建操作，由于维持了一个对象服务一个要求的行为，所以此模式下也不需要处理Thread同步的问题。

对象工厂设计类图

定义对象工厂接口IObjectFactory

public interface IObjectFactory
    {
        /// <summary>
        /// acquire a object.创建一个对象
        /// </summary>
        /// <param name="typeName">object type name. 对象类型名称</param>
        /// <returns>object 对象</returns>
        object AcquireObject(string typeName);
        /// <summary>
        /// acquire a object.创建一个对象
        /// </summary>
        /// <param name="type">object Type 对象类型</param>
        /// <returns>object对象</returns>
        object AcquireObject(Type type);
        /// <summary>
        /// release a object.释放一个对象
        /// </summary>
        /// <param name="obj">a object to releasing 要释放的对象</param>
        void ReleaseObject(object obj);
    }

单例对象工厂：继承对象工厂接口

/// <summary>
    /// 单例对象工厂：继承对象工厂接口
    /// </summary>
    public sealed class SingletonObjectFactory : IObjectFactory
    {
        /// <summary>
        /// 对象存储体（hashtable）
        /// </summary>
        private static Hashtable _cachedObjects = null;
        /// <summary>
        /// 对象锁
        /// </summary>
        private static object _lock = new object();
        /// <summary>
        /// 对象私有属性
        /// </summary>
        private Hashtable CachedObjects
        {
            get
            {
                lock (_lock)
                {
                    if (_cachedObjects == null)
                    {
                        _cachedObjects = new Hashtable();
                    }
                    return _cachedObjects;
                }
            }
        }

        #region IObjectFactory 成员
        /// <summary>
        /// 根据类型名创建一个单例对象
        /// </summary>
        /// <param name="typeName">类型名</param>
        /// <returns>对象</returns>
        public object AcquireObject(string typeName)
        {
            return AcquireObject(TypeResolverHelper.ResolveType(typeName));
        }
        /// <summary>
        /// 创建一个对象
        /// </summary>
        /// <param name="type">对象类型</param>
        /// <returns>对象</returns>
        public object AcquireObject(Type type)
        {
            if (CachedObjects.Contains(type))
                return CachedObjects[type];
            lock (_lock)
            {
                CachedObjects.Add(type, Activator.CreateInstance(type, false));
                return CachedObjects[type];
            }
        }
        /// <summary>
        /// 回收对象资源
        /// </summary>
        /// <param name="obj">对象</param>
        public void ReleaseObject(object obj)
        {
            //do nothing because .net对托管对象自动回收
        }

#endregion
}

SingleCallObject工厂

public class SingleCallObjectFactory : IObjectFactory
{

        #region IObjectFactory 成员
        /// <summary>
        /// 根据类型名创建一个普通对象
        /// </summary>
        /// <param name="typeName">类型名</param>
        /// <returns>对象</returns>
        public object AcquireObject(string typeName)
        {
            return AcquireObject(TypeResolverHelper.ResolveType(typeName));
        }
        /// <summary>
        /// 创建一个对象
        /// </summary>
        /// <param name="type">对象类型</param>
        /// <returns>对象</returns>
        public object AcquireObject(Type type)
        {
            object obj = Activator.CreateInstance(type, false);
            return obj;
        }
        /// <summary>
        /// 回收对象资源
        /// </summary>
        /// <param name="obj">对象</param>
        public void ReleaseObject(object obj)
        {
            if (obj != null)
            {
                if (obj is IDisposable)
                    ((IDisposable)obj).Dispose();
            }
        }

#endregion
}

池对象工厂

public sealed class PoolObjectFactory : IObjectFactory, IDisposable
    {
        /// <summary>
        /// 池数据
        /// </summary>
        class PoolData
        {
            /// <summary>
            /// 是否在使用
            /// </summary>
            public bool InUse = false;
            /// <summary>
            /// 对象
            /// </summary>
            public object obj;
        }
        /// <summary>
        /// 存储体
        /// </summary>
        private IList _storage;
        /// <summary>
        /// 最大限制
        /// </summary>
        private int _max = 100;
        /// <summary>
        /// 是否限制
        /// </summary>
        private bool _limit = false;
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="max">最大数</param>
        /// <param name="limit">是否限制</param>
        /// <param name="storage"></param>
        public PoolObjectFactory(int max, bool limit, IList storage)
        {
            _max = max;
            _limit = limit;
            _storage = storage;
        }
        /// <summary>
        /// 构造函数
        /// </summary>
        public PoolObjectFactory()
        {
        }
        /// <summary>
        /// 对象数据属性
        /// </summary>
        /// <param name="obj">对象</param>
        /// <returns>对象数据</returns>
        private PoolData GetPoolData(object obj)
        {
            lock (_storage.SyncRoot)
            {
                for (int i = 0; i < _storage.Count; i++)
                {
                    PoolData p = (PoolData)_storage[i];
                    if (p.obj == obj)
                        return p;
                }
            }
            return null;
        }
        /// <summary>
        /// 对象属性
        /// </summary>
        /// <param name="type">对象类型</param>
        /// <returns>对象</returns>
        private object GetObject(Type type)
        {
            lock (_storage.SyncRoot)
            {
                if (_storage.Count > 0)
                {
                    if (((PoolData)_storage[0]).obj.GetType() != type)
                        throw new Exception(
                            string.Format("the Pool Factory only for Type :{0}", _storage[0].GetType().Name));
                }

                for (int i = 0; i < _storage.Count; i++)
                {
                    PoolData p = (PoolData)_storage[i];
                    if (!p.InUse)
                    {
                        p.InUse = true;
                        return p.obj;
                    }
                }

if (_storage.Count > _max && _limit)
throw new Exception("max limit is arrived.");

                object obj = TypeFactory.CreateInstance(type);
                PoolData p1 = new PoolData();
                p1.InUse = true;
                p1.obj = obj;
                _storage.Add(p1);
                return obj;
            }
        }
        /// <summary>
        /// 设置对象数据为不可用
        /// </summary>
        /// <param name="obj">对象</param>
        private void PutObject(object obj)
        {
            PoolData p = GetPoolData(obj);
            if (p != null)
                p.InUse = false;
        }
        #region IObjectFactory 成员

        /// <summary>
        /// 根据对象名称在对象池创建一个对象池
        /// </summary>
        /// <param name="typeName">对象名</param>
        /// <returns>对象</returns>
        public object AcquireObject(string typeName)
        {
            return GetObject(TypeResolverHelper.ResolveType(typeName));
        }
        /// <summary>
        /// 根据对象类型在对象池创建一个对象池
        /// </summary>
        /// <param name="type">对象类型</param>
        /// <returns>对象</returns>
        public object AcquireObject(Type type)
        {
            return GetObject(type);
        }

        /// <summary>
        /// 释放对象
        /// </summary>
        /// <param name="obj">对象</param>
        public void ReleaseObject(object obj)
        {
            if (_storage.Count > _max)
            {
                if (obj is IDisposable)
                    ((IDisposable)obj).Dispose();
                PoolData p = GetPoolData(obj);
                lock (_storage.SyncRoot)
                    _storage.Remove(p);
                return;
            }
            PutObject(obj);
        }

#endregion

        #region IDisposable 成员
        /// <summary>
        /// 释放非托管资源
        /// </summary>
        public void Dispose()
        {
            lock (_storage.SyncRoot)
            {
                for (int i = 0; i < _storage.Count; i++)
                {
                    PoolData p = (PoolData)_storage[i];
                    if (p.obj is IDisposable)
                        ((IDisposable)p.obj).Dispose();
                }
            }
        }