Unity基础之C#进阶篇笔记1：简单数据结构类

最新推荐文章于 2024-03-27 22:05:28 发布
最新推荐文章于 2024-03-27 22:05:28 发布
阅读量1.2k 收藏 2
点赞数 3
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42481369/article/details/117337094
版权

Unity基础之C#进阶篇笔记1：简单数据结构类

Arraylist

1.ArrayList的本质

            //ArrayList是一个C#为我们封装好的类，
            //它的本质是一个object类型的数组，
            //ArrayList类帮助我们实现了很多方法，
            //比如数组的增删查改

2.申明

            //需要引用命名空间using System.Collections;
            ArrayList array = new ArrayList();

3.增删查改


            #region 增
            array.Add(1);
            array.Add("123");
            array.Add(true);
            array.Add(new object());
            array.Add(new Test());
            array.Add(1);
            array.Add(true);

            ArrayList array2 = new ArrayList();
            array2.Add(123);
            //范围增加（批量增加 把另一个list容器里面的内容加到后面）
            array.AddRange(array2);

            array.Insert(1, "12345676");
            Console.WriteLine(array[1]);
            #endregion

            #region 删

            //移除指定元素 从头找 找到删
            array.Remove(1);
            //移除指定位置的元素
            array.RemoveAt(2);
            //清空
            //array.Clear();

            #endregion

            #region 查
            //得到指定位置的元素
            Console.WriteLine(array[0]);

            //查看元素是否存在
            if( array.Contains("1234") )
            {
                Console.WriteLine("存在123");
            }

            //正向查找元素位置
            //找到的返回值 是位置 找不到 返回值 是-1
            int index = array.IndexOf(true);
            Console.WriteLine(index);

            Console.WriteLine(array.IndexOf(false));

            //反向查找元素位置
            //返回时从头开始的索引数
            index = array.LastIndexOf(true);
            Console.WriteLine(index);
            #endregion

            #region 改
            Console.WriteLine(array[0]);
            array[0] = "999";
            Console.WriteLine(array[0]);
            #endregion

4.遍历

            //长度
            Console.WriteLine(array.Count);
            //容量
            //避免产生过多的垃圾
            Console.WriteLine(array.Capacity);
            Console.WriteLine("***********************");
            for (int i = 0; i < array.Count; i++)
            {
                Console.WriteLine(array[i]);
            }
            Console.WriteLine("***********************");
            //迭代器遍历
            foreach (object item in array)
            {
                Console.WriteLine(item);
            }

5.装箱拆箱

            //ArrayList本质上是一个可以自动扩容的object数组，
            //由于用万物之父来存储数据，自然存在装箱拆箱。
            //当往其中进行值类型存储时就是在装箱，当将值类型对象取出来转换使用时，就存在拆箱。
            //所以ArrayList尽量少用，之后我们会学习更好的数据容器。

            int k = 1;
            array[0] = k;//装箱
            k = (int)array[0];//拆箱

6.练习题

1.练习题1

    //请简述ArrayList和数组的区别
    #region 答案
    //ArrayList本质上是一个object数组的封装

    //1.ArrayList可以不用一开始就定长，单独使用数组是定长的
    //2.数组可以指定存储类型，ArrayList默认为object类型
    //3.数组的增删需要我们自己去实现，ArrayList帮我们封装了方便的API来使用
    //4.ArrayList使用时可能存在装箱拆箱，数组使用时只要不是object数组那就不存在这个问题
    //5.数组长度为Length, ArrayList长度为Count
	#endregion

