Method Parameters

นิสิต หนูนวน 650710560

1. Named parameters

Named parameters คือ การส่ง parameters โดยระบุชื่อ parameter ในการส่ง ซึ่งมีข้อดีคือ ไม่ต้องระบุค่าตามลำดับของ parameters ที่กำหนดใน method

Named parameters เป็นสิ่งที่อำนวยความสะดวกในการเขียน Code โดยเฉพาะ method ที่มี parameter จำนวนมาก ทำให้ง่ายต่อการทำความเข้าใจ และลดความสับสนใจการเขียน

1.1 ข้อควรระวัง !!

หากมีการใช้งานร่วมกับ Positional parameters จะต้องส่งค่าของ Positional parameters มาก่อน Named parameters เสมอ

1.2 Example

public class GFG { 
    // addstr มี 3 parameters 
    public static void addstr(string s1, string s2, string s3) 
    { 
        string result = s1 + s2 + s3; 
        Console.WriteLine("Final string is: " + result); 
    } 
    // Main Method 
    static public void Main() 
    { 
        // เรียกใช้ Method โดยใช้ Named parameter ในการส่งค่า
        addstr(s1: "Geeks", s2: "for", s3: "Geeks");                     
    } 
}

Output

Final string is: GeeksforGeeks

class NamedExample
{
    static void Main(string[] args)
    {
        // การเรียกใช้ Method แบบปกติ (Positional parameters)
        PrintOrderDetails("Gift Shop 1", 31, "Red Mug");

        // Named parameter สามารถเรียกใช้ โดยไม่ต้องเรียงลำดับใน method 
        PrintOrderDetails(orderNum: 31, productName: "Red Mug", sellerName: "Gift Shop 2");
        PrintOrderDetails(productName: "Red Mug", sellerName: "Gift Shop 3", orderNum: 31);

        // การใช้ Named parameters ร่วมกับ positional parameters 
        // สามารถใช้งานร่วมกันได้ !! แต่ต้องกำหนดตำแหน่งให้ถูกต้องตามลำดับใน method !!
        PrintOrderDetails("Gift Shop 4", 31, productName: "Red Mug");
        PrintOrderDetails(sellerName: "Gift Shop 5", 31, productName: "Red Mug");
        PrintOrderDetails("Gift Shop 6", orderNum: 31, "Red Mug");
    }
    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}");
    }
}

Output

Seller: Gift Shop 1, Order #: 31, Product: Red Mug
Seller: Gift Shop 2, Order #: 31, Product: Red Mug
Seller: Gift Shop 3, Order #: 31, Product: Red Mug
Seller: Gift Shop 4, Order #: 31, Product: Red Mug
Seller: Gift Shop 5, Order #: 31, Product: Red Mug
Seller: Gift Shop 6, Order #: 31, Product: Red Mug

public class NamedArgumentsExample
{
    static string GetFullName(string firstName, string lastName)
    {
        return firstName + " " + lastName;
    }
    public static void Main(string[] args)
    {
        // Positional parameters
        string fullName1 = GetFullName("Rahul", "Kumar");  
        // Named parameters
        string fullName2 = GetFullName(firstName: "Rahul", lastName: "Kumar");
        // Changing order
        string fullName3 = GetFullName(lastName: "Rahul", firstName: "Kumar");
        Console.WriteLine(fullName1);
        Console.WriteLine(fullName2);
        Console.WriteLine(fullName3);
    }
}

Output

Rahul Kumar
Rahul Kumar
Kumar Rahul

หากใส่ Named parameters ก่อน Positional parameters จะทำให้ compiler แจ้งเตือนข้อผิดพลาด เช่น

`[ error CS1738: Named arguments must appear after the positional arguments when using language version older than 7.2 ]`

ตัวอย่าง

public class GFG
{
    public static void addstr(string s1, string s2, string s3)
    {
        string result = s1 + s2 + s3;
        Console.WriteLine("Final string is: " + result);
    }
    static public void Main()
    {
        // กำหนด Named parameters ก่อน
        // Positional parameters 
        // ทำให้แจ้งเตือน error
        addstr(s1: "Geeks", s3: "for", "Geeks");
    }
}

s3: "for" เป็น Named arguments ซึ่งประกาศก่อน "Geeks" ที่เป็น positional argument ทำให้เกิดการแจ้งเตือนข้อผิดพลาดจาก compiler

