วิธี C #

วิธีการหนึ่งที่จะนำงบที่เกี่ยวข้องบางกลุ่มเข้าด้วยกันสำหรับบล็อกของงบในการดำเนินงานได้ โปรแกรมทุกคนมีอย่างน้อยคลาส C # ด้วยวิธีการหลัก

จะใช้วิธีการที่คุณจะต้อง:

วิธีการนิยาม
วิธีการเรียก

วิธี C # ตามที่กำหนดใน

เมื่อกำหนดวิธีการพื้นฐานการพูดก็เป็นคำสั่งขององค์ประกอบของโครงสร้างที่ ใน C # วิธีนิยามไวยากรณ์เป็นดังนี้:

<เข้าถึง Specifier> <ประเภทกลับ> <ชื่อวิธี> (Parameter List)
{
   ร่างกายวิธี
}

ต่อไปนี้เป็นองค์ประกอบของแต่ละ:

Specifier เข้าถึง: ปรับปรุงการเข้าถึงตัวแปรการตัดสินใจหรือวิธีการสำหรับการแสดงผลชั้นอื่น
ประเภทกลับ: ชนิดกลับวิธีการที่สามารถกลับค่าประเภทผลตอบแทนเป็นชนิดข้อมูลของค่าส่งกลับโดยวิธีการ หากวิธีการไม่คืนค่าใด ๆชนิดที่ส่งกลับมาจะถือเป็นโมฆะ
ชื่อ method: วิธีที่ชื่อเป็นตัวระบุที่ไม่ซ้ำกันและเป็นกรณีที่สำคัญมันไม่สามารถเป็นเช่นเดียวกับการประกาศคลาสระบุอื่น ๆ
รายการพารามิเตอร์: รายการของพารามิเตอร์ในวงเล็บพารามิเตอร์ที่ใช้สำหรับการส่งผ่านข้อมูลและวิธีการที่ได้รับรายการพารามิเตอร์ชนิดพารามิเตอร์หมายถึงวิธีการสั่งซื้อและปริมาณ พารามิเตอร์เป็นตัวเลือกที่จะบอกว่าวิธีการที่อาจจะไม่ได้มีพารามิเตอร์
ร่างกายวิธีการ: ร่างกายวิธีการรวมถึงความจำเป็นที่จะเสร็จงานชุดคำสั่ง

ตัวอย่าง

ส่วนรหัสต่อไปนี้แสดงฟังก์ชั่นFindMax ซึ่งรับสองค่าจำนวนเต็มและผลตอบแทนที่มีขนาดใหญ่ของทั้งสองค่าแต่ก็มีการปรับปรุงการเข้าถึงของประชาชนเพื่อที่จะสามารถเข้าถึงได้โดยใช้ตัวอย่างของการเรียนจากนอกชั้นเรียน

class NumberManipulator
{
   public int FindMax(int num1, int num2)
   {
      /* 局部变量声明 */
      int result;

      if (num1 > num2)
         result = num1;
      else
         result = num2;

      return result;
   }
   ...
}

เรียกวิธีการใน C #

คุณสามารถใช้ชื่อเรียกของวิธีการที่ ตัวอย่างต่อไปนี้แสดงให้เห็นถึงจุดนี้:

การใช้ระบบ

CalculatorApplication namespace
{
   NumberManipulator ระดับ
   {
      int สาธารณะ FindMax (int num1, num2 int)
      {
         / * ประกาศตัวแปรท้องถิ่น * /
         ผล int;

         ถ้า (num1> num2)
            ผล = num1;
         อื่น
            ผล = num2;

         ผลกลับมา
      }
      เป็นโมฆะคง main (String args [])
      {
         / * นิยามตัวแปรท้องถิ่น * /
         int A = 100;
         int B = 200;
         เกษียณ int;
         NumberManipulator n = NumberManipulator ใหม่ ();

         // เรียกวิธี FindMax เกษียณ = n.FindMax (A, B);
         Console.WriteLine ( "แม็กซ์: {0}" เกษียณ);
         Console.ReadLine ();
      }
   }
}

เมื่อโค้ดข้างต้นจะรวบรวมและดำเนินการก็จะก่อให้เกิดผลลัพธ์ต่อไปนี้:

ค่าสูงสุดคือ 200

คุณยังสามารถประเภทอื่น ๆ เช่นวิธีการสาธารณะระดับเรียกจากชั้นอื่น ตัวอย่างเช่นวิธีการFindMaxอยู่ในระดับNumberManipulatorคุณสามารถเรียกได้จากการทดสอบอีกชั้นใน

การใช้ระบบ

CalculatorApplication namespace
{
    NumberManipulator ระดับ
    {
        int สาธารณะ FindMax (int num1, num2 int)
        {
            / * ประกาศตัวแปรท้องถิ่น * /
            ผล int;

            ถ้า (num1> num2)
                ผล = num1;
            อื่น
                ผล = num2;

            ผลกลับมา
        }
    }
    ทดสอบระดับ
    {
        เป็นโมฆะคง main (String args [])
        {
            / * นิยามตัวแปรท้องถิ่น * /
            int A = 100;
            int B = 200;
            เกษียณ int;
            NumberManipulator n = NumberManipulator ใหม่ ();
            // เรียกวิธี FindMax เกษียณ = n.FindMax (A, B);
            Console.WriteLine ( "แม็กซ์: {0}" เกษียณ);
            Console.ReadLine ();

        }
    }
}

เมื่อโค้ดข้างต้นจะรวบรวมและดำเนินการก็จะก่อให้เกิดผลลัพธ์ต่อไปนี้:

最大值是： 200

เรียกวิธีการซ้ำ

วิธีสามารถเรียกตัวเองนี้เรียกว่าการเรียกซ้ำตัวอย่างต่อไปนี้ใช้ฟังก์ชันเวียนในการคำนวณปัจจัยของตัวเลข:

การใช้ระบบ

CalculatorApplication namespace
{
    NumberManipulator ระดับ
    {
        int สาธารณะปัจจัย (int NUM)
        {
            / * นิยามตัวแปรท้องถิ่น * /
            ผล int;

            ถ้า (NUM == 1)
            {
                กลับ 1;
            }
            อื่น
            {
                ผล = ปัจจัย (NUM - 1) * NUM;
                ผลกลับมา
            }
        }
    
        เป็นโมฆะคง main (String args [])
        {
            NumberManipulator n = NumberManipulator ใหม่ ();
            // เรียกวิธี Console.WriteLine ปัจจัย ( "6 ปัจจัยคือ: {0}" n.factorial (6));
            Console.WriteLine ( "7 ปัจจัยคือ: {0}" n.factorial (7));
            Console.WriteLine ( "8 ปัจจัยคือ: {0}" n.factorial (8));
            Console.ReadLine ();

        }
    }
}

เมื่อโค้ดข้างต้นจะรวบรวมและดำเนินการก็จะก่อให้เกิดผลลัพธ์ต่อไปนี้:

6 ปัจจัยคือ 720
7 ปัจจัยคือ: 5040
8 ปัจจัยคือ: 40320

ผ่านพารามิเตอร์

เมื่อคุณเรียกวิธีการที่มีพารามิเตอร์ที่คุณต้องผ่านพารามิเตอร์กับวิธีการ ใน C # มีสามวิธีที่จะส่งผ่านพารามิเตอร์กับวิธีการ:

方式	描述
值参数	这种方式复制参数的实际值给函数的形式参数，实参和形参使用的是两个不同内存中的值。在这种情况下，当形参的值发生改变时，不会影响实参的值，从而保证了实参数据的安全。
引用参数	这种方式复制参数的内存位置的引用给形式参数。这意味着，当形参的值发生改变时，同时也改变实参的值。
输出参数	这种方式可以返回多个值。

ผ่านพารามิเตอร์โดยค่า

นี่คือการส่งผ่านพารามิเตอร์เริ่มต้น ด้วยวิธีนี้เมื่อคุณเรียกวิธีการที่จะสร้างสถานที่เก็บใหม่สำหรับแต่ละพารามิเตอร์

