2.枚举，标志枚举

Enum 枚举分为简单枚举和标志枚举。简单枚举包含的值不用于组合，也不用于按位比较。标志枚举可以使用位操作符进行组合

[Flags]
public enum FileProperty
{
    Hidden = 1,
    ReadOnly = 2,
    Encrypt = 4,
}

FileAttributes attributes = File.GetAttributes(fileName);//获取特性
attributes & FileAttributes.Hidden == FileAttributes.Hidden; // 结果为true时表示存在这个属性

2022.09.15

1.有关图集打包：

对于不规则的图形打包图集时不要勾选Tight Packing(紧凑打包)，尽量调整大的Padding。否则打包后会显示不正确；但在编辑器中是正确的。因为在编辑器中读取的是单个精灵的纹理，而不是在图集中切割获取精灵纹理。
正确显示：

不正确显示：

2.Dictionary C#字典中  Add方法，TryAdd方法，与字典索引器的区别：

public static Dictionary<int, string> actDict = new();
static void Main(string[] args)
{
    actDict.Add(3, "123");
    actDict.Add(3, "abc");
    Console.WriteLine(actDict[3]);
}
//异常：System.ArgumentException:“An item with the same key has already been added. Key: 3” 提示已经存在相同的Key值

public static Dictionary<int, string> actDict = new();
static void Main(string[] args)
{
    actDict.TryAdd(2, "123");
    actDict.TryAdd(2, "abc");
    Console.WriteLine(actDict[2]);
}
//输出结果：123 

public static Dictionary<int, string> actDict = new();
static void Main(string[] args)
{
    actDict[1]="123";
    actDict[1]="abc";
    Console.WriteLine(actDict[1]);
}
//输出结果：abc

/*
try{
程序代码块；
}
catch(Exception e){
异常处理代码块；
}
finally{
无论是否发生异常，均要执行的代码块；
}
*/
//thorw后的语句不会执行。

var i = 0;
try
{
// int a;
  // string b;
  // Console.WriteLine("请输入一个整数");
  // b = Console.ReadLine();
  // a = int.Parse(b);
  throw new Exception();//在当前代码块中throw后的语句不会执行
  i += 1;
  Console.WriteLine("1:" + i);
}
catch (Exception e)
{
  // Console.WriteLine(e);
  // throw;//throw后的语句不会执行
  i += 1;
  Console.WriteLine("2:" + i);
}
finally
{
  i += 2;
  // Console.WriteLine("finally块内总是能运行到");
  Console.WriteLine("3:" + i);
}
i += 3;
Console.WriteLine("4:" + i);

using System;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args)
    {
        List<Cube> cubes = new List<Cube>();

        cubes.Add(new Cube(8, 8, 4));
        cubes.Add(new Cube(8, 4, 8));
        cubes.Add(new Cube(8, 6, 4));

        if (cubes.Contains(new Cube(8, 6, 4))) {
            Console.WriteLine("An equal cube is already in the collection.");
        }
        else {
            Console.WriteLine("Cube can be added.");
        }

        //Outputs "An equal cube is already in the collection."
    }
}

public class Cube : IEquatable<Cube>
{

    public Cube(int h, int l, int w)
    {
        this.Height = h;
        this.Length = l;
        this.Width = w;
    }
    public int Height { get; set; }
    public int Length { get; set; }
    public int Width { get; set; }

    public bool Equals(Cube other)//定义具体的比较方法，满足条件时表示两个Cube相等。
    {
        if (this.Height == other.Height && this.Length == other.Length
            && this.Width == other.Width) {
            return true;
        }
        else {
            return false;
        }
    }
}

2022.09.22

1.text超采样：

2.TextMeshPro—Text：

3.Unity性能优化：

2022.09.26

1.对于unity中SVG格式的图片不正确显示的问题，是因为mate的损坏造成的。修复：选中资源，右键选择Reimport可以重新生成mate文件。