class NamedExample
{
    static void Main(string[] args)
    {
        // กำหนด Named parameters ก่อน
        // Positional parameters 
        // ทำให้แจ้งเตือน errorent
        PrintOrderDetails( sellerName:"Gift Shop 1", productName: "Red Mug" ,31);
    }
    static void PrintOrderDetails(string sellerName, int orderNum, string productName)
    {
        Console.WriteLine($"Seller: {sellerName}, Order #: {orderNum}, Product: {productName}");
    }
}

productName: "Red Mug" เป็น Named arguments ซึ่งประกาศก่อนค่า 31 ที่เป็น positional argument ทำให้เกิดการแจ้งเตือนข้อผิดพลาดจาก compiler

public class NamedArgumentsExample
{
    static string GetFullName(string firstName, string lastName)
    {
        return firstName + " " + lastName;
    }
    public static void Main(string[] args)
    {
        // กำหนด Named parameters ก่อน
        // Positional parameters 
        // ทำให้แจ้งเตือน error
        string fullName1 = GetFullName(lastName: "Rahul", "Kumar");
        Console.WriteLine(fullName1);
    }
}

"lastName: "Rahul" เป็น Named parameters ซึ่งประกาศก่อน "Kumar" ที่เป็น Positional parameters ทำให้เกิดการแจ้งเตือนข้อผิดพลาดจาก compiler

1.3 ความแตกต่าง

ความแตกต่างของ Named parameters ระหว่าง C, Python และ Java มีดังนี้

C ไม่รองรับการใช้ Named Parameters

ซึ่งในการส่งค่า Parameters จำนวนหลายค่า ต้องแน่ใจว่าจำนวน Parameters ที่ส่ง เท่ากับจำนวน Parameter ใน function และมีการเรียงลำดับค่าที่ถูกต้อง

#include<stdio.h>

int add(int first_number, int second_number); pe
void main() {
  int first_number = 4;
  int second_number = 6;
  
  // เรียกใช้ function และ กำหนดค่า parameter และ
  // เรียงลำดับให้ตรงกับ parameters ใน function ที่เรียก 
  int sum = add(first_number, second_number); 
  printf("Sum of %d and %d is %d", first_number, second_number, sum);
}
int add(int a, int b) {
  int c = a + b;
  return c;
}

Output

Sum of 4 and 6 is 10

Java ไม่รองรับการใช้ Named Parameters เช่นเดียวกับภาษา C

ซึ่งจำเป็นจะต้องกำหนด parameters ให้เท่ากับจำนวน parameters ใน method และต้องมีการเรียงลำดับในการส่งให้ตรงกัน

public class Main {
  static void myMethod(String fname, int age) {
    System.out.println(fname + " is " + age);
  }
  public static void main(String[] args) {
    myMethod("Liam", 5);
    myMethod("Jenny", 8);
    myMethod("Anja", 31);
  }
}

Output

Liam is 5
Jenny is 8
Anja is 31

Python รองรับการใช้ Named parameters แต่ใช้ชื่อ Keyword-Only Arguments

def greet_person(person, number):
    for greeting in range(number):
        print(f"Hello {person}! How are you doing today?")
# 1.
greet_person("Elizabeth", 1)
# 2.
greet_person("Ishaan", number=2)
# 3.
greet_person(person="Messi", number=3)
# 4.
greet_person(number=4, person="Ronaldo")

# การใช้ Named parameters ก่อน
# Positional parameters จะทำให้เกิด Error !!
# greet_person(person="Stephen", 10)

Output

Hello Elizabeth! How are you doing today?
Hello Ishaan! How are you doing today?
Hello Ishaan! How are you doing today?
Hello Messi! How are you doing today?
Hello Messi! How are you doing today?
Hello Messi! How are you doing today?
Hello Ronaldo! How are you doing today?
Hello Ronaldo! How are you doing today?
Hello Ronaldo! How are you doing today?
Hello Ronaldo! How are you doing today?

2. Reference parameters

Reference parameters หรือ Passing by reference ใน C# ใช้ keyword คือ ref เป็นการส่งค่า parameter ไปยัง method โดยการอ้างอิงตัวแปรนั้นในการทำงาน ซึ่งหากมีการเปลี่ยนแปลงค่าใน method จะมีผลต่อตัวแปรนั้นเมื่อส่งค่ากลับไปยังตัวแปรต้นทาง ซึ่งก่อนที่จะใช้งาน จะต้องทำการกำหนดค่าของตัวแปรนั้นก่อน

2.1 ข้อควรระวัง !!

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

2.2 Example

