เมื่อใดควรใช้การอ้างอิงและเมื่อไม่จำเป็นใน C #

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

byte[] received_s = new byte[2048];
IPEndPoint tmpIpEndPoint = new IPEndPoint(IPAddress.Any, UdpPort_msg);
EndPoint remoteEP = (tmpIpEndPoint);

int sz = soUdp_msg.ReceiveFrom(received_s, ref remoteEP); 

มันทำให้ฉันสับสนเพราะทั้งสองอย่างreceived_sและremoteEPกำลังส่งคืนสิ่งต่างๆจากฟังก์ชัน ทำไมremoteEPต้องมีrefและreceived_sไม่?

ฉันเป็นโปรแกรมเมอร์ ac ด้วยดังนั้นฉันจึงมีปัญหาในการดึงตัวชี้ออกจากหัว

แก้ไข: ดูเหมือนว่าวัตถุใน C # เป็นตัวชี้ไปยังวัตถุที่อยู่ใต้ฝากระโปรง ดังนั้นเมื่อคุณส่งผ่านวัตถุไปยังฟังก์ชันคุณสามารถแก้ไขเนื้อหาของวัตถุผ่านตัวชี้และสิ่งเดียวที่ส่งผ่านไปยังฟังก์ชันคือตัวชี้ไปยังวัตถุเพื่อไม่ให้วัตถุนั้นถูกคัดลอก คุณใช้ ref หรือ out ถ้าคุณต้องการให้สามารถสลับออกหรือสร้างวัตถุใหม่ในฟังก์ชันซึ่งเปรียบเสมือนตัวชี้คู่

คำตอบสั้น: อ่านของฉันบทความเกี่ยวกับการโต้แย้งผ่าน

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

เมื่อพารามิเตอร์ (ชนิดใดก็ได้) ถูกส่งผ่านโดยการอ้างอิงนั่นหมายความว่าผู้เรียกใช้การเปลี่ยนแปลงใด ๆ กับพารามิเตอร์ - การเปลี่ยนแปลงพารามิเตอร์คือการเปลี่ยนแปลงของตัวแปร

บทความนี้อธิบายรายละเอียดทั้งหมดนี้โดยละเอียด :)

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

คิดว่าพารามิเตอร์ non-ref เป็นตัวชี้และพารามิเตอร์ ref เป็นตัวชี้คู่ สิ่งนี้ช่วยฉันได้มากที่สุด

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

สำหรับค่าที่ส่งคืนหลายค่า

• สร้างโครงสร้างที่แสดงถึงค่าที่ส่งคืนหลายค่า

สำหรับ primitives ที่เปลี่ยนวิธีการอันเป็นผลมาจากการเรียก method (method มีผลข้างเคียงกับพารามิเตอร์ primitive)

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

คุณอาจเขียนแอป C # ทั้งหมดและไม่ส่งผ่านวัตถุ / โครงสร้างใด ๆ โดยการอ้างอิง

ฉันมีศาสตราจารย์ที่บอกฉันสิ่งนี้:

สถานที่เดียวที่คุณใช้อ้างอิงคือที่ที่คุณ:

1. ต้องการส่งผ่านวัตถุขนาดใหญ่ (เช่นวัตถุ / โครงสร้างมีวัตถุ / โครงสร้างภายในไปยังหลายระดับ) และการคัดลอกจะมีราคาแพงและ
2. คุณกำลังเรียกใช้ Framework, Windows API หรือ API อื่น ๆ ที่ต้องการ

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

ฉันเห็นด้วยกับคำแนะนำของเขาและในช่วงห้าปีที่ผ่านมาตั้งแต่เลิกเรียนฉันไม่เคยมีความต้องการนอกเหนือจากการเรียก Framework หรือ Windows API

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

เช่นไบต์อาร์เรย์เป็นตัวชี้ไปยังหน่วยความจำเดียวกันก่อนและหลังหน่วยความจำเพิ่งได้รับการอัปเดต

การอ้างอิงปลายทางกำลังอัปเดตตัวชี้ไปยังปลายทางในฟังก์ชันภายนอกเป็นอินสแตนซ์ใหม่ที่สร้างขึ้นภายในฟังก์ชัน

คิดว่าการอ้างอิงหมายถึงคุณกำลังส่งผ่านตัวชี้โดยการอ้างอิง การไม่ใช้การอ้างอิงหมายความว่าคุณกำลังส่งตัวชี้ตามค่า

ยังดีกว่าไม่สนใจสิ่งที่ฉันกล่าวว่า (มันอาจจะทำให้เข้าใจผิดโดยเฉพาะอย่างยิ่งกับประเภทค่า) และอ่านหน้านี้ MSDN

ความเข้าใจของฉันคืออ็อบเจ็กต์ทั้งหมดที่ได้รับจากคลาสอ็อบเจ็กต์จะถูกส่งผ่านเป็นพอยน์เตอร์ในขณะที่ชนิดธรรมดา (int, struct) ไม่ถูกส่งผ่านเป็นพอยน์เตอร์และต้องการการอ้างอิง ฉันไม่แน่ใจเกี่ยวกับสตริง (ท้ายที่สุดแล้วมันมาจากคลาส Object หรือไม่)

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

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

กฎ Ground Zero ก่อน Primitives จะถูกส่งผ่านโดย value (stack) และ Non-Primitive โดยการอ้างอิง (Heap) ในบริบทของ TYPES ที่เกี่ยวข้อง

พารามิเตอร์ที่เกี่ยวข้องจะถูกส่งผ่านโดยค่าเริ่มต้น โพสต์ที่ดีที่อธิบายสิ่งต่างๆโดยละเอียด http://yoda.arachsys.com/csharp/parameters.html

Student myStudent = new Student {Name="A",RollNo=1};

ChangeName(myStudent);

static void ChangeName(Student s1)
{
  s1.Name = "Z"; // myStudent.Name will also change from A to Z
                // {AS s1 and myStudent both refers to same Heap(Memory)
                //Student being the non-Primitive type
}

ChangeNameVersion2(ref myStudent);
static void ChangeNameVersion2(ref Student s1)
{
  s1.Name = "Z"; // Not any difference {same as **ChangeName**}
}

static void ChangeNameVersion3(ref Student s1)
{
    s1 = new Student{Name="Champ"};

    // reference(myStudent) will also point toward this new Object having new memory
    // previous mystudent memory will be released as it is not pointed by any object
}

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