dbparams.cs

用于c#.net数据库操作的类库。能把结婚集以数组的形成操作。

using System;
using System.Collections;

namespace EnterpriseObjects
{
	[Serializable]
	public class DbParams:IDictionary//,ISerializable
	{
		/// <summary>
		/// 数值主表
		/// </summary>
		protected	Hashtable	innerHash;

		/// <summary>
		/// 参数对照表
		/// </summary>
		private		Hashtable	mapingHash; 

		//protected string _StroeProcedureName;
		protected int _ResultCount;

		/// <summary>
		/// 执行存储过程返回的值
		/// </summary>
		private int _ReturnValue;


		public  DbParams()
		{
			innerHash = new Hashtable();
			mapingHash=new Hashtable();
		}
		public Hashtable HashData
		{
			get
			{
				return innerHash;
			}
		}
		/// <summary>
		/// 执行存储过程返回的值
		/// </summary>
		public int ReturnValue
		{
			get
			{
				return _ReturnValue;
			}
			set
			{
				_ReturnValue=value;
			}
		}
		public EnterpriseObjects.Service Service
		{
			get
			{
				return EnterpriseObjects.EnterpriseApplication.Application.Service;
			}
		}
	
		/// <summary>
		/// 获取某一参数的值
		/// </summary>
		/// <param name="key">参数 @key </param>
		/// <returns>参数的值</returns>
		public object GetValueByParam(string key)
		{
			try
			{
				string trueKey;
				if(mapingHash.Contains(key))
				{
					trueKey=mapingHash[key].ToString();
					if(innerHash.Contains(trueKey))
					{
						return innerHash[trueKey];
					}
					else
					{
						return System.DBNull.Value;
					}
				}
				else
				{
					trueKey=key.Substring(1,key.Length-1);
					if(innerHash.Contains(trueKey))
					{
						return innerHash[trueKey];
					}
					else
					{
						return System.DBNull.Value;
					}
				}
			}
			catch
			{
				return System.DBNull.Value;
			}

		}
		public virtual void Populate(System.Data.DataRow dr)
		{
			for(int i=0;i<dr.Table.Columns.Count;i++)
			{
				innerHash[dr.Table.Columns[i].ColumnName]=dr[i];
			}
		}
		public virtual void Populate (DbParams dbp)
		{
			this.innerHash=dbp.HashData;
		}

		//[NonSerialized()]
//		public string StroeProcedureName
//		{
//			get
//			{
//				return  _StroeProcedureName;
//			}
//			set
//			{
//				_StroeProcedureName=value;
//			}
//		}
		/// <summary>
		/// 执行命令（存贮过程）所影响的行数
		/// </summary>
		public int ResultCount
		{
			get
			{
				return _ResultCount;
			}
			set
			{
				_ResultCount=value;
			}
		}
		//		public DbParams(int initsize)
		//		{
		//			innerHash=new Hashtable(initsize);
		//		}
		//		protected DbParams(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context)
		//		{
		////			System.Runtime.Serialization.Formatters.Binary.BinaryFormatter bf=new BinaryFormatter();
		////			System.IO.MemoryStream strem=new System.IO.MemoryStream((byte[])info.GetValue("Hashtable",typeof(System.Byte[])));
		////			innerHash=(Hashtable)bf.Deserialize(strem);
		//
		//			innerHash = (Hashtable)info.GetValue("innerHash", typeof(Hashtable));
		//		}
		//		public Hashtable Hashtable
		//		{
		//			get
		//			{
		//				return innerHash;
		//			}
		//		}
		//		#region ISerializable 成员
		//
		//		public void GetObjectData(SerializationInfo info, StreamingContext context)
		//		{
		//
		//			//			System.Runtime.Serialization.Formatters.Binary.BinaryFormatter bf=new BinaryFormatter();
		//			//			System.IO.MemoryStream strem=new System.IO.MemoryStream();
		//			//			bf.Serialize(strem,innerHash);
		//			//			info.AddValue("Hashtable",strem.ToArray());
		//
		//			if(null!=innerHash)
		//			{
		//				info.AddValue("innerHash",innerHash,typeof(Hashtable));
		//			}
		//			else
		//			{
		//				info.AddValue("innerHash",null,typeof(Hashtable));
		//			}
		//		}
		//		//
		//		#endregion

		#region IDictionary 成员

		public bool IsReadOnly
		{
			get
			{
				// TODO:  添加 DbParams.IsReadOnly getter 实现
				return innerHash.IsReadOnly;
			}
		}

