C# System.Linq.Last方法代码示例

        public void Execute()
        {
            var languages = new[] {"csharp", "visualbasic", "java", "python", "ruby", "php", "c++"};

            //
            // First拡張メソッドは、シーケンスの最初の要素を返すメソッド。
            //
            // predicateを指定した場合は、その条件に合致する最初の要素が返る。
            //
            Output.WriteLine("============ First ============");
            Output.WriteLine(languages.First());
            Output.WriteLine(languages.First(item => item.StartsWith("v")));

            //
            // Last拡張メソッドは、シーケンスの最後の要素を返すメソッド。
            //
            // predicateを指定した場合は、その条件に合致する最後の要素が返る。
            //
            Output.WriteLine("============ Last ============");
            Output.WriteLine(languages.Last());
            Output.WriteLine(languages.Last(item => item.StartsWith("p")));

            //
            // Single拡張メソッドは、シーケンスの唯一の要素を返すメソッド。
            //
            // Singleを利用する場合、対象となるシーケンスには要素が一つだけ
            // でないといけない。複数の要素が存在する場合例外が発生する。
            //
            // また、空のシーケンスに対してSingleを呼ぶと例外が発生する。
            //
            // predicateを指定した場合は、その条件に合致するシーケンスの唯一の
            // 要素が返される。この場合も、結果のシーケンスには要素が一つだけの
            // 状態である必要がある。条件に合致する要素が複数であると例外が発生する、
            //
            Output.WriteLine("============ Single ============");
            var onlyOne = new[] {"csharp"};
            Output.WriteLine(onlyOne.Single());

            try
            {
                // ReSharper disable once UnusedVariable
                var val = languages.Single();
            }
            catch
            {
                Output.WriteLine("複数の要素が存在する状態でSingleを呼ぶと例外が発生する。");
            }

            Output.WriteLine(languages.Single(item => item.EndsWith("y")));

            try
            {
                // ReSharper disable once UnusedVariable
                var val = languages.Single(item => item.StartsWith("p"));
            }
            catch
            {
                Output.WriteLine("条件に合致する要素が複数存在する場合例外が発生する。");
            }
        }

        public void Append_adds_item_to_end_of_sequence()
        {
            var result = new[] { 1, 2 }.Append(3);

            Assert.Equal(3, result.Count());
            Assert.Equal(1, result.First());
            Assert.Equal(3, result.Last());
        }

        public void Prepend_adds_item_to_beginning_of_sequence()
        {
            var result = new[] { 2, 3 }.Prepend(1);

            Assert.Equal(3, result.Count());
            Assert.Equal(1, result.First());
            Assert.Equal(3, result.Last());
        }

 public void Should_fill_an_incomplete_set_if_requested()
 {
     var nums = new[] { 1, 2, 3, 4, 5, 6, 7 };
     const int numberInSet = 2;
     const int fillValue = 9;
     var pairs = nums.InSetsOf(numberInSet, true, fillValue).ToArray();
     var last = pairs.Last();
     last.Count.ShouldBeEqualTo(numberInSet);
     last[0].ShouldBeEqualTo(nums.Last());
     last[1].ShouldBeEqualTo(fillValue);
 }

        public void StatementPositionTest()
        {
            const string temp = "Test 123123123 ";
            var strings = new[]
                          {
                          	"<%ruleclass Test%>",   // 0
                          	"<%rule Temp()%>",      // 1
                          	temp + "<%= value %>",  // 2 0, 1
                          	"Pre End Text",         // 3 2
                          	"<%= value %>",         // 4 3
                          	"End Text",             // 5 4
                          	"<%end%>",              // 6
                          };

            const string endLine = "\r\n";
            var statementText = string.Join( endLine, strings );

            var ruleClassStatement = ParserHelper.ParseClass( statementText );

            var textStatement1StartPos = string.Join( endLine, strings.Take(2).ToArray() ).Length + endLine.Length;
            var textStatement1EndPos = textStatement1StartPos + temp.Length - 1;

            var ruleMethodStatement = (RuleMethodStatement)ruleClassStatement.RuleMethodStatements[0];
            AssertHelper.AssertStatementPosition( textStatement1StartPos, textStatement1EndPos,
                                                  ruleMethodStatement.Statements[0].StatementPosition );

            // »звратный подсчЄт, дл¤ UnitTest'а плохой вариант, но так впадлу вручную считать
            AssertHelper.AssertStatementPosition( 3, 3, temp.Length + 1, strings[2].Length, textStatement1EndPos + 1,
                                                  textStatement1EndPos + strings[2].Length - temp.Length,
                                                  ruleMethodStatement.Statements[1].StatementPosition );

            TestText( endLine, strings, 3, 2, ruleMethodStatement.Statements[2].StatementPosition );

            TestText( endLine, strings, 5, 1, ruleMethodStatement.Statements[4].StatementPosition );

            AssertHelper.AssertStatementPosition( 1, strings.Length, 1, strings.Last().Length, 0, statementText.Length - 1,
                                                  ruleClassStatement.StatementPosition );
        }

        public void ReturnsAnEnumerableWithTheAdditionalItemsAtTheEnd()
        {
            var collection = new[] { 1, 2, 3 }.Concat(4);

            Assert.That(collection.Last(), Is.EqualTo(4));
        }

        private static void ThrowExceptionOnLast1()
        {
            var numbers = new[] { 3, 4 };

            numbers.Last(x => x == 5);
        }