ในภาษาซีชาร์ปเราสามารถกำหนดหน้าที่ใหม่ให้แก่ตัวกระทำ (Operator โอเปอร์เรเตอร์) เพื่อให้มันทำงานแตกต่างไปจากการทำงานปรกติที่ถูกกำหนดไว้โดยปริยายได้ เรียกการทำเช่นนี้ว่าโอเปอร์เรเตอร์โอเวอร์โหลดดิง(operator overloading) ภาษาจาวาไม่มีคุณสมบัตินี้ และเราจะทำเช่นนี้ในภาษาซีมาตรฐานก็ไม่ได้เหมือนกัน

เราสามารถโอเวอร์โหลดตัวกระทำได้ทุกชนิด ไม่ว่าจะเป็น ตัวกระทำทางคณิตศาสตร์ (อาทิ + บวก – ลบ * คูณ / หาร) ตัวกระทำทางการเปรียบเทียบ ( อาทิ > มากกว่า < น้อยกว่า == เท่ากับ) ตัวกระทำตรรกแก่บิต (& และ | หรือ) ตัวกระทำที่ต้องการผู้ถูกกระทำ (operand) เพียงตัวเดียว (อาทิ ++ เพิ่มค่า -- ลดค่า) และอื่น ๆ

มีตัวกระทำเพียงไม่กี่แบบที่โอเวอร์โหลดไม่ได้ เช่น ตัวกระทำตรรก && และ || หรือ, ตัวกระทำสำหรับกำหนดดรรชนีของอาร์เรย์ [ ], ตัวกระทำเพื่อการแปลงค่า ( ), ตัวกระทำสร้างออพเจ็กต์ new, และตัวกระทำเพื่อกำหนดค่า = ฯลฯ

การโอเวอร์โหลดตัวกระทำ ๆ ได้โดยนิยามเมธอดพิเศษเพื่อการนี้โดยเฉพาะโดยมีโครงสร้างตามที่เห็นในภาพ คือจะต้องเป็นเมธอดที่มีเอ็กเซสโมดิไฟเออร์เป็นแบบพับลิก และเป็นสแตติก คำว่า return_type ในกรณีที่เป็นการโอเวอร์โหลดตัวกระทำแบบเดี่ยว (คือ unary operator อย่าง +, ~, ! และจุด) ให้แทนด้วยค่าส่งกลับซึ่งเป็นชนิดข้อมูลอะไรก็ได้ที่ต้องการ (ยกเว้น void) ในกรณีที่โอเวอร์โหลดตัวกระทำ ++ และ - - ค่าส่งกลับจะต้องเป็นชนิดข้อมูลเดียวกันกับ Type ในวงเล็บ ถ้าต้องการโอเวอร์โหลดตัวกระทำ true หรือ false ท่านจำเป็นจะต้องนิยามเมธอดสองเมธอด เมธอดแรกสำหรับนิยามค่า true และอีกอันสำหรับ false และค่าส่งกลับก็ต้องเป็นแบบบูลีนด้วย หากลืมนิยามให้ครบทั้งสอบแบบจะมีข้อความแจ้งความผิดพลาดตอนคอมไพล์ คำว่า operator ที่อยุ่หลัง return_type ที่เห็นในภาพเป็นคำเฉพาะ (คีย์เวิร์ด keyword) ที่จำเป็นต้องใส่ไว้ในตำแหน่งนั้น ความพิเศษของเมธอดชนิดนี้คือเราไม่ต้องกำหนดชื่อให้กับมัน ตำแหน่งที่ควรจะเป็นชื่อเมธอดกลายเป็นคำว่า op ซึ่งหมายถึงให้ท่านใส่ตัวกระทำที่จะโอเวอร์โหลดไว้ตรงนั้น ยกตัวอย่างเช่น หากท่านต้องการโอเวอร์โหลดตัวกระทำ + ให้ท่านใส่เครื่องหมาย + แทนคำว่า op ถัดมาในวงเล็บคือพารามิเตอร์ หากต้องการโอเวอร์โหลดตัวกระทำแบบเดี่ยว (unary operator ต้องการตัวถูกกระทำตัวเดียว) จะมีพารามิเตอร์หนึ่งตัว หากต้องการโอเวอร์โหลดตัวกระทำแบบคู่ (binary operator ต้องการตัวถูกกระทำสองตัว) ท่านจะต้องใส่พารามิเตอร์สองตัว โดย Type จะต้องเป็นคลาสหรือ struct ที่ท่านนิยามขึ้นเอง

