2024年11月

前言

watch这个API大家应该都不陌生,在Vue3版本中给watch增加不少有用的功能,比如
deep选项支持传入数字

pause、resume、stop方法

once选项

onCleanup函数
。这些功能大家平时都不怎么用得上,但是在一些特定的场景中,他们能够起大作用,这篇文章欧阳就来带你盘点一下这些功能。

关注公众号:【前端欧阳】,给自己一个进阶vue的机会

deep
支持传入数字

deep
选项大家应该比较熟悉,常见的值为
true
或者
false
,表示是否深度监听
watch
传入的对象。

在Vue3.5版本中对
deep
选项进行了增强,不光支持布尔值,而且还支持传入数字,数字表示需要监听的层数。

比如下面这个例子:

const obj1 = ref({
  a: {
    b: 1,
    c: {
      d: 2,
      e: {
        f: 3,
      },
    },
  },
});

watch(
  obj1,
  () => {
    console.log("监听到obj1变化");
  },
  {
    deep: 3,
  }
);

function changeDeep3Obj() {
  obj1.value.a.c.d = 20;	// 能够触发watch回调
}

function changeDeep4Obj() {
  obj1.value.a.c.e.f = 30;	// 不能触发watch回调
}

在上面的例子
watch

deep
选项值是3,表明监听到对象的第3层。

changeDeep3Obj
函数中就是修改对象的第3层的
d
属性,所以能够触发
watch
的回调。


changeDeep4Obj
函数是修改对象的第4层的
f
属性,所以不能触发
watch
的回调。

他的实现也很简单,我们来看一下deep相关的源码:

function watch(source, cb, options) {
  // ...省略
  if (cb && deep) {
    const depth = deep === true ? Infinity : deep
    getter = () => traverse(baseGetter(), depth)
  }
  // ...省略
}

这里的
depth
就表示watch监听一个对象的深度。

如果
deep
选项的值为true,那么就将
depth
设置为正无穷
Infinity
,说明需要监听到对象的最深处。

如果
deep
选项的值为false,或者没有传入
deep
,那么就表明只需要监听对象的最外层。

如果
deep
选项的值为number类型数字,那么就把这个数字赋给
depth
,表明需要监听到对象的具体某一层。

pause、resume、stop方法

这三个方法也是Vue3.5版本中引入的,通过解构
watch
函数的返回值就可以直接拿到
pause

resume

stop
这三个方法。

我们来看一下源码,其实很简单:

function watch(source, cb, options) {
  // ...省略
  watchHandle.pause = effect.pause.bind(effect)
  watchHandle.resume = effect.resume.bind(effect)
  watchHandle.stop = watchHandle
  return watchHandle
}

watch返回了一个名为
watchHandle
的对象,对象上面有
pause、resume、stop
这三个方法,所以我们可以通过解构
watch
函数的返回值拿到这三个方法。

pause
方法的作用是“暂停”watch回调的触发,也就是说在暂停期间不管watch监听的响应式变量如何改变,他的回调函数都不会触发。

有“暂停”,那么肯定就有“恢复”。

resume
方法的作用是恢复watch回调的触发,此时会主动执行一次watch的回调。后面watch监听的响应式变量改变时,他的回调函数也会触发。

来看个demo,代码如下:

<template>
  <button @click="count++">count++</button>
  <button @click="runner.pause()">暂停</button>
  <button @click="runner.resume()">恢复</button>
  <button @click="runner.stop()">停止</button>
</template>

<script setup lang="ts">
import { watch, ref } from "vue";

const count = ref(0);
const runner = watch(count, () => {
  console.log(count.value);
});
</script>

点击“count++”按钮会导致
watch
回调中的console执行。

但是当我们点击了“暂停”按钮后,此时我们再怎么点击“count++”按钮都不会触发
watch
的回调。

点击
恢复
按钮后会立即触发一次
watch
回调的执行,后面点击“count++”按钮也同样会触发
watch
的回调。

我们来看看
pause

resume
方法的源码,很简单,代码如下:

class ReactiveEffect {
  pause(): void {
    this.flags |= EffectFlags.PAUSED
  }

  resume(): void {
    if (this.flags & EffectFlags.PAUSED) {
      this.flags &= ~EffectFlags.PAUSED
      if (pausedQueueEffects.has(this)) {
        pausedQueueEffects.delete(this)
        this.trigger()
      }
    }
  }

