C# 接口_索引器_命名空间

已于 2024-03-28 20:43:37 修改
阅读量2.5k 收藏 42
点赞数 52
分类专栏： 21天速通 C# 文章标签： c# java servlet 人工智能 开发语言 microsoft 服务器
于 2024-03-22 17:49:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_82410658/article/details/136941754
版权

文章目录

接口

接口的设计目的是为了定义一组公共的、可被多个类实现的方法和属性

  1. 接口中只能定义属性,不能定义字段，方法不能有方法体

  2. 不能包含静态成员

  3. 接口的成员不能用修饰符,所有成员默认为public,即使是public也不能写

  4. 类或者结构体实现的时候,类的成员相对于接口成员,只能多,不能少,如果接口中规定的属性拥有get和set,类中必须都有,接口规定只有get,类中可以有get和set

  5. 当类实现多个接口的时候,使用,分割

  6. 当类同时继承基类和接口的时候,必须把基类放在前面

     代码示例

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _02_接口
{
    internal class Program
    {
        static void Main(string[] args)
        {

            //接口是指一组成员,而不对他们的成员进行实现的引用类型,只能被类和结构体所实现,
            类和结构体继承这个接口的时候,必须实现接口中定义的所有的成员



            //接口只是一种规范,不具备存储数据和定义方法的能力
            //类和结构体实现这个接口的时候,以这个接口的规范为准,进行一一实现,具体怎么实现,
            还是由类和结构体决定
            
            //接口:指定规则,应该有什么
            //类和结构体:实现接口指定的规则,具体怎么有


        }
    }
        //定义一个接口 接口的名字一般以I开头
        //格式:interface 接口的名称{成员}
    interface IBook { 

            //属性
            string Name { get; set; }
            double Price { get; set; }
            void Fn();
            void Fn(string v);

     }

    interface IPaper
    {
        string Type { get; set; }
        string Color { get; set; }
        double Height { get;set; }
    }

    //让某个类实现这个接口,某个类或者结构体实现了这个接口的时候,必须实现这个接口的所有的成员
    //一个类可以使用,实现多个接口
    class Book : IBook, IPaper
    {
        public string Name { get; set; }
        public double Price { get; set; }
        public string Color { get; set; }
        public string Type { get; set; }
        //实现的类总可以拥有更多的成员,但是不能少
        private double price;
        public double Height { get; set; }
        public void Fn() { }
        public void Fn(string v) { }

    }


    interface IPeople
    {
        string Name { get; set; }
        char Sex { get; set; }
        int Age { get; set; }




    }
    interface IStudent
    {
        string StudentNo { get; set; }
        double Age { get; set; }
    }
    class People : IPeople
    {
        public string Name { get; set; }
        public char Sex { get; set; }
        public int Age { get; set; }
    }

    class Student : People, IStudent
    {
        public string StudentNo { get; set; }
        //当基类拥有和接口中同名的属性的时候,派生类不需要自己实现,也可以使用new关键字重新实现(了解);
        public  new double Age { get; set; }
        public void Study()
        {
            Console.WriteLine("我爱学习");
        }
    }



    }

多接口

  1. 当一个类实现的多个接口中拥有相同的类型和相同的属性,只实现一个即可
  2. 当一个类实现的多个接口中拥有不同类型的相同属性,需要使用显示接口实现
  3. 显示接口的实现,不需要也不能加访问修饰符,这个成员访问需要将对象标识为对应的接口的类型
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _03_多接口
{
    internal class Program
    {
        static void Main(string[] args)
        {
           




        }

    }

    interface IA
    {
        string A { get; set; }
        string B { get; set; }
        int D { get; set;}
        void Fn(int v);
    }


    interface IB
    {
       
        string B { get; set; }
        string C { get; set; }
        string D { get;set; }
        void Fn(string v);
    }

    //类可以实现多个接口
    class Tset : IA, IB
    {
        public string A { get; set; }
        //当一个类实现的多个接口中拥有相同的类型和相同的属性,只实现一个即可
        public string B { get; set; }
        

        //当一个类实现的多个接口中拥有不同类型的相同属性,需要使用显示接口实现
        //显示接口的实现,不需要也不能加访问修饰符,这个成员访问需要将对象标识为对应的接口的类型
        int IA.D { get; set; }
        string IB.D { get; set; }
        public bool D { get; set; } 

        //因为方法可以重载,所以可以直接重载两个接口的方法
        public void  Fn(int v) { }
        public void Fn(string v) { }
    }


}

