¿Alguien puede simplificar este algoritmo para mí?

Question

Básicamente solo quiero comprobar si un período de tiempo se solapa con otro. Fecha de finalización nula significa hasta el infinito. ¿Alguien puede acortar esto para mí, ya que es bastante difícil de leer a veces. Saludos

public class TimePeriod 
    { 
     public DateTime StartDate { get; set; } 
     public DateTime? EndDate { get; set; } 

     public bool Overlaps(TimePeriod other) 
     { 
      // Means it overlaps 
      if (other.StartDate == this.StartDate 
       || other.EndDate == this.StartDate 
       || other.StartDate == this.EndDate 
       || other.EndDate == this.EndDate) 
       return true; 

      if(this.StartDate > other.StartDate) 
      { 
       // Negative 
       if (this.EndDate.HasValue) 
       { 
        if (this.EndDate.Value < other.StartDate) 
         return true; 
        if (other.EndDate.HasValue && this.EndDate.Value < other.EndDate.Value) 
         return true; 
       } 

       // Negative 
       if (other.EndDate.HasValue) 
       { 
        if (other.EndDate.Value > this.StartDate) 
         return true; 
        if (this.EndDate.HasValue && other.EndDate.Value > this.EndDate.Value) 
         return true; 
       } 
       else 
        return true; 
      } 
      else if(this.StartDate < other.StartDate) 
      { 
       // Negative 
       if (this.EndDate.HasValue) 
       { 
        if (this.EndDate.Value > other.StartDate) 
         return true; 
        if (other.EndDate.HasValue && this.EndDate.Value > other.EndDate.Value) 
         return true; 
       } 
       else 
        return true; 

       // Negative 
       if (other.EndDate.HasValue) 
       { 
        if (other.EndDate.Value < this.StartDate) 
         return true; 
        if (this.EndDate.HasValue && other.EndDate.Value < this.EndDate.Value) 
         return true; 
       } 
      } 

      return false; 
     } 
    } 

Answer 1

public bool Overlaps(TimePeriod other) 
{ 
    return (other.StartDate >= StartDate && 
       (EndDate == null || other.StartDate <= EndDate.Value)) || 
      (StartDate >= other.StartDate && 
       (other.EndDate == null || StartDate <= other.EndDate.Value)) 
} 

Answer 2

mira esto: DateTimeOverlaps

De manera muy general, si todas las variables son datetimes anulables, a continuación,

return (StartA.HasValue? StartA.Value:DateTime.Minimum) <= 
      (EndB.HasValue? EndB.Value:DateTime.Maximum) && 
      (EndA.HasValue? EndA.Value:DateTime.Maximum) >= 
       (StartB.HasValue? StartB.Value:DateTime.Minimum); 

El concepto, (como se explica en el enlace) es muy simple, y es simplemente y concisamente expresado arriba.

Si el inicio es anterior al final de los otros, y el final es posterior al otro comienzo, tiene superposición. Esto lo dice todo, y todo lo que es necesario, en una oración simple con dos cláusulas, y cualquiera que sea el código que se escriba, se debe mapear concisamente a ese concepto simple sin ofuscarlo. Agregar complejidad extra innecesaria no agrega comprensión, solo agrega longitud.

Falla Caso 1: TopStart DESPUÉS otro extremo - no se aprueba

 |----------| 
|--| 

Falla Caso 2: topend pos de inicio - fallan

|-----------| 
        |------| 

En todos los demás casos, de inicio es anterior otro extremo, y el final es después de otro inicio.

caso A

|----------| 
|-----| 

caso B

| ---------| 
|-------------------| 

caso C

|-----------| 
    |------| 

caso D

|-----------| 
     |-------------| 

Answer 3

¿Qué tal este:

public bool Overlaps(TimePeriod other) 
{ 
    bool isOtherEarlier = this.StartDate > other.StartDate; 
    TimePeriod earlier = isOtherEarlier ? other : this; 
    TimePeriod later = isOtherEarlier ? this : other; 
    return !earlier.EndDate.HasValue || earlier.EndDate > later.StartDate; 
} 

Answer 4

Cada vez que usted está tratando con pura lógica booleana, se puede destilar el algoritmo a una sola declaración. Pero no supongas que solo porque puedes, deberías. A menos que el rendimiento sea vital, siempre opte por código legible sobre código compacto. (No es que compacidad == rendimiento, necesariamente)

Esto es fácil de leer porque está compuesto en su totalidad de una sola y expresiones, y es obvio que todos ellos determinan un no-solapamiento:

public bool Overlaps(TimePeriod other) 
{ 
    if (other.EndDate.HasValue && other.EndDate < StartDate) 
     return false; 

    if (EndDate.HasValue && EndDate < other.StartDate) 
     return false; 

    if (!EndDate.HasValue && other.EndDate < StartDate) 
     return false; 

    if (!other.EndDate.HasValue && EndDate < other.StartDate) 
     return false; 

    return true; 
} 

No

que la otras respuestas son malas (me gusta la de Adam, su formato obviamente está diseñado para ayudar a la legibilidad). Solo digo esto porque está claro que eres un principiante y creo que esta es una lección que no se tiene en cuenta lo suficiente (soy culpable).Alguien (creo que Martin Fowler) dijo una vez algo como: "Cualquier tonto puede escribir código que una computadora entienda, pero un buen programador puede escribir código que un humano entienda".