ISO20022.Parser 1.2.0

ISO 20022 Parsing .Net 8 Library

ISO20022.Parser is a .NET 8 library designed to parse ISO 20022 messages in the fastest way possible using predefined rule sets.

NOTE: MXParser has been deprecated. Please switch to ISO20022.Parser.

Features

• Parse ISO 20022 XML messages with pre-defined rules.
  • Rules can be in JSON structure or database structure.
• High performance: Parses large XML files efficiently.

Performance Note

The library can parse a 60.6MB XML data file containing 129,769 <Ntry> records , in 6 seconds on a machine with 4 cores, 8 logical processors, and 16GB of RAM.

Installation

Install the ISO20022.Parser NuGet package:

.NET CLI

dotnet add package ISO20022.Parser

Package Manager

Install-Package ISO20022.Parser

Features in Detail

Parsing ISO 20022 Messages

Here is an example of how to use the library to parse ISO 20022 messages:

using System.Data;
using System.Diagnostics;
using ISO20022.Parser;

public class Program
{
    private static async Task Main(string[] args)
    {
        Stopwatch stopwatch = new();
        stopwatch.Start();
        IParsingService parsingService = new ParsingService(new ParsingJsonRules(@"data\parsing_rules.json"), "Document");
        await parsingService.ParseXmlAsync(@"data\camt.053.xml", (DataSet ds, Guid messageUniqueId, Guid uniquiId) =>
        {
            Task task = Task.Run(() =>
            {
                string dateTime = DateTime.Now.ToString("ddmmyyyyHHmmssfff");
                foreach (DataTable dt in ds.Tables)
                {
                    ExportDataTableToCsv(dt, @$"export\{dt.TableName}_{uniquiId}.csv");
                }
            });
            return task;
        });
        stopwatch.Stop();
        TimeSpan elapsedTime = stopwatch.Elapsed;

        Console.WriteLine("Elapsed Time: " + elapsedTime);
        Console.Read();
    }

    static void ExportDataTableToCsv(DataTable dataTable, string filePath)
    {
        if (!File.Exists(filePath))
        {
            File.Create(filePath).Close();
        }
        using (StreamWriter writer = new StreamWriter(filePath))
        {
            foreach (DataColumn column in dataTable.Columns)
            {
                writer.Write(column.ColumnName);
                writer.Write(",");
            }
            writer.WriteLine();

            foreach (DataRow row in dataTable.Rows)
            {
                foreach (object item in row.ItemArray)
                {
                    writer.Write(item);
                    writer.Write(",");
                }
                writer.WriteLine();
            }
        }
    }
}

Parsing Rules

Follow the parsing rules example provided in the data directory of the repository.
Mapping rules should follow the below model class structure:

public class MappingRules
{
    public string Namespace { get; set; }
    public List<MappingTable> Mappings { get; set; }
}

public class MappingTable
{
    public string NodeName { get; set; }
    public string XPath { get; set; }
    public IList<MappingColumn> Columns { get; set; }
}

public class MappingColumn
{
    public int OrderNumber { get; set; }
    public string NodeName { get; set; }
    public string XPath { get; set; }
    public string DataType { get; set; }
    public int MinLength { get; set; }
    public int MaxLength { get; set; }
    public int fractionDigits { get; set; }
    public int totalDigits { get; set; }
}

Overriding Parsing Rules

If you want to store parsing rules in a database, override the DeserializeRules method in the ParsingRules class.
For example:

public class ParsingDatabaseRules : ParsingRules
{
    public override void DeserializeRules()
    {
        MapParsingRules = GetMyRulesFromDB();
    }
}

Sample Files

XML file with 129,769 <Ntry/> entries. 60 Mb of file.

• camt.053.xml
• parsing_rules.json

License

This project is licensed under the Apache License.