C# ExcludeIncludeFieldsList类代码示例

        public static List<DateTime> FetchRepoAukcijaDateCollection(DataAccessAdapterBase adapter)
        {
            if (null == _repoAukcijaDateCollection)
            {
                EntityCollection<RepoAukcijaEntity> repoAukcijaEntityCollection = new EntityCollection<RepoAukcijaEntity>(new RepoAukcijaEntityFactory());
                ExcludeIncludeFieldsList includeFieldList = new ExcludeIncludeFieldsList(false);
                includeFieldList.Add(RepoAukcijaFields.DatumAukcije);

                adapter.FetchEntityCollection(repoAukcijaEntityCollection, includeFieldList, null);

                _repoAukcijaDateCollection = repoAukcijaEntityCollection.OrderByDescending(ra => ra.DatumAukcije).Select(ra => ra.DatumAukcije).ToList();
            }

            return _repoAukcijaDateCollection;
        }

 /// <summary> Fetches the entity from the persistent storage. Fetch simply reads the entity into an EntityFields object. </summary>
 /// <param name="dEntry">PK value for TJadwal which data should be fetched into this TJadwal object</param>
 /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
 /// <param name="contextToUse">The context to add the entity to if the fetch was succesful. </param>
 /// <param name="excludedIncludedFields">The list of IEntityField objects which have to be excluded or included for the fetch. 
 /// If null or empty, all fields are fetched (default). If an instance of ExcludeIncludeFieldsList is passed in and its ExcludeContainedFields property
 /// is set to false, the fields contained in excludedIncludedFields are kept in the query, the rest of the fields in the query are excluded.</param>
 /// <returns>True if succeeded, false otherwise.</returns>
 private bool Fetch(Nullable<System.DateTime> dEntry, IPrefetchPath prefetchPathToUse, Context contextToUse, ExcludeIncludeFieldsList excludedIncludedFields)
 {
     try
     {
         OnFetch();
         IDao dao = this.CreateDAOInstance();
         base.Fields[(int)TJadwalFieldIndex.DEntry].ForcedCurrentValueWrite(dEntry);
         dao.FetchExisting(this, base.Transaction, prefetchPathToUse, contextToUse, excludedIncludedFields);
         return (base.Fields.State == EntityState.Fetched);
     }
     finally
     {
         OnFetchComplete();
     }
 }

 /// <summary>Reads an entity based on a unique constraint. Which entity is read is determined from the passed in fields for the UniqueConstraint.</summary>
 /// <param name="entityToFetch">The entity to fetch. Contained data will be overwritten.</param>
 /// <param name="containingTransaction">A containing transaction, if caller is added to a transaction, or null if not.</param>
 /// <param name="threadID">Value for a field in the UniqueConstraint, which is used to retrieve the contents.</param>
 /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch.</param>
 /// <param name="contextToUse">The context to fetch the prefetch path with.</param>
 /// <param name="excludedIncludedFields">The list of IEntityField objects which have to be excluded or included for the fetch. 
 /// If null or empty, all fields are fetched (default). If an instance of ExcludeIncludeFieldsList is passed in and its ExcludeContainedFields property
 /// is set to false, the fields contained in excludedIncludedFields are kept in the query, the rest of the fields in the query are excluded.</param>
 public void FetchSupportQueueThreadUsingUCThreadID(IEntity entityToFetch, ITransaction containingTransaction, System.Int32 threadID, IPrefetchPath prefetchPathToUse, Context contextToUse, ExcludeIncludeFieldsList excludedIncludedFields)
 {
     IPredicateExpression selectFilter = new PredicateExpression();
     selectFilter.Add(new FieldCompareValuePredicate(entityToFetch.Fields[(int)SupportQueueThreadFieldIndex.ThreadID], ComparisonOperator.Equal, threadID));
     this.PerformFetchEntityAction(entityToFetch, containingTransaction, selectFilter, prefetchPathToUse, contextToUse, excludedIncludedFields);
 }

        private static IPrefetchPathElement2 ConvertPrefetchRepresentationToPrefetchPathElement(EntityType parentEntityType,
                                                                                         PrefetchElementStringRepresentation
                                                                                             prefetchRepresentation,
                                                                                         Dictionary
                                                                                             <string, List<string>>
                                                                                             prefetchFieldNamesDictionary,
                                                                                         string fieldNamesKey,
                                                                                         out ExcludeIncludeFieldsList
                                                                                             includeFieldList)
        {
            includeFieldList = null;

            if (prefetchRepresentation == null)
                return null;

            var includeMap = GetEntityTypeIncludeMap(parentEntityType);

            IPrefetchPathElement2 newElement = null;
            var rr =
                includeMap.FirstOrDefault(
                    rm => rm.Key.Equals(prefetchRepresentation.Name, StringComparison.InvariantCultureIgnoreCase));
            if (!rr.Equals(default(KeyValuePair<string, IPrefetchPathElement2>)))
            {
                newElement = rr.Value;

                foreach (var childRepresentation in prefetchRepresentation.Children)
                {
                    ExcludeIncludeFieldsList subElementIncludeFieldList;
                    var subElement =
                        ConvertPrefetchRepresentationToPrefetchPathElement((EntityType)newElement.ToFetchEntityType,
                                                                           childRepresentation,
                                                                           prefetchFieldNamesDictionary,
                                                                           string.Concat(fieldNamesKey, ".",
                                                                                         childRepresentation.Name
                                                                                                            .ToLowerInvariant
                                                                                             ()),
                                                                           out subElementIncludeFieldList);
                    if (subElement != null)
                        newElement.SubPath.Add(subElement, subElementIncludeFieldList);
                }
            }

            if (newElement != null)
            {
                // Determin if there is a max amount of records to return for this prefetch element
                if (newElement.MaxAmountOfItemsToReturn < prefetchRepresentation.MaxNumberOfItemsToReturn)
                    newElement.MaxAmountOfItemsToReturn = prefetchRepresentation.MaxNumberOfItemsToReturn;

                // Determine if there are field name restrictions applied to the prefetched item
                if (prefetchFieldNamesDictionary.ContainsKey(fieldNamesKey))
                {
                    includeFieldList = ConvertEntityTypeFieldNamesToExcludedIncludedFields(
                        (EntityType)newElement.ToFetchEntityType, prefetchFieldNamesDictionary[fieldNamesKey]);
                }
            }

            return newElement;
        }

 /// <summary> Fetches the contents of this entity from the persistent storage using the primary key specified in a polymorphic way, so the entity returned 
 /// could be of a subtype of the current entity or the current entity.</summary>
 /// <param name="transactionToUse">transaction to use during fetch</param>
 /// <param name="id">PK value for Condition which data should be fetched into this Condition object</param>
 /// <param name="contextToUse">Context to use for fetch</param>
 /// <param name="excludedIncludedFields">The list of IEntityField objects which have to be excluded or included for the fetch. 
 /// If null or empty, all fields are fetched (default). If an instance of ExcludeIncludeFieldsList is passed in and its ExcludeContainedFields property
 /// is set to false, the fields contained in excludedIncludedFields are kept in the query, the rest of the fields in the query are excluded.</param>
 /// <returns>Fetched entity of the type of this entity or a subtype, or an empty entity of that type if not found.</returns>
 /// <remarks>Creates a new instance, doesn't fill <i>this</i> entity instance</remarks>
 public static new ConditionEntity FetchPolymorphic(ITransaction transactionToUse, System.Int32 id, Context contextToUse, ExcludeIncludeFieldsList excludedIncludedFields)
 {
     ConditionDAO dao = new ConditionDAO();
     IEntityFields fields = EntityFieldsFactory.CreateEntityFieldsObject(policyDB.EntityType.ConditionEntity);
     fields[(int)ConditionFieldIndex.Id].ForcedCurrentValueWrite(id);
     return (ConditionEntity)dao.FetchExistingPolymorphic(transactionToUse, fields, contextToUse, excludedIncludedFields);
 }

 /// <summary> Fetches the contents of this entity from the persistent storage using the primary key.</summary>
 /// <param name="sectionID">PK value for Section which data should be fetched into this Section object</param>
 /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
 /// <param name="contextToUse">The context to add the entity to if the fetch was succesful. </param>
 /// <param name="excludedIncludedFields">The list of IEntityField objects which have to be excluded or included for the fetch. 
 /// If null or empty, all fields are fetched (default). If an instance of ExcludeIncludeFieldsList is passed in and its ExcludeContainedFields property
 /// is set to false, the fields contained in excludedIncludedFields are kept in the query, the rest of the fields in the query are excluded.</param>
 /// <returns>True if succeeded, false otherwise.</returns>
 public bool FetchUsingPK(System.Int32 sectionID, IPrefetchPath prefetchPathToUse, Context contextToUse, ExcludeIncludeFieldsList excludedIncludedFields)
 {
     return Fetch(sectionID, prefetchPathToUse, contextToUse, excludedIncludedFields);
 }

 /// <summary> Method which will try to fetch the contents for this entity using a unique constraint. </summary>
 /// <remarks>All contents of the entity is lost.</remarks>
 /// <param name="threadID">Value for a field in the UniqueConstraint, which is used to retrieve the contents.</param>
 /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
 /// <param name="contextToUse">The context to add the entity to if the fetch was succesful. </param>
 /// <param name="excludedIncludedFields">The list of IEntityField objects which have to be excluded or included for the fetch. 
 /// If null or empty, all fields are fetched (default). If an instance of ExcludeIncludeFieldsList is passed in and its ExcludeContainedFields property
 /// is set to false, the fields contained in excludedIncludedFields are kept in the query, the rest of the fields in the query are excluded.</param>
 /// <returns>true if succeeded and the contents is read, false otherwise</returns>
 public bool FetchUsingUCThreadID(System.Int32 threadID, IPrefetchPath prefetchPathToUse, Context contextToUse, ExcludeIncludeFieldsList excludedIncludedFields)
 {
     try
     {
         OnFetch();
         ((SupportQueueThreadDAO)CreateDAOInstance()).FetchSupportQueueThreadUsingUCThreadID(this, this.Transaction, threadID, prefetchPathToUse, contextToUse, excludedIncludedFields);
         return (this.Fields.State == EntityState.Fetched);
     }
     finally
     {
         OnFetchComplete();
     }
 }

 /// <summary> Fetches the contents of this entity from the persistent storage using the primary key specified in a polymorphic way, so the entity returned  could be of a subtype of the current entity or the current entity.</summary>
 /// <param name="transactionToUse">transaction to use during fetch</param>
 /// <param name="auditDataID">PK value for AuditDataMessageRelated which data should be fetched into this AuditDataMessageRelated object</param>
 /// <param name="contextToUse">Context to use for fetch</param>
 /// <param name="excludedIncludedFields">The list of IEntityField objects which have to be excluded or included for the fetch. 
 /// If null or empty, all fields are fetched (default). If an instance of ExcludeIncludeFieldsList is passed in and its ExcludeContainedFields property
 /// is set to false, the fields contained in excludedIncludedFields are kept in the query, the rest of the fields in the query are excluded.</param>
 /// <returns>Fetched entity of the type of this entity or a subtype, or an empty entity of that type if not found.</returns>
 /// <remarks>Creates a new instance, doesn't fill <i>this</i> entity instance</remarks>
 public static new AuditDataMessageRelatedEntity FetchPolymorphic(ITransaction transactionToUse, System.Int32 auditDataID, Context contextToUse, ExcludeIncludeFieldsList excludedIncludedFields)
 {
     IEntityFields fields = EntityFieldsFactory.CreateEntityFieldsObject(SD.HnD.DAL.EntityType.AuditDataMessageRelatedEntity);
     fields[(int)AuditDataMessageRelatedFieldIndex.AuditDataID].ForcedCurrentValueWrite(auditDataID);
     return (AuditDataMessageRelatedEntity)new AuditDataMessageRelatedDAO().FetchExistingPolymorphic(transactionToUse, fields, contextToUse, excludedIncludedFields);
 }

 /// <summary> Fetches the contents of this entity from the persistent storage using the primary key.</summary>
 /// <param name="eventId">PK value for AuctionEventDonor which data should be fetched into this AuctionEventDonor object</param>
 /// <param name="donorId">PK value for AuctionEventDonor which data should be fetched into this AuctionEventDonor object</param>
 /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
 /// <param name="contextToUse">The context to add the entity to if the fetch was succesful. </param>
 /// <param name="excludedIncludedFields">The list of IEntityField objects which have to be excluded or included for the fetch. 
 /// If null or empty, all fields are fetched (default). If an instance of ExcludeIncludeFieldsList is passed in and its ExcludeContainedFields property
 /// is set to false, the fields contained in excludedIncludedFields are kept in the query, the rest of the fields in the query are excluded.</param>
 /// <returns>True if succeeded, false otherwise.</returns>
 public bool FetchUsingPK(System.Int64 eventId, System.Int64 donorId, IPrefetchPath prefetchPathToUse, Context contextToUse, ExcludeIncludeFieldsList excludedIncludedFields)
 {
     return Fetch(eventId, donorId, prefetchPathToUse, contextToUse, excludedIncludedFields);
 }

        private static void LoadTrgovanjeGodinaList(DataAccessAdapterBase adapter)
        {
            EntityCollection<TrgovanjeGlavaEntity> trgovanjeGlavaCollection = new EntityCollection<TrgovanjeGlavaEntity>(new TrgovanjeGlavaEntityFactory());

            ExcludeIncludeFieldsList includeFieldList = new ExcludeIncludeFieldsList(false);
            includeFieldList.Add(TrgovanjeGlavaFields.Datum);

            adapter.FetchEntityCollection(trgovanjeGlavaCollection, includeFieldList, null);

            _godinaTrgovanjaCollection = trgovanjeGlavaCollection.Select(tg => tg.Datum.Year).Distinct().ToList();

            _godinaTrgovanjaCollection.Sort();
        }

 /// <summary> Method which will try to fetch the contents for this entity using a unique constraint. </summary>
 /// <remarks>All contents of the entity is lost.</remarks>
 /// <param name="nickName">Value for a field in the UniqueConstraint, which is used to retrieve the contents.</param>
 /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
 /// <param name="contextToUse">The context to add the entity to if the fetch was succesful. </param>
 /// <param name="excludedIncludedFields">The list of IEntityField objects which have to be excluded or included for the fetch. 
 /// If null or empty, all fields are fetched (default). If an instance of ExcludeIncludeFieldsList is passed in and its ExcludeContainedFields property
 /// is set to false, the fields contained in excludedIncludedFields are kept in the query, the rest of the fields in the query are excluded.</param>
 /// <returns>true if succeeded and the contents is read, false otherwise</returns>
 public bool FetchUsingUCNickName(System.String nickName, IPrefetchPath prefetchPathToUse, Context contextToUse, ExcludeIncludeFieldsList excludedIncludedFields)
 {
     try
     {
         OnFetch();
         ((UserDAO)CreateDAOInstance()).FetchUserUsingUCNickName(this, this.Transaction, nickName, prefetchPathToUse, contextToUse, excludedIncludedFields);
         return (this.Fields.State == EntityState.Fetched);
     }
     finally
     {
         OnFetchComplete();
     }
 }

 /// <summary>Reads an entity based on a unique constraint. Which entity is read is determined from the passed in fields for the UniqueConstraint.</summary>
 /// <param name="entityToFetch">The entity to fetch. Contained data will be overwritten.</param>
 /// <param name="containingTransaction">A containing transaction, if caller is added to a transaction, or null if not.</param>
 /// <param name="nickName">Value for a field in the UniqueConstraint, which is used to retrieve the contents.</param>
 /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch.</param>
 /// <param name="contextToUse">The context to fetch the prefetch path with.</param>
 /// <param name="excludedIncludedFields">The list of IEntityField objects which have to be excluded or included for the fetch. 
 /// If null or empty, all fields are fetched (default). If an instance of ExcludeIncludeFieldsList is passed in and its ExcludeContainedFields property
 /// is set to false, the fields contained in excludedIncludedFields are kept in the query, the rest of the fields in the query are excluded.</param>
 public void FetchUserUsingUCNickName(IEntity entityToFetch, ITransaction containingTransaction, System.String nickName, IPrefetchPath prefetchPathToUse, Context contextToUse, ExcludeIncludeFieldsList excludedIncludedFields)
 {
     IPredicateExpression selectFilter = new PredicateExpression();
     selectFilter.Add(new FieldCompareValuePredicate(entityToFetch.Fields[(int)UserFieldIndex.NickName], ComparisonOperator.Equal, nickName));
     this.PerformFetchEntityAction(entityToFetch, containingTransaction, selectFilter, prefetchPathToUse, contextToUse, excludedIncludedFields);
 }

 /// <summary> Fetches the contents of this entity from the persistent storage using the primary key.</summary>
 /// <param name="roleID">PK value for RoleUser which data should be fetched into this RoleUser object</param>
 /// <param name="userID">PK value for RoleUser which data should be fetched into this RoleUser object</param>
 /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
 /// <param name="contextToUse">The context to add the entity to if the fetch was succesful. </param>
 /// <param name="excludedIncludedFields">The list of IEntityField objects which have to be excluded or included for the fetch. 
 /// If null or empty, all fields are fetched (default). If an instance of ExcludeIncludeFieldsList is passed in and its ExcludeContainedFields property
 /// is set to false, the fields contained in excludedIncludedFields are kept in the query, the rest of the fields in the query are excluded.</param>
 /// <returns>True if succeeded, false otherwise.</returns>
 public bool FetchUsingPK(System.Int32 roleID, System.Int32 userID, IPrefetchPath prefetchPathToUse, Context contextToUse, ExcludeIncludeFieldsList excludedIncludedFields)
 {
     return Fetch(roleID, userID, prefetchPathToUse, contextToUse, excludedIncludedFields);
 }

 /// <summary> Fetches the contents of this entity from the persistent storage using the primary key.</summary>
 /// <param name="keywordId">PK value for ProductKeyword which data should be fetched into this ProductKeyword object</param>
 /// <param name="productId">PK value for ProductKeyword which data should be fetched into this ProductKeyword object</param>
 /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
 /// <param name="contextToUse">The context to add the entity to if the fetch was succesful. </param>
 /// <param name="excludedIncludedFields">The list of IEntityField objects which have to be excluded or included for the fetch. 
 /// If null or empty, all fields are fetched (default). If an instance of ExcludeIncludeFieldsList is passed in and its ExcludeContainedFields property
 /// is set to false, the fields contained in excludedIncludedFields are kept in the query, the rest of the fields in the query are excluded.</param>
 /// <returns>True if succeeded, false otherwise.</returns>
 public bool FetchUsingPK(System.Int32 keywordId, System.Int32 productId, IPrefetchPath prefetchPathToUse, Context contextToUse, ExcludeIncludeFieldsList excludedIncludedFields)
 {
     return Fetch(keywordId, productId, prefetchPathToUse, contextToUse, excludedIncludedFields);
 }

 /// <summary> Fetches the contents of this entity from the persistent storage using the primary key.</summary>
 /// <param name="dEntry">PK value for TJadwal which data should be fetched into this TJadwal object</param>
 /// <param name="prefetchPathToUse">the PrefetchPath which defines the graph of objects to fetch as well</param>
 /// <param name="contextToUse">The context to add the entity to if the fetch was succesful. </param>
 /// <param name="excludedIncludedFields">The list of IEntityField objects which have to be excluded or included for the fetch. 
 /// If null or empty, all fields are fetched (default). If an instance of ExcludeIncludeFieldsList is passed in and its ExcludeContainedFields property
 /// is set to false, the fields contained in excludedIncludedFields are kept in the query, the rest of the fields in the query are excluded.</param>
 /// <returns>True if succeeded, false otherwise.</returns>
 public bool FetchUsingPK(Nullable<System.DateTime> dEntry, IPrefetchPath prefetchPathToUse, Context contextToUse, ExcludeIncludeFieldsList excludedIncludedFields)
 {
     return Fetch(dEntry, prefetchPathToUse, contextToUse, excludedIncludedFields);
 }