【C# Programming】编程入门:方法和参数

一、方法

1、方法的定义

由一系列以执行特定的操作或计算结果语句组成。方法总是和类关联,类型将相关的方法分为一组。

  • 方法名称
  • 形参和实参(parameter & argument)
  • 返回值

2、命名空间

一种分类机制,用于组合功能相关的所有类型。命名空间是分级的,级数可以是任意。 命名空间层级一般从公司名开始,然后是产品名,最后是功能领域,例如:

  • Microsoft.Win32.Networking

主要用于按照功能领域组织,以便更容易查找和理解它们。除此之外,命名空间还有助于防止类型名称发生冲突.

3、作用域

  • 可以通过非限定名称引用到的区域
  • 对于某个类型中一个方法的调用,如果这个方法在类型中声明,那么对该方法的调用不需要使用类型限定符; 类似的,一个类型对声明了它的整个命名空间也都在作用域内。

二、表达式

1、表达式主题成员

表达式主体成员提供了一种更简洁、更可读的成员实现

|--------------|--------------------|
| Member | Supported as of... |
| Method | C# 6 |
| Constructor | C# 7 |
| Finalizer | C# 7 |
| Property Get | C# 6 |
| Property Set | C# 7 |
| Indexer | C# 7 |

语法:member => expression

2、表达式主体方法

表达式主体方法使用箭头操作符 (=>) 将单个表达式分配到一个属性或方法来替代语句体 ,如果方法有返回值, 该表达式返回值必须与方法返回类型相同;如果方法无返回值,则表达式执行一系列操作。

public class Person 
{ 
     public Person(string firstName, string lastName) 
     { 
         fname = firstName; 
         lname = lastName; 
     }
     private string fname; 
     private string lname; 
     public override string ToString() => $"{fname} {lname}".Trim();
     public void DisplayName() => Console.WriteLine(ToString());
 } 

三、方法声明

C# 不支持全局方法,所有方法都必须在某个类型中。

public class Program
{
    public static void ChapterMain()
    {
        string firstName, lastName, fullName, initials;
        System.Console.WriteLine("Hey you!");
        firstName = GetUserInput("Enter your first name: ");
        lastName = GetUserInput("Enter your last name: ");
        fullName = GetFullName(firstName, lastName);
        initials = GetInitials(firstName, lastName);
        DisplayGreeting(fullName, initials);
    }
    static string GetUserInput(string prompt)
    {
        System.Console.Write(prompt);
        return System.Console.ReadLine();
    }
    static string GetFullName(  string firstName, string lastName) => $"{ firstName } { lastName }";
    static void DisplayGreeting(string fullName, string initials)
    {
        System.Console.WriteLine($"Hello { fullName }! Your initials are { initials }");
    }
    static string GetInitials(string firstName, string lastName)
    {
        return $"{ firstName[0] }. { lastName[0] }.";
    }
}

四、Main() 的返回值和参数

C# 支持在执行程序时提供命令行参数,并运行从Main() 方法返回状态标识符,当需要从非Main()方法中访问命令行参数时, 可用System.Environment.GetcommandLineArgs() 方法:

public static int  Main(string[] args)
{
    int result;
    string targetFileName, string url;
    switch(args.Length)
    {
        default:
            Console.WriteLine("ERROR:  You must specify the "+ "URL and the file name"); // Exactly two arguments must be specified; give an error.
            targetFileName = null;
            url = null;
            break;
        case 2:
            url = args[0];
            targetFileName = args[1];
            break;
    }
    if(targetFileName != null && url != null)
    {
        using (HttpClient httpClient = new HttpClient())
        using (HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, url))
        using (HttpResponseMessage message = httpClient.SendAsync(request).Result)
        using (Stream contentStream = message.Content.ReadAsStreamAsync().Result)
        using (FileStream fileStream = new FileStream(targetFileName, FileMode.Create, FileAccess.Write, FileShare.None))
        {
            contentStream.CopyToAsync(fileStream);
        }
        return 0;
    }
    Console.WriteLine("Usage: Downloader.exe <URL> <TargetFileName>");
    return 1;
}

五、方法的参数

1、值参数

C# 中,参数传递默认是值传递的, 也就是说,参数表达式的值会复制到目标参数中。

  • 对于值类型参数,方法获得是值的副本,所以方法内无法改变实参的值

  • 对于引用类型参数,方法获得的是引用(地址)的副本,方法可以改变引用对象的值

    public static void ChapterMain()
    {
    string fullName;
    string driveLetter = "C:";
    string folderPath = "Data";
    string fileName = "index.html";
    fullName = Combine(driveLetter, folderPath, fileName);
    Console.WriteLine(fullName);
    }
    static string Combine(string driveLetter, string folderPath, string fileName)
    {
    string path;
    path = string.Format("{1}{0}{2}{0}{3}", System.IO.Path.DirectorySeparatorChar, driveLetter, folderPath, fileName);
    return path;
    }

