Error Calling C# dll from Java using JNI

See more:

C++

C#

Java

I want to call C# class from Managed C++ class
C# class calls another C# class and imports another C++ library.

I've got error, when creating object of C# class
CSharpHelloWorld __gc *t=new CSharpHelloWorld ();


Please help me :confused:

//Managed C++ Class
// HelloWorld.h

#pragma once
#using <mscorlib.dll>
#using "CSharpHelloWorld.netmodule"
#using "AbstractMessage.netmodule"
#include "stdio.h"
using namespace System;



public  __gc class HelloWorldC{

public:
	CSharpHelloWorld __gc *t;

	 HelloWorldC(){	
	t=new CSharpHelloWorld();
	}
	void callCSharpHelloWorld(){
	t->displayHelloWorld();	
	}};

C# class
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;

   public  class CSharpHelloWorld: AbstractMessage
   {
       #region variable     
       private byte[] _isoPackedData;
       private short _isoPackedSize;
       private Field003_ProcessingCode _pc;
    public     BalanceInquiry_t bli;

   
       #endregion   
  
       public  CSharpHelloWorld()
       {

           Console.WriteLine("Here is C# Code");
           // mti

           _mti = new Field000_MTI();

           // 
           //  _isoPackedData = new byte[993];
           _pc = new Field003_ProcessingCode("310000");
           //  _fields.Add(_pc);

           _tranAmount = new Field004_TransactionAmount();
           //  _fields.Add(_tranAmount);

           _cardHolderTransaction = new Field035_CardHolderTransactions();
           //  _fields.Add(_cardHolderTransaction);

           _pin = new Field053_PIN();
           //    _fields.Add(_pin);

           _addData = new Field054_AdditionalData();
           //   _fields.Add(_addData);


           //    this._packedData = new byte[1000];           
       }

     //  [DllImport(@"E:\gsp\projects\Working\Bank\MIT.ISO8583\Debug\MIT.ISO8583.dll", CharSet = CharSet.Ansi)]
        [DllImport("MIT.ISO8583.dll", CharSet = CharSet.Ansi)]
        /*
           DL_UINT8 * packedBuf,DL_UINT16 *packedBufSize, 
	DL_UINT8 * MTI,DL_UINT16 *MTISize, 
	DL_UINT8 * processCode,DL_UINT16 *processCodeSize, 
	
	DL_UINT8* tranAmount, DL_UINT16 * tranAmountSize,
	DL_UINT8* cardHolderTran, DL_UINT16 * cardHolderTranSize,
	DL_UINT8* Pin, DL_UINT16  *pinSize,
	DL_UINT8* addData, DL_UINT16 * addDataSize
*/
        public static extern unsafe int MTIX200_BalanceInquiryPack(
                      byte* packedBuf, short * packedBufSize,
                       RequestEnum isRequest,

                        byte* tranAmount,
                        byte* cardHolderTran,
                        byte* Pin, 
                        byte* addData
           
           );


    //  [DllImport(@"E:\gsp\projects\Working\Bank\MIT.ISO8583\Debug\MIT.ISO8583.dll")]
      [DllImport("MIT.ISO8583.dll")]
       //    public static extern unsafe int MTIX200_BalanceInquiryUnpack(byte* buf, short packedSize);
       public static extern unsafe int MTIX200_BalanceInquiryUnpack(
             byte* buf, short packedSize, BalanceInquiry_t * sptr,byte *additionalData
             ,byte* mti
             , byte* processCode
             );

         private Field000_MTI _mti;

         private Field003_ProcessingCode _processCode;
         
       private Field004_TransactionAmount _tranAmount;


       public String Field000_MTI
       {
        //   set{_mti.MTI = value;}
            get { return _mti.MTI;}
       }

       public String Field003_ProcessCode
       {
         //  set { _pc.ProcessCode = value; }
           get { return _pc.ProcessCode; }
       }
       public String Field004_TransactionAmount        
        {
         get { return _tranAmount.TransactionAmount;}

            
        set {_tranAmount.TransactionAmount = value;}
        }

       private Field035_CardHolderTransactions _cardHolderTransaction;

	public String  Field035_CardHolderTransactions 
	{
		get { return _cardHolderTransaction.CardHolderTransaction;}
		set { _cardHolderTransaction .CardHolderTransaction= value;}
	}
	

       private Field053_PIN  _pin;

	public String Field053_PIN  
	{
		get { return _pin.PIN;}
		set { _pin.PIN = value;}
	}

    public int PackFromCPP() {
        return Pack(RequestEnum.Response);   
   }
        public override int Pack(RequestEnum requestenum)
        {
         return    unsafePack( requestenum);
        }
        private Field054_AdditionalData _addData;

        //public Field054_AdditionalData AddtionalData
        //{
        //    get { return _addData; }
        //    set { _addData = value; }
        //}

       // field54 
        public String Field054_AdditionData_AccountType
        {
            get { return _addData.AccountType; }
            set { _addData.AccountType = value; }
        }
       // Amount Type
        public String Field054_AdditionData_AmountType
        {
            get { return _addData.AmountType; }
            set { _addData.AmountType = value; }
        }
        public String Field054_AdditionData_CurrencyCode
        {
            set { _addData.CurrencyCode = value; }
            get { return _addData.CurrencyCode; }
        }
       // sign code

        public Char Field054_AdditionData_SignCode
        {
            set { _addData.SignCode = value; }
            get { return _addData.SignCode; }
        }
        public long Field054_AdditionData_Amount
        {
            set { _addData.Amount = value; }
            get { return _addData.Amount; }
        }

        unsafe private int unsafeUnpack()
        {
            GeneralUtility.Instance.Copy(_packedData, _grgHeader._packedData, 0, _grgHeader._packedSize);

             byte []addData = new byte[120];
            if (this._isoPackedData == null)
            {
                this._isoPackedData = new byte[this._packedSize- this._grgHeader._packedSize];
                this._isoPackedSize =(short)( (int)this._packedSize - (int)this._grgHeader._packedSize);
            }
            GeneralUtility.Instance.Copy(_packedData, 7, _isoPackedData, 0, _packedSize-_grgHeader._packedSize);
         
            fixed (BalanceInquiry_t* ptr = &this.bli)
            {
                fixed (byte* bptr = this._isoPackedData, addDataPtr = addData, mtiptr = _mti._packedData , processCodePtr = _pc._packedData)
                {
                     MTIX200_BalanceInquiryUnpack(bptr, this._isoPackedSize, ptr,addDataPtr, mtiptr,processCodePtr);
                     unpackfields(ptr,addDataPtr);      
                }
            }
           
            return 0;
        }
       
        private unsafe void unpackfields(BalanceInquiry_t* ptr,byte* additionData)
        {

            // pti

            _mti.Unpack();

            // process code

            _pc.Unpack();

            // Tran Amount
            for (int i = 0; i < this._tranAmount._packedSize; i++)
            {
                this._tranAmount._packedData[i] = ptr->TranAmount.TransactionAmount[i];

            }
           
            this._tranAmount.Unpack();
            // Card holde tran

            for (short i = 0; i < this._cardHolderTransaction._packedSize ; i++)
            {
                this._cardHolderTransaction._packedData[i] = ptr->CardHolderTran.CardHolderTransaction[i];

            }
            this._cardHolderTransaction.Unpack();
            // Pin
            for (short i = 0; i < this._pin._packedSize; i++)
            {
                this._pin._packedData[i] = ptr->Pin.Pin[i];

            }
            _pin.PAN = this.Field035_CardHolderTransactions;
            this._pin.Unpack();
            // additinal data

            for (short i = 0; i < this._addData._packedSize ; i++)
            {

           //     this._addData._packedData[i] = ptr->AdditionalData.AdditionalData[i];
                     this._addData._packedData[i] = additionData[i];

            }
            this._addData.Unpack();
        }
        public int GRGSourceID
        {
            set { _grgHeader.SourceID = value; }
            get { return _grgHeader.SourceID; }
        }
        public int GRGDestinationID
        {
            set { _grgHeader.DestinationID = value; }
            get { return _grgHeader.DestinationID; }
        }
        public int GRGNAC
        {
            get { return _grgHeader.NAC; }
        }
        public int GRGSize
        {
            get { return _grgHeader.ISOPackedSize; }
        }
unsafe private int unsafePack(RequestEnum requestenum)

{
    int ret=0;

    if (_isoPackedData == null)
    {
        this._isoPackedData = new byte[1000];
    }

   // byte[] tr = this.CardHolderTransaction.packedData;
    this._cardHolderTransaction.Pack();

    this._pin.PAN = this.Field035_CardHolderTransactions;
    this._pin.Pack();
    this._addData.Pack();
    this._tranAmount.Pack();
    //for (int i = 0; i < 22; i++)
    //{
    //    this.AddtionalData._packedData[i] = 49;
    //}
      

    fixed (
        byte* packedBufPtr =  this._isoPackedData // this._packedData
            ,tranamtptr = this._tranAmount._packedData
            , tranptr = this._cardHolderTransaction._packedData
            , pinptr = this._pin._packedData
            , addptr = this._addData._packedData
        ){
 
            fixed(short* packedSizePtr = &_isoPackedSize)
                 {                      
                        MTIX200_BalanceInquiryPack(packedBufPtr, packedSizePtr, requestenum, tranamtptr, tranptr, pinptr, addptr);
                        this._grgHeader.ISOPackedSize  = _isoPackedSize;
                        this._grgHeader.Pack();
                        if (_packedData == null)
                        {
                            this._packedData = new byte[_isoPackedSize + _grgHeader._packedSize];
                            this._packedSize =(short)( (int)_isoPackedSize +(int) _grgHeader._packedSize);
                        }
                        GeneralUtility.Instance.Copy(this._grgHeader._packedData, this._packedData, 0, this._grgHeader._packedData.Length);
                        GeneralUtility.Instance.Copy(this._isoPackedData, this._packedData, 7, this._isoPackedSize);                        
                        return ret;        
                }
    }
   

 	//MTIX200_BalanceInquiryPack(
}

        public override int Unpack()
        {
        int ret=     unsafeUnpack();
      //  this.bli.TranAmounbt.TransactionAmount;
        _grgHeader.Unpack();        
        
        return 0;        }        
    }