.NET wrapper about blingfire HOT 3 CLOSED

namespace MyNamespace
{
    public static class BlingFireUtils
    {
        public static IEnumerable<string> GetSentences(string paragraph)
        {
            // use Bling Fire TOK for sentence breaking
            byte[] paraBytes = Encoding.UTF8.GetBytes(paragraph);
            int MaxLength = (2 * paraBytes.Length) + 1;
            byte[] outputBytes = new byte[MaxLength];

            // native call returns '\n' delimited sentences, and adds 0 byte at the end
            Int32 actualLength = TextToSentences(paraBytes, (Int32)paraBytes.Length, outputBytes, MaxLength);
            if (0 < actualLength - 1 && actualLength <= MaxLength)
            {
                string sentencesStr = Encoding.UTF8.GetString(SubArray(outputBytes, 0, actualLength - 1));
                var sentences = sentencesStr.Split(_justNewLineChar, StringSplitOptions.RemoveEmptyEntries);
                foreach (var s in sentences)
                {
                    yield return s;
                }
            }
        }

        public static IEnumerable<Tuple<string, int, int>> GetSentencesWithOffsets(string paragraph)
        {
            // use Bling Fire TOK for sentence breaking
            return GetSentencesWithOffsets(Encoding.UTF8.GetBytes(paragraph));
        }

        public static IEnumerable<Tuple<string, int, int>> GetSentencesWithOffsets(byte[] paraBytes)
        {
            // use Bling Fire TOK for sentence breaking
            int MaxLength = (2 * paraBytes.Length) + 1;
            byte[] outputBytes = new byte[MaxLength];
            int[] startOffsets = new int[MaxLength];
            int[] endOffsets = new int[MaxLength];

            // native call returns '\n' delimited sentences, and adds 0 byte at the end
            Int32 actualLength = TextToSentencesWithOffsets(paraBytes, (Int32)paraBytes.Length, outputBytes, startOffsets, endOffsets, MaxLength);
            if (0 < actualLength - 1 && actualLength <= MaxLength)
            {
                string sentencesStr = Encoding.UTF8.GetString(SubArray(outputBytes, 0, actualLength - 1));
                var sentences = sentencesStr.Split(_justNewLineChar, StringSplitOptions.RemoveEmptyEntries);
                for (int i = 0; i < sentences.Length; ++i)
                {
                    yield return new Tuple<string, int, int>(sentences[i], startOffsets[i], endOffsets[i]);
                }
            }
        }


        public static IEnumerable<string> GetWords(string sentence)
        {
            // use Bling Fire TOK for sentence breaking
            byte[] paraBytes = Encoding.UTF8.GetBytes(sentence);
            int MaxLength = (2 * paraBytes.Length) + 1;
            byte[] outputBytes = new byte[MaxLength];

            // native call returns '\n' delimited sentences, and adds 0 byte at the end
            Int32 actualLength = TextToWords(paraBytes, (Int32)paraBytes.Length, outputBytes, MaxLength);
            if (0 < actualLength - 1 && actualLength <= MaxLength)
            {
                string wordsStr = Encoding.UTF8.GetString(SubArray(outputBytes, 0, actualLength - 1));
                var words = wordsStr.Split(_justSpaceChar, StringSplitOptions.RemoveEmptyEntries);
                foreach (var w in words)
                {
                    yield return w;
                }
            }
        }

        public static IEnumerable<Tuple<string, int, int>> GetWordsWithOffsets(string sentence)
        {
            // use Bling Fire TOK for sentence breaking
            byte[] paraBytes = Encoding.UTF8.GetBytes(sentence);
            int MaxLength = (2 * paraBytes.Length) + 1;
            byte[] outputBytes = new byte[MaxLength];
            int[] startOffsets = new int[MaxLength];
            int[] endOffsets = new int[MaxLength];

            // native call returns '\n' delimited sentences, and adds 0 byte at the end
            Int32 actualLength = TextToWordsWithOffsets(paraBytes, (Int32)paraBytes.Length, outputBytes, startOffsets, endOffsets, MaxLength);
            if (0 < actualLength - 1 && actualLength <= MaxLength)
            {
                string wordsStr = Encoding.UTF8.GetString(SubArray(outputBytes, 0, actualLength - 1));
                var words = wordsStr.Split(_justSpaceChar, StringSplitOptions.RemoveEmptyEntries);
                for (int i = 0; i < words.Length; ++i)
                {
                    yield return new Tuple<string, int, int>(words[i], startOffsets[i], endOffsets[i]);
                }
            }
        }

        public static T[] SubArray<T>(this T[] data, int index, int length)
        {
            T[] result = new T[length];
            Array.Copy(data, index, result, 0, length);
            return result;
        }

        //
        // expose Bling Fire interfaces
        //

        [DllImport("blingfiretokdll.dll")]
        private static extern Int32 TextToSentences([MarshalAs(UnmanagedType.LPArray)] byte[] InUtf8Str, Int32 InUtf8StrLen, byte[] OutBuff, Int32 MaxBuffSize);

        [DllImport("blingfiretokdll.dll")]
        private static extern Int32 TextToWords([MarshalAs(UnmanagedType.LPArray)] byte[] InUtf8Str, Int32 InUtf8StrLen, byte[] OutBuff, Int32 MaxBuffSize);

        [DllImport("blingfiretokdll.dll")]
        private static extern Int32 TextToSentencesWithOffsets([MarshalAs(UnmanagedType.LPArray)] byte[] InUtf8Str, Int32 InUtf8StrLen, byte[] OutBuff, int[] StartOffsets, int[] EndOffsets, Int32 MaxBuffSize);

        [DllImport("blingfiretokdll.dll")]
        private static extern Int32 TextToWordsWithOffsets([MarshalAs(UnmanagedType.LPArray)] byte[] InUtf8Str, Int32 InUtf8StrLen, byte[] OutBuff, int[] StartOffsets, int[] EndOffsets, Int32 MaxBuffSize);

        private static char[] _justNewLineChar = new char[] { '\n' };
        private static char[] _justSpaceChar = new char[] { ' ' };

    }
}