Master/detail implementation for #23

[petersondrew]

This PR implements a solution for #23 and associated tests.

Please let me know if you'd like any changes to the API, it's pretty basic and I didn't give it a ton of thought.

[petersondrew]

Here's a usage example:

// Init multi record file engine
var engine =
    EngineFactory.GetEngine(
        new[]
        {
            typeof (SettlementHeaderRecord),
            typeof (TransactionRecord),
            typeof (TransactionDetailRecord),
            typeof (SettlementTrailerRecord)
        },
        s =>
        {
            if (String.IsNullOrEmpty(s) || s.Length < 1) return null;
            switch (s[0])
            {
                case 'H':
                    return typeof(SettlementHeaderRecord);
                case 'D':
                    return typeof(TransactionRecord);
                case 'P':
                    return typeof(TransactionDetailRecord);
                case 'V':
                    return typeof(SettlementTrailerRecord);
            }
            return null;
        });
// Read file
using (var stream = File.OpenRead(file))
    engine.Read(stream);

var transactions = engine.GetRecords<TransactionRecord>().ToList();

// Get detail records
foreach (var detailRecord in transaction.DetailRecords.OfType<TransactionDetailRecord>())
    detailRecord.TransactionId = transaction.Id;

It's not quite as abstracted as the engine is (e.g. engine.GetRecords<T>), but it leaves less to implement when implementing IMasterRecord if you just use the OfType<T> extension method when accessing the detail records to pull the type you'd like to work with (if you have multiple detail record types).

[forcewake]

@petersondrew, it looks good.
But I have several questions/suggestions:

• Could you please update the documentation as it will be lost after the merge
• I'm not sure that I'm OK with the engine's initialization code:

// Init multi record file engine
var engine =
    EngineFactory.GetEngine(
        new[]
        {
            typeof (SettlementHeaderRecord),
            typeof (TransactionRecord),
            typeof (TransactionDetailRecord),
            typeof (SettlementTrailerRecord)
        },
        s =>
        {
            if (String.IsNullOrEmpty(s) || s.Length < 1) return null;
            switch (s[0])
            {
                case 'H':
                    return typeof(SettlementHeaderRecord);
                case 'D':
                    return typeof(TransactionRecord);
                case 'P':
                    return typeof(TransactionDetailRecord);
                case 'V':
                    return typeof(SettlementTrailerRecord);
            }
            return null;
        });

Let's me explain why:

1. It's rather hard to read
2. It's rather hard to extend in future
3. When we will have a lot of engines we will have a lot of copy-paste code

I can merge you changes without any problems, but could you please spend some time on rethinking about the initialization (maybe some kind of the IEngineConfiguration or something else)?

Thank you for you great help.

Pavel.

[petersondrew]

Thanks for the feedback @forcewake . Just an FYI - the engine code initialization hasn't changed since it was created 😉

As for coming up with some sort of engine configuration class, I think that's a good idea. Also note that you can pass a named function rather than an anonymous one for better code re-use on the initialization.

For this PR though, nothing has changed with the API for the multi-record engine. Just the support for the IMasterRecord/IDetailRecord stuff. Any thoughts on that part in particular?

[forcewake]

Any thoughts on that part in particular?

Yes, I will create another issue. Good idea. 👍

Just an FYI - the engine code initialization hasn't changed since it was created

My fault 😢
Nevertheless, it will be cool if can spend some time on this small issue.

I will merge and close this PR

Thank you for help.