C# IEdmEntityTypeReference.StructuralProperties方法代码示例

        /// <summary>
        /// Creates a new instance of the <see cref="SelectExpandNode"/> class describing the set of structural properties,
        /// navigation properties, and actions to select and expand for the given <paramref name="selectExpandClause"/>.
        /// </summary>
        /// <param name="selectExpandClause">The parsed $select and $expand query options.</param>
        /// <param name="entityType">The entity type of the entry that would be written.</param>
        /// <param name="model">The <see cref="IEdmModel"/> that contains the given entity type.</param>
        public SelectExpandNode(SelectExpandClause selectExpandClause, IEdmEntityTypeReference entityType, IEdmModel model)
            : this()
        {
            if (entityType == null)
            {
                throw Error.ArgumentNull("entityType");
            }
            if (model == null)
            {
                throw Error.ArgumentNull("model");
            }

            HashSet<IEdmStructuralProperty> allStructuralProperties = new HashSet<IEdmStructuralProperty>(entityType.StructuralProperties());
            HashSet<IEdmNavigationProperty> allNavigationProperties = new HashSet<IEdmNavigationProperty>(entityType.NavigationProperties());
            HashSet<IEdmFunctionImport> allActions = new HashSet<IEdmFunctionImport>(model.GetAvailableProcedures(entityType.EntityDefinition()));

            if (selectExpandClause == null)
            {
                SelectedStructuralProperties = allStructuralProperties;
                SelectedNavigationProperties = allNavigationProperties;
                SelectedActions = allActions;
            }
            else
            {
                if (selectExpandClause.AllSelected)
                {
                    SelectedStructuralProperties = allStructuralProperties;
                    SelectedNavigationProperties = allNavigationProperties;
                    SelectedActions = allActions;
                }
                else
                {
                    BuildSelections(selectExpandClause, allStructuralProperties, allNavigationProperties, allActions);
                }

                BuildExpansions(selectExpandClause, allNavigationProperties);

                // remove expanded navigation properties from the selected navigation properties.
                SelectedNavigationProperties.ExceptWith(ExpandedNavigationProperties.Keys);
            }
        }

        /// <summary>
        /// Creates a new instance of the backing CLR object for the given entity type.
        /// </summary>
        /// <param name="entityType">The EDM type of the entity to create.</param>
        /// <param name="readContext">The deserializer context.</param>
        /// <returns>The created CLR object.</returns>
        public virtual object CreateEntityResource(IEdmEntityTypeReference entityType, ODataDeserializerContext readContext)
        {
            if (readContext == null)
            {
                throw Error.ArgumentNull("readContext");
            }
            if (entityType == null)
            {
                throw Error.ArgumentNull("entityType");
            }

            IEdmModel model = readContext.Model;
            if (model == null)
            {
                throw Error.Argument("readContext", SRResources.ModelMissingFromReadContext);
            }

            if (readContext.IsUntyped)
            {
                return new EdmEntityObject(entityType);
            }
            else
            {
                Type clrType = EdmLibHelpers.GetClrType(entityType, model);
                if (clrType == null)
                {
                    throw new ODataException(
                        Error.Format(SRResources.MappingDoesNotContainEntityType, entityType.FullName()));
                }

                if (readContext.IsDeltaOfT)
                {
                    IEnumerable<string> structuralProperties = entityType.StructuralProperties()
                        .Select(edmProperty => EdmLibHelpers.GetClrPropertyName(edmProperty, model));
                    return Activator.CreateInstance(readContext.ResourceType, clrType, structuralProperties);
                }
                else
                {
                    return Activator.CreateInstance(clrType);
                }
            }
        }

        private void BuildSelections(Selection selection, IEdmEntityTypeReference entityType, IEdmModel model)
        {
            Contract.Assert(entityType != null);
            Contract.Assert(model != null);

            HashSet<IEdmStructuralProperty> allStructuralProperties = new HashSet<IEdmStructuralProperty>(entityType.StructuralProperties());
            HashSet<IEdmNavigationProperty> allNavigationProperties = new HashSet<IEdmNavigationProperty>(entityType.NavigationProperties());
            HashSet<IEdmFunctionImport> allActions = new HashSet<IEdmFunctionImport>(model.GetAvailableProcedures(entityType.EntityDefinition()));

            if (selection == null || selection == AllSelection.Instance)
            {
                SelectedStructuralProperties = allStructuralProperties;
                SelectedNavigationProperties = allNavigationProperties;
                SelectedActions = allActions;
            }
            else if (selection == ExpansionsOnly.Instance)
            {
                // nothing to select.
            }
            else
            {
                PartialSelection partialSelection = selection as PartialSelection;
                if (partialSelection == null)
                {
                    throw new ODataException(Error.Format(SRResources.SelectionTypeNotSupported, selection.GetType().Name));
                }

                HashSet<IEdmStructuralProperty> selectedStructuralProperties = new HashSet<IEdmStructuralProperty>();
                HashSet<IEdmNavigationProperty> selectedNavigationProperties = new HashSet<IEdmNavigationProperty>();
                HashSet<IEdmFunctionImport> selectedActions = new HashSet<IEdmFunctionImport>();

                foreach (SelectionItem selectionItem in partialSelection.SelectedItems)
                {
                    PathSelectionItem pathSelection = selectionItem as PathSelectionItem;

                    if (pathSelection != null)
                    {
                        ValidatePathIsSupported(pathSelection.SelectedPath);
                        Segment segment = pathSelection.SelectedPath.LastSegment;

                        NavigationPropertySegment navigationPropertySegment = segment as NavigationPropertySegment;
                        if (navigationPropertySegment != null)
                        {
                            if (allNavigationProperties.Contains(navigationPropertySegment.NavigationProperty))
                            {
                                selectedNavigationProperties.Add(navigationPropertySegment.NavigationProperty);
                            }
                            continue;
                        }

                        PropertySegment structuralPropertySegment = segment as PropertySegment;
                        if (structuralPropertySegment != null)
                        {
                            if (allStructuralProperties.Contains(structuralPropertySegment.Property))
                            {
                                selectedStructuralProperties.Add(structuralPropertySegment.Property);
                            }
                            continue;
                        }

                        throw new ODataException(Error.Format(SRResources.SelectionTypeNotSupported, segment.GetType().Name));
                    }

                    WildcardSelectionItem wildCardSelection = selectionItem as WildcardSelectionItem;
                    if (wildCardSelection != null)
                    {
                        selectedStructuralProperties = allStructuralProperties;
                        selectedNavigationProperties = allNavigationProperties;
                        continue;
                    }

                    ContainerQualifiedWildcardSelectionItem wildCardActionSelection = selectionItem as ContainerQualifiedWildcardSelectionItem;
                    if (wildCardActionSelection != null)
                    {
                        IEnumerable<IEdmFunctionImport> actionsInThisContainer = allActions.Where(a => a.Container == wildCardActionSelection.Container);
                        foreach (IEdmFunctionImport action in actionsInThisContainer)
                        {
                            selectedActions.Add(action);
                        }
                        continue;
                    }

                    throw new ODataException(Error.Format(SRResources.SelectionTypeNotSupported, selectionItem.GetType().Name));
                }

                SelectedStructuralProperties = selectedStructuralProperties;
                SelectedNavigationProperties = selectedNavigationProperties;
                SelectedActions = selectedActions;
            }
        }