标签：Log C# Enum emAction 笔记 语法 int 数组 Debug

C#基础语法

一、C#变量的概念和数据类型

1. 变量的概念

概念：变量是存储内容的别名，通过变量可以访问到内容。

为什么要使用变量？

通过变量可以映射计算机内存地址，进而获取解析相应的内存块，最后返回想要访问的数据。

变量的赋值格式：

<data type><variable_name>=value;
​
例:  int a = 10;

2. 数据类型取值范围

 

3. 常用的数据类型

char和string：

char表示一个字符，string是一个char类型的数组。

// 匈牙利命名法（驼峰式）
int hpValue = 1000;
int iHpValue = 2000;// i表示int
​
// 可单行赋值多个相同数据类型的变量
int c = 30, d = 40;
​
// string str
string strMonster = "树人";
​
// char ch
char chUnicode = 'a';
​
// short sh
short shID = 100;
​
// long l
long lMpValue = 1000;
​
// bool true : false  b/is
bool bOpen = true;

// 输出格式化，范例如下
Debug.LogFormat("名字{0},血量{1},等级{2},经验值{3}", strName, iHpValue, iLevel, IExp);

 

二、C#数组

1. 数组概念

数组，是有序的相同数据类型元素组成的有限集合，内存是线性连续的。

一维数组：数组中每个元素都只带有一个下标；

二维数组：数组中每个元素带有两个下标；

………………

N维数组：数组中每个元素带有N个下标。

<data_type>[] variable_name;

2. 数组的使用

    int[] array;  // 数组的声明，并没有分配内存
    int[] array1 = new int[5]; // 数组的声明并分配内存
    int iNumber = 10;
​
    // 第一种数组初始化
    int[] array3 = new int[5];
    for(int i = 0; i < array3.Length; i++)
    {
        array3[i] = iNumber;
        iNumber += 10;
    }
​
    Debug.Log("访问第4个元素（第三个下标）代表的数据：" + array3[3]);
    array3[3] = 400;
    Debug.Log("访问第4个元素（修正）代表的数据：" + array3[3]);
​
    // 第二种数组初始化
    int[] array4 = new int[5] { 100, 200, 300, 400, 500 };// 容量显式声明
    int[] array5 = new int[] { 100, 200, 300, 400, 500 };// 容量隐式声明
​
    // 第三种数组初始化
    int[] array6 = { 100, 200, 300, 400, 500 };
​
    Debug.Log("获取array6的数组长度（容量）= " + array6.Length);
​
    // 二维数组
    int[,] array7 = new int[2, 2];
    array7[0, 0] = 100;// 1行1列
    array7[0, 1] = 200;// 1行2列
    array7[1, 0] = 300;// 2行1列
    array7[1, 1] = 400;// 2行2列
​
    Debug.Log("打印第2行第1列数据：" + array7[1, 0]);
​
    int[,] array8 = new int[2, 2]
    {
        { 1000, 2000 },
        { 3000, 4000 },
    };
    int[,] array9;
    array9 = new int[2, 3]
    {
        { 1000, 2000, 9 },
        { 3000, 4000, 8 },
    };
​
    Debug.Log("array9总长度（容量）" + array9.Length);
    Debug.Log("array9行数" + array9.GetLength(0));
    Debug.Log("array9列数" + array9.GetLength(1));
​
    // 三维数组
    int[,,] array10 = new int[3, 4, 5]
    {
        {{1, 2, 3, 4, 5 }, {6, 7, 8, 9, 10 }, {1, 2, 3, 4, 5 }, {6, 7, 8, 9, 10 } },
        {{1, 2, 3, 4, 5 }, {6, 7, 8, 9, 10 }, {1, 2, 3, 4, 5 }, {6, 7, 8, 9, 10 } },
        {{1, 2, 3, 4, 5 }, {6, 7, 8, 9, 10 }, {1, 2, 3, 4, 5 }, {6, 7, 8, 9, 10 } }
    };
    Debug.Log("array10总容量：" + array10.Length);
    Debug.Log("array10行数：" + array10.GetLength(0));
    Debug.Log("array10列数：" + array10.GetLength(1));
    Debug.Log("array10层数：" + array10.GetLength(2));
    Debug.Log("arry10[2, 2, 2]:" + array10[2, 2, 2]);
