protected static void StartClient(PipeDirection direction, SafePipeHandle clientPipeHandle)
 {
     using (AnonymousPipeClientStream client = new AnonymousPipeClientStream(direction, clientPipeHandle))
     {
         DoStreamOperations(client);
     }
 }

        private void Create(PipeDirection direction, HandleInheritability inheritability, int bufferSize)
        {
            Debug.Assert(direction != PipeDirection.InOut, "Anonymous pipe direction shouldn't be InOut");
            // Ignore bufferSize.  It's optional, and the fcntl F_SETPIPE_SZ for changing it is Linux specific.

            // Use pipe or pipe2 to create our anonymous pipe
            int[] fds = new int[2];
            unsafe
            {
                fixed (int* fdsptr = fds)
                {
                    CreatePipe(inheritability, fdsptr);
                }
            }

            // Create SafePipeHandles for each end of the pipe.  Which ends goes with server and which goes with
            // client depends on the direction of the pipe.
            SafePipeHandle serverHandle = new SafePipeHandle(
                (IntPtr)fds[direction == PipeDirection.In ? Interop.libc.ReadEndOfPipe : Interop.libc.WriteEndOfPipe], 
                ownsHandle: true);
            SafePipeHandle clientHandle = new SafePipeHandle(
                (IntPtr)fds[direction == PipeDirection.In ? Interop.libc.WriteEndOfPipe : Interop.libc.ReadEndOfPipe], 
                ownsHandle: true);

            // We're connected.  Finish initialization using the newly created handles.
            InitializeHandle(serverHandle, isExposed: false, isAsync: false);
            _clientHandle = clientHandle;
            State = PipeState.Connected;
        }

 internal static extern bool GetNamedPipeInfo(
     SafePipeHandle hNamedPipe,
     IntPtr lpFlags,
     IntPtr lpOutBufferSize,
     out int lpInBufferSize,
     IntPtr lpMaxInstances
 );

        public AnonymousPipeServerStream(PipeDirection direction, SafePipeHandle serverSafePipeHandle, SafePipeHandle clientSafePipeHandle)
            : base(direction, 0)
        {
            if (direction == PipeDirection.InOut)
            {
                throw new NotSupportedException(SR.NotSupported_AnonymousPipeUnidirectional);
            }
            if (serverSafePipeHandle == null)
            {
                throw new ArgumentNullException("serverSafePipeHandle");
            }
            if (clientSafePipeHandle == null)
            {
                throw new ArgumentNullException("clientSafePipeHandle");
            }
            if (serverSafePipeHandle.IsInvalid)
            {
                throw new ArgumentException(SR.Argument_InvalidHandle, "serverSafePipeHandle");
            }
            if (clientSafePipeHandle.IsInvalid)
            {
                throw new ArgumentException(SR.Argument_InvalidHandle, "clientSafePipeHandle");
            }
            ValidateHandleIsPipe(serverSafePipeHandle);
            ValidateHandleIsPipe(clientSafePipeHandle);

            InitializeHandle(serverSafePipeHandle, true, false);

            _clientHandle = clientSafePipeHandle;
            _clientHandleExposed = true;
            State = PipeState.Connected;
        }

        public AnonymousPipeClientStream(PipeDirection direction, String pipeHandleAsString)
            : base(direction, 0)
        {
            if (direction == PipeDirection.InOut)
            {
                throw new NotSupportedException(SR.NotSupported_AnonymousPipeUnidirectional);
            }
            if (pipeHandleAsString == null)
            {
                throw new ArgumentNullException("pipeHandleAsString");
            }

            // Initialize SafePipeHandle from String and check if it's valid. First see if it's parseable
            long result = 0;
            bool parseable = long.TryParse(pipeHandleAsString, out result);
            if (!parseable)
            {
                throw new ArgumentException(SR.Argument_InvalidHandle, "pipeHandleAsString");
            }

            // next check whether the handle is invalid
            SafePipeHandle safePipeHandle = new SafePipeHandle((IntPtr)result, true);
            if (safePipeHandle.IsInvalid)
            {
                throw new ArgumentException(SR.Argument_InvalidHandle, "pipeHandleAsString");
            }

            Init(direction, safePipeHandle);
        }

 public AnonymousPipeServerStream(PipeDirection direction, SafePipeHandle serverSafePipeHandle, SafePipeHandle clientSafePipeHandle) : base(direction, 0)
 {
     if (direction == PipeDirection.InOut)
     {
         throw new NotSupportedException(System.SR.GetString("NotSupported_AnonymousPipeUnidirectional"));
     }
     if (serverSafePipeHandle == null)
     {
         throw new ArgumentNullException("serverSafePipeHandle");
     }
     if (clientSafePipeHandle == null)
     {
         throw new ArgumentNullException("clientSafePipeHandle");
     }
     if (serverSafePipeHandle.IsInvalid)
     {
         throw new ArgumentException(System.SR.GetString("Argument_InvalidHandle"), "serverSafePipeHandle");
     }
     if (clientSafePipeHandle.IsInvalid)
     {
         throw new ArgumentException(System.SR.GetString("Argument_InvalidHandle"), "clientSafePipeHandle");
     }
     if (Microsoft.Win32.UnsafeNativeMethods.GetFileType(serverSafePipeHandle) != 3)
     {
         throw new IOException(System.SR.GetString("IO_IO_InvalidPipeHandle"));
     }
     if (Microsoft.Win32.UnsafeNativeMethods.GetFileType(clientSafePipeHandle) != 3)
     {
         throw new IOException(System.SR.GetString("IO_IO_InvalidPipeHandle"));
     }
     base.InitializeHandle(serverSafePipeHandle, true, false);
     this.m_clientHandle = clientSafePipeHandle;
     this.m_clientHandleExposed = true;
     base.State = PipeState.Connected;
 }

 internal static extern bool GetNamedPipeHandleState(
     SafePipeHandle hNamedPipe,
     IntPtr lpState,
     out int lpCurInstances,
     IntPtr lpMaxCollectionCount,
     IntPtr lpCollectDataTimeout,
     IntPtr lpUserName,
     int nMaxUserNameSize);

 internal void InitializeBufferSize(SafePipeHandle handle, int bufferSize)
 {
     if (bufferSize > 0)
     {
         SysCall(handle, (fd, _, size) => Interop.libc.fcntl(fd, Interop.libc.FcntlCommands.F_SETPIPE_SZ, size), 
             IntPtr.Zero, bufferSize);
     }
 }

        public static void InOutPipeDirection_Throws_NotSupportedException()
        {
            // Anonymous pipes can't be made with PipeDirection.InOut
            Assert.Throws<NotSupportedException>(() => new AnonymousPipeClientStream(PipeDirection.InOut, "123"));

            SafePipeHandle pipeHandle = new SafePipeHandle(new IntPtr(-1), true);
            Assert.Throws<NotSupportedException>(() => new AnonymousPipeClientStream(PipeDirection.InOut, pipeHandle));
        }

 /// <summary>Throws an exception if the supplied handle does not represent a valid pipe.</summary>
 /// <param name="safePipeHandle">The handle to validate.</param>
 internal void ValidateHandleIsPipe(SafePipeHandle safePipeHandle)
 {
     // Check that this handle is infact a handle to a pipe.
     if (Interop.mincore.GetFileType(safePipeHandle) != Interop.mincore.FileTypes.FILE_TYPE_PIPE)
     {
         throw new IOException(SR.IO_InvalidPipeHandle);
     }
 }

 internal static extern bool DuplicateHandle(
     IntPtr hSourceProcessHandle,
     SafePipeHandle hSourceHandle,
     IntPtr hTargetProcessHandle,
     out SafePipeHandle lpTargetHandle,
     uint dwDesiredAccess,
     [MarshalAs(UnmanagedType.Bool)] bool bInheritHandle,
     uint dwOptions);

 public static void StartClient(PipeDirection direction, SafePipeHandle clientPipeHandle)
 {
     using (AnonymousPipeClientStream client = new AnonymousPipeClientStream(direction, clientPipeHandle))
     {
         DoStreamOperations(client);
     }
     // If you don't see this message that means that this task crashed.
     Console.WriteLine("*** Client operations suceedeed. ***");
 }

 /// <summary>Initializes the handle to be used asynchronously.</summary>
 /// <param name="handle">The handle.</param>
 private void InitializeAsyncHandle(SafePipeHandle handle)
 {
     // If the handle is of async type, bind the handle to the ThreadPool so that we can use 
     // the async operations (it's needed so that our native callbacks get called).
     if (!ThreadPool.BindHandle(handle))
     {
         throw new IOException(SR.IO_BindHandleFailed);
     }
 }

 private void Init(PipeDirection direction, SafePipeHandle safePipeHandle)
 {
     Debug.Assert(direction != PipeDirection.InOut, "anonymous pipes are unidirectional, caller should have verified before calling Init");
     Debug.Assert(safePipeHandle != null && !safePipeHandle.IsInvalid, "safePipeHandle must be valid");
     ValidateHandleIsPipe(safePipeHandle);
     
     InitializeHandle(safePipeHandle, true, false);
     State = PipeState.Connected;
 }

 private void Init(PipeDirection direction, SafePipeHandle safePipeHandle)
 {
     if (Microsoft.Win32.UnsafeNativeMethods.GetFileType(safePipeHandle) != 3)
     {
         throw new IOException(System.SR.GetString("IO_IO_InvalidPipeHandle"));
     }
     base.InitializeHandle(safePipeHandle, true, false);
     base.State = PipeState.Connected;
 }

		public NamedPipeClientStream (PipeDirection direction, bool isAsync, bool isConnected, SafePipeHandle safePipeHandle)
			: base (direction, DefaultBufferSize)
		{
			if (IsWindows)
				impl = new Win32NamedPipeClient (this, safePipeHandle);
			else
				impl = new UnixNamedPipeClient (this, safePipeHandle);
			IsConnected = isConnected;
			InitializeHandle (safePipeHandle, true, isAsync);
		}

 /// <summary>Throws an exception if the supplied handle does not represent a valid pipe.</summary>
 /// <param name="safePipeHandle">The handle to validate.</param>
 internal void ValidateHandleIsPipe(SafePipeHandle safePipeHandle)
 {
     Interop.Sys.FileStatus status;
     int result = CheckPipeCall(Interop.Sys.FStat(safePipeHandle, out status));
     if (result == 0)
     {
         if ((status.Mode & Interop.Sys.FileTypes.S_IFMT) != Interop.Sys.FileTypes.S_IFIFO)
         {
             throw new IOException(SR.IO_InvalidPipeHandle);
         }
     }
 }

		public AnonymousPipeClientStream (PipeDirection direction,SafePipeHandle safePipeHandle)
			: base (direction, DefaultBufferSize)
		{
			/*
			if (IsWindows)
				impl = new Win32AnonymousPipeClient (this, safePipeHandle);
			else
				impl = new UnixAnonymousPipeClient (this, safePipeHandle);
			*/

			InitializeHandle (safePipeHandle, false, false);
			IsConnected = true;
		}

        internal static bool TryGetNumberOfServerInstances(SafePipeHandle handle, out int numberOfServerInstances)
        {
            int serverInstances;

            if (GetNamedPipeHandleState(handle, IntPtr.Zero, out serverInstances, IntPtr.Zero, IntPtr.Zero, null, 0))
            {
                numberOfServerInstances = serverInstances;
                return true;
            }

            numberOfServerInstances = 0;
            return false;
        }

        public static void InvalidPipeHandle_Throws()
        {
            using (AnonymousPipeServerStream dummyserver = new AnonymousPipeServerStream(PipeDirection.Out))
            {
                Assert.Throws<ArgumentNullException>("serverSafePipeHandle", () => new AnonymousPipeServerStream(PipeDirection.Out, null, dummyserver.ClientSafePipeHandle));

                Assert.Throws<ArgumentNullException>("clientSafePipeHandle", () => new AnonymousPipeServerStream(PipeDirection.Out, dummyserver.SafePipeHandle, null));

                SafePipeHandle pipeHandle = new SafePipeHandle(new IntPtr(-1), true);
                Assert.Throws<ArgumentException>("serverSafePipeHandle", () => new AnonymousPipeServerStream(PipeDirection.Out, pipeHandle, dummyserver.ClientSafePipeHandle));

                Assert.Throws<ArgumentException>("clientSafePipeHandle", () => new AnonymousPipeServerStream(PipeDirection.Out, dummyserver.SafePipeHandle, pipeHandle));
            }
        }