Пример #1
0
        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
            }));
        }
Пример #2
0
        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);
        }
Пример #3
0
        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));
        }