C# IProperty.IsForeignKey方法代码示例

 public virtual RelationalTypeMapping GetTypeMapping(IProperty property)
     => GetTypeMapping(
         property.Relational().ColumnType,
         property.Relational().Column,
         property.ClrType.UnwrapNullableType(),
         property.IsKey() || property.IsForeignKey(),
         property.IsConcurrencyToken);

        public override object Next(StateEntry entry, IProperty property)
        {
            Check.NotNull(property, "property");

            Contract.Assert(property.IsForeignKey());

            var entityType = property.EntityType;
            var stateManager = entry.Configuration.StateManager;

            foreach (var foreignKey in entityType.ForeignKeys)
            {
                for (var propertyIndex = 0; propertyIndex < foreignKey.Properties.Count; propertyIndex++)
                {
                    if (property == foreignKey.Properties[propertyIndex])
                    {
                        foreach (var navigation in entityType.Navigations
                            .Concat(foreignKey.ReferencedEntityType.Navigations)
                            .Where(n => n.ForeignKey == foreignKey)
                            .Distinct())
                        {
                            var principal = TryFindPrincipal(stateManager, navigation, entry.Entity);

                            if (principal != null)
                            {
                                var principalEntry = stateManager.GetOrCreateEntry(principal);

                                return principalEntry[foreignKey.ReferencedProperties[propertyIndex]];
                            }
                        }
                    }
                }
            }

            return null;
        }

        public virtual void PropagateValue(InternalEntityEntry entry, IProperty property)
        {
            Debug.Assert(property.IsForeignKey());

            if (!TryPropagateValue(entry, property)
                && property.IsKey())
            {
                var valueGenerator = TryGetValueGenerator(property);

                if (valueGenerator != null)
                {
                    entry[property] = valueGenerator.Next();
                }
            }
        }

        public PropertyMetadata(IProperty property, Type dbContextType)
        {
            Contract.Assert(property != null);
            Contract.Assert(property.ClrType != null); //Do we need to make sure this is not called on Shadow properties?

            PropertyName = property.Name;
            TypeName = property.ClrType.FullName;

            IsPrimaryKey = property.IsPrimaryKey();
            // The old scaffolding has some logic for this property in an edge case which is
            // not clear if needed any more; see EntityFrameworkColumnProvider.DetermineIsForeignKeyComponent
            IsForeignKey = property.IsForeignKey();

            IsEnum = property.ClrType.GetTypeInfo().IsEnum;
            IsReadOnly = property.IsReadOnlyBeforeSave;
            IsAutoGenerated = property.IsStoreGeneratedAlways;

            ShortTypeName = TypeUtil.GetShortTypeName(property.ClrType);

            Scaffold = true;
            var reflectionProperty = property.DeclaringEntityType.ClrType.GetProperty(property.Name);
            if (reflectionProperty != null)
            {
                var scaffoldAttr = reflectionProperty.GetCustomAttribute(typeof(ScaffoldColumnAttribute)) as ScaffoldColumnAttribute;
                if (scaffoldAttr != null)
                {
                    Scaffold = scaffoldAttr.Scaffold;
                }
            }

            IsEnumFlags = false;
            if (IsEnum)
            {
                var flagsAttr = property.ClrType.GetTypeInfo().GetCustomAttribute(typeof(FlagsAttribute)) as FlagsAttribute;
                IsEnumFlags = (flagsAttr != null);
            }
        }

        private void DetectKeyChange(InternalEntityEntry entry, IProperty property, Sidecar snapshot)
        {
            if (!snapshot.HasValue(property))
            {
                return;
            }

            // TODO: Perf: make it fast to check if a property is part of any key
            var isPrimaryKey = property.IsPrimaryKey();
            var isPrincipalKey = _model.GetReferencingForeignKeys(property).Any();
            var isForeignKey = property.IsForeignKey();

            if (isPrimaryKey
                || isPrincipalKey
                || isForeignKey)
            {
                var snapshotValue = snapshot[property];
                var currentValue = entry[property];

                // Note that mutation of a byte[] key is not supported or detected, but two different instances
                // of byte[] with the same content must be detected as equal.
                if (!StructuralComparisons.StructuralEqualityComparer.Equals(currentValue, snapshotValue))
                {
                    if (isForeignKey)
                    {
                        entry.StateManager.Notify.ForeignKeyPropertyChanged(entry, property, snapshotValue, currentValue);
                    }

                    if (isPrimaryKey)
                    {
                        entry.StateManager.UpdateIdentityMap(entry, snapshot.GetPrimaryKeyValue());
                    }

                    if (isPrincipalKey)
                    {
                        entry.StateManager.Notify.PrincipalKeyPropertyChanged(entry, property, snapshotValue, currentValue);
                    }

                    snapshot.TakeSnapshot(property);
                }
            }
        }

        private bool DetectForeignKeyChange(StateEntry entry, IProperty property)
        {
            if (property.IsForeignKey())
            {
                var snapshotValue = entry.RelationshipsSnapshot[property];
                var currentValue = entry[property];

                // Note that mutation of a byte[] key is not supported or detected, but two different instances
                // of byte[] with the same content must be detected as equal.
                if (!StructuralComparisons.StructuralEqualityComparer.Equals(currentValue, snapshotValue))
                {
                    _notifier.ForeignKeyPropertyChanged(entry, property, snapshotValue, currentValue);

                    return true;
                }
            }

            return false;
        }