咖啡丶七

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
 
public class Test : MonoBehaviour {
 
    private float alpha0 = 0.0f;
 
    private float alphaSpeed = 2.0f;
    bool isShow;
 
    private CanvasGroup cg;
 
	void Start () {
        cg = this.transform.GetComponent<CanvasGroup>();
	}
	
	void Update ()
    {
        if (!isShow)
        {
            cg.alpha = Mathf.Lerp(cg.alpha, alpha0, alphaSpeed * Time.deltaTime);
            if (Mathf.Abs(alpha0 - cg.alpha) <= 0.01)
            {
                isShow = true;
                cg.alpha = alpha0;
                alpha0 = 1;
            }
        }
        else
        {
            //*0.5是因为从隐藏当显示感觉很快
            cg.alpha = Mathf.Lerp(cg.alpha, alpha0, alphaSpeed * Time.deltaTime * 0.5f);
            if (Mathf.Abs(alpha0 - cg.alpha) <= 0.01)
            {
                isShow = false;
                cg.alpha = alpha0;
                alpha0 = 0;
            }
        }
	}
 
}

# true：在UI上，false：不在UI上
# 受GraphicRaycaster组件影响，鼠标在未激活GraphicRaycaster的canvas上时返回false
bool isOn = UnityEngine.EventSystems.EventSystem.current.IsPointerOverGameObject()

void Start()
{
  Debug.Log(Mathf.Lerp(0, 100, 0).ToString());
  Debug.Log(Mathf.Lerp(0, 100, 0.1f).ToString());
  Debug.Log(Mathf.Lerp(0, 100, 0.2f).ToString());
  Debug.Log(Mathf.Lerp(0, 100, 0.3f).ToString());
  Debug.Log(Mathf.Lerp(0, 100, 0.4f).ToString());
  Debug.Log(Mathf.Lerp(0, 100, 0.5f).ToString());
  Debug.Log(Mathf.Lerp(0, 100, 0.6f).ToString());
  Debug.Log(Mathf.Lerp(0, 100, 0.7f).ToString());
  Debug.Log(Mathf.Lerp(0, 100, 0.8f).ToString());
  Debug.Log(Mathf.Lerp(0, 100, 0.9f).ToString());
  Debug.Log(Mathf.Lerp(0, 100, 1).ToString());
}

// 结果为
// 0
// 10
// 20
// ....
// 90
// 100

void Update()
{
  transform.position = Vector3.Lerp(A, B, Time.time);
}

Vector3 vectorA = new Vector3(1, 2, 3);
Vector3 vectorB = new Vector3(4, 5, 6);

float dotProduct = Vector3.Dot(vectorA, vectorB);

// 结果输出: 32，32>0，即向量a,b的夹角为锐角
// dotProduct > 0，为锐角
// dotProduct = 0, 为直角
// dotProduct < 0, 为钝角

Vector3 vectorA = new Vector3(1, 2, 3);
Vector3 vectorB = new Vector3(4, 5, 6);

Vector3 crossProduct = Vector3.Cross(vectorA, vectorB);

// 结果输出: (3, -6, 3)

// right是(1, 0, 0)    forward是(0, 0, 1)
Vector3.Cross(Vector3.right, Vector3.forward) = (0, -1, 0)

float length = vector.magnitude;

float sqrMagnitude = vector.sqrMagnitude;

Vector3 normalizedVector = vector.normalized;

Vector3 interpolatedVector = Vector3.Lerp(startVector, endVector, t);

float distance = Vector3.Distance(vectorA, vectorB);

float angle = Vector3.Angle(vectorA, vectorB);

Vector3 projectionVector = Vector3.Project(vectorToProject, ontoVector);

Vector3 B = new Vector3(2, 2, 2);
Vector3 result = Vector3.Project(B, Vector3.forward);    // 结果为 OP(0,0,2)

Vector3 reflectionVector = Vector3.Reflect(incidentVector, normal);

private static TOut TransReflection<TIn, TOut>(TIn tIn)
{
    // 创建一个新的 TOut 实例
    TOut tOut = Activator.CreateInstance<TOut>();
    // 获取到 tIn 的类型
    var tInType = tIn.GetType();
    // 遍历 TOut 的属性
    foreach (var itemOut in tOut.GetType().GetProperties())
    {
        // 获取到 tIn 的属性
        var itemIn = tInType.GetProperty(itemOut.Name);

        if (itemIn != null)
        {
            // 将 tIn 的属性赋给 tOut 的对应属性
            itemOut.SetValue(tOut, itemIn.GetValue(tIn));
        }
    }
    return tOut;
}

public static T DeepCopy<T>(T obj)
{
    if (obj == null)
    {
        return obj;
    }
    var type = obj.GetType();
    if (obj is string || type.IsValueType)
    {
        return obj;
    }

    var result = Activator.CreateInstance(type);
    var fields = type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance);
    foreach (var field in fields)
    {
        field.SetValue(result, field.GetValue(obj));
    }
    return (T)result;
}