2.练习题2

    //创建一个背包管理类，使用ArrayList存储物品，
    //实现购买物品，卖出物品，显示物品的功能。购买与卖出物品会导致金钱变化

    class BagMgr
    {
        //背包中的物品
        private ArrayList items;

        private int money;

        public BagMgr( int money )
        {
            this.money = money;
            items = new ArrayList();
        }

        public void BuyItem(Item item)
        {
            if( item.num <= 0 || item.money < 0 )
            {
                Console.WriteLine("请传入正确的物品信息");
                return;
            }

            if( this.money < item.money*item.num )
            {
                //买不起 钱不够
                Console.WriteLine("买不起 钱不够");
                return;
            }
            //减钱
            this.money -= item.money * item.num;
            Console.WriteLine("购买{0}{1}个花费{2}钱", item.name, item.num, item.money * item.num);
            Console.WriteLine("剩余{0}元钱", this.money);
            //如果想要叠加物品 可以在前面先判断 是否有这个物品 然后加数量
            for (int i = 0; i < items.Count; i++)
            {
                if( (items[i] as Item).id == item.id )
                {
                    //叠加数量
                    (items[i] as Item).num += item.num;
                    return;
                }
            }
            //把一组物品加到 list中
            items.Add(item);
        }

        public void SellItem(Item item)
        {
            for (int i = 0; i < items.Count; i++)
            {
                //如何判断 卖的东西我有没有
                //这是在判断 两个引用地址 指向的是不是同一个房间
                //所以我们要判断 卖的物品 一般不这样判断
                //if(items[i] == item)
                //{

                //}
                if( (items[i] as Item).id == item.id )
                {
                    //两种情况
                    int num = 0;
                    string name = (items[i] as Item).name;
                    int money = (items[i] as Item).money;
                    if ((items[i] as Item).num > item.num)
                    {
                        //1.比我身上的少
                        num = item.num;
                    }
                    else
                    {
                        //2.大于等于我身上的东西数量
                        num = (items[i] as Item).num;
                        //卖完了  就从身上移除了
                        items.RemoveAt(i);
                    }

                    int sellMoney = (int)(num * money * 0.8f);
                    this.money += sellMoney;

                    Console.WriteLine("卖了{0}{1}个，赚了{2}钱", name, num, sellMoney);
                    Console.WriteLine("目前拥有{0}元钱", this.money);

                    return;
                }
            }
        }

        public void SellItem(int id, int num = 1)
        {
            //我这是想 直接调用上面写好的方法 
            //我就直接构造一个Item类 把ID和数量两个关键信息设置了即可 就可以卖了
            Item item = new Item(id, num);
            SellItem(item);
        }

        public void ShowItem()
        {
            Item item;
            for (int i = 0; i < items.Count; i++)
            {
                item = items[i] as Item;
                Console.WriteLine("有{0}{1}个", item.name, item.num);
            }
            Console.WriteLine("当前拥有{0}元钱", this.money);
        }
    }

    class Item
    {
        //物品唯一ID 来区分物品的种类
        public int id;
        //物品多少钱(单价)
        public int money;
        //物品名字
        public string name;
        //public string tips;
        //物品数量
        public int num;

        public Item(int id, int num)
        {
            this.id = id;
            this.num = num;
        }

        public Item(int id, int money, string name, int num)
        {
            this.id = id;
            this.money = money;
            this.name = name;
            this.num = num;
        }
    }

    #endregion

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("ArrayList练习题");

            BagMgr bag = new BagMgr(99999);
            Item i1 = new Item(1, 10, "红药", 10);
            Item i2 = new Item(2, 20, "蓝药", 10);
            Item i3 = new Item(3, 999, "屠龙刀", 1);

            bag.BuyItem(i1);
            bag.BuyItem(i2);
            bag.BuyItem(i3);

            bag.SellItem(i3);
            bag.SellItem(1, 1);
            bag.SellItem(1, 1);
            bag.SellItem(2, 1);
            bag.SellItem(2, 1);
        }
    }

Stack 栈

1.Stack的本质

            //Stack（栈）是一个C#为我们封装好的类
            //它的本质也是object[]数组，只是封装了特殊的存储规则

            //Stack是栈存储容器，栈是一种先进后出的数据结构
            //先存入的数据后获取，后存入的数据先获取
            //栈是先进后出

2.申明

           
            //需要引用命名空间 System.Collections
            Stack stack = new Stack();

3.增取查改

            #region 增
            //压栈
            stack.Push(1);
            stack.Push("123");
            stack.Push(true);
            stack.Push(1.2f);
            stack.Push(new Test());

            #endregion

            #region 取
            //栈中不存在删除的概念
            //只有取的概念
            //弹栈
            object v = stack.Pop();
            Console.WriteLine(v);

            v = stack.Pop();
            Console.WriteLine(v);
            #endregion

            #region 查
            //1.栈无法查看指定位置的 元素
            //  只能查看栈顶的内容
            v = stack.Peek();
            Console.WriteLine(v);
            v = stack.Peek();
            Console.WriteLine(v);

            //2.查看元素是否存在于栈中
            if( stack.Contains("123") )
            {
                Console.WriteLine("存在123");
            }

            #endregion

            #region 改
            //栈无法改变其中的元素 只能压(存)和弹（取）
            //实在要改 只有清空
            stack.Clear();
            Console.WriteLine(stack.Count);
            stack.Push("1");
            stack.Push(2);
            stack.Push("哈哈哈");
            #endregion

