C# 中的函数与方法

在 C# 中,函数是一段代码块,用于执行特定的任务或操作。函数也被称为方法(method),它们是面向对象编程(OOP)的基本构建块之一。函数使代码模块化,提高代码的可读性、可维护性和重用性。

简单的函数定义

这个示例展示了如何在 C# 中定义和使用方法,以及如何传递参数和获取返回值。方法使得我们可以封装一些特定的功能,以便在程序中多次使用,并且可以接收参数和返回值来处理不同的情况。

下面是对代码的解释:

  1. Program 类中定义了两个静态方法 GetMaxIsRun

    • GetMax 方法接受两个整数参数 xy,并返回其中较大的值。
    • IsRun 方法接受一个整数参数 year,用于判断给定年份是否是闰年,并返回布尔值。
  2. Main 方法中,调用了这两个方法并将结果输出到控制台。

    • 调用 GetMax 方法,传递参数 100 和 200,并将返回的结果赋值给 max 变量。然后使用 Console.WriteLine 方法输出最大值。
    • 调用 IsRun 方法,传递参数 2020,并将返回的结果赋值给 ret 变量。然后使用 Console.WriteLine 方法输出是否为闰年。
  3. 程序在控制台等待用户输入任意键后结束运行。

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

namespace ConsoleApplication1
{
    class Program
    {
        // 定义一个方法,并提供参数传递
        public static int GetMax(int x, int y)
        {
            return x > y ? x : y;
        }
        // 定义一个判断闰年的方法
        public static bool IsRun(int year)
        {
            bool ret = (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
            return ret;
        }

        static void Main(string[] args)
        {
            int max = Program.GetMax(100, 200);
            Console.WriteLine("最大值: {0}", max);

            bool ret = Program.IsRun(2020);
            Console.WriteLine("闰年: {0}", ret);

            Console.ReadKey();
        }
    }
}

方法传递数组与字符串

这段代码展示了在 C# 中如何通过方法传递数组和字符串。下面是对代码的解释:

  1. Program 类中定义了两个静态方法 GetSumIsString

    • GetSum 方法接受一个整数数组作为参数 Array,并对数组中的元素进行求和操作,最后返回求和结果。
    • IsString 方法接受一个字符串参数 str,并直接返回该字符串。
  2. Main 方法中,创建一个整数数组 Array,并初始化数组的值为 1, 2, 3, 4, 5。

  3. 调用 GetSum 方法,传递数组 Array 作为参数,并将返回的结果赋值给 ret_sum 变量。然后使用 Console.WriteLine 方法输出求和结果。

  4. 调用 IsString 方法,传递字符串 "hello lyshark" 作为参数,并将返回的结果赋值给 ret_str 变量。然后使用 Console.WriteLine 方法输出字符串。

  5. 程序在控制台等待用户输入任意键后结束运行。

总的来说,这个示例演示了如何通过方法在 C# 中传递数组和字符串参数。方法可以接受不同类型的参数,进行特定的处理,并返回结果。这样可以使代码更灵活和可复用。

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

namespace ConsoleApplication1
{
    class Program
    {
        // 方法传递数组
        public static int GetSum(int[] Array)
        {
            int sum = 0;
            for (int x = 0; x < Array.Length; x++)
                sum += Array[x];

            return sum;
        }
        // 方法传递字符串
        public static string IsString(string str)
        {
            return str;
        }

        static void Main(string[] args)
        {
            int[] Array = new int[] { 1, 2, 3, 4, 5 };

            int ret_sum = Program.GetSum(Array);
            Console.WriteLine("相加结果: {0}", ret_sum);

            string ret_str = Program.IsString("hello lyshark");
            Console.WriteLine("字符串: {0}", ret_str);

            Console.ReadKey();
        }
    }
}

Out 方法返回多个参数

这个示例演示了如何使用 out 参数在 C# 中返回多个值。通过将变量声明为 out 参数,并在方法内部对其进行赋值,可以将结果返回给调用方。这种方式比较灵活,能够在方法内部同时返回多个值。

下面是对代码的解释:

  1. Program 类中定义了一个静态方法 GetNum,该方法接受一个整数数组 Array 和两个 out 参数 MaxMin