ค่าพารามิเตอร์จริงที่ถูกคัดลอกไปพารามิเตอร์ข้อโต้แย้งและพารามิเตอร์ที่ใช้ในค่าหน่วยความจำที่แตกต่างกันสอง ดังนั้นเมื่อมีการเปลี่ยนแปลงค่าพารามิเตอร์จะไม่ส่งผลกระทบต่อมูลค่าของการโต้แย้งจึงมั่นใจได้ว่าการรักษาความปลอดภัยข้อมูลพารามิเตอร์จริง ตัวอย่างต่อไปนี้แสดงให้เห็นถึงแนวคิดนี้:

using System;
namespace CalculatorApplication
{
   class NumberManipulator
   {
      public void swap(int x, int y)
      {
         int temp;
         
         temp = x; /* 保存 x 的值 */
         x = y;    /* 把 y 赋值给 x */
         y = temp; /* 把 temp 赋值给 y */
      }
      
      static void Main(string[] args)
      {
         NumberManipulator n = new NumberManipulator();
         /* 局部变量定义 */
         int a = 100;
         int b = 200;
         
         Console.WriteLine("在交换之前，a 的值： {0}", a);
         Console.WriteLine("在交换之前，b 的值： {0}", b);
         
         /* 调用函数来交换值 */
         n.swap(a, b);
         
         Console.WriteLine("在交换之后，a 的值： {0}", a);
         Console.WriteLine("在交换之后，b 的值： {0}", b);
         
         Console.ReadLine();
      }
   }
}

เมื่อโค้ดข้างต้นจะรวบรวมและดำเนินการก็จะก่อให้เกิดผลลัพธ์ต่อไปนี้:

在交换之前，a 的值：100
在交换之前，b 的值：200
在交换之后，a 的值：100
在交换之后，b 的值：200

ผลการศึกษาพบว่าแม้จะอยู่ในฟังก์ชั่นที่มีการเปลี่ยนแปลงมูลค่าที่คุ้มค่าของการเปลี่ยนแปลงใด ๆ ที่เกิดขึ้น

ผ่านพารามิเตอร์โดยการอ้างอิง

พารามิเตอร์อ้างอิงการอ้างอิงไปยังที่ตั้งของหน่วยความจำแปรผันเมื่อพารามิเตอร์ที่ส่งผ่านโดยการอ้างอิงกับค่าของพารามิเตอร์ที่แตกต่างกันก็คือว่ามันไม่ได้สร้างสถานที่เก็บใหม่สำหรับพารามิเตอร์เหล่านี้ พารามิเตอร์อ้างอิงหมายถึงพารามิเตอร์ที่เกิดขึ้นจริงกับวิธีการที่มีหน่วยความจำตำแหน่งเดียวกัน

ใน C #,ใช้คำว่าโทษที่จะประกาศพารามิเตอร์อ้างอิงตัวอย่างต่อไปนี้แสดงให้เห็นถึงจุดนี้:

การใช้ระบบ
CalculatorApplication namespace
{
   NumberManipulator ระดับ
   {
      โมฆะสาธารณะแลกเปลี่ยน (Ref int X, Y เตะ int)
      {
         int อุณหภูมิ;

         อุณหภูมิ = x; / * บันทึกค่าของ x * / การ
         X = Y; / * Y ถูกกำหนดให้กับ X * /
         Y = อุณหภูมิ; / * การกำหนดอุณหภูมิจะ Y * /
       }
   
      เป็นโมฆะคง main (String args [])
      {
         NumberManipulator n = NumberManipulator ใหม่ ();
         / * นิยามตัวแปรท้องถิ่น * /
         int A = 100;
         int B = 200;

         Console.WriteLine ( "ก่อนที่จะแลกเปลี่ยนค่า: {0}" เป็น);
         Console.WriteLine ( "ก่อนที่จะแลกเปลี่ยนค่า B: {0}" b);

         / * เรียกใช้ฟังก์ชันเป็นค่าแลกเปลี่ยน * /
         n.swap (Ref ให้โทษข);

         Console.WriteLine ( "หลังจากการแลกเปลี่ยนค่า: {0}" เป็น);
         Console.WriteLine ( "หลังจากการแลกเปลี่ยนค่า B: {0}" b);
 
         Console.ReadLine ();

      }
   }
}

เมื่อโค้ดข้างต้นจะรวบรวมและดำเนินการก็จะก่อให้เกิดผลลัพธ์ต่อไปนี้:

