internal void SendEditor(ScintillaCommand cmd, int param1, byte[] param2)
        {
            // Initialize unmanged memory to hold the array.
            int size = Marshal.SizeOf(param2[0]) * param2.Length;

            IntPtr pnt = Marshal.AllocHGlobal(size);

            try
            {
                // Copy the array to unmanaged memory.
                Marshal.Copy(param2, 0, pnt, param2.Length);
                Win32Api.SendMessage(Handle, (uint)cmd, new IntPtr(param1), pnt);
            }
            finally
            {
                Marshal.FreeCoTaskMem(pnt);
            }
        }

Janus\ScintillaWrapper\ScintillaEditor\Control\ScintillaEditor.cs

       internal void SendEditor(ScintillaCommand cmd, int param1, byte[] param2)
        {
            IntPtr pnt = IntPtr.Zero;
            if (param2 != null && param2.Length > 0)
            {
                // Initialize unmanged memory to hold the array.
                int size = Marshal.SizeOf(param2[0]) * param2.Length;

                pnt = Marshal.AllocHGlobal(size);
            }

            try
            {
                if (pnt != IntPtr.Zero)
                {
                    // Copy the array to unmanaged memory.
                    Marshal.Copy(param2, 0, pnt, param2.Length);
                }
                Win32Api.SendMessage(Handle, (uint)cmd, new IntPtr(param1), pnt);
            }
            finally
            {
                if (pnt != IntPtr.Zero)
                {
                    Marshal.FreeCoTaskMem(pnt);
                }
            }
        }

Janus\Janus-Common\Utils\SpecialByteConverter.cs

   public static class SpecialByteConverter
    {
        public static string ToHexString(this byte[] array)
...

Janus\Rsdn\Janus.Rsdn\Synchronization\Tasks\PostMessagesSyncTask.cs

        protected override void ProcessResponse(
            ISyncContext context,
            PostRequest request,
            PostResponse response)
        {
            ClearOutbox(context, response.commitedIds);
            ClearRatesOutbox(context);

            context.StatisticsContainer.AddValue(JanusATInfo.OutboundMessagesStats, response.commitedIds.Length);
            context.StatisticsContainer.AddValue(JanusATInfo.FailedOutboundMessagesStats, response.exceptions.Length);
            context.StatisticsContainer.AddValue(JanusATInfo.OutboundRatesStats, request.rates.Length);

            Exception syncException = null;
            
            foreach (PostExceptionInfo ex in response.exceptions)
            {
                if (syncException == null)
                {
                    syncException = new SyncTroubleException();
                }

                SyncErrorInfo syncErrorInfo = new SyncErrorInfo(SyncErrorType.CriticalError, GetDisplayName(), ex.exception);
                syncException.Data.Add(syncErrorInfo, ex);
                context.TryAddSyncError(syncErrorInfo);
            }

            if (syncException != null)
            {
                throw syncException;
            }
        }
    }

Janus\Janus-Common\Synchronization\WebSvcSync\SimpleSyncTask.cs

        public void Sync(ISyncContext context, TSvc svc, int retries, ITaskIndicator indicator)
        {
...
            indicator.SetTaskState(SyncTaskState.Sync);
            try
            {
                context.CheckState();

                indicator.SetStatusText(SyncResources.IndicatorPrepareRequest);
                TRq rq = PrepareRequest(context);
                if (rq == null)
                {
                    return; // Nothing to do
                }

                context.CheckState();

                indicator.SetStatusText(SyncResources.IndicatorMakeRequest);

                Func<TRsp> requestMaker = delegate { return MakeRequest(context, svc, rq); };
                TRsp rsp = context.CallWithRetries(rq, GetDisplayName(), retries, requestMaker);

                context.CheckState();

                indicator.SetStatusText(SyncResources.IndicatorProcessResponse);
                SyncTaskState syncTaskState = SyncTaskState.Succeed;
                string finishText = SyncResources.IndicatorSuccessFinish;
                try
                {
                    ProcessResponse(context, rq, rsp);
                }
                catch (SyncTroubleException ex)
                {
                    syncTaskState = SyncTaskState.Failed;
                    finishText = SyncResources.IndicatorNotSuccessFinish;
                }

                context.CheckState();
                indicator.SetTaskState(syncTaskState);
                indicator.SetStatusText(finishText);
            }
            // Отмену пользователем не трактуем как ошибку и выкидываем наверх
            catch (UserCancelledException)
            {
                throw;
            }
            catch (Exception ex)
            {
...
            }
        }

Janus\Rsdn\Janus.Rsdn\Synchronization\Tasks\UsersSyncTask.cs

Janus\Janus-Common\Utils\SpecialByteConverter.cs

   public static class SpecialByteConverter
AN>     {
AN>         public static string ToHexString(this byte[] array)
AN> ...

       public static string ToHexString(this byte[] array)
        {
            if (array != null)
            {
                StringBuilder sb = new StringBuilder(array.Length * 2);
                foreach (byte b in array)
                {
                    sb.AppendFormat(CultureInfo.InvariantCulture, "{0:X2}", b);
                }

                return sb.ToString();
            }

            return string.Empty;
        }

(userRequest.maxOutput > 0 && userRequest.maxOutput < 1000) ? userRequest.maxOutput : 1000

       private static Control GetControlFromHandle(IntPtr handle)
        {
            if (handle == IntPtr.Zero)
            {
                return null;
            }

            return Control.FromHandle(handle) != null
                       ? Control.FromHandle(handle)
                       : GetControlFromHandle(GetParent(handle));
        }