LinQ 查询表达式大全 Unity UniRx 中文目录-Chinar

最新推荐文章于 2024-01-02 11:48:31 发布
最新推荐文章于 2024-01-02 11:48:31 发布
阅读量938 收藏 3
点赞数 1
分类专栏： Unity 3D 插件 文章标签： LinQ查询表达式大全 LinQ表达式中文 UniRx 表达式大全 UniRx操作符 LInQ操作符
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ChinarCSDN/article/details/85805971
版权
Unity 3D 同时被 2 个专栏收录
178 篇文章 255 订阅
订阅专栏
插件
37 篇文章 5 订阅
订阅专栏

Chinar blog ：www.chinar.xin


UnitRx LinQ 表达式全解


本文提供全流程，中文翻译。

Chinar 坚持将简单的生活方式，带给世人！

（拥有更好的阅读体验 —— 高分辨率用户请根据需求调整网页缩放比例）

Chinar —— 心分享、心创新！

助力查询学习 LinQ 查询语句的具体用法、可用于备忘

为新手节省宝贵的时间，避免采坑！

Chinar 教程效果：暂时留空

文章目录

全文高清图片，点击即可放大观看 (很多人竟然不知道)

一

1. Where —— 筛选条件


Where —— 使满足条件的数据通过，排除被限制的元素

举个例子

查询狗狗数据中，重量大于 30 的狗

// ========================================================
// 描述：Where 筛选满足/限制条件
// 作者：Chinar 
// 创建时间：2019-01-03 23:55:27
// 版 本：1.0
// ========================================================
using System.Collections.Generic;
using System.Linq;
using UnityEngine;


namespace ChinarDemo.LinQ
{
    public class Chinar_Where : MonoBehaviour
    {
        void Start()
        {
            //一个数据列表，并添加数据
            List<Dog> dogs = new List<Dog>()
            {
                new Dog("金毛",  2000, 62),
                new Dog("二哈",  1500, 45),
                new Dog("泰迪",  1000, 15),
                new Dog("吉娃娃", 500,  10)
            };
            //1-查询 狗狗中 重量大于30
            dogs.Where(dog => dog.Weight > 30).ToList().ForEach(dog => print(dog.ToString()));
            //2-LinQ 查询 狗狗中 重量大于30
            (from dog in dogs where dog.Weight > 30 select dog).ToList().ForEach(dog => print(dog.ToString()));
        }
    }
}

打印输出：

Name: 金毛, Price: 2000, Weight: 62
Name: 二哈, Price: 1500, Weight: 45

Name: 金毛, Price: 2000, Weight: 62
Name: 二哈, Price: 1500, Weight: 45

数据类 —— 为了简化代码，将该类放于 ChinarDemo.LinQ 命名空间中。便于以下例子使用此数据！ 

namespace ChinarDemo.LinQ
{
    /// <summary>
    /// 狗狗数据类
    /// </summary>
    public class Dog
    {
        public string Name;   //名称
        public int    Price;  //价格
        public float  Weight; //重量


        /// <summary>
        /// 构造 —— 简化代码
        /// </summary>
        public Dog(string name, int price, float weight)
        {
            Name   = name;
            Price  = price;
            Weight = weight;
        }


        /// <summary>
        /// 便于打印输出看效果 —— 简化代码
        /// </summary>
        public override string ToString()
        {
            return $"{nameof(Name)}: {Name}, {nameof(Price)}: {Price}, {nameof(Weight)}: {Weight}";
        }
    }
}

2. Select —— 返回选定类型


Select —— 选择并返回相应数据类型

举个例子

每帧，监听左键点击与右键点击，并选择需要返回的数据类型，打印输出！

using UniRx;
using UniRx.Triggers;
using UnityEngine;


namespace ChinarDemo.LinQ
{
    public class LinQ_Select : MonoBehaviour
    {
        int count = 0;