接口的继承

  1. 一个接口可以继承另一个接口,如果接口B继承了接口A,某个类实现了接口B的时候,要实现A和B的所有的成员
  2. 抽象类和接口有什么异同?

  • 相同点:

  • 1.抽象类和接口都不能实例化 不能new

  • 2.都可以包含未实现的方法,由派生类去实现

  • 不同点:

  • 1.抽象类可以包含非抽象成员 接口只能包含抽象成员(这里的抽象可以理解无实现)

  • 2.抽象类只能被实现一个 而接口可以被实现多个(多个接口用逗号隔开·)

  • 3.抽象类的派生类需要使用override去覆写抽象类的抽象成员 接口派生类直接覆写

  • 4.抽象类可以包含访问修饰符 接口不能有访问修饰符

  • 5.抽象类可以包含属性 字段 方法(只能是抽象方法) 接口只能包含属性和方法(不能有抽象方法)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _04_接口的继承
{
    internal class Program
    {
        static void Main(string[] args)
        {

        }
    }
    interface IPeople
    {
        string Name { get; set; }
        int Age { get; set; }
    }

    //一个接口可以继承另一个接口,如果接口B继承了接口A,某个类实现了接口B的时候,要实现A和B的所有的成员
    interface IStudent : IPeople
    {
        string StudentId { get; set;}
       void Study();

    }


    class Student : IStudent
    {
        public string StudentId { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
        public string Name { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
        public int Age { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }

        public void Study()
        {
            throw new NotImplementedException();
        }
    }


}

索引器

索引器: 一种可以让我们使用 “索引” 来访问对象的一种方式

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _05_索引器
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //索引器: 一种可以让我们使用 "索引" 来访问对象的一种方式

           ClassRoom room = new ClassRoom();
           room.Add(new Student() { Name = "吴亦凡", Sex = "男" });
           room.Add(new Student() { Name = "罗志祥", Sex = "男" });
           room.Add(new Student() { Name = "李云迪", Sex = "女" });
           room.Add(new Student() { Name = "郑爽", Sex = "女" });


            //需求:想访问数组中的数据一样,通过索引获取班级中学生的姓名

            Console.WriteLine(room[0].Name); 
            Console.WriteLine(room[1].Name);
            //通过索引这是值,将会执行索引器中的set代码块
            room[3]=new Student() { Name="李易峰",Sex="男"};


            Student s = room["吴亦凡"];//返回Name属性为吴亦凡的那个对象


        }
    }
    class Student
    {
        public string Name { get; set; }
        public string Sex { get; set; }

    }
    class ClassRoom
    {
        public string No { get; set; }
        public string Name { get; set; }

        private List<Student> student =new List<Student>();
        public void Add(Student s)
        {
            student.Add(s);
        }

        //给类中添加一个索引器,这个类的实例就可以想数组一样通过索引进行访问了
        //格式:public 返回值类型 this[索引的类型 索引] {}
        public Student this[int index]
        {
            //通过索引来访问数据的时候执行
            get
            {
                //当前访问的索引
                Console.WriteLine(index);

                return student[index];
            }
            //通过索引来设置这个数据的时候执行(如果没有set代码块,表示这个索引器是只读)
            set
            {
                student[index] = value;
            }


        }
        public Student this[string index]
        {
            get
            {
                //根据传入的值,也就是学生的姓名进行对象的查找
                //for (int i = 0; i < student.Count; i++)
                //{
                //    if (student[i].Name==index)
                //    {
                //        return student[i]; 
                //    }
                //}
                //return null;

                return student.Find(student => student.Name == index);
            }
        }
    }
}

索引器练习

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _06_索引器练习
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Student student =new Student(new string[] {"吴凡","罗祥","李迪"});
            Console.WriteLine(student.Name);
            Console.WriteLine(student[0]);
            Console.WriteLine(student[1]);


            student[3] = "郑";
            Console.WriteLine(student[3]);
        }
    }
    class Student
    {
        // 存储所有学生的名字
        string[] names;
        //Name 设置默认值 为第一个学生的名字
        public string Name { get => names[0]; }
        public Student(string[] names) { 

            this.names = names;
        }

        public string this[int index] {

            //get
            //{
            //    return names[index];
            //}
            get => names[index];
            set
            {
                if (index>=Name.Length)
                {
                    string[] NewNames=new string[index+1];
                    Array.Copy(names, NewNames, names.Length);
                    NewNames[index] = value;
                    names = NewNames;
                }
                else
                {
                    names[index]=value;
                }

            }
        
        }




    }
}

