RawSocket 类 抽象 接口

一个 TCP 连接。

一个 套接字连接 将 本地 套接字连接到 远程 套接字。数据以 Uint8List 的形式由本地套接字接收，并通过 read 方法提供，可以通过 write 方法发送到远程套接字。

此类 Stream 接口提供有关特定变化发生时的通知，例如数据可用时（《RawSocketEvent.read》）或远程端停止监听时（《RawSocketEvent.closed》）。

实现类型
实现者

构造函数

RawSocket()

属性

address → InternetAddress
用于连接此套接字的 InternetAddress。
无设置器
first → Future<RawSocketEvent>
此流的第一元素。
无设置器继承
hashCode → int
此对象的哈希码。
无设置器继承
isBroadcast → bool
是否此流是广播流。
无设置器继承
isEmpty → Future<bool>
是否此流包含任何元素。
无设置器继承
last → Future<RawSocketEvent>
此流的最后一个元素。
无设置器继承
length → Future<int>
此流中的元素数量。
无设置器继承
port → int
此套接字使用的端口号。
无设置器
readEventsEnabled ↔ bool
设置或获取，是否应在 RawSocket 中监听 RawSocketEvent.read 事件。默认值为 true。
获取器/设置器对
remoteAddress → InternetAddress
此套接字连接的远程 InternetAddress。
无设置器
remotePort → int
此套接字连接的远程端口号。
无设置器
runtimeType → Type
对象运行时类型的表示。
无设置器继承
single → Future<RawSocketEvent>
此流的单个元素。
无设置器继承
writeEventsEnabled ↔ bool
设置或获取，是否应该让 RawSocket 监听 RawSocketEvent.write 事件。默认为 true。这是一个一次性监听器，必须将 writeEventsEnabled 设置为 true 才能接收另一个写入事件。
获取器/设置器对

方法