        /// <summary>
        /// 1 —— UniRx表达式
        /// 点右键
        /// </summary>
        void Start()
        {
            this.UpdateAsObservable()
                .Where(_ => Input.GetMouseButtonDown(1)) //条件
                .Select(_ => "Chinar右" + count++)         //返回 字符串 —— Chinar0 / Chinar1 / Chinar...
                .Subscribe(print);                       // print 等同于<  .Subscribe(chinarEvent=>print(chinarEvent))  >
                
            LinQ();
        }


        /// <summary>
        /// 2 —— 查询表达式
        /// 点左键
        /// </summary>
        private void LinQ()
        {
            (from _ in this.UpdateAsObservable() where Input.GetMouseButtonDown(0) select "Chinar左" + count++).Subscribe(print);
        }
    }
}

打印输出：
在这里插入图片描述

2.1 SelectMany —— 返回多个选定类型/协程排序


SelectMany —— 选择并返回相应数据类型，是在Select的基础上，返回了多个类型
在 UniRx 中多用于对协程执行顺序进行管理

举个例子

下面例子中，将狗狗的名字拆分为字符类型，并返回
对3个协程依照需求顺序执行

public class Chinar_SelectMany : MonoBehaviour
{
    private List<Dog> dogs;


    /// <summary>
    /// 初始化函数
    /// </summary>
    void Start()
    {
        dogs = new List<Dog>() //该数据用的是 1 中写好的数据
        {
            new Dog("金毛",  2000, 62),
            new Dog("二哈",  1500, 45),
            new Dog("泰迪",  1000, 15),
            new Dog("吉娃娃", 500,  10)
        };
        dogs.ToObservable().SelectMany(_ => _.Name).Subscribe(_ => print(_)); //从列表中选择返回名字，并切分为Char类型
        Chinar_UniRx();
    }


    private void LinQ()
    {
        dogs.SelectMany(_ => _.Name).ToList().ForEach(_ => print(_));
    }


    /// <summary>
    /// 在 UniRx 中的用法，可将协程以需要的顺序执行
    /// </summary>
    private void Chinar_UniRx()
    {
        var ie1 = Observable.FromCoroutine(Ie1);
        var ie2 = Observable.FromCoroutine(Ie2);
        var ie3 = Observable.FromCoroutine(Ie3);
        ie3.SelectMany(ie2.SelectMany(ie1)).Subscribe(); //协程执行顺序一一对应： 3-2-1
    }


    IEnumerator Ie1()
    {
        yield return new WaitForSeconds(0.5f);
        print(1);
    }


    IEnumerator Ie2()
    {
        yield return new WaitForSeconds(0.5f);
        print(2);
    }


    IEnumerator Ie3()
    {
        yield return new WaitForSeconds(0.5f);
        print(3);
    }
}

打印输出：
在这里插入图片描述

3. First —— 首次/第一个数据


First —— 数据 / 事件中，满足条件的第一个

举个例子

1-无论点击多少次，只会只在首次点击左键时输出 0
2-只取第一个，数组中满足条件的元素

using System.Linq;
using UniRx;
using UniRx.Triggers;
using UnityEngine;


namespace ChinarDemo.LinQ
{
    public class Chinar_First : MonoBehaviour
    {
        private int count = 0;


        void Start()
        {
            this.UpdateAsObservable()
                .First(_ => Input.GetMouseButtonDown(0)) //第一次点击左键时
                .Subscribe(_ => print(count++));         // 无论点击多少次，只会只在首次点击左键时输出 0
            LinQ();
        }


        private void LinQ()
        {
            int[] numbers  = {1, 2, 3, 4, 5, 6};        //数组
            var   numFirst = numbers.First(i => i > 3); //返回满足条件的第一个数据元素
            print(numFirst);                            //输出 4
        }
    }
}

打印输出：
在这里插入图片描述

4. Distinct —— 找不同


Distinct —— 数据/事件中的不同元素通过，相同元素被剔除


如：1122334 经过剔除，会变成 1234

举个例子

剔除Update事件流中相同的事件

找到数字列表中不同的数字

