Dynamic Type in C#

นันทภพ วีระหงษ์ 650710084

หลักการทำงานของ Dynamic Type

Dynamic Type ใน C# คือฟีเจอร์ที่ทำให้เราประกาศตัวแปรโดยไม่ต้องกำหนดชนิดข้อมูลตั้งแต่แรก เวลาที่โปรแกรมทำงาน ตัวแปรจะค่อยๆ ถูกกำหนดชนิดของข้อมูลเองตามค่าที่ถูกใส่เข้าไป ข้อดีคือมันช่วยให้เขียนโค้ดได้ง่ายและยืดหยุ่นขึ้นโดยไม่ต้องกำหนดประเภทของตัวแปรให้ชัดเจนตั้งแต่แรก แต่ข้อเสียคือเวลาใช้ dynamic type ระบบจะไม่สามารถเช็คความถูกต้องของชนิดข้อมูลระหว่าง compile-time ได้ ทำให้มีโอกาสเกิดข้อผิดพลาดในตอน runtime

ตัวอย่างเช่น เราสามารถสร้างตัวแปรแบบ dynamic และใส่ค่าได้หลายประเภท เช่น int, string, หรือวัตถุอื่นๆ

C#

dynamic x = 10;      // x ตอนนี้เป็น int
x = "Hello";         // x เปลี่ยนเป็น string
x = new List<int>(); // x กลายเป็น List<int>

dynamic type เหมาะกับเวลาที่เราไม่รู้ล่วงหน้าว่าตัวแปรจะเป็นประเภทอะไร เช่น การเรียกใช้ API ภายนอก หรือการทำงานกับข้อมูลที่มาจากแหล่งต่างๆ ที่อาจมีประเภทข้อมูลไม่แน่นอน

ความสำคัญของ Dynamic Type ใน C#

Dynamic Type ใน C# มีความสำคัญเพราะช่วยให้เราเขียนโค้ดได้อย่างยืดหยุ่นและสะดวกมากยิ่งขึ้นในบางกรณี โดยเฉพาะเมื่อเราทำงานกับข้อมูลที่มีความไม่แน่นอนหรือเปลี่ยนแปลงได้ เช่น การเรียกใช้ API ที่ส่งข้อมูลกลับมาหลายประเภท หรือการทำงานกับ library ภายนอกที่เราไม่รู้แน่นอนว่าข้อมูลที่ได้จะเป็นชนิดไหน

ข้อดีหลักๆ ของ dynamic type คือไม่ต้องมากังวลเรื่องการกำหนดชนิดของตัวแปรล่วงหน้า และมันยังช่วยลดการเขียนโค้ดที่ซับซ้อนเวลาเราเจอข้อมูลที่เปลี่ยนแปลงชนิดบ่อยๆ อย่างไรก็ตาม มันก็มีข้อเสียตรงที่ระบบจะไม่ช่วยเช็คข้อผิดพลาดเรื่องชนิดข้อมูลตอน compile-time ซึ่งทำให้เราต้องระวังเรื่องการใช้งาน dynamic มากขึ้น เพราะถ้าเกิดปัญหา ก็จะมารู้ตัวตอนโปรแกรมรันไปแล้วเท่านั้น

การใช้ dynamic type เลยสำคัญในงานที่ต้องการความยืดหยุ่นสูง แต่ก็ต้องใช้ด้วยความระมัดระวังเพื่อไม่ให้เกิด bug ในภายหลัง

ความแตกต่างระหว่าง Dynamic Typing และ Static Typing

Dynamic Typing กับ Static Typing ต่างกันที่วิธีจัดการกับชนิดของข้อมูลในตัวแปร