4.遍历

            //1.长度
            Console.WriteLine(stack.Count);

            //2.用foreach遍历
            //  而且遍历出来的顺序 也是从栈顶到栈底
            foreach(object item in stack)
            {
                Console.WriteLine(item);
            }

            //3.还有一种遍历方式
            //  将栈转换为object数组
            //  遍历出来的顺序 也是从栈顶到栈底
            object[] array = stack.ToArray();
            for (int i = 0; i < array.Length; i++)
            {
                Console.WriteLine(array[i]);
            }

            Console.WriteLine(stack.Count);
            //4.循环弹栈
            while( stack.Count > 0 )
            {
                object o = stack.Pop();
                Console.WriteLine(o);
            }
            Console.WriteLine(stack.Count);

5.装箱拆箱

            //由于用万物之父来存储数据，自然存在装箱拆箱。
            //当往其中进行值类型存储时就是在装箱
            //当将值类型对象取出来转换使用时，就存在拆箱。

6.练习题

1.练习题1

       //请简述栈的存储规则
       //先进后出

2.练习题2

            //写一个方法计算任意一个数的二进制数
            //使用栈结构方式存储，之后打印出来
            Calc(10);
            Calc(2);
            Calc(3);
            Calc(8);
            Calc(16);
        static void Calc(uint num)
        {
            Console.Write("{0}的二进制是：", num);
            Stack stack = new Stack();
            while(true)
            {
                stack.Push(num % 2);
                num /= 2;
                if (num == 1)
                {
                    stack.Push(num);
                    break;
                }
            }
            //循环弹栈
            while(stack.Count > 0)
            {
                Console.Write(stack.Pop());
            }
            Console.WriteLine();
}

Queue 队列

1.Queue 的本质

            //Queue是一个C#为我们封装好的类
            //它的本质也是object[]数组，只是封装了特殊的存储规则

            //Queue是队列存储容器
            //队列是一种先进先出的数据结构
            //先存入的数据先获取，后存入的数据后获取
            //先进先出

2.申明

            //需要引用命名空间 System.Collections
            Queue queue = new Queue();

3.增取查改

            #region 增
            queue.Enqueue(1);
            queue.Enqueue("123");
            queue.Enqueue(1.4f);
            queue.Enqueue(new Test());
            #endregion

            #region 取
            //队列中不存在删除的概念
            //只有取的概念 取出先加入的对象
            object v = queue.Dequeue();
            Console.WriteLine(v);
            v = queue.Dequeue();
            Console.WriteLine(v);
            #endregion

            #region 查
            //1.查看队列头部元素但不会移除
            v = queue.Peek();
            Console.WriteLine(v);
            v = queue.Peek();
            Console.WriteLine(v);

            //2.查看元素是否存在于队列中
            if( queue.Contains(1.4f) )
            {
                Console.WriteLine("队列中存在1.4f");
            }

            #endregion

            #region 改
            //队列无法改变其中的元素 只能进出队列
            //实在要改 只有清
            Console.WriteLine(queue.Count);
            queue.Clear();
            queue.Enqueue(1);
            queue.Enqueue(2);
            queue.Enqueue(3);
            #endregion

4.遍历

            //1.长度
            Console.WriteLine(queue.Count);
            //2.用foreach遍历
            foreach (object item in queue)
            {
                Console.WriteLine(item);
            }
            //3.还有一种遍历方式
            //  将队列转换为object数组
            object[] array = queue.ToArray();
            for (int i = 0; i < array.Length; i++)
            {
                Console.WriteLine(array[i]);
            }

            //4.循环出列
            while(queue.Count>0)
            {
                object o = queue.Dequeue();
                Console.WriteLine(o);
            }
            Console.WriteLine(queue.Count);

5.装箱拆箱

            //由于用万物之父来存储数据，自然存在装箱拆箱。
            //当往其中进行值类型存储时就是在装箱
            //当将值类型对象取出来转换使用时，就存在拆箱。

6.练习题

1.练习题1

            //请简述队列的存储规则
            //先进先出