class GFG { 
    public static void Main() 
    { 
        // กำหนดค่าเริ่มต้นของตัวแปร
        string val = "Dog"; 
        // เรียกใช้ method และส่งค่าด้วย ref 
        CompareValue(ref val);  
        Console.WriteLine(val); 
    } 
  
    static void CompareValue(ref string val1) 
    { 
        // Compare the value 
        if (val1 == "Dog")  
        { 
            Console.WriteLine("Matched!"); 
        } 
        // เปลี่ยนค่าของตัวแปรและส่งกลับ
        val1 = "Cat"; 
    } 
}

Output

Matched!
Cat

public static class ByRefExample
{
    public static void Main()
    {
        // กำหนดค่าเริ่มต้นของตัวแปร value
        var value = 20;
        Console.WriteLine("In Main, value = {0}", value);
        // เรียกใช้ method และส่งค่าด้วย ref
        ModifyValue(ref value);
        Console.WriteLine("Back in Main, value = {0}", value);
    }

    private static void ModifyValue(ref int i)
    {
        // เปลี่ยนค่าของตัวแปรและส่งกลับ
        i = 30;
        Console.WriteLine("In ModifyValue, parameter value = {0}", i);
        return;
    }
}

Output

In Main, value = 20
In ModifyValue, parameter value = 30
Back in Main, value = 30

class Program
{
    // การใช้ ref parameters
    static void ModifyValue(ref int number)
    {
        // เปลี่ยนค่าของตัวแปรและส่งกลับ
        number *= 2;
    }

    static void Main()
    {
        // กำหนดค่าเริ่มต้นของตัวแปร value
        int value = 5;
        Console.WriteLine("Output: Original value = " + value); 
        // เรียกใช้ method และส่งค่าด้วย ref 
        ModifyValue(ref value); 
        Console.WriteLine("Output: Modified value = " + value); 
    }
}

Output

Output: Original value = 5
Output: Modified value = 10

2.3 ความแตกต่าง

ความแตกต่างของ Reference parameters ระหว่าง C, Python และ Java มีดังนี้

ภาษา C ไม่รองรับการใช้งาน Reference parameters หรือ Passing by reference แต่จะใช้ pointer เข้าถึงตำแหน่งของค่า ซึ่งอาจใช้ชื่อว่า Call by reference, Call by pointers, and Pass by pointers

#include <stdio.h>
//ฟังก์ชันจะรับค่าของพารามิเตอร์โดยใช้ pointer (*)
void swap(int* a, int* b)
{
	int temp = *a;
	*a = *b;
	*b = temp;
}

int main(void)
{
	int n1 = 5;
	int n2 = 10;

	// value before swapping
	printf(" Before swapping : n1 is %d and n2 is %d\n", n1,n2);
	// เรียกใช้ function และใช้ (&) เพื่อส่งที่อยู่ของตัวแปร n1,n2
	swap(&n1, &n2);
	
	// value after swapping
	printf(" After swapping : n1 is %d and n2 is %d\n", n1,n2);
	return 0;
}

Output

 Before swapping : n1 is 5 and n2 is 10
 After swapping : n1 is 10 and n2 is 5

java ไม่รองรับ Reference parameter แต่สามารถใช้ Object เพื่อการทำงานที่เทียบเคียงได้

class Person {
    private String name;
    private int age;
    private int weight;
    private int height;

    public Person(String name) {
        this(name, 0, 0, 0);
    }

    public Person(String name, int age, int height, int weight) {
        this.name = name;
        this.age = age;
        this.weight = weight;
        this.height = height;
    }
   
    public void growOlder() {
        this.age = this.age + 1;
    }
 
    @Override
    public String toString() {
        return this.name + ", age " + this.age + " years";
    }
}

public class Test {
    public static void main(String[] args) {
        Person joan = new Person("Joan Ball");
        System.out.println(joan);

        Person ball = joan;
        ball.growOlder();
        ball.growOlder();

        System.out.println(joan);
    }
}

// Output:

// Joan Ball, age 0 years
// Joan Ball, age 2 yearsOutput:

// Output:
Joan Ball, age 0 years
Joan Ball, age 2 years

Python รองรับ Ref parameters ในชื่อ pass by Reference และมีข้อกำหนดบางประการ ดังนี้

Pass by value เมื่อส่ง parameter ที่เป็น Immutable Objects (ไม่สามารถเปลี่ยนแปลงสถานะหรือค่าในอ็อบเจกต์นั้นได้) เช่น integers, floats, strings, และ tuples

def modify_immutable(value):
  value += 1
  print("Inside function:", value)

