public async Task Should_chain_in_order2() { /* Given */ var values = new List <int>(); var builder = new ResolverBuilder(); builder.Use((context, next) => { values.Add(0); return(next(context)); }); builder.Use((context, next) => { var result = next(context); values.Add(1); return(result); }); builder.Use((context, next) => { values.Add(2); return(next(context)); }); builder.Run(context => new ValueTask <IResolverResult>(Resolve.As(42))); /* When */ var resolver = builder.Build(); await resolver(null); /* Then */ Assert.Equal(new[] { 0, 2, 1 }, values.ToArray()); }
private IResolver EnsureResolver(Type type) { if (_resolverCache.TryGetValue(type, out IResolver resolver)) { return(resolver); } IResolverBuilder builder = new ResolverBuilder(type, _definitions, this); if (_resolversBeingBuilt.Contains(builder.InstanceType)) { return(null); } _resolversBeingBuilt.Add(builder.InstanceType); try { var enumerable = builder.GetEnumerableResolver(); if (builder.EnumerableType != null) { _resolverCache[builder.EnumerableType] = enumerable; } var instance = builder.GetInstanceResolver(); if (builder.InstanceType != null) { _resolverCache[builder.InstanceType] = instance; } return(type.IsEnumerable() ? enumerable : instance); } finally { _resolversBeingBuilt.Remove(builder.InstanceType); } }
private void LevelUpdateCallBack(object state) { //object[] objParams = state as object[]; DataTable dtHL = state as DataTable; string extHierarchyID = string.Empty; Int16 groupingLevel = 0; ResolverBuilder requestResolver = new ResolverBuilder(); try { requestResolver.Build(); requestResolver.Container.RegisterType <IProductService, ProductService>(new HierarchicalLifetimeManager()); IProductService ps = requestResolver.Container.Resolve <IProductService>(); foreach (DataRow row in dtHL.Rows) { extHierarchyID = row["ExtHierarchyID"].ToString(); groupingLevel = row["LevelInHierarchy"].ConvertToInt16(); AMSResult <bool> amsResult = m_ProductService.UpdateHierarchyLevel(extHierarchyID, groupingLevel); if (amsResult.ResultType != AMSResultType.Success) { infobar.Visible = true; infobar.InnerHtml = PhraseLib.Lookup("pab.config.levelupdateerror", LanguageID) + ": " + amsResult.MessageString; } } } catch (Exception ex) { infobar.Visible = true; infobar.InnerHtml = PhraseLib.Lookup("pab.config.levelupdateerror", LanguageID) + ": " + ex.Message; } }
public void CreateSourcePropertyResolver() { // arrange var context = new Mock <IResolverContext>(MockBehavior.Strict); context.Setup(t => t.Parent <FooType>()) .Returns(new FooType()); context.Setup(t => t.RequestAborted) .Returns(CancellationToken.None); var fieldMember = new FieldMember( "type", "field", typeof(FooType).GetProperty("BarProperty")); var descriptor = new SourceResolverDescriptor( typeof(FooType), fieldMember); // act var resolverBuilder = new ResolverBuilder(); resolverBuilder.AddDescriptor(descriptor); ResolverBuilderResult result = resolverBuilder.Build(); // assert Assert.Collection(result.Resolvers, r => { Assert.Equal("type", r.TypeName); Assert.Equal("field", r.FieldName); Assert.NotNull(r.Resolver); object resolvedResult = r.Resolver( context.Object).Result; Assert.Equal("Hello World Property", resolvedResult); }); }
private ResolverBuilderResult CompileResolvers() { var resolverBuilder = new ResolverBuilder(); resolverBuilder.AddDescriptors(CreateResolverDescriptors()); resolverBuilder.AddDescriptors(CreateMiddlewareDescriptors()); resolverBuilder.AddDescriptors(_resolverDescriptors.Values); return(resolverBuilder.Build()); }
private IServiceResolver GetResolver(string name) { ResolverBuilder resolverBuilder = new ResolverBuilder(); resolverBuilder.Build(); IServiceResolver serviceResolver = resolverBuilder.GetResolver(); serviceResolver.AppName = name; return(serviceResolver); }
public bool TryGetResolver(TypeSystem.ComplexType type, string fieldName, out ResolverBuilder resolver) { if (_resolvers.TryGetValue(type.Name, out var fields)) { if (fields.TryGetValue(fieldName, out resolver)) { return(true); } } resolver = null; return(false); }
public DirectiveFieldVisitorContext WithResolver(Action <ResolverBuilder> build) { if (build == null) { throw new ArgumentNullException(nameof(build)); } var builder = new ResolverBuilder(); build(builder); return(new DirectiveFieldVisitorContext(Name, Field, builder.Build(), Subscriber)); }
public void CreateAsyncCollectionMethodResolver() { // arrange var context = new Mock <IResolverContext>(MockBehavior.Strict); context.Setup(t => t.Parent <FooType>()) .Returns(new FooType()); context.Setup(t => t.Resolver <FooTypeResolver>()) .Returns(new FooTypeResolver()); context.Setup(t => t.RequestAborted) .Returns(CancellationToken.None); var argumentDescriptor = new ArgumentDescriptor( "foo", "b", ArgumentKind.Source, typeof(FooType), null); var fieldMember = new FieldMember( "type", "field", typeof(FooTypeResolver).GetMethod("BarResolverAsync")); var descriptor = new ResolverDescriptor( typeof(FooTypeResolver), typeof(FooType), fieldMember, new[] { argumentDescriptor }); // act var resolverBuilder = new ResolverBuilder(); resolverBuilder.AddDescriptor(descriptor); ResolverBuilderResult result = resolverBuilder.Build(); // assert Assert.Collection(result.Resolvers, r => { Assert.Equal("type", r.TypeName); Assert.Equal("field", r.FieldName); Assert.NotNull(r.Resolver); object resolvedValue = r.Resolver( context.Object) .Result; Assert.Equal("Hello World_123", resolvedValue); }); }
/// <summary> /// checks to see if the name has a cname /// we use Ubiety because MySQL uses it and /// we dont want to introduce a new DNS class /// </summary> /// <param name="hostName"></param> /// <returns></returns> public static string GetCNameOfHostOrNull(string hostName) { Resolver dnsLookup = ResolverBuilder.Begin().SetTimeout(1000) .SetRetries(3) .UseRecursion() .Build(); string returnValue = null; Response dnsResponse = dnsLookup.Query(hostName, Ubiety.Dns.Core.Common.QuestionType.CNAME, Ubiety.Dns.Core.Common.QuestionClass.IN); List <Ubiety.Dns.Core.Records.General.RecordCname> cnameRecords = dnsResponse.GetRecords <Ubiety.Dns.Core.Records.General.RecordCname>(); if (cnameRecords.Count > 0) { returnValue = cnameRecords[0].Cname; } return(returnValue); }
public ConnectionBuilder Include( ObjectType objectType, string fieldName, ResolverBuilder resolver) { if (_resolvers.TryGetValue(objectType.Name, out var fieldResolvers)) { fieldResolvers.Add(fieldName, resolver); } else { throw new ArgumentOutOfRangeException(nameof(objectType), $"Cannot include resolver. Unknown type '{objectType.Name}'."); } return(this); }
public ResolverBuilder Resolver(ComplexType owner, string fieldName) { if (!_resolvers.ContainsKey(owner.Name)) { _resolvers[owner.Name] = new Dictionary <string, ResolverBuilder>(); } if (_resolvers[owner.Name].ContainsKey(fieldName)) { throw new SchemaBuilderException(owner.Name, $"Cannot add resolver for '{fieldName}'. Resolver has been already created. Use {nameof(GetOrAddResolver)}."); } var builder = new ResolverBuilder(); _resolvers[owner.Name].Add(fieldName, builder); return(builder); }
public static void Compile( IDictionary <FieldReference, RegisteredResolver> resolvers) { if (resolvers == null) { throw new ArgumentNullException(nameof(resolvers)); } var resolverBuilder = new ResolverBuilder(); foreach (RegisteredResolver resolver in resolvers.Values) { if (resolver.Field is FieldMember member) { if (resolver.IsSourceResolver) { resolverBuilder.AddDescriptor( new SourceResolverDescriptor( resolver.SourceType, member)); } else { resolverBuilder.AddDescriptor( new ResolverDescriptor( resolver.ResolverType, resolver.SourceType, member)); } } } ResolverBuilderResult result = resolverBuilder.Build(); foreach (FieldResolver resolver in result.Resolvers) { var reference = resolver.ToFieldReference(); if (resolvers.TryGetValue(reference, out RegisteredResolver registered)) { resolvers[reference] = registered.WithField(resolver); } } }
public async Task Should_propagate_resolved_value() { /* Given */ var builder = new ResolverBuilder(); builder .Use((context, next) => next(context)) .Use((context, next) => next(context)) .Use((context, next) => next(context)); builder.Run(context => new ValueTask <IResolverResult>(Resolve.As(42))); /* When */ var resolver = builder.Build(); var result = await resolver(null); /* Then */ Assert.Equal(42, result.Value); }
public void Should_not_call_chain_until_resolver_executed() { /* Given */ var values = new List <int>(); var builder = new ResolverBuilder(); builder.Use((context, next) => { values.Add(0); return(next(context)); }); builder.Run(context => new ValueTask <IResolverResult>(Resolve.As(42))); /* When */ builder.Build(); /* Then */ Assert.Equal(new int[] {}, values.ToArray()); }
public void Application_Start(object sender, EventArgs e) { //Initialize NEP Application NepServiceApplication.Init(); WebApiConfig.Register(GlobalConfiguration.Configuration); // Code that runs on application startup CMS.AMS.ResolverBuilder resolver = new ResolverBuilder(); CurrentRequest.Resolver = resolver.GetResolver(); CurrentRequest.Resolver.AppName = "Global.asax"; IDBAccess m_dbaccess = CurrentRequest.Resolver.Resolve <DBAccess>(); SQLParametersList paramlist = new SQLParametersList(); String QueryStr = "Update Folders set MassOperationStatus = '~FNIU~'"; m_dbaccess.ExecuteNonQuery(DataBases.LogixRT, CommandType.Text, QueryStr, paramlist); //Adding health monitors InitializeHealthMonitors(); HealthOptions.AddHealthMonitors(componentHealthMonitors.ToArray()); }
public DirectiveFieldVisitorContext WithSubscriber(Action <ResolverBuilder> buildResolver, Action <SubscriberBuilder> buildSubscriber) { if (buildResolver == null) { throw new ArgumentNullException(nameof(buildResolver)); } if (buildSubscriber == null) { throw new ArgumentNullException(nameof(buildSubscriber)); } var resolverBuilder = new ResolverBuilder(); buildResolver(resolverBuilder); var subscriberBuilder = new SubscriberBuilder(); buildSubscriber(subscriberBuilder); return(new DirectiveFieldVisitorContext(Name, Field, resolverBuilder.Build(), subscriberBuilder.Build())); }
private static (Type Type, Type ResolverType) CreateType() { var fields = new Dictionary <string, Type> { { "Name", typeof(string) }, }; for (var i = 1; i < 100; i++) { fields.Add($"DecimalProp{i}", typeof(decimal)); } for (var i = 1; i < 100; i++) { fields.Add($"StringProp{i}", typeof(string)); } var assemblyName = new AssemblyName($"DynamicTyping{Guid.NewGuid():N}"); var assemblyBuilder = AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run); var moduleBuilder = assemblyBuilder.DefineDynamicModule(assemblyName.Name); var typeBuilder = moduleBuilder.DefineType("Person", TypeAttributes.Public | TypeAttributes.Class); // static fields typeBuilder .WithField("Id", typeof(Guid)) .WithIgnoredField("Parent", typeBuilder) .WithField("Children", typeof(List <>).MakeGenericType(typeBuilder)); foreach (var(fieldName, fieldType) in fields) { typeBuilder.WithField(fieldName, fieldType); } var type = typeBuilder.CreateType(); var resolverType = new ResolverBuilder(moduleBuilder).Build(type); return(type, resolverType); }
public ConcurrencyStrategy(ConcurrencyConflict value, string displayName, ResolverBuilder builder) : base(value, displayName) { Build = builder; }