เริ่มต้นกับ C# (ตอน 3: Variables and Parameter)

Variables (หรือตัวแปรนั่นแหละครับ) ใช้อ้างถึงสถานที่ที่ใช้เก็บข้อมูล ตัวแปรแต่ละตัวจะถูกระบุโดย Type ว่าตัวมันเองจะเก็บข้อมูลประเภทไหน. Local Variables คือตัวแปรที่ถูกประกาศอยู่ใน methods, properties หรือ indexers การะประกาศเจ้าตัวแปรที่เรียกว่า local variables นี้ทำได้โดยการประกาศประเภทของตัวแปร (หรือ type จากตอนที่แล้วครับ) ตามด้วยชื่อตัวแปร แค่นี้ครับ หรืออาจจะประกาศค่าเริ่มต้นให้กับมันเลยก็ได้ในคราวเดียวกัน อย่างเช่น

int a;
int b = 1;
แต่เราสามารถที่จะระบุ type ครั้งเดียวแต่ประกาศตัวแปลหลายชื่อก็ได้ครับ แล้วแต่ความชื่นชอบของแต่ละบุคคลดังตัวอย่างครับ

int a, b = 1;

มีข้อกำหนดอยู่ว่าตัวแปรที่เราประกาศเพื่อที่จะใช้งานมัน ต้องกำหนดค่าให้มันก่อนนำไปใช้ด้วยนะครับ ลองดูตัวอย่างข้างล่าง


[src]
Class Test
{
static void Main() {
int a;
int b = 1;
int c = a + b; // อย่างนี้ Error ครับ เพราะ a ยังไม่ได้กำหนดค่า
....
}
}
[/src]


จากตัวอย่างข้างบนมันจะ compile ไม่ผ่านครับเพราะว่า เราประกาศ a ก็จริง แต่ยังไม่ได้กำหนดค่าเริ่มต้นให้กับมัน

ต่อมาเป็นตัวแปรประเภท field ครับ อันนี้จะถูกประกาศอยู่ใน class หรือ struct ตัวแปรประเภท field ที่ถูกประกาศโดยการเอาคำว่า static มาใว้ข้างหน้ามันเรียกว่า static variable ครับ ถ้าประกาศกันโต้งๆ โดยไม่มีคำว่า static เราจะเรียกมันว่า instance variable โดย static field จะถูกจัดเข้ากับ type ต่างกับ instance fiend ที่จะผนวกเข้ากับ instance ดูตัวอย่างข้างล่างครับ

[src]
using Personal1.Data;
class Employee
{
private static DataSet ds;
public string Name;
public decimal Salary;
....
}
[/src]


จากตัวอย่าง class Employee ประกอบไปด้วย private static varible อันนึงแล้วก็ 2 public instance varibles.

ส่วน parameter จะเป็นใช้สำหรับการกำหนดความหมายให้กับ varible อีกทีครับ ซึ่ง parameter มีอยู่ 4 ชนิดได้แก่ value parameter, reference parameter, output parameter และ parameter array

value parameter ใช้ในการส่งผ่านค่าเข้าไปยัง method ครับ โดยการผ่านค่าในลักษณะของ value parameter ตัวแปรที่ส่งไปจะไปอยู่ใน local variable ใน method นั้นๆ การแก้ไขค่าของตัวแปรที่ผ่านเช้าไปใน method จะไม่มีผลใดๆ ต่อตัวแปรตั้งต้น โดยตัวแปรมันจะ copy ค่าของมันไปยังตัวแปร local อีกตัวนึง ดูดัวอย่างครับ


[src]
class Test {
static void F(int p) {
Console.WriteLine("p = {0}",p);
p++;
}
static void Main() {
int a = 1;
Console.WriteLine("pre: a = {0}", a);
F(a);
Console.WriteLine("post: a = {0}", a);
}
}
[/src]


จากตัวอย่างเห็นได้ว่าเรา ผ่านค่าตัวแปร a เข้าไปใน method F(int p) โดยใช้ p เป็นตัวแปร local variable สำหรับรับค่าของ a มีการเพิ่มค่า p ใน method แต่ไม่มีผลกับ a ครับ ผลที่ได้จะเป็นดังนี้

pre: a = 1
p = 1
post: a = 1

reference parameter ใช้สำหรับการส่งผ่านค่าตัวแปรเหมือนกันครับ แต่เป็นการส่งในลักษณะที่เรียกว่า "by reference" การส่งผ่านลักษณะนี้ตัวแปรที่รับจะอ้างถึง address ในตัวแหน่งเดียวกับตัวแปรที่เราส่งให้มัน ลักษณะคล้ายๆ ให้กุญแจไปโดยที่ตู้เก็บข้อมูลยังเป็นตู้เดียวกันนั่นแหละครับ การแก้ไขค่าของตัวแปร ใน method นั้นๆ จะทำให้ค่าของตัวแปรตั้งตนเปลี่ยนไปด้วย ลองดูตัวอย่างข้างล่างครับ


[src]
class Test {
static void Swap(ref int a, ref int B) {
int t = a;
a = b;
b = t;
}
static void Main() {
int x = 1;
int y = 2;

Console.WriteLine("pre: x = {0}, y = {1}", x, y);
Swap(ref x, ref y);
Console.WriteLine("post: x = {0}, y = {1}", x, y,);
}
}
[/src]

