dba.cs

报刊广告管理系统。CSharp编写

				}
				returnvalues = null;    
			}
			finally 
			{
				con.Close();
			}
			return returnvalues;
		}
		#endregion

	}
	#endregion

	#region DataTable ,DataRowCollection ,DataRow
	public class DRPro
	{
		#region DataRow clone to DataRow
		public static DataRow CloneDataRow(DataRow source)
		{
			if(source == null)return null;
			DataRow dest = source.Table.NewRow();
			foreach(DataColumn col in dest.Table.Columns)
			{
				if(source.Table.Columns.Contains(col.ColumnName))
				{
					dest[col.ColumnName] = source[col.ColumnName];
				}
			}
			return dest;
		}
		public static bool CloneDataRow(DataRow source ,DataRow dest)
		{
			try
			{
				foreach(DataColumn col in dest.Table.Columns)
				{
					if(source.Table.Columns.Contains(col.ColumnName))
					{
						dest[col.ColumnName] = source[col.ColumnName];
					}
				}
				return true;
			}
			catch
			{
				dest = dest.Table.NewRow();
				return false;
			}
		}
		public static bool CloneDataRow(DataRow source ,DataRow dest , params int[] colIndex)
		{
			try
			{
				foreach(int col in colIndex)
				{
					dest[col] = source[col];
				}
				return true;
			}
			catch
			{
				dest = dest.Table.NewRow();
				return false;
			}
		}

		public static bool CloneDataRow(DataRow source ,DataRow dest , params string[] colName)
		{
			try
			{
				foreach(string col in colName)
				{
					dest[col] = source[col];
				}
				return true;
			}
			catch
			{
				dest = dest.Table.NewRow();
				return false;
			}
		}

		#endregion

		#region Clear DataRow Null Item
		public static void ClearNull(DataRow dr)
		{
			if(dr.Table != null)
			{
				foreach(DataColumn col in dr.Table.Columns)
				{
					if(dr[col.ColumnName].GetType().Name == "DBNull")
					{
						switch(col.DataType.Name)
						{
							case "Int32":
							case "Single":
								dr[col.ColumnName] = 0;
								break;
							case "String":
								dr[col.ColumnName] = "";
								break;
							case "Boolean":
								dr[col.ColumnName] = false;
								break;
							case "DateTime":
								dr[col.ColumnName] = DateTime.Parse("1900-1-1");
								break;
							case "Byte[]":
								dr[col.ColumnName] = new byte[0];
								break;
						}
					}
				}
			}
		}
		#endregion
	}
	#region DataTableProcess
	/// <summary>
	/// DataTableProcess 的摘要说明。
	/// </summary>
	public class DTPro
	{
		#region Private Common 
		private static int check(DataTable dt , string fieldName , object keyValue)
		{
			int col = -1;
			foreach(DataColumn dcol in dt.Columns)
			{
				if(dcol.ColumnName == fieldName)
				{
					if(dcol.DataType != keyValue.GetType())
					{
						return -3; //类型不匹配
					}
					col = dcol.Ordinal;
					break;
				}
			}
			if(col == -1)
			{
				return -2; //没有指定列
			}
			return col;
		}

		/// <summary>
		/// 检索数据
		/// </summary>
		/// <param name="dt">待检索的表</param>
		/// <param name="fieldName">检索字段</param>
		/// <param name="keyValue">检索值</param>
		/// <returns></returns>
		private static int findGetIndex(DataTable dt , string fieldName , object keyValue)
		{
			return findGetIndex(dt,fieldName,keyValue,0);
		}

		/// <summary>
		/// 检索数据
		/// </summary>
		/// <param name="dt">待检索的表</param>
		/// <param name="fieldName">检索字段</param>
		/// <param name="keyValue">检索值</param>
		/// <param name="startIndex">开始位置(检索是包含检索该位置的元素)</param>
		/// <returns></returns>
		private static int findGetIndex(DataTable dt , string fieldName , object keyValue , int startIndex)
		{
			if(startIndex>=dt.Rows.Count)
				return -4; //起始位置超过Rows的个数
			for(int i=startIndex;i<dt.Rows.Count;i++)
			{
				DataRow dr = dt.Rows[i];
				if(dr.RowState!=DataRowState.Deleted&&dr.RowState!=DataRowState.Detached)
					if(dr[fieldName].Equals(keyValue))
					{
						return i;
					}
			}
			return -1; // 没有找到
		}
		/// <summary>
		/// 检索数据
		/// </summary>
		/// <param name="dt">待检索的表</param>
		/// <param name="fieldName">检索字段</param>
		/// <param name="keyValue">检索值</param>
		/// <returns></returns>
		private static DataRow findGetRow(DataTable dt , string fieldName , object keyValue )
		{
			return findGetRow(dt,fieldName,keyValue,0);
		}

		/// <summary>
		/// 检索数据
		/// </summary>
		/// <param name="dt">待检索的表</param>
		/// <param name="fieldName">检索字段</param>
		/// <param name="keyValue">检索值</param>
		/// <param name="startIndex">开始位置(检索是包含检索该位置的元素)</param>
		/// <returns></returns>
		private static DataRow findGetRow(DataTable dt , string fieldName , object keyValue , int startIndex)
		{
			if(startIndex>=dt.Rows.Count)
				return null; //起始位置超过Rows的个数
			for(int i=startIndex;i<dt.Rows.Count;i++)
			{
				DataRow dr = dt.Rows[i];
				if(dr.RowState!=DataRowState.Deleted&&dr.RowState!=DataRowState.Detached)
					if(dr[fieldName].Equals(keyValue))
					{
						return dr;
					}
			}
			return null; // 没有找到
		}
		#endregion 

		#region Find
		#region 自定义的查找方法
		public static int FindRowGetCount(DataTable dt , string fieldName , object keyValue)
		{
			int rv = check(dt,fieldName,keyValue);
			if(rv<0) return rv;
			int count = 0;
			foreach(DataRow dr in dt.Rows)
			{
				if(dr.RowState!=DataRowState.Deleted&&dr.RowState!=DataRowState.Detached)
					if(dr[fieldName].Equals(keyValue))
					{
						count++;
					}
			}
			return count;
		}
		public static int FindRowGetIndex(DataTable dt , string fieldName , object keyValue)
		{
			return FindRowGetIndex(dt,fieldName,keyValue,0);
		}

		public static int FindRowGetIndex(DataTable dt , string fieldName , object keyValue , int startIndex)
		{
			int rv = check(dt,fieldName,keyValue);
			return rv<0?rv:findGetIndex(dt,fieldName,keyValue);
		}
		public static DataRow FindRow(DataTable dt , string fieldName , object keyValue)
		{
			int rv = check(dt,fieldName,keyValue);
			return rv<0?null:findGetRow(dt,fieldName,keyValue);
		}
		public static DataRow[] FindRows(DataTable dt , string fieldName , object keyValue)
		{
			int count = FindRowGetCount(dt,fieldName,keyValue);
			DataRow[] drs = new DataRow[count];
			int index = 0;
			for(int i=0;i<count;i++)
			{
				index = findGetIndex(dt,fieldName,keyValue,index);
				if(index>=0)
				{
					drs[i] = dt.Rows[index];
					index++; //下移一个元素，以排除当前的元素
				}
				else
				{
					break;
				}
			}
			return drs;
		}
		#endregion
		#region DataTable 的查找方法
		public static DataRow FindRowInPrimaryKey(DataTable dt , object keyValue)
		{
			return dt.Rows.Find(keyValue);
		}
		public static DataRow FindRowInPrimaryKey(DataTable dt , object[] keyValues)
		{
			return dt.Rows.Find(keyValues);
		}

		#endregion
		#endregion

		#region Update
		/// <summary>
		/// 更新表中某些字段的值
		/// </summary>
		/// <param name="dt">待更新的表</param>
		/// <param name="keyfield">查询字段</param>
		/// <param name="keyvalue">查询关键值</param>
		/// <param name="upfields">更新的字段列表(可以包含查询字段)</param>
		/// <param name="upvalues">更新的值列表</param>
		/// <returns></returns>
		public static int UpdateRows(DataTable dt, string keyfield, object keyvalue, string[] upfields ,object[] upvalues)
		{
			if(upfields.Length!=upvalues.Length)
			{
				return -1;	//给定更新的字段和值的数量不一致;
			}
			bool rv = true;
			for(int i=0;i<upfields.Length;i++)
			{
				if(check(dt,upfields[i],upvalues[i])<0)
				{
					rv = false;
					break;
				}
			}
			if(!rv)return -2; //给定更新的字段和值的类型不一致;
			int count = 0;
			foreach(DataRow dr in FindRows(dt,keyfield,keyvalue))
			{
				for(int i=0;i<upfields.Length;i++)
				{
					dr[upfields[i]] = upvalues[i];
				}
				count++;
			}
			return count; //返回更新记录的条数
		}
		public static int UpdateRows(DataTable dt, string keyfield, object keyvalue, string upfield ,object upvalue)
		{
			if(check(dt,upfield,upvalue)<0)
				return -2; //给定更新的字段和值的类型不一致;
			int count = 0;
			foreach(DataRow dr in FindRows(dt,keyfield,keyvalue))
			{
				dr[upfield] = upvalue;
				count++;
			}
			return count; //返回更新记录的条数
		}
		#endregion

		#region Edit
		public static bool EditRow(DataRow tableRow ,DataRow valueRow)
		{
			tableRow.BeginEdit();
			bool rv = true;
			try
			{
				rv = DRPro.CloneDataRow(valueRow,tableRow);
			}
			catch
			{
				rv = false;
			}
			finally
			{
				if(!rv)
					tableRow.CancelEdit();
				tableRow.EndEdit();
			}
			return rv;
		}
		public static bool EditRow(DataRow tableRow , params object[] values)
		{
			tableRow.BeginEdit();
			bool rv = true;
			try
			{
				if(values.Length != tableRow.Table.Columns.Count)
				{
					rv = false;
				}
				else
				{
					for(int i=0;i<values.Length;i++)
					{
						if(values[i].GetType().Equals(tableRow[i].GetType()))
						{
							tableRow[i] = values[i];
						}
						else
						{
							rv =false;
							break;
						}
					}
				}
			}
			catch
			{
				rv = false;
			}
			finally
			{
				if(!rv)
					tableRow.CancelEdit();
				tableRow.EndEdit();
			}
			return rv;
		}

		#endregion

		#region Append
		public static bool AddRow(DataTable dt , DataRow dr)
		{
			return AddRow(dt,dr,-1);
		}
		public static bool AddRow(DataTable dt , DataRow dr , int pos)
		{
			try
			{
				DataRow _ndr; 
				if(!dr.Table.Equals(dt))
				{
					_ndr = dt.NewRow();
					DRPro.CloneDataRow(dr,_ndr);
				}
				else
				{
					_ndr = dr;
				}
				if(pos > 0)
				{
					dt.Rows.InsertAt(_ndr,pos);
				}
				else
				{
					dt.Rows.Add(_ndr);
				}
				dt.AcceptChanges();
				return true;
				
			}
			catch
			{
				return false;
			}
		}
		#endregion

		#region Delete
		public static void RemoveRow(DataTable dt ,DataRow dr)
		{
			if(dr!=null && dr.Table.Equals(dt))
			{
				dt.Rows.Remove(dr);
				dt.AcceptChanges();
			}
		}
		public static void RemoveRow(DataTable dt ,int index)
		{			
			if(index>=0 && index<dt.Rows.Count)
				dt.Rows.RemoveAt(index);
		}
		#endregion

		#region Filter
		public static void SetFilter(DataTable dt,string filter)
		{
			dt.DefaultView.RowFilter = filter;
		}
		#endregion

		#region Sort
		public static void SetSort(DataTable dt,string sort)
		{
			dt.DefaultView.Sort = sort;
		}
		#endregion
	}
	#endregion
	#endregion


}