  trigger(): void {
    if (this.flags & EffectFlags.PAUSED) {
      pausedQueueEffects.add(this)
    } else if (this.scheduler) {
      this.scheduler()
    } else {
      this.runIfDirty()
    }
  }
}


pause

resume
方法中通过修改
flags
属性的值,来切换是不是“暂停状态”。

在执行
trigger
方法依赖触发时,就会先去读取
flags
属性判断当前是不是“暂停状态”,如果是那么就不去执行watch的回调。

从上面的代码可以看到这三个方法是在
ReactiveEffect
类上面的,这个
ReactiveEffect
类是Vue的一个底层类,
watch

watchEffect

watchPosEffect

watchSyncEffect
都是基于这个类实现的,所以他们自然也支持
pause

resume

stop
这三个方法。

最后就是
stop
方法了,当你确定后面都不再想要触发watch的回调了,那么就调用这个
stop
方法。代码如下:

const watchHandle: WatchHandle = () => {
  effect.stop()
  if (scope && scope.active) {
    remove(scope.effects, effect)
  }
}

watchHandle.stop = watchHandle

响应式变量
count
收集的订阅者集合中有这个watch回调,所以当
count
的值改变后会触发watch回调。这里的
stop
方法中主要是依靠双向链表将这个watch回调从响应式变量
count
的订阅者集合中给remove掉,所以执行stop方法后无论
count
变量的值如何改变,watch回调也不会再执行了。(PS:如果你看不懂这段话,建议你去看看我的上一篇
Vue3.5双向链表
文章,看完后你就懂了)

once选项

如果你只想让你的watch回调只执行一次,那么可以试试这个
once
选项,这个是在Vue3.4版本中新加的。

看个demo:

<template>
  <button @click="count++">count++</button>
</template>

<script setup lang="ts">
import { watch, ref } from "vue";

const count = ref(0);
watch(
  count,
  () => {
    console.log("once", count.value);
  },
  {
    once: true,
  }
);
</script>

由于使用了
once
选项,所以只有第一次点击“count++”按钮才会触发watch的回调。后面再怎么点击按钮都不会触发watch回调。

我们来看看
once
选项的源码,很简单,代码如下:

function watch(source, cb, options) {
  const watchHandle: WatchHandle = () => {
    effect.stop()
    if (scope && scope.active) {
      remove(scope.effects, effect)
    }
  }

  if (once && cb) {
    const _cb = cb
    cb = (...args) => {
      _cb(...args)
      watchHandle()
    }
  }

  // ...省略
  watchHandle.pause = effect.pause.bind(effect)
  watchHandle.resume = effect.resume.bind(effect)
  watchHandle.stop = watchHandle
  return watchHandle
}

先看中间的代码
if (once && cb)
,这句话的意思是如果
once
选项的值为true,并且也传入了watch回调。那么就封装一层新的
cb
回调函数,在新的回调函数中还是会执行用户传入的watch回调。然后再去执行一个
watchHandle
函数,这个
watchHandle
是不是觉得有点眼熟?

前面讲的
stop
方法其实就是在执行这个
watchHandle
,执行完这个
watchHandle
函数后watch就不再监听
count
变量了,所以后续不管
count
变量怎么修改,watch的回调也不会再触发。

onCleanup函数

有的情况我们需要watch监听一个变量,然后去发起http请求。如果变量改变的很快就会出现第一个请求还没回来,第二个请求就已经发起了。在一些极端情况下还会出现第一个请求的响应比第二个请求的响应还要慢,此时第一个请求的返回值就会覆盖第二个请求的返回值。实际上我们期待最终拿到的是第二个请求的返回值。

这种情况我们就可以使用
onCleanup函数
,他是作为watch回调的第三个参数暴露给我们的。看个例子:

watch(id, async (newId, oldId, onCleanup) => {
  const { response, cancel } = myFetch(newId)
  // 当 `id` 变化时,`cancel` 将被调用,
  // 取消之前的未完成的请求
  onCleanup(cancel)
  data.value = await response
})

watch回调的前两个参数大家都很熟悉:新的id值和旧的id值。第三个参数就是
onCleanup
函数,在watch回调触发之前调用,所以我们可以使用他来cancel掉上一次的请求。

onCleanup
函数的注册也很简单,代码如下:

let boundCleanup

boundCleanup = fn => onWatcherCleanup(fn, false, effect)