命名空间

  1. 我们的代码越来越多,类越来越多,代码写在同一个文件夹中会导致某个文件结构复杂,代码格式杂乱.命名空间可以让我们在不同的文件中书写代码,不同的文件互相引用
  2. namespace 用来定义一个命名空间 命名空间以大驼峰命名法命名
  3. 如果出现多个命名空间下拥有相同的成员,我们使用的时候会导致不明确的指向
  4. 可以使用 重命名的方案会进行处理
    using myCar1 = Car1.Car;
    using myCar2 = Car2.Car;


//using 命名空间的名称  引用其他的命名空间
using fanfan;

using luozhixiang.xiangxiang;

//如果出现多个命名空间下拥有相同的成员,我们使用的时候会导致不明确的指向
//可以使用 重命名的方案会进行处理
using myCar1 =  Car1.Car;
using myCar2 =  Car2.Car;

//namespace 用来定义一个命名空间 命名空间以大驼峰命名法命名
//格式:namespace 命名空间的名称

//我们的代码越来越多,类越来越多,代码写在同一个文件夹中会导致某个文件结构复杂,代码格式杂乱
//命名空间可以让我们在不同的文件中书写代码,不同的文件互相引用
namespace _07_命名空间
{
    internal class Program
    {
        static void Main(string[] args)
        {
            System.Console.WriteLine("控制台打印");



            //在同一个项目的不同文件中,可以直接访问相同命名空间下的其他类
            People people = new People();
            Student student = new Student();


            //当某个类和当前类不再同一个命名空间下的时候
            //使用 命名空间.目标名称 来引用

            fanfan.Book book1 = new fanfan.Book();

            //我们如果频繁使用其他命名空间的类,结构体 接口等,需要using关键字引用
            //使用using引用之后,就可以把它内部的成员当做相同命名空间下的成员来使用了
            fanfan.Book book2 = new fanfan.Book();
            Book book3 =new Book();

            luozhixiang.xiangxiang.C c = new luozhixiang.xiangxiang.C();

            C c2 = new C();

            luozhixiang.Tool.Test.AA.A a=new luozhixiang.Tool.Test.AA.A();

            Car1.Car cc1 =new Car1.Car();
            Car2.Car cc2 = new Car2.Car();

            myCar1 my1=new myCar1();
        }
    }
}

引用静态类

静态成员可以在using static 引入之后 直接访问
非静态成员 使用实例进行访问


//using xxx 只能引入命名空间 System.Console 不是命名空间 而是一个类 所以不能被引用
//using System.Console;


//我们可以使用using static 引用类, 就可以直接使用类中的静态成员了

using  static System.Console;
using static fanfan.Test;
using fanfan;

namespace _08_引用静态类
{
    internal class Program
    {
        static void Main(string[] args)
        {
            WriteLine("控制台打印");
            WriteLine("控制台打印");

            //静态成员可以在using static 引入之后 直接访问
            Fn1();
            //非静态成员 使用实例进行访问
           new Test().Fn2();
        }
    }
}

引用其他项目

引用同一解决方案下的其他项目

​ 1.当前项目中的"引用"上,右键点击

​ 2.在弹出的菜单中选择添加引用

​ 3.选择 “项目” ==> “解决方案”

​ 4.勾选需要引用的项目

​ 5.点击确定

​ 6.根据对应的项目的命名空间进行引用

引用其他解决方案的项目

​ 1.当前项目中的"引用"上,右键点击

​ 2.在弹出的菜单中选择"添加引用"

​ 3.选择"项目"==>“解决方案”

​ 4.点击"浏览"

​ 5.找到对应解决方案中对应的项目文件 “解决方案目录”–> 项目目录–>bin -->Debug —>Next.x —> xxx.dll或者 xxx.exe

​ 6.点击确定

​ 7.根据对应项目的命名空间进行引用

