Geri arama nedir ve C # ile nasıl uygulanır?

Olarak bilgisayar programlama , bir geri arama çalıştırılabilir kod bir şekilde geçirilir argüman diğer kod.

- Wikipedia: Geri arama (bilgisayar bilimi)

C # bu amaçla delege sahibidir . Bir olay ekli delegeleri (olay işleyicileri) otomatik olarak çağırabileceğinden, etkinliklerle yoğun olarak kullanılırlar .

Sadece seninle tanıştım,
Ve bu çılgınca,
Ama işte numaram (delege), Bir
şey olursa (olay),
Beni ara, belki (geri arama)?

Geri arama, belirli bir görevi yürütme işlemi tamamlandığında çağrılacak bir işlevdir.

Geri arama kullanımı genellikle eşzamansız mantık içindedir.

C # 'da bir geri arama oluşturmak için, bir değişkenin içine bir fonksiyon adresi kaydetmeniz gerekir. Bu, a delegateveya yeni lambda semantik Funcveya Action.

    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);
    }

Bugün C #, bu lambda gibi kullanılarak yapılabilir:

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

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

Tanım

Geri arama , diğer koda argüman olarak iletilen yürütülebilir koddur.

uygulama

// 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();
    }
}

kullanım

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

Bağlantılar

• C # için daha fazla ayrıntı .

Geri arama, başka bir işleve ilettiğiniz bir işlev işaretçisidir. Aradığınız işlev, tamamlandığında diğer işlevi 'geri çağırır' (yürütür).

Bu bağlantıya göz atın .

ASP.Net geri aramalarına başvuruyorsanız:

ASP.NET Web sayfaları için varsayılan modelde, kullanıcı bir sayfa ile etkileşime girer ve bir düğmeyi tıklatır veya geri gönderme ile sonuçlanan başka bir eylem gerçekleştirir. Sayfa ve kontrolleri yeniden oluşturulur, sayfa kodu sunucuda çalışır ve sayfanın yeni bir sürümü tarayıcıya oluşturulur. Ancak, bazı durumlarda, bir geri gönderme gerçekleştirmeden istemciden sunucu kodu çalıştırmak yararlıdır. Sayfadaki istemci komut dosyası bazı durum bilgilerini koruyorsa (örneğin, yerel değişken değerleri), sayfayı yayınlamak ve yeni bir kopyasını almak bu durumu yok eder. Ayrıca, sayfa geri gönderimleri, performansı düşürebilen ve kullanıcıyı sayfanın işlenmesini ve yeniden oluşturulmasını beklemeye zorlayabilecek işleme yükü sunar.

İstemci durumunu kaybetmemek ve sunucu gidiş dönüşünün işlem yüküne maruz kalmamak için, ASP.NET Web sayfasını istemci geri çağrıları yapabilmesi için kodlayabilirsiniz. İstemci geri aramasında, istemci komut dosyası işlevi bir ASP.NET Web sayfasına istek gönderir. Web sayfası normal yaşam döngüsünün değiştirilmiş bir sürümünü çalıştırır. Sayfa başlatılır ve kontrolleri ve diğer üyeleri oluşturulur ve daha sonra özel olarak işaretlenmiş bir yöntem çağrılır. Yöntem, kodladığınız işlemi gerçekleştirir ve ardından tarayıcıya başka bir istemci komut dosyası işlevi tarafından okunabilen bir değer döndürür. Bu işlem boyunca sayfa tarayıcıda yayında.

Kaynak: http://msdn.microsoft.com/en-us/library/ms178208.aspx

Koddaki geri aramalara başvuruyorsanız:

Geri aramalar genellikle belirli bir işlem tamamlandığında veya bir alt eylem gerçekleştirdiğinde çağrılan yöntemlere delege olur. Bunları genellikle eşzamansız işlemlerde bulacaksınız. Hemen hemen her kodlama dilinde bulabileceğiniz bir programlama prensibidir.

Daha fazla bilgi burada: http://msdn.microsoft.com/en-us/library/ms173172.aspx

LightStriker'a Adanmışlık:
Örnek Kod:

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();
    }       
}

Kod Açıklaması:

