private static IEnumerable <XObject> GenerateAttributeArgument(IProcessingContext context,
CustomAttributeTypedArgument cata)
{
// TODO this needs to be cleaned up, and fixed
context.AddReference(AssetIdentifier.FromMemberInfo(cata.ArgumentType));
yield return(new XAttribute("type", AssetIdentifier.FromMemberInfo(cata.ArgumentType)));
if (cata.ArgumentType.IsEnum)
{
if (
cata.ArgumentType.GetCustomAttributesData().Any(
ca =>
ca.Constructor.DeclaringType ==
typeof(FlagsAttribute)))
{
string flags = Enum.ToObject(cata.ArgumentType, cata.Value).ToString();
string[] parts = flags.Split(',');
yield return
(new XElement("literal",
new XAttribute("value", cata.Value),
Array.ConvertAll(parts,
s => new XElement("flag", new XAttribute("value", s.Trim())))));
}
else
{
string value = Enum.GetName(cata.ArgumentType, cata.Value);
if (value != null)
{
yield return(new XElement("literal", new XAttribute("value", value)));
}
yield return(new XElement("literal", new XAttribute("value", cata.Value)));
}
}
else if (cata.ArgumentType == typeof(Type))
{
XElement tmp = new XElement("tmp");
DocGenerator.GenerateTypeRef(context.Clone(tmp), (Type)cata.Value, "value");
yield return(tmp.Attribute("value"));
foreach (XElement xElement in tmp.Elements())
{
yield return(xElement);
}
}
else // TODO fix how this encodes unprintable characters
{
yield return(new XAttribute("value", cata.Value.ToString().Replace("\0", "\\0")));
}
}
private void GenerateImplementsElement(IProcessingContext context, MemberInfo mInfo)
{
Type declaringType = mInfo.DeclaringType;
if (declaringType.IsGenericType && !declaringType.IsGenericTypeDefinition)
declaringType = declaringType.GetGenericTypeDefinition();
if (!declaringType.IsInterface)
{
Type[] interfaces = declaringType.GetInterfaces();
foreach (Type ifType in interfaces)
{
if (context.IsFiltered(AssetIdentifier.FromMemberInfo(ifType)))
continue;
InterfaceMapping ifMap = declaringType.GetInterfaceMap(ifType);
if (ifMap.TargetType != declaringType)
continue;
var targetMethod =
ifMap.TargetMethods.SingleOrDefault(mi => mi.MetadataToken == mInfo.MetadataToken &&
mi.Module == mInfo.Module);
if (targetMethod != null)
{
int mIx = Array.IndexOf(ifMap.TargetMethods, targetMethod);
AssetIdentifier miAid;
if (ifMap.InterfaceMethods[mIx].DeclaringType.IsGenericType)
{
Type declType = ifMap.InterfaceMethods[mIx].DeclaringType.GetGenericTypeDefinition();
MethodInfo[] allMethods =
declType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance |
BindingFlags.Static);
miAid =
AssetIdentifier.FromMemberInfo(allMethods.Single(mi =>
mi.MetadataToken == ifMap.InterfaceMethods[mIx].MetadataToken &&
mi.Module == ifMap.InterfaceMethods[mIx].Module));
}
else
{
miAid = AssetIdentifier.FromMemberInfo(ifMap.InterfaceMethods[mIx]);
}
context.Element.Add(new XElement("implements", new XAttribute("member", miAid)));
context.AddReference(miAid);
}
}
}
}
private XElement GenerateMethodElement(IProcessingContext context, AssetIdentifier assetId)
{
// Debug.Assert(context.Element.Name.LocalName != "type", "Cannot put Method into closed generic type");
MethodBase mBase = (MethodBase)context.AssetResolver.Resolve(assetId);
if (mBase is ConstructorInfo)
return this.GenerateConstructorElement(context, assetId);
MethodInfo mInfo = (MethodInfo)mBase;
string elemName;
if (this.IsOperator(mInfo))
elemName = "operator";
else
elemName = "method";
XElement ret = new XElement(elemName,
new XAttribute("name", mInfo.Name),
new XAttribute("assetId", assetId),
new XAttribute("phase", context.Phase));
context.Element.Add(ret);
Type declaringType = mInfo.DeclaringType;
if (declaringType.IsGenericType && !declaringType.IsGenericTypeDefinition)
declaringType = declaringType.GetGenericTypeDefinition();
MethodInfo realMethodInfo =
declaringType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance |
BindingFlags.Static).Single(
mi =>
mi.MetadataToken == mInfo.MetadataToken &&
mi.Module == mInfo.Module);
AssetIdentifier declaredAs = AssetIdentifier.FromMemberInfo(realMethodInfo);
if (declaringType != mInfo.ReflectedType)
{
ret.Add(new XAttribute("declaredAs", declaredAs));
context.AddReference(declaredAs);
}
else if (realMethodInfo.GetBaseDefinition() != realMethodInfo)
{
MethodInfo baseMethod = realMethodInfo.GetBaseDefinition();
if (baseMethod.ReflectedType.IsGenericType)
{
Type realTypeBase = baseMethod.ReflectedType.GetGenericTypeDefinition();
MethodInfo[] allMethods =
realTypeBase.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance |
BindingFlags.Static);
baseMethod =
allMethods.Single(
m =>
m.Module == baseMethod.Module && m.MetadataToken == baseMethod.MetadataToken);
}
declaredAs = AssetIdentifier.FromMemberInfo(baseMethod);
ret.Add(new XAttribute("overrides", declaredAs));
context.AddReference(declaredAs);
}
this.GenerateImplementsElement(context.Clone(ret), mInfo);
this.GenerateAccessModifiers(ret, mInfo);
if (mInfo.ContainsGenericParameters)
{
Type[] typeParams = mInfo.GetGenericArguments();
foreach (Type tp in typeParams)
this.GenerateTypeParamElement(context.Clone(ret), mInfo, tp);
}
foreach (IEnricher item in this.Enrichers)
item.EnrichMethod(context.Clone(ret), mInfo);
ParameterInfo[] methodParams = mInfo.GetParameters();
this.GenerateParameterElements(context.Clone(ret), methodParams);
if (mInfo.ReturnType != typeof(void))
{
XElement retElem = new XElement("returns");
GenerateTypeRef(context.Clone(retElem), mInfo.ReturnType);
foreach (IEnricher item in this.Enrichers)
item.EnrichReturnValue(context.Clone(retElem), mInfo);
ret.Add(retElem);
}
return ret;
}
private XElement GenerateTypeElement(IProcessingContext context, AssetIdentifier assetId)
{
XElement ret;
Type type = (Type)context.AssetResolver.Resolve(assetId);
string elemName;
if (type.IsClass)
elemName = "class";
else if (type.IsEnum)
elemName = "enum";
else if (type.IsValueType)
elemName = "struct";
else if (type.IsInterface)
elemName = "interface";
else
throw new ArgumentException("Unknown asset type: " + assetId.Type.ToString(), "assetId");
ret = new XElement(elemName,
new XAttribute("name", type.Name),
new XAttribute("assetId", assetId),
new XAttribute("phase", context.Phase));
if (type.IsEnum)
{
AssetIdentifier aid = AssetIdentifier.FromType(type.GetEnumUnderlyingType());
ret.Add(new XAttribute("underlyingType", aid));
context.AddReference(aid);
}
if (!type.IsInterface && type.IsAbstract)
ret.Add(new XAttribute("isAbstract", XmlConvert.ToString(type.IsAbstract)));
if (!type.IsVisible || type.IsNested && type.IsNestedAssembly)
ret.Add(new XAttribute("isInternal", XmlConvert.ToString(true)));
if (type.IsPublic || type.IsNested && type.IsNestedPublic)
ret.Add(new XAttribute("isPublic", XmlConvert.ToString(true)));
if (type.IsNested && type.IsNestedPrivate)
ret.Add(new XAttribute("isPrivate", XmlConvert.ToString(true)));
if (type.IsNested && type.IsNestedFamily)
ret.Add(new XAttribute("isProtected", XmlConvert.ToString(true)));
if (type.IsNested && type.IsNestedFamANDAssem)
ret.Add(new XAttribute("isProtectedAndInternal", XmlConvert.ToString(true)));
if (type.IsNested && type.IsNestedFamORAssem)
ret.Add(new XAttribute("isProtectedOrInternal", XmlConvert.ToString(true)));
if (type.IsClass && type.IsSealed)
ret.Add(new XAttribute("isSealed", XmlConvert.ToString(true)));
if (type.BaseType != null)
{
AssetIdentifier baseAid = AssetIdentifier.FromType(type.BaseType);
if (!context.IsFiltered(baseAid))
{
var inheritsElem = new XElement("inherits");
ret.Add(inheritsElem);
GenerateTypeRef(context.Clone(inheritsElem), type.BaseType);
}
}
if (type.ContainsGenericParameters)
{
Type[] typeParams = type.GetGenericArguments();
foreach (Type tp in typeParams)
{
this.GenerateTypeParamElement(context.Clone(ret), type, tp);
}
}
if (type.IsClass)
{
foreach (Type interfaceType in type.GetInterfaces())
{
InterfaceMapping mapping = type.GetInterfaceMap(interfaceType);
if (mapping.TargetType == type)
{
AssetIdentifier interfaceAssetId =
AssetIdentifier.FromType(interfaceType.IsGenericType
? interfaceType.GetGenericTypeDefinition()
: interfaceType);
if (!context.IsFiltered(interfaceAssetId))
{
var implElement = new XElement("implements");
ret.Add(implElement);
GenerateTypeRef(context.Clone(implElement), interfaceType, "interface");
}
}
}
}
foreach (IEnricher enricher in this._enrichers)
enricher.EnrichType(context.Clone(ret), type);
context.Element.Add(ret);
return ret;
}
public static void GenerateTypeRef(IProcessingContext context, Type pType, string attrName = null)
{
if (pType.IsArray)
{
var arrayElem = new XElement("arrayOf", new XAttribute("rank", pType.GetArrayRank()));
context.Element.Add(arrayElem);
GenerateTypeRef(context.Clone(arrayElem), pType.GetElementType());
}
else
{
if (pType.IsGenericParameter)
context.Element.Add(new XAttribute("param", pType.Name));
else if (pType.IsGenericType)
{
AssetIdentifier aid = AssetIdentifier.FromType(pType.GetGenericTypeDefinition());
context.AddReference(aid);
context.Element.Add(new XAttribute(attrName ?? "type", aid));
foreach (Type genArg in pType.GetGenericArguments())
{
XElement argElem = new XElement("with");
GenerateTypeRef(context.Clone(argElem), genArg);
context.Element.Add(argElem);
}
}
else
{
AssetIdentifier aid = AssetIdentifier.FromMemberInfo(pType);
context.AddReference(aid);
context.Element.Add(new XAttribute(attrName ?? "type", aid));
}
}
}
private static void GenerateAttributeElements(IProcessingContext context,
IEnumerable<CustomAttributeData> attrData)
{
foreach (CustomAttributeData custAttr in attrData)
{
context.AddReference(AssetIdentifier.FromMemberInfo(custAttr.Constructor));
var attrElem = new XElement("attribute",
new XAttribute("type",
AssetIdentifier.FromMemberInfo(
custAttr.Constructor.
ReflectedType ??
custAttr.Constructor.
DeclaringType)),
new XAttribute("constructor",
AssetIdentifier.FromMemberInfo(custAttr.Constructor)));
foreach (CustomAttributeTypedArgument cta in custAttr.ConstructorArguments)
{
if (cta.Value is ReadOnlyCollection<CustomAttributeTypedArgument>)
{
AssetIdentifier elementAssetId =
AssetIdentifier.FromMemberInfo(cta.ArgumentType.GetElementType());
context.AddReference(elementAssetId);
attrElem.Add(new XElement("argument",
new XElement("array",
new XAttribute("type", elementAssetId),
((IEnumerable<CustomAttributeTypedArgument>)cta.Value).
Select(
ata =>
new XElement("element",
GenerateAttributeArgument(
context,
ata))))));
}
else
{
attrElem.Add(new XElement("argument",
GenerateAttributeArgument(context, cta)));
}
}
foreach (CustomAttributeNamedArgument cta in custAttr.NamedArguments)
{
AssetIdentifier namedMember = AssetIdentifier.FromMemberInfo(cta.MemberInfo);
context.AddReference(namedMember);
if (cta.TypedValue.Value is ReadOnlyCollection<CustomAttributeTypedArgument>)
{
context.AddReference(namedMember);
AssetIdentifier elementAssetId =
AssetIdentifier.FromMemberInfo(cta.TypedValue.ArgumentType.GetElementType());
context.AddReference(elementAssetId);
attrElem.Add(new XElement("argument",
new XAttribute("member", namedMember),
new XElement("array",
new XAttribute("type", elementAssetId),
((IEnumerable<CustomAttributeTypedArgument>)
cta.TypedValue.Value).Select(
ata =>
new XElement("element",
GenerateAttributeArgument
(context,
ata))))));
}
else
{
attrElem.Add(new XElement("argument",
new XAttribute("member", namedMember),
GenerateAttributeArgument(context, cta.TypedValue)));
}
}
context.Element.Add(attrElem);
}
}
private static IEnumerable<XObject> GenerateAttributeArgument(IProcessingContext context,
CustomAttributeTypedArgument cata)
{
context.AddReference(AssetIdentifier.FromMemberInfo(cata.ArgumentType));
yield return new XAttribute("type", AssetIdentifier.FromMemberInfo(cata.ArgumentType));
if (cata.ArgumentType.IsEnum)
{
if (
cata.ArgumentType.GetCustomAttributesData().Any(
ca =>
ca.Constructor.DeclaringType ==
typeof(FlagsAttribute)))
{
var parts = GetEnumFlags(cata.ArgumentType, cata.Value).ToArray();
yield return
new XElement("enum",
Array.ConvertAll(parts,
s => new XElement("flag", new XAttribute("value", s.Trim()))));
}
else
{
var val = Enum.GetName(cata.ArgumentType, cata.Value) ?? "";
yield return
new XElement("enum", new XAttribute("value", val));
}
}
else if (cata.ArgumentType == typeof(Type))
{
XElement tmp = new XElement("tmp");
DocGenerator.GenerateTypeRef(context.Clone(tmp), (Type)cata.Value, "value");
yield return tmp.Attribute("value");
foreach (XElement xElement in tmp.Elements())
yield return xElement;
// yield return new XAttribute("value", AssetIdentifier.FromMemberInfo((Type)cata.Value));
}
else
yield return new XAttribute("value", cata.Value.ToString());
}
private XElement GenerateTypeElement(IProcessingContext context, Asset asset)
{
XElement ret;
Type type = (Type)asset.Target;
string elemName;
if (type.IsClass)
elemName = "class";
else if (type.IsEnum)
elemName = "enum";
else if (type.IsValueType)
elemName = "struct";
else if (type.IsInterface)
elemName = "interface";
else
throw new ArgumentException("Unknown asset type: " + asset.Type.ToString(), "asset");
//XTypeBuilder typeBuilder = new XTypeBuilder(type.Name, asset.Id, context.Phase);
//typeBuilder.A
//ret = typeBuilder.ToElement();
ret = new XElement(elemName,
new XAttribute("name", type.Name),
new XAttribute("assetId", asset.Id),
new XAttribute("phase", context.Phase));
if (type.IsEnum)
{
Type underlyingType = type.GetEnumUnderlyingType();
AssetIdentifier aid = AssetIdentifier.FromType(underlyingType);
ret.Add(new XAttribute("underlyingType", aid));
context.AddReference(new Asset(aid, underlyingType));
}
if (!type.IsInterface && type.IsAbstract)
ret.Add(new XAttribute("isAbstract", XmlConvert.ToString(type.IsAbstract)));
if (!type.IsVisible || type.IsNested && type.IsNestedAssembly)
ret.Add(new XAttribute("isInternal", XmlConvert.ToString(true)));
if (type.IsPublic || type.IsNested && type.IsNestedPublic)
ret.Add(new XAttribute("isPublic", XmlConvert.ToString(true)));
if (type.IsNested && type.IsNestedPrivate)
ret.Add(new XAttribute("isPrivate", XmlConvert.ToString(true)));
if (type.IsNested && type.IsNestedFamily)
ret.Add(new XAttribute("isProtected", XmlConvert.ToString(true)));
if (type.IsNested && type.IsNestedFamANDAssem)
ret.Add(new XAttribute("isProtectedAndInternal", XmlConvert.ToString(true)));
if (type.IsNested && type.IsNestedFamORAssem)
ret.Add(new XAttribute("isProtectedOrInternal", XmlConvert.ToString(true)));
if (type.IsClass && type.IsSealed)
ret.Add(new XAttribute("isSealed", XmlConvert.ToString(true)));
if (type.BaseType != null)
{
AssetIdentifier baseAid = AssetIdentifier.FromType(type.BaseType);
Asset baseAsset = new Asset(baseAid, type.BaseType);
if (!context.IsFiltered(baseAsset))
{
var inheritsElem = new XElement("inherits");
ret.Add(inheritsElem);
GenerateTypeRef(context.Clone(inheritsElem), type.BaseType);
}
}
if (type.ContainsGenericParameters)
{
Type[] typeParams = type.GetGenericArguments();
if (type.IsNested && type.DeclaringType.ContainsGenericParameters)
{
Type[] inheritedTypeParams = type.DeclaringType.GetGenericArguments();
Debug.Assert(typeParams.Length >= inheritedTypeParams.Length);
for (int paramPos = 0; paramPos < inheritedTypeParams.Length; paramPos++)
{
Debug.Assert(typeParams[paramPos].Name == inheritedTypeParams[paramPos].Name);
Debug.Assert(typeParams[paramPos].GenericParameterAttributes == inheritedTypeParams[paramPos].GenericParameterAttributes);
}
Type[] declaredTypeParams = new Type[typeParams.Length - inheritedTypeParams.Length];
for (int paramPos = inheritedTypeParams.Length; paramPos < typeParams.Length; paramPos++)
{
declaredTypeParams[paramPos - inheritedTypeParams.Length] = typeParams[paramPos];
}
typeParams = declaredTypeParams;
}
foreach (Type tp in typeParams)
{
this.GenerateTypeParamElement(context.Clone(ret), type, tp);
}
}
if (type.IsClass)
{
foreach (Type interfaceType in type.GetInterfaces())
{
InterfaceMapping mapping = type.GetInterfaceMap(interfaceType);
if (mapping.TargetMethods.Any(mi => mi.DeclaringType == type))
{
Type ifType = interfaceType.IsGenericType
? interfaceType.GetGenericTypeDefinition()
: interfaceType;
AssetIdentifier interfaceAssetId = AssetIdentifier.FromType(ifType);
Asset interfaceAsset = new Asset(interfaceAssetId, ifType);
if (!context.IsFiltered(interfaceAsset))
{
var implElement = new XElement("implements");
ret.Add(implElement);
GenerateTypeRef(context.Clone(implElement), interfaceType, "interface");
}
}
}
}
foreach (IEnricher enricher in this._enrichers)
enricher.EnrichType(context.Clone(ret), type);
context.Element.Add(ret);
return ret;
}
public static void GenerateTypeRef(IProcessingContext context, Type pType, string attrName = null)
{
// TODO rethink how we generate the typerefs, probably ensure we always output a root element rather than just the attribute for param/type
if (pType.IsArray)
{
// TODO arrayOf is the only capitalized element
var arrayElem = new XElement("arrayOf", new XAttribute("rank", pType.GetArrayRank()));
context.Element.Add(arrayElem);
GenerateTypeRef(context.Clone(arrayElem), pType.GetElementType());
}
else
{
if (pType.IsGenericParameter)
context.Element.Add(new XAttribute("param", pType.Name));
else if (pType.IsGenericType)
{
Type typeDefinition = pType.GetGenericTypeDefinition();
AssetIdentifier aid = AssetIdentifier.FromType(typeDefinition);
context.AddReference(new Asset(aid, typeDefinition));
context.Element.Add(new XAttribute(attrName ?? "type", aid));
foreach (Type genArg in pType.GetGenericArguments())
{
XElement argElem = new XElement("with");
GenerateTypeRef(context.Clone(argElem), genArg);
context.Element.Add(argElem);
}
}
else
{
AssetIdentifier aid = AssetIdentifier.FromMemberInfo(pType);
context.AddReference(new Asset(aid, pType));
context.Element.Add(new XAttribute(attrName ?? "type", aid));
}
}
}
protected virtual void GenerateAttributeElements(IProcessingContext context, IEnumerable<CustomAttributeData> attrData)
{
foreach (CustomAttributeData custAttr in attrData)
{
Type originatingType = custAttr.Constructor.ReflectedType
?? custAttr.Constructor.DeclaringType;
Asset typeAsset = ReflectionServices.GetAsset(originatingType);
if (context.IsFiltered(typeAsset))
continue;
Asset ctorAsset = ReflectionServices.GetAsset(custAttr.Constructor);
context.AddReference(ctorAsset);
var attrElem = new XElement("attribute",
new XAttribute("type", typeAsset.Id),
new XAttribute("constructor", ctorAsset.Id));
foreach (CustomAttributeTypedArgument cta in custAttr.ConstructorArguments)
{
XElement argElem = new XElement("argument");
this.GenerateValueLiteral(context.Clone(argElem), cta);
attrElem.Add(argElem);
}
foreach (CustomAttributeNamedArgument cta in custAttr.NamedArguments)
{
Asset asset = ReflectionServices.GetAsset(cta.MemberInfo);
context.AddReference(asset);
XElement argElem = new XElement("argument",
new XAttribute("member", asset.Id));
this.GenerateValueLiteral(context.Clone(argElem), cta.TypedValue);
attrElem.Add(argElem);
}
context.Element.Add(attrElem);
}
}
private static IEnumerable<XObject> GenerateAttributeArgument(IProcessingContext context,
CustomAttributeTypedArgument cata)
{
// TODO this needs to be cleaned up, and fixed
context.AddReference(AssetIdentifier.FromMemberInfo(cata.ArgumentType));
yield return new XAttribute("type", AssetIdentifier.FromMemberInfo(cata.ArgumentType));
if (cata.ArgumentType.IsEnum)
{
if (
cata.ArgumentType.GetCustomAttributesData().Any(
ca =>
ca.Constructor.DeclaringType ==
typeof(FlagsAttribute)))
{
string flags = Enum.ToObject(cata.ArgumentType, cata.Value).ToString();
string[] parts = flags.Split(',');
yield return
new XElement("literal",
new XAttribute("value", cata.Value),
Array.ConvertAll(parts,
s => new XElement("flag", new XAttribute("value", s.Trim()))));
}
else
{
string value = Enum.GetName(cata.ArgumentType, cata.Value);
if (value != null)
yield return new XElement("literal", new XAttribute("value", value));
yield return new XElement("literal", new XAttribute("value", cata.Value));
}
}
else if (cata.ArgumentType == typeof(Type))
{
XElement tmp = new XElement("tmp");
DocGenerator.GenerateTypeRef(context.Clone(tmp), (Type)cata.Value, "value");
yield return tmp.Attribute("value");
foreach (XElement xElement in tmp.Elements())
yield return xElement;
}
else // TODO fix how this encodes unprintable characters
yield return new XAttribute("value", cata.Value.ToString().Replace("\0", "\\0"));
}
// TODO fix this, and the accompanying XSLT template, the construction of attribute
// arguments isn't very consitent
private static void GenerateAttributeElements(IProcessingContext context,
IEnumerable <CustomAttributeData> attrData)
{
foreach (CustomAttributeData custAttr in attrData)
{
AssetIdentifier typeAssetId =
AssetIdentifier.FromMemberInfo(custAttr.Constructor.ReflectedType
?? custAttr.Constructor.DeclaringType);
if (context.IsFiltered(typeAssetId))
{
continue;
}
context.AddReference(AssetIdentifier.FromMemberInfo(custAttr.Constructor));
var attrElem = new XElement("attribute",
new XAttribute("type",
typeAssetId),
new XAttribute("constructor",
AssetIdentifier.FromMemberInfo(custAttr.Constructor)));
foreach (CustomAttributeTypedArgument cta in custAttr.ConstructorArguments)
{
if (cta.Value is ReadOnlyCollection <CustomAttributeTypedArgument> )
{
AssetIdentifier elementAssetId =
AssetIdentifier.FromMemberInfo(cta.ArgumentType.GetElementType());
context.AddReference(elementAssetId);
attrElem.Add(new XElement("argument",
new XElement("array",
new XAttribute("type", elementAssetId),
((IEnumerable <CustomAttributeTypedArgument>)cta.Value).
Select(
ata =>
new XElement("element",
GenerateAttributeArgument(
context,
ata))))));
}
else
{
attrElem.Add(new XElement("argument",
GenerateAttributeArgument(context, cta)));
}
}
foreach (CustomAttributeNamedArgument cta in custAttr.NamedArguments)
{
AssetIdentifier namedMember = AssetIdentifier.FromMemberInfo(cta.MemberInfo);
context.AddReference(namedMember);
if (cta.TypedValue.Value is ReadOnlyCollection <CustomAttributeTypedArgument> )
{
context.AddReference(namedMember);
AssetIdentifier elementAssetId =
AssetIdentifier.FromMemberInfo(cta.TypedValue.ArgumentType.GetElementType());
context.AddReference(elementAssetId);
attrElem.Add(new XElement("argument",
new XAttribute("member", namedMember),
new XElement("array",
new XAttribute("type", elementAssetId),
((IEnumerable <CustomAttributeTypedArgument>)
cta.TypedValue.Value).Select(
ata =>
new XElement("element",
GenerateAttributeArgument(context, ata))))));
}
else
{
attrElem.Add(new XElement("argument",
new XAttribute("member", namedMember),
GenerateAttributeArgument(context, cta.TypedValue)));
}
}
context.Element.Add(attrElem);
}
//using (var ms = new MemoryStream())
// context.Element.Save(ms);
}
