LINQ를 사용하여 문자열 연결

구식을 쓰는 가장 효율적인 방법은 무엇입니까?

StringBuilder sb = new StringBuilder();
if (strings.Count > 0)
{
    foreach (string s in strings)
    {
        sb.Append(s + ", ");
    }
    sb.Remove(sb.Length - 2, 2);
}
return sb.ToString();

... LINQ에서?

이 답변은 Aggregate질문에 요청 된 LINQ ( )의 사용법을 보여 주며 일상적인 사용을위한 것이 아닙니다. 이것이 사용하지 않기 때문에 StringBuilder매우 긴 시퀀스에서 끔찍한 성능을 발휘합니다. String.Join다른 답변에 표시된 것처럼 정기적 인 코드 사용

다음과 같은 집계 쿼리를 사용하십시오.

string[] words = { "one", "two", "three" };
var res = words.Aggregate(
   "", // start with empty string to handle empty list case.
   (current, next) => current + ", " + next);
Console.WriteLine(res);

출력 :

, 하나 둘 셋

집계는 값 모음을 가져와 스칼라 값을 반환하는 함수입니다. T-SQL의 예로는 min, max 및 sum이 있습니다. VB와 C # 모두 집계를 지원합니다. VB와 C #은 모두 확장 방법으로 집계를 지원합니다. 점 표기법을 사용하면 IEnumerable 객체 에서 메서드를 호출하기 만하면 됩니다.

집계 쿼리는 즉시 실행됩니다.

추가 정보 -MSDN : 집계 쿼리

CodeMonkeyKing의 의견에서 제안한 Aggregate사용 변형 을 실제로 사용 하려면 많은 객체에 대한 우수한 성능을 포함하여 일반과 거의 동일한 코드 가됩니다.StringBuilderString.Join

 var res = words.Aggregate(
     new StringBuilder(), 
     (current, next) => current.Append(current.Length == 0? "" : ", ").Append(next))
     .ToString();

return string.Join(", ", strings.ToArray());

.Net 4에는 을 허용 하는 새로운 과부하 가 있습니다. 코드는 다음과 같습니다.string.JoinIEnumerable<string>

return string.Join(", ", strings);

Linq를 왜 사용해야합니까?

string[] s = {"foo", "bar", "baz"};
Console.WriteLine(String.Join(", ", s));

그것은 완벽하게 작동 IEnumerable<string>하며 내가 기억 하는 한 받아들 입니다. Aggregate더 느린 여기에는 아무것도 필요하지 않습니다 .

집계 확장 방법을 보셨습니까?

var sa = (new[] { "yabba", "dabba", "doo" }).Aggregate((a,b) => a + "," + b);

내 코드의 실제 예 :

return selected.Select(query => query.Name).Aggregate((a, b) => a + ", " + b);

쿼리는 문자열 인 Name 속성을 가진 객체이며 선택한 목록의 모든 쿼리 이름을 쉼표로 구분하여 원합니다.

다음은 다른 답변과 해결 된 문제를 살펴본 후 설정 한 결합 / 링크 방법입니다. 비슷한 질문에서 된 문제 (즉, 집계 및 연결이 0 요소로 실패 함)를 입니다.

string Result = String.Join(",", split.Select(s => s.Name));

또는 ( s 문자열이 아닌 )

string Result = String.Join(",", split.Select(s => s.ToString()));

• 단순한
• 읽고 이해하기 쉬운
• 일반 요소에 적용
• 객체 또는 객체 속성 사용 가능
• 길이가 0 인 요소를 처리
• 추가 Linq 필터링과 함께 사용 가능
• 잘 수행 (적어도 내 경험에서)
• StringBuilder구현하기 위해 추가 객체 (예 :)를 (수동으로) 만들 필요가 없습니다

물론 Join은 때때로 다른 접근법 ( for, foreach)에 몰래 들어가는 성가신 최종 쉼표 를 처리하므로 Linq 솔루션을 먼저 찾고있었습니다.

당신이 사용할 수 StringBuilder있는 Aggregate:

  List<string> strings = new List<string>() { "one", "two", "three" };

  StringBuilder sb = strings
    .Select(s => s)
    .Aggregate(new StringBuilder(), (ag, n) => ag.Append(n).Append(", "));

  if (sb.Length > 0) { sb.Remove(sb.Length - 2, 2); }

  Console.WriteLine(sb.ToString());

