private XElement CreateMemberElement(InvolvedTypeMember member)
{
MemberInfo memberInfo = member.MemberInfo;
var memberModifier = _memberModifierUtility.GetMemberModifiers(memberInfo);
if (memberModifier.Contains("private")) // memberModifier.Contains ("internal")
{
return(null);
}
var memberName = GetMemberName(memberInfo);
var attributes = new StringBuilder();
XElement overridesElement = null;
XElement overriddenElement = null;
if (_involvedType != null)
{
if (HasOverrideMixinAttribute(memberInfo))
{
attributes.Append("OverrideMixin ");
}
if (HasOverrideTargetAttribute(memberInfo))
{
attributes.Append("OverrideTarget ");
}
overridesElement = CreateOverridesElement(member);
overriddenElement = CreateOverriddenElement(member.MemberInfo);
}
if (memberInfo.DeclaringType != _type &&
overridesElement == null && overriddenElement == null)
{
return(null);
}
var element = new XElement("Member", new XAttribute("id", _memberIdentifierGenerator.GetIdentifier(memberInfo)),
new XAttribute("metadataToken", GetMetadataToken(memberInfo)),
new XAttribute("type", memberInfo.MemberType),
new XAttribute("name", memberName),
new XAttribute("is-declared-by-this-class", memberInfo.DeclaringType == _type),
_outputFormatter.CreateModifierMarkup(attributes.ToString(), memberModifier),
_memberSignatureUtility.GetMemberSignature(memberInfo),
member.SubMemberInfos.Select(CreateSubMemberElement),
overridesElement,
overriddenElement);
return(element);
}
private XElement CreateInvolvedTypeElement(InvolvedType involvedType)
{
var realType = involvedType.Type;
var element = new XElement(
"InvolvedType",
new XAttribute("id", _involvedTypeIdentifierGenerator.GetIdentifier(realType)),
new XAttribute("metadataToken", realType.MetadataToken),
new XAttribute("assembly-ref", _assemblyIdentifierGenerator.GetIdentifier(realType.Assembly)),
new XAttribute("namespace", realType.Namespace),
new XAttribute("name", _outputFormatter.GetShortFormattedTypeName(realType)),
new XAttribute("base", GetCSharpLikeNameForBaseType(realType)),
new XAttribute("base-ref", GetBaseReference(realType)),
new XAttribute("is-target", involvedType.IsTarget),
new XAttribute("is-mixin", involvedType.IsMixin),
new XAttribute("is-unusedmixin",
!involvedType.IsTarget && !involvedType.IsMixin &&
_remotionReflector.IsInheritedFromMixin(involvedType.Type) &&
!_remotionReflector.IsInfrastructureType(involvedType.Type)),
new XAttribute("is-generic-definition", realType.IsGenericTypeDefinition),
new XAttribute("is-interface", realType.IsInterface),
_outputFormatter.CreateModifierMarkup(GetAlphabeticOrderingAttribute(involvedType),
_typeModifierUtility.GetTypeModifiers(realType)),
_summaryPicker.GetSummary(realType),
new MemberReportGenerator(realType, involvedType, _involvedTypeIdentifierGenerator, _memberIdentifierGenerator,
_outputFormatter).GenerateXml(),
new InterfaceReferenceReportGenerator(
involvedType, _interfaceIdentifierGenerator, _remotionReflector).GenerateXml(),
new AttributeReferenceReportGenerator(
realType, _attributeIdentifierGenerator, _remotionReflector).GenerateXml(),
new MixinReferenceReportGenerator(
involvedType,
_assemblyIdentifierGenerator,
_involvedTypeIdentifierGenerator,
_interfaceIdentifierGenerator,
_attributeIdentifierGenerator,
_remotionReflector,
_outputFormatter).GenerateXml(),
new TargetReferenceReportGenerator(
involvedType, _involvedTypeIdentifierGenerator).GenerateXml()
);
if (realType.IsGenericType && !realType.IsGenericTypeDefinition)
{
element.Add(new XAttribute("generic-definition-ref",
_involvedTypeIdentifierGenerator.GetIdentifier(realType.GetGenericTypeDefinition())));
}
return(element);
}
public void GenerateXml_ForGenericTypeDefinition()
{
var involvedType1 = new InvolvedType(typeof(GenericTarget <,>));
var reportGenerator = CreateInvolvedTypeReportGenerator(involvedType1);
var output = reportGenerator.GenerateXml();
var expectedOutput = new XElement(
"InvolvedTypes",
new XElement(
"InvolvedType",
new XAttribute("id", "0"),
new XAttribute("assembly-ref", "0"),
new XAttribute("namespace", "MixinXRef.UnitTests.TestDomain"),
new XAttribute("name", "GenericTarget<TParameter1, TParameter2>"),
new XAttribute("base", "Object"),
new XAttribute("base-ref", "none"),
new XAttribute("is-target", false),
new XAttribute("is-mixin", false),
new XAttribute("is-unusedmixin", false),
new XAttribute("is-generic-definition", true),
new XAttribute("is-interface", false),
_outputFormatter.CreateModifierMarkup("", _typeModifierUtility.GetTypeModifiers(involvedType1.Type)),
_summaryPicker.GetSummary(involvedType1.Type),
new MemberReportGenerator(involvedType1.Type, null, null, _memberIdentifierGenerator, _outputFormatter).GenerateXml(),
new InterfaceReferenceReportGenerator(involvedType1, _interfaceIdentifierGenerator, _remotionReflector).GenerateXml(),
new AttributeReferenceReportGenerator(involvedType1.Type, _attributeIdentifierGenerator, _remotionReflector).GenerateXml(),
new MixinReferenceReportGenerator(
involvedType1, _assemblyIdentifierGenerator,
_readOnlyInvolvedTypeIdentifierGenerator,
_interfaceIdentifierGenerator,
_attributeIdentifierGenerator,
_remotionReflector,
_outputFormatter).
GenerateXml(),
new TargetReferenceReportGenerator(involvedType1, _readOnlyInvolvedTypeIdentifierGenerator).GenerateXml()
));
XElementComparisonHelper.Compare(output, expectedOutput);
}
public void GenerateXml_InterfaceWithMembers()
{
var reportGenerator = CreateMemberReportGenerator(typeof(IDisposable), null);
var output = reportGenerator.GenerateXml();
var expectedOutput = new XElement(
"Members",
new XElement(
"Member",
new XAttribute("id", "0"),
new XAttribute("type", MemberTypes.Method),
new XAttribute("name", "Dispose"),
new XAttribute("is-declared-by-this-class", true),
_outputFormatter.CreateModifierMarkup("", "public abstract"),
_outputFormatter.CreateMethodMarkup("Dispose", typeof(void), new ParameterInfo[0])
)
);
XElementComparisonHelper.Compare(output, expectedOutput);
}