/// <summary> /// Creates a new reactive processing context using the specified services and with default service objects. /// </summary> /// <param name="expressionServices">Expression tree services.</param> /// <param name="clientService">Client-side operation services.</param> /// <param name="definitionService">Definition operation services.</param> /// <param name="metadataService">Metadata services.</param> protected ReactiveServiceContext(IReactiveExpressionServices expressionServices, IReactiveClientEngineProvider clientService, IReactiveDefinitionEngineProvider definitionService, IReactiveMetadataEngineProvider metadataService) : this(expressionServices, new ReactiveClient(clientService, expressionServices), new ReactiveDefinition(definitionService, expressionServices), new ReactiveMetadata(metadataService, expressionServices)) { var thisParameter = ResourceNaming.GetThisReferenceExpression(this); expressionServices.RegisterObject(this, thisParameter); }
protected Resource(ReactiveResourceContainer container, IReactiveExpressionServices expressionServices) { Debug.Assert(container != null); Uri = container.Uri; _expression = new Lazy <Expression>(() => expressionServices != null ? expressionServices.Normalize(container.Expression.ToExpression()) : container.Expression.ToExpression()); }
/// <summary> /// Creates a new reactive processing metadata object using the specified metadata operations provider. /// </summary> /// <param name="provider">Metadata operations provider.</param> /// <param name="expressionServices">Expression services object, used to perform expression tree manipulations.</param> public ReactiveMetadataProxy(IReactiveMetadataServiceProvider provider, IReactiveExpressionServices expressionServices) { _provider = provider ?? throw new ArgumentNullException(nameof(provider)); _expressionServices = expressionServices ?? throw new ArgumentNullException(nameof(expressionServices)); var thisParameter = ResourceNaming.GetThisReferenceExpression(this); expressionServices.RegisterObject(this, thisParameter); }
protected ReliableReactiveServiceContext(IReactiveExpressionServices expressionServices, ReliableReactiveClient client) { if (expressionServices == null) { throw new ArgumentNullException(nameof(expressionServices)); } Client = client ?? throw new ArgumentNullException(nameof(client)); var thisParameter = ResourceNaming.GetThisReferenceExpression(this); expressionServices.RegisterObject(this, thisParameter); }
/// <summary> /// Creates a new reactive processing context using the specified proxy objects. /// </summary> /// <param name="expressionServices">Expression tree services.</param> /// <param name="clientProxy">Client-side operation proxy.</param> /// <param name="definitionProxy">Definition operation proxy.</param> /// <param name="metadataProxy">Metadata service proxy.</param> protected ReactiveClientContext(IReactiveExpressionServices expressionServices, ReactiveClientProxy clientProxy, ReactiveDefinitionProxy definitionProxy, ReactiveMetadataProxy metadataProxy) { if (expressionServices == null) { throw new ArgumentNullException(nameof(expressionServices)); } Client = clientProxy; Definition = definitionProxy; Metadata = metadataProxy; var thisParameter = ResourceNaming.GetThisReferenceExpression(this); expressionServices.RegisterObject(this, thisParameter); }
/// <summary> /// Creates a new reactive processing context using the specified service objects. /// </summary> /// <param name="expressionServices">Expression tree services.</param> /// <param name="client">Client-side operation service object.</param> /// <param name="definition">Definition operation service object.</param> /// <param name="metadata">Metadata service object.</param> protected ReactiveServiceContext(IReactiveExpressionServices expressionServices, ReactiveClient client, ReactiveDefinition definition, ReactiveMetadata metadata) { if (expressionServices == null) { throw new ArgumentNullException(nameof(expressionServices)); } Client = client ?? throw new ArgumentNullException(nameof(client)); Definition = definition ?? throw new ArgumentNullException(nameof(definition)); Metadata = metadata ?? throw new ArgumentNullException(nameof(metadata)); var thisParameter = ResourceNaming.GetThisReferenceExpression(this); expressionServices.RegisterObject(this, thisParameter); }
/// <summary> /// Creates a new reactive processing client using the specified client operations provider. /// </summary> /// <param name="provider">Client operations provider.</param> /// <param name="expressionServices">Expression services object, used to perform expression tree manipulations.</param> public ReactiveClientProxy(IReactiveClientServiceProvider provider, IReactiveExpressionServices expressionServices) : base(new AsyncReactiveQueryProvider(provider, expressionServices)) { if (provider == null) { throw new ArgumentNullException(nameof(provider)); } if (expressionServices == null) { throw new ArgumentNullException(nameof(expressionServices)); } var thisParameter = ResourceNaming.GetThisReferenceExpression(this); expressionServices.RegisterObject(this, thisParameter); expressionServices.RegisterObject(base.Provider, Expression.Property(thisParameter, (PropertyInfo)ReflectionHelpers.InfoOf((IReactiveClientProxy c) => c.Provider))); }
public SubscriptionContext(IReactiveExpressionServices expressionServices, IReactiveServiceProvider serviceProvider) : base(expressionServices, serviceProvider) { }
public Subscription(ReactiveResourceContainer container, IReactiveExpressionServices expressionServices) : base(container, expressionServices) { }
/// <summary> /// Creates a new reactive processing context using the specified services. /// </summary> /// <param name="expressionServices">Expression tree services.</param> /// <param name="clientServiceProvider">Client/service provider.</param> protected ReactiveClientContext(IReactiveExpressionServices expressionServices, IReactiveServiceProvider clientServiceProvider) : this(expressionServices, clientServiceProvider, clientServiceProvider, clientServiceProvider) { }
/// <summary> /// Creates a new reactive processing context using the specified services and with default proxy objects. /// </summary> /// <param name="expressionServices">Expression tree services.</param> /// <param name="clientService">Client-side operation services.</param> /// <param name="definitionService">Definition operation services.</param> /// <param name="metadataService">Metadata services.</param> protected ReactiveClientContext(IReactiveExpressionServices expressionServices, IReactiveClientServiceProvider clientService, IReactiveDefinitionServiceProvider definitionService, IReactiveMetadataServiceProvider metadataService) : this(expressionServices, new ReactiveClientProxy(clientService, expressionServices), new ReactiveDefinitionProxy(definitionService, expressionServices), new ReactiveMetadataProxy(metadataService, expressionServices)) { }
public ProcessResource(ReactiveResourceContainer container, IReactiveExpressionServices expressionServices) : base(container, expressionServices) { State = container.State; }
/// <summary> /// Initializes the remoting client context using a given service provider. /// </summary> /// <param name="expressionServices">The expression services for normalization of expressions.</param> /// <param name="serviceProvider">The service provider underlying the client context.</param> public RemotingClientContext(IReactiveExpressionServices expressionServices, IReactiveServiceProvider serviceProvider) : base(expressionServices, serviceProvider) { }
public Observable(ReactiveResourceContainer container, IReactiveExpressionServices expressionServices) : base(container, expressionServices) { }
public ReliableQueryProvider(IReliableReactiveClientEngineProvider provider, IReactiveExpressionServices expressionServices) : base(expressionServices) { _provider = provider ?? throw new ArgumentNullException(nameof(provider)); }
/// <summary> /// Creates a new reactive processing client using the specified expression services object. /// </summary> /// <param name="expressionServices">Expression services object, used to perform expression tree manipulations.</param> protected ReliableReactiveClientBase(IReactiveExpressionServices expressionServices) { _expressionServices = expressionServices ?? throw new ArgumentNullException(nameof(expressionServices)); }
/// <summary> /// Instantiates the data converter with an expression services implementation /// to apply when serializing or deserializing expressions. /// </summary> /// <param name="expressionServices">The expression services.</param> public ReactiveResourceConverter(IReactiveExpressionServices expressionServices) { _expressionServices = expressionServices; }
public Stream(ReactiveResourceContainer container, IReactiveExpressionServices expressionServices) : base(container, expressionServices) { }
public AgentsTestContext(IReactiveExpressionServices expressionServices, IReactiveServiceProvider serviceProvider) : base(expressionServices, serviceProvider) { }
protected ReliableReactiveServiceContext(IReactiveExpressionServices expressionServices, IReliableReactiveEngineProvider engineProvider) : this(expressionServices, engineProvider, null) { }
public ReliableReactiveClient(IReliableReactiveClientEngineProvider provider, IReactiveExpressionServices expressionServices) : base(expressionServices) { if (provider == null) { throw new ArgumentNullException(nameof(provider)); } Provider = new ReliableQueryProvider(provider, expressionServices); // TODO: Re-enable this. //var thisParameter = ResourceNaming.GetThisReferenceExpression(this); //expressionServices.RegisterObject(this, thisParameter); //expressionServices.RegisterObject(_provider, Expression.Property(thisParameter, (PropertyInfo)ReflectionHelpers.InfoOf((IReactiveClient c) => c.Provider))); }
// TODO: Add the definition and metadata and remove the dummy object param. protected ReliableReactiveServiceContext(IReactiveExpressionServices expressionServices, IReliableReactiveClientEngineProvider clientEngineProvider, object removeme) : this(expressionServices, new ReliableReactiveClient(clientEngineProvider, expressionServices)) { _ = removeme; // See remark above. }
/// <summary> /// Creates a new reactive processing query provider with default factory method implementations. /// </summary> /// <param name="expressionServices">Expression services object, used to perform expression tree manipulations.</param> protected AsyncReactiveQueryProviderBase(IReactiveExpressionServices expressionServices) { ExpressionServices = expressionServices ?? throw new ArgumentNullException(nameof(expressionServices)); }
/// <summary> /// Instantiates the client context. /// </summary> /// <param name="expressionServices">The expression rewrite services.</param> /// <param name="serviceProvider">The service provider.</param> public ReificationClientContext(IReactiveExpressionServices expressionServices, IReactiveServiceProvider serviceProvider) : base(expressionServices, serviceProvider) { // NB: base used to accept new TupletizingExpressionServices(typeof(IReactiveClientProxy)), which has dependencies on DataModel etc. }