/// <summary>
        /// </summary>
        /// <param name="association"></param>
        /// <typeparam name="T"></typeparam>
        public static void UpdateAssociationAccessibility <T>(AssociationBase <T> association) where T : class
        {
            // Validate the properties Type Access.
            association.TypeAccess = GetAccessibilityModifier(association.TypeAccess, AccessibilityConstants.Public, true);

            association.GetterAccess = GetAccessibilityModifier(association.GetterAccess, AccessibilityConstants.Public, true);
            int getterModifierRank = AccessModifierRank.ContainsKey(association.GetterAccess) ? AccessModifierRank[association.GetterAccess] : AccessModifierRank[AccessibilityConstants.Private];

            association.SetterAccess = GetAccessibilityModifier(association.SetterAccess, AccessibilityConstants.Public, true);
            int setterModifierRank = AccessModifierRank.ContainsKey(association.SetterAccess) ? AccessModifierRank[association.SetterAccess] : AccessModifierRank[AccessibilityConstants.Private];

            int propertyModifierRank = Math.Min(getterModifierRank, setterModifierRank);

            if (getterModifierRank == propertyModifierRank)
            {
                association.GetterAccess = String.Empty;
            }

            if (setterModifierRank == propertyModifierRank)
            {
                association.SetterAccess = String.Empty;
            }

            // Set the type's rank based on the getter and setters modifier ranking.
            association.TypeAccess = AccessModifierRank.Where(m => m.Value == propertyModifierRank).Select(m => m.Key).First();
        }
Пример #2
0
        /// <summary>
        /// </summary>
        public void ValidateAllMembers()
        {
            if (Configuration.Instance.ExcludeForiegnKeyIdProperties)
            {
                List <string> keys = PropertyMap.Where(p => p.Value.IsType(PropertyType.Foreign)).Select(p => p.Key).ToList();
                foreach (string key in keys)
                {
                    PropertyMap.Remove(key);
                }
            }

            AssociationBase <T> .ValidateAssocationNames(this);

            List <DuplicateMemberHelper> members = PropertyMap.Values.Select(property => new DuplicateMemberHelper {
                Member = property,
                Name   = property.Name
            }).ToList();

            members.AddRange(AssociationMap.Values.Select(association => new DuplicateMemberHelper {
                Member = association,
                Name   = association.Name
            }));
            foreach (DuplicateMemberHelper member in members)
            {
                DuplicateMemberHelper[] duplicates = members.Where(m => m.Name == member.Name).ToArray();

                if (duplicates.Length <= 1)
                {
                    continue;
                }

                for (int i = 0; i < duplicates.Length; i++)
                {
                    duplicates[i].AppendNameSuffix(i + 1);
                }
            }
        }