上期习题答案

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _01_昨天作业
{
    internal class Program
    {
        static void Main(string[] args)
        {
        }
    }
    class Animal
    {
        //Name、MaxAge(最大寿命)、NowAge(当前的年龄，生成对象时随机设置)、Sex
        public string Name { get; set; }
        public int MaxAge { get; set; }
        private int nowAge;
        public int NowAge
        {
            get => nowAge;
            set
            {
                if (value > MaxAge)
                {
                    throw new Exception("年龄超出最大年龄限制");
                }
                nowAge = value;
            }
        }
        public char Sex { get; set; }
        // 一个随机对象，根据最大年龄设置当前年龄
        Random random = new Random();

        public Animal(int maxAge)
        {
            MaxAge = maxAge;
            // 在构造方法中进行年龄的初始化
            NowAge = random.Next(maxAge + 1);
        }
    }
    class Dog : Animal
    {
        // 指定一个无参的构造，当没有传递参数时指定MaxAge为34
        public Dog() : base(34) { }
        // 一个有参的构造，当传递参数时指定MaxAge为传递的值
        public Dog(int maxAge) : base(maxAge) { }

        public void Speak()
        {
            Console.WriteLine("汪汪汪");
        }
    }
    class Cat : Animal
    {
        // 指定一个无参的构造，当没有传递参数时指定MaxAge为39
        public Cat() : base(39) { }
        // 一个有参的构造，当传递参数时指定MaxAge为传递的值
        public Cat(int maxAge) : base(maxAge) { }

        public void Speak()
        {
            Console.WriteLine("喵喵喵");
        }
    }
    class Area
    {
        /// <summary>
        /// 计算矩形的面积
        /// </summary>
        /// <param name="lenght">长</param>
        /// <param name="width">宽</param>
        /// <returns>矩形的面积</returns>
        public static int GetArea(int lenght, int width)
        {
            return lenght * width;
        }

        /// <summary>
        /// 计算正方形的编辑
        /// </summary>
        /// <param name="lenght">边长</param>
        /// <returns>正方形的面积</returns>
        public static int GetArea(int lenght)
        {
            return lenght * lenght;
        }
        /// <summary>
        /// 计算梯形的面积
        /// </summary>
        /// <param name="top">上底长度</param>
        /// <param name="botoom">下底的长度</param>
        /// <param name="h">高度</param>
        /// <returns></returns>
        public static int GetArea(int top, int botoom, int h)
        {
            return (top + botoom) * h / 2;
        }
    }
    //抽象学生类
    abstract class Student
    {
        public abstract int Authority();
    }
    //本科生
    class Undergraduate : Student
    {
        public override int Authority()
        {
            return 5;
        }
    }

    //硕士生
    class Postgraduate : Student
    {
        public override int Authority()
        {
            return 10;
        }
    }
    //博士生
    class Doctor : Student
    {
        public override int Authority()
        {
            return 15;
        }
    }
    abstract class Pay
    {
        public string Id { get; set; }//账号
        public string Pws { get; set; }//密码
        public abstract void payment(double v);//支付的方法,应该接收金额
        public abstract void payment(double v, string account);//支付的方法,应该接收金额
    }
    class WeiXinPay : Pay
    {
        public override void payment(double v)
        {
            Console.WriteLine($"使用微信支付{v}圆,账号是{Id},密码{Pws}");
        }
        public override void payment(double v, string account)
        {
            Console.WriteLine($"使用微信支付给{account}{v}元,账号是{Id},密码{Pws}");
        }

    }
    class AliPay : Pay
    {
        public override void payment(double v)
        {
            Console.WriteLine($"使用支付宝支付{v}圆,账号是{Id},密码{Pws}");
        }
        public override void payment(double v, string account)
        {
            Console.WriteLine($"使用支付宝支付给{account}{v}元,账号是{Id},密码{Pws}");
        }

    }
}

本期习题

  1. 创建一个用于存储某公司员工信息的类Employee，并且可以通过索引来访问员工的姓名和年龄。（提示：使用字典）

    Employee employee = new Employee();

                employee[22] = "fanfan";   // 员工年龄22，名字 fanfan
            employee[22]  = "luoluo"; // 员工年龄22，名字 luoluo
            employee[23] = "Bob";  员工年龄23，名字 Bob
            employee["aa"] = 25;
            employee["Bob"] = 29; //修改Bob的年龄为29

  2. 创建一个名为DictionaryWrapper的类，它包装了一个Dictionary对象，并提供了一个索引器，允许我们通过键的部分名称来访问字典中的值。（提示，索引器可以接收多个参数）
    DictionaryWrapper dictionaryWrapper = new DictionaryWrapper();

    // 设置字典中的键值对