​
    int[,,] array11 = new int[2, 3, 4];
    for(int i = 0; i < array11.GetLength(0); i++)
    {
        for(int j = 0; j < array11.GetLength(1); j++)
        {
            for(int k = 0; k < array11.GetLength(2); k++)
            {
                array11[i, j, k] = 10;
            }
        }
    }
    Debug.Log(array11[1, 1, 1]);
​
    // 数组的访问
    // 1.下标的方式
    // 2.循环遍历的方式

 

三、C#函数

1. 函数的概念

函数，即方法（接口），可以直接被另一段程序调用的程序块。

一个较大的程序一般分为若干个程序块，每一个模块用来实现一个特定的功能。

2. 函数的定义及调用

无返回值函数的定义

有返回值函数的定义

函数的调用

// 1.函数返回值的分类
// （1）无返回值 void + function_name + (args) + { }
// （2）有返回值 function_type + function_name + (args) + { return function_type; }
​
// 2.函数调用
//  注意：
//  函数调用时，传入的参数的数据类型，必须和被调用的函数参数的数据类型保持一致
​
// 3.如何调试程序
//   断点如何添加：
//     （1）选中某一行，通过鼠标单击左侧竖栏，再单击一下取消
//     （2）选中某一行，按下F9标记断点，再按一下取消
//   如何调试
//     （1）附加到Unity，同时启动Unity
//     （2）F11进入函数体内，F11逐语句执行，F10逐过程执行
//     （3）shift+F5退出调试
​
public class function : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {
        ShowContxt();
        ShowName("老王");
        ShowName2("老张", 26);
        int result = GetSum(1, 2);
        Debug.Log("计算之和：" + result);
    }
​
    void ShowContxt()
    {
        Debug.Log("ShowContxt被调用");
    }
​
    void ShowName(string strName)
    {
        Debug.Log("ShowName输出参数：" + strName);
    }
    void ShowName2(string strName, int iAge)
    {
        Debug.Log("ShowName输出参数：" + strName + "，年龄：" + iAge);
    }
​
    int GetSum(int a, int b)
    {
        int sum = 0;
        sum = a + b;
        return sum;
    }
}

 

四、C#运算符

1. 运算符的概念

运算符，是一种告知编译器执行特定的数学或逻辑操作的符号。

2. 算术&赋值运算符

算术运算符：

 

赋值运算符：

 

3. 关系&逻辑&三目运算符

关系运算符：

 

逻辑运算符：

 

三目运算符：

a > b ? a : b

若a>b，则返回a；反之返回b

4. 位运算符

 

 

五、C#枚举

1. 枚举概念

枚举类型使用enum关键字声明，包含了一些易读的标识符。

2. 枚举和int、string的转换

// Enum <--> int
// Enum <--> string
public class EnumTest : MonoBehaviour
{
    /*
     *   枚举内容：
     *   1. 起床 2. 洗漱 3. 吃饭 4. 玩 
     */
    public enum emAction
    {
        /*None,  // 占位符
        GetUp,
        Wash,
        Eat,
        Play,*/
        None = 0,
        GetUp,  // 0 + 1 = 1
        Wash,   // 1 + 1 = 2
        Eat,       // 2 + 1 = 3
        Play      // 3 + 1 = 4
    }
​
    // 初始化
    public emAction mAction = emAction.Play;
    
