public static bool HasPublicModifier(IProperty property)
        {
            try
            {
                if (property.Getter == null)
                {
                    return false;
                }

                var declaration = property.GetDeclarations().FirstOrDefault();
                if (declaration == null)
                {
                    return false;
                }

                var memberDeclaration = declaration as ICSharpTypeMemberDeclaration;
                if (memberDeclaration == null)
                {
                    return false;
                }

                return memberDeclaration.ModifiersList.Modifiers.Any(m => m.GetTokenType() == CSharpTokenType.PUBLIC_KEYWORD);
            }
            catch (Exception exn)
            {
                Debug.WriteLine(exn);
                return false;
            }
        }

 public override string PropertyDefinition(IProperty property)
 {
     bool hasTick = property.PropertyType.IsRef && !property.PropertyType.IsGenericTypeArg;
     StringBuilder sb = new StringBuilder("public:").AppendLine();
     sb.Append("property ").Append(TypeName(property.PropertyType)).Append(' ');
     if (hasTick)
         sb.Append('^');
     sb.Append(property.DisplayName).AppendLine(" {");
     if (property.HasGetter)
     {
         sb.Append(Tabulator).Append(TypeName(property.PropertyType)).Append(' ');
         if (hasTick)
             sb.Append('^');
         sb.AppendLine("get();");
     }
     if (property.HasSetter)
     {
         sb.Append(Tabulator);
         if (property.SetterAccess.HasValue && property.SetterAccess.Value == AccessModifier.Protected)
             sb.Append("protected: ");
         sb.Append("void set(")
             .Append(TypeName(property.PropertyType))
             .Append(' ');
         if (hasTick)
             sb.Append('^');
         sb.AppendLine("value);");
     }
     sb.Append("}");
     return sb.ToString();
 }

        private void ForeignKeyPropertyChangedAction(InternalEntityEntry entry, IProperty property, object oldValue, object newValue)
        {
            foreach (var foreignKey in entry.EntityType.GetForeignKeys().Where(p => p.Properties.Contains(property)).Distinct())
            {
                var navigations = _model.GetNavigations(foreignKey).ToList();

                var oldPrincipalEntry = entry.StateManager.GetPrincipal(entry.RelationshipsSnapshot, foreignKey);
                if (oldPrincipalEntry != null)
                {
                    Unfixup(navigations, oldPrincipalEntry, entry);
                }

                var principalEntry = entry.StateManager.GetPrincipal(entry, foreignKey);
                if (principalEntry != null)
                {
                    if (foreignKey.IsUnique)
                    {
                        var oldDependents = entry.StateManager.GetDependents(principalEntry, foreignKey).Where(e => e != entry).ToList();

                        // TODO: Decide how to handle case where multiple values found (negative case)
                        // Issue #739
                        if (oldDependents.Count > 0)
                        {
                            StealReference(foreignKey, oldDependents[0]);
                        }
                    }

                    DoFixup(navigations, principalEntry, new[] { entry });
                }
            }
        }

        public virtual async Task<object> NextAsync(StateEntry stateEntry, IProperty property, CancellationToken cancellationToken = default(CancellationToken))
        {
            Check.NotNull(stateEntry, "stateEntry");
            Check.NotNull(property, "property");

            var newValue = GetNextValue();

            // If the chosen value is outside of the current block then we need a new block.
            // It is possible that other threads will use all of the new block before this thread
            // gets a chance to use the new new value, so use a while here to do it all again.
            while (newValue.Current >= newValue.Max)
            {
                // Once inside the lock check to see if another thread already got a new block, in which
                // case just get a value out of the new block instead of requesting one.
                using (await _lock.LockAsync(cancellationToken))
                {
                    if (newValue.Max == _currentValue.Max)
                    {
                        var commandInfo = PrepareCommand(stateEntry.Configuration);

                        var newCurrent = (long)await _executor.ExecuteScalarAsync(commandInfo.Item1.DbConnection, commandInfo.Item1.DbTransaction, commandInfo.Item2, cancellationToken).ConfigureAwait(false);
                        newValue = new SequenceValue(newCurrent, newCurrent + _blockSize);
                        _currentValue = newValue;
                    }
                    else
                    {
                        newValue = GetNextValue();
                    }
                }
            }

            return Convert.ChangeType(newValue.Current, property.PropertyType);
        }

        public PropertyResult(IProperty source)
        {
            if (source == null) return;

            _alias = source.Alias;
            _value = source.Value;
        }

        public virtual FieldInfo TryMatchFieldName(
            IProperty property, PropertyInfo propertyInfo, Dictionary<string, FieldInfo> dclaredFields)
        {
            Check.NotNull(property, nameof(property));
            Check.NotNull(propertyInfo, nameof(propertyInfo));
            Check.NotNull(dclaredFields, nameof(dclaredFields));

            var propertyName = propertyInfo.Name;
            var propertyType = propertyInfo.PropertyType.GetTypeInfo();

            var camelized = char.ToLowerInvariant(propertyName[0]) + propertyName.Substring(1);

            FieldInfo fieldInfo;
            return (dclaredFields.TryGetValue(camelized, out fieldInfo)
                    && fieldInfo.FieldType.GetTypeInfo().IsAssignableFrom(propertyType))
                   || (dclaredFields.TryGetValue("_" + camelized, out fieldInfo)
                       && fieldInfo.FieldType.GetTypeInfo().IsAssignableFrom(propertyType))
                   || (dclaredFields.TryGetValue("_" + propertyName, out fieldInfo)
                       && fieldInfo.FieldType.GetTypeInfo().IsAssignableFrom(propertyType))
                   || (dclaredFields.TryGetValue("m_" + camelized, out fieldInfo)
                       && fieldInfo.FieldType.GetTypeInfo().IsAssignableFrom(propertyType))
                   || (dclaredFields.TryGetValue("m_" + propertyName, out fieldInfo)
                       && fieldInfo.FieldType.GetTypeInfo().IsAssignableFrom(propertyType))
                ? fieldInfo
                : null;
        }

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

        public virtual ValueGenerator GetOrAdd(IProperty property, Func<IProperty, ValueGenerator> factory)
        {
            Check.NotNull(property, nameof(property));
            Check.NotNull(factory, nameof(factory));

            return _cache.GetOrAdd(property, factory);
        }

        public virtual void ForeignKeyPropertyChanged(StateEntry entry, IProperty property, object oldValue, object newValue)
        {
            Check.NotNull(entry, "entry");
            Check.NotNull(property, "property");

            PerformFixup(() => ForeignKeyPropertyChangedAction(entry, property, oldValue, newValue));
        }

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

            return Convert.ChangeType(Interlocked.Increment(ref _current), property.PropertyType);
        }

 private static IValueGeneratorPool CreatePool(IProperty property, IValueGeneratorFactory factory)
 {
     var poolSize = factory.GetPoolSize(property);
     return poolSize == 1
         ? (IValueGeneratorPool)new SingleValueGeneratorPool(factory, property)
         : new ValueGeneratorPool(factory, property, poolSize);
 }

        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 override object Next(StateEntry entry, IProperty property)
        {
            Check.NotNull(entry, "entry");
            Check.NotNull(property, "property");

            return Guid.NewGuid();
        }

 IProperty WrapProperty(IProperty result)
 {
     if (result == null) return null;
     if (!(result is AlienOwnedProperty))
         return new AlienOwnedProperty(this, _realMember, result);
     return result;
 }

        public ParameterDescriptorImpl(IProperty property)
        {
            if (property == null) throw new ArgumentNullException("property");
            this.property = property;

            SetEnumerable();
        }

 public static IEnumerable<object> GetValues(IProperty property, bool isExploded = false)
 {
     if (isSimpleType(property.Type))
     {
         object result = property.Value;
         return new object[] { result };
     }
     else if (isListType(property.Type))
     {
         var result = (IEnumerable)property.Value;
         return result.Cast<object>().ToArray();
     }
     else
     {
         object instance = property.Value;
         var subProperties = PropertyLookup.CreatePropertyLookup(instance);
         List<object> values = new List<object>();
         foreach (IProperty subProperty in subProperties.GetProperties())
         {
             object value = subProperty.Value;
             if (isExploded)
             {
                 var pair = new Tuple<string, object>(subProperty.Name, value);
                 values.Add(pair);
             }
             else
             {
                 values.Add(subProperty.Name);
                 values.Add(value);
             }
         }
         return values.ToArray();
     }
 }

		public static int GetIcon(IProperty property)
		{
			if (property.IsIndexer)
				return IndexerIndex + GetModifierOffset(property.Modifiers);
			else
				return PropertyIndex + GetModifierOffset(property.Modifiers);
		}

        /// <summary>
        ///     Selects the appropriate value generator for a given property.
        /// </summary>
        /// <param name="property"> The property to get the value generator for. </param>
        /// <param name="entityType"> 
        ///     The entity type that the value generator will be used for. When called on inherited properties on derived entity types, 
        ///     this entity type may be different from the declared entity type on <paramref name="property" /> 
        /// </param>
        /// <returns> The value generator to be used. </returns>
        public virtual ValueGenerator Select(IProperty property, IEntityType entityType)
        {
            Check.NotNull(property, nameof(property));
            Check.NotNull(entityType, nameof(entityType));

            return Cache.GetOrAdd(property, entityType, Create);
        }

        protected static XElement GetOrUpdateProperty(XElement rootElement, IProperty property)
        {
            var propElem = rootElement.GetOrCreateElement("property", x => x.GetAttributeValue("name") == property.Name);
            propElem.SetAttributeValue("name", property.Name);      // todo: escape attribute values?

            var propertyValue = property.Value;
            if (propertyValue == null)
            {

            }
            else if (propertyValue is IXmlExportable)
            {
                var type = propertyValue.GetType();
                var typeString = type.FullName + ", " + type.Assembly.GetName().Name;

                var exportable = (IXmlExportable)propertyValue;
                propElem.SetAttributeValue("type", typeString);
                exportable.Export(propElem);
            }
            else
            {
                var value = propertyValue != null ? propertyValue.ToString() : null;
                propElem.SetAttributeValue("value", value);
            }
            return propElem;
        }

		public MemberNode(IProperty property)
		{
			InitMemberNode(property);
			sortOrder = 12;
			Text = AppendReturnType(GetAmbience().Convert(property), property.ReturnType);
			SelectedImageIndex = ImageIndex = ClassBrowserIconService.GetIcon(property).ImageIndex;
		}