x = 5
print("Before function:", x)
modify_immutable(x)
print("After function:", x)

# Output 
# Before function: 5
# Inside function: 6
# After function: 5

Pass by reference เมื่อส่ง parameter ที่เป็น mutable Objects (สามารถเปลี่ยนแปลงได้หลังจากที่ถูกสร้างขึ้นแล้ว) เช่น list และ dictionaries

def modify_mutable(data):
  data[0] = "modified"
  print("Inside function:", data)

my_list = ["original"]
print("Before function:", my_list)
modify_mutable(my_list)
print("After function:", my_list)
# Output
# Before function: ['original']
# Inside function: ['modified']
# After function: ['modified']

3. Out Parameters

Out parameters ใน C# ใช้ keyword คือ out เป็นการส่งค่า parameter ไปยัง method โดยการอ้างอิงตัวแปรนั้นในการทำงาน เช่นเดียวกับ reference parameters แต่มีความแตกต่างคือ ต้องมีการกำหนดค่าของตัวแปรภายใน method และไม่จำเป็นต้องกำหนดค่าของตัวแปรเริ่มต้นก่อนใช้งาน เพราะจะไม่มีผลต่อค่าของตัวแปรที่กำหนดใน method

Out Parameters มักใช้งานเมื่อมีการส่งค่ากลับแบบหลายค่า (multiple value)

3.1 Example

using System; 
class GFG
{
    static public void Main()
    {
        // สร้างตัวแปรโดยไม่ต้องหนดค่าของตัวแปร
        int num;
        
        // ส่งตัวแปร num ไปยัง method 
        // โดยใช้ keyword 'out'
        AddNum(out num);
        Console.WriteLine("The sum of"
          + " the value is: {0}", num);
    }
    // method จะส่งค่าของ num กลับไปยังตัวแปรต้นทาง
    public static void AddNum(out int num)
    {
        // กำหนดค่าของตัวแปรใน method
        num = 40;
        num += num;
    }
}

Output

The sum of the value is: 80

using System;  
namespace OutParameter  
{  
    class Program  
    {  
        
        public void Show(out int val) 
        {  
            
            int square = 5;  
            // กำหนดค่าของตัวแปร val ใน method 
            val = square;  
            val *= val;  
        }  
        entry point of the program  
        static void Main(string[] args)  
        {  
            // กำหนดค่าเริ่มต้นของตัวแปร
            // ซึ่งจะไม่มีผลต่อค่าตัวแปรใน method
            int val =69;  
            // สร้าง Object
            Program program = new Program();   
            
            Console.WriteLine("Value before passing out variable " + val);
            // ส่งตัวแปร val ไปยัง method ด้วย out argument
            program.Show(out val);  
            Console.WriteLine("Value after recieving the out variable " + val);  
        }  
    }  
}

Output

Value before passing out variable 69
Value after recieving the out variable 25

3.2 ความแตกต่าง

ความแตกต่างของ Out parameters ระหว่าง C, Python และ Java มีดังนี้

ภาษา C ไม่รองรับการส่ง multiple values จาก function โดยตรง แต่สามารถใช้ "Pass by pointers" ในการรับข้อมูลของตัวแปร จากการใช้ pointer อ้างอิงตำแหน่งของข้อมูล

#include<stdio.h>
void div(int a, int b, int *quotient, int *remainder) {
   *quotient = a / b;
   *remainder = a % b;
}
main() {
   int a = 76, b = 10;
   int q, r;
   div(a, b, &q, &r);
   printf("Quotient is: %d\nRemainder is: %d\n", q, r);
}

Output

Quotient is: 7
Remainder is: 6

java ไม่รองรับ Out parameter แต่สามารถใช้ List เพื่อการทำงานที่เทียบเคียงได้

public class Outjava {
    public static int[] assignValues() {
        int[] values = new int[2];
        values[0] = 50; // ค่าแรก
        values[1] = 100; // ค่าที่สอง
        return values;
    }

    public static void main(String[] args) {
        int[] results = assignValues();
        System.out.println("Value 1: " + results[0]);
        System.out.println("Value 2: " + results[1]);
    }
}

Output :

Value 1: 50
Value 2: 100

Python ไม่รองรับ Out parameter แต่สามารถใช้การคืนหลายค่าด้วย tuple

def assignValues():
    value1 = 50
    value2 = 100
    return value1, value2

value1, value2 = assignValues()
print("Value 1:", value1)
print("Value 2:", value2)

Output :

Value 1: 50
Value 2: 100

4. Default or Optional Parameters

