public SqlCommandProcessor( IDataReaderFactory dataReaderFactory, IParameterConverter parameterConverter) { _dataReaderFactory = dataReaderFactory; _parameterConverter = parameterConverter; }
// Use the ASP.NET Core DI system to inject these dependencies public PluginLoadOptions( IPluginLogger <T> logger, IAssemblyScanner <T> assemblyScanner, ISharedServicesProvider <T> sharedServicesProvider, IPluginTypesProvider <T> pluginTypesProvider, IPluginActivationContextProvider <T> pluginActivationContextProvider, IRemotePluginActivator <T> activator, IParameterConverter parameterConverter, IResultConverter resultConverter, IPluginAssemblyLoader <T> assemblyLoader, IPluginProxyCreator <T> proxyCreator, IHostTypesProvider <T> hostTypesProvider, IRemoteTypesProvider <T> remoteTypesProvider, IRuntimePlatformContext runtimePlatformContext, IAssemblySelector <T> assemblySelector, IPluginSelector <T> pluginSelector ) { this.logger = logger; this.assemblyScanner = assemblyScanner; this.sharedServicesProvider = sharedServicesProvider; this.pluginTypesProvider = pluginTypesProvider; this.pluginActivationContextProvider = pluginActivationContextProvider; this.activator = activator; this.parameterConverter = parameterConverter; this.resultConverter = resultConverter; this.assemblyLoader = assemblyLoader; this.proxyCreator = proxyCreator; this.hostTypesProvider = hostTypesProvider; this.remoteTypesProvider = remoteTypesProvider; this.runtimePlatformContext = runtimePlatformContext; this.assemblySelector = assemblySelector; this.pluginSelector = pluginSelector; }
public DimensionConverter(IDimensionMapper dimensionMapper, IParameterConverter parameterConverter, IUsingFormulaConverter usingFormulaConverter, IDataRepositoryConverter dataRepositoryConverter) { _dimensionMapper = dimensionMapper; _parameterConverter = parameterConverter; _usingFormulaConverter = usingFormulaConverter; _dataRepositoryConverter = dataRepositoryConverter; }
public RAMLDocGeneratorV08(IApiDescriptionGroupCollectionProvider apiDescription, IParameterConverter parameterConverter, IMethodConverter methodConverter, IComments comments) { this.apiDescription = apiDescription; this.parameterConverter = parameterConverter; this.methodConverter = methodConverter; this.comments = comments; }
public PluginLoadOptionsBuilder <T> WithDefaultOptions(string pluginPath = null) { if (String.IsNullOrEmpty(pluginPath)) { pluginPath = Path.Join(GetLocalExecutionPath(), "Plugins"); } this.pluginPathProvider = new DefaultPluginPathProvider <T>(pluginPath); this.dependencyPathProvider = new DependencyPathProvider <T>(pluginPath); this.runtimePlatformContext = new RuntimePlatformContext(); this.ScanForAssemblies(composer => composer.WithDefaultOptions <DefaultAssemblyScanner <T>, DefaultAssemblyScannerOptions <T> >()); this.pluginAssemblyNameProvider = new PluginAssemblyNameProvider <T>($"{typeof(T).Name}.dll"); this.sharedServicesProvider = new DefaultSharedServicesProvider <T>(new ServiceCollection()); this.activator = new DefaultRemotePluginActivator <T>(this.sharedServicesProvider); this.proxyCreator = new PluginProxyCreator <T>(); // Use System.Text.Json in 3.0 #if NETCORE3_0 this.parameterConverter = new JsonSerializerParameterConverter(); this.resultConverter = new JsonSerializerResultConverter(); this.assemblyLoaderType = typeof(DefaultAssemblyLoaderWithNativeResolver <T>); #endif // Use Newtonsoft.Json in 2.1 #if NETCORE2_1 this.parameterConverter = new NewtonsoftParameterConverter(); this.resultConverter = new NewtonsoftResultConverter(); this.assemblyLoaderType = typeof(DefaultAssemblyLoader <T>); #endif this.assemblySelector = new DefaultAssemblySelector <T>(); this.assemblyLoadOptions = new DefaultAssemblyLoadOptions <T>( PluginPlatformVersion.Empty(), false, NativeDependencyLoadPreference.PreferInstalledRuntime); this.probingPathsProvider = new ProbingPathsProvider <T>(); var hostTypesProvider = new HostTypesProvider(); hostTypesProvider.AddHostType(typeof(Prise.Plugin.PluginAttribute)); // Add the Prise.Infrastructure assembly to the host types hostTypesProvider.AddHostType(typeof(ServiceCollection)); // Adds the BuildServiceProvider assembly to the host types this.hostTypesProvider = hostTypesProvider; var remoteTypesProvider = new RemoteTypesProvider <T>(); remoteTypesProvider.AddRemoteType(typeof(T)); // Add the contract to the remote types, so that we can have backwards compatibility this.remoteTypesProvider = remoteTypesProvider; this.pluginSelector = new DefaultPluginSelector <T>(); this.depsFileProviderType = typeof(DefaultDepsFileProvider <T>); this.pluginDependencyResolverType = typeof(DefaultPluginDependencyResolver <T>); // Typically used for downloading and storing plugins from the network, but it could be useful for caching local plugins as well this.tempPathProviderType = typeof(UserProfileTempPathProvider <T>); this.nativeAssemblyUnloaderType = typeof(DefaultNativeAssemblyUnloader); this.hostFrameworkProviderType = typeof(HostFrameworkProvider); return(this); }
internal PluginProxy <T> SetParameterConverter(IParameterConverter parameterConverter) { if (parameterConverter == null) { throw new PrisePluginException($"IParameterConverter for Proxy<{typeof(T).Name}> was null"); } this.parameterConverter = parameterConverter; return(this); }
protected virtual void Dispose(bool disposing) { if (!this.disposed && disposing) { this.parameterConverter = null; this.resultConverter = null; this.remoteObject = null; } this.disposed = true; }
public static TProxyType CreateProxy <TProxyType>(object remoteObject, IParameterConverter parameterConverter, IResultConverter resultConverter) { var proxy = PluginProxy <TProxyType> .Create(); ((PluginProxy <TProxyType>)proxy) .SetRemoteObject(remoteObject) .SetParameterConverter(parameterConverter) .SetResultConverter(resultConverter); return((TProxyType)proxy); }
public CommandProcessorFactory( IProcedureLibrary storedProcedureLibrary, IProcedureRunner storedProcedureRunner, IDataReaderFactory dataReaderFactory, IParameterConverter parameterConverter) { _storedProcedureLibrary = storedProcedureLibrary; _storedProcedureRunner = storedProcedureRunner; _dataReaderFactory = dataReaderFactory; _parameterConverter = parameterConverter; }
internal static object[] SerializeParameters(IParameterConverter parameterConverter, MethodInfo targetMethod, object[] args) { var parameters = targetMethod.GetParameters(); var results = new List <object>(); for (var index = 0; index < parameters.Count(); index++) { var parameter = parameters[index]; var parameterValue = args[index]; results.Add(parameterConverter.ConvertToRemoteType(parameter.ParameterType, parameterValue)); } return(results.ToArray()); }
public DefaultPluginLoader( IAssemblyScanner assemblyScanner, IPluginTypeSelector pluginTypeSelector, IAssemblyLoader assemblyLoader, IParameterConverter parameterConverter, IResultConverter resultConverter, IPluginActivator pluginActivator) { this.assemblyScanner = assemblyScanner; this.pluginTypeSelector = pluginTypeSelector; this.assemblyLoader = assemblyLoader; this.parameterConverter = parameterConverter; this.resultConverter = resultConverter; this.pluginActivator = pluginActivator; this.pluginContexts = new ConcurrentBag <IPluginLoadContext>(); }
protected override void Context() { _element = new XElement("Root", new XElement("Container1", new XElement("Parameter1", new XAttribute(Constants.Serialization.Attribute.Dimension, "OldDim1")), new XElement("Parameter2", new XAttribute(Constants.Serialization.Attribute.Dimension, "Dim1"))), new XElement("Container2", new XElement("Parameter3", new XAttribute(Constants.Serialization.Attribute.Dimension, "OldDim2")), new XElement("Parameter4", new XAttribute(Constants.Serialization.Attribute.Dimension, "Dim2")))); _dimensionMapper = A.Fake <IDimensionMapper>(); _parameterConverter = A.Fake <IParameterConverter>(); _usingFormulaConverter = A.Fake <IUsingFormulaConverter>(); _dataRepositoryConverter = A.Fake <IDataRepositoryConverter>(); A.CallTo(() => _dimensionMapper.DimensionNameFor("OldDim1", false)).Returns("NewDim1"); A.CallTo(() => _dimensionMapper.DimensionNameFor("Dim1", false)).Returns("Dim1"); A.CallTo(() => _dimensionMapper.DimensionNameFor("OldDim2", false)).Returns("NewDim2"); A.CallTo(() => _dimensionMapper.DimensionNameFor("Dim2", false)).Returns("Dim2"); sut = new DimensionConverter(_dimensionMapper, _parameterConverter, _usingFormulaConverter, _dataRepositoryConverter); }
internal static string[] EvaluateAsConverter(string converterClassName, params string[] parameters) { Type converterType = GetConverterType(converterClassName); if (converterType == null) { return(Array.Empty <string>()); } try { IParameterConverter converter = Activator.CreateInstance(converterType) as IParameterConverter; MethodInfo method = converterType.GetMethod("TransformParameter"); return(method.Invoke(converter, new object[] { parameters }) as string[]); } catch (Exception exception) { s_log.Warn(LocalizationService.FormatResourceString("ExpressionEvaluatorMessage01", converterClassName, parameters), exception); } return(Array.Empty <string>()); }
private ParameterExpression CustomConverter(MethodContext methodContext, IParameterConverter parameterConverter) { var param = methodContext.AddVariable(typeof(object), "dispArgs"); var dict = Expression.Variable(typeof(IDictionary <string, object>), "params"); var dictInit = new List <Expression> { dict.Assign(Expression.Constant(new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase))) }; foreach (var parameter in Parameters.Skip(1)) { dictInit.Add(Expression.Call(dict, _dictAdd, Expression.Constant(parameter.Name), parameter)); } dictInit.Add(Expression.Call(Expression.Constant(parameterConverter), StoredProcedureAttribute.Convert, dict)); methodContext.Do(param.Assign(Expression.Block(param.Type, new[] { dict }, dictInit))); return(param); }
internal static object[] SerializeParameters(IParameterConverter parameterConverter, MethodInfo targetMethod, object[] args) { var parameters = targetMethod.GetParameters(); var results = new List <object>(); for (var index = 0; index < parameters.Count(); index++) { var parameter = parameters[index]; var parameterValue = args[index]; if (parameter.ParameterType.BaseType == typeof(System.MulticastDelegate)) { if (parameter.ParameterType.GenericTypeArguments.Any(g => g != typeof(EventArgs))) { throw new PriseProxyException($"Custom EventArgs are not supported in Prise"); } results.Add(parameterValue); continue; } object result = null; if (parameter.ParameterType.IsGenericParameter) { var runtimeType = parameterValue.GetType(); result = parameterConverter.ConvertToRemoteType(runtimeType, parameterValue); } else { result = parameterConverter.ConvertToRemoteType(parameter.ParameterType, parameterValue); } results.Add(result); } return(results.ToArray()); }
public static TProxyType CreateProxy <TProxyType>( object remoteObject, IParameterConverter parameterConverter = null, IResultConverter resultConverter = null) { if (parameterConverter == null) { parameterConverter = new PassthroughParameterConverter(); } if (resultConverter == null) { resultConverter = new PassthroughResultConverter(); } var proxy = PriseProxy <TProxyType> .Create(); ((PriseProxy <TProxyType>)proxy) .SetRemoteObject(remoteObject) .SetParameterConverter(parameterConverter) .SetResultConverter(resultConverter); return((TProxyType)proxy); }
public MethodConverterV10(IParameterConverter parameterConverter, IComments comments) : base(parameterConverter, comments) { }
public EventParameterInfo(IParameterSymbol parameter, GenerationOptions options, IParameterConverter converter) { m_converter = converter; m_options = options; m_parameter = parameter; }
public Parameter(string name, IParameterConverter rawValue) { Key = name; Value = rawValue.QueryValue; }
public MethodConverterV08(IParameterConverter parameterConverter, IComments comments) { this.parameterConverter = parameterConverter; this.comments = comments; }
public T CreatePluginProxy(object remoteObject, IParameterConverter parameterConverter, IResultConverter resultConverter) => ProxyCreator.CreateProxy <T>(remoteObject, parameterConverter, resultConverter);
public MethodConverterV10(IParameterConverter parameterConverter) : base(parameterConverter) { }
public static object Invoke(object remoteObject, MethodInfo targetMethod, object[] args, IParameterConverter parameterConverter, IResultConverter resultConverter) { try { var localType = targetMethod.ReturnType; var remoteMethod = FindMethodOnRemoteObject(targetMethod, remoteObject); if (remoteMethod == null) { throw new PriseProxyException($"Target method {targetMethod.Name} is not found on Proxy Type {remoteObject.GetType().Name}."); } object result = null; if (remoteMethod.IsGenericMethod) { var generic = remoteMethod.MakeGenericMethod(targetMethod.GetGenericArguments()); result = generic.Invoke(remoteObject, SerializeParameters(parameterConverter, remoteMethod, args)); } else { result = remoteMethod.Invoke(remoteObject, SerializeParameters(parameterConverter, remoteMethod, args)); } var remoteType = remoteMethod.ReturnType; if (remoteType.BaseType == typeof(System.Threading.Tasks.Task)) { return(resultConverter.ConvertToLocalTypeAsync(localType, remoteType, result as System.Threading.Tasks.Task)); } return(resultConverter.ConvertToLocalType(localType, remoteType, result)); } catch (Exception ex) when(ex is TargetInvocationException) { throw ex.InnerException ?? ex; } }
public AdoQueryRunner(IParameterConverter parameterConverter) { _parameterConverter = parameterConverter; }
public RAMLDocGeneratorV10(IApiDescriptionGroupCollectionProvider apiDescription, IParameterConverter parameterConverter, IMethodConverter methodConverter, IComments comments) : base(apiDescription, parameterConverter, methodConverter, comments) { }
public PluginLoadOptionsBuilder <T> WithParameterConverter(IParameterConverter parameterConverter) { this.parameterConverter = parameterConverter; return(this); }
public MethodConverterV08(IParameterConverter parameterConverter) { this.parameterConverter = parameterConverter; }