Dynamic Typing : ไม่ต้องระบุชนิดข้อมูลของตัวแปรล่วงหน้า ระบบจะกำหนดชนิดให้เองตอนที่โปรแกรมรัน (runtime) เช่น ใน Python, JavaScript หรือ dynamic ใน C# ตัวแปรสามารถเปลี่ยนชนิดข้อมูลได้ตลอดเวลา ถ้าเราใส่ค่าตัวเลขเข้าไป มันก็จะกลายเป็น int แต่ถ้าเปลี่ยนเป็นข้อความตัวแปรนั้นก็จะกลายเป็น string ด้วยหลักการทำงานแบบนี้ทำให้โค้ดยืดหยุ่นและเขียนง่าย แต่ข้อเสียคือมันตรวจจับข้อผิดพลาดเรื่องชนิดข้อมูลไม่ได้จนกว่าจะถึงตอนรันโปรแกรม ซึ่งอาจทำให้เกิด bugได้ง่ายขึ้น

ตัวอย่าง ภาษา Python หรือ C# ที่ใช้ dynamic สำหรับประกาศตัวแปรและเปลี่ยนชนิดของข้อมูลจาก string เป็น int

Python

variable = "Hello"  # กำหนด variable เป็น string
variable = 10       # เปลี่ยนเป็น int

C#

dynamic variable = "Hello";  // กำหนด variable เป็น string
variable = 10;               // เปลี่ยนเป็น int

คำอธิบาย : ใน Python ตัวแปรเป็นแบบ dynamic typing โดยอัตโนมัติ ซึ่งหมายความว่าเราสามารถเปลี่ยนชนิดของข้อมูลในตัวแปรได้โดยไม่ต้องประกาศชนิดล่วงหน้า ตัวแปร variable เริ่มต้นเป็นสตริง "Hello" และสามารถเปลี่ยนเป็นตัวเลข 10 ได้โดยไม่มีข้อผิดพลาด

คำอธิบาย : การใช้ dynamic ใน C# ทำให้ตัวแปรสามารถเปลี่ยนชนิดข้อมูลได้ในขณะรันไทม์ (runtime) โดยไม่เกิดข้อผิดพลาดในช่วงคอมไพล์ (compile-time) ดังนั้นในตัวอย่างนี้ตัวแปร variable จะเริ่มต้นด้วยค่าที่เป็นสตริง "Hello" แต่สามารถเปลี่ยนเป็นตัวเลข 10 ได้ในภายหลัง

Static Typing : ต้องกำหนดชนิดข้อมูลของตัวแปรตั้งแต่ตอนเขียนโค้ด เช่น ใน C, Java, หรือ C# ตัวแปรที่ถูกกำหนดให้เป็นชนิดไหนก็ต้องเป็นชนิดนั้นไปตลอด เช่น ถ้าบอกว่าเป็น int ก็จะเก็บเฉพาะตัวเลขเท่านั้น ข้อดีคือระบบจะเช็คชนิดข้อมูลให้เราได้ตั้งแต่ตอน compile-time ทำให้ตรวจจับข้อผิดพลาดได้เร็วขึ้นและโปรแกรมมีความเสถียรกว่า แต่โค้ดอาจเขียนยากขึ้นเล็กน้อย เพราะเราต้องระบุชนิดข้อมูลให้ชัดเจนตั้งแต่แรก

ตัวอย่าง ภาษา Java หรือ C# ที่ถ้าเรากำหนดประเภทตัวแปรเป็น int มันก็จะต้องเป็น int ไปตลอด

Java

int number = 5;    // กำหนด number เป็น int
number = "Hello";  // จะเกิดข้อผิดพลาดในช่วงคอมไพล์ เนื่องจากชนิดข้อมูลไม่ตรงกัน

C#

int number = 5;    // กำหนด number เป็น int
number = "Hello";  // จะเกิดข้อผิดพลาดในช่วงคอมไพล์ เนื่องจากชนิดข้อมูลไม่ตรงกัน

Output

Java

error: incompatible types: String cannot be converted to int

C#

Cannot implicitly convert type 'string' to 'int'

คำอธิบาย : ใน Java ซึ่งเป็นภาษาแบบ static typing เช่นเดียวกับ C# ตัวแปร number ถูกประกาศให้เป็น int ดังนั้นมันไม่สามารถเก็บข้อมูลชนิด String ได้จึงเกิด error

สรุปให้เข้าใจง่ายๆ คือ

Dynamic Typing : ยืดหยุ่น ไม่ต้องระบุชนิดล่วงหน้า แต่มีโอกาสเจอ bug ตอน runtime

