LINQ agrégé et groupé par périodes de temps

vous avez besoin d'une fonction qui fait le tour de vos horodateurs . Quelque chose comme:

 var grouped = from s in series
          group s by new DateTime(s.timestamp.Year, s.timestamp.Month,  
                s.timestamp.Day, s.timestamp.Hour, 0, 0) into g
          select new { timestamp = g.Key, value = g.Average(s => s.value };

pour les boîtes horaires. Et notez que l'horodatage dans le résultat sera désormais une DateTime, pas une durée.

je suis très en retard pour le jeu sur ce point, mais j'ai trouvé ceci en cherchant autre chose, et je pensais que j'avais une meilleure façon.

series.GroupBy (s => s.timestamp.Ticks / TimeSpan.FromHours(1).Ticks)
        .Select (s => new {
            series = s
            ,timestamp = s.First ().timestamp
            ,average = s.Average (x => x.value )
        }).Dump();

voici un exemple de programme linqpad pour que vous puissiez valider et tester ""

void Main()
{
    List<Sample> series = new List<Sample>();

    Random random = new Random(DateTime.Now.Millisecond);
    for (DateTime i = DateTime.Now.AddDays(-5); i < DateTime.Now; i += TimeSpan.FromMinutes(1))
    {
        series.Add(new UserQuery.Sample(){ timestamp = i, value = random.NextDouble() * 100 });
    }
    //series.Dump();
    series.GroupBy (s => s.timestamp.Ticks / TimeSpan.FromHours(1).Ticks)
        .Select (s => new {
            series = s
            ,timestamp = s.First ().timestamp
            ,average = s.Average (x => x.value )
        }).Dump();
}

// Define other methods and classes here
public class Sample
{
     public DateTime timestamp;
     public double value;
}

pour grouper par heure vous avez besoin de grouper par heure partie de votre timestamp qui pourrait être fait ainsi:

var groups = from s in series
  let groupKey = new DateTime(s.timestamp.Year, s.timestamp.Month, s.timestamp.Day, s.timestamp.Hour, 0, 0)
  group s by groupKey into g select new
                                      {
                                        TimeStamp = g.Key,
                                        Value = g.Average(a=>a.value)
                                      };

je suggère à l'aide de new DateTime() à éviter tout problèmes avec les sous de la milliseconde différences

var versionsGroupedByRoundedTimeAndAuthor = db.Versions.GroupBy(g => 
new
{
                UserID = g.Author.ID,
                Time = RoundUp(g.Timestamp, TimeSpan.FromMinutes(2))
});

avec

  private DateTime RoundUp(DateTime dt, TimeSpan d)
        {
            return new DateTime(((dt.Ticks + d.Ticks - 1) / d.Ticks) * d.Ticks);
        }

N.B. je suis ici groupant par auteur.ID ainsi que l'horodatage arrondi.

fonction RoundUp tirée de @dtb réponse ici https://stackoverflow.com/a/7029464/661584

lire à propos de l'égalité jusqu'à la milliseconde ne signifie pas toujours égalité ici pourquoi ce test de l'unité échoue-t-il lors des tests d'égalité DateTime?

même si je suis vraiment en retard, voici mes 2 cents:

je voulais Round() les valeurs de temps vers le bas ET jusqu'à 5 minutes d'intervalle:

10:31 --> 10:30
10:33 --> 10:35
10:36 --> 10:35

cela peut être réalisé en convertissant en Durée.Cochez et convertissez de nouveau à DateTime et en utilisant les mathématiques.Round ():

public DateTime GetShiftedTimeStamp(DateTime timeStamp, int minutes)
{
    return
        new DateTime(
            Convert.ToInt64(
                Math.Round(timeStamp.Ticks / (decimal)TimeSpan.FromMinutes(minutes).Ticks, 0, MidpointRounding.AwayFromZero)
                    * TimeSpan.FromMinutes(minutes).Ticks));
}

le shiftedTimeStamp peut être utilisé dans le groupe linq comme indiqué ci-dessus.

j'ai amélioré la réponse de BrokenGlass en la rendant plus générique et en y ajoutant des garanties. Avec sa réponse, si vous avez choisi un intervalle de 9, il ne fera pas ce que vous attendez. Il en va de même pour tout nombre 60 n'est pas divisible par. Pour cet exemple, j'utilise 9 et je commence à minuit (0:00).

• tout de 0: 00 à 0: 08.999 sera mis dans un groupe de 0:00 comme prévu. Il va continuer à faire cela jusqu'à ce que vous arrivez au groupement qui commence à 0 h 54.
• à 0: 54, Il ne groupera que les choses de 0:54 à 0:59.999 au lieu de monter à 01:03.999.

Pour moi, c'est un énorme problème.

Je ne sais pas comment réparer ça, mais vous pouvez ajouter des sauvegardes.

Modifications:

1. toute minute où 60 % [intervalle] est égal à 0 est un intervalle acceptable. Les énoncés ci-dessous relatifs à la fi le confirment.

2. les Heures de travail.

           double minIntervalAsDouble = Convert.ToDouble(minInterval);
           if (minIntervalAsDouble <= 0)
           {
               string message = "minInterval must be a positive number, exiting";
               Log.getInstance().Info(message);
               throw new Exception(message);
           }
           else if (minIntervalAsDouble < 60.0 && 60.0 % minIntervalAsDouble != 0)
           {
               string message = "60 must be divisible by minInterval...exiting";
               Log.getInstance().Info(message);
               throw new Exception(message);
           }
           else if (minIntervalAsDouble >= 60.0 && (24.0 % (minIntervalAsDouble / 60.0)) != 0 && (24.0 % (minIntervalAsDouble / 60.0) != 24.0))
           {
               //hour part must be divisible...
               string message = "If minInterval is greater than 60, 24 must be divisible by minInterval/60 (hour value)...exiting";
               Log.getInstance().Info(message);
               throw new Exception(message);
           }
           var groups = datas.GroupBy(x =>
           {
               if (minInterval < 60)
               {
                   var stamp = x.Created;
                   stamp = stamp.AddMinutes(-(stamp.Minute % minInterval));
                   stamp = stamp.AddMilliseconds(-stamp.Millisecond);
                   stamp = stamp.AddSeconds(-stamp.Second);
                   return stamp;
               }
               else
               {
                   var stamp = x.Created;
                   int hourValue = minInterval / 60;
                   stamp = stamp.AddHours(-(stamp.Hour % hourValue));
                   stamp = stamp.AddMilliseconds(-stamp.Millisecond);
                   stamp = stamp.AddSeconds(-stamp.Second);
                   stamp = stamp.AddMinutes(-stamp.Minute);
                   return stamp;
               }
           }).Select(o => new
           {
               o.Key,
               min = o.Min(f=>f.Created),
               max = o.Max(f=>f.Created),
               o
           }).ToList();
   

mettez tout ce que vous voulez dans la déclaration select! J'ai mis min/max parce que c'était plus facile de le tester.

je sais que cela ne répond pas directement à la question, mais je googlais autour de la recherche d'une solution très similaire aux données agrégées de bougie pour les actions / monnaies de crypto d'une période de minute plus petite à une période de minute plus élevée(5, 10, 15, 30). Vous ne pouvez pas simplement revenir de la minute actuelle en prenant X à la fois, car les horodateurs pour les périodes agrégées ne seront pas cohérents. Vous devez également veiller à ce qu'il y ait suffisamment de données au début et à la fin de la liste pour remplir une chandelier de la période plus grande. Cela étant, la solution que j'ai trouvée était la suivante. (Il suppose que les bougies pour la période plus courte, comme indiqué par rawPeriod, sont triées par estampille temporelle ascendante.)

public class Candle
{
    public long Id { get; set; }
    public Period Period { get; set; }
    public DateTime Timestamp { get; set; }
    public double High { get; set; }
    public double Low { get; set; }
    public double Open { get; set; }
    public double Close { get; set; }
    public double BuyVolume { get; set; }
    public double SellVolume { get; set; }
}

public enum Period
{
    Minute = 1,
    FiveMinutes = 5,
    QuarterOfAnHour = 15,
    HalfAnHour = 30
}

    private List<Candle> AggregateCandlesIntoRequestedTimePeriod(Period rawPeriod, Period requestedPeriod, List<Candle> candles)
    {
        if (rawPeriod != requestedPeriod)
        {
            int rawPeriodDivisor = (int) requestedPeriod;
            candles = candles
                        .GroupBy(g => new { TimeBoundary = new DateTime(g.Timestamp.Year, g.Timestamp.Month, g.Timestamp.Day, g.Timestamp.Hour, (g.Timestamp.Minute / rawPeriodDivisor) * rawPeriodDivisor , 0) })
                        .Where(g => g.Count() == rawPeriodDivisor )
                        .Select(s => new Candle
                        {
                            Period = requestedPeriod,
                            Timestamp = s.Key.TimeBoundary,
                            High = s.Max(z => z.High),
                            Low = s.Min(z => z.Low),
                            Open = s.First().Open,
                            Close = s.Last().Close,
                            BuyVolume = s.Sum(z => z.BuyVolume),
                            SellVolume = s.Sum(z => z.SellVolume),
                        })
                        .OrderBy(o => o.Timestamp)
                        .ToList();
        }

        return candles;
    }