ในโค้ดตัวอย่างการโอเวอร์โหลดตัวกระทำแบบยูนารี
บรรทัดที่ 9 ถึง 32 คือนิยามคลาส Complex ในคลาสนี้จะมีการโอเวอร์โหลดตัวกระทำ – (เครื่องหมายลบ) ให้ทำหน้าที่แปลงข้อมูลของออพเจ็กต์จากเลขจำนวนเต็มบวกเป็นเลขจำนวนเต็มลบ
บรรทัดที่ 11,12 ประกาศสมาชิกแบบฟิลด์ที่จะใช้เป็นตัวเก็บข้อมูล
บรรทัดที่ 13-15 คือนิยามเมธอดคอนสทรักเตอร์ที่เป็นตัวดีฟอลต์
บรรทัดที่ 16-20 คือการทำโอเวอร์โหลดเมธอดคอนสทรักเตอร์เป็นแบบมีพารามิเตอร์สองตัว โดยจะนำค่าจากพารามิเตอร์ทั้งสองนี้ไปกำหนดค่าให้แก่ฟิลด์สมาชิก

บรรทัดที่ 21-24 คือนิยามเมธอด ShowYX() ซึ่งทำหน้าที่แสดงค่าของฟิลด์สมาชิกที่คอนโซล
บรรทัดที่ 25-31 คือเมธอดที่ทำหน้าที่โอเวอร์โหลดตัวกระทำ – โปรดสังเกตว่าค่าส่งกลับและพารามิเตอร์เป็นชนิดข้อมูลเดียวกันคือ Complex ซึ่งถูกนิยามโดยคลาสนี้
บรรทัดที่ 27 สร้างออพเจ็กต์ (ที่ถูกอ้างถึงโดยตัวแปร) ชื่อ temp
บรรทัดที่ 28-29 นำค่ามาจากพารามิเตอร์คือ x และ y ของ c แล้วเปลี่ยนให้เป็นจำนวนลบ แล้วนำไปใส่ไว้ใน x และ y ของ temp จากนั้นส่งค่ากลับไปด้วยคำสั่ง return

โค้ดตัวอย่างแสดงการใช้งานตัวกระทำที่ถูกโอเวอร์โหลดคือบรรทัดที่ 37 ถึง 42
บรรทัดที่ 37 สร้างออพเจ็กต์ c1 จากคลาส Complex ที่นิยามไว้โดยเรียกคอนสทรักเตอร์แบบมีพารามิเตอร์สองตัวแล้วส่งค่า 10 และ 20 ไป
บรรทัดที่ 38 เรียกหาเมธอด ShowXY() ของออพเจ็กต์ c1 ซึ่งเผยให้เห็นว่าค่า x และ y ของ c1 มีค่าเป็น 10 และ 20 ตามลำดับ

บรรทัดที่ 39 สร้างออพเจ็กต์ c2 จากคลาส Complex ที่นิยามไว้โดยเรียกดีฟอลต์คอนสทรักเตอร์
บรรทัดที่ 40 เรียกหาเมธอด ShowXY() ของออพเจ็กต์ c2 ซึ่งเผยให้เห็นว่าค่า x และ y ของ c2 มีค่าเป็น 0 และ 0 ตามลำดับ

บรรทัดที่ 41 แสดงการเรียกใช้ตัวกระทำ – ที่ถูกโอเวอร์โหลดไว้ในคลาส Complex ซึ่งจะมีผลให้โค้ดบรรทัด 27-30 ทำงาน เมื่อสั่งให้แสดงค่าของ x และ y โดยเรียกเมธอด ShowXY()
บรรทัดที่ 42 จะพบว่าค่าของ x และ y จะเป็น -10 และ -20 ตามลำดับ

การโอเวอร์โหลดตัวกระทำแบบที่มีตัวถูกกระทำสองฝั่งหรือ binary operator มีโครงสร้างนิยามอย่างที่เห็นในภาพ จะเห็นว่าเหมือนกับโครงสร้างนิยามของการโอเวอร์โหลดตัวกระทำแบบที่มีตัวถูกกระทำฝั่งเดียวหรือ unary operator เกือบทุกประการยกเว้นในวงเล็บจะมีพารามิเตอร์เพิ่มขึ้นมาอีกหนึ่งตัว คือ Type2 ข้อกำหนดของโครงสร้างนิยามการโอเวอร์โหลดตัวกระทำแบบที่มีตัวถูกกระทำสองฝั่งคือจะต้องมีพารามิเตอร์อย่างน้อยหนึ่งตัวเป็นชนิดข้อมูลแบบคลาสหรือ struct
ขณะที่ return_type จะเป็นชนิดข้อมูลอะไรก็ได้ (ยกเว้น void) 