		public IDictionaryEnumerator GetEnumerator()
		{
			// TODO:  添加 DbParams.GetEnumerator 实现
			return innerHash.GetEnumerator();
		}

		public object this[object key]
		{
			get
			{
				// TODO:  添加 DbParams.this getter 实现
				return innerHash[key];
			}
			set
			{
				innerHash[key]=value;
			}
		}

		public void Remove(object key)
		{
			innerHash.Remove(key);
		}

		public bool Contains(object key)
		{
			// TODO:  添加 DbParams.Contains 实现
			return innerHash.Contains(key);
		}

		public void Clear()
		{
			innerHash.Clear();
			mapingHash.Clear();
		}

		public ICollection Values
		{
			get
			{
				// TODO:  添加 DbParams.Values getter 实现
				return innerHash.Values;
			}
		}
        /// <summary>
        /// 
        /// </summary>
        /// <param name="key">参数名，不带"@"</param>
        /// <param name="value">值</param>
		public void Add(object key, object value)
		{
			innerHash.Add(key,value);
		}

		public ICollection Keys
		{
			get
			{
				// TODO:  添加 DbParams.Keys getter 实现
				return innerHash.Keys;
			}
		}

		public bool IsFixedSize
		{
			get
			{
				// TODO:  添加 DbParams.IsFixedSize getter 实现
				return innerHash.IsFixedSize;
			}
		}

		#endregion

		#region ICollection 成员

		public bool IsSynchronized
		{
			get
			{
				// TODO:  添加 DbParams.IsSynchronized getter 实现
				return innerHash.IsSynchronized;
			}
		}

		public int Count
		{
			get
			{
				// TODO:  添加 DbParams.Count getter 实现
				return innerHash.Count;
			}
		}

		public void CopyTo(Array array, int index)
		{
			innerHash.CopyTo(array,index);
		}

		public object SyncRoot
		{
			get
			{
				// TODO:  添加 DbParams.SyncRoot getter 实现
				return innerHash.SyncRoot;
			}
		}

		#endregion

		#region IEnumerable 成员

		IEnumerator System.Collections.IEnumerable.GetEnumerator()
		{
			// TODO:  添加 DbParams.System.Collections.IEnumerable.GetEnumerator 实现
			return innerHash.GetEnumerator();
		}

		#endregion

		#region 属性值操作

		public void SetValue(string key,object values)
		{
			innerHash[key]=values;
		}

		public object GetProperty(string key, object defaultvalue)
		{
			if (!innerHash.ContainsKey(key)) 
			{
				if (defaultvalue != null) 
				{
					innerHash[key] = defaultvalue;
				}
				return defaultvalue;
			}
			if(null==innerHash[key] ||System.DBNull.Value==innerHash[key])
			{
				if (defaultvalue != null) 
				{
					innerHash[key] = defaultvalue;
				}
				return defaultvalue;
			}
			return innerHash[key];
		}

		public object GetProperty(string key)
		{
			return GetProperty(key, (object)null);
		}
		public int GetProperty(string key, int defaultvalue)
		{
			return int.Parse(GetProperty(key, (object)defaultvalue).ToString());
		}
		public bool GetProperty(string key, bool defaultvalue)
		{
			return bool.Parse(GetProperty(key, (object)defaultvalue).ToString());
		}
		public short GetProperty(string key, short defaultvalue)
		{
			return short.Parse(GetProperty(key, (object)defaultvalue).ToString());
		}
		public float GetProperty(string key,float defaultvalue)
		{
			return float.Parse(GetProperty(key, (object)defaultvalue).ToString());
		}
		public byte GetProperty(string key, byte defaultvalue)
		{
			return byte.Parse(GetProperty(key, (object)defaultvalue).ToString());
		}
		public string GetProperty(string key, string defaultvalue)
		{
			return GetProperty(key, (object)defaultvalue).ToString();
		}
		public System.Enum GetProperty(string key, System.Enum defaultvalue)
		{
			return (System.Enum)Enum.Parse(defaultvalue.GetType(), GetProperty(key, (object)defaultvalue).ToString());
		}
		public byte[] GetProperty(string key,byte[] defaultvalue)
		{
			object myobject=GetProperty(key);
			return myobject==null?null:(byte[])myobject;
		}

		public DateTime GetProperty(string key,DateTime date)
		{
			return DateTime.Parse(GetProperty(key,(object)date).ToString());
		}
		public Decimal GetProperty(string key,Decimal data)
		{
			return  Decimal.Parse(GetProperty(key,(object)data).ToString());
		}
		#endregion

	}
}