function watch(source, cb, options) {
  // ...省略
  const job = (immediateFirstRun?: boolean) => {
    const args = [
      newValue,
      oldValue,
      boundCleanup,
    ]
    cb(...args)
    oldValue = newValue
  }
  // ...省略
}

执行watch回调实际就是在执行这个
job
函数,在
job
函数中执行watch回调时传入了三个参数。分别是
newValue

oldValue

boundCleanup
。前两个参数大家都很熟悉,第三个参数
boundCleanup
是一个函数:
fn => onWatcherCleanup(fn, false, effect)

这个
onWatcherCleanup
大家熟悉不?这也是Vue暴露出来的一个API,注册一个清理函数,在当前侦听器即将重新运行时执行。关于
onWatcherCleanup
之前欧阳写过一篇文章专门讲了如何使用:
使用Vue3.5的onWatcherCleanup封装自动cancel的fetch函数

总结

这篇文章盘点了Vue3 watch新增的一些新功能:
deep选项支持传入数字

pause、resume、stop方法

once选项

onCleanup函数
。这些功能大家平时可能用不上,但是还是要知道有这些功能,因为有的情况下这些功能能够派上大用场。

关注公众号:【前端欧阳】,给自己一个进阶vue的机会

另外欧阳写了一本开源电子书
vue3编译原理揭秘
,看完这本书可以让你对vue编译的认知有质的提升。这本书初、中级前端能看懂,完全免费,只求一个star。

大家好,我是 V 哥,很好奇,在ArkTS中实现异步编程是怎样的,今天的内容来聊聊这个问题,总结了一些学习笔记,分享给大家,在 ArkTS中实现异步编程主要可以通过以下几种方式:

1. 使用
async

await
关键字

async
函数是一种特殊的函数,它能以同步代码的方式编写异步代码。在
async
函数内部,可以使用
await
表达式来等待一个异步操作返回一个Promise对象。这种方式可以让异步代码的编写和阅读更接近同步代码的风格,提高代码的可读性和可维护性。

// 定义一个async函数
async function myAsyncFunction() {
  // 使用await等待异步操作完成
  const result = await someAsyncOperation();
  console.log(result);
}

async函数和await关键字有什么区别?

async

await
是 JavaScript 中用于异步编程的两个关键字,它们共同工作以简化异步代码的编写和理解,但它们各自有不同的用途和含义:

async 关键字

  • async
    是一个用于声明异步函数的关键字。
  • 任何使用
    async
    声明的函数都会自动返回一个
    Promise
    对象。
  • 如果函数正常执行结束,
    Promise
    将被解决(resolve)并返回函数的返回值。
  • 如果函数中抛出错误,
    Promise
    将被拒绝(reject)。
  • async
    函数内部可以包含一个或多个
    await
    表达式。

await 关键字

  • await
    是一个用于等待一个
    Promise
    对象解决(resolve)的关键字。
  • await
    只能在
    async
    函数内部使用。
  • 当执行到
    await
    表达式时,JavaScript 引擎会暂停该
    async
    函数的执行,直到等待的
    Promise
    被解决。
  • 如果
    Promise
    被解决,
    await
    表达式返回
    Promise
    的值。
  • 如果
    Promise
    被拒绝,
    await
    表达式会抛出拒绝的原因,这可以通过
    try...catch
    语句捕获。
  • await
    后面通常跟的是一个异步操作,比如一个返回
    Promise
    的函数调用。

它们的区别

  • async
    是用来声明函数的,而
    await
    是用来在函数内部等待异步操作的。
  • async
    本身不暂停代码执行,它只是让函数返回一个
    Promise
    ;而
    await
    是用来暂停代码执行,直到
    Promise
    被解决。
  • async
    可以不与
    await
    一起使用,这时函数仍然返回一个
    Promise
    ,但不会暂停执行。
  • await
    必须用在
    async
    函数内部,否则会抛出语法错误。

示例

// async 函数声明
async function fetchData() {
  // 等待异步操作完成
  const data = await fetchSomeData(); // 这里使用了 await
  return data;
}

// 单独使用 async
async function justAsync() {
  console.log('This is an async function, but without await.');
}

// 使用 await
async function useAwait() {
  console.log('Before await.');
  await justAsync(); // 等待 justAsync 完成
  console.log('After await.');
}

所以啊, V哥提醒一下,
async