ในโค้ดตัวอย่างการแสดงการโอเวอร์โหลดตัวกระทำแบบไบนารีจะคล้ายกับตัวอย่างก่อนหน้านี้
บรรทัดที่ 9 ถึง 31 คือนิยามคลาส Complex ที่มีการโอเวอร์โหลดตัวกระทำ + (เครื่องหมายบวก) ให้ทำหน้าที่นำฟิลด์สองฟิลด์ (x และ y) จากออพเจ็กต์หนึ่งมาบวกกับ x และ y ในอีกออพเจ็กต์หนึ่ง

บรรทัดที่ 11,12 ประกาศสมาชิกแบบฟิลด์ที่จะใช้เป็นตัวเก็บข้อมูล
บรรทัดที่ 13 คือนิยามเมธอดคอนสทรักเตอร์ที่เป็นตัวดีฟอลต์
บรรทัดที่ 15-19 คือการทำโอเวอร์โหลดเมธอดคอนสทรักเตอร์เป็นแบบมีพารามิเตอร์สองตัว โดยจะนำค่าจากพารามิเตอร์ทั้งสองนี้ไปกำหนดค่าให้แก่ฟิลด์สมาชิก

บรรทัดที่ 20-23 คือนิยามเมธอด ShowYX() ซึ่งทำหน้าที่แสดงค่าของฟิลด์สมาชิกที่คอนโซล
บรรทัดที่ 24-30 คือเมธอดที่ทำหน้าที่โอเวอร์โหลดตัวกระทำ + โปรดสังเกตว่าค่าส่งกลับและพารามิเตอร์ทั้งสองตัวเป็นชนิดข้อมูลเดียวกันคือ Complex ซึ่งถูกนิยามโดยคลาสนี้
บรรทัดที่ 26 สร้างออพเจ็กต์ (ที่ถูกอ้างถึงโดยตัวแปร) ชื่อ temp
บรรทัดที่ 27-28 นำค่ามาจากพารามิเตอร์ x และ y ของ c1 แล้วนำไปบวกกับพารามิเตอร์ x และ y ของ c2 แล้วนำไปใส่ไว้ใน x และ y ของ temp จากนั้นส่งค่ากลับไปด้วยคำสั่ง return

โค้ดตัวอย่างแสดงการใช้งานตัวกระทำที่ถูกโอเวอร์โหลดคือบรรทัดที่ 36 ถึง 42
บรรทัดที่ 36 สร้างออพเจ็กต์ c1 จากคลาส Complex ที่นิยามไว้โดยเรียกคอนสทรักเตอร์แบบมีพารามิเตอร์สองตัวแล้วส่งค่า 10 และ 20 ไป
บรรทัดที่ 37 เรียกหาเมธอด ShowXY() ของออพเจ็กต์ c1 ซึ่งเผยให้เห็นว่าค่า x และ y ของ c1 มีค่าเป็น 10 และ 20 ตามลำดับ
บรรทัดที่ 38 สร้างออพเจ็กต์ c2 จากคลาส Complex ที่นิยามไว้โดยเรียกคอนสทรักเตอร์แบบมีพารามิเตอร์สองตัวแล้วส่งค่า 10 และ 20 ไป
บรรทัดที่ 39 เรียกหาเมธอด ShowXY() ของออพเจ็กต์ c2 ซึ่งเผยให้เห็นว่าค่า x และ y ของ c2 มีค่าเป็น 20 และ 30 ตามลำดับ
บรรทัดที่ 41 แสดงการเรียกใช้ตัวกระทำ + ที่ถูกโอเวอร์โหลดไว้ในคลาส Complex ซึ่งจะมีผลให้โค้ดบรรทัด 26-29 ทำงาน เมื่อสั่งให้แสดงค่าของ x และ y โดยเรียกเมธอด ShowXY()
บรรทัดที่ 42 จะพบว่าค่าของ x และ y จะเป็น 30 และ 50 ตามลำดับ

 

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

ในตัวอย่างโค้ดแสดงการสืบคุณสมบัติตัวกระทำยูนารี + (เครื่องหมายบวก) ที่ถูกโอเวอร์โหลดไว้ในเบสคลาส เรานิยามคลาส FooComplex ซึ่งสืบคุณสมบัติจาก Complex
จึงได้รับคุณสมบัติตัวกระทำยูนารี + ที่ถูกโอเวอร์โหลดไว้ในคลาส Complex มาด้วยโดยอัตโนมัติ

 

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

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

