I got a chance to try your advise out.  I think I am doing something
wrong though.  I think it has something to do with the way I am
creating the process.
Here's my pipe class:
sealed class Pipe : IDisposable
   {
       [DllImport("kernel32.dll", SetLastError = true)]
       [return: MarshalAs(UnmanagedType.Bool)]
       private static extern bool CreatePipe(out SafeFileHandle
hReadPipe, out
           SafeFileHandle hWritePipe, [In] ref SECURITY_ATTRIBUTES
lpPipeAttributes, int nSize);

       private FileStream m_readStream;
       private FileStream m_writeStream;
       private ILog m_logg = LogManager.GetLogger(typeof(Pipe));

       public FileStream ReadStream
       {
           get
           {
               return m_readStream;
           }
       }

       public FileStream WriteStream
       {
           get
           {
               return m_writeStream;
           }
       }

       public Pipe(SECURITY_ATTRIBUTES se)
       {
           SafeFileHandle readHandle;
           SafeFileHandle writeHandle;
           if (!CreatePipe(out readHandle, out writeHandle, ref se,
0))
           {
               int errorNum = Marshal.GetLastWin32Error();
               m_logg.Error("****** Creation of pipe failed.  Error "
+ errorNum + " ******");
           }
           m_logg.Info("Successfully created pipe with read handle "
+ readHandle.DangerousGetHandle()
               + " and write handle " +
writeHandle.DangerousGetHandle());
           m_readStream = new FileStream(readHandle,
FileAccess.Read);
           m_writeStream = new FileStream(writeHandle,
FileAccess.Write);
       }

       #region IDisposable Members

       public void Dispose()
       {
           if (m_readStream != null)
           {
               m_readStream.Dispose();
           }
           if (m_writeStream != null)
           {
               m_writeStream.Dispose();
           }
       }

       #endregion
   }

Here I create the pipe:
private const uint CREATE_UNICODE_ENVIRONMENT = 0x00000400;
private const uint CREATE_NO_WINDOW = 0x08000000;
private const uint STARTF_USESTDHANDLES = 0x00000100;
SECURITY_ATTRIBUTES pipeOutSa = new SECURITY_ATTRIBUTES();
Pipe stdout;
pipeOutSa.nLength = (uint)Marshal.SizeOf(pipeOutSa);
pipeOutSa.bInheritHandle = true;
stdout = new Pipe(pipeOutSa);
FileStream m_outStream = stdout.ReadStream;

Here I start the process:
PROCESS_INFORMATION pi = new PROCESS_INFORMATION();
STARTUPINFO si = new STARTUPINFO();
SECURITY_ATTRIBUTES saP = new SECURITY_ATTRIBUTES();
SECURITY_ATTRIBUTES saT = new SECURITY_ATTRIBUTES();
IntPtr env = new IntPtr(0);
bool result = false;
uint creationFlags = CREATE_UNICODE_ENVIRONMENT | CREATE_NO_WINDOW;
si.cb = (uint)Marshal.SizeOf(si);
saP.nLength = (uint)Marshal.SizeOf(saP);
saT.nLength = (uint)Marshal.SizeOf(saT);
si.hStdInput = m_inStream.SafeFileHandle.DangerousGetHandle();
si.hStdOutput = m_outStream.SafeFileHandle.DangerousGetHandle();
si.hStdError = m_errStream.SafeFileHandle.DangerousGetHandle();
si.dwFlags = STARTF_USESTDHANDLES;
saP.bInheritHandle = true;
saT.bInheritHandle = true;

result = CreateProcessAsUser(token,
    null,
    fullProcessName,
    ref saP,
    ref saP,
    true,
    creationFlags,
    env,
    null,
    ref si,
    out pi);

I used this simple c++ program to test it out:
#include <iostream>
#include <string>

using namespace std;
int main()
{
    string hold = "";
    while(true)
    {
        cout << "I should be printing to stdout." << endl;
        std::getline(cin, hold);
        cout << "This is what you entered." << hold << endl;
        cerr << "Trying out what should be stderr." << endl;
    }
}
After the process is started, the test program uses up all of the
CPU.  When I try to use stdout.EndOfStream or stdout.Peek(), it just
stalls waiting for the test program to return.  Am I creating the
process wrong?  Am I passing the wrong flag or something?  I have
tried it with just CreateProcess and get the same thing.  I have also
tried it with different executables (like cmd.exe and powershell.exe)
and I get nothing from stdin, stdout, or stderr on those either.
Thanks for your time.