Beispiel #1
0
 public override void _0003()
 {
     //Discarded unreachable code: IL_0002
     //IL_0003: Incompatible stack heights: 0 vs 1
     ((RecordClassDispatcher)m_ComposerIssuer)._0003();
     errorIssuer._0003();
     base._0003();
 }
        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();
        }
Beispiel #3
0
 public override void _0001(RecordClassDispatcher param, BroadcasterError[] token)
 {
     //Discarded unreachable code: IL_0002
     //IL_0003: Incompatible stack heights: 0 vs 1
     param._0003();
     for (int i = 0; i < attrIssuer.Count; i++)
     {
         attrIssuer[i]._0001(param, token);
     }
     param._000F();
 }
        private void VerifyClass(RecordClassDispatcher value, IEnumerable second, MessageTest state, ProductInstanceExpression reference2, InitializerTest v3, ProductInstanceExpression init4)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            ManagerErrorFilter managerErrorFilter = second as ManagerErrorFilter;
            object             obj = (managerErrorFilter != null) ? managerErrorFilter._0001() : second;

            ManageBroadcaster(value, state, obj);
            wrapperProperty.Add(obj);
            bool flag = ValidateClass(value, obj, state, reference2, v3, init4);

            value._0003();
            int lengthpred = value._0002();
            int num        = 0;

            foreach (object item in second)
            {
                try
                {
                    ProcTest procTest = ((InitializerTest)state)._0002() ?? DeleteBroadcaster(item);
                    if (CountBroadcaster(item, null, procTest, state, reference2))
                    {
                        QueryBroadcaster(value, item);
                    }
                    else if (CustomizeBroadcaster(value, item, null, procTest, state, reference2))
                    {
                        InvokeBroadcaster(value, item, procTest, null, state, reference2);
                    }
                }
                catch (Exception ident)
                {
                    if (!CheckBroadcaster(obj, state, num, null, value._0001(), ident))
                    {
                        throw;
                    }
                    EnableClass(value, lengthpred);
                }
                finally
                {
                    num++;
                }
            }
            value._000F();
            if (flag)
            {
                value._0011();
            }
            wrapperProperty.RemoveAt(wrapperProperty.Count - 1);
            InitBroadcaster(value, state, obj);
        }
Beispiel #5
0
 private void ManageRequest(RecordClassDispatcher task, XmlNamespaceManager result, bool skipres, CreatorIssuer cust2, string instance3)
 {
     //Discarded unreachable code: IL_0002
     //IL_0003: Incompatible stack heights: 0 vs 1
     if (!CancelRequest(cust2))
     {
         InitRequest(task, cust2, result, skipres);
         return;
     }
     if (skipres)
     {
         task._0002(instance3);
     }
     task._0003();
     InitRequest(task, cust2, result, isresult2: false);
     task._000F();
 }
        private void FindClass(RecordClassDispatcher instance, Array cont, MessageTest rule, ProductInstanceExpression ivk2, int cust3max, int[] last4)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            int num = last4.Length;

            int[] array = new int[num + 1];
            for (int i = 0; i < num; i++)
            {
                array[i] = last4[i];
            }
            instance._0003();
            for (int j = cont.GetLowerBound(num); j <= cont.GetUpperBound(num); j++)
            {
                array[num] = j;
                if (array.Length == cont.Rank)
                {
                    object value = cont.GetValue(array);
                    try
                    {
                        ProcTest procTest = ((InitializerTest)rule)._0002() ?? DeleteBroadcaster(value);
                        if (CountBroadcaster(value, null, procTest, rule, ivk2))
                        {
                            QueryBroadcaster(instance, value);
                        }
                        else if (CustomizeBroadcaster(instance, value, null, procTest, rule, ivk2))
                        {
                            InvokeBroadcaster(instance, value, procTest, null, rule, ivk2);
                        }
                    }
                    catch (Exception ident)
                    {
                        if (!CheckBroadcaster(cont, rule, j, null, instance._0001(), ident))
                        {
                            throw;
                        }
                        EnableClass(instance, cust3max + 1);
                    }
                }
                else
                {
                    FindClass(instance, cont, rule, ivk2, cust3max + 1, array);
                }
            }
            instance._000F();
        }
Beispiel #7
0
 public DicIssuer(RecordClassDispatcher asset)
 {
     //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();
     errorIssuer      = asset;
     m_PropertyIssuer = new StringWriter(CultureInfo.InvariantCulture);
     m_PropertyIssuer.Write("Serialized JSON: " + Environment.NewLine);
     m_ComposerIssuer = new StatusDicCandidate(m_PropertyIssuer);
     m_ComposerIssuer._0001((TimeState)1);
     m_ComposerIssuer._0001(asset._0001());
     m_ComposerIssuer._0001(asset._0001());
     m_ComposerIssuer._0007(asset._0003());
     m_ComposerIssuer._0001(asset._0001());
     m_ComposerIssuer._0001(asset._0001());
 }
Beispiel #8
0
 private void SetupRequest(RecordClassDispatcher reference, XmlNamespaceManager cont, bool addcomp, List <CreatorIssuer> vis2, string ident3)
 {
     //Discarded unreachable code: IL_0002
     //IL_0003: Incompatible stack heights: 0 vs 1
     if (vis2.Count == 1 && !CancelRequest(vis2[0]))
     {
         InitRequest(reference, vis2[0], cont, addcomp);
         return;
     }
     if (addcomp)
     {
         reference._0002(ident3);
     }
     reference._0003();
     for (int i = 0; i < vis2.Count; i++)
     {
         InitRequest(reference, vis2[i], cont, isresult2: false);
     }
     reference._000F();
 }