Optional Parameters คือ parameter ที่มีการกำหนดค่า default value ไว้ใน method ซึ่งหากเรียกใช้ method และส่ง parameter โดยไม่ระบุค่าของตัวแปรที่เป็น Optional parameter ระบบจะนำค่า default value ที่กำหนดใน method มาใช้

4.1 ข้อควรระวัง !!

การกำหนดค่าของ optional parameters จะต้องอยู่หลัง regular parameter เสมอ

4.2 Example

using System;  
class GFG {  
    // method นี้มีการกำหนด parameter คือ 
    // regular  parameters : ename , eid
    // optional parameters : bgrp , dept
    static public void detail(string ename,   
                               int eid,  
                               string bgrp = "A+",  
                    string dept = "Review-Team")  
    {  
        Console.WriteLine("Employee name: {0}", ename);  
        Console.WriteLine("Employee ID: {0}", eid);  
        Console.WriteLine("Blood Group: {0}", bgrp);  
        Console.WriteLine("Department: {0}", dept);  
    }  
    // Main Method  
    static public void Main()  
    {  
        // ไม่กำหนดค่าให้กับ optional parameter 
        detail("XYZ", 123);  
        // กำหนดค่าให้กับ optional parameter 
        detail("ABC", 456, "B-");  
        detail("DEF", 789, "B+", "Software Developer");  
    }  
}

Output

Employee name: XYZ
Employee ID: 123
Blood Group: A+
Department: Review-Team
Employee name: ABC
Employee ID: 456
Blood Group: B-
Department: Review-Team
Employee name: DEF
Employee ID: 789
Blood Group: B+
Department: Software Developer

using System;  
class Optional{
    // method นี้มีการกำหนด parameter คือ 
    // regular  parameters : firstName , lastName
    // optional parameters : age , city
    public static void CreateProfile(string firstName, string lastName,
                                 int age = 25, string city = "Unknown")
    {
        Console.WriteLine($"Name: {firstName} {lastName}, Age: {age}, 
                            City: {city}");
    }
    static void Main()
    {
        // ไม่กำหนดค่าให้กับ optional parameter
        CreateProfile("John", "Doe"); 
        // กำหนดค่าให้กับ optional parameter
        CreateProfile("Jane", "Doe", 30, "New York"); 
    }
}

Output

Name: John Doe, Age: 25, City: Unknown
Name: Jane Doe, Age: 30, City: New York

4.3 ความแตกต่าง

ความแตกต่างของ Optional parameters ระหว่าง C, Python และ Java มีดังนี้

ภาษา C ไม่รองรับการใช้ Optional parameter แต่สามารถใช้ การทำ null pointer ในการตรวจสอบการส่งค่า parameter

#include <stdio.h>
int fun1(int *ptrvarB)
{
    if (ptrvarB == NULL)
    {
        // Handle NULL pointer input
        printf("It is null pointer");
    }
    else
    {
        printf("It is not a null pointer");
    }
}
int main()
{
    int *ptrvarA = NULL;
    fun1(ptrvarA);
}

Output :

 It is null pointer

Java ไม่รองรับ Optional parameter แต่สามารถใช้ method overloading เพื่อให้มี method มี parameter หลายรูปแบบ

class Addition {
    // Method to add two numbers
    public int sum(int num1, int num2) {
        return num1 + num2;
    }
     
    // Method to add three numbers
    public int sum(int num1, int num2, int num3) {
        return num1 + num2 + num3;
    }
}
public class overrideParam{
    public static void main(String[] args){
        Addition add = new Addition();
        int result = add.sum(5, 10);
        System.out.println("Sum of two numbers: " + result);
    }
}

Output :

Sum of two numbers: 15

Python รองรับ Optional parameter ซึ่งสามารถกำหนดค่า default value ได้เหมือน C#

# b เป็น optional parameter 
def func(a, b=1098):
    return a+b
# กำหนดค่าของ optional parameter   
print(func(2, 2))
# ไม่กำหนดค่าของ optional parameter
print(func(1))

Output :

4
1099

5. Dynamic Parameters

Dynamic parameters คือ parameter ที่กำหนดขึ้นโดยใช้ keyword dynamic ทำให้ไม่ต้องระบุชนิดของตัวแปร เนื่องจาก Compiler จะไม่มีการตรวจสอบชนิดของตัวแปรในขณะ compile-time แต่จะรับชนิดของตัวแปรในขณะ run time

Dynamic parameters มีประโยชน์สำหรับการจัดการกับชนิดข้อมูลที่ไม่แน่นอน ช่วยเพิ่มความยืดหยุ่นในการเขียน Code

5.1 Example

using System;
class program
{
    // กำหนดตัวแปรที่ไม่มีชนิดข้อมูล โดยใช้ dynamic keyword
    public static void add(dynamic r1, dynamic r2)
    {
        dynamic result = r1+r2;
        Console.WriteLine(r1 + r2+" : "+result.GetType().ToString());
        
    }
    // Main method is called
    static public void Main()
    {
    // ส่งค่าของตัวแปรไปยัง method 
    //String + String
    add("H", "I");
    add("Welcome to", " dynamic type");
    //Integer + Interger
    add(20, 20);
    //Double + Double
    add(20.5, 1.5);
    //Integer + String
    add(100, "fun");
    }
}

Output

HI : System.String
Welcome to dynamic type : System.String
40 : System.Int32
22 : System.Double
100fun : System.String11

using System; 
class GFG { 
  