using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        List<string> dinosaurs = new List<string>();

        dinosaurs.Add("0.Pachycephalosaurus");
        dinosaurs.Add("1.Parasauralophus");
        dinosaurs.Add("2.Mamenchisaurus");
        dinosaurs.Add("3.Amargasaurus");
        dinosaurs.Add("4.Coelophysis");
        dinosaurs.Add("5.Oviraptor");

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        dinosaurs.Reverse();

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        dinosaurs.Reverse(1, 4);//反转从索引1到索引4之间的元素

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }
    }
}

/* This code example produces the following output:

0.Pachycephalosaurus
1.Parasauralophus
2.Mamenchisaurus
3.Amargasaurus
4.Coelophysis
5.Oviraptor

5.Oviraptor
4.Coelophysis
3.Amargasaurus
2.Mamenchisaurus
1.Parasauralophus
0.Pachycephalosaurus

5.Oviraptor
1.Parasauralophus
2.Mamenchisaurus
3.Amargasaurus
4.Coelophysis
0.Pachycephalosaurus
 */

2.C# Find()和First()与FirstOrDefault()

2022.10.13

1.Compile，Build，Execute的区别

2.ToString的重写

public delegate void MyHandler();
private static event MyHandler myEvent;
public static event MyHandler MyEvent
{
    add { myEvent += value; }
    remove { myEvent -= value; }
}

//---事件的注册与注销-----
// --- 当使用以下方式进行事件的注册与注销时会导致注销不成功；因为两个delegate 是两个方法 其引用地址不同-----------
MyEvent += delegate { Console.WriteLine(123); };
MyEvent -= delegate { Console.WriteLine(123); };
//------------------

// --以下方法可以正确的进行事件的注册和注销  因为用的同一个方法 方法地址相同 --
MyEvent += MyEventAction();
MyEvent -= MyEventAction();
private static void MyEventAction()
{ Console.WriteLine(123); }
//事件触发： myEvent.Invoke();

2022.12.2

显式枚举转换

string str = "Hello, World!";
string subStr = str[2..7]; // "llo, "

List<int> list = new List<int> { 1, 2, 3 };
foreach (int item in list)
{
    Console.WriteLine(item);
}

IEnumerator MyCoroutine()
{
    // 第一段代码
    yield return new WaitForSeconds(1.0f);

    // 第二段代码
    yield return new WaitUntil(() => someConditionIsTrue);

    // 第三段代码
    yield return null;

    // 第四段代码
    yield break;
}

StartCoroutine(MyCoroutine());

5.Quaternion.FromToRotation

2023.3.30

1.List.Sort() 与 List.OrderBy()

class Foo : IComparer<Foo>, IComparable<Foo> //自定义类使用Sort排序方法需要继承IComparable<>
{
    public int     Id;
    public string? Name;

    public int Compare(Foo? foo1, Foo? foo2)
    {
        if (foo2 != null && foo1 != null && foo1.Id > foo2.Id)
        {
            return 1; //foo1>foo2
        }
        else if (foo2 != null && foo1 != null && foo1.Id < foo2.Id)
        {
            return -1; //foo1<foo2
        }
        else
        {
            //如果相同根据名字排序
            if (foo1?.Name?.CompareTo(foo2?.Name) > 0) //<====>(String.Compare(foo1?.Name, foo2?.Name, StringComparison.Ordinal) > 0)
            {
                return 1; //foo1>foo2
            }
            else
            {
                return -1; //foo1<foo2
            }
        }
    }

    /// <summary> 这个例子中与Compare排序相反 </summary>
    /// <param name="other"></param>
    /// <returns></returns>
    public int CompareTo(Foo? other)
    {
        if (other != null && other.Id > Id)
        {
            return 1; //other>this
        }
        else if (other != null && other.Id < Id)
        {
            return -1; //other<this
        }
        else
        {
            //如果相同根据名字排序
            if (other?.Name?.CompareTo(Name) > 0) //<====>(String.Compare(other?Name, Name, StringComparison.Ordinal) > 0)
            {
                return 1; //other>this
            }
            else
            {
                return -1; //other<this
            }
        }
    }
}

List<Foo> foos = new List<Foo>
{
    new Foo { Id = 1, Name = "b" },
    new Foo { Id = 5, Name = "c" },
    new Foo { Id = 7, Name = "A" },
    new Foo { Id = 4, Name = "B" },
    new Foo { Id = 1, Name = "v" },
    new Foo { Id = 9, Name = "F" },
    new Foo { Id = 6, Name = "f" },
    new Foo { Id = 3, Name = "B" }
};