2.练习题2

            //使用队列存储消息，一次性存10条消息，每隔一段时间打印一条消息
            //控制台打印消息时要有明显停顿感
            Queue queue = new Queue();
            queue.Enqueue("获得10枚金币");
            queue.Enqueue("获得屠龙刀x1");
            queue.Enqueue("获得99枚金币");
            queue.Enqueue("获得血瓶x1");
            queue.Enqueue("获得85枚金币");
            queue.Enqueue("获得11枚金币");
            queue.Enqueue("获得2枚金币");
            queue.Enqueue("获得91枚金币");
            queue.Enqueue("获得73枚金币");
            queue.Enqueue("获得645枚金币");

            int updateIndex = 1;
            while (true)
            {
                if( updateIndex % 99999999 == 0 )
                {
                    if(queue.Count > 0)
                    {
                        Console.WriteLine(queue.Dequeue());
                    }
                    updateIndex = 0;
                }
                ++updateIndex;
            }

Hashtable 哈希表

1.Hashtalbe的本质

            //Hashtable（又称散列表） 是基于键的哈希代码组织起来的 键/值对
            //它的主要作用是提高数据查询的效率
            //使用键来访问集合中的元素

2.声明

            //需要引用命名空间 System.Collections
            Hashtable hashtable = new Hashtable();

3.增删改查

            #region 增
            hashtable.Add(1, "123");
            hashtable.Add("123", 2);
            hashtable.Add(true, false);
            hashtable.Add(false, false);
            //注意：不能出现相同键
            #endregion

            #region 删
            //1.只能通过键去删除
            hashtable.Remove(1);
            //2.删除不存在的键 没反应
            hashtable.Remove(2);

            //3.或者直接清空
            hashtable.Clear();
            hashtable.Add(1, "123");
            hashtable.Add(2, "1234");
            hashtable.Add(3, "123");
            hashtable.Add("123123", 12);
            #endregion

            #region 查
            //1.通过键查看值
            //  找不到会返回空
            Console.WriteLine(hashtable[1]);
            Console.WriteLine(hashtable[4]);//null
            Console.WriteLine(hashtable["123123"]);

            //2.查看是否存在
            //根据键检测
            if( hashtable.Contains(2) )
            {
                Console.WriteLine("存在键为2的键值对");
            }
            if( hashtable.ContainsKey(2) )
            {
                Console.WriteLine("存在键为2的键值对");
            }

            //根据值检测
            if( hashtable.ContainsValue(12) )
            {
                Console.WriteLine("存在值为12的键值对");
            }
            #endregion

            #region 改
            //只能改 键对应的值内容 无法修改键
            Console.WriteLine(hashtable[1]);
            hashtable[1] = 100.5f;
            Console.WriteLine(hashtable[1]);
            #endregion

4.遍历

            //得到键值对 对数
            Console.WriteLine(hashtable.Count);

            //1.遍历所有键
            foreach (object item in hashtable.Keys)
            {
                Console.WriteLine("键："+item);
                Console.WriteLine("值："+hashtable[item]);
            }

            //2.遍历所有值
            foreach (object item in hashtable.Values)
            {
                Console.WriteLine("值：" + item);
            }

            //3.键值对一起遍历
            foreach (DictionaryEntry item in hashtable)
            {
                Console.WriteLine("键：" + item.Key + "值：" + item.Value);
            }

            //4.迭代器遍历法
            IDictionaryEnumerator myEnumerator = hashtable.GetEnumerator();
            bool flag = myEnumerator.MoveNext();
            while (flag)
            {
                Console.WriteLine("键：" + myEnumerator.Key + "值：" + myEnumerator.Value);
                flag = myEnumerator.MoveNext();
            }

5.装箱拆箱

            //由于用万物之父来存储数据，自然存在装箱拆箱
            //当往其中进行值类型存储时就是在装箱
            //当将值类型对象取出来转换使用时，就存在拆箱

6.练习题

1.练习题1

    //请描述Hashtable的存储规则

    // 一个键值对形式存储的 容器
    // 一个键 对应一个值
    // 类型是object

