常用类

数组/集合工具类（应用泛型委托）

using System;
using System.Collections.Generic;

//Array.Sort()不支持类对象
//arr.OrderBy((a) => a).ToArray()  //不支持IOS平台 
    //eg:Student []arr2 =  arr.OrderBy((x)=>x.id).ToArray();

/// <summary>  
/// 选择委托：从一个对象中选择某个属性，返回属性的值
/// </summary>
/// <typeparam name="T">对象的类型</typeparam>
/// <typeparam name="TKey">对象的某个属性</typeparam>
/// <param name="t">对象</param>
/// <returns>对象的某个属性的值</returns>
public delegate TKey SelectHandler<T, TKey>(T t);
/// <summary>
/// 查询委托
/// </summary>
/// <typeparam name="T">对象的类型</typeparam>
/// <param name="t">对象的某个属性</param>
/// <returns>bool结果</returns>
public delegate bool FindHandler<T>(T t);
/// <summary>
/// 数组助手类：数组工具类 封装一些项目常用的操作数组的方法
/// 通用性，方便使用，跨平台【平台兼容性】 
/// -tarena 1.0
/// 2.0 by cle.... 
/// </summary>
public class ArrayHelper
{
    /// <summary>
    /// 升序排列，从小到大
    /// </summary>
    /// <typeparam name="T">对象的类型</typeparam>
    /// <typeparam name="TKey">对象的某个属性</typeparam>
    /// <param name="arr">对象数组</param>
    /// <param name="handler">委托对象</param>
    public static void OrderBy<T, TKey>(T[] arr, SelectHandler<T, TKey> handler)
        where TKey : IComparable, IComparable<TKey>
    {
        for (int i = 0; i < arr.Length - 1; i++)
        {
            for (int j = i + 1; j < arr.Length; j++)
            {
                if (handler(arr[i]).CompareTo(handler(arr[j])) > 0)
                {
                    T temp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = temp;
                }
            }
        }
    }

    /// <summary>
    /// 降序排列 从大到小
    /// </summary>
    /// <typeparam name="T">对象的类型</typeparam>
    /// <typeparam name="TKey">对象的某个属性</typeparam>
    /// <param name="arr">对象数组</param>
    /// <param name="handler">委托对象</param>
    public static void OrderByDescending<T, TKey>(T[] arr, SelectHandler<T, TKey> handler)
        where TKey : IComparable, IComparable<TKey>
    {
        for (int i = 0; i < arr.Length - 1; i++)
        {
            for (int j = i + 1; j < arr.Length; j++)
            {
                if (handler(arr[i]).CompareTo(handler(arr[j])) < 0)
                {
                    T temp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = temp;
                }
            }
        }
    }

    /// <summary>
    /// 找最大 对象
    /// </summary>
    /// <typeparam name="T">对象的类型</typeparam>
    /// <typeparam name="TKey">对象的某个属性</typeparam>
    /// <param name="arr">对象数组</param>
    /// <param name="handler">委托对象</param>
    public static T Max<T, TKey>(T[] arr, SelectHandler<T, TKey> handler)
        where TKey : IComparable, IComparable<TKey>
    {
        T t = arr[0];
        for (int i = 1; i < arr.Length; i++)
        {
            if (handler(arr[i]).CompareTo(handler(t)) > 0)
            {
                t = arr[i];
            }
        }
        return t;
    }
    /// <summary>
    /// 找最小 对象
    /// </summary>
    /// <typeparam name="T">对象的类型</typeparam>
    /// <typeparam name="TKey">对象的某个属性</typeparam>
    /// <param name="arr">对象数组</param>
    /// <param name="handler">委托对象</param>
    public static T Min<T, TKey>(T[] arr, SelectHandler<T, TKey> handler)
        where TKey : IComparable, IComparable<TKey>
    {
        T t = arr[0];
        for (int i = 1; i < arr.Length; i++)
        {
            if (handler(arr[i]).CompareTo(handler(t)) < 0)
            {
                t = arr[i];
            }
        }
        return t;
    }
    
    /// <summary>
    /// 查找 集合中符合条件的一个对象
    /// </summary>
    /// <typeparam name="T">数据类型</typeparam>
    /// <param name="arr">对象集合</param>
    /// <param name="handler">查找条件</param>
    /// <returns>一个对象或null</returns>
    public static T Find<T>(T[] arr, FindHandler<T> handler)
    {
        T t = default(T);
        for (int i = 0; i < arr.Length; i++)
        {
            if (handler(arr[i]))
            {
                t = arr[i];
                return t;
            }
        }
        return t;
    }
    /// <summary>
    ///  查找 集合中符合条件的一个对象
    /// </summary>
    /// <typeparam name="T">数据类型</typeparam>
    /// <param name="arr">集合对象</param>
    /// <param name="handler">查找条件</param>
    /// <returns>符合条件的所有对象</returns>
    public static T[] FindAll<T>(T[] arr, FindHandler<T> handler)
    {
        List<T> list = new List<T>();
        for (int i = 0; i < arr.Length; i++)
        {
            if (handler(arr[i]))
            {
                list.Add(arr[i]);
            }
        }
        return list.ToArray();
    }   
    /// <summary>
    /// 从原来对象集合中 提取每个对象的某个属性值做成一个新的数组
    /// </summary>
    /// <typeparam name="T">对象类型</typeparam>
    /// <typeparam name="TKey">对象的某个属性的类型</typeparam>
    /// <param name="arr">对象集合</param>
    /// <param name="handler">选择条件委托</param>
    /// <returns>属性值集合</returns>
    public static TKey[] Select<T, TKey>(T[] arr, SelectHandler<T, TKey> handler)
    {
        TKey[] arrNew = new TKey[arr.Length];
        for (int i = 0; i < arr.Length; i++)
        {
            arrNew[i] = handler(arr[i]);
        }
        return arrNew;
    }
    //8 工作中积累......
}

