score:1

Accepted answer

You can use Linq to transform both data sources to the same type, and then combine them and sort them. Here I have some objects from a pretend database table T_Log which has a Timestamp field and some other fields, and another source is some strings from a fake file where each string contains a timestamp at the start of the line. I transformed them both to a custom class CommonLog and then used this to sort. The CommonLog contains a reference to the original objects so if I need more detailed information I can cast and get that information.

A more lightweight implementation could convert to a class that already exists, such as KeyValuePair<DateTime, object>.

Here's the code:

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{    
    // Fake database class.
    class T_Log
    {
        public DateTime Timestamp { get; set; }
        public string Info { get; set; }
        public int Priority { get; set; }
    }

    static void Main(string[] args)
    {
        // Create some events in the fake database.
        List<T_Log> dbLogs = new List<T_Log> {
            new T_Log { Timestamp = new DateTime(2009, 2, 5), Info = "db: foo", Priority = 1 },
            new T_Log { Timestamp = new DateTime(2009, 2, 9), Info = "db: bar", Priority = 2 }
        };

        // Create some lines in a fake file.
        List<string> fileLogs = new List<string> {
            "2009-02-06: File foo",
            "2009-02-10: File bar"
        };


        var logFromDb =
            dbLogs.Select(x => new CommonLog(
                          x.Timestamp,
                          string.Format("{1} [Priority={2}]",
                                        x.Timestamp,
                                        x.Info,
                                        x.Priority),
                          x));

        var logFromFile =
            fileLogs.Select(x => new CommonLog(
                            DateTime.Parse(x.Substring(0, x.IndexOf(':'))),
                            x.Substring(x.IndexOf(':') + 2),
                            x
                ));

        var combinedLog = logFromDb.Concat(logFromFile).OrderBy(x => x.Timestamp);
        foreach (var logEntry in combinedLog)
            Console.WriteLine("{0}: {1}", logEntry.Timestamp, logEntry.Log);
    }
}

// This class is used to store logs from any source.
class CommonLog
{
    public CommonLog(DateTime timestamp,
                     string log,
                     object original)
    {
        this.Timestamp = timestamp;
        this.Log = log;
        this.Original = original;
    }

    public DateTime Timestamp { get; private set; }
    public string Log { get; private set; }
    public object Original { get; private set; }
}

Output:

05-02-2009 00:00:00: db: foo [Priority=0]
06-02-2009 00:00:00: file: baz
09-02-2009 00:00:00: db: bar [Priority=0]
10-02-2009 00:00:00: file: quux

Update: Martin replied the following in a comment to this post, but it was hard to read due to lack of formatting in comments. Here it is with formatting:

var ld = rs.Select(x => new KeyValuePair<DateTime, object>(DateTime.Parse(x[0]), x))
           .Concat(ta.Select(y => new KeyValuePair<DateTime, object>(y.Tidspunkt, y)))
           .OrderBy(d => d.Key); 

score:1

i think the code below should achieve what your looking for.

basically you just need to create a list of objects and then add your lists of db & file logs to that list. once that's done you can write a delegate to handle the sorting

    List<Db> db_inserts = new List<Db>();
    // populate list of db events here

    List<Fi> files = new List<Fi>();
    // populate list of file events here

    List<object> all = new List<object>();
    all.AddRange(db_inserts.Cast<object>());
    all.AddRange(files.Cast<object>());

    // sort the list by time
    all.Sort(delegate(object a, object b)
    {
        DateTime aTime = DateTime.MinValue;
        DateTime bTime = DateTime.MinValue;

        if (a is Db)
            aTime = ((Db)a).time;
        else if (a is Fi)
            aTime = ((Fi)a).time;

        if (b is Db)
            bTime = ((Db)b).time;
        else if (b is Fi)
            bTime = ((Fi)b).time;

        return aTime.CompareTo(bTime);
    });

EDIT: The code above could be improved using the code below (assume LogItem is a container class like in @Mark Byers reply:

    List<LogItem> all = new List<LogItem>();
    all.AddRange(db_inserts.Select(x => new LogItem { time = x.time, msg = x.name, source=x}));
    all.AddRange(files.Select(x => new LogItem{time = x.time, msg = x.name, source = x}));

    var query = all.OrderBy(x => x.time);

score:1

Concatenate the log sources, then sort the results. Assuming each log source is an IEnumerable<LogEntry> :

var logSources = new []
{
    GetFileLogs(),
    GetDbLogs()
    // whatever other sources you need...
};

var entries = Enumerable.Empty<LogEntry>();
foreach (var source in logSources)
{
    entries = entries.Concat(source);
}

entries = entries.OrderBy(e => e.Timestamp);

Related Articles