#region Sort

Console.WriteLine("\n------- 使用Sort进行排序 Start-------\n");

List<int> ints = new List<int>{ 1,5,7,4,1,9,6,3,};

Console.WriteLine("\n------- Int排序 -------\n");

ints.Sort();

ints.ForEach
(
    i =>
    {
        Console.WriteLine($"使用Name值排序 Id:{i}");
    }
);

Console.WriteLine("\n------- 继承IComparer<Foo> 正序 -------\n");

IComparer<Foo> fooComparer = new Foo();
foos.Sort(fooComparer);

foos.ForEach
(
    p =>
    {
        Console.WriteLine($"继承IComparer<Foo> Id:{p.Id},Name:{p.Name}");
    }
);

Console.WriteLine("\n------- 继承IComparable<Foo> 倒序 -------\n");

foos.Sort();

foos.ForEach
(
    p =>
    {
        Console.WriteLine($"继承IComparable<Foo> Id:{p.Id},Name:{p.Name}");
    }
);

Console.WriteLine("\n------- 使用Comparison委托 -------\n");

foos.Sort
(
    delegate(Foo foo1, Foo foo2)
    {
        if (foo1.Id > foo2.Id)
        {
            return 1; //foo1>foo2
        }
        else if (foo1.Id < foo2.Id)
        {
            return -1; //foo1<foo2
        }
        else
        {
            //如果相同根据名字排序
            if (foo1.Name?.CompareTo(foo2.Name) > 0) //<====>(String.Compare(foo1.Name, foo2.Name, StringComparison.Ordinal) > 0)
            {
                return 1; //foo1>foo2
            }
            else
            {
                return -1; //foo1<foo2
            }
        }
    }
);

foos.ForEach
(
    p =>
    {
        Console.WriteLine($"使用Comparison委托 Id:{p.Id},Name:{p.Name}");
    }
);

Console.WriteLine("\n------- 使用Sort进行排序 End-------\n");

#endregion

------- 使用Sort进行排序 Start-------


------- Int排序 -------

使用Name值排序 Id:1
使用Name值排序 Id:1
使用Name值排序 Id:3
使用Name值排序 Id:4
使用Name值排序 Id:5
使用Name值排序 Id:6
使用Name值排序 Id:7
使用Name值排序 Id:9

------- 继承IComparer<Foo> 正序 -------

继承IComparer<Foo> Id:1,Name:b
继承IComparer<Foo> Id:1,Name:v
继承IComparer<Foo> Id:3,Name:B
继承IComparer<Foo> Id:4,Name:B
继承IComparer<Foo> Id:5,Name:c
继承IComparer<Foo> Id:6,Name:f
继承IComparer<Foo> Id:7,Name:A
继承IComparer<Foo> Id:9,Name:F

------- 继承IComparable<Foo> 倒序 -------

继承IComparable<Foo> Id:9,Name:F
继承IComparable<Foo> Id:7,Name:A
继承IComparable<Foo> Id:6,Name:f
继承IComparable<Foo> Id:5,Name:c
继承IComparable<Foo> Id:4,Name:B
继承IComparable<Foo> Id:3,Name:B
继承IComparable<Foo> Id:1,Name:v
继承IComparable<Foo> Id:1,Name:b

------- 使用Comparison委托 -------

使用Comparison委托 Id:1,Name:b
使用Comparison委托 Id:1,Name:v
使用Comparison委托 Id:3,Name:B
使用Comparison委托 Id:4,Name:B
使用Comparison委托 Id:5,Name:c
使用Comparison委托 Id:6,Name:f
使用Comparison委托 Id:7,Name:A
使用Comparison委托 Id:9,Name:F

------- 使用Sort进行排序 End-------

#region OrderBy

Console.WriteLine("\n------- 使用OrderBy进行排序 Start-------\n");
int[] orderArr =  { 9, 8, 7, 6, 5, 4, 1, 2, 3 };