Static Typing : เสถียร ตรวจจับข้อผิดพลาดได้เร็ว แต่ต้องระบุชนิดให้ชัดเจนตั้งแต่แรก

เปรียบเทียบ Dynamic Typing กับภาษาอื่นๆ

การเปรียบเทียบ Dynamic Typing กับภาษาอื่นๆ อย่าง C, Java, และ Python จะช่วยให้เห็นความแตกต่างและความยืดหยุ่นของการจัดการชนิดข้อมูลในแต่ละภาษามากขึ้น

1. C (Static Typing)

ในภาษา C ตัวแปรทุกตัวต้องระบุชนิดข้อมูลตั้งแต่ช่วงคอมไพล์ เช่น int, char, หรือ float และเปลี่ยนชนิดข้อมูลไม่ได้หลังจากประกาศแล้ว ถ้าเรากำหนดชนิดผิดหรือพยายามเปลี่ยนชนิด ระบบจะแจ้งเตือนข้อผิดพลาดในตอนคอมไพล์

• ข้อดี: ตรวจจับข้อผิดพลาดได้ตั้งแต่ตอน compile-time ทำให้โปรแกรมมีความเสถียรมาก

• ข้อเสีย: เขียนโค้ดได้ช้ากว่า เพราะต้องระบุชนิดข้อมูลทุกครั้ง

ในภาษา C ไม่มีการสนับสนุน dynamic typing เช่นเดียวกับ C# หรือ Python แต่สามารถจำลองการเกิดข้อผิดพลาดเกี่ยวกับการเปลี่ยนชนิดข้อมูลในภาษา C ได้ โดยการใช้ void pointers ซึ่งทำให้สามารถเก็บที่อยู่ของข้อมูลได้ แต่ไม่สามารถเปลี่ยนชนิดข้อมูลได้ตามต้องการ

ตัวอย่างในภาษา C ที่แสดงการพยายามเปลี่ยนชนิดข้อมูลของตัวแปรและจะเกิดข้อผิดพลาดตอนการคอมไพล์

C

#include <stdio.h>

int main() {
    void *variable;      // ใช้ void pointer เพื่อเก็บที่อยู่ของข้อมูล

    variable = "Hello";  // เก็บ string
    printf("%s\n", (char *)variable); // พิมพ์ค่าเป็น string

    variable = 10;       // พยายามเก็บ int
    printf("%d\n", (int)variable);  // พิมพ์ค่าเป็น int (จะเกิด warning)

    return 0;
}

Output

C

warning: cast to pointer from integer of different size

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

2. Java (Static Typing)

ในภาษา Java จะคล้ายกับภาษา C ตรงที่ Java เป็นภาษาแบบ static typing ซึ่งทุกตัวแปรจะต้องระบุชนิดข้อมูล เช่น int, String และชนิดข้อมูลไม่สามารถเปลี่ยนได้ แต่ Java มีสิ่งที่เรียกว่า autoboxing ช่วยให้จัดการชนิดข้อมูลบางอย่างได้ง่ายขึ้น

• ข้อดี: ตรวจสอบชนิดข้อมูลได้ตั้งแต่ compile-time ทำให้ระบบปลอดภัยและป้องกันการเกิดข้อผิดพลาด

• ข้อเสีย: ขาดความยืดหยุ่นเมื่อทำงานกับข้อมูลที่ชนิดไม่แน่นอน

ในภาษา Java ไม่มีการสนับสนุน dynamic typing เหมือนใน C# หรือ Python อย่างไรก็ตาม สามารถแสดงการเกิดข้อผิดพลาดจากการเปลี่ยนชนิดข้อมูลใน Java ได้ โดยใช้ชนิดข้อมูลที่กำหนดไว้แล้ว เช่น String กับ int

ตัวอย่างในภาษา Java ที่แสดงการพยายามเปลี่ยนชนิดข้อมูลของตัวแปรและจะเกิดข้อผิดพลาดในการคอมไพล์

Java

