/// <summary>
/// Loads all members from a target model that implements <see cref="IDotNetContainer"/> 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, IDotNetMember> > FormatCSharpComparisonMembers(
this IDotNetContainer source, MemberComparisonType comparisonType = MemberComparisonType.Base)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (!source.Members.Any())
{
return(ImmutableList <KeyValuePair <int, IDotNetMember> > .Empty);
}
List <KeyValuePair <int, IDotNetMember> > result = new List <KeyValuePair <int, IDotNetMember> >();
var members = source.Members.Select(m =>
new KeyValuePair <int, IDotNetMember>(m.FormatCSharpMemberComparisonHashCode(comparisonType), m));
result.AddRange(members);
switch (source.ContainerType)
{
case DotNetContainerType.Interface:
var interfaceContainer = source as IDotNetInterface;
if (interfaceContainer?.InheritedInterfaces != null)
{
foreach (var inheritedInterface in interfaceContainer.InheritedInterfaces)
{
var interfaceMembers = inheritedInterface.FormatCSharpComparisonMembers(comparisonType);
if (interfaceMembers.Any())
{
result.AddRange(interfaceMembers);
}
}
}
break;
case DotNetContainerType.Class:
var classContainer = source as IDotNetClass;
if (classContainer?.BaseClass != null)
{
var baseMembers = classContainer.BaseClass.FormatCSharpComparisonMembers(comparisonType);
if (baseMembers.Any())
{
result.AddRange(baseMembers);
}
}
break;
}
return(result.ToImmutableArray());
}
/// <summary>
/// Creates a list of the interface members that are not implemented in the <see cref="IDotNetContainer"/> 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 <IDotNetMember> MissingContainerInterfaceMembers(IDotNetContainer source)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (source.ContainerType == DotNetContainerType.Interface)
{
return(ImmutableList <IDotNetMember> .Empty);
}
if (source.InheritedInterfaces == null)
{
return(ImmutableList <IDotNetMember> .Empty);
}
var sourceMembers = source.FormatCSharpComparisonMembers(MemberComparisonType.Security);
var interfaceMembers = new Dictionary <int, IDotNetMember>();
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 <IDotNetMember> .Empty);
}
return((from interfaceMember in interfaceMembers
where !sourceMembers.Any(m => m.Key == interfaceMember.Key)
select interfaceMember.Value).ToImmutableList());
}
