Заполнение и отправка структуры данных

    public sealed class MidiOutWrapper : IDisposable
    {
        #region ~ PInvoke ~
 
        private const uint MOM_OPEN = 0x3C7;
        private const uint MOM_CLOSE = 0x3C8;
        private const uint MOM_DONE  = 0x3C9;
 
        private const uint CALLBACK_FUNCTION = 0x00030000;
        private const uint MMSYSERR_NOERROR = 0;
        private const string Winmm = "winmm.dll";
 
        [StructLayout( LayoutKind.Sequential )]
        struct MIDIHDR
        {
            public IntPtr   lpData;
            public int      dwBufferLength;
            public int      dwBytesRecorded;
            public IntPtr   dwUser;
            public uint     dwFlags;
            private IntPtr  lpNext;
            private IntPtr  reserved;
            public int      dwOffset;
            private IntPtr  dwReserved0;
            private IntPtr  dwReserved1;
            private IntPtr  dwReserved2;
            private IntPtr  dwReserved3;
        }
 
        [DllImport( Winmm, SetLastError = true, ExactSpelling = true )]
        private static extern uint midiOutPrepareHeader (
            IntPtr hmo,
            ref MIDIHDR lpMidiOutHdr,
            int cbMidiOutHdr
            );
 
        [UnmanagedFunctionPointer( CallingConvention.StdCall )]
        private delegate void MidiOutProc (
            IntPtr hmo,
            uint wMsg,
            IntPtr dwInstance,
            IntPtr dwParam1,
            IntPtr dwParam2
            );
 
        [DllImport( Winmm, SetLastError = true, ExactSpelling = true )]
        private static extern uint midiOutOpen (
            out IntPtr lphmo,
            uint uDeviceID,
            MidiOutProc dwCallback,
            IntPtr dwCallbackInstance,
            uint dwFlags
            );
 
        [DllImport( Winmm, SetLastError = true, ExactSpelling = true )]
        private static extern uint midiOutClose (
            IntPtr hmo
            );
 
        [DllImport( Winmm, SetLastError = true, ExactSpelling = true )]
        private static extern uint midiOutLongMsg (
            IntPtr hmo,
            ref MIDIHDR lpMidiOutHdr,
            int cbMidiOutHdr
            );
 
        [DllImport( Winmm, SetLastError = true, ExactSpelling = true )]
        private static extern uint midiOutUnprepareHeader (
            IntPtr hmo,
            ref MIDIHDR lpMidiOutHdr,
            int cbMidiOutHdr
            );
 
        [DllImport( Winmm, SetLastError = true, ExactSpelling = true )]
        private static extern uint midiOutGetNumDevs ( );
 
        #endregion
 
        #region ~ Static ~
 
        public static uint DeviceCount
        {
            get { return midiOutGetNumDevs(); }
        }
 
        #endregion
 
        #region ~ Fields ~
 
        private IntPtr hMidiOut;
        private MidiOutProc mMidiOutCallback;
        private readonly int SizeOfMidiHeader;
 
        #endregion
 
        #region ~ Constructor ~
 
        public MidiOutWrapper ( uint devID )
        {
            mMidiOutCallback = MidiCallback;
 
            uint retValue = midiOutOpen( out hMidiOut, devID, mMidiOutCallback, IntPtr.Zero, CALLBACK_FUNCTION );
            if ( MMSYSERR_NOERROR != retValue )
                throw new Win32Exception( (int)retValue, "midiOutOpen failed!" );
 
            SizeOfMidiHeader = Marshal.SizeOf( typeof( MIDIHDR ) );
        }
 
        #endregion
 
        public void SendLongMessage ( byte[] buffer )
        {
            if ( buffer == null || buffer.Length == 0 )
                throw new Exception( "Invalid buffer data!" );
 
            uint retValue;
            var hdr = new MIDIHDR();
 
            hdr.lpData = Marshal.AllocHGlobal( buffer.Length );
            Marshal.Copy( buffer, 0, hdr.lpData, buffer.Length );
            hdr.dwBufferLength = hdr.dwBytesRecorded = buffer.Length;
 
            PrepareHeader( ref hdr );
 
            retValue = midiOutLongMsg( hMidiOut, ref hdr, SizeOfMidiHeader );
            UnprepareHeader( ref hdr );
            Marshal.FreeHGlobal( hdr.lpData );
 
            if ( MMSYSERR_NOERROR != retValue )
                throw new Win32Exception( (int)retValue, "midiOutLongMsg failed!" );
        }
 
        void PrepareHeader ( ref MIDIHDR hdr )
        {
            uint retValue = midiOutPrepareHeader( hMidiOut, ref hdr, SizeOfMidiHeader );
            if ( MMSYSERR_NOERROR != retValue )
                throw new Win32Exception( (int)retValue, "midiOutPrepareHeader failed!" );
        }
 
        void UnprepareHeader ( ref MIDIHDR hdr )
        {
            uint retValue = midiOutUnprepareHeader( hMidiOut, ref hdr, SizeOfMidiHeader );
            if ( MMSYSERR_NOERROR != retValue )
                throw new Win32Exception( (int)retValue, "midiOutUnprepareHeader failed!" );
        }
 
        private void MidiCallback ( IntPtr hmo, uint wMsg, IntPtr dwInstance, IntPtr dwParam1, IntPtr dwParam2 )
        {
            switch ( wMsg )
            {
            case MOM_OPEN:
 
                break;
            case MOM_DONE:
 
                break;
            case MOM_CLOSE:
 
                break;
            }
        }
 
        public void Dispose ( )
        {
            if ( hMidiOut != IntPtr.Zero )
            {
                if ( MMSYSERR_NOERROR == midiOutClose( hMidiOut ) )
                {
                    mMidiOutCallback = null;
                    hMidiOut = IntPtr.Zero;
                }
            }
        }
    }