    // กำหนดตัวแปรที่ไม่มีชนิดข้อมูล โดยใช้ dynamic keyword
    public static void mulval(dynamic val) 
    { 
        val *= val; 
        Console.WriteLine("Result = "+val); 
    } 
    // Main method 
    static public void Main() 
    { 
        // เรียกใช้ method และส่งค่า 30 (Integer)
        mulval(30); 
    } 
} 
Output
Result = 900

Output

Result = 900

5.2 ความแตกต่าง

ความแตกต่างของ Dynamic parameters ระหว่าง C, Python และ Java มีดังนี้

C เป็นภาษาแบบ Static typing และไม่มี keyword สำหรับการเปลี่ยนแปลงค่า (dynamic) แบบ C#

6. Value Parameters

Value parameters คือ parameter ที่ส่งข้อมูลหรือค่าของตัวแปรที่กำหนดขึ้น ไปยัง method ซึ่งหากมีการเปลี่ยนแปลงค่าของตัวแปรใน method จะไม่ส่งผลต่อค่าของตัวแปรต้นทางที่เรียกใช้

Value parameters เป็นการส่ง parameter แบบปกติในภาษา C#

6.1 Example

using System; 
public class GFG { 
    static public void Main() 
    { 
        // กำหนดค่าของตัวแปร
        string str1 = "Geeks"; 
        string str2 = "geeks"; 
        //เรียกใช้ method โดยส่ง parameter เป็นค่าของตัวแปร
        string res = addstr(str1, str2); 
        Console.WriteLine(res); 
    } 
  
