C# ReportItemCollection类代码示例

		public Report( string name, string width )
		{
			m_Name = name;
			m_Width = width;
			m_Columns = new ReportColumnCollection();
			m_Items = new ReportItemCollection();
		}

		public ListLayout(ReportModel reportModel,ReportItemCollection reportItemCollection):base(reportModel)
		{
			this.reportItems = reportItemCollection;
			ICSharpCode.Reports.Core.BaseRowItem row = new ICSharpCode.Reports.Core.BaseRowItem();
			AdjustContainer(base.ReportModel.DetailSection,row);
			base.ParentItem = row;
		}

		public void Fill (ReportItemCollection collection) {
			foreach (var item in collection) {
				IDataItem dataItem = item as IDataItem;
				if (dataItem != null) {
					this.store.Fill(dataItem);
				}
			}
		}

		public override void Fill(int position,ReportItemCollection collection)
		{
			DataRow row = this.table.Rows[position];
			foreach (var item in collection) {
				IDataItem dataItem = item as IDataItem;
				if (dataItem != null) {
					FillInternal (row,dataItem);
				}
			}
		}

		public  static void AdjustParent (ISimpleContainer parent,ReportItemCollection items)
		{
			foreach (BaseReportItem item in items) {
				item.Parent = parent as BaseReportItem;
				ISimpleContainer container = item as ISimpleContainer;
				if (container != null) {
					AdjustParentInternal(container.Items,container);
				} else {
					AdjustParentInternal(items,parent as ISimpleContainer);
				}
			}
		}

		public  static void AdjustParent (BaseReportItem parent,ReportItemCollection items)
		{
			foreach (BaseReportItem i in items) {
				i.Parent = parent;
				ISimpleContainer ic = i as ISimpleContainer;
				if (ic != null) {
					AdjustParentInternal(ic.Items,i);
				} else {
					AdjustParentInternal(items,parent);
				}
			}
		}

		internal static  ReportItemCollection ExtractSelectedItems(ReportItemCollection sourceItems,DataGridViewColumn[] displayCols)
		{
			var destItems = new ReportItemCollection();
			foreach (DataGridViewColumn cc in displayCols) {
				DataGridViewColumnHeaderCheckBoxCell hc = (DataGridViewColumnHeaderCheckBoxCell)cc.HeaderCell;
				if (hc.Checked) {
					BaseReportItem br = (BaseReportItem)sourceItems.Find(cc.HeaderText);
					destItems.Add(br);
				}
			}
			return destItems;
		}

		public void Fill(ReportItemCollection collection)
		{
			TableStrategy tableStrategy =  store as TableStrategy;
			foreach (var item in collection) {
				IDataItem dataItem = item as IDataItem;
				if (dataItem != null) {
					CurrentItemsCollection currentItemsCollection = tableStrategy.FillDataRow(this.indexList[CurrentRow].ListIndex);
					CurrentItem s = currentItemsCollection.FirstOrDefault(x => x.ColumnName == dataItem.ColumnName);
					dataItem.DBValue = s.Value.ToString();
				}
				
			}
		}

		public static AbstractLayout CreateGenerator (GlobalEnums.ReportLayout reportLayout,
		                                              ReportModel model,
		                                              ReportItemCollection items)
		{
			AbstractLayout layout = null;
			switch (reportLayout) {
				case GlobalEnums.ReportLayout.ListLayout:
					layout = new ListLayout(model,items);
					break;
				case GlobalEnums.ReportLayout.TableLayout:
					layout = new TableLayout(model,items);
					break;
			}
			return layout;
		}

		public ExporterCollection ConvertSimpleItems (Point offset,ReportItemCollection items)
		{
			if (items == null) {
				throw new ArgumentNullException("items");
			}
			ExporterCollection col = new ExporterCollection();
			if (items.Count > 0) {
				
				foreach(BaseReportItem item in items)
				{
					col.Add(ConvertToLineItem(offset,item));
				}
			}
			return col;
		}

		public static void EvaluateReportItems (IExpressionEvaluatorFacade  evaluator,ReportItemCollection items)
		{
			foreach(BaseReportItem column in items)
			{
				var container = column as ISimpleContainer ;
				if (container != null) {
					EvaluateReportItems(evaluator,container.Items);
				}
				
				IReportExpression expressionItem = column as IReportExpression;
				if (expressionItem != null) {
					evaluator.Evaluate(expressionItem);
				}
			}
		}

		private BaseReportItem FindRec (ReportItemCollection items, string name)
		{
			foreach(BaseReportItem item in items)
			{
				ISimpleContainer cont = item as ISimpleContainer;
				if (cont != null) {
					return FindRec(cont.Items,name);
				} else {
					var query = from bt in items where bt.Name == name select bt;
					if (query.Count() >0) {
						return query.FirstOrDefault();
					}
				}
			}
			return null;
		}

		private void EvaluateRecursive (IExpressionEvaluatorFacade evaluatorFassade,ReportItemCollection items)
		{
			foreach (BaseReportItem be in items) {
				
				ISimpleContainer  ec = be as ISimpleContainer;
				if (ec != null)
				{
					if (ec.Items.Count > 0) {
						EvaluateRecursive(evaluatorFassade,ec.Items);
					}
				}
				BaseTextItem bt = be as BaseTextItem;
				if (bt != null) {
					bt.Text = evaluatorFassade.Evaluate(bt.Text);
				}
			}
		}

		public static  ExporterCollection ConvertPlainCollection (ReportItemCollection items,Point offset)
		{
			if (items == null) {
				throw new ArgumentNullException("items");
			}

			ExporterCollection col = new ExporterCollection();
			if (items.Count > 0) {
				items.SortByLocation();
				foreach(BaseReportItem item in items)
				{
					var converteditem = ExportHelper.ConvertLineItem(item,offset);
					col.Add((BaseExportColumn)converteditem);
				}
			}
			return col;
		}

		public void TypeOfReportItemIsString () {
			var ric = new ReportItemCollection(){
				new BaseDataItem(){
					ColumnName = "Lastname"
						
				},
				new BaseDataItem(){
					ColumnName = "Firstname"
				}
			};
			var collectionSource = new CollectionSource	(list,new ReportSettings());
			collectionSource.Bind();
			collectionSource.Fill(ric);
			foreach (BaseDataItem element in ric) {
				Assert.That(element.DataType,Is.EqualTo("System.String"));
			}
		}