¿Cómo se repite todos los días del año?

Question

Dada una fecha de inicio de 1/1/2009 y una fecha de finalización de 31/12/2009, ¿cómo puedo repetir cada fecha y recuperar un valor de DateTime usando C#?

Gracias!

Answer 1

me gustaría utilizar un bucle que tiene este aspecto

for(DateTime date = begin; date <= end; date = date.AddDays(1)) 
{ 
} 

Conjunto comenzar y terminar en consecuencia

Answer 2

DateTime dateTime = new DateTime(2009, 1, 1);  

while(dateTime.Year < 2010) 
    { 

     dateTime = dateTime.AddDays(1); 
    } 

Answer 3

definir dos variables:

DateTime lowValue = DateTime.Parse("1/1/2009"); 
DateTime highValue = DateTime.Parse("12/31/2009"); 

A continuación, añadir un día a la valor bajo hasta que sea igual a valor alto:

while (lowValue <= highValue) 
{ 
    //Do stuff here 
    lowValue = lowValue.AddDays(1); 
} 

O algo así.

Answer 4

DateTime current = DateTime.Parse("1/1/2009"); 
DateTime nextYear = current.AddYears(1); 
do 
{ 
    Console.WriteLine(current); 
    current = current.AddDays(1); 
} while (current < nextYear) ; 

Answer 5

int day; for (int i = 1; i<365;i++) { day++; }

Lo sentimos, no podían resistir.

Answer 6

que haría uso de MiscUtil y sus métodos de extensión:

foreach(DateTime date in 1.January(2009) 
         .To(31.December(2009)) 
         .Step(1.Days()) 
{ 
    Console.WriteLine(date); 
} 

Answer 7

Otra opción implementación del patrón de diseño iterador:

Esto puede parecer innecesario, pero dependiendo de cómo se utiliza esta funcionalidad , también puede implementar el Iterator design pattern.

Piense en esto. Supongamos que todo funciona bien, y copia/pega por todas partes la frase "para". Y de repente, como parte de los requisitos, debe repetir todos los días pero omita algunos de ellos (como en el calendario, saltear días festivos, fines de semana, personalizados, etc.)

Debería crear un nuevo "recorte" y usar Calendario en su lugar. Luego busca y reemplaza todos tus for's.

En OOP, esto se puede lograr utilizando el patrón iterador.

De Wikpedia:

En la programación orientada a objetos, el iterador es un patrón de diseño en que se utilizan los iteradores para acceder a los elementos de un objeto agregado secuencialmente sin exponer su representación subyacente. Un objeto Iterator encapsula la estructura interna de cómo se produce la iteración.

Así que la idea es utilizar una construcción como esta:

 DateTime fromDate = DateTime.Parse("1/1/2009"); 
     DateTime toDate = DateTime.Parse("12/31/2009"); 

     // Create an instance of the collection class 
     DateTimeEnumerator dateTimeRange = 
           new DateTimeEnumerator(fromDate, toDate); 


     // Iterate with foreach 
     foreach (DateTime day in dateTimeRange) 
     { 
      System.Console.Write(day + " "); 
     } 

Y luego, si es necesario se puede crear subclases de implementar algoritmos diferentes, uno que utiliza AddDay (1), otra que utiliza AddDay (7) u otro que simplemente usa Calendar en su lugar. Etcétera etcétera.

La idea es reducir el acoplamiento entre los objetos.

Una vez más, esto sería excesivo para la mayoría de los casos, pero si las formas de iteración un relevante parte de un sistema (digamos, que está creando una especie de lo que sea la notificación, para una empresa, y debe adherirse a diferentes globalizaciones

la implementación básica, por supuesto, sería utilizar el período de.

public class DateTimeEnumerator : System.Collections.IEnumerable 
{ 
    private DateTime begin; 
    private DateTime end; 

    public DateTimeEnumerator (DateTime begin , DateTime end) 
    { 
     // probably create a defensive copy here... 
     this.begin = begin; 
     this.end = end; 
    } 
    public System.Collections.IEnumerator GetEnumerator() 
    { 
     for(DateTime date = begin; date < end; date = date.AddDays(1)) 
     { 
      yield return date; 
     } 
    } 
} 

Sólo una idea :)

Answer 8

un método alternativo que podría ser más reutilizable es w rite un método de extensión en DateTime y devuelva un IEnumerable.

Por ejemplo, puede definir una clase:

public static class MyExtensions 
{ 
    public static IEnumerable EachDay(this DateTime start, DateTime end) 
    { 
     // Remove time info from start date (we only care about day). 
     DateTime currentDay = new DateTime(start.Year, start.Month, start.Day); 
     while (currentDay <= end) 
     { 
      yield return currentDay; 
      currentDay = currentDay.AddDays(1); 
     } 
    } 
} 

Ahora en el código de llamada se puede hacer lo siguiente:

DateTime start = DateTime.Now; 
DateTime end = start.AddDays(20); 
foreach (var day in start.EachDay(end)) 
{ 
    ... 
} 

Otra ventaja de este enfoque es que hace que sea trivial agregue EachWeek, EachMonth etc. A continuación, todos estarán accesibles en DateTime.