2.练习题2

    //制作一个怪物管理器，提供创建怪物
    //移除怪物的方法。每个怪物都有自己的唯一ID
    
    /// <summary>
    /// 怪物管理器 因为一般 管理器 都是唯一的 所以把它做成 一个单例模式的对象
    /// </summary>
    class MonsterMgr
    {
        private static MonsterMgr instance = new MonsterMgr();

        private Hashtable monstersTable = new Hashtable();

        private MonsterMgr()
        {

        }

        public static MonsterMgr Instance
        {
            get
            {
                return instance;
            }
        }

        private int monsterID = 0;

        public void AddMonster()
        {
            Monster monster = new Monster(monsterID);
            Console.WriteLine("创建了id为{0}的怪物", monsterID);
            ++monsterID;
            //Hashtable 的键 是不能重复的 所以一定是用唯一ID
            monstersTable.Add(monster.id, monster);
        }

        public void RemoveMonster(int monsterID)
        {
            if( monstersTable.ContainsKey(monsterID) )
            {
                (monstersTable[monsterID] as Monster).Dead();
                monstersTable.Remove(monsterID);
            }
        }
    }

    class Monster
    {
        public int id;

        public Monster(int id)
        {
            this.id = id;
        }

        public void Dead()
        {
            Console.WriteLine("怪物{0}死亡", id);
        }
    }
    #endregion

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hashtable练习题");

            MonsterMgr.Instance.AddMonster();
            MonsterMgr.Instance.AddMonster();
            MonsterMgr.Instance.AddMonster();
            MonsterMgr.Instance.AddMonster();
            MonsterMgr.Instance.AddMonster();
            MonsterMgr.Instance.AddMonster();

            MonsterMgr.Instance.RemoveMonster(0);
            MonsterMgr.Instance.RemoveMonster(3);
        }
    }
