collections.cs

客户关系管理系统ASP.NET+VB.NET编程完整程序！

		/// <summary>
		/// Filter by the property IsReadOnly.
		/// </summary>
		/// <param name="searchValue">The value to search for</param>
		/// <param name="comparer">What sort of comparison should be made</param>
		/// <returns>A ColumnCollection of Columns</returns>
		public	ColumnCollection	FilterByIsReadOnly( System.String searchValue, CompareType comparer )
		{
			ColumnCollection retCollection = new ColumnCollection();

			foreach( Column _Column in List)
			{
				if ( Match(comparer,_Column.IsReadOnly , searchValue) ) 
					retCollection.Add( _Column );
			}
			
			retCollection.Parent = this.Parent;

			return retCollection;
		}

		/// <summary>
		/// Filter by the property DeclaredType.
		/// </summary>
		/// <param name="searchValue">The value to search for</param>
		/// <returns>A ColumnCollection of Columns</returns>
		public	ColumnCollection	FilterByDeclaredType( System.String searchValue )
		{
			return FilterByDeclaredType( searchValue, CompareType.Exact );
		}
		
		/// <summary>
		/// Filter by the property DeclaredType.
		/// </summary>
		/// <param name="searchValue">The value to search for</param>
		/// <param name="comparer">What sort of comparison should be made</param>
		/// <returns>A ColumnCollection of Columns</returns>
		public	ColumnCollection	FilterByDeclaredType( System.String searchValue, CompareType comparer )
		{
			ColumnCollection retCollection = new ColumnCollection();

			foreach( Column _Column in List)
			{
				if ( Match(comparer,_Column.DeclaredType , searchValue) ) 
					retCollection.Add( _Column );
			}
			
			retCollection.Parent = this.Parent;

			return retCollection;
		}

		/// <summary>
		/// Filter by the property Precision.
		/// </summary>
		/// <param name="searchValue">The value to search for</param>
		/// <returns>A ColumnCollection of Columns</returns>
		public	ColumnCollection	FilterByPrecision( System.Data.SqlTypes.SqlInt32 searchValue )
		{
			return FilterByPrecision( searchValue, CompareType.Exact );
		}
		
		/// <summary>
		/// Filter by the property Precision.
		/// </summary>
		/// <param name="searchValue">The value to search for</param>
		/// <param name="comparer">What sort of comparison should be made</param>
		/// <returns>A ColumnCollection of Columns</returns>
		public	ColumnCollection	FilterByPrecision( System.Data.SqlTypes.SqlInt32 searchValue, CompareType comparer )
		{
			ColumnCollection retCollection = new ColumnCollection();

			foreach( Column _Column in List)
			{
				if ( Match(comparer,_Column.Precision , searchValue) ) 
					retCollection.Add( _Column );
			}
			
			retCollection.Parent = this.Parent;

			return retCollection;
		}


		/// <summary>
		/// Filter by the property Precision.
		/// </summary>
		/// <param name="searchValue">The value to search for</param>
		/// <returns>A ColumnCollection of Columns</returns>
		public	ColumnCollection	FilterByPrecision( string searchValue )
		{
			return FilterByPrecision( System.Data.SqlTypes.SqlInt32.Parse(searchValue), CompareType.Exact );
		}
		
		/// <summary>
		/// Filter by the property Precision.
		/// </summary>
		/// <param name="searchValue">The value to search for</param>
		/// <param name="comparer">What sort of comparison should be made</param>
		/// <returns>A ColumnCollection of Columns</returns>
		public	ColumnCollection	FilterByPrecision( string searchValue, CompareType comparer )
		{
			return FilterByPrecision( System.Data.SqlTypes.SqlInt32.Parse(searchValue),comparer );
		}		/// <summary>
		/// Sorts a Column by the property ID.
		/// </summary>
		/// <param name="sortDirection">The direction to sort in</param>
		/// <returns>The collection in sorted order</returns>
		public	ColumnCollection	SortByID ( SortDirection sortDirection )
		{
			InnerList.Sort( new OrmLib.ObjectPropertyComparer("ID"));
			if (sortDirection == SortDirection.Descending) InnerList.Reverse();
			return (ColumnCollection)this;
		}

		/// <summary>
		/// Sorts a Column by the property FKTableID.
		/// </summary>
		/// <param name="sortDirection">The direction to sort in</param>
		/// <returns>The collection in sorted order</returns>
		public	ColumnCollection	SortByFKTableID ( SortDirection sortDirection )
		{
			InnerList.Sort( new OrmLib.ObjectPropertyComparer("FKTableID"));
			if (sortDirection == SortDirection.Descending) InnerList.Reverse();
			return (ColumnCollection)this;
		}

		/// <summary>
		/// Sorts a Column by the property Name.
		/// </summary>
		/// <param name="sortDirection">The direction to sort in</param>
		/// <returns>The collection in sorted order</returns>
		public	ColumnCollection	SortByName ( SortDirection sortDirection )
		{
			InnerList.Sort( new OrmLib.ObjectPropertyComparer("Name"));
			if (sortDirection == SortDirection.Descending) InnerList.Reverse();
			return (ColumnCollection)this;
		}

		/// <summary>
		/// Sorts a Column by the property FKDataTypeID.
		/// </summary>
		/// <param name="sortDirection">The direction to sort in</param>
		/// <returns>The collection in sorted order</returns>
		public	ColumnCollection	SortByFKDataTypeID ( SortDirection sortDirection )
		{
			InnerList.Sort( new OrmLib.ObjectPropertyComparer("FKDataTypeID"));
			if (sortDirection == SortDirection.Descending) InnerList.Reverse();
			return (ColumnCollection)this;
		}

		/// <summary>
		/// Sorts a Column by the property Length.
		/// </summary>
		/// <param name="sortDirection">The direction to sort in</param>
		/// <returns>The collection in sorted order</returns>
		public	ColumnCollection	SortByLength ( SortDirection sortDirection )
		{
			InnerList.Sort( new OrmLib.ObjectPropertyComparer("Length"));
			if (sortDirection == SortDirection.Descending) InnerList.Reverse();
			return (ColumnCollection)this;
		}

		/// <summary>
		/// Sorts a Column by the property PrimaryKey.
		/// </summary>
		/// <param name="sortDirection">The direction to sort in</param>
		/// <returns>The collection in sorted order</returns>
		public	ColumnCollection	SortByPrimaryKey ( SortDirection sortDirection )
		{
			InnerList.Sort( new OrmLib.ObjectPropertyComparer("PrimaryKey"));
			if (sortDirection == SortDirection.Descending) InnerList.Reverse();
			return (ColumnCollection)this;
		}

		/// <summary>
		/// Sorts a Column by the property SetAccessor.
		/// </summary>
		/// <param name="sortDirection">The direction to sort in</param>
		/// <returns>The collection in sorted order</returns>
		public	ColumnCollection	SortBySetAccessor ( SortDirection sortDirection )
		{
			InnerList.Sort( new OrmLib.ObjectPropertyComparer("SetAccessor"));
			if (sortDirection == SortDirection.Descending) InnerList.Reverse();
			return (ColumnCollection)this;
		}

		/// <summary>
		/// Sorts a Column by the property GetAccessor.
		/// </summary>
		/// <param name="sortDirection">The direction to sort in</param>
		/// <returns>The collection in sorted order</returns>
		public	ColumnCollection	SortByGetAccessor ( SortDirection sortDirection )
		{
			InnerList.Sort( new OrmLib.ObjectPropertyComparer("GetAccessor"));
			if (sortDirection == SortDirection.Descending) InnerList.Reverse();
			return (ColumnCollection)this;
		}

		/// <summary>
		/// Sorts a Column by the property RequiredForInstantiation.
		/// </summary>
		/// <param name="sortDirection">The direction to sort in</param>
		/// <returns>The collection in sorted order</returns>
		public	ColumnCollection	SortByRequiredForInstantiation ( SortDirection sortDirection )
		{
			InnerList.Sort( new OrmLib.ObjectPropertyComparer("RequiredForInstantiation"));
			if (sortDirection == SortDirection.Descending) InnerList.Reverse();
			return (ColumnCollection)this;
		}

		/// <summary>
		/// Sorts a Column by the property AccessorName.
		/// </summary>
		/// <param name="sortDirection">The direction to sort in</param>
		/// <returns>The collection in sorted order</returns>
		public	ColumnCollection	SortByAccessorName ( SortDirection sortDirection )
		{
			InnerList.Sort( new OrmLib.ObjectPropertyComparer("AccessorName"));
			if (sortDirection == SortDirection.Descending) InnerList.Reverse();
			return (ColumnCollection)this;
		}

		/// <summary>
		/// Sorts a Column by the property Nullable.
		/// </summary>
		/// <param name="sortDirection">The direction to sort in</param>
		/// <returns>The collection in sorted order</returns>
		public	ColumnCollection	SortByNullable ( SortDirection sortDirection )
		{
			InnerList.Sort( new OrmLib.ObjectPropertyComparer("Nullable"));
			if (sortDirection == SortDirection.Descending) InnerList.Reverse();
			return (ColumnCollection)this;
		}

		/// <summary>
		/// Sorts a Column by the property IsIdentity.
		/// </summary>
		/// <param name="sortDirection">The direction to sort in</param>
		/// <returns>The collection in sorted order</returns>
		public	ColumnCollection	SortByIsIdentity ( SortDirection sortDirection )
		{
			InnerList.Sort( new OrmLib.ObjectPropertyComparer("IsIdentity"));
			if (sortDirection == SortDirection.Descending) InnerList.Reverse();
			return (ColumnCollection)this;
		}

		/// <summary>
		/// Sorts a Column by the property IsReadOnly.
		/// </summary>
		/// <param name="sortDirection">The direction to sort in</param>
		/// <returns>The collection in sorted order</returns>
		public	ColumnCollection	SortByIsReadOnly ( SortDirection sortDirection )
		{
			InnerList.Sort( new OrmLib.ObjectPropertyComparer("IsReadOnly"));
			if (sortDirection == SortDirection.Descending) InnerList.Reverse();
			return (ColumnCollection)this;
		}

		/// <summary>
		/// Sorts a Column by the property DeclaredType.
		/// </summary>
		/// <param name="sortDirection">The direction to sort in</param>
		/// <returns>The collection in sorted order</returns>
		public	ColumnCollection	SortByDeclaredType ( SortDirection sortDirection )
		{
			InnerList.Sort( new OrmLib.ObjectPropertyComparer("DeclaredType"));
			if (sortDirection == SortDirection.Descending) InnerList.Reverse();
			return (ColumnCollection)this;
		}

		/// <summary>
		/// Sorts a Column by the property Precision.
		/// </summary>
		/// <param name="sortDirection">The direction to sort in</param>
		/// <returns>The collection in sorted order</returns>
		public	ColumnCollection	SortByPrecision ( SortDirection sortDirection )
		{
			InnerList.Sort( new OrmLib.ObjectPropertyComparer("Precision"));
			if (sortDirection == SortDirection.Descending) InnerList.Reverse();
			return (ColumnCollection)this;
		}


		}


		/// <summary>
		///	Holds a collection of Databases that can be searched and enumerated.
		/// </summary>
		[OrmLib.TypedCollection(typeof(Database))]
		public abstract class DatabaseCollectionOrmTemplate : CollectionTemplate
		{
			public DatabaseCollectionOrmTemplate() : base(typeof(Database)){}

			public Database this[int index]
			{
				get
				{
					return (Database)List[index];
				}
				set
				{
					throw new NotSupportedException("Please use the Add() method."); 
				} 
			}	

			/// <summary>
			/// Filter by the provided property name
			/// </summary>
			/// <param name="property">The property to filter on</param>
			/// <param name="searchValue">The value to search for</param>
			/// <returns>A collection of Databases</returns>
			public DatabaseCollection FilterBy( string property, object searchValue )
			{
				return FilterBy(property, searchValue, CompareType.Exact);
			}

			/// <summary>
			/// Filter by the provided property name
			/// </summary>
			/// <param name="property">The property to filter on</param>
			/// <param name="searchValue">The value to search for</param>
			/// <param name="comparer">How to compare the property to the search value</param>
			/// <returns>A collection of Databases</returns>
			public DatabaseCollection FilterBy( string property, object searchValue, CompareType comparer )
			{
				DatabaseCollection retCollection = new DatabaseCollection();
				
				foreach( Database _Database in List)
				{
					if ( Match(comparer,_Database[property] , searchValue) ) 
						retCollection.Add( _Database );
				}
			
				return retCollection;
			}

			/// <summary>
			/// Returns a sorted collection based on the supplied property name.
			/// </summary>
			/// <param name="property">The property to sort by</param>
			/// <returns></returns>
			public DatabaseCollection SortBy( string property )
			{
				return SortBy( property, SortDirection.Ascending );
			}

			/// <summary>
			/// Returns a sorted collection based on the supplied property name.
			/// </summary>
			/// <param name="property">The property to sort by</param>
			/// <param name="sortDirection"></param>
			/// <returns></returns>
			public DatabaseCollection SortBy( string property, SortDirection sortDirection )
			{
				InnerList.Sort( new OrmLib.ObjectPropertyComparer(property));
				if (sortDirection == SortDirection.Descending) InnerList.Reverse();
				return (DatabaseCollection)this;
			}

		
			/// <summary>
			/// Find the first in the collection, based on the
			/// supplied property.
			/// </summary>
			/// <param name="property">The property to find by</param>
			/// <param name="searchValue"></param>
			/// <returns></returns>
			public Database FindBy( string property, object searchValue )
			{
				return FindBy(property, searchValue, CompareType.Exact);
			}

			/// <summary>
			/// Find the first in the collection, based on the
			/// supplied property.
			/// </summary>
			/// <param name="property">The property to find by</param>