internal ManagerErrorFilter CalculateClient(object def) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 if (m_ExporterTest == null) { annotationTest = typeof(GDBD.Dispatcher.SetterComposer <>).MakeGenericType(this._0001()); Type type = (!ResolverErrorFilter.RunReader(_AlgoTest, typeof(List <>)) && !(_AlgoTest.GetGenericTypeDefinition() == typeof(IEnumerable <>))) ? _AlgoTest : typeof(ICollection <>).MakeGenericType(this._0001()); ConstructorInfo constructor = annotationTest.GetConstructor(new Type[1] { type }); m_ExporterTest = ConfigProperty._0001()._0001(constructor); } return((ManagerErrorFilter)m_ExporterTest(new object[1] { def })); }
public void _0001(GDBD.Specifications.AdapterClassSpec <object> ident) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 _RepositoryProperty = ident; }
internal void _0002(GDBD.Specifications.AdapterClassSpec <object> res) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 getterProperty = res; }
public void _0001(GDBD.Specifications.AdapterClassSpec <object> spec) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 identifierProperty = spec; }
public static ModelInstanceExpression InitIssuer(Type var1, MethodBase cfg, string[] field) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 VisitorComposer visitorComposer = ConfigProperty._0001(); GDBD.Specifications.AdapterClassSpec <object> last = null; if (cfg != null) { last = visitorComposer._0001(cfg); } else if (ResolverErrorFilter.LoginReader(var1, isconnection: false)) { Func <object> func = visitorComposer._0001 <object>(var1); last = ((object[] P_0) => func()); } ModelInstanceExpression modelInstanceExpression = new ModelInstanceExpression(last); Newtonsoft.Rules.ClientInstanceRule <object, object> clientInstanceRule; Newtonsoft.Rules.ClientInstanceRule <object, object> clientInstanceRule2; foreach (string text in field) { MemberInfo[] member = var1.GetMember(text, BindingFlags.Instance | BindingFlags.Public); if (member.Length != 1) { throw new ArgumentException("Expected a single member with the name '{0}'.".ListReader(CultureInfo.InvariantCulture, text)); } MemberInfo memberInfo = member.Single(); StubTest stubTest = new StubTest(); switch (memberInfo.DefineReader()) { case MemberTypes.Field: case MemberTypes.Property: if (ResolverErrorFilter.LogoutReader(memberInfo, updateb: false)) { stubTest._0001(visitorComposer.ValidateIssuer <object>(memberInfo)); } if (ResolverErrorFilter.VisitReader(memberInfo, calcconnection: false, addrule: false)) { stubTest._0001(visitorComposer.OrderIssuer <object>(memberInfo)); } break; case MemberTypes.Method: { MethodInfo methodInfo = (MethodInfo)memberInfo; if (methodInfo.IsPublic) { ParameterInfo[] parameters = methodInfo.GetParameters(); if (parameters.Length == 0 && methodInfo.ReturnType != typeof(void)) { clientInstanceRule = visitorComposer._0001 <object>(methodInfo); stubTest._0001((object P_0) => clientInstanceRule(P_0, new object[0])); } else if (parameters.Length == 1 && methodInfo.ReturnType == typeof(void)) { clientInstanceRule2 = visitorComposer._0001 <object>(methodInfo); stubTest._0001(delegate(object P_0, object P_1) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 clientInstanceRule2(P_0, new object[1] { P_1 }); }); } } break; } default: throw new ArgumentException("Unexpected member type '{0}' for member '{1}'.".SelectReader(CultureInfo.InvariantCulture, memberInfo.DefineReader(), memberInfo.Name)); } stubTest._0001(ResolverErrorFilter.InsertReader(memberInfo)); modelInstanceExpression._0001()[text] = stubTest; } return(modelInstanceExpression); }
public MessageTest(Type instance) { //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(instance); _ErrorProperty = (ParameterFilterResolver)2; m_GlobalTest = (base._0003().IsArray || (_InstanceProperty.CallReader() && _InstanceProperty.GetGenericTypeDefinition().FullName == "System.Linq.EmptyPartition`1")); bool forcedef; Type _0004; if (this._0002()) { _ProductTest = ResolverErrorFilter.EnableReader(base._0002()); composerProperty = true; _AlgoTest = typeof(List <>).MakeGenericType(this._0001()); forcedef = true; m_InterceptorTest = (base._0003().IsArray&& base._0002().GetArrayRank() > 1); } else if (typeof(IList).IsAssignableFrom(_InstanceProperty)) { if (ResolverErrorFilter.FillReader(_InstanceProperty, typeof(ICollection <>), out _AlgoTest)) { _ProductTest = _AlgoTest.GetGenericArguments()[0]; } else { _ProductTest = ResolverErrorFilter.EnableReader(_InstanceProperty); } if (_InstanceProperty == typeof(IList)) { _0002(typeof(List <object>)); } if (this._0001() != null) { _TemplateTest = ObserverIteratorMapping.ManageTest(_InstanceProperty, this._0001()); } composerProperty = ResolverErrorFilter.RunReader(_InstanceProperty, typeof(ReadOnlyCollection <>)); forcedef = true; } else if (ResolverErrorFilter.FillReader(_InstanceProperty, typeof(ICollection <>), out _AlgoTest)) { _ProductTest = _AlgoTest.GetGenericArguments()[0]; if (ResolverErrorFilter.OrderReader(_InstanceProperty, typeof(ICollection <>)) || ResolverErrorFilter.OrderReader(_InstanceProperty, typeof(IList <>))) { _0002(typeof(List <>).MakeGenericType(this._0001())); } if (ResolverErrorFilter.OrderReader(_InstanceProperty, typeof(ISet <>))) { _0002(typeof(HashSet <>).MakeGenericType(this._0001())); } _TemplateTest = ObserverIteratorMapping.ManageTest(_InstanceProperty, this._0001()); forcedef = true; _WrapperTest = true; } else if (ResolverErrorFilter.FillReader(_InstanceProperty, typeof(IEnumerable <>), out _0004)) { _ProductTest = _0004.GetGenericArguments()[0]; if (ResolverErrorFilter.OrderReader(base._0002(), typeof(IEnumerable <>))) { _0002(typeof(List <>).MakeGenericType(this._0001())); } _TemplateTest = ObserverIteratorMapping.ManageTest(_InstanceProperty, this._0001()); StartClient(_InstanceProperty); if (_InstanceProperty.CallReader() && _InstanceProperty.GetGenericTypeDefinition() == typeof(IEnumerable <>)) { _AlgoTest = _0004; composerProperty = false; _WrapperTest = false; forcedef = true; } else { _AlgoTest = typeof(List <>).MakeGenericType(this._0001()); composerProperty = true; _WrapperTest = true; forcedef = _0006(); } } else { forcedef = false; _WrapperTest = true; } _0001(forcedef); if (this._0001() != null && ParamRequestStrategy.CalcIssuer(_InstanceProperty, this._0001(), out Type _00042, out GDBD.Specifications.AdapterClassSpec <object> _0005)) { _0002(_00042); m_ExpressionTest = _0005; composerProperty = true; _0001(forcedef: true); } }
internal static bool InstantiateIssuer(Type setup, Type result, Type consumer, [ConsumerBroadcasterDispatcher(true)][_0008._0012(2)] out Type _0005, [ConsumerBroadcasterDispatcher(true)][_0008._0012(new byte[] { 2, 1 })] out GDBD.Specifications.AdapterClassSpec <object> _0006) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 if (setup.CallReader()) { Type genericTypeDefinition = setup.GetGenericTypeDefinition(); string fullName = genericTypeDefinition.FullName; RegistryTest registryTest = proxyTest.FirstOrDefault((RegistryTest P_0) => P_0._0001() == fullName); if (registryTest != null) { Type type = genericTypeDefinition.RevertReader().GetType(registryTest._0002()); Type type2 = genericTypeDefinition.RevertReader().GetType(registryTest._0003()); if (type != null && type2 != null) { MethodInfo methodInfo = type2.GetMethods().FirstOrDefault(delegate(MethodInfo v) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 ParameterInfo[] parameters = v.GetParameters(); return(v.Name == "CreateRange" && parameters.Length == 1 && parameters[0].ParameterType.CallReader() && parameters[0].ParameterType.GetGenericTypeDefinition() == typeof(IEnumerable <>)); }); if (methodInfo != null) { _0005 = type.MakeGenericType(result, consumer); MethodInfo v2 = methodInfo.MakeGenericMethod(result, consumer); _0006 = ConfigProperty._0001()._0001(v2); return(true); } } } } _0005 = null; _0006 = null; return(false); }
internal static bool CalcIssuer(Type i, Type b, [ConsumerBroadcasterDispatcher(true)][_0008._0012(2)] out Type _0004, [_0008._0012(new byte[] { 2, 1 })][ConsumerBroadcasterDispatcher(true)] out GDBD.Specifications.AdapterClassSpec <object> _0005) { //Discarded unreachable code: IL_0002 //IL_0003: Incompatible stack heights: 0 vs 1 if (i.CallReader()) { Type genericTypeDefinition = i.GetGenericTypeDefinition(); string fullName = genericTypeDefinition.FullName; RegistryTest registryTest = _QueueTest.FirstOrDefault((RegistryTest P_0) => P_0._0001() == fullName); if (registryTest != null) { Type type = genericTypeDefinition.RevertReader().GetType(registryTest._0002()); Type type2 = genericTypeDefinition.RevertReader().GetType(registryTest._0003()); if (type != null && type2 != null) { MethodInfo methodInfo = type2.GetMethods().FirstOrDefault((MethodInfo spec) => spec.Name == "CreateRange" && spec.GetParameters().Length == 1); if (methodInfo != null) { _0004 = type.MakeGenericType(b); MethodInfo v = methodInfo.MakeGenericMethod(b); _0005 = ConfigProperty._0001()._0001(v); return(true); } } } } _0004 = null; _0005 = null; return(false); }