using System;

using System.Collections.Generic;

using System.Text;

using System.Linq;

public class Program

{

    public static void Main()

    {

    }

}

​

public class GatewayCardEMVData

{

    private readonly int m_length;

    private readonly int m_valueOffset;

    private GatewayCardEMVData( int tag, int length, int valueOffset, byte[] rawData )

    {

        Tag = tag;

        m_length = length;

        m_valueOffset = valueOffset;

        RawData = rawData;

    }

    public int Tag { get; private set; }

    public byte[] RawData { get; private set; }

    public ICollection<GatewayCardEMVData> SubData { get; private set; } = new List<GatewayCardEMVData>();

    public byte[] Value

    {

        get

        {

            byte[] result = new byte[m_length];

            Array.Copy( RawData, m_valueOffset, result, 0, m_length );

            return result;

        }

    }

    public string HexTag

    {

        get { return Tag.ToString( "X" ); }

    }

    public string HexValue

    {

        get { return GetHexString( Value ); }

    }

    public static ICollection<GatewayCardEMVData> ParseTLV( string hexTlv )

    {

        if( string.IsNullOrWhiteSpace( hexTlv ) )

        {

            throw new ArgumentException( nameof( hexTlv ) );

        }

        return ParseTLV( GetBytes( hexTlv ) );

    }

    public static ICollection<GatewayCardEMVData> ParseTLV( byte[] rawTlv )

    {

        if( rawTlv == null || rawTlv.Length == 0 )

        {

            throw new ArgumentException( nameof( rawTlv ) );

        }

        var result = new List<GatewayCardEMVData>();

        ParseTlv( rawTlv, result );

        return result;

    }

    private static void ParseTlv( byte[] rawTlv, ICollection<GatewayCardEMVData> result )

    {

        for( int i = 0, start = 0; i < rawTlv.Length; start = i )

        {

            // parse Tag

            bool constructedTlv = ( rawTlv[i] & 0x20 ) != 0;

            bool moreBytes = ( rawTlv[i] & 0x1F ) == 0x1F;

            while( moreBytes && ( rawTlv[++i] & 0x80 ) != 0 ) ;

            i++;

            int tag = GetInt( rawTlv, start, i - start );

            // parse Length

            bool multiByteLength = ( rawTlv[i] & 0x80 ) != 0;

            int length = multiByteLength ? GetInt( rawTlv, i + 1, rawTlv[i] & 0x1F ) : rawTlv[i];

            i = multiByteLength ? i + ( rawTlv[i] & 0x1F ) + 1 : i + 1;

            i += length;

            byte[] rawData = new byte[i - start];

            Array.Copy( rawTlv, start, rawData, 0, i - start );

            var tlv = new GatewayCardEMVData( tag, length, rawData.Length - length, rawData );

            result.Add( tlv );

            if( constructedTlv )

            {

                ParseTlv( tlv.Value, tlv.SubData );

            }

        }

    }

    private static string GetHexString( byte[] arr )

    {

        var sb = new StringBuilder( arr.Length * 2 );

        foreach( byte b in arr )

        {

            sb.AppendFormat( "{0:X2}", b );

        }

        return sb.ToString();

    }

    private static byte[] GetBytes( string hexString )

    {

        return Enumerable.Range( 0, hexString.Length )

            .Where( x => x % 2 == 0 )

            .Select( x => Convert.ToByte( hexString.Substring( x, 2 ), 16 ) )

            .ToArray();

    }

    private static int GetInt( byte[] data, int offset, int length )

    {

        var result = 0;

        for( var i = 0; i < length; i++ )

        {

            result = ( result << 8 ) | data[offset + i];

        }

        return result;

    }

}