    public static string addstr(string s1, string s2) 
    { 
        return s1 + s2; 
    } 
}

Output

Geeksgeeks

using System;
class Valueparam{
    static void Main(string[] args)  
    {
        // กำหนดค่าของตัวแปร  
        int a = 10;  
        int b = 25;  
        //เรียกใช้ method โดยส่ง parameter เป็นค่าของตัวแปร และเก็บใน res
        int res = Change(a, b);  
        Console.WriteLine("res = " + res);
        Console.WriteLine("a = " + a);
        Console.WriteLine("b = " + b);
    }  
    public static int Change(int x, int y)  
    {  
        return x = y;  
    }
}

Output

res = 25
a = 10
b = 25

6.2 ความแตกต่าง

ความแตกต่างของ Value parameters ระหว่าง C, Python และ Java มีดังนี้

ภาษา C รองรับ Value parameters ในชื่อ Pass by value

#include <stdio.h>
 
void swap (int a, int b)
{
    int temp = a;
    a = b;
    b = temp;
    
    printf("swap in function, a = %d, b = %d\n", a,b);
}
 
int main ()
{
    int a = 10;
    int b = 20;
    printf ("Before swap, a = %d, b = %d\n", a, b);
    swap (a, b);
    printf ("After swap, a = %d, b = %d\n", a, b);
    return 0;
}

Output :

Before swap, a = 10, b = 20
swap in function, a = 20, b = 10
After swap, a = 10, b = 20

Java รองรับ Value parameter และ จะส่ง Parameter ด้วยวิธีนี้เสมอไม่ว่าจะเป็น Primative data หรือ Object

class Balloon {
	private String color;
	public Balloon() {}
	public Balloon(String c) {
		this.color = c;
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
}

public class Test {
	public static void main(String[] args) {

		Balloon red = new Balloon("Red"); // memory reference = 50
		Balloon blue = new Balloon("Blue"); // memory reference = 100
		
		swap(red, blue);
		System.out.println("After the swap method executes:");
		System.out.println("`red` color value = " + red.getColor());
		System.out.println("`blue` color value = " + blue.getColor());
		
		changeValue(blue);
		System.out.println("After the changeValue method executes:");
		System.out.println("`blue` color value = " + blue.getColor());
		
	}
	// Generic swap method
	public static void swap(Object o1, Object o2){
		Object temp = o1;
		o1 = o2;
		o2 = temp;
	}
	private static void changeValue(Balloon balloon) {
	// balloon = 100
		balloon.setColor("Red"); // balloon = 100
		balloon = new Balloon("Green"); // balloon = 200
		balloon.setColor("Blue"); // balloon = 200
	}
}

//Output

After the swap method executes:
`red` color value = Red
`blue` color value = Blue
After the changeValue method executes:
`blue` color value = Red

Python รองรับ Value parameters ในชื่อ pass by value และมีข้อกำหนดบางประการ ดังนี้

Pass by value เมื่อส่ง parameter ที่เป็น Immutable Objects (ไม่สามารถเปลี่ยนแปลงสถานะหรือค่าในอ็อบเจกต์นั้นได้) เช่น integers, floats, strings, และ tuples

def modify_immutable(value):
  value += 1
  print("Inside function:", value)

x = 5
print("Before function:", x)
modify_immutable(x)
print("After function:", x)

# Output 
# Before function: 5
# Inside function: 6
# After function: 5

Pass by reference เมื่อส่ง parameter ที่เป็น mutable Objects (สามารถเปลี่ยนแปลงได้หลังจากที่ถูกสร้างขึ้นแล้ว) เช่น list และ dictionaries

def modify_mutable(data):
  data[0] = "modified"
  print("Inside function:", data)

my_list = ["original"]
print("Before function:", my_list)
modify_mutable(my_list)
print("After function:", my_list)
# Output
# Before function: ['original']
# Inside function: ['modified']
# After function: ['modified']

7. Params

keyword params เป็นการกำหนดให้สามารถส่งค่า argument ได้จำนวนหลายค่าตามที่ต้องการโดยไม่ต้องกำหนดจำนวนของ parameters ก่อน ซึ่งจะเป็นประโยชน์เมื่อไม่ทราบจำนวนของ argument ที่ต้องการจะส่ง

7.1 ข้อควรระวัง !!

ในหนึ่ง method สามารถใช้ paramsได้เพียงตัวเดียว และ parameter ที่ใช้ params ต้องเป็นชนิด Array เท่านั้น และจะต้องกำหนดให้เป็น parameters สุดท้ายของ method

7.1 Example

using System; 
class Param { 
    // ใช้ params keyword
  public static int Add(params int[] numbers)
  {
      int sum = 0;
      foreach (int number in numbers)
      {
          sum += number;
      }
      return sum;
  }

  static public void Main()
  {
    int result = Add(1, 2, 3, 4);
    Console.WriteLine("Result = " + result);
  }
 
}

// ไม่ใช้ params keyword (multiple overloads)
public static int Add(int a, int b)
{
    return a + b;
}
 
public static int Add(int a, int b, int c)
{
    return a + b + c;
}
 
public static int Add(int a, int b, int c, int d)
{
    return a + b + c + d;
}

Output

Result = 10

using System; 
  
class Geeks { 
      // การกำหนด method parameter แบบ params
    public static int mulval(params int[] num) 
    { 
        int res = 1; 
        
        foreach(int j in num) 
        { 
            res *= j; 
        } 
        return res; 
    } 
  
    static void Main(string[] args) 
    { 
        // เรียกใช้ method และส่งค่า parameter 
        // โดยไม่ต้องกำหนดจำนวนล่วงหน้า
        int x = mulval(20, 49, 56, 69, 78); 
  
        Console.WriteLine(x); 
    } 

}

Output

295364160

7.2 ความแตกต่าง

ความแตกต่างของ Params ระหว่าง C, Python และ Java มีดังนี้

ภาษา C ใช้ Variadic function สำหรับการรับ argument ที่ไม่จำกัดจำนวน ซึ่งฟังก์ชันที่ใช้บ่อยที่สุดอย่าง printf() , scanf() ก็เป็น Variadic function เนื่องจากสามารถส่งจำนวน argument ได้ตามต้องการ

โดยจะต้องทำการเพิ่ม #include <stdarg.h> ไว้บน header และ ต้องกำหนด fixed argument อย่างน้อย 1 ค่า แล้วตามด้วย (...) เพื่อให้ compiler เข้าใจว่า สามารถรับ arguments ที่ไม่จำกัดจำนวนได้

#include <stdio.h>
#include <stdarg.h>

// Variadic function to add numbers
int addition(int n, ...){

   va_list args;
   int i, sum = 0;
   va_start (args, n);  
  
   for (i = 0; i < n; i++){    
      sum += va_arg (args, int);    
   }

   va_end (args);    
  
   return sum;
}

int main(){

   printf("Sum = %d ", addition(5, 1, 2, 3, 4, 5));
   
   return 0;
}

Output

Sum = 15

Java ใช้ Varargs ในการรับ arguments ที่ไม่จำกัดจำนวน โดยใช้ ... ด้านหลังชนิดข้อมูลของ parameter

class VarargExample {