public class DynamicTypingExample {
    public static void main(String[] args) {
        Object variable;          // ประกาศตัวแปรเป็น Object

        variable = "Hello";      // เก็บ String
        System.out.println(variable); // พิมพ์ค่าเป็น String

        variable = 10;           // พยายามเก็บ int
        System.out.println(variable); // พิมพ์ค่าเป็น int (จะเกิด warning)
        
        // เมื่อพยายามแคสต์กลับเป็น String จะเกิดข้อผิดพลาด
        String str = (String) variable; // จะเกิด ClassCastException ใน runtime
        System.out.println(str);
    }
}

Output

Java

Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
    at DynamicTypingExample.main(DynamicTypingExample.java:10)

คำอธิบาย : เมื่อรันโค้ดนี้ โปรแกรมจะเกิดข้อผิดพลาดใน runtime เนื่องจากพยายามแคสต์ variable จาก int เป็น String ซึ่งจะทำให้เกิด ClassCastException

ในกรณีนี้ variable เก็บค่า 10 เป็น int แต่เราพยายามแคสต์ให้เป็น String ซึ่งจะทำให้เกิดข้อผิดพลาดนี้ใน runtime

3. Python (Dynamic Typing)

ใน Python ทุกตัวแปรเป็น dynamic typing โดยไม่ต้องระบุชนิดข้อมูลล่วงหน้า เราสามารถเปลี่ยนชนิดของตัวแปรได้ตลอดเวลา เช่น ตัวแปรสามารถเก็บทั้งตัวเลขและสตริงในเวลาต่างๆ

• ข้อดี: เขียนโค้ดได้ยืดหยุ่น ไม่ต้องระบุชนิดข้อมูลตั้งแต่แรก ทำให้เขียนโค้ดได้เร็ว

• ข้อเสีย: อาจทำให้เจอ bug ในช่วง runtime เพราะระบบจะตรวจชนิดข้อมูลเมื่อรันโปรแกรม

หมายความว่าเราสามารถเปลี่ยนชนิดข้อมูลของตัวแปรได้ตลอดเวลาโดยไม่ต้องประกาศชนิดของตัวแปรล่วงหน้า

ตัวอย่างการใช้ dynamic typing ในภาษา Python

Python

# กำหนดตัวแปรเป็น string
variable = "Hello"
print(variable)  # Output: Hello

# เปลี่ยนตัวแปรเป็น int
variable = 10
print(variable)  # Output: 10

# เปลี่ยนตัวแปรเป็น list
variable = [1, 2, 3]
print(variable)  # Output: [1, 2, 3]

# เกิดข้อผิดพลาดเมื่อลองใช้ string operation กับตัวแปรที่เป็น list
print(variable + " World")  # พยายามรวม list กับ string จะเกิด error

Output

Python

Hello
10
[1, 2, 3]
Traceback (most recent call last):
  File "example.py", line 11, in <module>
    print(variable + " World")  # พยายามรวม list กับ string จะเกิด error
TypeError: can only concatenate list (not "str") to list

คำอธิบาย : Python จะเกิด TypeError เมื่อพยายามเอา list มาบวกกับ string เนื่องจาก + ใน Python ใช้สำหรับการต่อกันของชนิดข้อมูลเดียวกัน เช่น string ต่อกับ string หรือ list ต่อกับ list

ข้อดี - ข้อเสียของ Dynamic Type

ข้อดี ของ Dynamic Type

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

2. ลดความซับซ้อน : เหมาะกับการทำงานกับข้อมูลที่ไม่แน่นอนหรือข้อมูลที่มาจากแหล่งต่างๆ เช่น การรับข้อมูลจาก API หรือ JSON ซึ่งไม่รู้ล่วงหน้าว่าจะได้ข้อมูลประเภทไหน

3. เขียนโค้ดสั้นลง : ไม่ต้องเขียนโค้ดยาวๆ เพื่อระบุชนิดข้อมูล ทำให้โค้ดอ่านง่ายขึ้นและดูสะอาดขึ้น

4. เหมาะกับงานที่เน้น prototyping : ช่วยให้การสร้างต้นแบบโปรแกรมทำได้เร็วขึ้น เพราะไม่ต้องกังวลเรื่องชนิดข้อมูลตั้งแต่แรก

