コード例 #1
0
        /// <summary>
        /// Loads all members from a target model that implements <see cref="CsContainer"/> and returns all members and the comparison hash code for each member.
        /// </summary>
        /// <param name="source">The target container to load members from.</param>
        /// <param name="comparisonType">The type of hash code to build for comparision. Default comparison type is set to the base comparison. </param>
        /// <returns>List of all the hash codes and the members for each hashcode.</returns>
        /// <exception cref="ArgumentNullException">Thrown if the source container is null.</exception>
        public static IReadOnlyList <KeyValuePair <int, CsMember> > FormatCSharpComparisonMembers(
            this CsContainer source, MemberComparisonType comparisonType = MemberComparisonType.Base)
        {
            if (source == null)
            {
                throw new ArgumentNullException(nameof(source));
            }

            if (!source.Members.Any())
            {
                return(ImmutableList <KeyValuePair <int, CsMember> > .Empty);
            }

            List <KeyValuePair <int, CsMember> > result = new List <KeyValuePair <int, CsMember> >();

            var members = source.Members.Select(m =>
                                                new KeyValuePair <int, CsMember>(m.FormatCSharpMemberComparisonHashCode(comparisonType), m));

            result.AddRange(members);

            switch (source.ContainerType)
            {
            case CsContainerType.Interface:

                var interfaceContainer = source as ICsInterface;

                if (interfaceContainer?.InheritedInterfaces != null)
                {
                    foreach (var inheritedInterface in interfaceContainer.InheritedInterfaces)
                    {
                        var interfaceMembers = inheritedInterface.FormatCSharpComparisonMembers(comparisonType);
                        if (interfaceMembers.Any())
                        {
                            result.AddRange(interfaceMembers);
                        }
                    }
                }

                break;

            case CsContainerType.Class:

                var classContainer = source as ICsClass;

                if (classContainer?.BaseClass != null)
                {
                    var baseMembers = classContainer.BaseClass.FormatCSharpComparisonMembers(comparisonType);

                    if (baseMembers.Any())
                    {
                        result.AddRange(baseMembers);
                    }
                }

                break;
            }

            return(result.ToImmutableArray());
        }
コード例 #2
0
        /// <summary>
        /// Creates a list of the interface members that are not implemented in the <see cref="ICsContainer"/> model.
        /// </summary>
        /// <param name="source">The source model to check.</param>
        /// <returns>List of models that are missing or an empty list if there are no missing members.</returns>
        /// <exception cref="ArgumentNullException">Throws an argument null exception if the model does not exist.</exception>
        private static IReadOnlyList <CsMember> MissingContainerInterfaceMembers(CsContainer source)
        {
            if (source == null)
            {
                throw new ArgumentNullException(nameof(source));
            }

            if (source.ContainerType == CsContainerType.Interface)
            {
                return(ImmutableList <CsMember> .Empty);
            }
            if (source.InheritedInterfaces == null)
            {
                return(ImmutableList <CsMember> .Empty);
            }

            var sourceMembers = source.FormatCSharpComparisonMembers(MemberComparisonType.Security);

            var interfaceMembers = new Dictionary <int, CsMember>();

            foreach (var inheritedInterface in source.InheritedInterfaces)
            {
                var compareMembers = inheritedInterface.FormatCSharpComparisonMembers(MemberComparisonType.Security);
                if (!compareMembers.Any())
                {
                    continue;
                }

                foreach (var compareMember in compareMembers)
                {
                    if (!interfaceMembers.ContainsKey(compareMember.Key))
                    {
                        interfaceMembers.Add(compareMember.Key, compareMember.Value);
                    }
                }
            }

            if (!interfaceMembers.Any())
            {
                return(ImmutableList <CsMember> .Empty);
            }

            return((from interfaceMember in interfaceMembers
                    // ReSharper disable once SimplifyLinqExpression
                    where !sourceMembers.Any(m => m.Key == interfaceMember.Key)
                    select interfaceMember.Value).ToImmutableList());
        }
コード例 #3
0
        /// <summary>
        /// Checks a type definition to see if it inherits a target interface.
        /// </summary>
        /// <param name="source">Type to check for inheritance </param>
        /// <param name="interfaceName">The name of the interface</param>
        /// <param name="interfaceNamespace">Optional parameter that contains the target namespace for the interface.</param>
        /// <returns>True if inherited or false if not.</returns>
        public static bool InheritsInterface(this CsType source, string interfaceName,
                                             string interfaceNamespace = null)
        {
            if (source == null)
            {
                return(false);
            }
            if (!source.IsLoaded)
            {
                return(false);
            }
            if (!source.IsClass & !source.IsStructure)
            {
                return(false);
            }

            CsContainer containerData = source.IsClass ? source.GetClassModel() as CsContainer
                : source.GetStructureModel() as CsContainer;

            if (containerData == null)
            {
                return(false);
            }
            if (!containerData.IsLoaded)
            {
                return(false);
            }
            if (!containerData.InheritedInterfaces.Any())
            {
                return(false);
            }

            var interfaceData = interfaceNamespace == null
                ? containerData.InheritedInterfaces.FirstOrDefault(i => interfaceName == i.Name)
                : containerData.InheritedInterfaces.FirstOrDefault(i =>
                                                                   (interfaceNamespace == i.Namespace & interfaceName == i.Name));

            return(interfaceData != null);
        }