    public int sumNumber(int ... args){
        System.out.println("argument length: " + args.length);
        int sum = 0;
        for(int x: args){
            sum += x;
        }
        return sum;
    }

    public static void main( String[] args ) {
        VarargExample ex = new VarargExample();

        int sum2 = ex.sumNumber(2, 4);
        System.out.println("sum2 = " + sum2);

        int sum3 = ex.sumNumber(1, 3, 5);
        System.out.println("sum3 = " + sum3);

        int sum4 = ex.sumNumber(1, 3, 5, 7);
        System.out.println("sum4 = " + sum4);
    }
}

Output

argument length: 2
sum2 = 6
argument length: 3
sum3 = 9
argument length: 4
sum4 = 16

Python ใช้ keyword *args และ *kwargs ในการรับ parameter ที่ไม่จำกกัดจำนวน arguments โดย

*args ใช้สำหรับรับ argument ที่เป็น Non-Keyword Arguments หรือ ไม่มี keyword ซึ่งจะเก็บในรูปแบบของ tuple และเรียกใช้งานในลักษณะของ list

def hello_guy(*args):
    for arg in args:
        print(arg)

# ส่งเข้ามากี่ตัวก็ได้ (ในตัวอย่างคือ 3 ตัว)
hello_guy('Hello', 'Mr. Pita', 43) 

#Output 
#Hello
#Mr. Pita
#43

*kwargs ใช้สำหรับ argument ที่ส่งเข้ามาต้องเป็นแบบคีย์เวิร์ด Keyword Argument ซึ่งจะถูกรับเข้ามาแบบ dict ( หรือ dictionary) ทำให้ต้องกำหนด Key ให้กับ argument ด้วย แทนที่จะใส่เฉพาะ Value

def hello_devhub(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")
        
# ส่งแบบ key:value
print(hello_devhub(greeting='Hello', 
        name='Devhub', team_members=3)) 

#Output
#greeting: Hello
#name: Devhub
#team_members: 3

Video Presentation

Slide Presentation

41MB

SCSU-Slide-Method-Parameters-650710560.pdf

Open

Resource

Key resource

Saini, A. (2019). C# | Method Parameters. GeeksforGeeks. https://www.geeksforgeeks.org/c-sharp-method-parameters/

Additional Resources

IronPdf. (2024). C# Optional Parameters (How It Works For Developers). https://ironpdf.com/blog/net-help/csharp-optional-parameters/
Javatpoint. (n.d.). C# Named and Optional Arguments. https://www.javatpoint.com/csharp-named-and-optional-arguments
Javatpoint. (n.d.). C# Out Parameter. https://www.javatpoint.com/c-sharp-out-parameter
Narayan, B. (2015). Different Types Of Method Parameters in C#. C#Corner.https://www.c-sharpcorner.com/UploadFile/efa3cf/different-types-of-method-parameters-in-C-Sharp/
Pal, V. (2023). Understanding Ref and Out Parameters in C#. Medium. https://medium.com/@vndpal/understanding-ref-and-out-parameters-in-c-3259e936a6eb
Shivakumar, S. (2023). C# Dynamic. EDUCBA. https://www.educba.com/c-sharp-dynamic/
Tutorials.EU. (n.d.). C# params in easy words. https://tutorials.eu/a-guide-to-using-csharp-params-to-work-with-parameters/
Wagner et al., (2024). Named and Optional Arguments (C# Programming Guide). Microsoft Learn. https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/named-and-optional-arguments?redirectedfrom=MSDN
Wagner et al., (2024). Methods in C#. Microsoft Learn. https://learn.microsoft.com/en-us/dotnet/csharp/methods#passing-parameters

PreviousMethod returning an object NextRuntime (Dynamic) Polymorphism

Last updated 1 year ago