2、引用参数(ref)

  • ref 关键字表明参数是通过引用传递而不是值传递。无论实参是值类型还是引用类型,都可以通过引用传递

  • 如果方法定义使用了ref 关键字,调用方法时实参前必须显式使用ref 限定

  • 使用ref 限定的实参必须在调用前初始化

  • 对于值类型参数,引用传递使得方法 可以改变实参的值

    class RefExample
    {
    static void Method(ref int i)
    {
    i = i + 44;
    }
    static void Main()
    {
    int val = 1;
    Method(ref val);
    Console.WriteLine(val); // Output: 45
    }
    }

  • 对于引用类型参数,引用传递使得方法不仅可以改变引用对象的值,也可以更换引用参数引用的对象

    class RefExample2
    {
    static void Main()
    {
    Product item = new Product("Fasteners", 54321);// Declare an instance of Product and display its initial values.
    System.Console.WriteLine("Original values in Main. Name: {0}, ID: {1}\n", item.ItemName, item.ItemID);
    ChangeByReference(ref item); // Pass the product instance to ChangeByReference.
    System.Console.WriteLine("Back in Main. Name: {0}, ID: {1}\n", item.ItemName, item.ItemID);
    }
    static void ChangeByReference(ref Product itemRef)
    {
    // Change the address that is stored in the itemRef parameter.
    itemRef = new Product("Stapler", 99999);
    itemRef.ItemID = 12345;
    }
    }
    class Product
    {
    public Product(string name, int newID)
    {
    ItemName = name;
    ItemID = newID;
    }
    public string ItemName { get; set; }
    public int ItemID { get; set; }
    }

3、out参数

  1. 类似ref,out也表明参数是通过引用传递而不是值传递; 方法定义时形参指定了out,调用时实参也必须使用out 显式指定

  2. out 和ref 区别如下:

    1. 使用out限定的实参不必在调用前初始化
    2. 方法在返回前必须对所有out参数赋值,编译器会检查所有返回路径确保所有的out 参数被赋值
  3. out 常用于需要从方法返回多个值的场合

    class OutReturnExample
    {
    static void Method(out int i, out string s1, out string s2)
    {
    i = 44;
    s1 = "I've been returned";
    s2 = null;
    }
    static void Main()
    {
    int value;
    string str1, str2;
    Method(out value, out str1, out str2);
    }
    }

4、参数数组(param)

通过在方法参数前显式指定 param, C# 允许在调用方法时提供可变数量参数

  • 参数数组不一定是方法的唯一参数,但必须是方法最后一个参数

  • 实参的类型必须兼容与参数数组中元素的类型

  • 调用者既可以传递以逗号分隔的参数,也可以显式使用数组

  • 调用者可以指定和参数数组对应的零个实参

    public static void ChapterMain()
    {
    string fullName;
    fullName = Combine(Directory.GetCurrentDirectory(), "bin", "config", "index.html"); // Call Combine() with four parameters
    Console.WriteLine(fullName);
    fullName = Combine(Directory.GetParent(Directory.GetCurrentDirectory()).FullName, "Temp", "index.html"); // Call Combine() with only three parameters
    Console.WriteLine(fullName);
    fullName = Combine( new string[] {$"C:{Path.DirectorySeparatorChar}", "Data", "HomeDir", "index.html" }); // Call Combine() with an array
    Console.WriteLine(fullName);
    }
    static string Combine(params string[] paths)
    {
    string result = string.Empty;
    foreach (string path in paths)
    result = System.IO.Path.Combine(result, path);
    return result;
    }

5、命名参数(named argument)