dictionaryWrapper["dog"] = "狗";
dictionaryWrapper["cat"] = "猫";
dictionaryWrapper["elephant"] = "大象";
dictionaryWrapper["dolphin"] = "海豚";

// 输出字典中的值
Console.WriteLine("通过完整键访问:");
Console.WriteLine("dog的值是：" + dictionaryWrapper["dog"]);    // 狗
Console.WriteLine("cat的值是：" + dictionaryWrapper["cat"]);    // 猫
Console.WriteLine("elephant的值是：" + dictionaryWrapper["elephant"]);  // 大象
Console.WriteLine("dolphin的值是：" + dictionaryWrapper["dolphin"]);    // 海豚

Console.WriteLine("\n通过键的部分名称访问:");
Console.WriteLine("以\"do\"开头的键的第一个值是：" + dictionaryWrapper["do", 0]);   // 狗
Console.WriteLine("以\"do\"开头的键的第二个值是：" + dictionaryWrapper["do", 1]);   // 海豚

  3. 将练习1中的类在其他的项目中使用

  4. 将练习2中的类提取到另一个解决方案，并在当前项目中使用

2401_82410658
关注
  • 52
    点赞
  • 踩
  • 42
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C#与命名空间和索引器
qq_42200934的博客
07-20 253
1、引用命名空间的方法是利用using指令，使用格式如下： using【别名=】命名空间   或   using【别名=】命名空间.成员 using mysn = System.Math; //声明命名空间中某个类的别名 namespace 命名空间 { class Program { static void Main(string[] args) ...
C# list集合 重复元素 索引_C# 集合
weixin_39680121的博客
11-20 1171
数组可以保存多个兑现个，但是某些情况下无法确定到底需要保存多少个对象，由于数组的长度不可变，因此数组将不再适用。 为了保存这些数目不确定的对象C#提供了一系列特殊的类，这些类可以储存任意类型的对象，并且长度可变，统称为集合集合分类：可以分为非泛型集合和泛型集合，二者均间接实现了IEnumerble接口非泛型集合： 非泛型集合位于System.Collectio...
C#_泛型_委托
2401_82410658的博客
03-25 1384
C# 中的委托（Delegate）类似于 C 或 C++ 中函数的指针。委托（Delegate） 是存有对某个方法的引用的一种引用类型变量。是一种规范，它允许我们使用占位符来定义类和方法，编译器会在编译时将这些占位符替换为指定的类型，利用泛型的这一特性我们可以定义通用类（泛型类）,方法（泛型方法）,接口(泛型接口)。2.当委托中没有存储任何方法的时候,执行会报错:未将对象引用设置到对象的实例 ,解决方法—简写为?主页有21天速通C#教程欢迎订阅!1.委托被调用的时候,会执行该委托变量中存储的所有的方法。
唐老师的C#教程练习----索引器
What_hope的博客
02-17 357
【代码】唐老师的C#教程练习----索引器。
VBA 字典与集合（Dictionary与Collection）
刘岩的专栏
01-05 8536
Dictionary对象将替换Collection对象，并提供附加的语言从而使增加和删除记录的速度比以前提高三倍，虽然Visual Basic 6.0只有很少的新特点，但是具有某些功能强大的新的对象模型，其中之一就是Dictionary对象。Dictionary对象是无处不在的Visual Basic Collection对象的新版本。它的介绍存在于VBScript 2.0，并通过Visual Ba
C#中集合和索引器
wenchm的博客
11-22 1296
继承IEnumerable和IEnumerator接口并定义一个集合来存储商品信息，遍历输出集合中的商品信息。// 集合public class Goods(string code, string name) //定义集合中的元素类，表示商品信息类//编号//名称public class JHClass : IEnumerable, IEnumerator //定义集合类//初始化Goods类型的集合public JHClass(Goods[] gArray) //使用带参构造函数赋值。
十八 C# 迭代器、分部类和索引器
Mwyldnje2003的博客
03-12 1342
迭代器 迭代器（iterator）解决的是集合访问的问题，提供一种方法顺序访问一个集合对象中的各个元素，而不暴露对象内部标识。迭代器还有一个别名：游标（cursor） foreach语句与迭代器的关系：Foreach循环语句可以用来迭代枚举的集合中的所有元素，又称foreach迭代语句 可枚举的：C#中，如果某个类型继承了接口IEnumerable，或者继承了泛型接口IEnumerable或者继承了泛型接口IEnumerable的任何构造类型，那么久成这个类型时可枚举的 常见的可枚举类型：集合，数组，字符
三分之十的菜鸟C#学习小记（十）接口和命名空间
weixin_43109325的博客
06-15 296
接口（Interface） C#接口 接口只包含了成员的声明。成员的定义是派生类的责任。接口提供了派生类应遵循的标准结构。 抽象类在某种程度上与接口类似，但是，它们大多只是用在，当只有少数方法由基类声明，由派生类实现时。 接口语法： using System; // 接口定义 interface IMyInterface { void MethodToImplement(); } // 接口实现：和继承类似 class InterfaceImplementer : IMyInterface {
C# 语法基础.zip_c# 语法_ozn_语法基础
07-15
总的来说，C#的基础语法涵盖了变量、数据类型、函数、控制流、数组、类、命名空间、接口、继承和多态等多个方面。理解和掌握这些基础知识，是成为C#程序员的关键步骤。通过不断的实践和学习，你可以逐步掌握更高级的...
mdb.rar_c# mdb_c++ 操作mdb_数据库
09-24
C#通常使用ADO.NET（ActiveX Data Objects .NET）框架来访问数据库，其中包括System.Data.OleDb命名空间，它提供了对OLE DB提供程序的支持，包括对mdb文件的访问。 结合这些信息，我们可以深入讨论以下几个知识点：...
C#_接口项目例子
02-17
接口只包含方法签名、属性、索引器和事件，不包含实现。例如： ```csharp public interface IMyInterface { void MyMethod(); int MyProperty { get; set; } } ``` 2. **接口实现**：类可以实现一个或多个接口，...
Csharp8InANutshell_C#8.0_C#8.0_c#8_C#8.0中文手册_C#_
10-01
5. **索引器**：C# 8.0引入了索引器，使得你可以通过一个整数或表达式（如`myArray[0..3]`）访问数组或集合的部分元素，增强了代码的简洁性和可读性。 6. **模式匹配增强**：包括在`is`和`switch`语句中的模式匹配...
jihe.rar_C Builder_C#搜索
09-24
2. **C#中的集合搜索**：C#的`System.Collections`和`System.Collections.Generic`命名空间提供了多种集合类型，如`List<T>`、`Dictionary, TValue>`等。在这些集合中，可以使用`Find`、`Any`、`Contains`等方法进行...
C#理论 —— 命名空间、类、方法、封装、多态、接口
Adam's Rib for Antennnin
11-21 1004
文章目录1. 方法1.1 定义方法1.2 调用方法1.2.1 递归调用1.3 参数传递1.3.1 按值传递参数1.3.2 按引用传递参数1.3.3 按输出传递参数 1. 方法 一个方法（函数）是把一些相关功能的语句组织在一起，用来执行一个任务的语句块。每一个 C# 程序至少有一个带有 Main 方法的类。 1.1 定义方法 语法： <访问修饰符> <返回值类型> <方法名>(参数列表) { ... } 例程： class NumberManipulator {
记录｜使用ＨslCommunication库进行写入Real数据的坑
最新发布
技术小白=-=的博客
07-24 498
现在已经通过HslCommunication连接上了PLC，需要对DB1.DBD10的位置处进行数据写入。
C# 与C++ cli
汤圆
07-23 582
问题起因：“windows.h”间接引入了 servprov.h， 而 servprov.h中存在：typedef interface IServiceProvider IServiceProvider;其中 IServiceProvider与System命名空间中的 IServiceProvider冲突，从而引起不确定性。解决办法： 优先 using namespace System 引用。
Unity监听某个值是否改变，c#数值监听器
GoodCooking的博客
07-23 301
Unity监听某个值是否改变，c#数值监听器
C# __FUNCTION__
01-13
C#中没有内置的__FUNCTION__关键字来获取当前函数的名称。但是你可以使用System.Reflection命名空间中的MethodInfo类来获取当前函数的名称。下面是一个示例代码： ```csharp using System; using System.Reflection; public class MyClass { public void MyMethod() { string functionName = MethodBase.GetCurrentMethod().Name; Console.WriteLine("Current function name: " + functionName); } } public class Program { public static void Main(string[] args) { MyClass myObject = new MyClass(); myObject.MyMethod(); // 输出：Current function name: MyMethod } } ``` 在上面的示例中，我们使用MethodBase.GetCurrentMethod().Name来获取当前函数的名称，并将其打印出来。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值