C #에서 정수 시퀀스를 만드는 방법은 무엇입니까?

F #에는 시퀀스 를 만들 수있는 시퀀스가 ​​있습니다.

seq { 0 .. 10 }

0에서 10까지의 숫자 시퀀스를 만듭니다.

C #에 비슷한 것이 있습니까?

사용할 수 있습니다 Enumerable.Range(0, 10);. 예:

var seq = Enumerable.Range(0, 10);

여기에 MSDN 페이지 .

Enumerable.Range(0, 11);

지정된 범위 내에서 일련의 정수를 생성합니다.

http://msdn.microsoft.com/en-us/library/system.linq.enumerable.range.aspx

간단한 함수를 만들 수 있습니다. 이것은 더 복잡한 시퀀스에서 작동합니다. 그렇지 않으면 Enumerable.Range해야합니다.

IEnumerable<int> Sequence(int n1, int n2)
{
    while (n1 <= n2)
    {
        yield return  n1++;
    }
}

거의 사용되지 않는 인덱서 오버로드 가있는 Linq 프로젝션 (i) :

(new int[11]).Select((o,i) => i)

유연성 때문에이 방법을 선호합니다.

예를 들어, 짝수를 원한다면 :

(new int[11]).Select((item,i) => i*2)

또는 5 분 단위로 시간을 늘리려면 :

(new int[12]).Select((item,i) => i*5)

또는 문자열 :

(new int[12]).Select((item,i) => "Minute:" + i*5)

C # 8.0에서는 인덱스와 범위를 사용할 수 있습니다.

예를 들면 :

var seq = 0..2;
var array = new string[]
{
    "First",
    "Second",
    "Third",
};

foreach(var s in array[seq])
{
    System.Console.WriteLine(s);
}
// Output: First, Second

또는 생성하려는 경우 IEnumerable<int>확장을 사용할 수 있습니다.

public static IEnumerable<int> ToEnumerable(this Range range)
{
   for (var i = range.Start.Value; i < range.End.Value; i++)
   {
       yield return i;
   }
}
...
var seq = 0..2;

foreach (var s in seq.ToEnumerable())
{
   System.Console.WriteLine(s);
}
// Output: 0, 1

추신 그러나 '끝에서 색인'에 주의하십시오 . 예를 들어 ToEnumerable 확장 메서드는 var seq = ^2..^0.

내 구현 :

    private static IEnumerable<int> Sequence(int start, int end)
    {
        switch (Math.Sign(end - start))
        {
            case -1:
                while (start >= end)
                {
                    yield return start--;
                }

                break;

            case 1:
                while (start <= end)
                {
                    yield return start++;
                }

                break;

            default:
                yield break;
        }
    }

원래 여기에 대답했습니다 .

일련의 숫자 ( IEnumerable<int>)를 0변수 에서 열거 하려면 end다음을 시도하십시오.

Enumerable.Range(0, ++10);

설명에서, 0에서 10까지의 숫자 시퀀스를 얻으려면 시퀀스를 0에서 시작해야합니다 (0에서 10 사이의 숫자가 11 개 (포함)임을 기억).

무제한 선형 시리즈를 원한다면 다음과 같은 함수를 작성할 수 있습니다.

IEnumerable<int> Series(int k = 0, int n = 1, int c = 1)
{
    while (true)
    {
        yield return k;
        k = (c * k) + n;
    }
}

다음과 같이 사용할 수 있습니다.

var ZeroTo1000 = Series().Take(11);

함수를 원하면 반복적으로 호출하여 증가하는 숫자를 생성 할 수 있습니다. 아마도 다음과 같은 것을 원할 것입니다.

using System.Threading;

private static int orderNumber = 0;

int Seq()
{
    return Interlocked.Increment(ref orderNumber);
}

전화 Seq()하면 다음 주문 번호가 반환되고 카운터가 증가합니다.

내 코드에 이러한 기능이 있습니다.

private static IEnumerable<int> FromZero(this int count)
    {
        if (count <= 0)
            yield break;

        for (var i = 0; i < count; i++)
        {
            yield return i;
        }
    }

    private static IEnumerable<int> FromOne(this int count)
    {
        if (count <= 0)
            yield break;

        for (var i = 1; i <= count; i++)
        {
            yield return i;
        }
    }

이는 일부 for (i) 코드를 줄이는 데 도움이됩니다.