await
是异步编程中两个互补的概念,
async
用于声明异步函数,而
await
用于在异步函数内部等待异步操作的完成,初学者需要注意不要混淆了。

2. 使用Promise对象

上面我们已经提到Promise对象了,Promise是处理异步操作的对象,它提供了一个状态机制来管理异步操作的不同阶段,代表一个异步操作的最终完成(或失败)及其结果值,并提供了一些方法来注册回调函数以处理异步操作的成功或失败的结果。Promise有三种状态:pending(进行中)、fulfilled(已完成)和rejected(已拒绝)。

// 创建一个新的Promise
const myPromise = new Promise((resolve, reject) => {
  // 异步操作
  if (/* 异步操作成功 */) {
    resolve("Success");
  } else {
    reject("Error");
  }
});

// 使用then和catch处理Promise的结果
myPromise.then((value) => {
  console.log(value); // "Success"
}).catch((error) => {
  console.error(error); // "Error"
});

3. 异常处理

在异步函数中,如果出现错误,可以通过
try...catch
语句来捕获异常。

async function myAsyncFunction() {
  try {
    const result = await someAsyncOperation();
    console.log(result);
  } catch (error) {
    console.error(error);
  }
}

4. 并发执行异步任务

可以使用
Promise.all
来并发执行多个异步任务,并等待它们全部完成。

async function concurrentTasks() {
  const [result1, result2] = await Promise.all([
    asyncOperation1(),
    asyncOperation2()
  ]);
  console.log(result1, result2);
}

5. 使用Actor模型

ArkTS语言采用的Actor模型是一种并发编程模型,其中每个Actor都是一个独立的计算单元,拥有自己的状态和行为,并通过消息传递与其他Actor进行通信和协作。

1. Actor模型概述

在Actor模型中,每个Actor都可以接收异步消息,并根据消息内容和当前状态做出响应。Actor之间的消息传递是异步的,发送消息的Actor不需要等待接收消息的Actor的响应,从而实现并发执行。由于每个Actor都是独立的,它们之间不存在共享状态,因此不需要进行锁机制和同步操作,避免了一些常见的并发编程问题,如死锁和竞争条件。

2. 数据传输对象

ArkTS语言支持传输的数据对象可以分为四种:普通对象、可转移对象、可共享对象和Native绑定对象。普通对象的传输是通过结构化克隆算法进行序列化的,支持多种类型,包括基础类型、Date、String、RegExp、Array、Map、Set等。

3. 实现例子

以下是一个使用ArkTS的Actor模型实现的生产者消费者问题的示例:

生产者(Producer)和消费者(Consumer)的Actor模型实现:

import taskpool from '@ohos.taskpool';

// 跨线程并发任务
@Concurrent
async function produce(): Promise<number>{
  // 添加生产相关逻辑
  console.log("test producing...");
  return Math.random();
}

class Consumer {
  public consume(value: number) {
    // 添加消费相关逻辑
    console.log("test consuming value: " + value);
  }
}

@Entry
@Component
struct Index {
  @State message: string = 'Hello I am VG';
  build() {
    Row() {
      Column() {
        Text(this.message)
          .fontSize(50)
          .fontWeight(FontWeight.Bold)
        Button() {
          Text("start")
        }.onClick(() => {
          let produceTask: taskpool.Task = new taskpool.Task(produce);
          let consumer: Consumer = new Consumer();
          for (let index: number = 0; index < 10; index++) {
            // 执行生产异步并发任务
            taskpool.execute(produceTask).then((res: number) => {
              consumer.consume(res);
            }).catch((e: Error) => {
              console.error(e.message);
            })
          }
        })
        .width('20%')
        .height('20%')
      }
      .width('100%')
    }
    .height('100%')
  }
}

在这个例子中,
produce
函数是一个异步函数,模拟生产者的生产过程,并返回一个随机数作为产品。
Consumer
类包含
consume
方法,用于消费产品。在UI界面上,当用户点击“start”按钮时,会启动10次生产任务,每次生产任务完成后,都会调用
Consumer

consume
方法来消费产品。

这个例子展示了如何在ArkTS中使用Actor模型来实现并发执行,其中生产者和消费者之间通过异步消息传递来通信,无需等待对方的响应,从而实现高效的并发处理。

最后

ArkTS提供了强大的异步编程能力,使得开发者可以有效地处理异步任务,提高程序的性能和响应能力。对于有 TypeScript 经验的兄弟是不是有种找到真爱的感觉呢。关注威哥爱编程,鸿蒙开天辟地,你我皆是同路人。

