C# DataCollection.Add方法代码示例

		public void FillInformationAndInformationenAddOns(Guid? ActiveInformationenID)
			{
			ActiveInformationen = DataModell.LoadDBInformationenShortTreeFromEntryDataSet
					(DataModell.GetEntryDataSet((Guid) ActiveInformationenID, null, null, false));
			if (ActiveInformationen == null)
				return;
			InformationAndInformationenAddOns = new DataCollection<object>();
			InformationAndInformationenAddOns.Add(ActiveInformationen);
			foreach (InformationenAddOn Entry in ActiveInformationen.ConnectedInformationenAddOn)
				InformationAndInformationenAddOns.Add(Entry);
			}

		private  DataCollection<FullUseForTyp> LoadAvailableFullTypForTyp (Typ TypToSearchFor)
			{
			DataCollection<FullUseForTyp> Result = new DataCollection<FullUseForTyp> ();
			foreach (FullUseForTyp Entry in AvailableFullTyp.Values)
				{
				if (Entry.ConnectedID == TypToSearchFor.ID)
					Result.Add(Entry);
				else if (Entry.ConnectedID == TypToSearchFor.RootFormat)
					Result.Add ((Entry));
				}
			return Result;
			}

		private void LoadAllTimingTypen(DataCollection<TimingTypen> _allTimingTypen)
			{
			foreach (DataRow TimingTypenRow in DataModell.DataSetForStaticTables.Tables["TimingTypen"].Rows)
				{
				_allTimingTypen.Add(new TimingTypen(TimingTypenRow));
				}
			}

		private void LoadAccessRights(DataCollection<AccessRights> _selectableAccessRights)
			{
			foreach (DataRow AccessEntryRow in DataModell.DataSetForStaticTables.Tables["AccessRights"].Rows)
				{
				_selectableAccessRights.Add(new AccessRights(AccessEntryRow));
				}
			}

		private void LoadTypTree(DataCollection<TreeEntryClass> _typTree)
			{
			foreach (DataRow RootDataTemplateRow in DataModell.DataSetForStaticTables.Tables["RootDataTemplates"].Rows)
				{
				RootDataTemplates RootTyp = new RootDataTemplates(RootDataTemplateRow);
				_typTree.Add(new TreeEntryClass()
					{
					Parent = null,
					HeadLine = RootTyp.NameID,
					ConnectedObject = RootTyp
					});
				foreach (DataRow TypRow in DataModell.DataSetForStaticTables.Tables["Typ"].Rows)
					{
					if (((Guid)TypRow["RootFormat"]) != RootTyp.ID)
						continue;
					Typ SelectableTyp = new Typ(TypRow);
					_typTree.Last().Childs.Add(new TreeEntryClass()
						{
						Parent = _typTree.Last(),
						HeadLine = SelectableTyp.NameID,
						ConnectedObject = SelectableTyp
						});
					}
				}
			}

		public static DataCollection<Kandidat> LoadKandidaten(MBRWahlDataModell Parent)
			{
			DataCollection<Kandidat> KandidatenEntries = new DataCollection<Kandidat>();
			foreach (DataRow Entry in MBRWahlDataWrapper.Instance.StaticDataSetForInternet.Tables ["Kandidaten"].Rows)
				{
				KandidatenEntries.Add (new Kandidat (Entry) {Parent = Parent});
				}
			return KandidatenEntries;
			}

		private void LoadSelectableTyp(DataCollection<Typ> _selectableTyp)
			{
			foreach (DataRow TypRow in DataModell.DataSetForStaticTables.Tables["Typ"].Rows)
				{
				_selectableTyp.Add(new Typ(TypRow)
					{

					});
				}
			}

		//private Dictionary<Guid,DataCollection<FullUseForTyp>> _availableFullTypForTypOrRoot;
		//public Dictionary<Guid, DataCollection<FullUseForTyp>> AvailableFullTypForTypOrRoot
		//	{
		//	get
		//		{
		//		if (_availableFullTypForTypOrRoot == null)
		//			_availableFullTypForTypOrRoot = new Dictionary<Guid, DataCollection<FullUseForTyp>>();
		//		if (Profile.ActiveTyp != null)
		//			{
		//			if (!_availableFullTypForTypOrRoot.ContainsKey(Profile.ActiveTyp.ID))
		//				_availableFullTypForTypOrRoot[Profile.ActiveTyp.ID] = LoadAvailableFullTypForTyp(Profile.ActiveTyp);
		//			}
		//		else
		//			{
		//			if (Profile.ActiveRootDataTemplates != null)
		//				{
		//				if (!_availableFullTypForTypOrRoot.ContainsKey(Profile.ActiveRootDataTemplates.ID))
		//					_availableFullTypForTypOrRoot[Profile.ActiveRootDataTemplates.ID] = LoadAvailableFullTypForRoot(Profile.ActiveRootDataTemplates);
		//				}
		//			}

		//		return _availableFullTypForTypOrRoot;
		//		}
		//	set { SetProperty (ref _availableFullTypForTypOrRoot, value); }
		//	}
		private DataCollection<FullUseForTyp> LoadAvailableFullTypForRoot(RootDataTemplates RootToSearchFor)
			{
			DataCollection<FullUseForTyp> Result = new DataCollection<FullUseForTyp>();
			foreach (FullUseForTyp Entry in AvailableFullTyp.Values)
				{
				if (Entry.ConnectedID == RootToSearchFor.ID)
					Result.Add(Entry);
				}
			return Result;
			}

		public DataCollection<PropertyInfo> PropertiesForClass (String ClassName)
			{
			DataCollection<PropertyInfo> Result = new DataCollection<PropertyInfo> ();
			if (!String.IsNullOrEmpty (ClassName))
				foreach (PropertyInfo PropInfo in DataWrapper.GetTypeToCreate (ClassName).GetProperties ())
					{
					Result.Add (PropInfo);
					}
			return Result;
			}

		private void LoadSelectableZielGruppe(DataCollection<ZielGruppen> _selectableZielGruppe)
			{
			foreach (DataRow ZielGruppenRow in DataModell.DataSetForStaticTables.Tables["ZielGruppen"].Rows)
				{
				_selectableZielGruppe.Add(new ZielGruppen(ZielGruppenRow)
					{

					});
				}
			}

 private int LoadAllWSPLakate()
 {
     _allWSPlakate = new DataCollection<WSPlakate>();
     int Counter = 0;
     foreach (DataRow WSPlakateRow in WordUpBasics.WordUpWCFAccess.GetCommonDataSet("Select * from WSPlakate order by NameID").Tables["WSPlakate"].Rows)
     {
         _allWSPlakate.Add(new WSPlakate(WSPlakateRow) { Parent = _allWSPlakate });
         Counter++;
     }
     return Counter;
 }

		public static DataCollection<WordUp23.Chart> CreateMyElements()
			{
			DataCollection<WordUp23.Chart> Elements = new DataCollection<WordUp23.Chart>();
			foreach (DataWrapper.Charts Entry in Enum.GetValues(typeof(DataWrapper.Charts)))
				{
				Elements.Add(new WordUp23.Chart()
					{
					ChartsToCreate = Entry
					});
				}
			return Elements;
			}

		private DataCollection<TextReplaceElement> LoadTextReplaceElements ()
			{
			DataCollection<TextReplaceElement> Result = new DataCollection<TextReplaceElement> ();
			foreach (XElement ReplacementEntry  in PreprocessorDirectives.Elements(StartDefinitionsName).First()
				.Elements(StartReplaceDefinitionsName).Descendants(ReplaceDefinitionName))
				{
				if (ReplacementEntry.Name != ReplaceDefinitionName)
					continue;
				Result.Add (new TextReplaceElement (ReplacementEntry) {Parent = this});
				}
			return Result;
			}

		public static DataCollection<SortOrder> CreateMyElements()
			{
			DataCollection<SortOrder> Elements = new DataCollection<SortOrder>();
			foreach (DataWrapper.SortOrder Entry in Enum.GetValues(typeof(DataWrapper.SortOrder)))
				{
				Elements.Add(new SortOrder()
					{
					SortField = Entry
					});
				}
			return Elements;
			}

		public static DataCollection<PersonenAuswertung> CreateMyElements()
			{
			DataCollection<PersonenAuswertung> Elements = new DataCollection<PersonenAuswertung>();
			foreach (DataWrapper.PersonenAuswertung Entry in Enum.GetValues(typeof(DataWrapper.PersonenAuswertung)))
				{
				Elements.Add(new PersonenAuswertung()
					{
					PersonenAuswertungenToCreate = Entry
					});
				}
			return Elements;
			}