ข้อเสีย ของ Dynamic Type

1. เสี่ยงต่อข้อผิดพลาด : เนื่องจากไม่ตรวจสอบชนิดของข้อมูลตอนคอมไพล์ (compile-time) ทำให้บางครั้งโปรแกรมอาจเจอ bug ในช่วงรันไทม์ (runtime) เช่น การใช้ตัวแปรผิดชนิดโดยที่ไม่ได้ตั้งใจ

2. ประสิทธิภาพอาจต่ำกว่า : การทำงานแบบ dynamic typing ใช้ทรัพยากรมากกว่า static typing เพราะระบบต้องตรวจสอบชนิดข้อมูลขณะรันโปรแกรม ซึ่งอาจทำให้ประสิทธิภาพลดลง

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

4. อ่านโค้ดยากเมื่อโครงการใหญ่ : เมื่อโครงการขยายใหญ่ขึ้น การใช้ dynamic typing อาจทำให้ยากต่อการติดตามชนิดของตัวแปร โดยเฉพาะในโค้ดที่ซับซ้อนหรือมีหลายคนร่วมพัฒนา

ข้อควรระวังในการใช้งาน

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

2. ปัญหาค้นหา bug : bug ที่เกี่ยวกับชนิดข้อมูลอาจจะเจอเฉพาะในช่วงรันไทม์ ซึ่งทำให้แก้ไขยากขึ้น เพราะเราจะไม่รู้ว่ามีปัญหาจนกว่าจะรันโปรแกรม

3. ประสิทธิภาพลดลง : การใช้ Dynamic Type อาจทำให้โปรแกรมทำงานช้ากว่า static typing เพราะระบบต้องคอยตรวจสอบชนิดข้อมูลขณะรันโปรแกรม ถ้าต้องการให้โปรแกรมทำงานเร็วๆ ควรคิดถึงตรงนี้

4. อ่านโค้ดยากขึ้นเมื่อทีมใหญ่ : ถ้าทำงานกับทีมใหญ่หรือโค้ดซับซ้อน Dynamic Type อาจทำให้คนอื่นงงได้ เพราะไม่มีการระบุชนิดข้อมูลชัดเจน ต้องเขียนโค้ดให้ชัดเจนและใส่คอมเมนต์เพื่อให้คนอื่นเข้าใจง่ายขึ้น

5. ตรวจสอบชนิดข้อมูลให้ดี : ควรเช็คชนิดข้อมูลก่อนใช้จริง เช่น ใช้ type() หรือ isinstance() ใน Python เพื่อตรวจสอบชนิดของตัวแปรก่อนจะทำงานกับมัน เพื่อลดข้อผิดพลาดที่อาจเกิดขึ้น

Clip VDO

URL : https://youtu.be/lqiOF8TH4eI?si=fT1veoasBQRI7KGg

Slide

2MB

Dynamic Type in C#.pdf

pdf

---

แหล่งที่มาอ้างอิง

1. BillWagner. (n.d.). C# language reference. Microsoft Learn. https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/ เนื้อหาที่นำมาใช้ : ใช้เพื่ออธิบายข้อมูลพื้นฐานเกี่ยวกับ dynamic typing ในภาษา C# และวิธีการใช้งานในเวอร์ชัน 4.0 โดยเน้นไปที่คำอธิบายการทำงานและการใช้งาน dynamic type ในโค้ด C# อย่างเป็นทางการ

2. GeeksforGeeks. (2024, July 8). C# Tutorial. GeeksforGeeks. https://www.geeksforgeeks.org/csharp-programming-language/ เนื้อหาที่นำมาใช้ : ใช้ในการอธิบายเกี่ยวกับฟีเจอร์ dynamic typing ว่ามีประโยชน์อย่างไร รวมถึงเปรียบเทียบ dynamic typing กับ static typing ในภาษา C# โดยเน้นที่ข้อดีและข้อเสียของ dynamic type

