1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
|
using Microsoft.Win32.SafeHandles;
using System.Threading;
using System.Threading.Tasks;
namespace System.IO.Pipes
{
public abstract partial class PipeStream : Stream
{
internal const bool CheckOperationsRequiresSetHandle = false;
// Blocks until the other end of the pipe has read in all written buffer.
public void WaitForPipeDrain()
{
throw new PlatformNotSupportedException();
}
// Gets the transmission mode for the pipe. This is virtual so that subclassing types can
// override this in cases where only one mode is legal (such as anonymous pipes)
public virtual PipeTransmissionMode TransmissionMode
{
get { throw new PlatformNotSupportedException(); }
}
// Gets the buffer size in the inbound direction for the pipe. This checks if pipe has read
// access. If that passes, call to GetNamedPipeInfo will succeed.
public virtual int InBufferSize
{
get { throw new PlatformNotSupportedException(); }
}
// Gets the buffer size in the outbound direction for the pipe. This uses cached version
// if it's an outbound only pipe because GetNamedPipeInfo requires read access to the pipe.
// However, returning cached is good fallback, especially if user specified a value in
// the ctor.
public virtual int OutBufferSize
{
get { throw new PlatformNotSupportedException(); }
}
public virtual PipeTransmissionMode ReadMode
{
get { throw new PlatformNotSupportedException(); }
set { throw new PlatformNotSupportedException(); }
}
/// <summary>Initializes the handle to be used asynchronously.</summary>
/// <param name="handle">The handle.</param>
private void InitializeAsyncHandle(SafePipeHandle handle)
{
throw new PlatformNotSupportedException();
}
internal virtual void DisposeCore(bool disposing)
{
// It's incorrect to throw PNSE here because the finalizer will invoke DisposeCore.
// The finalizer can be hit if someone attempts to construct a PipeStream
// because the failed constructor invocation still creates an instance and registers
// it for finalization.
}
private unsafe int ReadCore(Span<byte> buffer)
{
throw new PlatformNotSupportedException();
}
private unsafe void WriteCore(ReadOnlySpan<byte> buffer)
{
throw new PlatformNotSupportedException();
}
private Task<int> ReadAsyncCore(Memory<byte> destination, CancellationToken cancellationToken)
{
throw new PlatformNotSupportedException();
}
private Task WriteAsyncCore(ReadOnlyMemory<byte> source, CancellationToken cancellationToken)
{
throw new PlatformNotSupportedException();
}
/// <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)
{
throw new PlatformNotSupportedException();
}
internal static string GetPipePath(string serverName, string pipeName)
{
throw new PlatformNotSupportedException();
}
}
}
|