    void Start()
    {
        Func1();
    }
​
    void Func1()
    {
        Debug.Log(mAction);
        Debug.Log(mAction.ToString());
​
        // Enum <--> string
        // mAction.ToString()   Enum 转化为string
        // mAction = (emAction)Enum.Parse(typeof(emAction), "Wash");   string 转化为 Enum
​
        mAction = (emAction)Enum.Parse(typeof(emAction), "Wash");
        Debug.Log("string --> Enum: " + mAction);
​
        // Enum <--> int
        // int iPlay = (int)mAction;   Enum 转化为 int
        // int iConverValue = Convert.ToInt32(mAction);  Enum 转化为 int
        
        // mAction = (emAction)3;    int 转化为 Enum
        //  Enum.ToObject(typeof(emAction), 1);   int 转化为 Enum
​
        int iPlay = (int)mAction;
        Debug.Log("Enum --> int:  " + iPlay);
        int iConverValue = Convert.ToInt32(mAction);
        Debug.Log(iConverValue);
​
        mAction = (emAction)3;
        Debug.Log("int --> Enum: " + mAction);
​
        mAction = (emAction)Enum.ToObject(typeof(emAction), 1);
        // Enum在switch-case中的应用
        // 增加了代码的可读性
        switch( mAction )
        {
            case emAction.GetUp:
                Debug.Log("起床");
                break;
            case emAction.Wash:
                Debug.Log("洗漱");
                break;
            case emAction.Eat:
                Debug.Log("吃饭");
                break;
            case emAction.Play:
                Debug.Log("玩");
                break;
            default:
                Debug.Log("none");
                break;
        }
    }
}

 

六、判断语句与循环语句

1. 逻辑判断语句

if{} else{}和switch() case 0: break; case 1: break;……

2. 循环语句

for 语句

// int i = 0 定义变量
// i < length; 检测条件
// i++ 自增自减语句
for (int i = 0; i < 10; i++)
{
    Debug.Log(i);
}
for (int i = 10; i > 0; i--)
{
    Debug.Log(i);
}

for-each语句

foreach是一种语法糖，用来简化对可枚举元素的遍历代码。而被遍历的类通过实现IEnumerable接口和一个相关的IEnumerator枚举器来实现遍历功能。

在foreach语句中有两个限制，第一不能修改枚举成员，其次不要对集合进行删除操作。也就是如下两种方式都是错误的。

// Use "foreach" to loop an arraylist
foreach( int i in arrInt )
{
    i++;//Can't be compiled
    Debug.WriteLine( i.ToString() );
}
​
// Use "foreach" to loop an arraylist
foreach( int i in arrInt )
{
    arrInt.Remove( i );//It will generate error in run-time
    Debug.WriteLine( i.ToString() );
}

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

public class TestForeach : MonoBehaviour
{
    void Start()
    {
        GoTestForeach();
    }
	private void GoTestForeach()
	{
        Debug.Log("start foreach 空数组的遍历"); 
    	var array = new List<string>();
    	//注意区分：空数组是指元素个数为0，数组为空是指数组变量本身为null
    
    	foreach(var item in array)
    	{
        	//这里数组array变量不为空，只是元素个数为0，在遍历时不会报空。
        	Debug.Log(item);
    	}
 
    	//foreach语句中不能修改枚举成员
    	var array2 = new List<string> { "", "1", "2", "3" };
    	foreach(var item in array2)
    	{
       	 	Debug.Log(item);
        	array2.Remove("1");
        	Debug.Log(item);
    	}
 
	}
}

while 语句

// while 关键字
// (true) 检测条件
int i = 0;
while(i < 10)
{
    // 循环体
    Debug.Log(i);
    i++;
}

do-while 语句

int i = 10;
do
{
    Debug.Log("i")
}while(i > 10);
Debug.Log("!"); 

循环语句知识补充：

（1）continue 跳过：跳过当前循环，进入到下个循环；

（2）break 打断：跳出所有循环，到循环体外；

（3）++i 前自增：先进行 i+1，再执行有关 i 操作；

（4）i++ 后自增：先进行有关 i 的操作，再执行 i+1.

标签：Log,C#,Enum,emAction,笔记,语法,int,数组,Debug
来源： https://www.cnblogs.com/dukenone/p/16694391.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。