C# System.ToList方法代码示例

        public void AddStartStopSymbolsTest()
        {
            var tokens = new[] {"this", "is", "a", "test"};
            List<string> actual = tokens.ToList();
            List<string> expected = tokens.ToList();
            var model = new NGramModel(Unigram);
            model.AddStartStopSymbols(actual);
            CollectionAssert.AreEqual(expected, actual);

            model = new NGramModel(Bigram);
            actual = tokens.ToList();
            expected = new[] {"<s0>", "this", "is", "a", "test", "</s>"}.ToList();
            model.AddStartStopSymbols(actual);
            CollectionAssert.AreEqual(expected, actual);

            model = new NGramModel(Trigram);
            actual = tokens.ToList();
            expected = new[] {"<s1>", "<s0>", "this", "is", "a", "test", "</s>"}.ToList();
            model.AddStartStopSymbols(actual);
            CollectionAssert.AreEqual(expected, actual);

            model = new NGramModel(4);
            actual = tokens.ToList();
            expected = new[] {"<s2>", "<s1>", "<s0>", "this", "is", "a", "test", "</s>"}.ToList();
            model.AddStartStopSymbols(actual);
            CollectionAssert.AreEqual(expected, actual);
        }

        public static void Mod_Test()
        {
            var num1 = new[] {23.4m, 45, 0.96m, 31.2m, 0.87m, 0.8m};
            var num2 = 0.5m;

            Console.WriteLine(num1.Select(x => x.ToString()).Aggregate((x, y) => x + "," + y));
            num1.ToList().ForEach(x => Console.WriteLine("{0} 对 {1} 的余数: {2}", x, num2, x%num2));
            Console.WriteLine("-----------------------------------------------------------------");
            num1.ToList().ForEach(x => Console.WriteLine("{0} 项上取整 {1} 数", x, Math.Ceiling(x)));
            Console.WriteLine("-----------------------------------------------------------------");
            num1.ToList().ForEach(x => Console.WriteLine("{0}/0.5 项上取整 {1} 数", x, Math.Ceiling(x/0.5m)));
        }

        public static Commit BuildCommit(this Guid streamId)
        {
            const int StreamRevision = 2;
            const int CommitSequence = 2;
            var commitId = Guid.NewGuid();
            var headers = new Dictionary<string, object> { { "Key", "Value" }, { "Key2", (long)1234 }, { "Key3", null } };
            var events = new[]
            {
                new EventMessage
                {
                    Headers =
                    {
                        { "MsgKey1", TimeSpan.MinValue },
                        { "MsgKey2", Guid.NewGuid() },
                        { "MsgKey3", 1.1M },
                        { "MsgKey4", (ushort)1 }
                    },
                    Body = "some value"
                },
                new EventMessage
                {
                    Headers =
                    {
                        { "MsgKey1", new Uri("http://www.google.com/") },
                        { "MsgKey4", "some header" }
                    },
                    Body = new[] { "message body" }
                }
            };

            return new Commit(streamId, StreamRevision, commitId, CommitSequence, SystemTime.UtcNow, headers, events.ToList());
        }

		protected override void OnCreate (Bundle savedInstanceState)
		{
			base.OnCreate (savedInstanceState);
			SetContentView (Resource.Layout.recyclerview);

			recyclerView = FindViewById<RecyclerView> (Resource.Id.recycler_view);

			// Layout Managers:
			recyclerView.SetLayoutManager (new LinearLayoutManager (this));

			// Item Decorator:
			recyclerView.AddItemDecoration (new DividerItemDecoration (Resources.GetDrawable (Resource.Drawable.divider)));
			recyclerView.SetItemAnimator (new FadeInLeftAnimator ());

			// Adapter:
			var adapterData = new [] {
				"Alabama", "Alaska", "Arizona", "Arkansas", "California", "Colorado", 
				"Connecticut", "Delaware", "Florida", "Georgia", "Hawaii", "Idaho", 
				"Illinois", "Indiana", "Iowa", "Kansas", "Kentucky", "Louisiana", 
				"Maine", "Maryland", "Massachusetts", "Michigan", "Minnesota", 
				"Mississippi", "Missouri", "Montana", "Nebraska", "Nevada", 
				"New Hampshire", "New Jersey", "New Mexico", "New York", 
				"North Carolina", "North Dakota", "Ohio", "Oklahoma", "Oregon", 
				"Pennsylvania", "Rhode Island", "South Carolina", "South Dakota", 
				"Tennessee", "Texas", "Utah", "Vermont", "Virginia", "Washington", 
				"West Virginia", "Wisconsin", "Wyoming"
			};
			adapter = new RecyclerViewAdapter (this, adapterData.ToList ());
			adapter.Mode = Attributes.Mode.Single;
			recyclerView.SetAdapter (adapter);

			// Listeners
			recyclerView.SetOnScrollListener (new ScrollListener ());
		}

        protected override void OnCreate(Bundle bundle)
        {
            base.OnCreate (bundle);

            SetContentView (Resource.Layout.Main);

            Button button = FindViewById<Button> (Resource.Id.btnRun);

            button.Click += (a, b) =>
            {
                var runs = new[]{
                    new{alg= (IPrime)new AlgorithmAJavaMath(), label= FindViewById<TextView>(Resource.Id.lblAlgAJava), text = "A (java.lang.Math): "},
                    new{alg= (IPrime)new AlgorithmAMonoMath(), label= FindViewById<TextView>(Resource.Id.lblAlgAMono), text = "A (System.Math): "},
                    new{alg= (IPrime)new AlgorithmB(), label= FindViewById<TextView>(Resource.Id.lblAlgB), text = "B: "},
                };

                const int iterations = 100000;

                runs.ToList().ForEach(x =>
                {
                    var elapsed = TheBenchmark.Timed(() =>
                    {
                        for(int i=0; i<iterations; i++)
                        {
                            x.alg.IsPrime(i);
                        }
                    });
                    x.label.Text = x.text + " " + elapsed.TotalMilliseconds;
                });
            };
        }

        protected override System.IAsyncResult OnBeginWorkflowCompleted(System.Activities.ActivityInstanceState completionState, System.Collections.Generic.IDictionary<string, object> workflowOutputs, System.Exception terminationException, System.TimeSpan timeout, System.AsyncCallback callback, object state) {

            if(terminationException == null) {
                MailMessage mail = new MailMessage();
                mail.To.Add(Email);

                mail.From = new MailAddress("[email protected]");

                mail.Subject = "The workflow has completed";

                StringBuilder stringBuilder = new StringBuilder();
                
                stringBuilder.AppendLine("The result of the workflow was: ");
                
                workflowOutputs.ToList().ForEach(kvp => 
                    stringBuilder.AppendLine(string.Format("{0}: {1}", kvp.Key, kvp.Value))
                );
                
                mail.Body = stringBuilder.ToString();

                mail.IsBodyHtml = false;

                SmtpClient smtp = new SmtpClient();
                smtp.Send(mail);
                
            }

            return base.OnBeginWorkflowCompleted(completionState, workflowOutputs, terminationException, timeout, callback, state);
        }

        public override void ViewDidLoad()
        {
            base.ViewDidLoad ();

            btnBenchmark.TouchUpInside += (object sender, EventArgs e) =>
            {
                var runs = new[]{
                    new{alg= (IPrime)new AlgorithmAMonoMath(), label= lblStackOverflow, text = "A: "},
                    new{alg= (IPrime)new AlgorithmB(), label= lblPerls, text = "B: "},
                };

                const int iterations = 100000;

                runs.ToList().ForEach(x =>
                {
                    var elapsed = TheBenchmark.Timed(() =>
                    {
                        for(int i=0; i<iterations; i++)
                        {
                            var p = x.alg.IsPrime(i);
                        }
                    });
                    x.label.Text = x.text + " " + elapsed.TotalMilliseconds;
                });
            };
        }

        public CacheSet<string> SelectByIDs(string EntityName, System.Collections.Generic.IEnumerable<string> EntityIDs)
        {
            CacheSet<string> Result = new CacheSet<string>();

            if (!EntityNames.Contains(EntityName))
            {
                Result.WantIDs = EntityIDs.ToList<string>();

                return Result;
            }

            List<string> IDs = new List<string>();
            List<string> Contents = new List<string>();

            StringBuilder QueryBuilder = new StringBuilder();
            QueryBuilder.AppendFormat("select * from {0} where ID in ({1}) order by ID", EntityName, ToCommaList(EntityIDs));

            DataTable Table = SQLLite.GetDataTable(QueryBuilder.ToString());

            for (int i=0; i < Table.Rows.Count; i++)
            {
                IDs.Add(Table.Rows[i][0].ToString());
                Contents.Add(Table.Rows[i][1].ToString());
            }

            Result.Records = Contents;

            Result.WantIDs = EntityIDs.Except<string>(IDs).ToList<string>();

            return Result;
        }

        public void GetParsedEntities_should_return_two_entities_when_all_pattern_groups_are_used()
        {
            var correctAnswer = new[] { (Entity)new RawTextEntity("|"), new TestEntity("treasure") };
            var answer = Apply_GetParsedEntities("|treasure|some text|");

            CollectionAssert.AreEqual(correctAnswer.ToList(), answer);
        }

        public void GivenProductsWithCurrentCampaignWithSomeThatApplyToTheMember_WhenQuerying_ThenReturnTheProductsThatApplyToTheMember()
        {
            var member = new MemberBuilder().InState(State.Wa).WithAge(10, _now).Build();
            var products = new[]
            {
                new ProductBuilder().WithName("1").WithCampaign(_now,
                    new CampaignBuilder()
                        .ForAllMembers()
                        .StartingAt(_now.AddDays(-1))
                        .EndingAt(_now.AddDays(1))
                ).Build(),
                new ProductBuilder().WithName("2").WithCampaign(_now,
                    new CampaignBuilder()
                        .ForState(State.Act)
                        .StartingAt(_now.AddDays(-1))
                        .EndingAt(_now.AddDays(1))
                ).Build(),
                new ProductBuilder().WithName("2").WithCampaign(_now,
                    new CampaignBuilder()
                        .ForState(State.Wa)
                        .WithMinimumAge(9)
                        .WithMaximumAge(11)
                        .StartingAt(_now.AddDays(-1))
                        .EndingAt(_now.AddDays(1))
                ).Build()
            };
            products.ToList().ForEach(p => Session.Save(p));

            var result = Execute(new GetProductsForMember(_now, member));

            Assert.That(result.Select(p => p.Name).ToArray(), Is.EqualTo(new[]{products[0].Name, products[2].Name}));
        }

        public void GetParsedEntities_should_return_one_entity_when_first_pattern_group_is_empty()
        {
            var correctAnswer = new[] { (Entity)new TestEntity("treasure") };
            var answer = Apply_GetParsedEntities("treasure|some text|");

            CollectionAssert.AreEqual(correctAnswer.ToList(), answer);
        }

		public void EventTest ()
		{
			var automationEventsArray = new [] {
				new {Sender = (object) null, Args = (AutomationPropertyChangedEventArgs) null}};
			var automationEvents = automationEventsArray.ToList ();
			automationEvents.Clear ();

			var dock = (DockPattern)
				splitter1Element.GetCurrentPattern (DockPattern.Pattern);

			dock.SetDockPosition (DockPosition.Top);

			SWA.Automation.AddAutomationPropertyChangedEventHandler (splitter1Element,
				TreeScope.Element,
				(o, e) => automationEvents.Add (new { Sender = o, Args = e }),
				DockPattern.DockPositionProperty);

			dock.SetDockPosition (DockPosition.Right);
			Thread.Sleep (200);
			Assert.AreEqual (1, automationEvents.Count, "event count");
			Assert.AreEqual (DockPattern.DockPositionProperty,
				automationEvents [0].Args.Property, "event property");
			Assert.AreEqual (splitter1Element,
				automationEvents [0].Sender, "event sender");
			Assert.AreEqual (3,
				automationEvents [0].Args.NewValue, "event new val");
		}

        protected override Expression VisitBinary(BinaryExpression node)
        {
            if (node == null)
            {
                throw new ArgumentNullException("node");
            }

            var allowedProperties = new[] { "Project", "Definition", "Number", "Reason", "Quality", "Status", "RequestedBy", "RequestedFor", "StartTime", "FinishTime", "BuildFinished" };

            if (node.NodeType == ExpressionType.OrElse)
            {
                throw new NotSupportedException("Logical OR operators are not supported for Build Custom filters");
            }

            if (node.Left is MemberExpression && node.Right is ConstantExpression)
            {
                var fieldName = (node.Left as MemberExpression).Member.Name;
                var value = (node.Right as ConstantExpression).Value;

                if (!allowedProperties.ToList().Contains(fieldName))
                {
                    throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, "You can only filter by the following properties: {0}. (e.g. /Builds/$filter=Number gt 100 and  Quality eq 'Healthy') ", string.Join(", ", allowedProperties)));
                }

                this.AddFilterNode(fieldName, value, FilterNode.ParseFilterExpressionType(node.NodeType), FilterNodeRelationship.And);
            }
            else if (node.Left.NodeType == ExpressionType.Conditional)
            {
                throw new NotSupportedException("Only equality and inequality operators between fields and constant expressions are allowed with Build Custom filters");
            }

            return base.VisitBinary(node);
        }

        protected override Expression VisitBinary(BinaryExpression node)
        {
            if (node == null)
            {
                throw new ArgumentNullException("node");
            }

            var allowedProperties = new[] { "Id", "ArtifactUri", "Comment", "Committer", "CreationDate", "Owner", "Branch" };

            if (node.NodeType == ExpressionType.OrElse)
            {
                throw new NotSupportedException("Logical OR operators are not supported for Changeset Custom filters");
            }

            if (node.Left is MemberExpression && node.Right is ConstantExpression)
            {
                var fieldName = (node.Left as MemberExpression).Member.Name;
                var value = (node.Right as ConstantExpression).Value;

                if (!allowedProperties.ToList().Contains(fieldName))
                {
                    throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, "You can only filter by the following properties: {0}. (e.g. /Changesets/$filter=Committer eq 'john' and  CreationDate gt datetime'2010-10-18') ", string.Join(", ", allowedProperties)));
                }

                this.AddFilterNode(fieldName, value, FilterNode.ParseFilterExpressionType(node.NodeType), FilterNodeRelationship.And);
            }
            else if (node.Left.NodeType == ExpressionType.Conditional)
            {
                throw new NotSupportedException("Only equality and inequality operators between fields and constant expressions are allowed with Changeset Custom filters");
            }

            return base.VisitBinary(node);
        }

		public void PropertyEventTest ()
		{
			var automationEventsArray = new [] {
				new {Sender = (object) null, Args = (AutomationPropertyChangedEventArgs) null}};
			var automationEvents = automationEventsArray.ToList ();
			automationEvents.Clear ();

			string magicStr1 = "ValuePatternTest.PropertyEventTest.m1";
			string magicStr2 = "ValuePatternTest.PropertyEventTest.m2";
			ValuePattern pattern = (ValuePattern) textbox1Element.GetCurrentPattern (ValuePatternIdentifiers.Pattern);
			pattern.SetValue (magicStr1);
			Thread.Sleep (500);

			AutomationPropertyChangedEventHandler handler = 
				(o, e) => automationEvents.Add (new { Sender = o, Args = e });

			At.AddAutomationPropertyChangedEventHandler (textbox1Element,
				TreeScope.Element, handler,
				ValuePattern.ValueProperty,
				ValuePattern.IsReadOnlyProperty );

			pattern.SetValue (magicStr2);
			Thread.Sleep (500);
			Assert.AreEqual (1, automationEvents.Count, "event count");
			Assert.AreEqual (textbox1Element, automationEvents [0].Sender, "event sender");
			Assert.AreEqual (magicStr2, automationEvents [0].Args.NewValue, "new Value");
			// LAMESPEC: The value should be equal to "magicStr1" but is returning null instead
			Assert.IsNull (automationEvents [0].Args.OldValue, "old Value");
			automationEvents.Clear ();

			At.RemoveAutomationPropertyChangedEventHandler (textbox1Element, handler);
			pattern.SetValue (magicStr1);
			Thread.Sleep (500);
			Assert.AreEqual (0, automationEvents.Count, "event count");
		}