Beispiel #9
0
        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();
        }
Beispiel #10
0
        internal virtual void _0001(RecordClassDispatcher param, object cont, Type c)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            ContextClientBridge.RunClient(param, "jsonWriter");
            TimeState?timeState = null;

            if (_RuleError.HasValue && param._0001() != _RuleError)
            {
                timeState = param._0001();
                param._0001(_RuleError.GetValueOrDefault());
            }
            FindDirection?findDirection = null;

            if (m_BridgeError.HasValue && param._0001() != m_BridgeError)
            {
                findDirection = param._0001();
                param._0001(m_BridgeError.GetValueOrDefault());
            }
            PsMaxLengths?psMaxLengths = null;

            if (importerError.HasValue && param._0001() != importerError)
            {
                psMaxLengths = param._0001();
                param._0001(importerError.GetValueOrDefault());
            }
            ApplicationPartitionType?applicationPartitionType = null;

            if (m_IndexerError.HasValue && param._0001() != m_IndexerError)
            {
                applicationPartitionType = param._0001();
                param._0001(m_IndexerError.GetValueOrDefault());
            }
            GraphGroupStyle?graphGroupStyle = null;

            if (_FieldError.HasValue && param._0001() != _FieldError)
            {
                graphGroupStyle = param._0001();
                param._0001(_FieldError.GetValueOrDefault());
            }
            CultureInfo cultureInfo = null;

            if (m_ItemError != null && !m_ItemError.Equals(param._0001()))
            {
                cultureInfo = param._0001();
                param._0001(m_ItemError);
            }
            string var = null;

            if (proccesorError && param._0003() != containerError)
            {
                var = param._0003();
                param._0007(containerError);
            }
            DicIssuer dicIssuer = (this._0001() != null && this._0001()._0001() >= TraceLevel.Verbose) ? new DicIssuer(param) : null;

            new InterceptorInstanceExpression(this).ListBroadcaster(dicIssuer ?? param, cont, c);
            if (dicIssuer != null)
            {
                this._0001()._0001(TraceLevel.Verbose, dicIssuer.ReflectClass(), null);
            }
            if (timeState.HasValue)
            {
                param._0001(timeState.GetValueOrDefault());
            }
            if (findDirection.HasValue)
            {
                param._0001(findDirection.GetValueOrDefault());
            }
            if (psMaxLengths.HasValue)
            {
                param._0001(psMaxLengths.GetValueOrDefault());
            }
            if (applicationPartitionType.HasValue)
            {
                param._0001(applicationPartitionType.GetValueOrDefault());
            }
            if (graphGroupStyle.HasValue)
            {
                param._0001(graphGroupStyle.GetValueOrDefault());
            }
            if (proccesorError)
            {
                param._0007(var);
            }
            if (cultureInfo != null)
            {
                param._0001(cultureInfo);
            }
        }
        private string AddClass(RecordClassDispatcher item, object result, ProcTest temp, out bool last2)
        {
            //Discarded unreachable code: IL_0002
            //IL_0003: Incompatible stack heights: 0 vs 1
            if (temp._ErrorProperty == (ParameterFilterResolver)3)
            {
                ProccesorClassSpec proccesorClassSpec = (ProccesorClassSpec)temp;
                switch (proccesorClassSpec._0001())
                {
                case (SettingsSerializeAs)26:
                case (SettingsSerializeAs)27:
                {
                    DateTime token = DescriptorIteratorMapping.ReadProperty((DateTime)result, item._0001());
                    last2 = false;
                    StringWriter stringWriter2 = new StringWriter(CultureInfo.InvariantCulture);
                    DescriptorIteratorMapping.TestProperty(stringWriter2, token, item._0001(), item._0003(), item._0001());
                    return(stringWriter2.ToString());
                }

                case (SettingsSerializeAs)28:
                case (SettingsSerializeAs)29:
                {
                    last2 = false;
                    StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture);
                    DescriptorIteratorMapping.AssetProperty(stringWriter, (DateTimeOffset)result, item._0001(), item._0003(), item._0001());
                    return(stringWriter.ToString());
                }

                case (SettingsSerializeAs)24:
                case (SettingsSerializeAs)25:
                {
                    double num = (double)result;
                    last2 = false;
                    return(num.ToString("R", CultureInfo.InvariantCulture));
                }

                case (SettingsSerializeAs)22:
                case (SettingsSerializeAs)23:
                {
                    float num2 = (float)result;
                    last2 = false;
                    return(num2.ToString("R", CultureInfo.InvariantCulture));
                }

                default:
                {
                    last2 = true;
                    if (proccesorClassSpec._FilterProperty && InfoFilterResolver.InsertIssuer(proccesorClassSpec._InstanceProperty, result, null, out string _0005))
                    {
                        return(_0005);
                    }
                    return(Convert.ToString(result, CultureInfo.InvariantCulture));
                }
                }
            }
            if (ExcludeBroadcaster(result, result.GetType(), out string _0004))
            {
                last2 = true;
                return(_0004);
            }
            last2 = true;
            return(result.ToString());
        }