3. W3Schools.com. (n.d.). https://www.w3schools.com/cs/index.php เนื้อหาที่นำมาใช้ : ใช้สำหรับยกตัวอย่างพื้นฐานการใช้ dynamic ใน C# พร้อมทั้งอธิบายการเปลี่ยนแปลงประเภทตัวแปรในช่วงรันไทม์ผ่านโค้ดตัวอย่างที่เข้าใจง่าย

4. C# Tutorial. (n.d.). https://www.tutorialspoint.com/csharp/index.htm เนื้อหาที่นำมาใช้ : ใช้สำหรับอธิบายข้อดีและข้อเสียของการใช้ dynamic ในการพัฒนาโปรแกรม

5. Learn C# Tutorial - javatpoint. (n.d.). https://www.javatpoint.com/c-sharp-tutorial เนื้อหาที่นำมาใช้ : ใช้สำหรับการเปรียบเทียบระหว่าง dynamic typing ใน C# กับภาษาอื่น ๆ เช่น C, Java, และ Python โดยนำเนื้อหาส่วนการเปรียบเทียบมาจากแหล่งนี้

6. ByteHide. (2023, August 18). Dynamic Type in C# - Full guide 2024. ByteHide. https://www.bytehide.com/blog/dynamic-type-csharp เนื้อหาที่นำมาใช้ : นำมาใช้ในการวิเคราะห์ข้อดีและข้อเสียของ dynamic typing ในภาษา C# โดยนำมาขยายความเกี่ยวกับการใช้งาน dynamic กับ Reflection

7. C# dynamic Types. (n.d.). https://www.tutorialsteacher.com/csharp/csharp-dynamic-type เนื้อหาที่นำมาใช้ : นำมาอธิบายตัวอย่างการใช้งาน dynamic type ใน C# ในกรณีต่าง ๆ พร้อมทั้งการเปรียบเทียบระหว่าง dynamic typing และ static typing อย่างละเอียด

8. Choudhary, P. K. (n.d.). Dynamic Data type in C#. https://www.c-sharpcorner.com/UploadFile/f0b2ed/dynamic-data-type-in-C-Sharp/ เนื้อหาที่นำมาใช้ : ใช้ในการขยายความเกี่ยวกับ dynamic data types โดยเฉพาะการทำงานในกรณีที่ไม่สามารถกำหนดประเภทตัวแปรล่วงหน้าได้

9. Bagheri, H. S. (2019, May 24). Best use of Dynamic in C#. https://www.linkedin.com/pulse/best-use-dynamic-c-hossein-s-bagheri เนื้อหาที่นำมาใช้ : ใช้เพื่อสนับสนุนการอธิบายการใช้งาน dynamic type ในการจัดการข้อมูลที่เปลี่ยนแปลงได้ และวิเคราะห์การใช้งานในสถานการณ์ที่ dynamic type เหมาะสม

10. Pecanac, V., & Pecanac, V. (2022, August 3). Dynamic type in C#. Code Maze. https://code-maze.com/dynamic-type-csharp/ เนื้อหาที่นำมาใช้ : ใช้สำหรับอธิบายการทำงานของ dynamic type ใน C# และข้อดี-ข้อเสียของการใช้ dynamic ในกรณีต่าง ๆ เช่น การลดการใช้ Reflection

11. Tutorials, D. N. (2023, May 7). Dynamic Type in C# with Examples - Dot Net Tutorials. Dot Net Tutorials. https://dotnettutorials.net/lesson/dynamic-type-in-csharp/#google_vignette เนื้อหาที่นำมาใช้ : ใช้เพื่อขยายการอธิบายการใช้งาน dynamic ในสถานการณ์ที่ต้องใช้ข้อมูลที่ไม่ได้รับการตรวจสอบล่วงหน้าในช่วงคอมไพล์

12. C# Dynamic Type Tutorial | KoderHQ. (n.d.). https://www.koderhq.com/tutorial/csharp/dynamic-type/#google_vignette เนื้อหาที่นำมาใช้ : ใช้ในการยกตัวอย่างการใช้งาน dynamic typing ใน C# และเปรียบเทียบการทำงานกับ static typing เพื่อแสดงให้เห็นถึงข้อแตกต่าง