相关:

NVIDIA机器人仿真项目 —— Isaac Gym - Preview Release


本文说下NVIDIA公司的机器人仿真项目的一些历史发展。

NVIDIA公司的产品最初只有显卡,但是卖着卖着发现有很多人用CPU搞图形化设计,比如OpenGL,于是老黄大受启发,从此NVIDIA的显卡开发计算接口支持图形化计算,慢慢的NVIDIA的显卡被美国、中国等国家的超算机构所采用,于是NVIDIA公司就出现了家用游戏显卡和企业用计算显卡两种硬件产品以及图形化计算平台这个软件产品;随着AI时代的火热,Deep learning下的时代来临,NVIDIA公司在之前的三个产品(家用游戏显卡和企业用计算显卡两种硬件产品以及图形化计算平台)的基础上建立了AI模型库集成AI软件集成平台,然后随着AI平台在监督学习和无监督学习上集成的AI模型初具规模后,NVIDIA公司开始着眼于强化学习以及元宇宙概念,于是就有了NVIDIA公司的机器人仿真平台,这也是本文所要介绍的内容。


NVIDIA公司最初推出的机器人仿真平台是NVIDIA issac gym,这个项目一共出了四个版本,preview 1,preview 2,preview 3,preview 4,可以说这个issac gym是NVIDIA公司在机器人仿真方向上的大始祖,下面给出其中的第一、二、四版本的下载资源:

https://openi.pcl.ac.cn/devilmaycry812839668/issac_gym_store

由于是初代产品,因此这个Isaac gym平台只能够导入3D模型(urdf、mjdf文件),而不能提供3D设计的操作平台,并且将仿真平台和RL算法等AI算法集成在了一起,随着时间发展,这个产品逐渐成熟,于是在preview 4版本时将AI算法的接口和算法库单独拿了出来形成了IsaacGymEnvs项目:

https://github.com/NVIDIA-Omniverse/IsaacGymEnvs


由于NVIDIA公司认为机器人的AI平台是未来走向通用人工智能(AGI)的重要途径,于是不断加码这个领域的投入,于是就出现了多个部门同时在issac gym的基础上进行扩展开发,因此在issac gym项目抽取出issac gym envs项目后又将issac gym项目和issac gym envs项目升级为OmniIsaacGymEnvs项目,此时的重点是加强3D设计的操作界面做准备,也就是加入元宇宙概念,Omniverse:

https://github.com/NVIDIA-Omniverse/OmniIsaacGymEnvs

其实这里的元宇宙概念与之前的issac gym项目和issac gym envs项目的区别就是其内部的C++实现接口进行了升级,这样可以在下一个升级版本中加入3D设计的操作接口,这样就可以在一个项目中进行3D设计从而生成urdf和mjdf文件,而不需要从第三方仿真设计平台导入了,因此虽然说OmniIsaacGymEnvs是issac gym和issac gym envs的升级,但是对于使用者来说其实并没有太实质的变化,因为这个升级主要是为了服务其内部开发人员的。


在nvidia公司将issac gym和issac gym envs升级为OmniIsaacGymEnvs的同时也进行了fork操作,也就是在issac gym和issac gym envs的基础上又开了一个独立分支,这个分支也是为了元宇宙概念服务的,在这个新分支中考虑对更多的输入数据类型进行处理并且加入更多的AI模型的接入接口,于是有了orbit项目:

https://github.com/NVIDIA-Omniverse/orbit


因为NVIDIA公司的对机器人项目的投入是一个点开始,然后从一条线分出多条线独立发展,然后再将多条线合并到一起的发展路子,因此OmniIsaacGymEnvs和orbit都可以认为是issac gym项目基础上结合不同的元宇宙发展需要的后期接口进行fork后独立发展的,在issac gym项目分叉为OmniIsaacGymEnvs和orbit项目后,NVIDIA公司又决定将这几个项目合并成一个项目,这就是issac sim项目,地址:

https://developer.nvidia.cn/isaac/sim