public class Chinar_Distinct : MonoBehaviour
{
    /// <summary>
    /// 初始化函数
    /// </summary>
    void Start()
    {
        int count = 0;
        //只输出一次0，因为之后的事件流，都重复了（这里剔除的是相同的事件流，而不是数字）
        this.UpdateAsObservable().Distinct().Subscribe(_ => print("在 Update 事件中" + ++count + " 次数"));
        LinQ();
    }


    private void LinQ()
    {
        //一个数据列表，并添加数据
        List<int> ints = new List<int>()
        {
            1, 2, 3, 2, 3, 4, 5, 6, 7, 8, 9, 10
        };
        ints.Distinct().ToList().ForEach(_ => print(_)); //遍历输出，剔除后的列表
    }
}

打印输出：
在这里插入图片描述

5. Last —— 找不同


Last —— 最后一个元素

举个例子

找到狗狗中的最后一个/满足条件狗狗中的最后一个

using System.Collections.Generic;
using System.Linq;
using ChinarX.LinQ;
using UniRx;
using UnityEngine;


public class Chinar_Last : MonoBehaviour
{
    void Start()
    {
        List<Dog> dogs = new List<Dog>()//该数据用的是 1 中写好的数据
        {
            new Dog("金毛",  2000, 62),
            new Dog("二哈",  1500, 45),
            new Dog("泰迪",  1000, 15),
            new Dog("吉娃娃", 500,  10)
        };
        Dog dog = dogs.Last();                     //最后一个
        print(dog.ToString());                     //：吉娃娃
        Dog dog1 = dogs.Last(_ => _.Price > 1000); //传入条件：价格在 1000以上 的狗中的最后一个
        print(dog1.ToString());                    //：二哈
    }
}

打印输出：

Name: 吉娃娃, Price: 500, Weight: 10

Name: 二哈, Price: 1500, Weight: 45

6. Last —— 找不同


Last —— 最后一个元素

举个例子

找到狗狗中的最后一个/满足条件狗狗中的最后一个

using System.Collections.Generic;
using System.Linq;
using ChinarX.LinQ;
using UniRx;
using UnityEngine;


public class Chinar_Last : MonoBehaviour
{
    void Start()
    {
        List<Dog> dogs = new List<Dog>()//该数据用的是 1 中写好的数据
        {
            new Dog("金毛",  2000, 62),
            new Dog("二哈",  1500, 45),
            new Dog("泰迪",  1000, 15),
            new Dog("吉娃娃", 500,  10)
        };
        Dog dog = dogs.Last();                     //最后一个
        print(dog.ToString());                     //：吉娃娃
        Dog dog1 = dogs.Last(_ => _.Price > 1000); //传入条件：价格在 1000以上 的狗中的最后一个
        print(dog1.ToString());                    //：二哈
    }
}

打印输出：

Name: 吉娃娃, Price: 500, Weight: 10

Name: 二哈, Price: 1500, Weight: 45

5

Coroutine —— 协程


Observable.FromCoroutine(协程函数) —— 协程转 Observable

Observable.Timer(TimeSpan.FromSeconds(1)).ToYieldInstruction() —— Observable 转 Yield
举个例子

    void Start()
    {
        Observable.FromCoroutine(TestIEnumerator); //协程转 Observable
    }


    private IEnumerator TestIEnumerator()
    {
        yield return Observable.Timer(TimeSpan.FromSeconds(1)).ToYieldInstruction(); // 转 指令、
        print("Chinar Test-Func");
    }

6

WhenAll —— 等待执行完毕


Where() —— 当多个事件流，需要根据逻辑满足所有都执行后，才触发执行
举个例子

