C#语法进阶

前言

• 最近工作需要看以前项目的代码，然后在阅读代码的过程中，发现了一些别人对于C#语法的灵活使用，所以特此记录一下。
• 这里相当于一个总结帖子

单例

• 解释一下
• SyncRoot是为了加锁，避免多线程的时候创建多个对象
• 对于每一个需要单例的对象类型，只要将T替换，然后获取SingleTon就可以了
• TSingleton<PiggyManager>.Singleton.这些类型必须要具有私有构造方法
• 也可以继承对应类型的TSingleton,然后获取对应的Singleton即可
• public class GoodsManager : TSingleton<GoodsManager> GoodsManager.Singleton.isPlayFilm = true;

  public class TSingleton<T>
    {
        public static readonly Type[] EmptyTypes;
        private static T s_Instance;
        private static object SyncRoot;

        static TSingleton()
        {
            TSingleton<T>.SyncRoot = new object();
            TSingleton<T>.EmptyTypes = new Type[0];
        }

        public static T Singleton
        {
            get
            {
                if (TSingleton<T>.s_Instance == null)
                {
                    object syncRoot = TSingleton<T>.SyncRoot;
                    lock (syncRoot)
                    {
                        if (TSingleton<T>.s_Instance == null)
                        {
                            ConstructorInfo info = typeof(T).GetConstructor(BindingFlags.NonPublic | BindingFlags.Instance, null, TSingleton<T>.EmptyTypes, null);
                            if (info == null)
                            {
                                throw new InvalidOperationException("class must contain a private constructor, if it inheritance from MonoBehaviour please use Singleton");
                            }
                            TSingleton<T>.s_Instance = (T) info.Invoke(null);
                        }
                    }
                }
                return TSingleton<T>.s_Instance;
            }
        }
    }

编辑器代码

• 项目中策划需要编辑器来使用关卡
• UIBase是基类各个UI组件的基类，EditorModuleBase是各个模块的基类
• UI组件一共有以下几种
• UIText，UIImage，UIBlockBoard，UIButton，UIToggle，UIScrollview
• 在实例化这些组件的时候，需要指明pos，size，color，等设置。构造方法里面会从预制体里面自动加载对应的组件进行实例化。
• 当选中其中一层的时候，就把其余层的半透明

序列化

• unity自身有一个JsonUtility方法可以对可序列化对象进行序列化
• [Serializable]是标明这个是可以序列化的
• Unity自身的序列化只能序列公共字段，对于私有字段[需要标明SerializeField才会被序列化]
• 如果对于某些字段不想序列化，可以标注[NonSerialized]
• List，数组，基本数据类型，以及继承Unity.object的可以进行序列化，字典不能序列化

  [Serializable]
    public class BundleManifest : ISerializationCallbackReceiver
    {
        /// <summary>
        /// Convert from JSON string to BundleManifest object.
        /// </summary>
        /// <param name="json"></param>
        /// <returns></returns>
        public static BundleManifest Parse(string json)
        {
            return JsonUtility.FromJson<BundleManifest>(json);
        }

        [SerializeField]
        private BundleInfo[] bundleInfos = null;
        [SerializeField]
        private string defaultVariant = "";
        [SerializeField]
        private string version;

        [NonSerialized]
        private string[] activeVariants;
        [NonSerialized]
        private Dictionary<string, BundleInfo> bundles = new Dictionary<string, BundleInfo>();

 		 /// <summary>
        ///  Gets the version of the AssetBundle data.
        /// </summary>
        public virtual string Version { get { return this.version; } }

动态创建画布

  void CreateUIRoot( )
        {
            _globalUI = new GameObject("[GlobalUI_Root]");
            GameObject.DontDestroyOnLoad( _globalUI );

            //画布
            GameObject canObj = new GameObject("GlobalCanavs");
            canObj.transform.SetParent( _globalUI.transform, false );
            canObj.layer = LayerMask.NameToLayer( "UI" );
            _canvas = canObj.AddComponent<Canvas>( );
            _canvas.renderMode = RenderMode.ScreenSpaceCamera;
            _canvas.worldCamera = Camera.main;
            _canvas.planeDistance = 10;
            _canvas.sortingOrder = 20;

            //画布适配器
            _canvasScaler = canObj.AddComponent<CanvasScaler>();
            _canvasScaler.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize;
            _canvasScaler.referenceResolution = new Vector2( ReferenceScreenWidth, ReferenceScreenHeight );
            canObj.AddComponent<GraphicRaycaster>();

            //事件
            //GameObject evtObj = new GameObject("EventSystem");
            //evtObj.transform.SetParent( _globalUI.transform, false );
            //_eventSystem = evtObj.AddComponent<EventSystem>();
            evtObj.AddComponent<TouchInputModule>();
            //evtObj.AddComponent<StandaloneInputModule>();

            //层级
            foreach( UILayer layer in Enum.GetValues(typeof(UILayer)) )
            {
                GameObject obj = new GameObject(layer.ToString());
                obj.transform.SetParent(canObj.transform, false);
                RectTransform rt = obj.AddComponent<RectTransform>();
                obj.layer = LayerMask.NameToLayer("UI");
                rt.anchorMin = Vector2.zero;
                rt.anchorMax = Vector2.one;
                rt.sizeDelta = Vector2.zero;

                layerMap.Add(layer, obj.transform);

对于字典的迭代循环

  var iter = this._sideShakeCells.GetEnumerator();
            while( iter.MoveNext() )
            {
                Grid grid = iter.Current.Key;
                if( grid != null  && grid.enabled )
                {
                    var piece = grid.middlePiece;
                    if( piece != null && !piece.isShaking && !piece.isDroping )
                        piece.ShakeSlightly(iter.Current.Value, isBomb, isNormalEliminate);
                }
            }

Predicate的使用

  /// <summary>
        /// 获取普通棋子
        /// </summary>
        /// <returns></returns>
        public List<BasePiece> GetNormalPieceList( )
        {
            return GetPieceList(( piece ) => piece.name.Equals("normal"));
        }


        public List<BasePiece> GetPieceList( Predicate<BasePiece> match )
        {
            List<BasePiece> list = new List<BasePiece>();
            for( int i = 0; i < getLevelConfig().getColumn(); i++ )
            {
                for( int j = 0; j < getLevelConfig().getRow(); j++ )
                {
                    if( ( getLevelConfig().isValid(i, j) && ( m_grids[i, j].getHighestPiece() != null ) ) &&
                        ( !m_grids[i, j].isObstacle() && match( m_grids[i,j].getHighestPiece()) ))
                    {
                        list.Add(m_grids[i, j].getHighestPiece());
                    }
                }
            }
            return list;
        }

Canvas 可以用来调整层级