mirror of
https://github.com/ZuneDev/ZuneShell.dll.git
synced 2026-07-27 13:11:51 -07:00
359 lines
18 KiB
C#
359 lines
18 KiB
C#
// Decompiled with JetBrains decompiler
|
|
// Type: Microsoft.Iris.Markup.AssemblyLoadResult
|
|
// Assembly: UIX, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
|
|
// MVID: A56C6C9D-B7F6-46A9-8BDE-B3D9B8D60B11
|
|
// Assembly location: C:\Program Files\Zune\UIX.dll
|
|
|
|
using Microsoft.Iris.Drawing;
|
|
using Microsoft.Iris.Library;
|
|
using Microsoft.Iris.Markup.UIX;
|
|
using Microsoft.Iris.ModelItems;
|
|
using Microsoft.Iris.Session;
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using System.Runtime.InteropServices;
|
|
|
|
namespace Microsoft.Iris.Markup
|
|
{
|
|
internal class AssemblyLoadResult : LoadResult
|
|
{
|
|
private const string c_AssemblyProtocol = "assembly://";
|
|
private Assembly _assembly;
|
|
private string _namespace;
|
|
private string _namespacePrefix;
|
|
public static TypeSchema ObjectTypeSchema;
|
|
public static TypeSchema ListTypeSchema;
|
|
public static TypeSchema EnumeratorTypeSchema;
|
|
public static TypeSchema DictionaryTypeSchema;
|
|
public static TypeSchema CommandTypeSchema;
|
|
public static TypeSchema ValueRangeTypeSchema;
|
|
private static Map s_typeCache = new Map(32);
|
|
private static Map<AssemblyLoadResult.MapAssemblyKey, AssemblyLoadResult> s_assemblyCache = new Map<AssemblyLoadResult.MapAssemblyKey, AssemblyLoadResult>();
|
|
|
|
private static LoadResult Create(string uri)
|
|
{
|
|
LoadResult loadResult = null;
|
|
string valueName = uri.Substring("assembly://".Length);
|
|
if (valueName.IndexOf('/') == -1)
|
|
{
|
|
ErrorManager.ReportError("Invalid assembly reference '{0}'. URI must contain a forward slash after the assembly name", uri);
|
|
return null;
|
|
}
|
|
string leftName;
|
|
string rightName;
|
|
SplitAtLastWhack(valueName, out leftName, out rightName);
|
|
AssemblyName name = null;
|
|
try
|
|
{
|
|
name = new AssemblyName(leftName);
|
|
}
|
|
catch (COMException ex)
|
|
{
|
|
}
|
|
catch (FileLoadException ex)
|
|
{
|
|
}
|
|
if (name == null)
|
|
{
|
|
name = new AssemblyName();
|
|
name.CodeBase = leftName;
|
|
}
|
|
if (name != null)
|
|
{
|
|
Exception assemblyLoadException;
|
|
Assembly assembly = FindAssembly(name, out assemblyLoadException);
|
|
if (assembly != null)
|
|
loadResult = MapAssembly(assembly, rightName);
|
|
else if (assemblyLoadException != null)
|
|
ErrorManager.ReportError("Failure loading assembly: '{0}'", assemblyLoadException.Message);
|
|
else
|
|
ErrorManager.ReportError("Failure loading assembly");
|
|
}
|
|
return loadResult;
|
|
}
|
|
|
|
public static void Startup()
|
|
{
|
|
AssemblyObjectProxyHelper.InitializeStatics();
|
|
MarkupSystem.RegisterFactoryByProtocol("assembly://", new CreateLoadResultHandler(Create));
|
|
Map typeCache1 = s_typeCache;
|
|
Type type1 = typeof(object);
|
|
FrameworkCompatibleAssemblyPrimitiveTypeSchema primitiveTypeSchema;
|
|
ObjectTypeSchema = primitiveTypeSchema = new FrameworkCompatibleAssemblyPrimitiveTypeSchema(ObjectSchema.Type);
|
|
TypeSchema typeA1 = primitiveTypeSchema;
|
|
typeCache1[type1] = primitiveTypeSchema;
|
|
TypeSchema.RegisterTwoWayEquivalence(typeA1, ObjectSchema.Type);
|
|
TypeSchema.RegisterTwoWayEquivalence((TypeSchema)(s_typeCache[typeof(void)] = new FrameworkCompatibleAssemblyPrimitiveTypeSchema(VoidSchema.Type)), VoidSchema.Type);
|
|
TypeSchema.RegisterTwoWayEquivalence((TypeSchema)(s_typeCache[typeof(bool)] = new FrameworkCompatibleAssemblyPrimitiveTypeSchema(BooleanSchema.Type)), BooleanSchema.Type);
|
|
TypeSchema.RegisterTwoWayEquivalence((TypeSchema)(s_typeCache[typeof(byte)] = new FrameworkCompatibleAssemblyPrimitiveTypeSchema(ByteSchema.Type)), ByteSchema.Type);
|
|
TypeSchema.RegisterTwoWayEquivalence((TypeSchema)(s_typeCache[typeof(char)] = new FrameworkCompatibleAssemblyPrimitiveTypeSchema(CharSchema.Type)), CharSchema.Type);
|
|
TypeSchema.RegisterTwoWayEquivalence((TypeSchema)(s_typeCache[typeof(double)] = new FrameworkCompatibleAssemblyPrimitiveTypeSchema(DoubleSchema.Type)), DoubleSchema.Type);
|
|
TypeSchema.RegisterTwoWayEquivalence((TypeSchema)(s_typeCache[typeof(string)] = new FrameworkCompatibleAssemblyPrimitiveTypeSchema(StringSchema.Type)), StringSchema.Type);
|
|
TypeSchema.RegisterTwoWayEquivalence((TypeSchema)(s_typeCache[typeof(float)] = new FrameworkCompatibleAssemblyPrimitiveTypeSchema(SingleSchema.Type)), SingleSchema.Type);
|
|
TypeSchema.RegisterTwoWayEquivalence((TypeSchema)(s_typeCache[typeof(int)] = new FrameworkCompatibleAssemblyPrimitiveTypeSchema(Int32Schema.Type)), Int32Schema.Type);
|
|
TypeSchema.RegisterTwoWayEquivalence((TypeSchema)(s_typeCache[typeof(long)] = new FrameworkCompatibleAssemblyPrimitiveTypeSchema(Int64Schema.Type)), Int64Schema.Type);
|
|
Map typeCache2 = s_typeCache;
|
|
Type type2 = typeof(IList);
|
|
FrameworkCompatibleAssemblyTypeSchema assemblyTypeSchema1;
|
|
ListTypeSchema = assemblyTypeSchema1 = new FrameworkCompatibleAssemblyTypeSchema(typeof(IList), typeof(IList), typeof(ArrayList));
|
|
TypeSchema typeA2 = assemblyTypeSchema1;
|
|
typeCache2[type2] = assemblyTypeSchema1;
|
|
TypeSchema.RegisterTwoWayEquivalence(typeA2, ListSchema.Type);
|
|
Map typeCache3 = s_typeCache;
|
|
Type type3 = typeof(IEnumerator);
|
|
FrameworkCompatibleAssemblyTypeSchema assemblyTypeSchema2;
|
|
EnumeratorTypeSchema = assemblyTypeSchema2 = new FrameworkCompatibleAssemblyTypeSchema(typeof(IEnumerator), typeof(IEnumerator));
|
|
TypeSchema typeA3 = assemblyTypeSchema2;
|
|
typeCache3[type3] = assemblyTypeSchema2;
|
|
TypeSchema.RegisterTwoWayEquivalence(typeA3, EnumeratorSchema.Type);
|
|
Map typeCache4 = s_typeCache;
|
|
Type type4 = typeof(IDictionary);
|
|
FrameworkCompatibleAssemblyTypeSchema assemblyTypeSchema3;
|
|
DictionaryTypeSchema = assemblyTypeSchema3 = new FrameworkCompatibleAssemblyTypeSchema(typeof(IDictionary), AssemblyObjectProxyHelper.ProxyDictionaryType, typeof(Dictionary<object, object>));
|
|
TypeSchema producer1 = assemblyTypeSchema3;
|
|
typeCache4[type4] = assemblyTypeSchema3;
|
|
TypeSchema.RegisterOneWayEquivalence(producer1, DictionarySchema.Type);
|
|
Map typeCache5 = s_typeCache;
|
|
Type type5 = typeof(ICommand);
|
|
FrameworkCompatibleAssemblyTypeSchema assemblyTypeSchema4;
|
|
CommandTypeSchema = assemblyTypeSchema4 = new FrameworkCompatibleAssemblyTypeSchema(typeof(ICommand), AssemblyObjectProxyHelper.ProxyCommandType);
|
|
TypeSchema producer2 = assemblyTypeSchema4;
|
|
typeCache5[type5] = assemblyTypeSchema4;
|
|
TypeSchema.RegisterOneWayEquivalence(producer2, CommandSchema.Type);
|
|
Map typeCache6 = s_typeCache;
|
|
Type type6 = typeof(IValueRange);
|
|
FrameworkCompatibleAssemblyTypeSchema assemblyTypeSchema5;
|
|
ValueRangeTypeSchema = assemblyTypeSchema5 = new FrameworkCompatibleAssemblyTypeSchema(typeof(IValueRange), AssemblyObjectProxyHelper.ProxyValueRangeType);
|
|
TypeSchema producer3 = assemblyTypeSchema5;
|
|
typeCache6[type6] = assemblyTypeSchema5;
|
|
TypeSchema.RegisterOneWayEquivalence(producer3, ValueRangeSchema.Type);
|
|
TypeSchema.RegisterOneWayEquivalence((TypeSchema)(s_typeCache[typeof(Group)] = new FrameworkCompatibleAssemblyTypeSchema(typeof(Group), typeof(IUIGroup))), GroupSchema.Type);
|
|
TypeSchema.RegisterOneWayEquivalence((TypeSchema)(s_typeCache[typeof(Image)] = new FrameworkCompatibleAssemblyTypeSchema(typeof(Image), typeof(UIImage))), ImageSchema.Type);
|
|
TypeSchema.RegisterOneWayEquivalence((TypeSchema)(s_typeCache[typeof(Type)] = new FrameworkCompatibleAssemblyTypeSchema(typeof(Type), typeof(TypeSchema), null, ObjectTypeSchema)), TypeSchemaDefinition.Type);
|
|
TypeSchema.RegisterOneWayEquivalence((TypeSchema)(s_typeCache[typeof(VideoStream)] = new FrameworkCompatibleAssemblyTypeSchema(typeof(VideoStream))), VideoStreamSchema.Type);
|
|
TypeSchema producer4;
|
|
s_typeCache[typeof(Microsoft.Iris.Choice)] = (FrameworkCompatibleAssemblyTypeSchema)(producer4 = new FrameworkCompatibleAssemblyTypeSchema(typeof(Microsoft.Iris.Choice)));
|
|
TypeSchema.RegisterOneWayEquivalence(producer4, ChoiceSchema.Type);
|
|
TypeSchema.RegisterOneWayEquivalence(producer4, ValueRangeSchema.Type);
|
|
TypeSchema.RegisterOneWayEquivalence((TypeSchema)(s_typeCache[typeof(Microsoft.Iris.BooleanChoice)] = new FrameworkCompatibleAssemblyTypeSchema(typeof(Microsoft.Iris.BooleanChoice))), BooleanChoiceSchema.Type);
|
|
TypeSchema producer5;
|
|
s_typeCache[typeof(Microsoft.Iris.RangedValue)] = (FrameworkCompatibleAssemblyTypeSchema)(producer5 = new FrameworkCompatibleAssemblyTypeSchema(typeof(Microsoft.Iris.RangedValue)));
|
|
TypeSchema.RegisterOneWayEquivalence(producer5, RangedValueSchema.Type);
|
|
TypeSchema.RegisterOneWayEquivalence(producer5, ValueRangeSchema.Type);
|
|
TypeSchema.RegisterOneWayEquivalence((TypeSchema)(s_typeCache[typeof(Microsoft.Iris.IntRangedValue)] = new FrameworkCompatibleAssemblyTypeSchema(typeof(Microsoft.Iris.IntRangedValue))), IntRangedValueSchema.Type);
|
|
TypeSchema.RegisterOneWayEquivalence((TypeSchema)(s_typeCache[typeof(Microsoft.Iris.ByteRangedValue)] = new FrameworkCompatibleAssemblyTypeSchema(typeof(Microsoft.Iris.ByteRangedValue))), ByteRangedValueSchema.Type);
|
|
TypeSchema.RegisterTwoWayEquivalence((TypeSchema)(s_typeCache[typeof(DataProviderQuery)] = new FrameworkCompatibleAssemblyTypeSchema(typeof(DataProviderQuery), typeof(MarkupDataQuery))), MarkupDataQueryInstanceSchema.Type);
|
|
TypeSchema.RegisterTwoWayEquivalence((TypeSchema)(s_typeCache[typeof(DataProviderObject)] = new FrameworkCompatibleAssemblyTypeSchema(typeof(DataProviderObject), typeof(MarkupDataType))), MarkupDataTypeInstanceSchema.Type);
|
|
TypeSchema.RegisterTwoWayEquivalence((TypeSchema)(s_typeCache[typeof(DataProviderQueryStatus)] = new FrameworkCompatibleAssemblyTypeSchema(typeof(DataProviderQueryStatus))), UIXLoadResultExports.DataQueryStatusType);
|
|
}
|
|
|
|
public static void Shutdown()
|
|
{
|
|
foreach (SharedDisposableObject disposableObject in s_assemblyCache.Values)
|
|
disposableObject.UnregisterUsage(s_assemblyCache);
|
|
s_assemblyCache.Clear();
|
|
s_assemblyCache = null;
|
|
foreach (AssemblyTypeSchema assemblyTypeSchema in s_typeCache.Values)
|
|
{
|
|
AssemblyLoadResult owner = (AssemblyLoadResult)assemblyTypeSchema.Owner;
|
|
assemblyTypeSchema.Dispose(owner);
|
|
}
|
|
s_typeCache.Clear();
|
|
s_typeCache = null;
|
|
}
|
|
|
|
public string Namespace => _namespace;
|
|
|
|
public override LoadResultStatus Status => LoadResultStatus.Success;
|
|
|
|
public override TypeSchema FindType(string name)
|
|
{
|
|
Type type = _assembly.GetType(_namespacePrefix + name, false);
|
|
if (type == null)
|
|
return null;
|
|
if (type.IsVisible)
|
|
return MapType(type);
|
|
ErrorManager.ReportError("Type '{0}' is not public in '{1}'", name, _assembly);
|
|
return null;
|
|
}
|
|
|
|
public static AssemblyLoadResult MapAssembly(Assembly assembly, string ns)
|
|
{
|
|
AssemblyLoadResult.MapAssemblyKey key = new AssemblyLoadResult.MapAssemblyKey(assembly, ns);
|
|
AssemblyLoadResult assemblyLoadResult;
|
|
if (!s_assemblyCache.TryGetValue(key, out assemblyLoadResult))
|
|
{
|
|
string uri = "assembly://" + assembly.FullName;
|
|
if (ns != null)
|
|
uri = uri + "/" + ns;
|
|
assemblyLoadResult = new AssemblyLoadResult(assembly, ns, uri);
|
|
s_assemblyCache[key] = assemblyLoadResult;
|
|
assemblyLoadResult.RegisterUsage(s_assemblyCache);
|
|
}
|
|
return assemblyLoadResult;
|
|
}
|
|
|
|
public static AssemblyTypeSchema MapType(Type type)
|
|
{
|
|
object obj;
|
|
AssemblyTypeSchema assemblyTypeSchema;
|
|
if (s_typeCache.TryGetValue(type, out obj))
|
|
{
|
|
assemblyTypeSchema = (AssemblyTypeSchema)obj;
|
|
}
|
|
else
|
|
{
|
|
assemblyTypeSchema = AssemblyObjectProxyHelper.CreateProxySchema(type);
|
|
s_typeCache[type] = assemblyTypeSchema;
|
|
}
|
|
return assemblyTypeSchema;
|
|
}
|
|
|
|
public static Type MapType(TypeSchema typeSchema)
|
|
{
|
|
if (typeSchema is AssemblyTypeSchema assemblyTypeSchema)
|
|
return assemblyTypeSchema.InternalType;
|
|
for (TypeSchema typeSchema1 = typeSchema; typeSchema1 != null; typeSchema1 = typeSchema1.Base)
|
|
{
|
|
if (typeSchema1.Equivalents != null)
|
|
{
|
|
foreach (TypeSchema equivalent in typeSchema1.Equivalents)
|
|
{
|
|
if (equivalent is AssemblyTypeSchema assemblyTypeSchemaB)
|
|
return assemblyTypeSchemaB.InternalType;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
internal static Type[] MapTypeList(TypeSchema[] typeSchemaList)
|
|
{
|
|
Type[] typeArray = new Type[typeSchemaList.Length];
|
|
for (int index = 0; index < typeSchemaList.Length; ++index)
|
|
{
|
|
typeArray[index] = MapType(typeSchemaList[index]);
|
|
if (typeArray[index] == null)
|
|
return null;
|
|
}
|
|
return typeArray;
|
|
}
|
|
|
|
internal static TypeSchema[] MapTypeList(Type[] typeList)
|
|
{
|
|
TypeSchema[] typeSchemaArray = new TypeSchema[typeList.Length];
|
|
for (int index = 0; index < typeList.Length; ++index)
|
|
{
|
|
typeSchemaArray[index] = MapType(typeList[index]);
|
|
if (typeSchemaArray[index] == null)
|
|
return null;
|
|
}
|
|
return typeSchemaArray;
|
|
}
|
|
|
|
internal static object WrapObject(TypeSchema typeSchema, object instance) => AssemblyObjectProxyHelper.WrapObject(typeSchema, instance);
|
|
|
|
internal static object WrapObject(object instance) => AssemblyObjectProxyHelper.WrapObject(null, instance);
|
|
|
|
internal static object UnwrapObject(object instance) => AssemblyObjectProxyHelper.UnwrapObject(instance);
|
|
|
|
internal static object[] UnwrapObjectList(object[] instanceList)
|
|
{
|
|
if (instanceList == null)
|
|
return null;
|
|
object[] objArray = new object[instanceList.Length];
|
|
for (int index = 0; index < objArray.Length; ++index)
|
|
objArray[index] = UnwrapObject(instanceList[index]);
|
|
return objArray;
|
|
}
|
|
|
|
private static void SplitAtLastWhack(
|
|
string valueName,
|
|
out string leftName,
|
|
out string rightName)
|
|
{
|
|
int length = valueName.LastIndexOf('/');
|
|
if (length != -1)
|
|
{
|
|
leftName = valueName.Substring(0, length);
|
|
rightName = valueName.Substring(length + 1);
|
|
}
|
|
else
|
|
{
|
|
leftName = valueName;
|
|
rightName = null;
|
|
}
|
|
}
|
|
|
|
public static Assembly FindAssembly(
|
|
AssemblyName name,
|
|
out Exception assemblyLoadException)
|
|
{
|
|
Assembly assembly = null;
|
|
assemblyLoadException = null;
|
|
try
|
|
{
|
|
assembly = Assembly.Load(name);
|
|
}
|
|
catch (FileLoadException ex)
|
|
{
|
|
assemblyLoadException = ex;
|
|
Debug.Trace.EnableCategory(Debug.TraceCategory.MarkupCompiler, true);
|
|
Debug.Trace.WriteLine(Debug.TraceCategory.MarkupCompiler, ex.FusionLog);
|
|
}
|
|
catch (BadImageFormatException ex)
|
|
{
|
|
assemblyLoadException = ex;
|
|
}
|
|
catch (FileNotFoundException ex)
|
|
{
|
|
assemblyLoadException = ex;
|
|
}
|
|
return assembly;
|
|
}
|
|
|
|
public override string GetCompilerReferenceName() => base.GetCompilerReferenceName() ?? string.Format("{0}{1}/{2}", "assembly://", _assembly.GetName().Name, _namespace);
|
|
|
|
internal Assembly Assembly => _assembly;
|
|
|
|
private AssemblyLoadResult(Assembly assembly, string ns, string uri)
|
|
: base(uri)
|
|
{
|
|
_assembly = assembly;
|
|
_namespace = ns;
|
|
if (ns == null)
|
|
return;
|
|
_namespacePrefix = ns + ".";
|
|
}
|
|
|
|
internal struct MapAssemblyKey
|
|
{
|
|
private Assembly _assembly;
|
|
private string _namespace;
|
|
|
|
public MapAssemblyKey(Assembly assembly, string ns)
|
|
{
|
|
_assembly = assembly;
|
|
_namespace = ns;
|
|
}
|
|
|
|
public override bool Equals(object obj)
|
|
{
|
|
AssemblyLoadResult.MapAssemblyKey mapAssemblyKey = (AssemblyLoadResult.MapAssemblyKey)obj;
|
|
return _assembly == mapAssemblyKey._assembly && _namespace == mapAssemblyKey._namespace;
|
|
}
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
int hashCode = _assembly.GetHashCode();
|
|
if (_namespace != null)
|
|
hashCode ^= _namespace.GetHashCode();
|
|
return hashCode;
|
|
}
|
|
}
|
|
}
|
|
}
|