diff --git a/UIX/CommonExtensions.cs b/UIX/CommonExtensions.cs new file mode 100644 index 0000000..4a7d719 --- /dev/null +++ b/UIX/CommonExtensions.cs @@ -0,0 +1,18 @@ +using System; +using System.Runtime.Serialization; + +internal static class CommonExtensions +{ + /// + public static T GetValue(this SerializationInfo info, string name) + { + try + { + return (T)info.GetValue(name, typeof(T)); + } + catch + { + return default; + } + } +} diff --git a/UIX/Microsoft/Iris/CodeModel/Cpp/DllLoadResult.cs b/UIX/Microsoft/Iris/CodeModel/Cpp/DllLoadResult.cs index d2c2f57..57a984d 100644 --- a/UIX/Microsoft/Iris/CodeModel/Cpp/DllLoadResult.cs +++ b/UIX/Microsoft/Iris/CodeModel/Cpp/DllLoadResult.cs @@ -13,6 +13,7 @@ using System; namespace Microsoft.Iris.CodeModel.Cpp { + [Serializable] internal class DllLoadResult : LoadResult { private DllLoadResultFactory _source; @@ -21,7 +22,7 @@ namespace Microsoft.Iris.CodeModel.Cpp private IntPtr _schema; private Map _userDefinedTypes; private Map _intrinsicTypes; - private static Map s_intrinsicData; + private static Map s_intrinsicData; private ushort _component; private static ushort s_nextID = 1; private static LoadResult s_objectContext; @@ -35,18 +36,18 @@ namespace Microsoft.Iris.CodeModel.Cpp private static void LoadIntrinsicTypeData() { - s_intrinsicData = new Map(); - s_intrinsicData[4294967294U] = new DllLoadResult.IntrinsicTypeData(BooleanSchema.Type); - s_intrinsicData[4294967293U] = new DllLoadResult.IntrinsicTypeData(ByteSchema.Type); - s_intrinsicData[4294967292U] = new DllLoadResult.IntrinsicTypeData(DoubleSchema.Type); - s_intrinsicData[4294967285U] = new DllLoadResult.IntrinsicTypeData(ListSchema.Type, typeof(DllProxyList)); - s_intrinsicData[4294967284U] = new DllLoadResult.IntrinsicTypeData(ImageSchema.Type); - s_intrinsicData[4294967283U] = new DllLoadResult.IntrinsicTypeData(Int32Schema.Type); - s_intrinsicData[4294967282U] = new DllLoadResult.IntrinsicTypeData(Int64Schema.Type); - s_intrinsicData[4294967280U] = new DllLoadResult.IntrinsicTypeData(ObjectSchema.Type); - s_intrinsicData[4294967279U] = new DllLoadResult.IntrinsicTypeData(SingleSchema.Type); - s_intrinsicData[4294967278U] = new DllLoadResult.IntrinsicTypeData(StringSchema.Type); - s_intrinsicData[4294967277U] = new DllLoadResult.IntrinsicTypeData(VoidSchema.Type); + s_intrinsicData = new Map(); + s_intrinsicData[4294967294U] = new IntrinsicTypeData(BooleanSchema.Type); + s_intrinsicData[4294967293U] = new IntrinsicTypeData(ByteSchema.Type); + s_intrinsicData[4294967292U] = new IntrinsicTypeData(DoubleSchema.Type); + s_intrinsicData[4294967285U] = new IntrinsicTypeData(ListSchema.Type, typeof(DllProxyList)); + s_intrinsicData[4294967284U] = new IntrinsicTypeData(ImageSchema.Type); + s_intrinsicData[4294967283U] = new IntrinsicTypeData(Int32Schema.Type); + s_intrinsicData[4294967282U] = new IntrinsicTypeData(Int64Schema.Type); + s_intrinsicData[4294967280U] = new IntrinsicTypeData(ObjectSchema.Type); + s_intrinsicData[4294967279U] = new IntrinsicTypeData(SingleSchema.Type); + s_intrinsicData[4294967278U] = new IntrinsicTypeData(StringSchema.Type); + s_intrinsicData[4294967277U] = new IntrinsicTypeData(VoidSchema.Type); } public static void Shutdown() => DllProxyServices.Shutdown(); @@ -90,7 +91,7 @@ namespace Microsoft.Iris.CodeModel.Cpp if (_intrinsicTypes == null) _intrinsicTypes = new Map(); TypeSchema typeSchema; - DllLoadResult.IntrinsicTypeData intrinsicTypeData; + IntrinsicTypeData intrinsicTypeData; if (!_intrinsicTypes.TryGetValue(typeID, out typeSchema) && s_intrinsicData.TryGetValue(typeID, out intrinsicTypeData)) { typeSchema = !intrinsicTypeData.DemandCreateTypeSchema ? intrinsicTypeData.FrameworkEquivalent : new DllIntrinsicTypeSchema(this, typeID, intrinsicTypeData.FrameworkEquivalent); @@ -304,7 +305,7 @@ namespace Microsoft.Iris.CodeModel.Cpp } else { - DllLoadResult.IntrinsicTypeData intrinsicTypeData; + IntrinsicTypeData intrinsicTypeData; if (s_intrinsicData.TryGetValue(marshalAs, out intrinsicTypeData)) type = intrinsicTypeData.MarshalAsRuntimeType; } diff --git a/UIX/Microsoft/Iris/Markup/AssemblyLoadResult.cs b/UIX/Microsoft/Iris/Markup/AssemblyLoadResult.cs index 1bcdcc4..8321f75 100644 --- a/UIX/Microsoft/Iris/Markup/AssemblyLoadResult.cs +++ b/UIX/Microsoft/Iris/Markup/AssemblyLoadResult.cs @@ -15,9 +15,11 @@ using System.Collections.Generic; using System.IO; using System.Reflection; using System.Runtime.InteropServices; +using System.Runtime.Serialization; namespace Microsoft.Iris.Markup { + [Serializable] internal class AssemblyLoadResult : LoadResult { private const string c_AssemblyProtocol = "assembly://"; @@ -30,13 +32,19 @@ namespace Microsoft.Iris.Markup public static TypeSchema DictionaryTypeSchema; public static TypeSchema CommandTypeSchema; public static TypeSchema ValueRangeTypeSchema; - private static Map s_typeCache = new Map(32); - private static Map s_assemblyCache = new Map(); + private static Map s_typeCache = new(32); + private static Map s_assemblyCache = new(); + + protected AssemblyLoadResult(SerializationInfo info, StreamingContext context) : base(info, context) + { + _namespace = info.GetString(nameof(Namespace)); + _assembly = info.GetValue(nameof(Assembly)); + } private static LoadResult Create(string uri) { LoadResult loadResult = null; - string valueName = uri.Substring("assembly://".Length); + string valueName = uri.Substring(c_AssemblyProtocol.Length); if (valueName.IndexOf('/') == -1) { ErrorManager.ReportError("Invalid assembly reference '{0}'. URI must contain a forward slash after the assembly name", uri); @@ -78,7 +86,7 @@ namespace Microsoft.Iris.Markup public static void Startup() { AssemblyObjectProxyHelper.InitializeStatics(); - MarkupSystem.RegisterFactoryByProtocol("assembly://", new CreateLoadResultHandler(Create)); + MarkupSystem.RegisterFactoryByProtocol(c_AssemblyProtocol, new CreateLoadResultHandler(Create)); Map typeCache1 = s_typeCache; Type type1 = typeof(object); FrameworkCompatibleAssemblyPrimitiveTypeSchema primitiveTypeSchema; @@ -135,16 +143,16 @@ namespace Microsoft.Iris.Markup 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))); + s_typeCache[typeof(Choice)] = (FrameworkCompatibleAssemblyTypeSchema)(producer4 = new FrameworkCompatibleAssemblyTypeSchema(typeof(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.RegisterOneWayEquivalence((TypeSchema)(s_typeCache[typeof(BooleanChoice)] = new FrameworkCompatibleAssemblyTypeSchema(typeof(BooleanChoice))), BooleanChoiceSchema.Type); TypeSchema producer5; - s_typeCache[typeof(Microsoft.Iris.RangedValue)] = (FrameworkCompatibleAssemblyTypeSchema)(producer5 = new FrameworkCompatibleAssemblyTypeSchema(typeof(Microsoft.Iris.RangedValue))); + s_typeCache[typeof(RangedValue)] = (FrameworkCompatibleAssemblyTypeSchema)(producer5 = new FrameworkCompatibleAssemblyTypeSchema(typeof(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.RegisterOneWayEquivalence((TypeSchema)(s_typeCache[typeof(IntRangedValue)] = new FrameworkCompatibleAssemblyTypeSchema(typeof(IntRangedValue))), IntRangedValueSchema.Type); + TypeSchema.RegisterOneWayEquivalence((TypeSchema)(s_typeCache[typeof(ByteRangedValue)] = new FrameworkCompatibleAssemblyTypeSchema(typeof(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); @@ -182,11 +190,11 @@ namespace Microsoft.Iris.Markup public static AssemblyLoadResult MapAssembly(Assembly assembly, string ns) { - AssemblyLoadResult.MapAssemblyKey key = new AssemblyLoadResult.MapAssemblyKey(assembly, ns); + MapAssemblyKey key = new MapAssemblyKey(assembly, ns); AssemblyLoadResult assemblyLoadResult; if (!s_assemblyCache.TryGetValue(key, out assemblyLoadResult)) { - string uri = "assembly://" + assembly.FullName; + string uri = c_AssemblyProtocol + assembly.FullName; if (ns != null) uri = uri + "/" + ns; assemblyLoadResult = new AssemblyLoadResult(assembly, ns, uri); @@ -313,7 +321,7 @@ namespace Microsoft.Iris.Markup return assembly; } - public override string GetCompilerReferenceName() => base.GetCompilerReferenceName() ?? string.Format("{0}{1}/{2}", "assembly://", _assembly.GetName().Name, _namespace); + public override string GetCompilerReferenceName() => base.GetCompilerReferenceName() ?? $"{c_AssemblyProtocol}{_assembly.GetName().Name}/{_namespace}"; internal Assembly Assembly => _assembly; @@ -327,6 +335,14 @@ namespace Microsoft.Iris.Markup _namespacePrefix = ns + "."; } + public override void GetObjectData(SerializationInfo info, StreamingContext context) + { + base.GetObjectData(info, context); + + info.AddValue(nameof(Namespace), Namespace); + info.AddValue(nameof(Assembly), Assembly); + } + internal struct MapAssemblyKey { private Assembly _assembly; @@ -340,7 +356,7 @@ namespace Microsoft.Iris.Markup public override bool Equals(object obj) { - AssemblyLoadResult.MapAssemblyKey mapAssemblyKey = (AssemblyLoadResult.MapAssemblyKey)obj; + MapAssemblyKey mapAssemblyKey = (MapAssemblyKey)obj; return _assembly == mapAssemblyKey._assembly && _namespace == mapAssemblyKey._namespace; } diff --git a/UIX/Microsoft/Iris/Markup/CompiledMarkupLoadResult.cs b/UIX/Microsoft/Iris/Markup/CompiledMarkupLoadResult.cs index ec03f39..3a85524 100644 --- a/UIX/Microsoft/Iris/Markup/CompiledMarkupLoadResult.cs +++ b/UIX/Microsoft/Iris/Markup/CompiledMarkupLoadResult.cs @@ -7,9 +7,11 @@ using Microsoft.Iris.Data; using Microsoft.Iris.Session; using System; +using System.Runtime.Serialization; namespace Microsoft.Iris.Markup { + [Serializable] internal class CompiledMarkupLoadResult : MarkupLoadResult { private Resource _resource; @@ -25,6 +27,10 @@ namespace Microsoft.Iris.Markup _loader = CompiledMarkupLoader.Load(this, resource); } + protected CompiledMarkupLoadResult(SerializationInfo info, StreamingContext context) : base(info, context) + { + } + public override bool IsSource => false; public override MarkupConstantsTable ConstantsTable => _binaryDataTable.ConstantsTable; diff --git a/UIX/Microsoft/Iris/Markup/ErrorLoadResult.cs b/UIX/Microsoft/Iris/Markup/ErrorLoadResult.cs index c181c07..5e2b46a 100644 --- a/UIX/Microsoft/Iris/Markup/ErrorLoadResult.cs +++ b/UIX/Microsoft/Iris/Markup/ErrorLoadResult.cs @@ -4,8 +4,11 @@ // MVID: A56C6C9D-B7F6-46A9-8BDE-B3D9B8D60B11 // Assembly location: C:\Program Files\Zune\UIX.dll +using System; + namespace Microsoft.Iris.Markup { + [Serializable] internal class ErrorLoadResult : LoadResult { public ErrorLoadResult(string uri) diff --git a/UIX/Microsoft/Iris/Markup/LoadResult.cs b/UIX/Microsoft/Iris/Markup/LoadResult.cs index 5cfdac6..98f5795 100644 --- a/UIX/Microsoft/Iris/Markup/LoadResult.cs +++ b/UIX/Microsoft/Iris/Markup/LoadResult.cs @@ -7,19 +7,29 @@ using Microsoft.Iris.Library; using Microsoft.Iris.Session; using System; +using System.Runtime.Serialization; namespace Microsoft.Iris.Markup { - public abstract class LoadResult : SharedDisposableObject + [Serializable] + public abstract class LoadResult : SharedDisposableObject, ISerializable { - private string _uri; + private readonly string _uri; protected string _uriUnderlying; private uint _islandReferences; private string _compilerReferenceName; - public static LoadResult[] EmptyList = new LoadResult[0]; + public static readonly LoadResult[] EmptyList = Array.Empty(); public LoadResult(string uri) => _uri = uri; + protected LoadResult(SerializationInfo info, StreamingContext context) + { + _uri = info.GetString(nameof(Uri)); + _uriUnderlying = info.GetString(nameof(UnderlyingUri)); + _islandReferences = info.GetUInt32(nameof(IslandReferences)); + _compilerReferenceName = info.GetString("CompilerReferenceName"); + } + protected override void OnDispose() => base.OnDispose(); public string Uri => _uri; @@ -113,5 +123,17 @@ namespace Microsoft.Iris.Markup public virtual string GetCompilerReferenceName() => _compilerReferenceName; public override string ToString() => _uri; + + public virtual void GetObjectData(SerializationInfo info, StreamingContext context) + { + info.AddValue(nameof(Uri), Uri); + info.AddValue(nameof(UnderlyingUri), UnderlyingUri); + info.AddValue(nameof(IslandReferences), IslandReferences); + info.AddValue(nameof(Status), Status); + info.AddValue(nameof(Cachable), Cachable); + info.AddValue(nameof(Dependencies), Dependencies); + info.AddValue(nameof(ExportTable), ExportTable); + info.AddValue("CompilerReferenceName", GetCompilerReferenceName()); + } } } diff --git a/UIX/Microsoft/Iris/Markup/MarkupLoadResult.cs b/UIX/Microsoft/Iris/Markup/MarkupLoadResult.cs index a5bd8f2..f8c4c87 100644 --- a/UIX/Microsoft/Iris/Markup/MarkupLoadResult.cs +++ b/UIX/Microsoft/Iris/Markup/MarkupLoadResult.cs @@ -7,9 +7,12 @@ using Microsoft.Iris.Data; using Microsoft.Iris.Library; using Microsoft.Iris.Session; +using System; +using System.Runtime.Serialization; namespace Microsoft.Iris.Markup { + [Serializable] public abstract class MarkupLoadResult : LoadResult { private LoadResult[] _dependenciesTable = EmptyList; @@ -28,6 +31,16 @@ namespace Microsoft.Iris.Markup : base(uri) => _status = LoadResultStatus.Loading; + protected MarkupLoadResult(SerializationInfo info, StreamingContext context) : base(info, context) + { + _dependenciesTable = info.GetValue(nameof(Dependencies)); + _exportTable = info.GetValue(nameof(ExportTable)); + _aliasTable = info.GetValue(nameof(AliasTable)); + _dataMappingsTable = info.GetValue(nameof(DataMappingsTable)); + _binaryDataTable = info.GetValue(nameof(BinaryDataTable)); + _lineNumberTable = info.GetValue(nameof(LineNumberTable)); + } + private void OnLoaded() { if (_dataMappingsTable == null) @@ -176,5 +189,18 @@ namespace Microsoft.Iris.Markup } public virtual void MarkLoadFailed() => _status = LoadResultStatus.Error; + + public override void GetObjectData(SerializationInfo info, StreamingContext context) + { + base.GetObjectData(info, context); + + info.AddValue(nameof(IsSource), IsSource); + info.AddValue(nameof(ImportTables), ImportTables); + info.AddValue(nameof(AliasTable), AliasTable); + info.AddValue(nameof(DataMappingsTable), DataMappingsTable); + info.AddValue(nameof(BinaryDataTable), BinaryDataTable); + info.AddValue(nameof(ConstantsTable), ConstantsTable); + info.AddValue(nameof(LineNumberTable), LineNumberTable); + } } } diff --git a/UIX/Microsoft/Iris/Markup/SourceMarkupLoadResult.cs b/UIX/Microsoft/Iris/Markup/SourceMarkupLoadResult.cs index d7fb91a..e3888c9 100644 --- a/UIX/Microsoft/Iris/Markup/SourceMarkupLoadResult.cs +++ b/UIX/Microsoft/Iris/Markup/SourceMarkupLoadResult.cs @@ -7,9 +7,12 @@ using Microsoft.Iris.Data; using Microsoft.Iris.Markup.Validation; using Microsoft.Iris.Session; +using System; +using System.Runtime.Serialization; namespace Microsoft.Iris.Markup { + [Serializable] internal class SourceMarkupLoadResult : MarkupLoadResult { private MarkupConstantsTable _constantsTable; @@ -32,6 +35,12 @@ namespace Microsoft.Iris.Markup { } + protected SourceMarkupLoadResult(SerializationInfo info, StreamingContext context) : base(info, context) + { + _constantsTable = info.GetValue(nameof(ConstantsTable)); + _importTables = info.GetValue(nameof(ImportTables)); + } + public override bool IsSource => true; internal SourceMarkupLoader Loader => _loader; @@ -80,5 +89,12 @@ namespace Microsoft.Iris.Markup public void SetConstantsTable(MarkupConstantsTable constantsTable) => _constantsTable = constantsTable; public void SetImportTables(MarkupImportTables importTables) => _importTables = importTables; + + public override void GetObjectData(SerializationInfo info, StreamingContext context) + { + base.GetObjectData(info, context); + + info.AddValue(nameof(_resource), _resource); + } } } diff --git a/UIX/Microsoft/Iris/Markup/TypeSchema.cs b/UIX/Microsoft/Iris/Markup/TypeSchema.cs index 3a9885d..38f4231 100644 --- a/UIX/Microsoft/Iris/Markup/TypeSchema.cs +++ b/UIX/Microsoft/Iris/Markup/TypeSchema.cs @@ -7,6 +7,7 @@ using Microsoft.Iris.Library; using Microsoft.Iris.Markup.UIX; using System; +using System.Linq; namespace Microsoft.Iris.Markup { @@ -245,6 +246,50 @@ namespace Microsoft.Iris.Markup return typeSchema; } + private static bool IsBasicType(TypeSchema type) => + type == null || type.RuntimeType.Assembly.FullName.Contains("CoreLib") || type.Properties.Length == 0; + + public static void GenerateModelCode(TypeSchema dataType) + { + string code = + "using Microsoft.Iris.Markup;\r\n\r\n" + + "namespace Microsoft.Zune.Schemas;\r\n\r\n" + + "public class " + dataType.Name; + + if (!IsBasicType(dataType.Base)) + { + code += $" : {dataType.Base.Name}"; + GenerateModelCode(dataType.Base); + } + else + { + code += $" : MarkupDataType"; + } + + code += "\r\n{\r\n"; + code += $" public {dataType.Name}(MarkupTypeSchema schema) : base(schema)\r\n"; + code += " {\r\n"; + code += " }\r\n\r\n"; + + foreach (var prop in dataType.Properties) + { + string propType = prop.PropertyType.AlternateName ?? prop.PropertyType.Name; + + code += $" public {propType} {prop.Name}\r\n"; + code += " {\r\n"; + code += $" get => GetProperty<{propType}>();\r\n"; + code += $" set => SetProperty(value);\r\n"; + code += " }\r\n\r\n"; + + if (!IsBasicType(prop.PropertyType) && !Application.DebugSettings.DataMappingModels.Any(m => m.Type == propType)) + GenerateModelCode(prop.PropertyType); + } + + code += "}"; + + Application.DebugSettings.DataMappingModels.Add(new(dataType.RuntimeType.Name, dataType.Name, code)); + } + public override string ToString() => $"typeof({Name})"; } } diff --git a/UIX/Microsoft/Iris/Markup/UIXLoadResult.cs b/UIX/Microsoft/Iris/Markup/UIXLoadResult.cs index 47151b4..52aed08 100644 --- a/UIX/Microsoft/Iris/Markup/UIXLoadResult.cs +++ b/UIX/Microsoft/Iris/Markup/UIXLoadResult.cs @@ -6,9 +6,12 @@ using Microsoft.Iris.Library; using Microsoft.Iris.Markup.UIX; +using System; +using System.Runtime.Serialization; namespace Microsoft.Iris.Markup { + [Serializable] internal class UIXLoadResult : LoadResult { public UIXLoadResult(string uri) @@ -16,6 +19,11 @@ namespace Microsoft.Iris.Markup { } + protected UIXLoadResult(SerializationInfo info, StreamingContext context) : base(info, context) + { + UIXLoadResultExports.ExportTable = info.GetValue(nameof(ExportTable)); + } + public static void InitializeStatics() => UIXLoadResultExports.InitializeStatics(); public override TypeSchema[] ExportTable => UIXLoadResultExports.ExportTable; diff --git a/UIX/Microsoft/Iris/UI/RootLoadResult.cs b/UIX/Microsoft/Iris/UI/RootLoadResult.cs index b4adc60..bd2147f 100644 --- a/UIX/Microsoft/Iris/UI/RootLoadResult.cs +++ b/UIX/Microsoft/Iris/UI/RootLoadResult.cs @@ -5,9 +5,12 @@ // Assembly location: C:\Program Files\Zune\UIX.dll using Microsoft.Iris.Markup; +using System; +using System.Runtime.Serialization; namespace Microsoft.Iris.UI { + [Serializable] internal class RootLoadResult : MarkupLoadResult { public UIClassTypeSchema RootType; @@ -16,6 +19,11 @@ namespace Microsoft.Iris.UI : base(name) => RootType = new UIClassTypeSchema(this, name); + protected RootLoadResult(SerializationInfo info, StreamingContext context) : base(info, context) + { + RootType = info.GetValue(nameof(RootType)); + } + protected override void OnDispose() { base.OnDispose(); @@ -32,5 +40,12 @@ namespace Microsoft.Iris.UI public override MarkupConstantsTable ConstantsTable => (MarkupConstantsTable)null; public override MarkupImportTables ImportTables => (MarkupImportTables)null; + + public override void GetObjectData(SerializationInfo info, StreamingContext context) + { + base.GetObjectData(info, context); + + info.AddValue(nameof(RootType), RootType); + } } }