public void linq_defers_execution() { var array = new[] {"a", "b", "a", "a"}; var filteringValue = "a"; var results1 = array.Where(x => x == filteringValue); filteringValue = "b"; var results2 = array.Where(x => x == filteringValue); results1.Count().Should().Be(1); results2.Count().Should().Be(1); }
public void SplitSupportedQuery() { IQueryable<string> queryRoot = new[] { "query", "root" }.AsQueryable(); IQueryable<string> query = queryRoot.Where(s => true).Take(5); IQueryable supportedQuery; IQueryable unsupportedQuery; supportedQuery = QueryComposer.Split(query, out unsupportedQuery); MethodCallExpression mce = supportedQuery.Expression as MethodCallExpression; Assert.IsNotNull(mce, "The first supported expression should be a method call."); Assert.AreEqual("Take", mce.Method.Name, "The first supported expression should be a Take call."); Assert.AreEqual(2, mce.Arguments.Count, "The first supported expression should have 2 arguments."); MethodCallExpression mce2 = mce.Arguments[0] as MethodCallExpression; Assert.IsNotNull(mce2, "The second supported expression should be a method call."); Assert.AreEqual("Where", mce2.Method.Name, "The second supported expression should be a Where call."); Assert.AreEqual(2, mce2.Arguments.Count, "The second supported expression should have 2 arguments."); ConstantExpression ce = mce2.Arguments[0] as ConstantExpression; Assert.IsNotNull(ce, "The first argument in the second supported expression should be constant."); Assert.IsNull(unsupportedQuery, "The unsupported query should be null."); }
public void correct_iquerable_should_be_returned() { var source = new[] { new DummyDocument { Name = "First", }, new DummyDocument { Name = "Middle", }, new DummyDocument { Name = "Last", } } .AsQueryable(); var sortedData = source.DynamicFiltering("name", "Last"); var expectedSortedData = source.Where(document => document.Name == "Last"); sortedData.SequenceEqual(expectedSortedData).Should().BeTrue(); }
public void Foo() { // Single accepts a predicate - the Where is superfluous var stuff = new []{"Josh", "was", "here"}; var less = stuff.Where(x => x.StartsWith("J")).Single(); }
/*begin*/ public ActionResult GetItems(GridParams g, string[] selectedColumns, bool? choosingColumns) { //when setting columns from here we don't get the grid defaults, so we have to specify Sortable, Groupable etc. var columns = new[] { new Column { Name = "Id", Width = 70, Order = 1 }, new Column { Name = "Person", Sortable = true, Groupable = true, GroupRemovable = true, Order = 2 }, new Column { Name = "Food", Sortable = true, Groupable = true, GroupRemovable = true, Order = 3 }, new Column { Name = "Location", Sortable = true, Groupable = true, GroupRemovable = true, Order = 4 }, new Column { Name = "Date", Sortable = true, Groupable = true, GroupRemovable = true, Width = 100, Order = 5 }, new Column { Name = "Price", Sortable = true, Groupable = true, GroupRemovable = true, Width = 100, Order = 6 }, }; var baseColumns = new[] { "Id", "Person" }; //first load if (g.Columns.Length == 0) { g.Columns = columns; } if (choosingColumns.HasValue && selectedColumns == null) { selectedColumns = new string[] { }; } if (selectedColumns != null) { //make sure we always have Id and Person columns selectedColumns = selectedColumns.Union(baseColumns).ToArray(); var currectColumns = g.Columns.ToList(); //remove unselected columns currectColumns = currectColumns.Where(o => selectedColumns.Contains(o.Name)).ToList(); //add missing columns var missingColumns = selectedColumns.Except(currectColumns.Select(o => o.Name)).ToArray(); currectColumns.AddRange(columns.Where(o => missingColumns.Contains(o.Name))); g.Columns = currectColumns.ToArray(); } var gridModel = new GridModelBuilder<Lunch>(Db.Lunches.AsQueryable(), g).Build(); // used to populate the checkboxlist gridModel.Tag = new { columns = columns.Select(o => o.Name).Except(baseColumns).ToArray(), selectedColumns = g.Columns.Select(o => o.Name).Except(baseColumns).ToArray() }; return Json(gridModel); }
public override void Load() { var types = new[] {typeof (ILogInAccounts), typeof (LogInAccounts), GetType()} .Select(type => type.Assembly) .SelectMany(assembly => assembly.GetTypes()) .ToArray(); var services = types.Where(t => t.IsInterface && !t.IsGenericTypeDefinition); var implementations = types.Where(t => t.IsClass && !t.IsAbstract && !t.IsGenericTypeDefinition); services.SelectMany(t => implementations, (service, impl) => new {service, impl}) .Where(x => x.service.IsAssignableFrom(x.impl)) .GroupBy(x => x.service, x => x.impl) .Where(g => g.Count() == 1) .Select(g => new {service = g.Key, impl = g.Single()}) .ToList() .ForEach(x => Kernel.Bind(x.service).To(x.impl).InRequestScope()); }
public override string[] Complete(Shell shell, string[] tokens) { var items = new[] {"users"}; if (tokens.Length == 0) { return items; } return tokens.Length == 1 ? items.Where(x => x.StartsWith(tokens[0])).ToArray() : null; }
public void Switch() { var table = new[] { new { pre = ReelState.Stop, post = ReelState.Cycle }, new { pre = ReelState.Cycle, post = ReelState.Stop }, }; State = table.Where(t => t.pre == State) .First() .post; }
private void LoadLanguageList() { var settings = new[] { new DisplayLanguageSetting("en-US"), new DisplayLanguageSetting("fr-CA"), new DisplayLanguageSetting("sv-SV") }; LanguageList.Items.AddRange(settings.Where(item => item.Exists).ToArray()); LanguageList.DisplayMember = "Name"; }
public void CanUsePredicates() { var source = new[] { 1, 2, 3, 4, 5 }; var isEven = new Pred<int>(x => x%2 == 0); var isOdd = isEven.Invert(); var isOddOr2 = isOdd.Or(x => x == 2); var count = source.Where(isOddOr2).Count(); Assert.AreEqual(4, count); }
public void Syoka() { var table = new[] { new { pre = KakuhenMode.Normal, post = KakuhenMode.Kakuhen1 }, new { pre = KakuhenMode.Kakuhen1, post = KakuhenMode.Kakuhen2 }, new { pre = KakuhenMode.Kakuhen2, post = KakuhenMode.Kakuhen1 }, }; Mode = table.Where(t => t.pre == Mode) .First() .post; }
public override string ToString() { var result = new[] { VersionType.IsNullOrEmpty() ? "" : "\"_version_type\": " + VersionType.Quotate(), Version == null ? "" : "\"_version\": " + Version.AsString(), Routing.IsNullOrEmpty() ? "" : "\"_routing\": " + Routing.Quotate(), Percolate.IsNullOrEmpty() ? "" : "\"_percolate\": " + Percolate.Quotate(), Parent.IsNullOrEmpty() ? "" : "\"_parent\": " + Parent.Quotate(), Timestamp.IsNullOrEmpty() ? "" : "\"_timestamp\": " + Timestamp.Quotate(), Ttl.IsNullOrEmpty() ? "" : "\"_ttl\": " + Ttl.Quotate(), }; return result.Where(s => !s.IsNullOrEmpty()).JoinWithComma(); }
public void Rebase() { IQueryable<string> queryRoot = new[] { "query", "root" }.AsQueryable(); IQueryable<string> query = queryRoot.Where(s => true); MethodCallExpression mce = query.Expression as MethodCallExpression; Assert.IsNotNull(mce, "Expression should be a method call."); Assert.AreEqual("Where", mce.Method.Name, "Expression should be a Where call."); Assert.AreEqual(2, mce.Arguments.Count, "Expression should have 2 arguments."); ConstantExpression ce = mce.Arguments[0] as ConstantExpression; Assert.IsNotNull(ce, "The first expression argument should be constant."); Assert.AreEqual(queryRoot, ce.Value, "The first expression argument should be the query root."); IQueryable<string> newQueryRoot = new[] { "new", "query", "root" }.AsQueryable(); IQueryable rebasedQuery = QueryComposer.Compose(newQueryRoot, query); mce = rebasedQuery.Expression as MethodCallExpression; Assert.IsNotNull(mce, "Rebased expression should be a method call."); Assert.AreEqual("Where", mce.Method.Name, "Rebased expression should be a Where call."); Assert.AreEqual(2, mce.Arguments.Count, "Rebased expression should have 2 arguments."); ce = mce.Arguments[0] as ConstantExpression; Assert.IsNotNull(ce, "The first rebased expression argument should be constant."); Assert.AreEqual(newQueryRoot, ce.Value, "The first rebased expression argument should be the new query root."); }
/// <summary> /// Checks that the API key passed looks like a GW2 API key (follows a length pattern between delimiters and is alpha numeric). /// </summary> /// <param name="possibleKey"> /// The possible API key. /// </param> /// <returns> /// True if the possibleKey looks like a valid GW2 API key. /// </returns> public static bool LookLikeAValidGuildWarsTwoApiKey(string possibleKey) { const char Delimiter = '-'; var expectedTokenLengths = new [] { 8, 4, 4, 4, 20, 4, 4, 4, 12 }; var tokens = possibleKey.Split(Delimiter); var actualTokenLengths = tokens.Select(t => t.Length).ToArray(); if (expectedTokenLengths.Length != actualTokenLengths.Length) { return false; } if (expectedTokenLengths.Where((t, index) => actualTokenLengths[index] != t).Any()) { return false; } var allAlphaNumericChars = tokens.All(t => t.All(char.IsLetterOrDigit)); return allAlphaNumericChars; }
public ActionResult PredictiveSearch(string keywordStartsWith) { var data = new[] { "London", "Manchester", "Manchester Airport", "London Kings Cross", "London Euston" }; var results = data.Where(s => s.StartsWith(keywordStartsWith)).ToArray(); return new JsonResult { ContentEncoding = Encoding.UTF8, Data = results, ContentType = "application/json", JsonRequestBehavior = JsonRequestBehavior.AllowGet }; }
public override void Execute() { if (!SpellManager.ShouldCast(false)) { return; } const int range = 1100; const float hitchance = 56f; const float aoeratio = 0.2f; var enemies = EntityManager.Heroes.Enemies.Where(n => n.IsValidTarget(range)); var selectedTarget = TargetSelector.GetTarget(range, DamageType.Magical); var allTargets = new[] {selectedTarget}.Concat( enemies.Where(n => n.Index != selectedTarget.Index) .OrderByDescending(n => Damage.TotalDamage(SpellSlot.Q, n)/n.Health)).Where(n => n.IsValidTarget() && !n.WillDie()); if (selectedTarget == null && !enemies.Any()) { return; } #region Killsteal logic var ksQ = Config.Menu["ksQ"].Cast<CheckBox>().CurrentValue && Player.CanUseSpell(SpellSlot.Q) == SpellState.Ready; var ksW = Config.Menu["ksW"].Cast<CheckBox>().CurrentValue && Player.CanUseSpell(SpellSlot.W) == SpellState.Ready; var ksE = Config.Menu["ksE"].Cast<CheckBox>().CurrentValue && Player.CanUseSpell(SpellSlot.E) == SpellState.Ready; var ksR = Config.Menu["ksR"].Cast<CheckBox>().CurrentValue && Player.CanUseSpell(SpellSlot.R) == SpellState.Ready; foreach (var enemy in allTargets) { if (ksE && Player.Instance.IsInRange(enemy, E.Range) && enemy.Killable(SpellSlot.E)) { E.Cast(enemy); return; } if (ksW && Player.Instance.IsInRange(enemy, W.Range + W.Radius) && enemy.Killable(SpellSlot.W)) { var prediction = W.GetPrediction(enemy); if (prediction.HitChancePercent >= hitchance) { W.Cast(prediction.CastPosition); return; } } if (ksQ && Player.Instance.IsInRange(enemy, Q.Range) && enemy.Killable(SpellSlot.Q)) { var prediction = Q.GetPrediction(enemy); if (prediction.HitChancePercent >= hitchance) { Q.Cast(prediction.CastPosition); return; } } if (ksR && Player.Instance.IsInRange(enemy, R.Range) && enemy.Killable(SpellSlot.R)) { R.Cast(enemy); return; } } #endregion #region Combo logic var useQ = Config.Menu["comboQ"].Cast<CheckBox>().CurrentValue && Player.CanUseSpell(SpellSlot.Q) == SpellState.Ready; var useW = Config.Menu["comboW"].Cast<CheckBox>().CurrentValue && Player.CanUseSpell(SpellSlot.W) == SpellState.Ready; var useE = Config.Menu["comboE"].Cast<CheckBox>().CurrentValue && Player.CanUseSpell(SpellSlot.E) == SpellState.Ready; var useR = Config.Menu["comboR"].Cast<CheckBox>().CurrentValue && Player.CanUseSpell(SpellSlot.R) == SpellState.Ready; // check for AOE then single target burst // check W first if (enemies.Count() > 1) { if (useW) { var aoePrediction = Prediction.Position.PredictCircularMissileAoe(enemies.Cast<Obj_AI_Base>().ToArray(), W.Range, W.Radius, W.CastDelay, W.Speed) .OrderByDescending(r => r.GetCollisionObjects<Obj_AI_Minion>().Length) .FirstOrDefault(); if (aoePrediction != null) { var predictedHeroes = aoePrediction.GetCollisionObjects<AIHeroClient>(); if (predictedHeroes.Length > 1 && (float) predictedHeroes.Length/enemies.Count() >= aoeratio) { W.Cast(aoePrediction.CastPosition); return; } } } // check E next if (useE) { var enemyE = enemies.Where(n => n.IsValidTarget(E.Range) && n.IsBlazed()) .OrderByDescending(n => n.CountEnemiesInRange(SpellManager.ConflagrationSpreadRange)) .FirstOrDefault(); if (enemyE != null && enemyE.CountEnemiesInRange(SpellManager.ConflagrationSpreadRange) > 1) { E.Cast(enemyE); return; } } } // single target burst if (useE) { var targets = allTargets.Where(n => Player.Instance.IsInRange(n, E.Range)); foreach (var target in targets) { E.Cast(target); return; } } if (useW) { foreach (var target in allTargets) { if (W.Cast(target)) { return; } } } if (useQ) { foreach (var target in allTargets.Where(n => n.IsBlazed())) { if (Q.Cast(target)) { return; } } } if (useR) { var bestTarget = allTargets.Where(n => Player.Instance.IsInRange(n, R.Range)) .OrderByDescending(n => n.CountEnemiesInRange(SpellManager.PyroclasmSpreadRange)) .FirstOrDefault(); if (bestTarget != null && bestTarget.CountEnemiesInRange(SpellManager.PyroclasmSpreadRange) >= Config.Menu["minEnemiesR"].Cast<Slider>().CurrentValue) { if ((!useW && !useE || bestTarget.IsBlazed())) { R.Cast(bestTarget); } } } #endregion }
//public class A //{ // public string Name { get; set; } //} public static void Test(Assert assert) { assert.Expect(8); // TEST var numbers = new[] { 1, 3, 5, 7 }; var numberPlusOne = (from n in numbers select n + 1).ToArray(); assert.DeepEqual(numberPlusOne, new[] { 2, 4, 6, 8 }, "A sequence of ints one higher than the numbers[]"); // TEST var persons = Person.GetPersons(); var names = (from p in persons select p.Name).ToArray(); assert.DeepEqual(names, new[] { "Frank", "Zeppa", "John", "Billy", "Dora", "Ian", "Mary", "Nemo" }, "Selects names as instance field"); // TEST string[] strings = { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" }; var textNumbers = (from n in numbers select strings[n]).ToArray(); assert.DeepEqual(textNumbers, new[] { "one", "three", "five", "seven" }, "Selects names as items of another array"); // TEST var anonimNames = (from p in persons select new { Name = p.Name }).ToArray(); object[] anonimNamesToCompare = { new { Name = "Frank" }, new { Name = "Zeppa" }, new { Name = "John" }, new { Name = "Billy" }, new { Name = "Dora" }, new { Name = "Ian" }, new { Name = "Mary" }, new { Name = "Nemo" } }; assert.DeepEqual(anonimNames, anonimNamesToCompare, "Selects names as an anonymous type"); // TEST numbers = new[] { 0, 1, 3, 3 }; var numberssInPlace = numbers .Select((n, index) => new { Number = n, IsIndex = n == index }) .ToArray(); object[] anonimNumbersToCompare = { new { Number = 0, IsIndex = true }, new { Number = 1, IsIndex = true }, new { Number = 3, IsIndex = false }, new { Number = 3, IsIndex = true } }; assert.DeepEqual(numberssInPlace, anonimNumbersToCompare, "Selects numbers as an anonymous type"); // TEST var numbersA = new[] { 1, 5, 2 }; var numbersB = new[] { 3, 4, 2 }; var simplePairs = (from a in numbersA from b in numbersB where a < b select new { A = a, B = b } ).ToArray(); object[] expectedSimplePairs = { new { A = 1, B = 3 }, new { A = 1, B = 4 }, new { A = 1, B = 2 }, new { A = 2, B = 3 }, new { A = 2, B = 4 } }; assert.DeepEqual(simplePairs, expectedSimplePairs, "Join two numeric arrays with one where clause"); // TEST numbersA = new[] { 1, 5, 2, 4, 3 }; numbersB = new[] { 3, 4, 2, 5, 1 }; var pairs = (from a in numbersA where a > 1 from b in numbersB where b < 4 && a > b select new { Sum = a + b } ).ToArray(); object[] expectedPairs = { new { Sum = 8}, new { Sum = 7}, new { Sum = 6}, new { Sum = 3}, new { Sum = 7}, new { Sum = 6}, new { Sum = 5}, new { Sum = 5}, new { Sum = 4},}; assert.DeepEqual(pairs, expectedPairs, "Join two numeric arrays with two where clauses"); // TEST numbersA = new[] { 1, 5, 2, 4, 3 }; numbersB = new[] { 3, 4, 2, 5, 1 }; var manyNumbers = numbersA .SelectMany((a, aIndex) => numbersB.Where(b => a == b && b > aIndex).Select(b => new { A = a, B = b, I = aIndex })) .ToArray(); object[] expectedManyNumbers = { new { A = 1, B = 1, I = 0 }, new { A = 5, B = 5, I = 1 }, new { A = 4, B = 4, I = 3 }}; assert.DeepEqual(manyNumbers, expectedManyNumbers, "SelectMany() two number arrays"); }
public void Where() { var source = new[] { new TestObject {Id = 1}.ToSome(), Maybe<TestObject>.None, new TestObject {Id = 2}.ToSome(), new TestObject {Id = 3}.ToSome() }; var results = source.Where(x => x.Id >= 2).ToArray(); CollectionAssert.AreEqual(new[] {source[2], source[3]}, results); }
public void Test() { string[] coll = new[] {"aaa", "bb"}; string[] strings = coll.Where(s => s.Length == 2).ToArray(); }