组件助手类

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

/// <summary>
/// Transform组件助手类
/// </summary>
class TransformHelper
{
    /// <summary>
    /// 面向目标方向
    /// </summary>
    /// <param name="targetDirection">目标方向</param>
    /// <param name="transform">需要转向的对象</param>
    /// <param name="rotationSpeed">转向速度</param>
    public static void LookAtTarget(Vector3 targetDirection, Transform transform,float rotationSpeed)
    {
        if (targetDirection != Vector3.zero)
        {
            var targetRotation = Quaternion.LookRotation(targetDirection, Vector3.up);
            transform.rotation = Quaternion.Lerp(transform.rotation, targetRotation, rotationSpeed);
        }
    }

    /// <summary>
    /// 查找子物体（递归查找）
    /// </summary>
    /// <param name="trans">父物体</param>
    /// <param name="goName">子物体的名称</param>
    /// <returns>找到的相应子物体</returns>
    public static Transform FindChild(Transform trans, string goName)
    {
        Transform child = trans.FindChild(goName);
        if (child != null)
            return child;

        Transform go = null;
        for (int i = 0; i < trans.childCount; i++)
        {
            child = trans.GetChild(i);
            go = FindChild(child, goName);
            if (go != null)
                return go;
        }
        return null;
    }
}

 单例类

/// <summary>
/// Generic Mono singleton.
/// </summary>
using UnityEngine;

namespace Develop
{
    public abstract class MonoSingleton<T> : MonoBehaviour where T : MonoSingleton<T>{
        
        private static T m_Instance = null;
        
        public static T instance{
            get{
                if( m_Instance == null ){
                    m_Instance = GameObject.FindObjectOfType(typeof(T)) as T;
                    if( m_Instance == null ){
                        m_Instance = new GameObject("Singleton of " + typeof(T).ToString(), typeof(T)).GetComponent<T>();
                         m_Instance.Init();
                    }
                   
                }
                return m_Instance;
            }
        }

        private void Awake(){
       
            if( m_Instance == null ){
                m_Instance = this as T;
            }
        }
     
        public virtual void Init(){}
     

        private void OnApplicationQuit(){
            m_Instance = null;
        }
    }
}

 对象池

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

//单例模式
namespace ARPGSimpleDemo.Common
{ 
    //对象池
    public class GameObjectPool : MonoSingleton<GameObjectPool>
    {
        /// <summary>可能存放多个种类的对象，每个种类有多个对象 </summary>
        private Dictionary<string,List<GameObject>> cache = new Dictionary<string,List<GameObject>>();
       
        /// <summary>增加物体进入池(按类别增加)</summary>
        public void Add(string key, GameObject go)
        {
            //1.如果key在容器中存在，则将go加入对应的列表
            //2.如果key在容器中不存在，是先创建一个列表，再加入
            if (!cache.ContainsKey(key))
                cache.Add(key, new List<GameObject>());
            cache[key].Add(go);
        }

        /// <summary>销毁物体(将对象隐藏)</summary>
        public void MyDestory(GameObject destoryGo)
        {
            //设置destoryGo隐藏
            destoryGo.SetActive(false);
        }

        /// <summary>将对象归入池中<summary>
        public void MyDestory(GameObject tempGo, float delay)
        {
            //开启一个协程
            StartCoroutine(DelayDestory(tempGo,delay));
        }

        /// <summary>延迟销毁</summary>
        private IEnumerator DelayDestory(GameObject destoryGO, float delay)
        {
            //等待一个延迟的时间
            yield return new WaitForSeconds(delay);
            MyDestory(destoryGO);
        }

        /// <summary>取出可用的物体（已经隐藏的）</summary>
        public GameObject FindUsable(string key)
        {
            //1.在容器中找出key对应的列表，从列表中找出已经为隐藏状态的对象，返回
            if(cache.ContainsKey(key))
                foreach (GameObject item in cache[key])
                {
                    if (!item.activeSelf)
                        return item;
                }
            return null;
        }

        /// <summary>创建一个游戏物体到场景 </summary>
        public GameObject CreateObject(string key, GameObject go, Vector3 position, Quaternion quaternion)
        {
            //先找是否有可用的，如果没有则创建，如果有找到后设置好位置，朝向再返回
            GameObject tempGo = FindUsable(key);
            if (tempGo != null)
            {
                tempGo.transform.position = position;
                tempGo.transform.rotation = quaternion;
                tempGo.SetActive(true);
            }
            else
            {
                tempGo= GameObject.Instantiate(go, position, quaternion) as GameObject;
                Add(key, tempGo);
            }
            return tempGo;

        }

        /// <summary>清空某类游戏对象</summary>
        public void Clear(string key)
        {
            cache.Remove(key);
        }

        /// <summary>清空池中所有游戏对象</summary>
        public void ClearAll()
        {
            cache.Clear();
        }

       
    }
}