1：等待2个协程执行完毕
2：当所有事件执行完毕后

    void Start()
    {
        //第一种：等待协程都执行完毕
        var streamA = Observable.FromCoroutine(A);
        var streamB = Observable.FromCoroutine(B);
        Observable.WhenAll(streamA, streamB).Subscribe(_ => print("WenAll执行成功！"));

        //第二种：所有操作执行一次后，执行以下订阅
        var event1 = this.UpdateAsObservable().Where(_ => Input.GetMouseButtonDown(0)).First();
        var event2 = this.UpdateAsObservable().Where(_ => Input.GetMouseButtonDown(1)).First();
        Observable.WhenAll(event1, event2).Subscribe(_ => print("左右键执行一次后，执行操作！"));
    }


    IEnumerator A()
    {
        yield return new WaitForSeconds(1);
        print("A");
    }


    IEnumerator B()
    {
        yield return new WaitForSeconds(2);
        print("B");
    }

7

Thread —— 线程


Observable.Start() —— 开启一个线程

ObserveOnMainThread() —— 线程结果返回到主线程中，在主线程中观察
举个例子

    void Start()
    {
        var stream1 = Observable.Start(() =>
        {
            Thread.Sleep(5000);//5000毫秒
            print("等待了5秒");
            return 1;
        }); //线程1
        var stream2 = Observable.Start(() =>
        {
            Thread.Sleep(TimeSpan.FromSeconds(2));
            print("等待2秒");
            return 2;
        }); //线程2

        
        Observable.WhenAll(stream1, stream2).ObserveOnMainThread().Subscribe(_ => //当线程执行完毕，将其他线程中的值，返回到主线程中
        {
            print(_[0]);
            print(_[1]);
        });
    }

执行顺序
在这里插入图片描述

8

ObservableWWW —— RX-WWW请求


new ScheduledNotifier<float>() —— 声明一个预定进度对象

ObserveOnMainThread() —— 线程结果返回到主线程中，在主线程中观察
举个例子

        //第一个 print，请求正常信息
        //第二个 print，错误信息
        ObservableWWW.Get("http://www.chinar.xin/asdf").Subscribe(print, print);//请求一个错误的网路地址

    void Start()
    {
        var slider           = GameObject.Find("Slider").GetComponent<Slider>();                                                                    //滑动器
        var progressText     = GameObject.Find("ProgressText").GetComponent<Text>();                                                                //进度条文本
        var progressNotifier = new ScheduledNotifier<float>();                                                                                      //RX 预定通知 float
        ObservableWWW.GetAndGetBytes("http://www.chinar.xin/TestUpdate/granulesprite.unity3d", progress: progressNotifier).Subscribe(bytes => { }); //下载完成，做储存
        progressNotifier.Subscribe(progressFloat => { slider.value = progressFloat; });                                                             //更新进度
        progressNotifier.SubscribeToText(progressText);                                                                                             //进度值显示在 progressText
    }

在这里插入图片描述

7

Thread —— 线程


Observable.Start() —— 开启一个线程

ObserveOnMainThread() —— 线程结果返回到主线程中，在主线程中观察
举个例子

    void Start()
    {
        var stream1 = Observable.Start(() =>
        {
            Thread.Sleep(4000);//4000毫秒
            print("等待了4秒");
            return 1;
        }); //线程1
        var stream2 = Observable.Start(() =>
        {
            Thread.Sleep(TimeSpan.FromSeconds(2));
            print("等待2秒");
            return 2;
        }); //线程2

        
        Observable.WhenAll(stream1, stream2).ObserveOnMainThread().Subscribe(_ => //当线程执行完毕，将其他线程中的值，返回到主线程中
        {
            print(_[0]);
            print(_[1]);
        });
    }

执行顺序
在这里插入图片描述

7

Thread —— 线程


Observable.Start() —— 开启一个线程

ObserveOnMainThread() —— 线程结果返回到主线程中，在主线程中观察
举个例子

    void Start()
    {
        var stream1 = Observable.Start(() =>
        {
            Thread.Sleep(4000);//4000毫秒
            print("等待了4秒");
            return 1;
        }); //线程1
        var stream2 = Observable.Start(() =>
        {
            Thread.Sleep(TimeSpan.FromSeconds(2));
            print("等待2秒");
            return 2;
        }); //线程2

        
        Observable.WhenAll(stream1, stream2).ObserveOnMainThread().Subscribe(_ => //当线程执行完毕，将其他线程中的值，返回到主线程中
        {
            print(_[0]);
            print(_[1]);
        });
    }

