โทรกลับคืออะไรและมีการนำไปใช้ใน C # อย่างไร

ในการเขียนโปรแกรมคอมพิวเตอร์การเรียกกลับเป็นรหัสเรียกทำงานที่ถูกส่งผ่านเป็นอาร์กิวเมนต์ไปยังรหัสอื่น

- Wikipedia: โทรกลับ (วิทยาการคอมพิวเตอร์)

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

ฉันเพิ่งพบคุณ
และนี่มันบ้า
แต่นี่คือหมายเลขของฉัน (ผู้แทน),
ดังนั้นถ้ามีอะไรเกิดขึ้น (เหตุการณ์)
โทรหาฉันอาจจะ (โทรกลับ)?

การเรียกกลับเป็นฟังก์ชั่นที่จะถูกเรียกเมื่อกระบวนการเสร็จสิ้นการดำเนินงานที่เฉพาะเจาะจง

การใช้งานของการโทรกลับมักจะอยู่ในตรรกะแบบอะซิงโครนัส

ในการสร้างการโทรกลับใน C # คุณต้องจัดเก็บที่อยู่ฟังก์ชันไว้ในตัวแปร นี่คือความสำเร็จโดยใช้delegateหรือแลมบ์ดาใหม่ความหมายหรือFuncAction

    public delegate void WorkCompletedCallBack(string result);

    public void DoWork(WorkCompletedCallBack callback)
    {
        callback("Hello world");
    }

    public void Test()
    {
        WorkCompletedCallBack callback = TestCallBack; // Notice that I am referencing a method without its parameter
        DoWork(callback);
    }

    public void TestCallBack(string result)
    {
        Console.WriteLine(result);
    }

ในวันนี้ C # สามารถทำได้โดยใช้แลมบ์ดาเช่น:

    public void DoWork(Action<string> callback)
    {
        callback("Hello world");
    }

    public void Test()
    {
        DoWork((result) => Console.WriteLine(result));
    }

คำนิยาม

การเรียกกลับเป็นรหัสเรียกทำงานที่ถูกส่งผ่านเป็นอาร์กิวเมนต์ไปยังรหัสอื่น

การดำเนินงาน

// Parent can Read
public class Parent
{
    public string Read(){ /*reads here*/ };
}

// Child need Info
public class Child
{
    private string information;
    // declare a Delegate
    delegate string GetInfo();
    // use an instance of the declared Delegate
    public GetInfo GetMeInformation;

    public void ObtainInfo()
    {
        // Child will use the Parent capabilities via the Delegate
        information = GetMeInformation();
    }
}

การใช้

Parent Peter = new Parent();
Child Johny = new Child();

// Tell Johny from where to obtain info
Johny.GetMeInformation = Peter.Read;

Johny.ObtainInfo(); // here Johny 'asks' Peter to read

การเชื่อมโยง

• รายละเอียดเพิ่มเติมสำหรับ C #

การเรียกกลับเป็นตัวชี้ฟังก์ชันที่คุณส่งผ่านไปยังฟังก์ชันอื่น ฟังก์ชั่นที่คุณโทรจะ 'โทรกลับ' (ดำเนินการ) ฟังก์ชั่นอื่น ๆ เมื่อมันเสร็จสมบูรณ์

ตรวจสอบนี้การเชื่อมโยง

หากคุณอ้างถึงการเรียกกลับ ASP.Net:

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

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

ที่มา: http://msdn.microsoft.com/en-us/library/ms178208.aspx

หากคุณอ้างถึงการโทรกลับในรหัส:

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

ข้อมูลเพิ่มเติมที่นี่: http://msdn.microsoft.com/en-us/library/ms173172.aspx

การอุทิศตนเพื่อ LightStriker:
รหัสตัวอย่าง:

class CallBackExample
{
    public delegate void MyNumber();
    public static void CallMeBack()
    {
        Console.WriteLine("He/She is calling you.  Pick your phone!:)");
        Console.Read();
    }
    public static void MetYourCrush(MyNumber number)
    {
        int j;
        Console.WriteLine("is she/he interested 0/1?:");
        var i = Console.ReadLine();
        if (int.TryParse(i, out j))
        {
            var interested = (j == 0) ? false : true;
            if (interested)//event
            {
                //call his/her number
                number();
            }
            else
            {
                Console.WriteLine("Nothing happened! :(");
                Console.Read();
            }
        }
    }
    static void Main(string[] args)
    {
        MyNumber number = Program.CallMeBack;
        Console.WriteLine("You have just met your crush and given your number");
        MetYourCrush(number);
        Console.Read();
        Console.Read();
    }       
}

คำอธิบายรหัส:

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

โปรดแจ้งให้เราทราบหากคุณมีข้อสงสัย

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

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

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