可以说issac sim是NVIDIA公司的元宇宙技术平台的一个阶段性的汇总,在NVIDIA公司将issac gym项目升级为IsaacGymEnvs,然后再升级为OmniIsaacGymEnvs和orbit的同时,NVIDIA公司也在issac gym的最原始版本开出了其他路线的项目,如:Isaac ROS和Isaac Manipulator,其中Isaac ROS可以看做是issac gym和ROS软件平台的集成,而Isaac Manipulator可以看做是issac gym和视觉识别系统和动作规划系统的集成,于是issac gym发展成了今天的NVIDIA的issac家族,具体如下:

1、Isaac ROS:

https://developer.nvidia.cn/isaac/ros

体验参考指南标准:

https://img-bss.csdnimg.cn/bss/NVIDIA/IsaacROS.docx

2、Isaac Manipulator:

https://developer.nvidia.cn/isaac/manipulator

体验参考指南标准:

https://img-bss.csdnimg.cn/bss/NVIDIA/IsaacManipulator.docx

3、NVIDIA Isaac Sim:

https://developer.nvidia.cn/isaac/sim

体验参考指南标准:

https://img-bss.csdnimg.cn/bss/NVIDIA/IsaacSim.docx


issac sim可以看做是在issac gymenvs基础上加入了3D设计的图形化操作界面等支持其他功能接口的一次升级。


在NVIDIA推出NVIDIA issac家族后又进行了升级,推出了一个新产品,那就是issac Lab;issac Lab在issac sim基础上进行的,于是就从issac家族再次升级为issac Lab家族,其中issac Lab家族可以看做是在issac家族基础上加入了输入数据类型扩增的一次升级,因此在windows平台下issac sim平台就代表了issac lab平台,这二者是同义词,但是在Linux平台下二者有着不同的下载地址:

Isaac lab的主页地址:

https://developer.nvidia.com/isaac/lab?ncid=ref-inor-146211

Isaac sim的主页地址:

https://developer.nvidia.com/isaac/sim/


可以说issac lab是在issac sim的基础上增加一些功能后的产品,可以看作是一次升级,因此现在NVIDIA的维护项目为issac sim和issac lab项目,而之前的issac gym/issac gym envs/OmniIsaacGymEnvs/orbit项目都已经不再维护了。

因为我是从issac gym项目就关注NVIDIA公司的产品,因为我是从事RL方向的,于是就发现了NVIDIA公司在同一个产品上不对的升级,而且是多部门从事搞,于是就fork出了多个项目,然后项目开发到一定时候就merge到一起,然后再开发遇到问题,然后再fork出分支,于是就出现了今天的这种要人感觉乱七八糟的感觉,如果是新人入手来学机器人的AI方向,那么之前的版本就可以不用太在意了,直接从issac sim和issac lab开始即可。



扩展:

issac-gym下载地址:

https://developer.nvidia.com/isaac-gym/download

image-20241118120100625


Isaac Sim主页地址:

https://developer.nvidia.com/isaac/sim#isaac-lab

docker安装方式地址:

https://catalog.ngc.nvidia.com/orgs/nvidia/containers/isaac-sim

image-20241118120435405



个人github博客地址:
https://devilmaycry812839668.github.io/

在鸿蒙开发中,系统提供了PhotoViewPicker选择图片,cameraPicker拍照和录视频,此方式能够达到无需向用户申请权限就能选图片、拍照和录视频。除了用户操作的选图、拍照和录视频,其它时间APP无权获取相册图片,无权调用相机,对于用户来说,使用相册和相机都是很明确的时机,安全性非常高。以下来看看具体的使用方式。

使用PhotoViewPicker选择图片

我们new一个PhotoViewPicker并调用select方法,就可以打开系统图片选择器进行图片选择了,支持的参数非常多,基本满足了日常的使用场景。

  • MIMEType:我们可以通过MIMEType来设置是选择图片或者选择视频,甚至是同时选择图片和视频。
  • isEditSupported:通过isEditSupported参数来设置选择好图片后,是否进入图片编辑模式。
  • isOriginalSupported:通过isOriginalSupported参数来设置选择的图片是否为源图,该参数设置为true,选择页面有一个按钮,可以控制是否使用源图。
  • isPhotoTakingSupported:在图片选择页面,可以通过isPhotoTakingSupported参数设置第一个位置是否为拍照选项,设置后点击第一个位置,可以打开相机拍摄一张图片。
  • isPreviewForSingleSelectionSupported:通过isPreviewForSingleSelectionSupported参数可以在图片选择后,进入大图预览页面,使我们能够查看图片的更多细节。
  • isSearchSupported:当相册的图片太多时,我们可以通过isSearchSupported参数显示搜索框,在搜索框中输入图片相关内容,以便快速查找相关图片
  • maxSelectNumber:通过maxSelectNumber来设置选择的数量,默认选择50张图片,最多选择500张。
  • preselectedUris:当为多选模式时,通过preselectedUris参数可以预选中一些图片,以便避免每次打开图片选择器,都是重新选择,从而导致之前选择的图片丢失了。
    一个完整的示例如下