执行顺序
在这里插入图片描述

7

Thread —— 线程


Observable.Start() —— 开启一个线程

ObserveOnMainThread() —— 线程结果返回到主线程中，在主线程中观察
举个例子

    void Start()
    {
        var stream1 = Observable.Start(() =>
        {
            Thread.Sleep(4000);//4000毫秒
            print("等待了4秒");
            return 1;
        }); //线程1
        var stream2 = Observable.Start(() =>
        {
            Thread.Sleep(TimeSpan.FromSeconds(2));
            print("等待2秒");
            return 2;
        }); //线程2

        
        Observable.WhenAll(stream1, stream2).ObserveOnMainThread().Subscribe(_ => //当线程执行完毕，将其他线程中的值，返回到主线程中
        {
            print(_[0]);
            print(_[1]);
        });
    }

执行顺序
在这里插入图片描述

7

Thread —— 线程


Observable.Start() —— 开启一个线程

ObserveOnMainThread() —— 线程结果返回到主线程中，在主线程中观察
举个例子

    void Start()
    {
        var stream1 = Observable.Start(() =>
        {
            Thread.Sleep(4000);//4000毫秒
            print("等待了4秒");
            return 1;
        }); //线程1
        var stream2 = Observable.Start(() =>
        {
            Thread.Sleep(TimeSpan.FromSeconds(2));
            print("等待2秒");
            return 2;
        }); //线程2

        
        Observable.WhenAll(stream1, stream2).ObserveOnMainThread().Subscribe(_ => //当线程执行完毕，将其他线程中的值，返回到主线程中
        {
            print(_[0]);
            print(_[1]);
        });
    }

执行顺序
在这里插入图片描述

7

Thread —— 线程


Observable.Start() —— 开启一个线程

ObserveOnMainThread() —— 线程结果返回到主线程中，在主线程中观察
举个例子

    void Start()
    {
        var stream1 = Observable.Start(() =>
        {
            Thread.Sleep(4000);//4000毫秒
            print("等待了4秒");
            return 1;
        }); //线程1
        var stream2 = Observable.Start(() =>
        {
            Thread.Sleep(TimeSpan.FromSeconds(2));
            print("等待2秒");
            return 2;
        }); //线程2

        
        Observable.WhenAll(stream1, stream2).ObserveOnMainThread().Subscribe(_ => //当线程执行完毕，将其他线程中的值，返回到主线程中
        {
            print(_[0]);
            print(_[1]);
        });
    }

执行顺序
在这里插入图片描述

支持

May Be —— 开发者，总有一天要做的事！


拥有自己的服务器，无需再找攻略

Chinar 提供一站式《零》基础教程

使有限时间 具备无限可能！

Chinar 知你所想，予你所求！( Chinar Blog )

Chinar
END

本博客为非营利性个人原创，除部分有明确署名的作品外，所刊登的所有作品的著作权均为本人所拥有，本人保留所有法定权利。违者必究

对于需要复制、转载、链接和传播博客文章或内容的，请及时和本博主进行联系，留言，Email: ichinar@icloud.com

对于经本博主明确授权和许可使用文章及内容的，使用时请注明文章或内容出处并注明网址