การโทรกลับช่วยให้คุณสามารถส่งรหัสที่สามารถใช้งานได้เป็นอาร์กิวเมนต์ไปยังรหัสอื่น ใน C และ C ++ สิ่งนี้ถูกนำมาใช้เป็นตัวชี้ฟังก์ชั่น ใน. NET คุณจะใช้ผู้รับมอบสิทธิ์ในการจัดการตัวชี้ฟังก์ชั่น

การใช้งานบางอย่างรวมถึงการส่งสัญญาณข้อผิดพลาดและการควบคุมว่าฟังก์ชั่นทำหน้าที่หรือไม่

วิกิพีเดีย

ขั้นตอนการโทรกลับ:

1) เราต้องใช้ICallbackEventHandlerส่วนต่อประสาน

2) ลงทะเบียนสคริปต์ลูกค้า:

 String cbReference = Page.ClientScript.GetCallbackEventReference(this, "arg", "ReceiveServerData", "context");
    String callbackScript = "function UseCallBack(arg, context)" + "{ " + cbReference + ";}";
    Page.ClientScript.RegisterClientScriptBlock(this.GetType(), "UseCallBack", callbackScript, true);

1) จาก UI การโทร Onclient คลิกฟังก์ชั่นการโทรจาวาสคริปต์สำหรับ EX: - builpopup(p1,p2,p3...)

var finalfield = p1, p2, p3; UseCallBack(finalfield, ""); ข้อมูลจากไคลเอนต์ที่ส่งผ่านไปยังฝั่งเซิร์ฟเวอร์โดยใช้ UseCallBack

2) public void RaiseCallbackEvent(string eventArgument) ใน eventArgument เราได้รับข้อมูลที่ส่งผ่าน // ทำการดำเนินการด้านเซิร์ฟเวอร์และส่งผ่านไปยัง "callbackResult"

3) GetCallbackResult() // การใช้ข้อมูลวิธีนี้จะถูกส่งผ่านไปยังฝั่งไคลเอ็นต์ (ReceiveServerData () ฟังก์ชั่น)

callbackResult

4) รับข้อมูลที่ฝั่งไคลเอ็นต์: ReceiveServerData(text) ในการตอบกลับเซิร์ฟเวอร์ข้อความเราจะได้รับ

ผู้รับมอบสิทธิ์ทำสิ่งเดียวกันกับการเรียกกลับตามอินเตอร์เฟสใน C ++ (COM ใช้สิ่งเหล่านี้) แม้ว่าจะใช้งานได้ง่ายกว่ามาก

โปรดทราบว่า Microsoft ได้มอบหมายผู้รับมอบสิทธิ์ในการนำ Java ไปใช้ (J ++) แต่ Sun ไม่ชอบพวกเขา [java.sun.com] ดังนั้นอย่าคาดหวังว่าจะเห็นพวกเขาใน Java เวอร์ชันอย่างเป็นทางการเร็ว ๆ นี้ ฉันแฮ็ก preprocessor ร่วมกันเพื่อให้คุณใช้พวกมันใน C ++ ดังนั้นอย่าลืมว่าถ้าคุณไม่ได้เขียนโปรแกรมใน C # หรือบนแพลตฟอร์ม. NET (เช่นใน Managed C ++ หรือ Visual Basic.NET)

หากคุณคุ้นเคยกับการใช้งานพอยน์เตอร์พอยน์ใน C ผู้ได้รับมอบหมายโดยทั่วไปจะเป็นพอยน์เตอร์หนึ่งคู่ที่รวมกันเป็นหนึ่ง:

• ตัวชี้ไปยังวัตถุ (ไม่จำเป็น)
• ตัวชี้ไปยังวิธีการของวัตถุนั้น

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

คุณกำหนดให้พวกเขาเช่นนี้ใน C #:

public delegate void FooCallbackType( int a, int b, int c );

เมื่อคุณต้องการใช้พวกเขาให้คุณมอบหมายหน้าที่ที่คุณต้องการโทรออก:

class CMyClass
{
    public void FunctionToCall( int a, int b, int c )
    {
        // This is the callback
    }

    public void Foo()
    {
        FooCallbackType myDelegate = new FooCallbackType(
            this.FunctionToCall );
        // Now you can pass that to the function
        // that needs to call you back.
    }
}

ถ้าคุณต้องการให้ผู้รับมอบสิทธิ์ชี้ไปที่วิธีการแบบคงที่มันก็ดูเหมือนกัน:

class CMyClassWithStaticCallback
{
    public static void StaticFunctionToCall( int a, int b, int c )
    {
        // This is the callback
    }

    public static void Foo()
    {
        FooCallbackType myDelegate = new FooCallbackType(
            CMyClass.StaticFunctionToCall );
    }
}

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