在交换之前，a 的值：100
在交换之前，b 的值：200
在交换之后，a 的值：200
在交换之后，b 的值：100

ผลการศึกษาพบว่าค่าของฟังก์ชั่นการแลกเปลี่ยนภายในการเปลี่ยนแปลงและการเปลี่ยนแปลงนี้สามารถสะท้อนให้เห็นในฟังก์ชั่นหลัก

ผ่านพารามิเตอร์โดยเอาท์พุท

คำสั่งกลับสามารถนำมาใช้เพียงเพื่อจะกลับค่าจากฟังก์ชั่นอย่างไรก็ตามคุณสามารถใช้พารามิเตอร์ออกไปกลับมาสองค่าจากฟังก์ชั่นวิธีการส่งออกข้อมูลส่งออกพารามิเตอร์จะกำหนดเองและพารามิเตอร์อ้างอิงอื่นที่คล้ายคลึงกันของพวกเขา

ตัวอย่างต่อไปนี้แสดงให้เห็นถึงจุดนี้:

using System;

namespace CalculatorApplication
{
   class NumberManipulator
   {
      public void getValue(out int x )
      {
         int temp = 5;
         x = temp;
      }
   
      static void Main(string[] args)
      {
         NumberManipulator n = new NumberManipulator();
         /* 局部变量定义 */
         int a = 100;
         
         Console.WriteLine("在方法调用之前，a 的值： {0}", a);
         
         /* 调用函数来获取值 */
         n.getValue(out a);

         Console.WriteLine("在方法调用之后，a 的值： {0}", a);
         Console.ReadLine();

      }
   }
}

เมื่อโค้ดข้างต้นจะรวบรวมและดำเนินการก็จะก่อให้เกิดผลลัพธ์ต่อไปนี้:

在方法调用之前，a 的值： 100
在方法调用之后，a 的值： 5

จ่ายให้กับตัวแปรพารามิเตอร์ขาออกไม่จำเป็นต้องได้รับมอบหมาย เมื่อคุณต้องการที่จะกลับค่าจากค่าเริ่มต้นของพารามิเตอร์ที่ไม่ได้ระบุในวิธีการพารามิเตอร์ที่ส่งออกเป็นประโยชน์อย่างยิ่ง ลองพิจารณาตัวอย่างต่อไปนี้เพื่อทำความเข้าใจนี้:

using System;

namespace CalculatorApplication
{
   class NumberManipulator
   {
      public void getValues(out int x, out int y )
      {
          Console.WriteLine("请输入第一个值： ");
          x = Convert.ToInt32(Console.ReadLine());
          Console.WriteLine("请输入第二个值： ");
          y = Convert.ToInt32(Console.ReadLine());
      }
   
      static void Main(string[] args)
      {
         NumberManipulator n = new NumberManipulator();
         /* 局部变量定义 */
         int a , b;
         
         /* 调用函数来获取值 */
         n.getValues(out a, out b);

         Console.WriteLine("在方法调用之后，a 的值： {0}", a);
         Console.WriteLine("在方法调用之后，b 的值： {0}", b);
         Console.ReadLine();
      }
   }
}

เมื่อโค้ดข้างต้นเป็นข้อมูลที่รวบรวมและดำเนินการก็จะก่อให้เกิดผลลัพธ์ต่อไป (ขึ้นอยู่กับการป้อนข้อมูลของผู้ใช้):

โปรดป้อนค่า:
7
กรุณาใส่ค่าที่สอง:
8
หลังจากที่วิธีการเรียกค่า: 7
หลังจากที่วิธีการเรียกค่า B: 8

ก่อนหน้านี้: C # แพคเกจ

ถัดไป: ประเภท C # nullable

C# หลักสูตร

C# การสอนที่ทันสมัย

วิธี C #

วิธี C # ตามที่กำหนดใน

ตัวอย่าง

เรียกวิธีการใน C #

เรียกวิธีการซ้ำ

ผ่านพารามิเตอร์

ผ่านพารามิเตอร์โดยค่า

ผ่านพารามิเตอร์โดยการอ้างอิง

ผ่านพารามิเตอร์โดยเอาท์พุท