foos = foos.OrderBy
(
    e =>
    {
        var index = 0;
        index = Array.IndexOf(orderArr, e.Id); //查找orederArr数组中 与e.Id相同的索引值。 没有找到返回-1

        if (index != -1) { return index; }
        else
        {
            return int.MaxValue;
        }
    }
).ToList();

Console.WriteLine("\n------- 使用orderArr中的值排序 -------\n");

foos.ForEach
(
    p =>
    {
        Console.WriteLine($"Id:{p.Id},Name:{p.Name}");
    }
);

Console.WriteLine("\n------- 使用Name值排序 -------\n");

foos = foos.OrderBy(foo => foo.Name).ToList();

foos.ForEach
(
    p =>
    {
        Console.WriteLine($"使用Name值排序 Id:{p.Id},Name:{p.Name}");
    }
);

Console.WriteLine("\n------- 使用ID值排序 -------\n");

foos = foos.OrderBy(foo => foo.Id).ToList();

foos.ForEach
(
    p =>
    {
        Console.WriteLine($"使用Id值排序 Id:{p.Id},Name:{p.Name}");
    }
);

Console.WriteLine("\n------- 使用OrderBy进行排序 End-------\n");

#endregion

/*------- 使用OrderBy进行排序 Start-------


------- 使用orderArr中的值排序 -------

Id:9,Name:F
Id:7,Name:A
Id:6,Name:f
Id:5,Name:c
Id:4,Name:B
Id:1,Name:b
Id:1,Name:v
Id:3,Name:B

------- 使用Name值排序 -------

使用Name值排序 Id:7,Name:A
使用Name值排序 Id:1,Name:b
使用Name值排序 Id:4,Name:B
使用Name值排序 Id:3,Name:B
使用Name值排序 Id:5,Name:c
使用Name值排序 Id:6,Name:f
使用Name值排序 Id:9,Name:F
使用Name值排序 Id:1,Name:v

------- 使用ID值排序 -------

使用Id值排序 Id:1,Name:b
使用Id值排序 Id:1,Name:v
使用Id值排序 Id:3,Name:B
使用Id值排序 Id:4,Name:B
使用Id值排序 Id:5,Name:c
使用Id值排序 Id:6,Name:f
使用Id值排序 Id:7,Name:A
使用Id值排序 Id:9,Name:F

------- 使用OrderBy进行排序 End-------

3.C#中的结构体Struct

4.String类型尽量不要使用 == null 或 ==“”进行空判断 要使用string.IsNullOrEmpty

5.特性(Attribute)  自定义特性： XXXXAttribute

[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
public class ToggleTabOneEventAttribute: Attribute
{
    public int Index { get; set; }

    public ToggleTabOneEventAttribute(int index)
    {
        Index = index;
    }
}

public enum AttributeTargets
{
    Assembly = 1,//     可以对程序集应用特性。
    Module = 2,//     可以对模块应用特性。
    Class = 4,//     可以对类应用特性。
    Struct = 8,//     可以对结构应用特性，即值类型。
    Enum = 16,//     可以对枚举应用特性。
    Constructor = 32,//     可以对构造函数应用特性。
    Method = 64,//     可以对方法应用特性。
    Property = 128,//     可以对属性应用特性。
    Field = 256,//     可以对字段应用特性。
    Event = 512,//     可以对事件应用特性。
    Interface = 1024,//     可以对接口应用特性。
    Parameter = 2048,//     可以对参数应用特性。
    Delegate = 4096,//     可以对委托应用特性。
    ReturnValue = 8192,//     可以对返回值应用特性。
    GenericParameter = 16384,//     可以对泛型参数应用特性。
    All = 32767,//     可以对任何应用程序元素应用特性。
}

6.检测某个类（方法，属性等）是否使用了指定的特性

Attribute.IsDefined(目标的方法, typeof(指定的特性类型));

2.Attribute中静态方法 GetCustomAttributes 

3.Attribute中静态方法 GetCustomAttribute

返回应用于目标的指定attribute类的一个实例。该方法通常用于已将AllowMultiple设置为false的attribute。

4.MethodInfo中的实例方法 GetCustomAttribute

7.System.Reflection.BindingFlags