/// <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.
}
