private object ResolveType(AssetIdentifier assetId, Assembly hintAssembly)
{
string typeName = assetId.AssetId.Substring(assetId.TypeMarker.Length + 1);
int startIndex = 0;
return(this.GetDeclaringType(typeName, ref startIndex, hintAssembly));
}
private MemberInfo ResolveMethod(AssetIdentifier assetId, Assembly hintAssembly)
{
string asset = assetId.AssetId.Substring(2);
int startIndex = 0;
Type type = this.GetDeclaringType(asset, ref startIndex, hintAssembly);
const BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance;
var allMethods =
type.GetMethods(bindingFlags)
.Concat <MethodBase>(type.GetConstructors(bindingFlags));
MethodBase[] methods =
allMethods.Where(
m =>
(m is ConstructorInfo &&
assetId.AssetId.Equals(Naming.GetAssetId((ConstructorInfo)m),
StringComparison.Ordinal)) ||
(m is MethodInfo &&
assetId.AssetId.Equals(Naming.GetAssetId((MethodInfo)m), StringComparison.Ordinal)))
.ToArray();
// if there is a "new" method on the type we'll find both it and the method it hides.
if (methods.Length == 2 && methods[1].DeclaringType == type)
{
return(methods[1]);
}
Debug.Assert(methods.Length == 1 || methods.Length == 2,
string.Format("Found {0} methods, expected 1 or 2.", methods.Length));
return(methods[0]);
}
private PropertyInfo ResolveProperty(AssetIdentifier assetId, Assembly hintAssembly)
{
string asset = assetId.AssetId.Substring(2);
int startIndex = 0;
Type type = this.GetDeclaringType(asset, ref startIndex, hintAssembly);
PropertyInfo[] allProps =
type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static |
BindingFlags.Instance);
PropertyInfo[] properties =
allProps
.Where(p => assetId.AssetId.Equals(Naming.GetAssetId(p), StringComparison.Ordinal))
.ToArray();
// if there is a "new" property on the type we'll find both it and the property it hides.
if (properties.Length == 2 && properties[1].DeclaringType == type)
{
return(properties[1]);
}
Debug.Assert(properties.Length == 1 || properties.Length == 2,
string.Format("Found {0} properties, expected 1 or 2.", properties.Length));
return(properties[0]);
}
private object ResolveField(AssetIdentifier assetIdentifier, Assembly hintAssembly)
{
string asset = assetIdentifier.AssetId.Substring(assetIdentifier.TypeMarker.Length + 1);
int startIndex = 0;
Type type = this.GetDeclaringType(asset, ref startIndex, hintAssembly);
if (type.IsEnum)
{
MemberInfo[] members =
type.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance |
BindingFlags.Static);
foreach (MemberInfo memberInfo in members)
{
AssetIdentifier ret = AssetIdentifier.FromMemberInfo(memberInfo);
if (ret.AssetId == assetIdentifier.AssetId)
{
return(memberInfo);
}
}
return(null);
}
else
{
FieldInfo[] allFields =
type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static |
BindingFlags.Instance);
return(allFields.Single(f => Naming.GetAssetId(f).Equals(assetIdentifier.AssetId)));
}
}
public bool AddReference(string assetId)
{
if (string.IsNullOrEmpty(assetId))
{
throw new ArgumentException("Argument cannot be null or empty.", "assetId");
}
AssetIdentifier aid = AssetIdentifier.Parse(assetId);
Debug.Assert(aid.ToString().Equals(assetId, StringComparison.Ordinal),
"AssetIdentifier '{0}' failed to roundtrip.", assetId);
if (aid.AssetId[aid.AssetId.Length - 1] == ']')
{
aid = new AssetIdentifier(aid.AssetId.Substring(0, aid.AssetId.LastIndexOf('[')),
aid.Version);
}
object resolve = this.AssetResolver.Resolve(aid);
Debug.Assert(resolve != null);
Debug.Assert(!string.IsNullOrWhiteSpace(aid.AssetId));
if (this._references.Add(aid))
{
TraceSources.GeneratorSource.TraceEvent(TraceEventType.Verbose, 1, "Reference: {0}", aid);
return(true);
}
return(false);
}
public bool Filter(IFilterContext context, AssetIdentifier asset)
{
Type t = context.AssetResolver.Resolve(asset) as Type;
if (t != null)
{
return(Filter(context, t));
}
return(false);
}
public bool Filter(IFilterContext context, AssetIdentifier asset)
{
MemberInfo mi = context.AssetResolver.Resolve(asset) as MemberInfo;
if (mi != null)
{
return(Filter(context, mi));
}
return(false);
}
public object Resolve(AssetIdentifier assetIdentifier, AssetIdentifier hintAssembly)
{
object ret;
if (!this._cache.TryGetValue(assetIdentifier, out ret))
{
this._cache.Add(assetIdentifier, ret = this.ResolveInternal(assetIdentifier, (Assembly)this.ResolveInternal(hintAssembly)));
}
return(ret);
}
private EventInfo ResolveEvent(AssetIdentifier assetIdentifier, Assembly hintAssembly)
{
string asset = assetIdentifier.AssetId.Substring(assetIdentifier.TypeMarker.Length + 1);
int startIndex = 0;
Type type = this.GetDeclaringType(asset, ref startIndex, hintAssembly);
EventInfo[] allEvents =
type.GetEvents(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static |
BindingFlags.Instance);
return(allEvents.Single(e => Naming.GetAssetId(e).Equals(assetIdentifier.AssetId)));
}
private MethodInfo[] ResolveOverloads(AssetIdentifier assetIdentifier, Assembly hintAssembly)
{
string asset = assetIdentifier.AssetId.Substring(assetIdentifier.TypeMarker.Length + 1);
int startIndex = 0;
Type type = this.GetDeclaringType(asset, ref startIndex, hintAssembly);
string methodName = asset.Substring(startIndex + 1);
var allMethods = type.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance);
return(allMethods
.Where(m => m.Name.Equals(methodName, StringComparison.Ordinal))
.ToArray());
}
public bool IsFiltered(AssetIdentifier assetId)
{
IFilterContext filterContext = new FilterContext(this.Cache, this.Container, this.AssetResolver, FilterState.Generating);
for (int i = 0; i < this._filters.Length; i++)
{
if (this._filters[i].Filter(filterContext, assetId))
{
TraceSources.GeneratorSource.TraceEvent(TraceEventType.Verbose,
0,
"{0} - Filtered by {1}",
assetId.AssetId, this._filters[i]);
return(true);
}
}
return(false);
}
public LostDocFileInfo(string path)
{
this._assemblies = new List <AssemblyInfo>();
this.Path = path;
XDocument xDoc = XDocument.Load(path);
foreach (XElement asmElement in xDoc.Root.Elements("assembly"))
{
// name="Company.Project.AnotherLibrary" filename="Company.Project.AnotherLibrary.dll" assetId="{A:Company.Project.AnotherLibrary, V:2.1.3.5670}"
this._assemblies.Add(new AssemblyInfo
{
Name = asmElement.Attribute("name").Value,
Filename = asmElement.Attribute("filename").Value,
AssetId = AssetIdentifier.Parse(asmElement.Attribute("assetId").Value),
Phase = int.Parse(asmElement.Attribute("phase").Value, CultureInfo.InvariantCulture),
});
}
}
private object ResolveAssembly(AssetIdentifier assetId, Assembly hintAssembly)
{
IEnumerable <Assembly> referencedAssemblies =
this._assemblyLoader.SelectMany(
a =>
a.GetReferencedAssemblies().Select(
n =>
Assembly.ReflectionOnlyLoad(n.FullName)));
IEnumerable <Assembly> assemblies = this._assemblyLoader.Concat(referencedAssemblies);
foreach (Assembly assembly in assemblies)
{
if (AssetIdentifier.FromAssembly(assembly).Equals(assetId))
{
return(assembly);
}
}
return(null);
}
private object ResolveInternal(AssetIdentifier assetIdentifier, Assembly hintAssembly = null)
{
switch (assetIdentifier.Type)
{
case AssetType.Unknown:
if (StringComparer.Ordinal.Equals("Overload", assetIdentifier.TypeMarker))
{
return(this.ResolveOverloads(assetIdentifier, hintAssembly));
}
throw new ArgumentException(string.Format("Type '{0}' not supported.", assetIdentifier.TypeMarker),
"assetIdentifier");
case AssetType.Namespace:
return(assetIdentifier.AssetId.Substring(assetIdentifier.TypeMarker.Length + 1));
case AssetType.Type:
return(this.ResolveType(assetIdentifier, hintAssembly));
case AssetType.Method:
return(this.ResolveMethod(assetIdentifier, hintAssembly));
case AssetType.Field:
return(this.ResolveField(assetIdentifier, hintAssembly));
case AssetType.Event:
return(this.ResolveEvent(assetIdentifier, hintAssembly));
case AssetType.Property:
return(this.ResolveProperty(assetIdentifier, hintAssembly));
case AssetType.Assembly:
return(this.ResolveAssembly(assetIdentifier, hintAssembly));
default:
throw new ArgumentOutOfRangeException();
}
}
public IEnumerable <AssetIdentifier> GetAssetHierarchy(AssetIdentifier assetId)
{
if (assetId.Type == AssetType.Unknown)
{
yield break;
}
yield return(assetId);
switch (assetId.Type)
{
case AssetType.Namespace:
string ns = (string)this.Resolve(assetId);
Assembly[] matchingAssemblies =
this._assemblyLoader.Where(a => a.GetName().Version == assetId.Version)
.Where(a => a.GetTypes().Any(
t1 =>
t1.Namespace != null &&
(StringComparer.Ordinal.Equals(t1.Namespace, ns) ||
t1.Namespace.StartsWith(ns + ".", StringComparison.Ordinal))))
.ToArray();
if (matchingAssemblies.Length == 0)
{
throw new InvalidOperationException("Found no assembly containing namespace: " + ns);
}
if (matchingAssemblies.Length > 1)
{
TraceSources.AssetResolverSource.TraceWarning(
"Namespace {0} found in more than one assembly: {1}",
ns,
string.Join(", ", matchingAssemblies.Select(a => a.GetName().Name)));
}
yield return(AssetIdentifier.FromAssembly(matchingAssemblies[0]));
break;
case AssetType.Type:
Type t = (Type)this.Resolve(assetId);
while (t.IsNested)
{
t = t.DeclaringType;
yield return(AssetIdentifier.FromMemberInfo(t));
}
yield return(AssetIdentifier.FromNamespace(t.Namespace, t.Assembly.GetName().Version));
yield return(AssetIdentifier.FromAssembly(t.Assembly));
break;
case AssetType.Method:
case AssetType.Field:
case AssetType.Event:
case AssetType.Property:
object resolve = this.Resolve(assetId);
MemberInfo mi = (MemberInfo)resolve;
foreach (
AssetIdentifier aid in
this.GetAssetHierarchy(AssetIdentifier.FromMemberInfo(mi.ReflectedType)))
{
yield return(aid);
}
break;
case AssetType.Assembly:
yield break;
default:
throw new ArgumentOutOfRangeException();
}
}
protected internal Type GetDeclaringType(string typeName, ref int startIndex, Assembly hintAssembly)
{
Type ret = null;
string[] fragments = typeName.Substring(startIndex).Split('.');
for (int i = 0; i < fragments.Length; i++)
{
int fragmentEndsAt = fragments[i].IndexOfAny(new[] { '{', '+' });
string fragment;
fragment = fragmentEndsAt == -1 ? fragments[i] : fragments[i].Substring(0, fragmentEndsAt);
if (ret == null)
{
string possibleTypeName = string.Join(".", fragments, 0, i);
if (possibleTypeName.Length <= 0)
{
possibleTypeName = fragment;
}
else
{
possibleTypeName += '.' + fragment;
}
if (this.TryGetType(possibleTypeName, hintAssembly, out ret))
{
startIndex += possibleTypeName.Length;
}
else if (fragmentEndsAt >= 0 &&
this.TryGetType(possibleTypeName + fragments[i].Substring(fragmentEndsAt), hintAssembly, out ret))
{
startIndex += possibleTypeName.Length + (fragments[i].Length - fragmentEndsAt);
fragmentEndsAt = -1;
}
}
else
{
Type nested = ret.GetNestedType(fragment, BindingFlags.Public | BindingFlags.NonPublic);
if (nested == null)
{
break;
}
ret = nested;
// +1 to account for the seperator that is requried for nested types
startIndex += fragment.Length + 1;
}
if (fragmentEndsAt != -1 && fragments[i][fragmentEndsAt] == '{')
{
Debug.Assert(ret != null);
AssetIdentifier[] typeArgs = AssetIdentifier.ParseTypeArgs(typeName, ref startIndex).ToArray();
Type[] genTypeArgs = new Type[typeArgs.Length];
for (int j = 0; j < typeArgs.Length; j++)
{
genTypeArgs[j] = (Type)this.ResolveType(typeArgs[j], hintAssembly);
}
ret = ret.MakeGenericType(genTypeArgs);
break;
}
}
return(ret);
}
public XDocument Merge(out AssetRedirectCollection assetRedirects)
{
// merge assemblies
Func <AssetIdentifier, string> keySelector;
assetRedirects = new AssetRedirectCollection();
if (this._ignoreVersionComponent.HasValue)
{
TraceSources.BundleSource.TraceInformation("Merging assembly sections with version mask: {0}",
this._ignoreVersionComponent.Value.ToString());
keySelector =
aId =>
string.Format("{0}, {1}",
aId.AssetId,
aId.Version.ToString((int)this._ignoreVersionComponent.Value));
IEnumerable <XElement> allAssemblies = this._bundle.Root.XPathSelectElements("assembly[@phase = '0']");
foreach (XElement asm in allAssemblies)
{
Debug.WriteLine(keySelector(AssetIdentifier.Parse(asm.Attribute("assetId").Value)));
}
IEnumerable <IOrderedEnumerable <XElement> > groupedAssemblies =
allAssemblies.GroupBy(xe => keySelector(AssetIdentifier.Parse(xe.Attribute("assetId").Value)),
(key, grp) =>
grp.OrderByDescending(
xe =>
AssetIdentifier.Parse(xe.Attribute("assetId").Value).
Version));
foreach (IOrderedEnumerable <XElement> assemblyGroup in groupedAssemblies)
{
XElement primary = assemblyGroup.First();
IEnumerable <XElement> rest = assemblyGroup.Skip(1);
IEnumerable <XAttribute> assetAttrs =
((IEnumerable)primary.XPathEvaluate(".//@assetId")).Cast <XAttribute>();
Dictionary <string, AssetIdentifier> assets =
assetAttrs.Select(a => AssetIdentifier.Parse(a.Value)).ToDictionary(a => a.AssetId);
TraceSources.BundleSource.TraceInformation("Primary assembly: " +
primary.Attribute("assetId").Value);
foreach (XElement secondary in rest)
{
TraceSources.BundleSource.TraceInformation("Shadowed assembly: " +
secondary.Attribute("assetId").Value);
secondary.Remove();
IEnumerable <XAttribute> secondaryAssetAttrs =
((IEnumerable)secondary.XPathEvaluate(".//@assetId")).Cast <XAttribute>();
IEnumerable <AssetIdentifier> secondaryAssets =
secondaryAssetAttrs.Select(a => AssetIdentifier.Parse(a.Value));
foreach (AssetIdentifier asset in secondaryAssets)
{
AssetIdentifier primaryAsset;
if (assets.TryGetValue(asset.AssetId, out primaryAsset))
{
assetRedirects.Add(asset, primaryAsset);
}
else
{
// warnings, we merged and lost an asset!
TraceSources.BundleSource.TraceWarning(
"Failed to redirect asset {0}, no matching asset found in assembly {1}",
asset.ToString(),
primary.Attribute("assetId"));
}
}
}
}
}
TraceSources.BundleSource.TraceInformation("Sorting assemblies by version.");
XElement[] asmElements =
this._bundle.Root.Elements().OrderByDescending(
e =>
AssetIdentifier.Parse(e.Attribute("assetId").Value).
Version).ToArray();
this._bundle.Root.RemoveNodes();
this._bundle.Root.Add(asmElements);
return(this._bundle);
}