public static IOrderedEnumerable <string> PossiblePropertyNames(this PropertyInfo propertyInfo, IEnumerable <string> schemaNames = null) { var possibleNames = new Func <PropertyInfo, string[]>[] { p => new[] { Inflector.MakeInitialUpperCase(p.DeclaringType?.Name) + Inflector.MakeInitialUpperCase(p.Name) }, p => PrefixWithSchemaName(p.Name) .ToArray(), p => new[] { Inflector.MakeInitialUpperCase(p.Name) }, p => new[] { Inflector.CollapseNames(p.DeclaringType?.Name, p.Name) }, p => Inflector.StripLeftTerms(p.Name) .ToArray() }; // Important: The IOrderedEnumerable and OrderBy clause here preserves the naming precedence in possible names return(possibleNames.SelectMany(f => f(propertyInfo)).OrderBy(x => true)); IEnumerable <string> PrefixWithSchemaName(string name) { if (schemaNames == null) { yield break; } foreach (var schemaName in schemaNames) { yield return(Inflector.MakeInitialUpperCase(schemaName) + name); } } }
public Presenter( ILogSourcesManager logSourcesManager, IChangeNotification changeNotification, IView view, Preprocessing.IManager sourcesPreprocessingManager, Preprocessing.IStepsFactory preprocessingStepsFactory, MRU.IRecentlyUsedEntities mru, QuickSearchTextBox.IPresenter searchBoxPresenter, IAlertPopup alerts, ITraceSourceFactory traceSourceFactory ) { this.view = view; this.changeNotification = changeNotification; this.logSourcesManager = logSourcesManager; this.sourcesPreprocessingManager = sourcesPreprocessingManager; this.preprocessingStepsFactory = preprocessingStepsFactory; this.mru = mru; this.searchBoxPresenter = searchBoxPresenter; this.trace = traceSourceFactory.CreateTraceSource("UI", "hist-dlg"); this.alerts = alerts; items = Selectors.Create(() => visible, () => acceptedFilter, MakeItems); actuallySelected = Selectors.Create(() => items().displayItems, () => selected, (items, selected) => items.SelectMany(i => i.Flatten()).Where(i => selected.Contains(i.key)).ToImmutableList()); openButtonEnabled = Selectors.Create(actuallySelected, selected => selected.Any(IsOpenable)); rootViewItem = Selectors.Create(() => items().displayItems, () => selected, () => expanded, MakeRootItem); searchBoxPresenter.OnSearchNow += (s, e) => { acceptedFilter = searchBoxPresenter.Text; FocusItemsListAndSelectFirstItem(); changeNotification.Post(); }; searchBoxPresenter.OnRealtimeSearch += (s, e) => { acceptedFilter = searchBoxPresenter.Text; changeNotification.Post(); }; searchBoxPresenter.OnCancelled += (s, e) => { if (acceptedFilter != "") { acceptedFilter = ""; searchBoxPresenter.Focus(null); } else { visible = false; } changeNotification.Post(); }; view.SetViewModel(this); }
public override object CalculateResult() { var polygonalFuncs = new Func<int, int>[] { n => n * (n + 1) / 2, n => n * n, n => n * (3 * n - 1) / 2, n => n * (2 * n - 1), n => n * (5 * n - 3) / 2, n => n * (3 * n - 2), }; var numbers = polygonalFuncs .SelectMany((f, i) => new Range(1, int.MaxValue) .Select(n => f(n)) .SkipWhile(v => v < 1000) .TakeWhile(v => v < 10000) .Select(v => new { Part1 = v / 100, Part2 = v % 100, Value = v, Type = i, })) .ToArray(); return new Range(5) .Aggregate( numbers .Where(n => n.Type == 0) .Select(n => ImmutableSequence.Create(n)), (acc, i) => acc .SelectMany(x => numbers .Where(n => n.Part1 == x.First().Part2) .Where(n => x.All(v => n.Value != v.Value && n.Type != v.Type)) .Select(n => ImmutableSequence.Create(n, x))), acc => acc .Where(x => x.Last().Part1 == x.First().Part2)) .Single() .Sum(x => x.Value); }
public void FuncTest() { bool isExecuted1 = false; bool isExecuted2 = false; bool isExecuted3 = false; bool isExecuted4 = false; Func <int> f1 = () => { isExecuted1 = true; return(1); }; Func <int> f2 = () => { isExecuted2 = true; return(2); }; Func <int, int> f3 = x => { isExecuted3 = true; return(x + 1); }; Func <int, Func <int, int> > f4 = x => y => { isExecuted4 = true; return(x + y); }; Func <int> query1 = from x in f1 from y in f2 from z in f3.Partial(y) from _ in "abc".Func() let f4x = f4(x) select f4x(z); Assert.IsFalse(isExecuted1); // Deferred and lazy. Assert.IsFalse(isExecuted2); // Deferred and lazy. Assert.IsFalse(isExecuted3); // Deferred and lazy. Assert.IsFalse(isExecuted4); // Deferred and lazy. Assert.AreEqual(1 + 2 + 1, query1()); // Execution. Assert.IsTrue(isExecuted1); Assert.IsTrue(isExecuted2); Assert.IsTrue(isExecuted3); Assert.IsTrue(isExecuted4); // Monad law 1: m.Monad().SelectMany(f) == f(m) Func <int, Func <int> > addOne = x => (x + 1).Func(); Func <int> left = 1.Func().SelectMany(addOne, False); Func <int> right = addOne(1); Assert.AreEqual(left(), right()); // Monad law 2: M.SelectMany(Monad) == M Func <int> M = 1.Func(); left = M.SelectMany(FuncExtensions.Func, False); right = M; Assert.AreEqual(left(), right()); // Monad law 3: M.SelectMany(f1).SelectMany(f2) == M.SelectMany(x => f1(x).SelectMany(f2)) Func <int, Func <int> > addTwo = x => (x + 2).Func(); left = M.SelectMany(addOne, False).SelectMany(addTwo, False); right = M.SelectMany(x => addOne(x).SelectMany(addTwo, False), False); Assert.AreEqual(left(), right()); bool isExecuted5 = false; bool isExecuted6 = false; bool isExecuted7 = false; Func <int, int> f5 = x => { isExecuted5 = true; return(x + 1); }; Func <string, int> f6 = x => { isExecuted6 = true; return(x.Length); }; Func <int, Func <int, string> > f7 = x => y => { isExecuted7 = true; return(new string('a', x + y)); }; Func <int, Func <string, string> > query2 = a => b => (from x in f5(a).Func() from y in f6(b).Func() from z in 0.Func() select f7(x)(y))(); Assert.IsFalse(isExecuted5); // Deferred and lazy. Assert.IsFalse(isExecuted6); // Deferred and lazy. Assert.IsFalse(isExecuted7); // Deferred and lazy. Assert.AreEqual(new string('a', 1 + 1 + "abc".Length), query2(1)("abc")); // Execution. Assert.IsTrue(isExecuted5); Assert.IsTrue(isExecuted6); Assert.IsTrue(isExecuted7); }
public static Func <TState, UValue> SelectMany <TValue, UValue, TState>( this Func <TState, TValue> reader, Func <TValue, Func <TState, UValue> > binder) { return(reader.SelectMany(binder, IdValueSelector)); }
public static Func <T, A> Join <T, A>(this Func <T, Func <T, A> > f) { return(f.SelectMany(x => x)); }
// Not required, just for convenience. public static Func <TResult> SelectMany <TSource, TResult> (this Func <TSource> source, Func <TSource, Func <TResult> > selector) => source.SelectMany(selector, Functions.False);