Yukarıdaki cevaplardan LightStriker tarafından sağlanan komik açıklamayı uygulamak için kod oluşturdum. Temsilciyi (sayı) bir yönteme ( MetYourCrush) aktarıyoruz . İlgilenilen (olay) method ( MetYourCrush) öğesinde gerçekleşirse, CallMeBackyöntemin başvurusunu tutan temsilci (sayı) olarak adlandırılır . Böylece CallMeBackyöntem çağrılır. Temel olarak, geri arama yöntemini çağırmak için temsilci geçiriyoruz.

Herhangi bir sorunuz olursa lütfen bize bildirin.

Muhtemelen sözlük tanımı değil, geri arama genellikle belirli bir nesnenin dışında olan, depolanan ve daha sonra belirli bir olay üzerine çağrılan bir işlevi ifade eder.

Bir kullanıcı arabirimi düğmesi oluşturulduğunda, eylem gerçekleştiren bir işleve başvuruyu depolamak buna bir örnektir. Eylem, kodun farklı bir bölümü tarafından işlenir, ancak düğmeye basıldığında, geri arama çağrılır ve bu işlemin gerçekleştirilmesini sağlar.

C # 'yerine' geri arama 'terimi' olaylar 've' delegeler 'kullanır ve delegeler hakkında daha fazla bilgiyi burada bulabilirsiniz .

Geri arama yürütülebilir kodu diğer koda argüman olarak iletmenizi sağlar. C ve C ++ 'da bu bir işlev işaretçisi olarak uygulanır. .NET'te işlev işaretçileri yönetmek için bir temsilci kullanırsınız.

Birkaç kullanım, hata sinyali ve bir işlevin hareket edip etmediğini kontrol etmeyi içerir.

Vikipedi

geri arama çalışma adımları:

1) ICallbackEventHandlerArayüzü uygulamak zorundayız

2) İstemci komut dosyasını kaydedin:

 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 çağrı Onclient EX için tıklayın çağrı javascript fonksiyonu: - builpopup(p1,p2,p3...)

var final alanı = p1, p2, p3; UseCallBack(finalfield, ""); UseCallBack kullanılarak istemciden alınan veriler sunucu tarafına aktarıldı

2) public void RaiseCallbackEvent(string eventArgument) eventArgument öğesinde iletilen verileri alıyoruz // sunucu tarafında bazı işlemler yapıyoruz ve "callbackResult" a geçiyoruz

3) GetCallbackResult() // bu yöntem kullanılarak veriler istemci (ReceiveServerData () işlevi) tarafına geçirilir

callbackResult

4) Veriyi istemci tarafında alın:, ReceiveServerData(text) metin sunucusu yanıtında, alacağız.

Delegeler, C ++ 'da arayüz tabanlı geri aramalarla aynı şeyi yapar (COM bunları kullanır), ancak kullanımı çok daha basittir.

Microsoft'un delegelerini Java uygulamasına (J ++) koyduğunu, ancak Sun'ın onları beğenmediğini [java.sun.com] unutmayın, bu yüzden onları yakında Java'nın resmi sürümünde görmeyi beklemeyin. Onları C ++ ile kullanmanıza izin vermek için bir ön işlemciyi hackledim, bu yüzden C # veya .NET platformunda (yani Managed C ++ veya Visual Basic.NET'te) programlama yapmıyorsanız dışarıda hissetmeyin.

C'de işaretçileri çalıştırmaya alışkınsanız, bir temsilci temel olarak bir taneye yuvarlanmış bir çift işaretleyicidir:

• Bir nesneye işaretçi (isteğe bağlı)
• Bu nesnenin yöntemine bir işaretçi

Bu, tek bir temsilci, ister statik bir yöntem ister bir nesneyle ilişkilendirilmiş olsun, programınızdaki bir işlevi bulmak için gereken tüm bilgileri iletir.

Bunları C # ile şu şekilde tanımlarsınız:

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

Bunları kullanmak istediğinizde, temsilciyi aramak istediğiniz işlevden çıkarırsınız:

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.
    }
}

Bir temsilci statik bir yönteme işaret edecek şekilde yapmak istiyorsanız, aynı görünüyor:

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 );
    }
}

Sonuç olarak, C ++ 'da arayüz tabanlı geri aramalarla aynı şeyi yaparlar, ancak işlevlerinizi adlandırmak veya yardımcı nesneler yapmak konusunda endişelenmenize gerek olmadığından ve herhangi bir yöntemden temsilci oluşturabileceğiniz için biraz daha az soruna neden olurlar. Daha esnektirler.