调用者显式地为一个参数赋值

  • 调用者能以任何次序指定参数

  • 当命名参数和常规方法混合使用时,命名参数必须在所有常规参数传递之后

    static void Main(string[] args)
    {
    PrintOrderDetails("Gift Shop", 31, "Red Mug"); // The method can be called in the normal way, by using positional arguments.
    // Named arguments can be supplied for the parameters in any order.
    PrintOrderDetails(orderNum: 31, productName: "Red Mug", sellerName: "Gift Shop");
    PrintOrderDetails(productName: "Red Mug", sellerName: "Gift Shop", orderNum: 31);
    // Named arguments mixed with positional arguments are valid as long as they are used in their correct position.
    PrintOrderDetails("Gift Shop", 31, productName: "Red Mug");
    // However, mixed arguments are invalid if used out-of-order. The following statements will cause a compiler error.
    // PrintOrderDetails(productName: "Red Mug", 31, "Gift Shop");
    // PrintOrderDetails(31, sellerName: "Gift Shop", "Red Mug");
    // PrintOrderDetails(31, "Red Mug", sellerName: "Gift Shop");
    }
    static void PrintOrderDetails(string sellerName, int orderNum, string productName)
    {
    if (string.IsNullOrWhiteSpace(sellerName))
    throw new ArgumentException(message: "Seller name cannot be null or empty.", paramName: nameof(sellerName));
    Console.WriteLine($"Seller: {sellerName}, Order #: {orderNum}, Product: {productName}");
    }

6、可选参数(optional arguments)

  1. 方法定义时可指定参数是否可选。方法调用时必须提供所有非可选参数,允许忽略可选参数。
  2. 每个可选参数都必须有缺省值,缺省值为以下类型之一
    1. 常量表达式
    2. 形如 new valType 的表达式; valType 为值类型,比如:struct 和 enum
    3. 形如 default(valType) 的表达式; valType为值类型
  3. 可选参数类型必须在所有非可选参数之后定义。
  4. 方法调用时,如果为某一可选参数提供了值,该参数之前的所有可选参数都必须指定值;但是使用命名参数可以忽略该规则

可选参数例子:

static void Main(string[] args)
{
    // Instance anExample does not send an argument for the constructor's optional parameter.
    ExampleClass anExample = new ExampleClass();
    anExample.ExampleMethod(1, "One", 1);
    anExample.ExampleMethod(2, "Two");
    anExample.ExampleMethod(3);
    // Instance anotherExample sends an argument for the constructor's optional parameter.
    ExampleClass anotherExample = new ExampleClass("Provided name");
    anotherExample.ExampleMethod(1, "One", 1);
    anotherExample.ExampleMethod(2, "Two");
    anotherExample.ExampleMethod(3);
                        
    // You cannot leave a gap in the provided arguments.
    //anExample.ExampleMethod(3, ,4);
    //anExample.ExampleMethod(3, 4);
    // You can use a named parameter to make the previous statement work.
    anExample.ExampleMethod(3, optionalint: 4);
}
class ExampleClass
{
    private string _name;
    public ExampleClass(string name = "Default name")
    {
        _name = name;
    }
    public void ExampleMethod(int required, string optionalstr = "default string", int optionalint = 10)
    {
        Console.WriteLine("{0}: {1}, {2}, and {3}.", _name, required, optionalstr, optionalint);
    }
}

六、方法重载

类似于C++, C# 也支持方法重载。C# 根据参数类型和参数个数选择最匹配的方法

命名参数和可选参数影响重载规则

  • 如果方法每个参数或者是可选的,或按名称或位置恰好对一个实参,且该实参可转换为参数的类型,则方法成为候选项。
  • 如果找到多个候选项,则首选转换的重载规则应用于显式指定的实参。忽略调用者没有提供实参的所有可选参数 。
  • 如果两个候选项不相上下,优先选择没有使用缺省值的可选参数的候选项。 这是重载决策中优先选择参数较少的候选项规则产生 的结果。
相关推荐
喵呜角角2 分钟前
QML TableView 实例演示 + 可能遇到的一些问题(Qt_6_5_3)
开发语言·windows·qt·qml·qt quick
撸码到无法自拔2 分钟前
R语言贝叶斯分析:INLA 、MCMC混合模型、生存分析肿瘤临床试验、间歇泉喷发时间数据应用|附数据代码...
开发语言·r语言
SSONICX2 分钟前
QT:生成二维码 QRCode
开发语言·qt
老汉忒cpp6 分钟前
Qt-系统相关(1)事件&文件
开发语言·qt
小宋102125 分钟前
实现java执行kettle并传参数
java·开发语言·etl
FreeLikeTheWind.39 分钟前
C语言实例之9斐波那契数列实现
c语言·开发语言·算法
爱编程— 的小李1 小时前
文件的处理(c语言)
c语言·开发语言
就是有点傻1 小时前
C#中面试的常见问题007
面试·c#·wpf
monkey_meng1 小时前
【Rust Iterator 之 fold,map,filter,for_each】
开发语言·后端·rust
Vae_Mars1 小时前
QT-protected
开发语言·qt