การผ่านค่าลักษณะที่เรียกว่า "by reference" นี้จะต้องมีการใส่คำว่า ref บอกให้มันทราบด้วยนะครับว่า "ฉันจะส่งแกไปแบบ by reference นะ" และต้องใส่ทั้งตัวส่งและตัวรับด้วยนะครับ เค้าเอาไว้ให้โปรแกรมเมอร์ที่มาอ่าน code ตอนหลังได้เข้าใจได้ง่ายๆ หน่ะครับว่า method นี้ใช้การส่งค่าแบบ by reference นะ
ลองดูผลการทำงานของ code ข้างบนนะครับ จะเห็นว่าเราทำการสลับค่ากันระหว่าง a และ b ใน method Swap(..) ผลที่ได้หลังจาก compile และ run โปรแกรมจะเป็น
pre: x = 1, y = 2
post: x = 2, y = 1


output parameter การทำงานของ output parameter จะเหมือนกัน reference parameter จะต่างกันก็ตรงที่ เราไม่จำเป็นต้องกำหนดค่าตั้งต้นให้มันก่อนที่จะส่งผ่านเข้าไปยัง method ครับ โดย output parameter จะระบุโดยคำว่า out ครับผม ดูตัวอย่างครับ


[src]
class Test {
static void Divide(int a, int b, out int result, out int remainder) {
result = a / b;
remainder = a % b;
}
static void Main() {
for (int i = 1; i < 10; i++)
for (int j = 1; j < 10; j++) {
int ans, r;
Divide(i, j, out ans, out r);
Console.WriteLine("{0} / {1} = {2}r{3}", i, j, ans, r);
}
}
}
[/src]
จากตัวอย่างจะเห็นว่าเราไม่ได้กำหนดค่าตั้งต้นให้กับตัวแปรที่ชื่อ ans กับ r ก่อนที่จะเอาไปใช้งานครับ ลักษณะอย่างนี้แหละครับ ที่จำเป็นต้องใช้ out

จากตัวอย่างที่ผ่านมาทั้ง 3 ลักษณะของการส่งค่าตัวแปร จะเห็นว่าเป็นลักษณะของการส่งแบบ one-to-one ระหว่างตัวส่งและตัวรับ แต่ถ้าเราต้องการส่งเยอะ แล้วก็มาคอยกำหนดค่าการรับส่งอย่างนี้คงจะดูไม่ดีแน่ ครับเราสามารถส่งตัวค่าไปครั้งเดียวหลายๆ ค่า โดยผ่านเข้าไปยังตัวรับเพียงตัวเดียวได้ ลักษณะอย่างนี้เรียกว่า "parameter array"
การใช้ patameter array ใช้โดยการใส่คำว่า params ไว้ข้างหน้าตัวแปรที่ใช้รับข้อมูลครับ กระณีที่เรามีตัวแปรสำหรับรับค่าหล่ายตัว parameter array ต้องอยู่ขวาสุด หรือเป็นตัวสุดท้ายเสมอครับ และจะมีได้เพียงตัวเดียวเท่านั้นในแต่ละ method ตัวแปร array ที่รับค่าจะเป็น array 1 มิติเสมอ การผ่านค่าเข้าไปอาจจะเป็นค่าเดียวโดดๆ หลายๆ ค่า หรือเป็นชุดก็ได้ครับ ลองดูตัวอย่างข้างล่าง
[src]
class Test
{
static void F(patams int[] args) {
Console.WriteLine("# of arguments: {0}", args.Length);
for (int i = 0; i < args.Length, i++)
Console.WriteLine("targs[{0}] = {1}", i, args[i]);
}
static void Main() {
F();
F(1);
F(1, 2);
F(1,2,3);
F(new int[] { 1, 2, 3, 4});
}
}
[/src]


จากตัวอย่างแสดงให้เห็นถึงการผ่านค่าให้กับ F(..) ในหลายๆ ลักษณะครับ ผลที่ได้จะเป็นดังนี้


# of arguments: 0
# of arguments: 1
args[0] = 1
# of arguments: 2
args[0] = 1
args[1] = 2
# of arguments: 3
args[0] = 1
args[1] = 2
args[2] = 3
# of arguments: 4
args[0] = 1
args[1] = 2
args[2] = 3
args[3] = 4




จากตัวอย่างทั้งหมดจะเห็นว่าเราใช้ method ที่ชื่อ WriteLine ของ class Console ครับ จะเห็นว่าเรามีการผ่านค่าต่างๆ เข้าไปให้ method นี้ได้อย่างหลากหลายมาก อย่างเช่น
[src]
int a = 1, b = 2;
Console.WriteLine("a = {0}, b = {1}", a, b,);
[/src]
นี่แหละครับตัวอย่างชัดๆ ของการใช้งาน parameter array อันนึง ลองดูลักษณะโครงสร้างของ method นี้คร่าวๆ ครับผม
[src]
namespace System
{
public class Console
{
public static void WriteLine(string s) {...}
public static void WriteLine(string s, object a) {...}
public static void WriteLine(string s, object a, object B) {...}
...
public static void WriteLine(string s, params object[] args) {...}
}
}
[/src]

revised