Chinarcsdn
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
UniRx：适用于Unity的React性扩展
02-06
UniRx-适用于Unity的React性扩展 由河井义文（neuecc）创建 什么是UniRx？ UniRx（Unity的React式扩展）是.NETReact式扩展的重新实现。 Official Rx实现很棒，但是在Unity上不起作用，并且与iOS IL2CPP兼容性存在问题。 该库解决了这些问题，并为Unity添加了一些特定的实用程序。 支持的平台是PC / Mac / Android / iOS / WebGL / WindowsStore / etc和库。 UniRx可通过Unity资源商店（免费） - 博客以获取更新信息-https: Unity论坛上的支持线程：问我
【Unity3D插件】UniRx（基于Unity的响应式编程框架）插件学习
qq_38721111的博客
02-21 2598
UniRx是一种基于Unity3D的响应式编程框架。UniRx就是Unity版本的Rx响应式扩展响应式就是观察者和定时器，扩展指的是LINQ的操作符。Rx响应式扩展的特点就是擅长处理时间上的异步的逻辑。用Rx响应式扩展的方式编程可以很好地组织大量异步与并行处理。UniRx重写了.Net的响应式扩展，主要作用是解决时间上异步的逻辑，让异步逻辑变得更加简洁和优雅。Unity3D通常是单线程，但是UniRx可以让多线程更容易。UniRx可以简化 UGUI 的编程，所有的UI事件可以转化为UniRx的事件流。
UniRx（1）——简介
卐DIAX卍
03-30 1484
目录前言响应式编程可观察序列 前言 UniRx，顾名思义就是Unity上的ReactiveX（Rx）。Unity就很好理解了，可是这个Rx又是哪路神仙？找到Rx的官方简介，大概意思是：ReactiveX是一个通过可观察序列来综合异步编程和事件编程的库。 这句话回答了很多问题：首先它是一个库，其次它的作用是简化异步编程和事件编程，使用的手段是可观察序列。 于是，我们现在已经对Rx有了一个比较模糊的认...
UniRx官方入门文档
热门推荐
Sun.ME的博客
10-02 1万+
UniRx官方入门文档;Unity中的响应式编程框架;UniRx基础教程；UniRx入门教程；UniRx初学者教程
在Unity中使用Linq的注意事项
穿裤子的云
03-15 5279
linq是函数式编程，代码简洁，符合人类的逻辑，抽象度高，代码量少，代码好维护，特别适合数据处理。但是网上有不少争议......
C#使用LINQ查询表达式的基本子句总结
09-02
主要介绍了C#使用LINQ查询表达式的基本子句总结,在C#程序中我们可以使用LINQ基本查询表达式模式来查询和转换SQL数据库、ADO.NET数据集、XML文档和流以及.NET集合中的数据,需要的朋友可以参考下
c# 动态构建LINQ查询表达式
01-19
作者：精致码农 ... 最近工作中遇到一个这样的...如果只有一两个这样的数字列，那么使用 Entity Framework Core 可以这么写 LINQ 查询： public Task<List>> GetProductsAsync(string propertyToFilter, MathOperator ma
Serialize.Linq：C＃库用于序列化LINQ表达式
02-03
Serialize.Linq是用于序列化linq表达式的ac＃库。 它支持（但不限于）的格式为JSON，XML和BINARY。 安装 通过简单安装： PM> Install-Package Serialize.Linq 建立源 git clone ...
【UniRx】第一季：入门精讲
qq_41603955的博客
08-17 1482
前提：本人用的Unity2019.3.0f3，从AssetStore上直接下的UniRx 7.1.0;（摘自凉鞋） 一、UniRx简介 UniRx 是⼀一个 Unity3D 的编程框架。 专注于解决异步逻辑，使得异步逻辑的实现更更加简洁优雅。 简洁优雅如何体现? ⽐比如，实现⼀一个”只处理理第⼀一次⿏鼠标点击事件”这个功能，使⽤用 UniRx 实现如下： void Start() { Observable.EveryUpdate()
unity C# 中通俗易懂LINQ使用案例
最新发布
qqrrjj2011的博客
01-02 1518
​C# 中的 LINQ（Language Integrated Query，语言集成查询）允许开发者使用一种声明性的方式来查询和操作数据集合。
Unity C# LINQ语法
XHW1995的博客
11-22 250
C# LINQ（Language-Integrated Query）语言在unity中的用法
UniRx入门系列（一）
Sun.ME的博客
09-09 5670
Unity UniRx入门系列（一），Unity中的响应式编程概要。unirx初学者教程，unirx入门系列
02.UniRx序列（UniRx对游戏有什么用）
Unity3d 攻城师一枚
11-09 3495
UniRX在游戏里面的表现呢？ 学习一个技术，我们最关心的是它能不能给我们带来实际的效率，方便；做Unity的选择挺多的，大把的第三方插件；各种可视化工具，多到都不知道去挑哪一个来用；我并去推荐大家去使用什么插件，工具，这是一个双刃剑，既有方便也有不方便；方便的是你自己，痛苦的是那些不会的人和以后维护的人；插件一般使用的技术比较新，对系统有到一定的要求，因为不是自己写的东西；有可能插件出现的问题会...
UniRx入门系列（四）
Sun.ME的博客
09-16 2280
Unity UniRx入门系列（四），Unity中的响应式编程概要，unirx入门系列，unirx初学者教程
Unity Linq 常用用法记录
_Afra 的博客
12-28 920
ALL用法：用于判断一个集合中的所有元素是否都满足某一条件，返回true或者false public List<FirstGameFloorBtn> FirstGameFloorBtns = new List<FirstGameFloorBtn>(); public void CheckAllBtnInteractable() { Debug.Log(FirstGameFloorBtns.All(_ => _.Ca..
Unity——λ表达式(匿名函数)/Linq/回调函数
leikang111的博客
03-23 1011
有关C#中的λ表达式，Linq，回调函数的解释
Unity UniRX中文教程-Chinar
ChinarCSDN的博客
12-28 5444
Chinar blog ：www.chinar.xin UnitRx 响应式编程 本文提供全流程，中文翻译。 Chinar 坚持将简单的生活方式，带给世人！（拥有更好的阅读体验 —— 高分辨率用户请根据需求调整网页缩放比例） Chinar —— 心分享、心创新！助力学习理解 UniRx 响应式编程的函数、写法为新手节省宝贵的时间，避免采坑！ Chinar 教程效果...
22.UniRx专题（UniTask异步新特性）
Unity3d 攻城师一枚
12-24 1万+
什么是UniTask 一般什么情况下使用UniTask UniTask和UniRx什么关系 UniTask API UniTaskTracker 可视化任务 什么是UniTask UniTask是基于C# 5的async和await异步定制的一套Unity优化的异步解决方案；需要Unity2017以上的版本，并且需要升级c#库， 但并不如UniRx项目提供的更为轻量级，可是UniTask拥有...
UniRx之基础入门
Passion 的博客
02-03 688
官方ReactiveX简介：通过这句话我们可以得到：1.首先Rx是个编程接口，不同语言提供不同实现。例如JVM语言中的RxJava。2.使用场景，异步编程中。3.基于可观察的事件流。我们主要解释下事件流：Rx中把所有的事件都通过流的形式来处理，不通的操作符，相当于不通的流处理方式。最终筛选出我们需要的流。UniRx(Unity的响应式编程框架)是.Net响应式编程框架的重新实现版本。官方的Rx的实现方式是非常棒的。但是，在Unity中使用会有一些问题；
对LINQ查询表达式进行联接操作时，需要使用什么关键字？
06-10
在 LINQ 查询表达式中，进行联接操作需要使用 `join` 关键字。`join` 关键字可以用来将两个或多个数据源中的元素进行联接，生成一个新的序列。`join` 关键字通常与 `on` 关键字一起使用，用来指定联接的条件。 下面是一个使用 `join` 关键字进行联接操作的示例： ``` var query = from order in orders join customer in customers on order.CustomerID equals customer.CustomerID select new { OrderID = order.OrderID, CustomerName = customer.CustomerName }; ``` 在上面的代码中，`orders` 和 `customers` 是两个数据源，`join` 和 `on` 关键字用来将这两个数据源进行联接，生成一个新的序列。该查询语句将 `orders` 中的 `CustomerID` 字段和 `customers` 中的 `CustomerID` 字段进行比较，如果相等，则将两个数据源中的元素联接起来，并生成一个新的匿名类型序列，该序列包含 `OrderID` 和 `CustomerName` 两个字段。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值