C# List.Join方法代码示例

 public void JoinTest()
 {
     var data = new List<String>() { "A", "B", "C", "D", "E" };
       var expected = "A, B, C, D, E";
       var actual = data.Join(", ");
       Assert.AreEqual(expected, actual);
 }

        public void Join()
        {
            var emptyList = new List<string>();
            var oneItemList = new List<string> { "One" };
            var twoItemList = new List<string> { "One", "Two" };

            Assert.That(emptyList.Join(","), Is.EqualTo(String.Empty));
            Assert.That(oneItemList.Join(","), Is.EqualTo("One"));
            Assert.That(twoItemList.Join(","), Is.EqualTo("One,Two"));
        }

 public void join()
 {
     var list = new List<string>(new[] {"a", "b", "c"});
     list.Join(", ").ShouldEqual("a, b, c");
 }

 public void Join_IgnoresNullElements()
 {
     var listWithNull = new List<string> { "One", null, "Two" };
     Assert.That(listWithNull.Join(","), Is.EqualTo("One,Two"));
 }

 public void LIVE_STRESS_TEST_multiple_producers_multiple_queues_one_consumer_per_queue()
 {
     var messagesPerProducer = 100;
     var producerCount = 1;
     var client = CreateLiveClient();
     var queues = new List<string>();
     foreach(var x in new[] { "a", "b", "c", "d" }) {
         var queue = "test-" + x + "-" + StringUtil.CreateAlphaNumericKey(4);
         client.CreateQueue(queue, new Result<AwsSqsResponse>()).Wait();
         queues.Add(queue);
     }
     try {
         var producers = new List<Result<List<string>>>();
         for(var i = 0; i < producerCount; i++) {
             var producer = i;
             producers.Add(Async.Fork(() => {
                 _log.DebugFormat("producer {0} started", producer);
                 var c = CreateLiveClient();
                 var msgs = new List<string>();
                 for(var j = 0; j < messagesPerProducer; j++) {
                     var msg = StringUtil.CreateAlphaNumericKey(1024);
                     foreach(var queue in queues) {
                         c.Send(queue, AwsSqsMessage.FromBody(msg), new Result<AwsSqsSendResponse>()).Wait();
                     }
                     msgs.Add(msg);
                     if(msgs.Count % 10 == 0) {
                         _log.DebugFormat("producer {0} sent {1}/{2} msgs", producer, msgs.Count, messagesPerProducer);
                     }
                 }
                 _log.DebugFormat("producer {0} finished", producer);
                 return msgs;
             }, new Result<List<string>>()));
         }
         var consumers = queues.ToDictionary(queue => queue, queue => Async.Fork(() => {
             _log.DebugFormat("consumer {0} started", queue);
             var c = CreateLiveClient();
             var msgs = new List<string>();
             var expected = messagesPerProducer * producerCount;
             var lastReport = 0;
             while(msgs.Count < expected) {
                 var received = c.ReceiveMax(queue, new Result<IEnumerable<AwsSqsMessage>>()).Wait();
                 var count = 0;
                 foreach(var msg in received) {
                     count++;
                     msgs.Add(msg.Body);
                     c.Delete(msg, new Result<AwsSqsResponse>()).Wait();
                 }
                 if(count > 0 && msgs.Count > lastReport + 10) {
                     _log.DebugFormat("consumer '{0}' received: {1}/{2}", queue, msgs.Count, expected);
                     lastReport = msgs.Count;
                 }
             }
             return msgs;
         }, new Result<List<string>>()));
         producers.Join(new Result()).Wait();
         consumers.Values.Join(new Result()).Wait();
         var allMessages = producers.SelectMany(x => x.Value).OrderBy(x => x).ToArray();
         foreach(var consumed in consumers) {
             var queue = consumed.Key;
             var messages = consumed.Value.Value.OrderBy(x => x).ToArray();
             Assert.AreEqual(allMessages, messages, string.Format("message list for queue '{0}' is wrong", queue));
         }
     } finally {
         foreach(var queue in queues) {
             _log.DebugFormat("cleaning up queue '{0}'", queue);
             client.DeleteQueue(queue, new Result<AwsSqsResponse>()).Wait();
         }
     }
 }

 public Result<Production> Produce(int messages)
 {
     var production = new Production();
     var final = new Result<Production>();
     Async.Fork(() => {
         try {
             _log.DebugFormat("{0}: Producing {1} messages", production.Id, messages);
             var responses = new List<Result<string>>();
             var client = new AwsSqsClient(_clientConfig);
             for(var i = 0; i < messages; i++) {
                 var result = new Result<string>();
                 responses.Add(result);
                 var msg = production.Id + ":" + messages;
                 client.Send(_queue, AwsSqsMessage.FromBody(msg), new Result<AwsSqsSendResponse>()).WhenDone(r => {
                     if(r.HasException) {
                         result.Throw(r.Exception);
                         return;
                     }
                     result.Return(msg);
                 });
             }
             responses.Join(new Result()).WhenDone(r => {
                 if(r.HasException) {
                     final.Throw(r.Exception);
                     return;
                 }
                 production.Stopwatch.Stop();
                 production.Sent.AddRange(responses.Select(x => x.Value));
                 _log.DebugFormat("{0}: Sent {1} messages in {2:0.00}s @ {3:0.00}msg/sec",
                     production.Id,
                     production.Sent.Count,
                     production.Stopwatch.Elapsed.TotalSeconds,
                     production.Sent.Count / production.Stopwatch.Elapsed.TotalSeconds
                 );
                 final.Return(production);
             });
         } catch(Exception e) {
             final.Throw(e);
         }
     });
     return final;
 }

 public void LIVE_STRESSTEST_Produce_Consume()
 {
     var client = CreateLiveClient();
     var queue = "test-" + StringUtil.CreateAlphaNumericKey(8);
     client.CreateQueue(queue, new Result<AwsSqsResponse>()).Wait();
     try {
         var n = 100;
         var productions = new List<Result<Production>>();
         var producer = new Producer(queue, GetConfig());
         for(var i = 0; i < 4; i++) {
             productions.Add(producer.Produce(n));
         }
         productions.Join(new Result()).Wait();
         var totalMessages = productions.Count * n;
         var consumers = new List<Consumer>();
         for(var i = 0; i < 10; i++) {
             var consumer = new Consumer(queue, CreateLiveClient());
             consumer.Consume();
             consumers.Add(consumer);
         }
         Assert.IsTrue(
             Wait.For(() => consumers.Sum(x => x.Received) == totalMessages, (totalMessages * 0.2).Seconds()),
             string.Format("got {0} instead of the expected {1} messages", consumers.Sum(x => x.Received), totalMessages)
         );
     } finally {
         _log.DebugFormat("cleaning up queue '{0}'", queue);
         client.DeleteQueue(queue, new Result<AwsSqsResponse>()).Wait();
     }
 }

 public void WaitForEmailsToBeSent(List<string> recipients, int waitFor = 5)
 {
     WaitForEmailsWithCondition(waitFor,
                                messages => recipients.Join(messages, x => x, y => y.To.First().Address, (x, y) => x)
                                .Count() == recipients.Count());
 }

        private void CodegenAllServicesTest(string language)
        {
            // Discover discovery.
            IService discovery = DiscoverDiscovery();

            // Generate discovery.
            Assembly discoveryAssembly = CodegenDiscovery(discovery);

            // Call the .List method.
            API[] apis = DiscoveryListServices(discoveryAssembly);

            // Run the generator.
            List<Exception> exceptions = new List<Exception>();
            List<string> failedAPIs = new List<string>();
            foreach (API api in apis)
            {
                try
                {
                    Assert.NotNull(TestService(language, api));
                }
                catch (Exception e)
                {
                    // Catch all exceptions, and throw them together.
                    failedAPIs.Add(api.Name);
                    exceptions.Add(e);
                }
            }

            // Create the error message.
            if (exceptions.Count > 0)
            {
                var message = new StringBuilder();
                message.AppendLine(
                    string.Format("Failed to generate {0} out of {1} APIs:", failedAPIs.Count, apis.Length));
                message.AppendLine(String.Join(", ", failedAPIs.ToArray()));
                message.AppendLine();

                int i = 0;
                int j = 0;
                var msgs = failedAPIs.Join(
                    exceptions, str => i++, ex => j++, (str, ex) => new { API = str, Exception = ex });
                foreach (var entries in msgs)
                {
                    message.AppendLine(string.Format("API '{0}' failed with:", entries.API));
                    message.AppendLine(string.Format("   {0}", entries.Exception));
                }

                Assert.Fail(message.ToString());
            }
        }

        public void JoinWithComparerQueryReuse()
        {
            List<int> first = new List<int> { 1, 2 };
            List<int> second = new List<int> { 4, 5 };
            IEnumerable<string> enumerable = first.Join(second, x => x % 2 == 0, x => x % 2 == 0, (x, y) => String.Format("{0}:{1}", x, y), EqualityComparer<bool>.Default);

            enumerable.AssertEqual("1:5", "2:4");

            first.Add(3);
            second.Add(6);
            enumerable.AssertEqual("1:5", "2:4", "2:6", "3:5");
        }

 public void Join()
 {
     var list = new List<string>() { "first", "second", "third" };
     var joined = list.Join(",");
     Assert.That(joined, Has.Length.EqualTo(18), "Incorrect length.");
 }