AX 2012: Reading files from directory through X++

Following code can be used to read files from the specified path. With this example, I am reading a CSV files from a directory.

Class declaration

class readFilesFromDirectory extends RunBase





{



    FilePath            filePath;


    Filename            filename;

    CommaTextIo         fileIO;



    Set                 fileSet;

    CommaIo             commaIo;

    str                 currentFile;



    container           lineCon;



    #File

    #AviFiles



}

main method

Public static
void main(Args _args)





{



    readFilesFromDirectory  readFiles =
readFilesFromDirectory::construct();




    readFiles.readFilesFromDirtecory();
}

Construct

Public static
readFilesFromDirectory construct()





{



    return
new readFilesFromDirectory();

}

readFileFromDirectory method

private void
readFilesFromDirtecory()





{



    SetEnumerator           sE;


    int                     row = 1;



    filePath = @"C:\Temp\FilesToRead";



    this.getFiles();



    sE = fileSet.getEnumerator();



    while
(sE.moveNext()) // loop through all files

    {

        filename = sE.current();



        this.openFile();



        while(this.readLine())
// loop through all lines from current file

        {

            this.processRow(row, lineCon);



            row++;

        }

    }

}

getFiles method

private void
getFiles()

{

    System.String[]                 files;

    System.Collections.IEnumerator  enumerator;

    str
file;




    try

    {

        fileSet = new
Set(Types::Container);




        files =
System.IO.Directory::GetFiles(filePath, '*.csv');

        enumerator = files.GetEnumerator();




        while
(enumerator.MoveNext())

        {

            file = enumerator.get_Current();




            fileSet.add([file]);

        }




    }

    catch
(Exception::Internal)

    {

        this.processCLRErrorException();

    }

    catch
(Exception::CLRError)

    {

        this.processCLRErrorException();

    }
}

openFile method

private void
openFile()





{



    FileIOPermission fileIOPermission;




    fileIOPermission = new FileIOPermission(filename, #io_read);

    fileIOPermission.assert();



    commaIo = new
CommaIo(filename, #io_read);

    if
(commaIo && commaIo.status() == IO_Status::Ok)

    {

       
commaIo.inRecordDelimiter(#delimiterCRLF);

    }

    else

    {

        throw
error(strFmt("Error when opening file %1", filename));

    }
}

readLine method

private boolean
readLine()





{



    boolean
readLine;




    if
(commaIo && commaIo.status() == IO_Status::Ok)

    {

        lineCon = commaIo.read();

        readLine = lineCon != conNull();

    }

    else

    {

        lineCon = conNull();

        readLine = false;

    }



    return
readLine;

}

processRow method

private void
processRow(int _rowIdx, container 
_row)





{



    //conpeek(_row,
1);


    //conpeek(_row,
2);

    //conpeek(_row,
3);

    //conpeek(_row,
4);

    //conpeek(_row,
5);

    //conpeek(_row,
6);

    //conpeek(_row,
7);

    //conpeek(_row,
8);

    //conpeek(_row,
9);

    //conpeek(_row,
10);

}

processCLRErrorException method

private void
processCLRErrorException(

    boolean
_throw = true

    )

{

    str
strError;

    CLRObject exc;

    CLRObject innerExc;

    CLRObject clrExcMessage;



    exc = CLRInterop::getLastException();

    if
(exc)

    {

        clrExcMessage = exc.get_Message();

        innerExc = exc.get_InnerException();



        while
(innerExc != null)

        {

            clrExcMessage =
innerExc.get_Message();

            innerExc =
innerExc.get_InnerException();

        }



        strError =
CLRInterop::getAnyTypeForObject(clrExcMessage);



        error(strError);



        if (_throw)

        {

            throw
error("Update has been cancelled");

        }

    }

}