any(bool test(RawSocketEvent element)) → Future<bool>
检查 test 是否接受此流提供的任何元素。
继承
asBroadcastStream({void onListen(StreamSubscription<RawSocketEvent> subscription)?, void onCancel(StreamSubscription<RawSocketEvent> subscription)?}) → Stream<RawSocketEvent>
返回一个具有相同事件的多个订阅流的流。
继承
asyncExpand<E>(Stream<E>? convert(RawSocketEvent event)) → Stream<E>
将每个元素转换为一系列异步事件。
继承
asyncMap<E>(FutureOr<E> convert(RawSocketEvent event)) → Stream<E>
创建一个新的流，将此流的每个数据事件异步映射到新的事件。
继承
available() → int
可以读取的套接字中接收到的未读取字节数。
cast<R>() → Stream<R>
将此流调整为 Stream<R>。
继承
close() → Future<RawSocket>
关闭套接字。
contains(Object? needle) → Future<bool>
返回是否此流中的元素包含 needle。
继承
distinct([bool equals(RawSocketEvent previous, RawSocketEvent next)?]) → Stream<RawSocketEvent>
跳过如果它们与上一个数据事件相等的数据事件。
继承
drain<E>([E? futureValue]) → Future<E>
丢弃此流上的所有数据，但在完成或发生错误时发出信号。
继承
elementAt(int index) → Future<RawSocketEvent>
返回此流第 index 个数据事件的值。
继承
every(bool test(RawSocketEvent element)) → Future<bool>
检查 test 是否接受此流提供的所有元素。
继承
expand<S>(Iterable<S> convert(RawSocketEvent element)) → Stream<S>
将此流中的每个元素转换成一系列元素。
继承
firstWhere(bool test(RawSocketEvent element), {RawSocketEvent orElse()?}) → Future<RawSocketEvent>
找到与test匹配的流中的第一个元素。
继承
fold<S>(S initialValue, S combine(S previous, RawSocketEvent element)) → Future<S>
通过反复应用 combine 来组合一系列值。
继承
forEach(void action(RawSocketEvent element)) → Future<void>
对流中的每个元素执行 action。
继承
getRawOption(RawSocketOption option) → Uint8List
读取关于 RawSocket 的高级信息。
handleError(Function onError, {bool test(dynamic error)?}) → Stream<RawSocketEvent>
创建一个包装流，从流中拦截一些错误。
继承
join([String separator = ""]) → Future<String>
将元素的字符串表示形式组合成一个字符串。
继承
lastWhere(bool test(RawSocketEvent element), {RawSocketEvent orElse()?}) → Future<RawSocketEvent>
找到与 test 匹配的此流中的最后一个元素。
继承
listen(void onData(RawSocketEvent event)?, {Function? onError, void onDone()?, bool? cancelOnError}) → StreamSubscription<RawSocketEvent>
为此流添加订阅。
继承
map<S>(S convert(RawSocketEvent event)) → Stream<S>
将此流的每个元素转换成新的流事件。
继承
noSuchMethod(Invocation invocation) → dynamic
当访问不存在的函数或属性时被调用。
继承
pipe(StreamConsumer<RawSocketEvent> streamConsumer) → Future
将此流的某些事件导出到 streamConsumer。
继承
read([int? len]) → Uint8List?
从套接字中读取最多 len 字节的字节。
readMessage([int? count]) → SocketMessage?
从套接字中读取包含最多 count 字节的消息。
reduce(RawSocketEvent combine(RawSocketEvent previous, RawSocketEvent element)) → Future<RawSocketEvent>
通过反复应用 combine 来组合一系列值。
继承
sendMessage(List<SocketControlMessage> controlMessages, List<int> data, [int offset = 0, int? count]) → int
将套接字控制消息和数据字节写入套接字。
setOption(SocketOption option, bool enabled) → bool
自定义RawSocket。
setRawOption(RawSocketOption option) → void
自定义RawSocket。
shutdown(SocketDirection direction) → void
在direction中关闭套接字。
singleWhere(bool test(RawSocketEvent element), {RawSocketEvent orElse()?}) → Future<RawSocketEvent>
查找此流中匹配test的单个元素。
继承
skip(int count) → Stream<RawSocketEvent>
跳过此流中的前count个数据事件。
继承
skipWhile(booltest(RawSocketEventelement)) → Stream<RawSocketEvent>
跳过匹配test的数据事件。
继承
take(int count) → Stream<RawSocketEvent>
提供最多count个此流的数据事件。
继承
takeWhile(bool test(RawSocketEvent element)) → Stream<RawSocketEvent>
在 test 成功的条件下，转发数据事件。
继承
timeout(Duration timeLimit, {void onTimeout(EventSink<RawSocketEvent> sink)?}) → Stream<RawSocketEvent>
创建一个新的流，包含与该流相同的事件。
继承
toList() → Future<List<RawSocketEvent>>
将此流的所有元素收集到一个 List 中。
继承
toSet() → Future<Set<RawSocketEvent>>
将此流的数据收集到一个 Set 中。
继承
toString() → String
此对象的一个字符串表示形式。
继承
transform<S>(StreamTransformer<RawSocketEvent, S> streamTransformer) → Stream<S>
将 streamTransformer 应用到此流上。
继承
where(bool test(RawSocketEvent event)) → Stream<RawSocketEvent>
从该流创建一个新的流，丢弃一些元素。
继承
write(List<int> buffer, [int offset = 0, int? count]) → int
将缓冲区从 offset 缓冲区偏移量开始写入最多 count 个字节的缓冲区到套接字。

运算符

操作符 ==(Object other) → bool
等号操作符。
继承

静态方法

connect(dynamic host, int port, {dynamic sourceAddress, int sourcePort = 0}'Duration? timeout}) → Future<RawSocket>
创建一个新的到主机和端口的套接字连接。
startConnect(dynamic host, int port, {dynamic sourceAddress, int sourcePort = 0}'}) → Future<ConnectionTask<RawSocket>>
类似于 connect，但它返回一个可以取消的Future，当RawSocket不再需要时，可以取消连接任务。