    • 在方法内部,定义了两个变量 maxmin,分别初始化为 int.MinValueint.MaxValue,用于记录最大值和最小值。
    • 使用循环遍历数组 Array,并根据数组元素更新 maxmin 的值。
    • 最后,将 maxmin 的值分别赋给 MaxMin 参数。
  2. Main 方法中,创建一个整数数组 Array,并初始化数组的值为 2, 6, 9, 3, 10。

    • 同时,定义两个整数变量 MaxMin,用于接收方法 GetNum 的返回值。
  3. 调用 GetNum 方法,将数组 Array 和两个 out 参数 MaxMin 传递给方法。

    • 方法内部会计算数组中的最大值和最小值,并将结果赋值给 MaxMin 参数。
  4. 使用 Console.WriteLine 方法分别输出最大值和最小值。

  5. 程序在控制台等待用户输入任意键后结束运行。

类似C++中的多指针传递,就是说可以一次性传出多个参数。

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

namespace ConsoleApplication1
{
    class Program
    {
        // 返回 max => 最大值 / main => 最小值
        public static void GetNum(int[] Array, out int Max, out int Min)
        {
            int max = int.MinValue;
            int min = int.MaxValue;

            for (int i = 0; i < Array.Length; i++)
            {
                if (Array[i] > max)
                    max = Array[i];

                if (Array[i] < min)
                    min = Array[i];
            }
            Max = max;
            Min = min;
        }

        static void Main(string[] args)
        {
            int[] Array = new int[] { 2,6,9,3,10 };
            int Max = 0;
            int Min = 0;

            GetNum(Array,out Max,out Min);

            Console.WriteLine("最大值: {0}", Max);
            Console.WriteLine("最小值: {0}", Min);

            Console.ReadKey();
        }
    }
}

Out 实现参数返回

这个示例演示了如何自己实现一个类似 int.TryParse 的方法,用于尝试将字符串转换为整数。通过使用 Convert.ToInt32 方法进行转换,并通过 try-catch 块来处理转换过程中可能出现的异常,实现了类似的功能。这种自定义的转换方法可以根据实际需求进行灵活调整,适用于不同的转换场景。

下面是对代码的解释:

  1. Program 类中定义了一个静态方法 MyTryParse,该方法接受一个字符串 Str 和一个 out 参数 result,用于尝试将字符串转换为整数。

    • 方法内部首先将 result 初始化为 0。
    • 使用 Convert.ToInt32 方法尝试将字符串转换为整数,如果成功则将转换后的结果赋给 result 并返回 true
    • 如果转换失败,则会抛出异常,进入 catch 块,返回 false
  2. Main 方法中,定义一个整数变量 number

  3. 调用 int.TryParse 方法,尝试将字符串 "123" 转换为整数,并将转换结果赋给 number 变量,同时获取转换的状态,保存在 sys_ret 变量中。

  4. 调用自己实现的 MyTryParse 方法,尝试将字符串 "456" 转换为整数,并将转换结果赋给 number 变量,同时获取转换的状态,保存在 my_ret 变量中。

  5. 使用 Console.WriteLine 方法分别输出系统转换的结果和自定义转换的结果。

  6. 程序在控制台等待用户输入任意键后结束运行。

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

namespace ConsoleApplication1
{
    class Program
    {
        // 自己实现TryParse
        public static bool MyTryParse(string Str,out int result)
        {
            result = 0;
            try
            {
                result = Convert.ToInt32(Str);
                return true;
            }
            catch
            {
                return false;
            }
        }

        static void Main(string[] args)
        {
          int number = 0;
          bool sys_ret = int.TryParse("123", out number);
          Console.WriteLine("系统转换结果输出: {0} 状态: {1}", number,sys_ret);

          bool my_ret = Program.MyTryParse("456", out number);
          Console.WriteLine("My转换结果输出: {0} 状态:{1}", number,my_ret);

          Console.ReadKey();
        }
    }
}

Ref 变量指针交换

这个示例演示了如何使用 ref 参数来实现变量交换的功能。通过将变量的引用传递给方法,在方法内部通过临时变量进行值交换,从而实现了两个变量的值互换。这种技巧在需要交换变量值时非常有用,可以避免创建额外的临时变量。

下面是对代码的解释:

  1. Program 类中定义了一个静态方法 Exchange,该方法接受两个 ref 参数 xy,用于交换两个整数变量的值。

    • 方法内部创建一个临时变量 tmp,将 x 的值赋给 tmp
    • y 的值赋给 x,实现 xy 的值交换。
    • tmp 的值赋给 y,完成交换操作。
  2. Main 方法中,定义两个整数变量 xy,分别赋值为 100 和 200。

  3. 调用 Exchange 方法,并传递 xy 的引用(使用 ref 关键字),以便在方法内部修改它们的值,实现变量交换。

  4. 使用 Console.WriteLine 方法输出交换后的结果,显示 xy 的值。

  5. 程序在控制台等待用户输入任意键后结束运行。

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

namespace ConsoleApplication1
{
    class Program
    {
        // 变量交换,类似于指针传递
        public static void Exchange(ref int x,ref int y)
        {
            int tmp = x;
            x = y;
            y = tmp;
        }

        static void Main(string[] args)
        {
            int x = 100;
            int y = 200;
            Exchange(ref x, ref y);

            Console.Write("交换后: x = {0} y = {1}", x, y);

            Console.ReadKey();
        }
    }
}

params 传递可变参数

这个示例演示了如何使用可变参数来接受不定数量的字符串参数。在方法定义时,可以指定一个可变参数的名称,使用 params 关键字修饰,表示可以传递多个同类型的参数。在方法内部,可以通过遍历可变参数来处理每个传递进来的字符串。这种技巧在需要接受不定数量的参数时非常有用,可以灵活处理不同数量的参数值。

下面是对代码的解释:

  1. Program 类中定义了一个静态方法 GetName,该方法接受一个整数参数 Number 和可变参数 Str,用于输出指定数量的字符串。

  2. 方法内部使用 for 循环遍历可变参数 Str,并通过 Console.Write 方法输出每个字符串。

  3. Main 方法中,调用 GetName 方法,并传递整数参数 1001 和多个字符串参数("admin", "lyshark", "guest")。

  4. 使用 Console.ReadKey 方法等待用户按下任意键后结束程序的运行。

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

namespace ConsoleApplication1
{
    class Program
    {
        // 指定可变参数
        public static void GetName(int Number,params string[] Str)
        {
            for (int x = 0; x < Str.Length; x++)
                Console.Write(Number + "  " + Str[x] + "  ");
        }

        static void Main(string[] args)
        {
            GetName(1001,"admin", "lyshark", "guest");

            Console.ReadKey();
        }
    }
}

实现方法重载

这段代码演示了方法重载的概念,即在同一个类中定义具有相同名称但参数类型或参数个数不同的多个方法。

下面是对代码的解释:

  1. Program 类中定义了两个重载的 Sum 方法,一个接受两个 double 类型的参数,另一个接受两个 int 类型的参数。这两个方法执行相同的操作,即将两个数字相加并返回结果。

  2. Main 方法中,分别调用了两个重载的 Sum 方法,并传递不同类型的参数。

  3. 使用 Console.WriteLine 方法输出两次调用 Sum 方法的结果。

  4. 使用 Console.ReadKey 方法等待用户按下任意键后结束程序的运行。

方法重载允许在同一个类中定义多个具有相同名称但参数类型或参数个数不同的方法,使得代码更加灵活。在调用方法时,编译器会根据传递的参数类型或个数来确定调用哪个重载的方法。这样可以根据具体需求选择合适的方法进行调用,提高代码的可读性和可维护性。

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

namespace ConsoleApplication1
{
    class Program
    {
        // 方法重载
        public static double Sum(double x,double y)
        {
            return x + y;
        }
        public static int Sum(int x, int y)
        {
            return x + y;
        }

        static void Main(string[] args)
        {
            Console.WriteLine("int => {0}", Sum(10, 20));
            Console.WriteLine("double => {0}", Sum(10.5, 20.5));

            Console.ReadKey();
        }
    }
}
  • 0
    点赞
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

打赏作者

微软技术分享

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

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

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

打赏作者

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

抵扣说明:

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

余额充值