new photoAccessHelper.PhotoViewPicker().select({
  MIMEType: photoAccessHelper.PhotoViewMIMETypes.IMAGE_TYPE,
  maxSelectNumber: 9,
  isEditSupported: false,
  isOriginalSupported: rue,
  preselectedUris: [],
  isPhotoTakingSupported: false,
  isPreviewForSingleSelectionSupported: false,
  isSearchSupported: false
}, (err, data) => {
  console.log(data)
})

使用cameraPicker拍照和录视频

我们可以通过cameraPicker的select方法来进行拍照或录视频,也可以同时设置拍照和录视频,用户在拍照页面自行选择是拍照还是录视频。具体使用参数如下

  • mediaTypes:是一个数组,设置为拍照片,还是录视频,也可以同时设置
  • cameraPosition:设置是使用前置摄像头还是后置摄像头进行拍照或录视频
  • saveUri:设置拍照或录制的视频保存的位置,通常设置成我们的沙箱目录
  • videoDuration:当模式为录视频时,此参数为设置视频的最大时长。
    一个完整的示例如下
cameraPicker.pick(context,[cameraPicker.PickerMediaType.PHOTO, cameraPicker.PickerMediaType.VIDEO],
  { cameraPosition: camera.CameraPosition.CAMERA_POSITION_BACK,saveUri:'',videoDuration:30 })
  .then((value) => {
    console.log(value.resultUri)
  })

用户在系统拍照录视频页面,可以自己选择很多参数,例如是否打开闪光灯,图片的宽高比,视频的帧率,是否撕开参考线等等,可选择的参数很多,灵活度也很高,基本可以满足日常的使用场景,最主要的是不用向用户申请权限,还是非常方便的。

被微软形容为“迄今为止最高效、最现代、最安全、最智能、性能最高的.NET版本”——.NET 9已经发布有一周了,今天想和大家一起体验一下新功能。

此次.NET 9在性能、安全性和功能等方面进行了大量改进,包含了数千项的修改,今天主要和大家一起体验我们常用有变化的功能。

01
、安装

首先可以在命令行中通过dotnet --list-sdks指令查看是否以安装.NET9。

安装方式主要有两种,第一种通过直接下载.NET9 SDK安装。

第二种方式通过更新IDE Visual Studio至17.12.0或之后的版本,比如我的IDE是17.11.6,选择更新即可,如果是更老的版本,比如17.11.4则需要更新两次才行。

再次执行dotnet --list-sdks命令,发现已安装成功,结果如下:

02
、新的转义序列

本次C#13新引入了 \e 作为 ESC (Escape)字符 Unicode U+001B 的字符文本转义序列。而以前使用的是 \u001b 或 \x1b。

ESC (Escape) 字符(ASCII 编码值为 27,十六进制为 0x1b)是一种控制字符,可以用于 终端控制和文本格式化。它本身代是不可见字符,主要作用标志着后续字符序列的开始,这些序列会指定终端执行特定的操作,如改变文本颜色、设置文本样式、清屏、移动光标等。