using System;

namespace AsyncTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Player A = new Player("A", 10);
            //Player B = A;     // 浅拷贝
            Player B = TransReflection<Player, Player>(A);      // 深拷贝
            B.Age = 20;
            Console.WriteLine($"{A.Name}   {A.Age}");
            Console.WriteLine($"{B.Name}   {B.Age}");
            Console.ReadKey();
        }
        private static TOut TransReflection<TIn, TOut>(TIn tIn)
        {
            // 创建一个新的 TOut 实例
            TOut tOut = Activator.CreateInstance<TOut>();
            // 获取到 tIn 的类型
            var tInType = tIn.GetType();
            // 遍历 TOut 的属性
            foreach (var itemOut in tOut.GetType().GetProperties())
            {
                // 获取到 tIn 的属性
                var itemIn = tInType.GetProperty(itemOut.Name);

                if (itemIn != null)
                {
                    // 将 tIn 的属性赋给 tOut 的对应属性
                    itemOut.SetValue(tOut, itemIn.GetValue(tIn));
                }
            }
            return tOut;
        }
    }
    public class Player
    {
        public string Name { get; set; }
        public int Age { get; set; }
        public Player() { }
        public Player(string name, int age)
        {
            this.Name = name;
            this.Age = age;
        }
    }
}

Task task = new Task(() => {
	// 异步操作的代码
});

Task task = Task.Run(() => {
    // 异步操作的代码
});

Task<int> task = new Task<int>(() =>{
    // 异步操作的代码，返回int类型的结果
    return 42;
});

Task<int> task = Task.Run(() => {
    // 异步操作的代码，返回int类型的结果
    return 7;
});

task.Start();

task.Wait();	// 阻塞当前线程，等待任务完成
int result = task.Result;  // 阻塞当前线程，等待任务完成，并获取结果

Task.WaitAll(new Task[]{ task1, task2 });		// 等待所有的task都执行完成再解除阻塞
Task.WaitAny(new Task[]{ task1, task2 });		// 只要有一个task执行完毕就解除阻塞

Task.WhenAll(task1, task2).ContinueWith((t) => { Console.Writeline("执行异步代码"); });	// 当task1和task2执行完毕后，再执行后续代码
Task.WhenAny(task1, task2).ContinueWith((t) => { Console.Writeline("执行异步代码"); });	// 只要有一个执行完毕，就执行后续代码

using System;
using System.Threading.Tasks;

namespace AsyncTest
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("主线程开始");

            t().Start();

            Console.WriteLine("主线程结束");

            Console.ReadKey();
        }

        private static Task t()
        {
            return new Task(async () =>
            {
                Console.WriteLine("开始执行t");
                await Task.Delay(2000);			// 等待两秒，模拟一个异步操作
                Console.WriteLine("结束执行t");
            });
        }
    }
}

using System.Threading;

void start()
{
    Thread t1 = new Thread(A);
    Thread t2 = new Thread(B);
    t1.start();
    t2.start();
}

void A()
{
    Debug.Log("我是A函数1");
    Debug.Log("我是A函数2");
}

void B()
{
    Debug.Log("我是B函数1");
    Debug.Log("我是B函数2");
}

using System.Threading;

void start()
{
    static Object o = new object();
    Thread t1 = new Thread(A);
    Thread t2 = new Thread(B);
    t1.start();
    t2.start();
    Thread t3 = new Thread(C);
    t3.start();
}

static void A()
{
    lock(o)
    {
        Debug.Log("我是A函数1");
        Debug.Log("我是A函数2");
    }
}

static void B()
{
    lock(o)
    {
        // Thread.Sleep(1000);   // 暂停1秒
        Debug.Log("我是B函数1");
        Debug.Log("我是B函数2");
    }
}

static void C()
{
    DEbug.Log("我是随机函数");
}

using UnityEngine;
using System.Collections.Generic;
using System;

public class MainThreadDispatcher : MonoBehaviour
{
    private static MainThreadDispatcher instance;

    private Queue<Action> actionQueue = new Queue<Action>();		// 初始化一个队列:先进先出的一个数据结构

    private void Awake()
    {
        if (instance == null)
        {
            instance = this;
        }
        else
        {
            Destroy(gameObject);
        }
    }

    private void Update()
    {
        lock (actionQueue)
        {
            while (actionQueue.Count > 0)
            {
                Action action = actionQueue.Dequeue();		// 取出队列中的一个函数，并执行
                action.Invoke();
            }
        }
    }

    public static void RunOnMainThread(Action action)
    {
        lock (instance.actionQueue)		// 如果有其他的代码（包括自己）使用了lock(instance.actionQueue)，则会等待前面的执行完再执行自己
        {
            instance.actionQueue.Enqueue(action);		// 将传进来的action函数插入到队列中
        }
    }
}

RunOnMainThread(() =>
{
    // 转移到主线程上执行代码
    textValue.text = "你好";
});