public void RegisterHandlers(IIMOwinOptions options, Assembly[] hostAssemblies) { // memoized if (Interlocked.Increment(ref _alreadyRegistered) != 0) return; var contractTypes = hostAssemblies .SelectMany(x => { try { return x.GetTypes(); } catch (ReflectionTypeLoadException ex) { return ex.Types.Where(t => t != null); } }) .Where(x => typeof (IMOwinBehaviorContract).IsAssignableFrom(x)) .Where(x => !x.IsAbstract); Parallel.ForEach(contractTypes, classType => { var className = classType.Name; if (classType.GetConstructors().All(x => x.GetParameters().Length != 0)) { throw new InvalidOperationException(string.Format("Type needs parameterless constructor, class:{0}", classType.FullName)); } // ignore if (classType.GetCustomAttribute<IgnoreOperationAttribute>(true) != null) return; foreach (var methodInfo in classType.GetMethods(BindingFlags.Public | BindingFlags.Instance)) { // property if (methodInfo.IsSpecialName && (methodInfo.Name.StartsWith("set_") || methodInfo.Name.StartsWith("get_"))) continue; // ignore if (methodInfo.GetCustomAttribute<IgnoreOperationAttribute>(true) != null) continue; var methodName = methodInfo.Name; // ignore default methods if (methodName == "Equals" || methodName == "GetHashCode" || methodName == "GetType" || methodName == "ToString") continue; // create handler var handler = new OperationHandler(classType, methodInfo); lock (_handlers) { var path = new RequestPath(className, methodName); // 簡単化のため duplicate entry ⇒ fail if (_handlers.ContainsKey(path)) { throw new InvalidOperationException(string.Format("same class and method is not allowed, class:{0} method:{1}", className, methodName)); } _handlers.Add(path, handler); } } }); }
private static void RegisterBusinessLogic(ContainerBuilder builder, Assembly[] assemblies) { builder.RegisterAssemblyTypes(assemblies) .Where(t => !string.IsNullOrWhiteSpace(t.Namespace) && t.Namespace.StartsWith("ReMi.BusinessLogic")) .AsImplementedInterfaces() .InstancePerDependency() .PropertiesAutowired(); builder.Register<IApiDescriptionBuilder>( c => new ApiDescriptionBuilder( assemblies.SelectMany(a => a.GetTypes().Where(t => typeof(ApiController).IsAssignableFrom(t)).Select(x => x)), assemblies.SelectMany(a => a.GetTypes().Where(t => typeof(ICommand).IsAssignableFrom(t) && t.IsClass).Select(x => x)) )) .PropertiesAutowired() .InstancePerDependency(); }
public static void RegisterClients(Assembly[] assemblyToFindTypes, Action<Type, Type> registerTypeForContainer) { var allTypes = assemblyToFindTypes.SelectMany(a => a.GetTypes()); var allServiceClientInterfaces = allTypes.Where(x => typeof(IServiceClient).IsAssignableFrom(x) && x.IsInterface && x != typeof(IServiceClient)).ToList(); foreach (var @interface in allServiceClientInterfaces) { registerTypeForContainer(@interface, allTypes.Where(x => @interface.IsAssignableFrom(x) && x.IsClass).FirstOrDefault()); } }
/// <summary> /// Registers CQRS chunks into service container /// </summary> /// <param name="services">DI container</param> /// <param name="assemblies">Assemblies list where is CQRS stuff is placed</param> /// <param name="filter">Predicate to filter types you would like to register</param> public static IServiceCollection AddCqrsSpirit(this IServiceCollection services, Assembly[] assemblies, Func<Type, bool> filter = null) { var types = assemblies .SelectMany(assembly => assembly.ExportedTypes) .Where(t => t.GetTypeInfo().IsPublic); if (filter != null) types = types.Where(filter); return AddCqrsSpirit(services, types.ToArray()); }
public SammyApplication(IKernel kernel, Assembly[] assembly) { _kernel = kernel; var types = assembly.SelectMany<Assembly, Type>(a => a.GetTypes()).ToArray(); // Should this be off some kind of marker (like HttpApplication)? _kernel.Register(AllTypes.From(types).BasedOn<SammyController>()); // This is getting a bit large - how do we initialize this better? Routes = RouteCollector.Collect(_kernel.GetAssignableHandlers(typeof(SammyController)).Select(h => h.Service).ToArray()); }
private static IEnumerable<Type> GetAssemblyTypes(Assembly[] assembliesWithServices) { var results = new List<Type>(); try { results.AddRange(assembliesWithServices.SelectMany(assembly => assembly.GetTypes())); } catch (Exception) { // ignored } return results; }
public IEnumerable<MethodInfo> GetPublicNoArgExtensionMethods(Assembly[] sourceExtensionMethodSearch) { if (sourceExtensionMethodSearch == null) { return new MethodInfo[] { }; } //http://stackoverflow.com/questions/299515/c-sharp-reflection-to-identify-extension-methods return sourceExtensionMethodSearch .SelectMany(assembly => assembly.GetTypes()) .Where(type => type.IsSealed && !type.IsGenericType && !type.IsNested) .SelectMany(type => type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)) .Where(method => method.IsDefined(typeof(ExtensionAttribute), false)) .Where(method => method.GetParameters()[0].ParameterType == this.Type); }
public void RegisterAssemblies(Assembly[] assemblies) { var searchTarget = typeof(IHandler<>); var dict = assemblies.SelectMany(a => a.GetTypes()) .SelectMany(t => t.GetInterfaces() .Where(i => i.IsGenericType && (i.GetGenericTypeDefinition() == searchTarget) && !i.ContainsGenericParameters), (t, i) => new { Key = i.GetGenericArguments()[0], Value = t }) .GroupBy(x => x.Key, x => x.Value) .ToDictionary(g => g.Key, g => g.ToList()); _subscription = dict; }
public static void Register(Assembly[] handlerAssemblies, Assembly[] modelAssemblies) { foreach ( var route in handlerAssemblies.SelectMany(a => a.GetTypes()).Select(GetBaseRouteAttributeFor).SelectMany( routeInfo => routeInfo).OrderByDescending(x => x.Route)) { Debug.WriteLine(string.Format("[OpenRasta.Routing] Registering route '{0}' named '{1}' with handler '{2}'", route.Route, route.Name, route.HandlerType)); ResourceSpace.Has.ResourcesOfType(route.HandlerType) .AtUri(route.Route).Named(route.Name) .HandledBy(route.HandlerType) .AsJsonDataContract() .And.AsXmlDataContract(); } foreach (var type in modelAssemblies.SelectMany(x => x.GetTypes())) { Debug.WriteLine(string.Format("[OpenRasta.Routing] Registering type '{0}'", type)); ResourceSpace.Has.ResourcesOfType(type) .WithoutUri .AsJsonDataContract() .And.AsXmlDataContract(); } }
public static IEnumerable<RouteInfo> GetRouteInfo(Assembly[] handlerAssemblies) { return handlerAssemblies.SelectMany(a => a.GetTypes()).Select(GetBaseRouteAttributeFor).SelectMany( routeInfo => routeInfo); }
// cache all methods public IReadOnlyCollection<KeyValuePair<string, OperationInfo>> RegisterHandler(Assembly[] hostAssemblies) { if (Interlocked.Increment(ref alreadyRegistered) != 0) return new KeyValuePair<string, OperationInfo>[0]; var contractTypes = hostAssemblies .SelectMany(x => { try { return x.GetTypes(); } catch (ReflectionTypeLoadException ex) { return ex.Types.Where(t => t != null); } }) .Where(x => typeof(LightNodeContract).IsAssignableFrom(x)) .Where(x => !x.IsAbstract); Parallel.ForEach(contractTypes, classType => { var className = classType.Name; if (!classType.GetConstructors().Any(x => x.GetParameters().Length == 0)) { throw new InvalidOperationException(string.Format("Type needs parameterless constructor, class:{0}", classType.FullName)); } if (classType.GetCustomAttribute<IgnoreOperationAttribute>(true) != null) return; // ignore foreach (var methodInfo in classType.GetMethods(BindingFlags.Public | BindingFlags.Instance)) { if (methodInfo.IsSpecialName && (methodInfo.Name.StartsWith("set_") || methodInfo.Name.StartsWith("get_"))) continue; // as property if (methodInfo.GetCustomAttribute<IgnoreOperationAttribute>(true) != null) continue; // ignore var methodName = methodInfo.Name; // ignore default methods if (methodName == "Equals" || methodName == "GetHashCode" || methodName == "GetType" || methodName == "ToString") { continue; } var sw = Stopwatch.StartNew(); // create handler var handler = new OperationHandler(options, classType, methodInfo); lock (handlers) { // fail duplicate entry var path = new RequestPath(className, methodName); if (handlers.ContainsKey(path)) { throw new InvalidOperationException(string.Format("same class and method is not allowed, class:{0} method:{1}", className, methodName)); } handlers.Add(path, handler); } sw.Stop(); options.Logger.RegisiterOperation(handler.ClassName, handler.MethodName, sw.Elapsed.TotalMilliseconds); } }); // return readonly operation info return handlers.Select(x => new KeyValuePair<string, OperationInfo>(x.Key.ToString(), new OperationInfo(x.Value))).ToList().AsReadOnly(); }
private static void RegisterAssemblyTypes(ContainerBuilder builder, Assembly[] vuelingAssemblies) { var vuelingTypes = vuelingAssemblies.SelectMany(a => a.GetTypes()) .Where(t => !t.IsInterface && !t.IsAbstract).OrderBy(t => t.Name).ToList(); var interfacesImplements = new Dictionary<Type, Type>(); Assembly.GetExecutingAssembly().GetTypes().Where(t => !t.IsAbstract).ToList() .ForEach(c => RegisterTypeDependencies(c, vuelingTypes, interfacesImplements)); interfacesImplements.ToList().ForEach( delegate(KeyValuePair<Type, Type> ii) { builder.RegisterType(ii.Value).As(ii.Key).AsImplementedInterfaces(); }); }
public static void RegisterHandler(Assembly[] hostAssemblies) { if (Interlocked.Increment(ref alreadyRegistered) != 0) return; var contractTypes = hostAssemblies .SelectMany(x => x.GetTypes()) .Where(x => typeof(LightNodeContract).IsAssignableFrom(x)); Parallel.ForEach(contractTypes, classType => { var className = classType.Name; foreach (var methodInfo in classType.GetMethods(BindingFlags.Public | BindingFlags.Instance)) { if (methodInfo.IsSpecialName && (methodInfo.Name.StartsWith("set_") || methodInfo.Name.StartsWith("get_"))) continue; // as property var methodName = methodInfo.Name; // ignore default methods if (methodName == "Equals" || methodName == "GetHashCode" || methodName == "GetType" || methodName == "ToString") { continue; } var handler = new OperationHandler(); handler.MethodName = methodName; handler.Arguments = methodInfo.GetParameters(); handler.ReturnType = methodInfo.ReturnType; foreach (var argument in handler.Arguments) { if (!AllowRequestType.IsAllowType(argument.ParameterType)) { throw new InvalidOperationException(string.Format("parameter is not allowed, class:{0} method:{1} paramName:{2} paramType:{3}", className, methodName, argument.Name, argument.ParameterType.FullName)); } } // prepare lambda parameters var envArg = Expression.Parameter(typeof(IDictionary<string, object>), "environment"); var envBind = Expression.Bind(typeof(LightNodeContract).GetProperty("Environment"), envArg); var args = Expression.Parameter(typeof(object[]), "args"); var parameters = methodInfo.GetParameters() .Select((x, i) => Expression.Convert(Expression.ArrayIndex(args, Expression.Constant(i)), x.ParameterType)) .ToArray(); // Task or Task<T> if (typeof(Task).IsAssignableFrom(handler.ReturnType)) { // (object[] args) => new X().M((T1)args[0], (T2)args[1])... var lambda = Expression.Lambda<Func<IDictionary<string, object>, object[], Task>>( Expression.Call( Expression.MemberInit(Expression.New(classType), envBind), methodInfo, parameters), envArg, args); if (handler.ReturnType.IsGenericType && handler.ReturnType.GetGenericTypeDefinition() == typeof(Task<>)) { handler.HandlerBodyType = HandlerBodyType.AsyncFunc; handler.MethodAsyncFuncBody = lambda.Compile(); lock (taskResultExtractors) { if (!taskResultExtractors.ContainsKey(handler.ReturnType)) { // (object task) => (object)((Task<>).Result) var taskParameter = Expression.Parameter(typeof(object), "task"); var resultLambda = Expression.Lambda<Func<object, object>>( Expression.Convert( Expression.Property( Expression.Convert(taskParameter, handler.ReturnType), "Result"), typeof(object)), taskParameter); var compiledResultLambda = resultLambda.Compile(); taskResultExtractors[handler.ReturnType] = compiledResultLambda; } } } else { handler.HandlerBodyType = HandlerBodyType.AsyncAction; handler.MethodAsyncActionBody = lambda.Compile(); } } else if (handler.ReturnType == typeof(void)) // of course void { // (object[] args) => { new X().M((T1)args[0], (T2)args[1])... } var lambda = Expression.Lambda<Action<IDictionary<string, object>, object[]>>( Expression.Call( Expression.MemberInit(Expression.New(classType), envBind), methodInfo, parameters), envArg, args); handler.HandlerBodyType = HandlerBodyType.Action; handler.MethodActionBody = lambda.Compile(); } else // return T { // (object[] args) => (object)new X().M((T1)args[0], (T2)args[1])... var lambda = Expression.Lambda<Func<IDictionary<string, object>, object[], object>>( Expression.Convert( Expression.Call( Expression.MemberInit(Expression.New(classType), envBind), methodInfo, parameters) , typeof(object)), envArg, args); handler.HandlerBodyType = HandlerBodyType.Func; handler.MethodFuncBody = lambda.Compile(); } lock (handlers) { // fail duplicate entry var path = new RequestPath(className, methodName); if (handlers.ContainsKey(path)) { throw new InvalidOperationException(string.Format("same class and method is not allowed, class:{0} method:{1}", className, methodName)); } handlers.Add(path, handler); } } }); }
private void SetUpDefaults(Assembly[] assemblies) { var availableHandlerTypes = FindAvailableHandlerTypes(assemblies).ToList(); FindSagaIdsFor = GetDefaultFindSagaIdsFor(availableHandlerTypes); var streamPersisterType = assemblies.SelectMany(x => x.GetTypes()).FirstOrDefault(x => !x.IsAbstract && typeof(ISagaStreamPersister).IsAssignableFrom(x)); GetStreamPersister = () => { if (streamPersisterType == null) return null; return Construct(streamPersisterType) as ISagaStreamPersister; }; FindMessageHandler = GetDefaultFindMessageHandler(availableHandlerTypes); Construct = GetDefaultConstruct(); }