我们举一个例子,比如“ESC[31m ”表示把文本颜色设置为红色,我们把ESC改为转义序列,代码如下:

static void Main(string[] args)
{
    var colorRed = "\x1b[31m红色文本";
    Console.WriteLine(colorRed);
    Console.ReadKey();
}

执行效果如下:

如果单独使用ESC (Escape)字符的转义序列则表示其后接着的字符不可见,我们可以用\u001b和\x1b看看效果,结果如下,发现看字没有展示出来:

然后我们把\u001b和\x1b改为\u001b1和\x1b1,再看一下效果:

从上图可以发现使用\u001b1结果还是\u001b后面一个字符看不见,而使用\x1b1后变成问号“?”了,这是因为\x1b1整体被识别为一个更长的十六进制序列,而不是单纯的控制字符了,这就产生了歧义,因此不建议使用\x1b,因而这次新增了转义字符\e,效果如下。

03
、隐式索引访问

现在对象初始值设定项表达式中允许隐式“从末尾开始”索引运算符[^]。

我们来看一个例子,首先创建了一个ImplicitIndex类并且包含一个Numbers属性,该属性是一个长度为 5 的整数数组。

现在我们可以在初始化类ImplicitIndex时初始化属性Numbers,并使用“从末尾开始”索引运算符来填充数组值。

我们先看看在.NET8中的效果,鼠标移到错误上可以看到老版本是不支持该功能的,如下图:

而使用.NET9则可以。

04
、params参数增强

之前params只支持数组,而现在params参数支持更多的集合类型,包括 Span
、ReadOnlySpan 、IEnumerable 等等。这使得我们可以更加灵活的传入集合参数,而不用先把集合转成数组后再传输。

public static void PrintNumbers(params int[] numbers) { }
public static void PrintNumbers(params List<string> numbers) { }
public static void PrintNumbers(params HashSet<int> numbers) { }
public static void PrintNumbers(params SortedSet<int> numbers) { }
public static void PrintNumbers(params IList<int> numbers) { }
public static void PrintNumbers(params ICollection<int> numbers) { }
public static void PrintNumbers(params IEnumerable<int> numbers) { }
public static void PrintNumbers(params Span<int> numbers) { }
public static void PrintNumbers(params ReadOnlySpan<int> numbers) { }

params 关键字允许方法接收一个可变数量的参数,通常是单一类型的参数集合。params 的参数通常可以是数组、集合或其他实现了 IEnumerable
接口的类型,但有一些限制,比如以下类型虽然实现了IEnumerable 接口,但是并不受支持。

public static void PrintNumbers(params Dictionary<int, int> numbers) { }
public static void PrintNumbers(params SortedList<int, int> numbers) { }
public static void PrintNumbers(params LinkedList<int> numbers) { }
public static void PrintNumbers(params Queue<int> numbers) { }
public static void PrintNumbers(params Queue numbers) { }
public static void PrintNumbers(params Stack<int> numbers) { }
public static void PrintNumbers(params Stack numbers) { }
public static void PrintNumbers(params Hashtable numbers) { }

05
、锁对象

本次更新引入新的锁类型System.Threading.Lock,用于实现互斥。在之前的版本中通常通过object类型进行加锁,而现在有了专门的Lock类型用来加锁。

新的Lock类型会使得代码更干净、更安全、更高效。

在新的锁定机制中EnterScope替换了Monitor底层实现。同时它遵循Dispose模式返回ref struct,因此可以与using语句结合使用。

我们一起看看下面代码示例:

// .NET 9 之前
public class LockExampleNET9Before
{
    private readonly object _lock = new();
    public void Print()
    {
        lock (_lock)
        {
            Console.WriteLine("我们是老的锁");
        }
    }
}
// .NET 9
public class LockExampleNET9
{
    private readonly Lock _lock = new();
    public void Print()
    {
        lock (_lock)
        {
            Console.WriteLine("我们是 .NET 9 新锁");
        }
    }
    public async Task LogMessageAsync(string message)
    {
        using (_lock.EnterScope())
        {
            Console.WriteLine("我们是 .NET 9 新锁,可以和using一起使用");
        }
    }
}

06
、生成UUID v7

我们经常在实体中使用Guid作为主键,并且通过Guid.NewGuid()可以很方便的生成一个新的Guid,而此方法生成的Guid是依据UUID第四个版本规范生成的。

当前已经可以通过Guid.CreateVersion7()方法创建UUID第七个版本,这个版本UUID主要功能就是包含了时间戳,数据结构如下:

| 48位时间戳 | 12位随机 | 62位随机 |

这也意味着v7版本的UUID可以按时间排序了,在数据库中使用起来更方便,同时Guid.CreateVersion7()方法还有一个重载方法接收DateTimeOffset类型时间戳,用来通过指定时间创建UUID。

static void Main()
{
    // v4 UUID
    var guid_v4 = Guid.NewGuid();
    // v7 UUID
    var guid_v7 = Guid.CreateVersion7();
    // v7 UUID with timestamp
    var guid_v7_time = Guid.CreateVersion7(TimeProvider.System.GetLocalNow()); 
    Console.ReadKey();
}


:测试方法代码以及示例源码都已经上传至代码库,有兴趣的可以看看。
https://gitee.com/hugogoos/Planner