///<summary>
/// Returns a NamespaceMapEntry array given a xmlNamespace. Each
/// NamespaceMapEntry contains information the XamlTypeMapper uses for Mapping between an xml
/// XmlNamespace and what Assembly, Namespace to look in.
///</summary>
///<param name="xmlNamespace">
/// The xmlNamespace for the Map
///</param>
///<returns>
/// Returns an Array of NamespaceMapEntry
///</returns>
internal NamespaceMapEntry[] GetNamespaceMapEntries(string xmlNamespace)
{
NamespaceMapEntry[] namespaceMaps = null;
// check out hash and if already have resolved the Uri
// don't resolve again.
namespaceMaps = _namespaceMapHashList[xmlNamespace] as NamespaceMapEntry[];
if (null == namespaceMaps)
{
ArrayList namespaceMapArray = new ArrayList(6);
// this is the first time the XmlNamespace has been requested
// add items from the namespaceMap and then walk the assembly
// list to find matching items.
if (null != _namespaceMaps)
{
// need to find out the total number of entries by asking each hash
// review, may be better to sort these firt time through
// assumption here that the namespaceMap entries are small.
for (int i = 0; i < _namespaceMaps.Length; i++)
{
NamespaceMapEntry namespaceMap = _namespaceMaps[i];
if (namespaceMap.XmlNamespace == xmlNamespace)
{
namespaceMapArray.Add(namespaceMap);
}
}
}
List<ClrNamespaceAssemblyPair> namespaceAssemblyPair;
// Check for Processing instructions for mapping. If that fails,
// check for Xmlns definition files.
if (PITable.Contains(xmlNamespace))
{
namespaceAssemblyPair = new List<ClrNamespaceAssemblyPair>(1);
namespaceAssemblyPair.Add((ClrNamespaceAssemblyPair)PITable[xmlNamespace]);
}
else
{
namespaceAssemblyPair = GetClrNamespacePairFromCache(xmlNamespace);
}
// now walk through any using statements we got and add them
if (null != namespaceAssemblyPair)
{
for (int j = 0; j < namespaceAssemblyPair.Count; j++)
{
ClrNamespaceAssemblyPair mapping = namespaceAssemblyPair[j];
string usingAssemblyName = null;
string path = AssemblyPathFor(mapping.AssemblyName);
// using could either have an assembly or not, if it does
// have an assembly just need to add this one entry, if
// no assembly map in the referenced assemblies.
if (
#if PBTCOMPILER
mapping.LocalAssembly ||
#endif
(!(String.IsNullOrEmpty(mapping.AssemblyName)) && !(String.IsNullOrEmpty(mapping.ClrNamespace))) )
{
usingAssemblyName = mapping.AssemblyName;
NamespaceMapEntry nsMap = new NamespaceMapEntry(xmlNamespace,
usingAssemblyName,mapping.ClrNamespace,path);
#if PBTCOMPILER
nsMap.LocalAssembly = mapping.LocalAssembly;
// if xaml has local components, then it could have internals
// but there is no way to determine this until pass2. But we
// need to set this here in order to generate the InternalTypeHelper
// in pass1.
if (nsMap.LocalAssembly)
{
_hasLocalReference = true;
}
#endif
namespaceMapArray.Add(nsMap);
}
if (!String.IsNullOrEmpty(mapping.ClrNamespace))
{
// Also add in any assembly from the AssemblyNames collection
for (int k = 0; k < _assemblyNames.Length; k++)
{
if (usingAssemblyName == null)
{
namespaceMapArray.Add(new NamespaceMapEntry(xmlNamespace,
_assemblyNames[k],
mapping.ClrNamespace,
path));
}
else
{
// If we have a using Assembly, then only add assemblies from
// AssemblyNames that match the using Assembly.
int charIndex = _assemblyNames[k].LastIndexOf('\\');
if (charIndex > 0 &&
_assemblyNames[k].Substring(charIndex + 1) == usingAssemblyName)
{
namespaceMapArray.Add(new NamespaceMapEntry(xmlNamespace,
_assemblyNames[k],
mapping.ClrNamespace,
path));
}
}
}
}
}
}
// convert to a namespaceMap
namespaceMaps = (NamespaceMapEntry[]) namespaceMapArray.ToArray(typeof(NamespaceMapEntry));
// add to hash even if not items so we don't do this work again.
if (null != namespaceMaps)
{
_namespaceMapHashList.Add(xmlNamespace,namespaceMaps);
}
}
return namespaceMaps;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="assemblyNames">Assemblies XamlTypeMapper should use when resolving XAML</param>
/// <param name="namespaceMaps">NamespaceMap the XamlTypeMapper should use when resolving XAML</param>
public XamlTypeMapper(
string[] assemblyNames,
NamespaceMapEntry[] namespaceMaps)
{
if(null == assemblyNames)
{
throw new ArgumentNullException( "assemblyNames" );
}
_assemblyNames = assemblyNames;
_namespaceMaps = namespaceMaps;
#if PBTCOMPILER
_hasInternals = false;
_hasLocalReference = false;
#endif
}
/// <summary>
/// Return the Type that corresponds to a localName within a given clr namespace
/// in a given assembly
/// </summary>
/// <param name="namespaceMap">Specifies the CLR namespace and Assembly to look in</param>
/// <param name="localName">The name of the type</param>
/// <param name="knownTypesOnly">Search only known types</param>
/// <returns>Type of object that corresponds to localName</returns>
private Type GetObjectType(
NamespaceMapEntry namespaceMap,
string localName,
bool knownTypesOnly)
{
Debug.Assert(namespaceMap.ClrNamespace != null,"Null CLR Namespace");
Debug.Assert(localName != null,"Null localName");
Type type = null;
// Construct the full type name by concatenating the clr namespace and the local name
if (knownTypesOnly)
{
short typeID = BamlMapTable.GetKnownTypeIdFromName(namespaceMap.AssemblyName, namespaceMap.ClrNamespace, localName);
if (typeID != 0)
{
type = BamlMapTable.GetKnownTypeFromId(typeID);
}
}
else
{
Assembly assembly ;
#if PBTCOMPILER
try
{
#endif
// This may not work if the assembly is not present at compile time, so allow for that.
// At runtime it had better be there, so don't ignore it.
assembly = namespaceMap.Assembly;
#if PBTCOMPILER
}
catch (FileNotFoundException)
{
assembly = null;
}
#endif
if (null != assembly)
{
// Type loads may fail if all the prerequisite assemblies haven't been loaded
// yet. In this case, try one more time after loaded all assemblies that the
// compiler may have told the XamlTypeMapper about.
string fullTypeName = namespaceMap.ClrNamespace + "." + localName;
try
{
type = assembly.GetType(fullTypeName);
}
catch (Exception e)
{
if (CriticalExceptions.IsCriticalException(e))
{
throw;
}
else
{
if (LoadReferenceAssemblies())
{
try
{
type = assembly.GetType(fullTypeName);
}
catch (ArgumentException)
{
// A null type is allowable, and the caller will catch it
type = null;
}
}
}
}
}
}
return type;
}
private static bool IsInternalAllowedOnType(NamespaceMapEntry namespaceMap)
{
bool isInternalAllowed = namespaceMap.LocalAssembly || IsFriendAssembly(namespaceMap.Assembly);
_hasInternals = _hasInternals || isInternalAllowed;
return isInternalAllowed;
}
internal BamlWriterXamlTypeMapper(
string[] assemblyNames,
NamespaceMapEntry[] namespaceMaps) : base(assemblyNames, namespaceMaps)
{
}
public XamlTypeMapper(string[] assemblyNames, NamespaceMapEntry[] namespaceMaps)
{
}
// Returns a Hashtable of ns -> NamespaceMapEntry[] containing all mappings that are
// different from what would be returned by the shared context.
// We don't use _typeMapper.NamespaceMapHashList because we don't want to duplicate all
// the reflection done by the shared SchemaContext.
// Thread safety: we assume this is called on the parser thread, and so it's safe to
// iterate the _typeMapper's data structures.
internal Hashtable GetNamespaceMapHashList()
{
// Copy the ctor-provided namespace mappings into the result
Hashtable result = new Hashtable();
if (_typeMapper._namespaceMaps != null)
{
foreach (NamespaceMapEntry mapEntry in _typeMapper._namespaceMaps)
{
NamespaceMapEntry clone = new NamespaceMapEntry
{
XmlNamespace = mapEntry.XmlNamespace,
ClrNamespace = mapEntry.ClrNamespace,
AssemblyName = mapEntry.AssemblyName,
AssemblyPath = mapEntry.AssemblyPath
};
AddToMultiHashtable(result, mapEntry.XmlNamespace, clone);
}
}
// Copy the Mapping PIs into the result
foreach (DictionaryEntry piEntry in _typeMapper.PITable)
{
ClrNamespaceAssemblyPair mapping = (ClrNamespaceAssemblyPair)piEntry.Value;
NamespaceMapEntry mapEntry = new NamespaceMapEntry
{
XmlNamespace = (string)piEntry.Key,
ClrNamespace = mapping.ClrNamespace,
AssemblyName = mapping.AssemblyName,
AssemblyPath = _typeMapper.AssemblyPathFor(mapping.AssemblyName)
};
AddToMultiHashtable(result, mapEntry.XmlNamespace, mapEntry);
}
// Add any clr-namespaces that were resolved using custom assembly paths
lock (syncObject)
{
foreach (string clrNs in _clrNamespaces)
{
string clrNamespace, assembly;
SplitClrNsUri(clrNs, out clrNamespace, out assembly);
if (!string.IsNullOrEmpty(assembly))
{
string assemblyPath = _typeMapper.AssemblyPathFor(assembly);
if (!string.IsNullOrEmpty(assemblyPath))
{
NamespaceMapEntry mapEntry = new NamespaceMapEntry
{
XmlNamespace = clrNs,
ClrNamespace = clrNamespace,
AssemblyName = assembly,
AssemblyPath = assemblyPath
};
AddToMultiHashtable(result, mapEntry.XmlNamespace, mapEntry);
}
}
}
}
// Convert all the lists to arrays
object[] keys = new object[result.Count];
result.Keys.CopyTo(keys, 0);
foreach (object key in keys)
{
List <NamespaceMapEntry> list = (List <NamespaceMapEntry>)result[key];
result[key] = list.ToArray();
}
return(result);
}