พอยน์เตอร์เป็นชนิดข้อมูลแบบพิเศษที่เพิ่มขึ้นจากสองประเภทหลัก คือ แวลูไทป์ (value type) และรีเฟอร์เรนซ์ไทป์ (reference type) ส่วนพอยน์เตอร์เป็นชนิดข้อมูลชื่อ พอยน์เตอร์ไทป์ (pointer type) ชนิดข้อมูลแบบแวลูไทป์ทำหน้าที่เก็บข้อมูลโดยตรง เช่น int k = 123; ตัวแปร k จะมีค่า 123 เก็บอยู่ ส่วนชนิดข้อมูลแบบรีเฟอร์เรนซ์ไทป์ทำหน้าที่เก็บตัวอ้างอิงที่อ้างไปยังข้อมูล เช่น string s = “hello” ตัวแปร s ทำหน้าที่เก็บค่าอ้างอิงไปยังตำแหน่งที่เก็บข้อความว่า hello ในตัวแปร s ไม่ได้เก็บตัวชุดอักษร hello ส่วนชนิดข้อมูลแบบพอยน์เตอร์ทำหน้าที่เก็บเลขระบุตำแหน่งในหน่วยความจำของคอมพิวเตอร์ แนวคิดเรื่องพอยน์เตอร์มาจากภาษาเครื่อง (machine language) เพราะภายในซีพียูทุกตัวมีรีจิสเตอร์ (register) ที่ถูกกำหนดให้ทำหน้าที่เก็บค่าอ้างอิงไปยังตำแหน่งในหน่วยความจำ บางซีพียูมีรีจิสเตอร์แบบนี้หลายตัวและมีเทคนิคการอ้างถึงตำแหน่งในหน่วยความจำ (addressing technique) ได้หลายกลวิธี เมื่อภาษาซีถูกสร้างขึ้นจึงกำหนดให้มีพอยน์เตอร์เพื่อให้สามารถคอมไพล์ได้ลงรอยกับภาษาเครื่อง ภาษาซีและภาษาซีพลัสพลัส ที่แม้จะเป็นภาษาระดับสูงกว่าภาษาเครื่องหนึ่งชั้น แต่นักเขียนโค้ดยังคงมีจิตใจที่ยึดมั่นกับฮาร์ดแวร์อยู่มาก จึงเขียนโค้ดโดยใช้พอยน์เตอร์เป็นกำลังสำคัญ ขณะที่นักเขียนโค้ดภาษาซีชาร์ปส่วนใหญ่จิตหลุดพ้นจากฮาร์ดแวร์แล้ว จึงเขียนโด้ดตามคตินามธรรมโดยบริสุทธิ์ใจ ซึ่งการเขียนโค้ดแบบนี้ไม่มีความจำเป็นต้องใช้พอยน์เตอร์ เพราะสามารถใช้รีเฟอร์เรนซ์ไทป์ทดแทนได้อย่างสมบูรณ์

วิธีประกาศตัวแปรแบบพอยน์เตอร์เป็นอย่างที่เห็นในบรรทัดที่ 2 คำว่า type คือชนิดข้อมูลที่พอยน์เตอร์จะเก็บตัวอ้างอิง เช่นชนิดข้อมูลกลุ่มเลขจำนวนเต็ม (sbyte, byte, short, ushort, int, uint, long, ulong)
ชนิดข้อมูลกลุ่มเลขมีทศนิยม (float, double) และชนิดข้อมูลอื่น ๆ เช่น bool, enum, decimal, char เครื่องหมายดอกจันทร์ * คือตัวบอกให้รู้ว่าตัวแปรนี้เป็นพอยน์เตอร์ คำว่า identifier คือชื่อตัวแปรที่เราต้องการประกาศ
บรรทัดที่ 3 ถ้าเราไม่รู้ชนิดข้อมูลจะใช้คำว่า void ก็ได้แต่ไม่แนะนำให้ทำ
บรรทัดที่ 4 แสดงตัวอย่างที่ถูกต้องในการประกาศตัวแปรพอยน์เตอร์ชนิด int สามตัวภายในบรรทัดเดียวกัน
บรรทัดที่ 5 เป็นตัวอย่างการประกาศที่ผิด
บรรทัดที่ 7 คือการประกาศตัวแปรพอยน์เตอร์ที่เก็บค่าพอยน์เตอร์อีกทอดหนึ่ง หรือพอยน์เตอร์ที่ชี้ไปยังพอยน์เตอร์
บรรทัดที่ 8 คือการประกาศอาร์เรย์ของพอยน์เตอร์ เป็นอาร์เรย์มิติเดียวที่เก็บพอยน์เตอร์ชนิดเลขจำนวนเต็ม