/*----------------------------------------------------------------------------------------*/ /// <summary> /// Creates a terminating condition that determines whether any items in the series match the predicate. /// </summary> /// <param name="predicate">The predicate to execute.</param> public TerminatingCondition <TRoot, TSubject> Has(Predicate <TItem> predicate) { #if !MONO return(Terminate(e => e.Has(predicate))); #else return(Terminate(e => ExtensionsForIEnumerable.Has(e, predicate))); #endif }
/*----------------------------------------------------------------------------------------*/ /// <summary> /// Continues the conditional chain by counting the number of items in the collection that match /// the specified predicate. /// </summary> /// <param name="predicate">The predicate to execute.</param> public Int32ConditionBuilder <TRoot, TSubject> CountMatches(Predicate <TItem> predicate) { #if !MONO return(new Int32ConditionBuilder <TRoot, TSubject>(this, e => e.Count(predicate))); #else return(new Int32ConditionBuilder <TRoot, TSubject>(this, e => ExtensionsForIEnumerable.Count(e, predicate))); #endif }
/*----------------------------------------------------------------------------------------*/ #region Public Methods /// <summary> /// Loads the module into the kernel. /// </summary> public override void Load() { #if !MONO _assemblies.Each(RegisterControllers); #else ExtensionsForIEnumerable.Each(_assemblies, RegisterControllers); #endif }
/*----------------------------------------------------------------------------------------*/ /// <summary> /// Initializes a new instance of the <see cref="AutoControllerModule"/> class. /// </summary> /// <param name="assemblyNames">The names of assemblies which should be scanned for controllers.</param> public AutoControllerModule(params string[] assemblyNames) { #if !MONO _assemblies = assemblyNames.Convert(s => Assembly.Load(s)); #else _assemblies = ExtensionsForIEnumerable.Convert(assemblyNames, s => Assembly.Load(s)); #endif }
public void ToListSlow_Large() { var list = ExtensionsForIEnumerable.ToListSlow(_largeEnumerable, typeof(string)); foreach (var item in list) { if (item == null) { throw new Exception(); } } }
/*----------------------------------------------------------------------------------------*/ /// <summary> /// Returns a value indicating whether the specified member should be injected during activation. /// </summary> /// <param name="binding">The binding that points at the type whose activation plan being manipulated.</param> /// <param name="plan">The activation plan that is being manipulated.</param> /// <param name="candidates">The candidates that are available.</param> /// <param name="member">The member in question.</param> /// <returns><see langword="True"/> if the member should be injected, otherwise <see langword="false"/>.</returns> public bool ShouldInject(IBinding binding, IActivationPlan plan, IEnumerable <MethodInfo> candidates, MethodInfo member) { var registry = binding.Components.BindingRegistry; ParameterInfo[] parameters = member.GetParameters(); #if !MONO return(parameters.Length > 0 && parameters.Convert(p => p.ParameterType).All(registry.HasBinding)); #else return(parameters.Length > 0 && ExtensionsForIEnumerable.All( ExtensionsForIEnumerable.Convert(parameters, p => p.ParameterType), registry.HasBinding)); #endif }
/*----------------------------------------------------------------------------------------*/ /// <summary> /// Returns a value indicating whether the specified member should be injected during activation. /// </summary> /// <param name="binding">The binding that points at the type whose activation plan being manipulated.</param> /// <param name="plan">The activation plan that is being manipulated.</param> /// <param name="candidates">The candidates that are available.</param> /// <param name="member">The member in question.</param> /// <returns> /// <see langword="True"/> if the member should be injected, otherwise <see langword="false"/>. /// </returns> public bool ShouldInject(IBinding binding, IActivationPlan plan, IEnumerable <ConstructorInfo> candidates, ConstructorInfo member) { #if !MONO var list = candidates.ToList(); #else var list = ExtensionsForIEnumerable.ToList(candidates); #endif if (list.Count == 1) { return(true); } var registry = binding.Components.BindingRegistry; #if !MONO return(member == candidates.Best(c => c.GetParameterTypes().Count(registry.HasBinding))); #else return(member == ExtensionsForIEnumerable .Best(candidates, c => ExtensionsForIEnumerable.Count(ExtensionsForMethodBase.GetParameterTypes(c), registry.HasBinding))); #endif }
/*----------------------------------------------------------------------------------------*/ /// <summary> /// Continues the conditional chain, examining only items in the series that match the specified predicate. /// </summary> /// <param name="predicate">The predicate to execute.</param> public EnumerableConditionBuilder <TRoot, TSubject, IEnumerable <TItem>, TItem> Where(Predicate <TItem> predicate) { #if !MONO return(new EnumerableConditionBuilder <TRoot, TSubject, IEnumerable <TItem>, TItem>(this, e => e.Where(predicate))); #else return(new EnumerableConditionBuilder <TRoot, TSubject, IEnumerable <TItem>, TItem>(this, e => ExtensionsForIEnumerable.Where(e, predicate))); #endif }
/*----------------------------------------------------------------------------------------*/ #region EDSL Members /// <summary> /// Continues the conditional chain, converting all items in the input series. /// </summary> /// <typeparam name="TOutput">The type of item to convert to.</typeparam> /// <param name="converter">The converter callback to execute.</param> public EnumerableConditionBuilder <TRoot, TSubject, IEnumerable <TOutput>, TOutput> Convert <TOutput>(Func <TItem, TOutput> converter) { #if !MONO return(new EnumerableConditionBuilder <TRoot, TSubject, IEnumerable <TOutput>, TOutput>(this, e => e.Convert(converter))); #else return(new EnumerableConditionBuilder <TRoot, TSubject, IEnumerable <TOutput>, TOutput>(this, e => ExtensionsForIEnumerable.Convert(e, converter))); #endif }