(이것은 Select더 많은 LINQ 작업을 수행 할 수 있음을 보여주기 위해 있습니다.)

3000 개 이상의 요소에 대한 StringBuilder vs Select & Aggregate 사례에 대한 빠른 성능 데이터 :

단위 테스트-기간 (초)
LINQ_StringBuilder-0.0036644
LINQ_Select.Aggregate-1.8012535

    [TestMethod()]
    public void LINQ_StringBuilder()
    {
        IList<int> ints = new List<int>();
        for (int i = 0; i < 3000;i++ )
        {
            ints.Add(i);
        }
        StringBuilder idString = new StringBuilder();
        foreach (int id in ints)
        {
            idString.Append(id + ", ");
        }
    }
    [TestMethod()]
    public void LINQ_SELECT()
    {
        IList<int> ints = new List<int>();
        for (int i = 0; i < 3000; i++)
        {
            ints.Add(i);
        }
        string ids = ints.Select(query => query.ToString())
                         .Aggregate((a, b) => a + ", " + b);
    }

나는 항상 확장 방법을 사용합니다 :

public static string JoinAsString<T>(this IEnumerable<T> input, string seperator)
{
    var ar = input.Select(i => i.ToString()).ToArray();
    return string.Join(seperator, ar);
}

' 초 냉각 LINQ 방식 '을 통해 LINQ가 확장 방법을 사용하여 기능적 프로그래밍을 더욱 유용하게 만드는 방식에 대해 이야기 할 수 있습니다. 내 말은, 함수를 중첩 (하나는 다른 내부) 대신 시각적으로 선형 방식으로 (연속적으로) 연결할 수있는 구문 설탕입니다. 예를 들면 다음과 같습니다.

int totalEven = Enumerable.Sum(Enumerable.Where(myInts, i => i % 2 == 0));

다음과 같이 쓸 수 있습니다 :

int totalEven = myInts.Where(i => i % 2 == 0).Sum();

두 번째 예제를보다 쉽게 ​​읽을 수있는 방법을 알 수 있습니다. 또한 들여 쓰기 문제가 적거나 표현식 끝에 나타나는 Lispy 닫는 패런으로 더 많은 함수를 추가 할 수있는 방법을 확인할 수 있습니다 .

다른 답변들 중 다수는 String.Join읽는 것이 가장 빠르거나 단순하기 때문에 갈 길이라고 말합니다. 그러나 ' 슈퍼 쿨 LINQ 방식 '에 대한 나의 해석 을 사용한다면 대답은 String.JoinLINQ 스타일 확장 방법으로 감싸서 시각적으로 즐거운 방식으로 함수를 연결할 수 있도록하는 것입니다. 따라서 쓰고 싶다면 sa.Concatenate(", ")다음과 같이 만들어야합니다.

public static class EnumerableStringExtensions
{
   public static string Concatenate(this IEnumerable<string> strings, string separator)
   {
      return String.Join(separator, strings);
   }
}

이것은 직접 호출만큼 성능이 좋은 코드를 제공하며 (적어도 알고리즘 복잡성 측면에서) 특히 블록의 다른 코드가 연결된 함수 스타일을 사용하는 경우 상황에 따라 코드를 더 읽기 쉽게 만들 수 있습니다. .

이 이전 질문 에는 다양한 대체 답변이 있습니다.이 답변 은 정수 배열을 소스로 타겟팅했지만 일반 답변을 받았습니다.

여기서는 순수한 LINQ를 단일 표현식으로 사용합니다.

static string StringJoin(string sep, IEnumerable<string> strings) {
  return strings
    .Skip(1)
    .Aggregate(
       new StringBuilder().Append(strings.FirstOrDefault() ?? ""), 
       (sb, x) => sb.Append(sep).Append(x));
}

그리고 그 아주 빠른!

나는 약간의 속임수를 쓰고 여기에 주석 안에 넣는 대신 여기에있는 모든 것의 최고를 요약하는 것으로 보이는 새로운 대답을 던질 것입니다.

