¿Cómo recorro un rango de fechas?

Ni siquiera estoy seguro de cómo hacer esto sin usar alguna solución horrible para el tipo de bucle / contador. Aquí está el problema:

Me dan dos fechas, una fecha de inicio y una fecha de finalización y en un intervalo específico necesito tomar alguna medida. Por ejemplo: para cada fecha entre el 10/03/2009 y el tercer día hasta el 26/03/2009, necesito crear una entrada en una Lista. Entonces mis entradas serían:

DateTime StartDate = "3/10/2009";
DateTime EndDate = "3/26/2009";
int DayInterval = 3;

y mi salida sería una lista que tiene las siguientes fechas:

13/03/2009 16/03/2009 19/03/2009 22/03/2009 25/03/2009

Entonces, ¿cómo diablos haría algo como esto? Pensé en usar un bucle for que iteraría entre cada día en el rango con un contador separado como este:

int count = 0;

for(int i = 0; i < n; i++)
{
     count++;
     if(count >= DayInterval)
     {
          //take action
          count = 0;
     }

}

Pero parece que podría haber una mejor manera?

Bueno, deberás recorrerlos de una forma u otra. Prefiero definir un método como este:

public IEnumerable<DateTime> EachDay(DateTime from, DateTime thru)
{
    for(var day = from.Date; day.Date <= thru.Date; day = day.AddDays(1))
        yield return day;
}

Entonces puedes usarlo así:

foreach (DateTime day in EachDay(StartDate, EndDate))
    // print it or whatever

De esta manera, podría presionar cada dos días, cada tercer día, solo entre semana, etc. Por ejemplo, para regresar cada tercer día a partir de la fecha de "inicio", puede simplemente llamar AddDays(3)al bucle en lugar de hacerlo AddDays(1).

Tengo una Rangeclase en MiscUtil que puedes encontrar útil. En combinación con los diversos métodos de extensión, puede hacer:

foreach (DateTime date in StartDate.To(EndDate).ExcludeEnd()
                                   .Step(DayInterval.Days())
{
    // Do something with the date
}

(Es posible que desee o no excluir el final, solo pensé en proporcionarlo como ejemplo).

Esto es básicamente una forma lista para usar (y de uso más general) de la solución de mquander.

Para tu ejemplo puedes probar

DateTime StartDate = new DateTime(2009, 3, 10);
DateTime EndDate = new DateTime(2009, 3, 26);
int DayInterval = 3;

List<DateTime> dateList = new List<DateTime>();
while (StartDate.AddDays(DayInterval) <= EndDate)
{
   StartDate = StartDate.AddDays(DayInterval);
   dateList.Add(StartDate);
}

Código de @mquander y @Yogurt The Wise utilizado en extensiones:

public static IEnumerable<DateTime> EachDay(DateTime from, DateTime thru)
{
    for (var day = from.Date; day.Date <= thru.Date; day = day.AddDays(1))
        yield return day;
}

public static IEnumerable<DateTime> EachMonth(DateTime from, DateTime thru)
{
    for (var month = from.Date; month.Date <= thru.Date || month.Month == thru.Month; month = month.AddMonths(1))
        yield return month;
}

public static IEnumerable<DateTime> EachDayTo(this DateTime dateFrom, DateTime dateTo)
{
    return EachDay(dateFrom, dateTo);
}

public static IEnumerable<DateTime> EachMonthTo(this DateTime dateFrom, DateTime dateTo)
{
    return EachMonth(dateFrom, dateTo);
}

DateTime startDate = new DateTime(2009, 3, 10);
DateTime stopDate = new DateTime(2009, 3, 26);
int interval = 3;

for (DateTime dateTime=startDate;
     dateTime < stopDate; 
     dateTime += TimeSpan.FromDays(interval))
{

}

1 año después, que pueda ayudar a alguien,

Esta versión incluye un predicado , para ser más flexible.

Uso

var today = DateTime.UtcNow;
var birthday = new DateTime(2018, 01, 01);

Diariamente a mi cumpleaños

var toBirthday = today.RangeTo(birthday);  

Mensualmente para mi cumpleaños, paso 2 meses

var toBirthday = today.RangeTo(birthday, x => x.AddMonths(2));

Anual para mi cumpleaños

var toBirthday = today.RangeTo(birthday, x => x.AddYears(1));

Utilizar en su RangeFromlugar

// same result
var fromToday = birthday.RangeFrom(today);
var toBirthday = today.RangeTo(birthday);

Implementación

public static class DateTimeExtensions 
{

    public static IEnumerable<DateTime> RangeTo(this DateTime from, DateTime to, Func<DateTime, DateTime> step = null)
    {
        if (step == null)
        {
            step = x => x.AddDays(1);
        }

        while (from < to)
        {
            yield return from;
            from = step(from);
        }
    }

    public static IEnumerable<DateTime> RangeFrom(this DateTime to, DateTime from, Func<DateTime, DateTime> step = null)
    {
        return from.RangeTo(to, step);
    }
}

Extras

Podría lanzar una excepción si el fromDate > toDate, pero prefiero devolver un rango vacío en su lugar[]

DateTime startDate = new DateTime(2009, 3, 10);
DateTime stopDate = new DateTime(2009, 3, 26);
int interval = 3;

while ((startDate = startDate.AddDays(interval)) <= stopDate)
{
    // do your thing
}

Según el problema, puedes probar esto ...

// looping between date range    
while (startDate <= endDate)
{
    //here will be your code block...

    startDate = startDate.AddDays(1);
}

Gracias......

DateTime begindate = Convert.ToDateTime("01/Jan/2018");
DateTime enddate = Convert.ToDateTime("12 Feb 2018");
 while (begindate < enddate)
 {
    begindate= begindate.AddDays(1);
    Console.WriteLine(begindate + "  " + enddate);
 }

Puede considerar escribir un iterador en su lugar, lo que le permite usar la sintaxis de bucle 'for' normal como '++'. Busqué y encontré una pregunta similar respondida aquí en StackOverflow, que ofrece sugerencias para hacer que DateTime sea iterable.

Puede usar la DateTime.AddDays()función para agregar su DayIntervalal StartDatey verificar para asegurarse de que sea menor que el EndDate.

debe tener cuidado aquí para no perder las fechas cuando en el bucle sería una mejor solución.

esto le da la primera fecha de inicio y la usa en el ciclo antes de incrementarla y procesará todas las fechas, incluida la última fecha de finalización, por lo tanto <= finalización.

entonces la respuesta anterior es la correcta.

while (startdate <= enddate)
{
    // do something with the startdate
    startdate = startdate.adddays(interval);
}

Puedes usar esto.

 DateTime dt0 = new DateTime(2009, 3, 10);
 DateTime dt1 = new DateTime(2009, 3, 26);

 for (; dt0.Date <= dt1.Date; dt0=dt0.AddDays(3))
 {
    //Console.WriteLine(dt0.Date.ToString("yyyy-MM-dd"));
    //take action
 }

Iterar cada 15 minutos

DateTime startDate = DateTime.Parse("2018-06-24 06:00");
        DateTime endDate = DateTime.Parse("2018-06-24 11:45");

        while (startDate.AddMinutes(15) <= endDate)
        {

            Console.WriteLine(startDate.ToString("yyyy-MM-dd HH:mm"));
            startDate = startDate.AddMinutes(15);
        }

@ jacob-sobus y @mquander y @Yogurt no son exactamente correctos ... Si necesito al día siguiente, espero las 00:00 en su mayoría

    public static IEnumerable<DateTime> EachDay(DateTime from, DateTime thru)
    {
        for (var day = from.Date; day.Date <= thru.Date; day = day.NextDay())
            yield return day;
    }

    public static IEnumerable<DateTime> EachMonth(DateTime from, DateTime thru)
    {
        for (var month = from.Date; month.Date <= thru.Date || month.Year == thru.Year && month.Month == thru.Month; month = month.NextMonth())
            yield return month;
    }

    public static IEnumerable<DateTime> EachYear(DateTime from, DateTime thru)
    {
        for (var year = from.Date; year.Date <= thru.Date || year.Year == thru.Year; year = year.NextYear())
            yield return year;
    }

    public static DateTime NextDay(this DateTime date)
    {
        return date.AddTicks(TimeSpan.TicksPerDay - date.TimeOfDay.Ticks);
    }

    public static DateTime NextMonth(this DateTime date)
    {
        return date.AddTicks(TimeSpan.TicksPerDay * DateTime.DaysInMonth(date.Year, date.Month) - (date.TimeOfDay.Ticks + TimeSpan.TicksPerDay * (date.Day - 1)));
    }

    public static DateTime NextYear(this DateTime date)
    {
        var yearTicks = (new DateTime(date.Year + 1, 1, 1) - new DateTime(date.Year, 1, 1)).Ticks;
        var ticks = (date - new DateTime(date.Year, 1, 1)).Ticks;
        return date.AddTicks(yearTicks - ticks);
    }

    public static IEnumerable<DateTime> EachDayTo(this DateTime dateFrom, DateTime dateTo)
    {
        return EachDay(dateFrom, dateTo);
    }

    public static IEnumerable<DateTime> EachMonthTo(this DateTime dateFrom, DateTime dateTo)
    {
        return EachMonth(dateFrom, dateTo);
    }

    public static IEnumerable<DateTime> EachYearTo(this DateTime dateFrom, DateTime dateTo)
    {
        return EachYear(dateFrom, dateTo);
    }

Aquí están mis 2 centavos en 2020.

Enumerable.Range(0, (endDate - startDate).Days + 1)
.ToList()
.Select(a => startDate.AddDays(a));