public override void _0001(RecordClassDispatcher item, object cfg, PrototypeError filter) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 if (cfg == null) { item._0008(); return; } DataTable obj = (DataTable)cfg; PublisherRequestStrategy publisherRequestStrategy = filter._0001() as PublisherRequestStrategy; item._0003(); foreach (DataRow row in obj.Rows) { item._0002(); foreach (DataColumn column in row.Table.Columns) { object obj2 = row[column]; if (filter._0001() != (ApplicationState)1 || (obj2 != null && obj2 != DBNull.Value)) { item._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient(column.ColumnName) : column.ColumnName); filter.FlushComposer(item, obj2); } } item._0011(); } item._000F(); }
public override object _0001(TagTestItem def, Type ord, object dir, PrototypeError reg2) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 if (def._0001() == WatcherComposer.Null) { return(null); } DataSet dataSet = (ord == typeof(DataSet)) ? new DataSet() : ((DataSet)Activator.CreateInstance(ord)); FieldReaderMapper fieldReaderMapper = new FieldReaderMapper(); def.SortError(); while (def._0001() == WatcherComposer.PropertyName) { DataTable dataTable = dataSet.Tables[(string)def._0001()]; bool num = dataTable != null; dataTable = (DataTable)fieldReaderMapper._0001(def, typeof(DataTable), dataTable, reg2); if (!num) { dataSet.Tables.Add(dataTable); } def.SortError(); } return(dataSet); }
public override object _0001(TagTestItem info, Type b, object c, PrototypeError asset2) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 if (info._0001() == WatcherComposer.Null) { return(null); } DataTable dataTable = c as DataTable; if (dataTable == null) { dataTable = ((b == typeof(DataTable)) ? new DataTable() : ((DataTable)Activator.CreateInstance(b))); } if (info._0001() == WatcherComposer.PropertyName) { dataTable.TableName = (string)info._0001(); info.SortError(); if (info._0001() == WatcherComposer.Null) { return(dataTable); } } if (info._0001() != WatcherComposer.StartArray) { throw StrategyError.PatchComposer(info, "Unexpected JSON token when reading DataTable. Expected StartArray, got {0}.".ListReader(CultureInfo.InvariantCulture, info._0001())); } info.SortError(); while (info._0001() != WatcherComposer.EndArray) { RestartRequest(info, dataTable, asset2); info.SortError(); } return(dataTable); }
public InterceptorInstanceExpression(PrototypeError config) { //Discarded unreachable code: IL_0002, IL_0006 //IL_0003: Incompatible stack heights: 0 vs 1 //IL_0007: Incompatible stack heights: 0 vs 1 SingletonReader.PushGlobal(); wrapperProperty = new List <object>(); base._002Ector(config); }
private static void RestartRequest(TagTestItem instance, DataTable cont, PrototypeError template) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 DataRow dataRow = cont.NewRow(); instance.SortError(); while (instance._0001() == WatcherComposer.PropertyName) { string text = (string)instance._0001(); instance.SortError(); DataColumn dataColumn = cont.Columns[text]; if (dataColumn == null) { Type dataType = SearchRequest(instance); dataColumn = new DataColumn(text, dataType); cont.Columns.Add(dataColumn); } if (dataColumn.DataType == typeof(DataTable)) { if (instance._0001() == WatcherComposer.StartArray) { instance.SortError(); } DataTable dataTable = new DataTable(); while (instance._0001() != WatcherComposer.EndArray) { RestartRequest(instance, dataTable, template); instance.SortError(); } dataRow[text] = dataTable; } else if (!dataColumn.DataType.IsArray || !(dataColumn.DataType != typeof(byte[]))) { object obj2 = dataRow[text] = ((instance._0001() != null) ? (template.AddComposer(instance, dataColumn.DataType) ?? DBNull.Value) : DBNull.Value); } else { if (instance._0001() == WatcherComposer.StartArray) { instance.SortError(); } List <object> list = new List <object>(); while (instance._0001() != WatcherComposer.EndArray) { list.Add(instance._0001()); instance.SortError(); } Array array = Array.CreateInstance(dataColumn.DataType.GetElementType(), list.Count); ((ICollection)list).CopyTo(array, 0); dataRow[text] = array; } instance.SortError(); } dataRow.EndEdit(); cont.Rows.Add(dataRow); }
public override object _0001(TagTestItem setup, Type pol, object tag, PrototypeError def2) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 if (setup._0001() != WatcherComposer.Bytes) { throw new StrategyError("Expected Bytes but got {0}.".ListReader(CultureInfo.InvariantCulture, setup._0001())); } return(new TokenClassSpec((byte[])setup._0001())); }
public AlgoInstanceExpression(InterceptorInstanceExpression last) { //Discarded unreachable code: IL_0002, IL_0006 //IL_0003: Incompatible stack heights: 0 vs 1 //IL_0007: Incompatible stack heights: 0 vs 1 SingletonReader.PushGlobal(); base._002Ector(); ContextClientBridge.RunClient(last, "serializerWriter"); m_TemplateProperty = last; m_ExpressionProperty = last.baseProperty; }
public AlgoInstanceExpression(BroadcasterInstanceRule task) { //Discarded unreachable code: IL_0002, IL_0006 //IL_0003: Incompatible stack heights: 0 vs 1 //IL_0007: Incompatible stack heights: 0 vs 1 SingletonReader.PushGlobal(); base._002Ector(); ContextClientBridge.RunClient(task, "serializerReader"); _ParamsProperty = task; m_ExpressionProperty = task.baseProperty; }
protected RuleTestItem(PrototypeError item) { //Discarded unreachable code: IL_0002, IL_0006 //IL_0003: Incompatible stack heights: 0 vs 1 //IL_0007: Incompatible stack heights: 0 vs 1 SingletonReader.PushGlobal(); base._002Ector(); ContextClientBridge.RunClient(item, "serializer"); baseProperty = item; containerProperty = item._0001(); }
public override void _0001(RecordClassDispatcher config, object caller, PrototypeError comp) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 if (caller == null) { config._0008(); return; } byte[] item = ReflectRequest(caller); config._0001(item); }
private void ListRequest(RecordClassDispatcher i, Regex reg, PrototypeError tag) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 PublisherRequestStrategy publisherRequestStrategy = tag._0001() as PublisherRequestStrategy; i._0002(); i._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Pattern") : "Pattern"); i._0004(reg.ToString()); i._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Options") : "Options"); tag.FlushComposer(i, reg.Options); i._0011(); }
public override void _0001(RecordClassDispatcher config, object caller, PrototypeError template) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 TokenClassSpec tokenClassSpec = (TokenClassSpec)caller; TaskIteratorMapping taskIteratorMapping = config as TaskIteratorMapping; if (taskIteratorMapping != null) { taskIteratorMapping.PopIterator(tokenClassSpec._0001()); } else { config._0001(tokenClassSpec._0001()); } }
public override object _0001(TagTestItem config, Type ivk, object template, PrototypeError connection2) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 if (config._0001() == WatcherComposer.Null) { if (!ResolverErrorFilter.PatchReader(ivk)) { throw StrategyError.PatchComposer(config, "Cannot convert null value to KeyValuePair."); } return(null); } object obj = null; object obj2 = null; config.SortError(); Type res = ResolverErrorFilter.PatchReader(ivk) ? Nullable.GetUnderlyingType(ivk) : ivk; ModelInstanceExpression modelInstanceExpression = m_ListenerIssuer.InitReader(res); ProcTest procTest = connection2._0001()._0001(modelInstanceExpression.SetupIssuer("Key")); ProcTest procTest2 = connection2._0001()._0001(modelInstanceExpression.SetupIssuer("Value")); while (config._0001() == WatcherComposer.PropertyName) { string a = config._0001().ToString(); if (string.Equals(a, "Key", StringComparison.OrdinalIgnoreCase)) { config.CallError(procTest, iscaller: false); obj = connection2.AddComposer(config, procTest._0002()); } else if (string.Equals(a, "Value", StringComparison.OrdinalIgnoreCase)) { config.CallError(procTest2, iscaller: false); obj2 = connection2.AddComposer(config, procTest2._0002()); } else { config.AssetError(); } config.SortError(); } return(modelInstanceExpression._0001()(new object[2] { obj, obj2 })); }
private Regex DeleteRequest(TagTestItem config, PrototypeError result) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 string text = null; RegexOptions?regexOptions = null; while (config._0001()) { switch (config._0001()) { case WatcherComposer.PropertyName: { string a = config._0001().ToString(); if (!config._0001()) { throw StrategyError.PatchComposer(config, "Unexpected end when reading Regex."); } if (string.Equals(a, "Pattern", StringComparison.OrdinalIgnoreCase)) { text = (string)config._0001(); } else if (string.Equals(a, "Options", StringComparison.OrdinalIgnoreCase)) { regexOptions = result.CompareComposer <RegexOptions>(config); } else { config.AssetError(); } break; } case WatcherComposer.EndObject: if (text == null) { throw StrategyError.PatchComposer(config, "Error deserializing Regex. No pattern found."); } return(new Regex(text, regexOptions.GetValueOrDefault())); } } throw StrategyError.PatchComposer(config, "Unexpected end when reading Regex."); }
public override object _0001(TagTestItem first, Type result, object pool, PrototypeError spec2) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 switch (first._0001()) { case WatcherComposer.StartObject: return(DeleteRequest(first, spec2)); case WatcherComposer.String: return(SelectRequest(first)); case WatcherComposer.Null: return(null); default: throw StrategyError.PatchComposer(first, "Unexpected token when reading Regex."); } }
public override void _0001(RecordClassDispatcher config, object col, PrototypeError dic) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 if (col == null) { config._0008(); return; } ModelInstanceExpression modelInstanceExpression = m_ListenerIssuer.InitReader(col.GetType()); PublisherRequestStrategy publisherRequestStrategy = dic._0001() as PublisherRequestStrategy; config._0002(); config._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Key") : "Key"); dic.InsertComposer(config, modelInstanceExpression.CancelIssuer(col, "Key"), modelInstanceExpression.SetupIssuer("Key")); config._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Value") : "Value"); dic.InsertComposer(config, modelInstanceExpression.CancelIssuer(col, "Value"), modelInstanceExpression.SetupIssuer("Value")); config._0011(); }
public override object _0001(TagTestItem item, Type attr, object util, PrototypeError var12) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 RateRequest(attr); object obj = m_SerializerIssuer._0001()(new object[0]); SetRequest(item, "Key"); item.SortError(); m_SerializerIssuer.ExcludeIssuer(obj, "Key", item._0001()?.ToString()); SetRequest(item, "Type"); item.SortError(); Type type = Type.GetType(item._0001()?.ToString()); SetRequest(item, "Value"); item.SortError(); m_SerializerIssuer.ExcludeIssuer(obj, "Value", var12.AddComposer(item, type)); item.SortError(); return(obj); }
public override object _0001(TagTestItem instance, Type pred, object res, PrototypeError reference2) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 if (instance._0001() == WatcherComposer.Null) { if (!ResolverErrorFilter.VerifyReader(pred)) { throw StrategyError.PatchComposer(instance, "Cannot convert null value to {0}.".ListReader(CultureInfo.InvariantCulture, pred)); } return(null); } byte[] array; if (instance._0001() == WatcherComposer.StartArray) { array = RegisterRequest(instance); } else { if (instance._0001() != WatcherComposer.String) { throw StrategyError.PatchComposer(instance, "Unexpected token parsing binary. Expected String or StartArray, got {0}.".ListReader(CultureInfo.InvariantCulture, instance._0001())); } array = Convert.FromBase64String(instance._0001().ToString()); } Type type = ResolverErrorFilter.PatchReader(pred) ? Nullable.GetUnderlyingType(pred) : pred; if (type.FullName == "System.Data.Linq.Binary") { ResetRequest(type); return(_InfoIssuer._0001()(new object[1] { array })); } if (type == typeof(SqlBinary)) { return(new SqlBinary(array)); } throw StrategyError.PatchComposer(instance, "Unexpected object type when writing binary: {0}".ListReader(CultureInfo.InvariantCulture, pred)); }
public override void _0001(RecordClassDispatcher res, object connection, PrototypeError third) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 if (connection == null) { res._0008(); return; } DataSet obj = (DataSet)connection; PublisherRequestStrategy publisherRequestStrategy = third._0001() as PublisherRequestStrategy; FieldReaderMapper fieldReaderMapper = new FieldReaderMapper(); res._0002(); foreach (DataTable table in obj.Tables) { res._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient(table.TableName) : table.TableName); fieldReaderMapper._0001(res, table, third); } res._0011(); }
public override void _0001(RecordClassDispatcher spec, object map, PrototypeError consumer) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 if (map == null) { spec._0008(); return; } Regex regex = (Regex)map; TaskIteratorMapping taskIteratorMapping = spec as TaskIteratorMapping; if (taskIteratorMapping != null) { StartRequest(taskIteratorMapping, regex); } else { ListRequest(spec, regex, consumer); } }
public override void _0001(RecordClassDispatcher v, object col, PrototypeError role) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 if (col == null) { v._0008(); return; } RateRequest(col.GetType()); PublisherRequestStrategy publisherRequestStrategy = role._0001() as PublisherRequestStrategy; string init = (string)m_SerializerIssuer.CancelIssuer(col, "Key"); object obj = m_SerializerIssuer.CancelIssuer(col, "Value"); Type type = obj?.GetType(); v._0002(); v._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Key") : "Key"); v._0004(init); v._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Type") : "Type"); v._0004(type?.FullName); v._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Value") : "Value"); if (type != null) { if (InterceptorInstanceExpression.ExcludeBroadcaster(obj, type, out string _0004)) { v._0004(_0004); } else { v._0001(obj); } } else { v._0008(); } v._0011(); }
public override void _0001(RecordClassDispatcher v, object ivk, PrototypeError util) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 if (ivk == null) { v._0008(); return; } PublisherRequestStrategy publisherRequestStrategy = util._0001() as PublisherRequestStrategy; Type res = m_PrototypeIssuer.InitReader(ivk.GetType()); UtilsClientBridge utilsClientBridge = m_ParameterIssuer.InitReader(res); int num = (int)utilsClientBridge._ParserIssuer.ConnectIssuer(new object[1] { ivk }); FactoryDicCandidate factoryDicCandidate = utilsClientBridge.m_StatusIssuer.Single((FactoryDicCandidate P_0) => P_0.pageIssuer == num); v._0002(); v._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Case") : "Case"); v._0004(factoryDicCandidate._HelperIssuer); if (factoryDicCandidate.exceptionIssuer != null && factoryDicCandidate.exceptionIssuer.Length != 0) { object[] obj = (object[])factoryDicCandidate.attributeIssuer.ConnectIssuer(new object[1] { ivk }); v._0002((publisherRequestStrategy != null) ? publisherRequestStrategy.ResetClient("Fields") : "Fields"); v._0003(); object[] array = obj; foreach (object reg in array) { util.FlushComposer(v, reg); } v._000F(); } v._0011(); }
public override void _0001(RecordClassDispatcher i, object visitor, PrototypeError third) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 if (visitor == null) { i._0008(); return; } CreatorIssuer creatorIssuer = CountRequest(visitor); XmlNamespaceManager xmlNamespaceManager = new XmlNamespaceManager(new NameTable()); AssetRequest(creatorIssuer, xmlNamespaceManager); if (!_0004()) { i._0002(); } InitRequest(i, creatorIssuer, xmlNamespaceManager, !_0004()); if (!_0004()) { i._0011(); } }
public override void _0001(RecordClassDispatcher spec, object selection, PrototypeError role) { } //Discarded unreachable code: IL_0002
public override object _0001(TagTestItem param, Type counter, object helper, PrototypeError config2) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 return(RemoveRequest(param)); }
public override object _0001(TagTestItem param, Type reg, object serv, PrototypeError first2) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 switch (param._0001()) { case WatcherComposer.Null: return(null); default: throw StrategyError.PatchComposer(param, "XmlNodeConverter can only convert JSON that begins with an object."); case WatcherComposer.StartObject: { XmlNamespaceManager xmlNamespaceManager = new XmlNamespaceManager(new NameTable()); AttrBroadcasterFilter attrBroadcasterFilter = null; CreatorIssuer creatorIssuer = null; if (typeof(XObject).IsAssignableFrom(reg)) { if (reg != typeof(XContainer) && reg != typeof(XDocument) && reg != typeof(XElement) && reg != typeof(XNode) && reg != typeof(XObject)) { throw StrategyError.PatchComposer(param, "XmlNodeConverter only supports deserializing XDocument, XElement, XContainer, XNode or XObject."); } attrBroadcasterFilter = new AuthenticationComposerPool(new XDocument()); creatorIssuer = attrBroadcasterFilter; } if (typeof(XmlNode).IsAssignableFrom(reg)) { if (reg != typeof(XmlDocument) && reg != typeof(XmlElement) && reg != typeof(XmlNode)) { throw StrategyError.PatchComposer(param, "XmlNodeConverter only supports deserializing XmlDocument, XmlElement or XmlNode."); } attrBroadcasterFilter = new ConnectionComposerWorker(new XmlDocument { XmlResolver = null }); creatorIssuer = attrBroadcasterFilter; } if (attrBroadcasterFilter == null || creatorIssuer == null) { throw StrategyError.PatchComposer(param, "Unexpected type when converting XML: " + reg); } if (!SetterTest.StartReader(_0001())) { SortRequest(param, attrBroadcasterFilter, creatorIssuer, _0001(), xmlNamespaceManager); } else { param.SortError(); ValidateIterator(param, attrBroadcasterFilter, xmlNamespaceManager, creatorIssuer); } if (reg == typeof(XElement)) { XElement obj = (XElement)((CreatorIssuer)attrBroadcasterFilter._0001())._0001(); obj.Remove(); return(obj); } if (reg == typeof(XmlElement)) { return(((CreatorIssuer)attrBroadcasterFilter._0001())._0001()); } return(((CreatorIssuer)attrBroadcasterFilter)._0001()); } } }
public override void _0001(RecordClassDispatcher task, BroadcasterError[] counter) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 if (counter != null && counter.Length != 0 && m_InvocationIssuer != null) { BroadcasterError broadcasterError = PrototypeError.LogoutComposer(counter, m_InvocationIssuer.GetType()); if (broadcasterError != null && broadcasterError._0001()) { broadcasterError._0001(task, m_InvocationIssuer, PrototypeError.FillComposer()); return; } } switch (_ValIssuer) { case Newtonsoft.Rules.UnicodeCategory.Comment: task._0005(m_InvocationIssuer?.ToString()); break; case Newtonsoft.Rules.UnicodeCategory.Raw: task._0006(m_InvocationIssuer?.ToString()); break; case Newtonsoft.Rules.UnicodeCategory.Null: task._0008(); break; case Newtonsoft.Rules.UnicodeCategory.Undefined: task._000E(); break; case Newtonsoft.Rules.UnicodeCategory.Integer: { object invocationIssuer = m_InvocationIssuer; if (invocationIssuer is int) { int first_Low = (int)invocationIssuer; task._0001(first_Low); break; } invocationIssuer = m_InvocationIssuer; if (invocationIssuer is long) { long asset2 = (long)invocationIssuer; task._0001(asset2); break; } invocationIssuer = m_InvocationIssuer; if (invocationIssuer is ulong) { ulong specID = (ulong)invocationIssuer; task._0001(specID); break; } invocationIssuer = m_InvocationIssuer; if (invocationIssuer is BigInteger) { BigInteger bigInteger = (BigInteger)invocationIssuer; task._0001(bigInteger); } else { task._0001(Convert.ToInt64(m_InvocationIssuer, CultureInfo.InvariantCulture)); } break; } case Newtonsoft.Rules.UnicodeCategory.Float: { object invocationIssuer = m_InvocationIssuer; if (invocationIssuer is decimal) { decimal asset = (decimal)invocationIssuer; task._0001(asset); break; } invocationIssuer = m_InvocationIssuer; if (invocationIssuer is double) { double last = (double)invocationIssuer; task._0001(last); break; } invocationIssuer = m_InvocationIssuer; if (invocationIssuer is float) { float init = (float)invocationIssuer; task._0001(init); } else { task._0001(Convert.ToDouble(m_InvocationIssuer, CultureInfo.InvariantCulture)); } break; } case Newtonsoft.Rules.UnicodeCategory.String: task._0004(m_InvocationIssuer?.ToString()); break; case Newtonsoft.Rules.UnicodeCategory.Boolean: task._0001(Convert.ToBoolean(m_InvocationIssuer, CultureInfo.InvariantCulture)); break; case Newtonsoft.Rules.UnicodeCategory.Date: { object invocationIssuer = m_InvocationIssuer; if (invocationIssuer is DateTimeOffset) { DateTimeOffset last2 = (DateTimeOffset)invocationIssuer; task._0001(last2); } else { task._0001(Convert.ToDateTime(m_InvocationIssuer, CultureInfo.InvariantCulture)); } break; } case Newtonsoft.Rules.UnicodeCategory.Bytes: task._0001((byte[])m_InvocationIssuer); break; case Newtonsoft.Rules.UnicodeCategory.Guid: task._0001((m_InvocationIssuer != null) ? ((Guid?)m_InvocationIssuer) : null); break; case Newtonsoft.Rules.UnicodeCategory.TimeSpan: task._0001((m_InvocationIssuer != null) ? ((TimeSpan?)m_InvocationIssuer) : null); break; case Newtonsoft.Rules.UnicodeCategory.Uri: task._0001((Uri)m_InvocationIssuer); break; default: throw CustomerListAnnotation.ConcatIssuer("Type", _ValIssuer, "Unexpected token type."); } }
public override object _0001(TagTestItem ident, Type b, object field, PrototypeError config2) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 if (ident._0001() == WatcherComposer.Null) { return(null); } FactoryDicCandidate factoryDicCandidate = null; string text = null; InstanceClassDispatcher instanceClassDispatcher = null; ident.SortError(); while (ident._0001() == WatcherComposer.PropertyName) { string text2 = ident._0001().ToString(); if (string.Equals(text2, "Case", StringComparison.OrdinalIgnoreCase)) { ident.SortError(); UtilsClientBridge utilsClientBridge = m_ParameterIssuer.InitReader(b); text = ident._0001().ToString(); factoryDicCandidate = utilsClientBridge.m_StatusIssuer.SingleOrDefault((FactoryDicCandidate P_0) => P_0._HelperIssuer == text); if (factoryDicCandidate == null) { throw StrategyError.PatchComposer(ident, "No union type found with the name '{0}'.".ListReader(CultureInfo.InvariantCulture, text)); } } else { if (!string.Equals(text2, "Fields", StringComparison.OrdinalIgnoreCase)) { throw StrategyError.PatchComposer(ident, "Unexpected property '{0}' found when reading union.".ListReader(CultureInfo.InvariantCulture, text2)); } ident.SortError(); if (ident._0001() != WatcherComposer.StartArray) { throw StrategyError.PatchComposer(ident, "Union fields must been an array."); } instanceClassDispatcher = (InstanceClassDispatcher)ParserFilterResolver.SelectClass(ident); } ident.SortError(); } if (factoryDicCandidate == null) { throw StrategyError.PatchComposer(ident, "No '{0}' property with union name found.".ListReader(CultureInfo.InvariantCulture, "Case")); } object[] array = new object[factoryDicCandidate.exceptionIssuer.Length]; if (factoryDicCandidate.exceptionIssuer.Length != 0 && instanceClassDispatcher == null) { throw StrategyError.PatchComposer(ident, "No '{0}' property with union fields found.".ListReader(CultureInfo.InvariantCulture, "Fields")); } if (instanceClassDispatcher != null) { if (factoryDicCandidate.exceptionIssuer.Length != instanceClassDispatcher.get_Count()) { throw StrategyError.PatchComposer(ident, "The number of field values does not match the number of properties defined by union '{0}'.".ListReader(CultureInfo.InvariantCulture, text)); } for (int i = 0; i < instanceClassDispatcher.get_Count(); i++) { ParserFilterResolver parserFilterResolver = instanceClassDispatcher[i]; PropertyInfo propertyInfo = factoryDicCandidate.exceptionIssuer[i]; array[i] = parserFilterResolver.ListClass(propertyInfo.PropertyType, config2); } } object[] task = new object[1] { array }; return(factoryDicCandidate.m_DatabaseIssuer.ConnectIssuer(task)); }