四月的白羊座
关注
c#四部曲（进阶）
ultraman1234566的博客
01-14 1040
经常增删数据，用链表。增删较少而查找频繁，用顺序表。特性本质上也是一个类，可以给成员变量、方法提供额外信息。后续可以通过反射来获取额外信息这就是一个特性类了后缀必须加Attribute，调用时自动省略后缀 [MyCustom]这里传参是因为这个特性类里面有一个带参的构造函数。使用特性，等于调用该特性的构造函数类前，成员变量前，函数前，函数参数前都可以加。
【Unity】Effective C#观后感之提高Unity中C#代码质量的21条准则
天生爱赞美的博客
07-19 6296
我们知道，在C++领域，作为进阶阅读材料，必看的书是《Effective C++》。 而《Effective C#》之于C# ，是类似《Effective C++》之于C++一样的存在。这篇文章，将《Effective C# Second Edition》一书中适用于Unity游戏引擎里使用C#的经验之谈进行了提炼，总结成为21条（一开始总结的是22条，后来发现第22条也是.NET的特性，Unit
【Unityc#专题篇】之c#进阶篇
秩沅
06-05 6478
【本站最全系列】（c#系统化学习宝典）—精华图文提炼核心
Unity-C#进阶——更新完
最新发布
m0_67428211的博客
03-27 1948
C#进阶——Unity
C#四部曲（知识补充）
ultraman1234566的博客
03-12 1902
各种源码→根据.NET规范编写→(虚拟机)生成CIL中间码(保存在程序集中)→转成操作系统原代码跨语言 ↑ 跨平台 ↓（Mono）c#脚本→MonoC#编译器→IL中间代码→monoRunTIme虚拟机→操作系统原生代码（IL2CPP）mono直接将中间代码转原生代码。IL2CPP先将中间码转C++，再转原生码。
C#——进阶
HAL2020的博客
08-19 1721
1.ArrayList知识点 using System; using System.Collections; namespace lesson1_ArrayList知识点 { class Program { class Test { } static void Main(string[] args) { Console.WriteLine("ArrayLis
unity笔记 全阶段
03-16
本笔记旨在为初学者提供一个全面的Unity学习路径，从基础到进阶，涵盖环境搭建、3D基础知识、C#编程语言、脚本编写等多个方面。 一、Unity基础 1. 引言：在开始Unity学习之前，了解其历史背景、应用领域和主要功能...
C#6.0学习笔记 从第一行C#代码到第一个项目设计 随书源码
07-05
本学习笔记旨在帮助初学者从零基础开始掌握C#编程，逐步进阶到能够独立设计项目。随书源码为学习提供了实践操作的平台，确保理论与实践相结合。 一、C# 6.0基础语法 1. 变量与数据类型：C#支持多种数据类型，包括...
Unity跨平台UI解决方案：可能是最全的FairyGUI系列教程.Part1
空名先生
03-19 1万+
FairyGUI简介导读 她提供了超强的UI编辑器，界面操作与PS类似，友善且简单。主打的是摒弃了脚本和配置文件这些需要代码思维的操作，设计或者美术都可以轻轻松松学会并生产界面。 能实现功能非常之多：最基本的按钮，图片，富文本，进度条，滑动条，列表，树 进阶的有动画，控制器，关联系统，装载器，窗口，动效 支持的引擎也非常之多：Unity,Unreal,Cocos,ThreeJS,Egret,LayaAir等十多款游戏引擎 通过简单的操作来实现复杂的功能，提高开发效率，UI 制作效率提升昂...
我的学习笔记 ，涵盖：C#，java，SqlServer，MySql，Oracle，HTML，CSS.zip
02-23
1. **C#**：C#是微软开发的一种面向对象的编程语言，广泛应用于Windows桌面应用、游戏开发（尤其是Unity引擎）以及Web服务。关键知识点包括类与对象、继承、封装、多态、接口、异常处理、委托与事件、泛型、LINQ、...
unity不定长数据解析
qq_42585822的博客
02-02 2124
using System.Collections; using System.Collections.Generic; using System.IO.Ports; using UnityEngine; public class ChuankouBuding : MonoBehaviour { //状态 private int CONDITION=0; //校验 private const int VERIFY = 0; //校验长度 private co.
Unity学习（C#）——列表List的创建和使用
weixin_45045387的博客
06-18 1万+
集合类：数组的大小是固定的，有时候不方便，需要使用集合来管理，列表是集合类的一组，且可以方便的添加和删除数据。 创建和访问、插入数据。 static void Main(string[] args) { List<int> scoreList = new List<int>(); var scoreList1 = new List<int>(); var scoreList2 = n
Unity 背包功能实现
miumiumiu00的博客
10-09 3991
unity背包功能
unity之列的基本操作和约束
Candy_Gt的专栏
12-10 1721
嗨，欢迎来到我们的狗刨网，人应该每天来学习一些新的内容来充实自己，今天我们主要讲的数据库的列的基本操作和约束，下面就让我们一起来看 看我们讲的啥吧。 一、列的基本操作 1、添加一列：alter table 表名 add 列名 类型（长度） null 例如：alter table student add age int  null 2、更改一
Unity中集合的随机数（指定长度—List、Dictionary）
JLX_Sir的博客
08-02 1402
获取Dictionary、List集合中的指定长度不重复的随机数
C#的ArrayList
youyiyang的专栏
09-05 766
ArrayList类是一个特殊的数组。它来自于System.Collections命名空间；通过添加和删除元素，就可以动态改变数组的长度。 一、优点 1）支持自动改变大小的功能 2）可以灵活的插入元素 3）可以灵活的删除元素 二、局限性 跟一般的数组比起来，速度上差些。 因为它是动态数组，初始化大小容量4，当数据存满时扩容是以当前数组容量大小的2倍扩容，之后再把数组元素一个一个的
【唐老狮】C#四部曲之C#入门：习题汇总
MrTang_Unity的博客
04-26 3250
本篇文章对视频教程 《【唐老狮】Unity系列之C#四部曲—C#入门》 当中的课后练习题进行了汇总，方便同学们统一进行练习和复习 这些习题的解题部分都在本教程中以视频的形式进行了详细讲解 B站免费试看 【唐老狮】Unity系列之C#四部曲—C#入门_哔哩哔哩_bilibili 泰课会员免费看： https://www.taikr.com/goods/show/589 本套课程属于Unity实战就业路线（打折预售中） https://www.taikr.com/goods/show/5.
C# 获取list长度
热门推荐
m0_37275892的博客
10-23 3万+
C# 获取List长度 List<List<List<double>>> dataList = new List<List<List<double>>>(); dataList = this.Context.GetData; int lengthFirst = dataList.GetLength(0);//获取到一维的长...
Unity学习之C#_如何自己定义一个List集合
OJMars的博客
04-18 6634
如何使用C#自己创建一个和List集合功能大致相同的自定义集合 首先在介绍如何自己创建一个集合之前，先介绍几个概念：数据结构、数据（data）、数据元素（Data Element）、数据项（Data Item）、数据对象（Data Object）、数据类型（Data Type） 1、数据结构：数据结构是指相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成。 这里的定义来自...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

四月的白羊座

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值