따라서 한 줄로 할 수 있습니다.

List<string> strings = new List<string>() { "one", "two", "three" };

string concat = strings        
    .Aggregate(new StringBuilder("\a"), 
                    (current, next) => current.Append(", ").Append(next))
    .ToString()
    .Replace("\a, ",string.Empty); 

편집 : 빈 열거 형을 먼저 확인하거나.Replace("\a",string.Empty); 표현식 끝에를 합니다. 내가 너무 똑똑해 지려고했던 것 같아

@ a.friend의 대답은 약간 더 성능이 좋을 수 있습니다. 제거와 비교하여 교체에서 교체가 무엇을하는지 잘 모르겠습니다. \ a 's로 끝나는 문자열을 연결하려는 이유는 분리자를 잃을 것입니다. 이 경우 다른 멋진 캐릭터 를 선택할 수 있습니다.

LINQ와 string.join()매우 효과적으로 결합 할 수 있습니다 . 여기서는 문자열에서 항목을 제거하고 있습니다. 이 작업을 수행하는 더 좋은 방법이 있지만 여기에 있습니다.

filterset = String.Join(",",
                        filterset.Split(',')
                                 .Where(f => mycomplicatedMatch(f,paramToMatch))
                       );

선택의 여지가 많습니다. LINQ와 StringBuilder를 사용하면 다음과 같이 성능을 얻을 수 있습니다.

StringBuilder builder = new StringBuilder();
List<string> MyList = new List<string>() {"one","two","three"};

MyList.ForEach(w => builder.Append(builder.Length > 0 ? ", " + w : w));
return builder.ToString();

linq를 사용하여 IIS 로그 파일을 구문 분석 할 때 다음과 같이 빠르고 더러운 작업을 수행했지만 2 백만 줄을 시도 할 때 메모리 부족 오류가 있었지만 1 백만 줄에서 꽤 잘 작동했습니다 (15 초).

    static void Main(string[] args)
    {

        Debug.WriteLine(DateTime.Now.ToString() + " entering main");

        // USED THIS DOS COMMAND TO GET ALL THE DAILY FILES INTO A SINGLE FILE: copy *.log target.log 
        string[] lines = File.ReadAllLines(@"C:\Log File Analysis\12-8 E5.log");

        Debug.WriteLine(lines.Count().ToString());

        string[] a = lines.Where(x => !x.StartsWith("#Software:") &&
                                      !x.StartsWith("#Version:") &&
                                      !x.StartsWith("#Date:") &&
                                      !x.StartsWith("#Fields:") &&
                                      !x.Contains("_vti_") &&
                                      !x.Contains("/c$") &&
                                      !x.Contains("/favicon.ico") &&
                                      !x.Contains("/ - 80")
                                 ).ToArray();

        Debug.WriteLine(a.Count().ToString());

        string[] b = a
                    .Select(l => l.Split(' '))
                    .Select(words => string.Join(",", words))
                    .ToArray()
                    ;

        System.IO.File.WriteAllLines(@"C:\Log File Analysis\12-8 E5.csv", b);

        Debug.WriteLine(DateTime.Now.ToString() + " leaving main");

    }

linq를 사용한 실제 이유는 이전에 필요했던 Distinct () 때문이었습니다.

string[] b = a
    .Select(l => l.Split(' '))
    .Where(l => l.Length > 11)
    .Select(words => string.Format("{0},{1}",
        words[6].ToUpper(), // virtual dir / service
        words[10]) // client ip
    ).Distinct().ToArray()
    ;

나는 얼마 전에 이것에 대해 블로그를 작성했는데, 내가 원하는 것을 정확하게하기 위해 솔기를 한 것은 다음과 같습니다.

http://ondevelopment.blogspot.com/2009/02/string-concatenation-made-easy.html

블로그 게시물에서 IEnumerable에서 작동하고 Concatenate라는 확장 메소드를 구현하는 방법을 설명하면 다음과 같이 작성할 수 있습니다.

var sequence = new string[] { "foo", "bar" };
string result = sequence.Concatenate();

또는 더 정교한 것들 :

var methodNames = typeof(IFoo).GetMethods().Select(x => x.Name);
string result = methodNames.Concatenate(", ");