Ereignisse, Protokolle und Delegaten in Xamarin.iOS

  • Artikel

Xamarin.iOS verwendet Steuerelemente, um Ereignisse für die meisten Benutzerinteraktionen verfügbar zu machen. Xamarin.iOS-Anwendungen nutzen diese Ereignisse auf die gleiche Weise wie herkömmliche .NET-Anwendungen. Die UIButton-Klasse Xamarin.iOS verfügt beispielsweise über ein Ereignis namens TouchUpInside und nutzt dieses Ereignis so, als ob diese Klasse und das Ereignis in einer .NET-App wären.

Neben diesem .NET-Ansatz macht Xamarin.iOS ein weiteres Modell verfügbar, das für komplexere Interaktion und Datenbindung verwendet werden kann. Diese Methodik verwendet, was Apple Delegaten und Protokolle nennt. Delegaten ähneln dem Konzept von Delegaten in C#, aber anstatt eine einzelne Methode zu definieren und aufzurufen, ist ein Delegate in Objective-C eine ganze Klasse, die einem Protokoll entspricht. Ein Protokoll ähnelt einer Schnittstelle in C#, mit der Ausnahme, dass seine Methoden optional sein können. Um beispielsweise eine UITableView mit Daten aufzufüllen, erstellen Sie eine Delegatenklasse, die die im UITableViewDataSource-Protokoll definierten Methoden implementiert, die die UITableView aufrufen würde, um sich selbst aufzufüllen.

In diesem Artikel erfahren Sie mehr über all diese Themen und bieten Ihnen eine solide Grundlage für die Behandlung von Rückrufszenarien in Xamarin.iOS, einschließlich:

  • Ereignisse : Verwenden von .NET-Ereignissen mit UIKit-Steuerelementen.
  • Protokolle : Lernen Sie, welche Protokolle sind und wie sie verwendet werden, und erstellen Sie ein Beispiel, das Daten für eine Kartenanmerkung bereitstellt.
  • Delegaten – Lernen Sie mehr über Objective-C Delegaten, indem Sie das Kartenbeispiel erweitern, um Benutzerinteraktionen zu behandeln, die eine Anmerkung enthält, und dann den Unterschied zwischen starken und schwachen Delegaten und wann diese verwendet werden sollen.

Um Protokolle und Delegaten zu veranschaulichen, erstellen wir eine einfache Kartenanwendung, die einer Karte eine Anmerkung hinzufügt, wie hier gezeigt:

Ein Beispiel für eine einfache Kartenanwendung, die einer Karte eine Anmerkung hinzufügtEine Beispielanmerkung, die einer Karte hinzugefügt wurde

Bevor Sie sich mit dieser App befassen, sehen wir uns zunächst .NET-Ereignisse unter dem UIKit an.

.NET-Ereignisse mit UIKit

Xamarin.iOS macht .NET-Ereignisse für UIKit-Steuerelemente verfügbar. UiButton verfügt beispielsweise über ein TouchUpInside-Ereignis, das Sie wie gewohnt in .NET behandeln, wie im folgenden Code gezeigt, der einen C#-Lambdaausdruck verwendet:

aButton.TouchUpInside += (o,s) => {
    Console.WriteLine("button touched");
};

Sie können dies auch mit einer anonymen C# 2.0-Methode wie der folgenden implementieren:

aButton.TouchUpInside += delegate {
    Console.WriteLine ("button touched");
};

Der vorherige Code wird in der ViewDidLoad Methode des UIViewControllers verkabelt. Die aButton Variable verweist auf eine Schaltfläche, die Sie entweder im Xcode-Schnittstellen-Generator oder mit Code hinzufügen können.

Xamarin.iOS unterstützt auch den Zielaktionsstil, um Ihren Code mit einer Interaktion zu verbinden, die mit einem Steuerelement auftritt.

Weitere Informationen zum iOS-Zielaktionsmuster finden Sie im Abschnitt Target-Action der Kernanwendungskompetenzen für iOS in der iOS-Entwicklerbibliothek von Apple.

Weitere Informationen finden Sie unter Entwerfen von Benutzeroberflächen mit Xcode.

Ereignisse

Wenn Sie Ereignisse von UIControl abfangen möchten, haben Sie eine Reihe von Optionen: von der Verwendung der C#-Lambdas und Delegatfunktionen bis hin zur Verwendung der APIs auf niedriger Ebene Objective-C .

Der folgende Abschnitt zeigt, wie Sie das TouchDown-Ereignis auf einer Schaltfläche erfassen würden, je nachdem, wie viel Steuerelement Sie benötigen.

C#-Format

Verwenden der Delegatsyntax:

UIButton button = MakeTheButton ();
button.TouchDown += delegate {
    Console.WriteLine ("Touched");
};

Wenn Sie stattdessen Lambdas mögen:

button.TouchDown += () => {
   Console.WriteLine ("Touched");
};

Wenn Sie mehrere Schaltflächen verwenden möchten, verwenden Sie denselben Handler, um denselben Code zu verwenden:

void handler (object sender, EventArgs args)
{
   if (sender == button1)
      Console.WriteLine ("button1");
   else
      Console.WriteLine ("some other button");
}

button1.TouchDown += handler;
button2.TouchDown += handler;

Überwachen mehrerer Ereignisarten

Die C#-Ereignisse für UIControlEvent-Flags weisen eine 1:1-Zuordnung zu einzelnen Flags auf. Wenn Sie möchten, dass derselbe Code zwei oder mehr Ereignisse behandelt, verwenden Sie die UIControl.AddTarget -Methode:

button.AddTarget (handler, UIControlEvent.TouchDown | UIControlEvent.TouchCancel);

Verwenden der Lambdasyntax:

button.AddTarget ((sender, event)=> Console.WriteLine ("An event happened"), UIControlEvent.TouchDown | UIControlEvent.TouchCancel);

Wenn Sie Features auf Objective-Cniedriger Ebene von verwenden müssen, z. B. das Einbinden an ein bestimmtes Objekt instance und das Aufrufen eines bestimmten Selektors:

[Export ("MySelector")]
void MyObjectiveCHandler ()
{
    Console.WriteLine ("Hello!");
}

// In some other place:

button.AddTarget (this, new Selector ("MySelector"), UIControlEvent.TouchDown);

Beachten Sie, dass es sich bei der Implementierung der instance-Methode in einer geerbten Basisklasse um eine öffentliche Methode handeln muss.

Protokolle

Ein Protokoll ist ein Objective-C Sprachfeature, das eine Liste von Methodendeklarationen bereitstellt. Es dient einem ähnlichen Zweck wie eine Schnittstelle in C#. Der Standard Unterschied ist, dass ein Protokoll über optionale Methoden verfügen kann. Optionale Methoden werden nicht aufgerufen, wenn die Klasse, die ein Protokoll übernimmt, sie nicht implementiert. Außerdem kann eine einzelne Klasse in Objective-C mehrere Protokolle implementieren, genauso wie eine C#-Klasse mehrere Schnittstellen implementieren kann.

Apple verwendet Protokolle in iOS, um Verträge für zu übernehmende Klassen zu definieren, während die implementierende Klasse vom Aufrufer abstrahiert und somit wie eine C#-Schnittstelle funktioniert. Protokolle werden sowohl in Szenarien ohne Delegaten (z. B. im MKAnnotation folgenden Beispiel) als auch mit Delegaten (wie weiter unten in diesem Dokument im Abschnitt Delegaten dargestellt) verwendet.

Protokolle mit Xamarin.ios

Sehen wir uns ein Beispiel an, das ein Objective-C Protokoll von Xamarin.iOS verwendet. In diesem Beispiel verwenden wir das MKAnnotation Protokoll, das Teil des MapKit Frameworks ist. MKAnnotation ist ein Protokoll, mit dem jedes Objekt, das es übernimmt, Informationen zu einer Anmerkung bereitstellen kann, die einer Karte hinzugefügt werden kann. Ein implementierende MKAnnotation Objekt stellt beispielsweise die Position der Anmerkung und den ihr zugeordneten Titel bereit.

Auf diese Weise wird das MKAnnotation Protokoll verwendet, um relevante Daten bereitzustellen, die eine Anmerkung begleiten. Die tatsächliche Ansicht für die Anmerkung selbst wird aus den Daten im -Objekt erstellt, das das MKAnnotation Protokoll übernimmt. Beispielsweise stammt der Text für die Legende, die angezeigt wird, wenn der Benutzer auf die Anmerkung tippt (wie im Screenshot unten gezeigt), aus der Title Eigenschaft in der Klasse, die das Protokoll implementiert:

Beispieltext für die Legende, wenn der Benutzer auf die Anmerkung tippt

Wie im nächsten Abschnitt beschrieben, Protokolle deep dive, bindet Xamarin.iOS Protokolle an abstrakte Klassen. Für das MKAnnotation Protokoll wird die gebundene C#-Klasse benannt MKAnnotation , um den Namen des Protokolls nachzuahmen, und sie ist eine Unterklasse von NSObject, der Stammbasisklasse für CocoaTouch. Für das Protokoll müssen ein Getter und ein Setter für die Koordinate implementiert werden. Titel und Untertitel sind jedoch optional. Daher ist die -Eigenschaft in der MKAnnotationCoordinate -Klasse abstrakt, sodass sie implementiert werden muss und die Title Eigenschaften und Subtitleals virtual gekennzeichnet sind, sodass sie optional sind, wie unten gezeigt:

[Register ("MKAnnotation"), Model ]
public abstract class MKAnnotation : NSObject
{
    public abstract CLLocationCoordinate2D Coordinate
    {
        [Export ("coordinate")]
        get;
        [Export ("setCoordinate:")]
        set;
    }

    public virtual string Title
    {
        [Export ("title")]
        get
        {
            throw new ModelNotImplementedException ();
        }
    }

    public virtual string Subtitle
    {
        [Export ("subtitle")]
        get
        {
            throw new ModelNotImplementedException ();
        }
    }
...
}

Jede Klasse kann Anmerkungsdaten bereitstellen, indem sie einfach von MKAnnotationableiten, solange mindestens die Coordinate -Eigenschaft implementiert ist. Hier ist beispielsweise eine Beispielklasse, die die Koordinate im Konstruktor übernimmt und eine Zeichenfolge für den Titel zurückgibt:

/// <summary>
/// Annotation class that subclasses MKAnnotation abstract class
/// MKAnnotation is bound by Xamarin.iOS to the MKAnnotation protocol
/// </summary>
public class SampleMapAnnotation : MKAnnotation
{
    string title;

    public SampleMapAnnotation (CLLocationCoordinate2D coordinate)
    {
        Coordinate = coordinate;
        title = "Sample";
    }

    public override CLLocationCoordinate2D Coordinate { get; set; }

    public override string Title {
        get {
            return title;
        }
    }
}

Über das Protokoll, an das sie gebunden ist, kann jede Klasse, an die Unterklassen MKAnnotation gebunden ist, relevante Daten bereitstellen, die von der Karte verwendet werden, wenn sie die Ansicht der Anmerkung erstellt. Um einer Karte eine Anmerkung hinzuzufügen, rufen Sie einfach die AddAnnotation Methode eines MKMapView instance auf, wie im folgenden Code gezeigt:

//an arbitrary coordinate used for demonstration here
var sampleCoordinate =
    new CLLocationCoordinate2D (42.3467512, -71.0969456); // Boston

//create an annotation and add it to the map
map.AddAnnotation (new SampleMapAnnotation (sampleCoordinate));

Die Zuordnungsvariable ist hier eine instance von MKMapView, wobei es sich um die Klasse handelt, die die Karte selbst darstellt. Die MKMapView vom instance abgeleiteten SampleMapAnnotation Daten werden verwendetCoordinate, um die Anmerkungsansicht auf der Karte zu positionieren.

Das MKAnnotation Protokoll bietet einen bekannten Satz von Funktionen für alle Objekte, die es implementieren, ohne dass der Consumer (in diesem Fall die Karte) über Implementierungsdetails wissen muss. Dadurch wird das Hinzufügen einer Vielzahl möglicher Anmerkungen zu einer Karte optimiert.

Ausführlicher Ausführlicher Einblick in Protokolle

Da C#-Schnittstellen keine optionalen Methoden unterstützen, ordnet Xamarin.iOS Protokolle abstrakten Klassen zu. Daher erfolgt die Übernahme eines Protokolls in Objective-C in Xamarin.iOS, indem von der abstrakten Klasse abgeleitet wird, die an das Protokoll gebunden ist, und die erforderlichen Methoden implementiert werden. Diese Methoden werden als abstrakte Methoden in der -Klasse verfügbar gemacht. Optionale Methoden aus dem Protokoll werden an virtuelle Methoden der C#-Klasse gebunden.

Hier sehen Sie beispielsweise einen Teil des Protokolls, der UITableViewDataSource in Xamarin.iOS gebunden ist:

public abstract class UITableViewDataSource : NSObject
{
    [Export ("tableView:cellForRowAtIndexPath:")]
    public abstract UITableViewCell GetCell (UITableView tableView, NSIndexPath indexPath);
    [Export ("numberOfSectionsInTableView:")]
    public virtual int NumberOfSections (UITableView tableView){...}
...
}

Beachten Sie, dass die Klasse abstrakt ist. Xamarin.iOS macht die Klasse abstrakt, um optionale/erforderliche Methoden in Protokollen zu unterstützen. Im Gegensatz zu Objective-C Protokollen (oder C#-Schnittstellen) unterstützen C#-Klassen jedoch keine mehrfache Vererbung. Dies wirkt sich auf den Entwurf von C#-Code aus, der Protokolle verwendet und in der Regel zu geschachtelten Klassen führt. Weitere Informationen zu diesem Problem finden Sie weiter unten in diesem Dokument im Abschnitt Delegaten.

GetCell(…) ist eine abstrakte Methode, die an den Objective-CSelektor gebunden ist. tableView:cellForRowAtIndexPath:Dies ist eine erforderliche Methode des UITableViewDataSource Protokolls. Selektor ist der Begriff für den Objective-C Methodennamen. Um die Methode nach Bedarf zu erzwingen, deklariert Xamarin.iOS sie als abstrakt. Die andere Methode ist NumberOfSections(…)an numberOfSectionsInTableview:gebunden. Diese Methode ist im Protokoll optional. Daher deklariert Xamarin.iOS sie als virtuell, sodass sie optional in C# überschrieben werden kann.

Xamarin.iOS übernimmt die gesamte iOS-Bindung für Sie. Wenn Sie jedoch jemals ein Protokoll manuell Objective-C binden müssen, können Sie dies tun, indem Sie eine Klasse mit ExportAttributedekorieren. Dies ist die gleiche Methode, die von Xamarin.iOS selbst verwendet wird.

Weitere Informationen zum Binden Objective-C von Typen in Xamarin.iOS finden Sie im Artikel BindungstypenObjective-C.

Mit Protokollen sind wir jedoch noch nicht durch. Sie werden auch in iOS als Basis für Objective-C Delegaten verwendet, was das Thema des nächsten Abschnitts ist.

Delegaten

iOS verwendet Objective-C Delegaten, um das Delegierungsmuster zu implementieren, in dem ein Objekt die Arbeit an ein anderes übergibt. Das Objekt, das die Arbeit ausführt, ist der Delegat des ersten Objekts. Ein Objekt weist seinen Delegat an, seine Arbeit zu erledigen, indem es nachrichten sendet, nachdem bestimmte Dinge geschehen sind. Das Senden einer Nachricht wie diese in Objective-C entspricht funktional dem Aufrufen einer Methode in C#. Ein Delegat implementiert Methoden als Reaktion auf diese Aufrufe und stellt daher Funktionen für die Anwendung bereit.

Mit Delegaten können Sie das Verhalten von Klassen erweitern, ohne Unterklassen erstellen zu müssen. Anwendungen in iOS verwenden häufig Delegaten, wenn eine Klasse nach einer wichtigen Aktion an eine andere zurückruft. Beispielsweise ruft die MKMapView Klasse an ihren Delegaten zurück, wenn der Benutzer auf eine Anmerkung auf einer Karte tippt, sodass der Autor der Delegatenklasse innerhalb der Anwendung reagieren kann. Sie können ein Beispiel für diese Art der Verwendung von Delegaten weiter unten in diesem Artikel unter Beispiel für die Verwendung eines Delegaten mit Xamarin.iOS durcharbeiten.

An diesem Punkt fragen Sie sich möglicherweise, wie eine Klasse bestimmt, welche Methoden für ihren Delegaten aufgerufen werden sollen. Dies ist ein weiterer Ort, an dem Sie Protokolle verwenden. In der Regel stammen die für einen Delegaten verfügbaren Methoden aus den von ihnen übernommenen Protokollen.

Verwendung von Protokollen mit Delegaten

Wir haben bereits erfahren, wie Protokolle verwendet werden, um das Hinzufügen von Anmerkungen zu einer Karte zu unterstützen. Protokolle werden auch verwendet, um einen bekannten Satz von Methoden für Klassen bereitzustellen, die aufgerufen werden können, nachdem bestimmte Ereignisse auftreten, z. B. nachdem der Benutzer auf eine Anmerkung auf einer Karte tippt oder eine Zelle in einer Tabelle auswählt. Die Klassen, die diese Methoden implementieren, werden als Delegaten der Klassen bezeichnet, die sie aufrufen.

Klassen, die die Delegierung unterstützen, tun dies, indem sie eine Delegate-Eigenschaft verfügbar machen, der eine Klasse zugewiesen wird, die den Delegaten implementiert. Die Methoden, die Sie für den Delegaten implementieren, hängen vom Protokoll ab, das der jeweilige Delegat verwendet. Für die UITableView -Methode implementieren Sie das UITableViewDelegate Protokoll, für die UIAccelerometer -Methode implementieren UIAccelerometerDelegateSie usw. für alle anderen Klassen in iOS, für die Sie einen Delegaten verfügbar machen möchten.

Die MKMapView Klasse, die wir in unserem vorherigen Beispiel gesehen haben, verfügt auch über eine Eigenschaft namens Delegate, die aufgerufen wird, nachdem verschiedene Ereignisse auftreten. Der Delegat für MKMapView ist vom Typ MKMapViewDelegate. Sie verwenden dies kurz in einem Beispiel, um auf die Anmerkung zu reagieren, nachdem sie ausgewählt wurde, aber lassen Sie uns zunächst den Unterschied zwischen starken und schwachen Delegaten besprechen.

Starke Stellvertretungen im Vergleich zu schwachen Delegaten

Die Delegaten, die wir uns bisher angesehen haben, sind starke Delegaten, was bedeutet, dass sie stark typisiert sind. Die Xamarin.iOS-Bindungen enthalten eine stark typisierte Klasse für jedes Delegatprotokoll in iOS. iOS hat jedoch auch das Konzept eines schwachen Delegaten. Anstatt eine Klasse zu unterklassigen, die an das Objective-C Protokoll für einen bestimmten Delegaten gebunden ist, können Sie mit iOS auch auswählen, die Protokollmethoden selbst in einer beliebigen Klasse zu binden, die von NSObject abgeleitet ist, indem Sie Ihre Methoden mit dem ExportAttribute versehen und dann die entsprechenden Selektoren bereitstellen. Bei diesem Ansatz weisen Sie der WeakDelegate-Eigenschaft anstelle der Delegate-Eigenschaft eine instance Ihrer Klasse zu. Ein schwacher Delegat bietet Ihnen die Flexibilität, Ihre Delegatklasse in einer anderen Vererbungshierarchie nach unten zu bringen. Sehen wir uns ein Xamarin.iOS-Beispiel an, das sowohl starke als auch schwache Delegaten verwendet.

Beispiel für die Verwendung eines Delegaten mit Xamarin.iOS

Um Code als Reaktion darauf auszuführen, dass der Benutzer in unserem Beispiel auf die Anmerkung tippt, können wir eine Unterklasse MKMapViewDelegate und eine instance der -Eigenschaft des MKMapViewzuweisenDelegate. Das MKMapViewDelegate Protokoll enthält nur optionale Methoden. Daher sind alle Methoden virtuell, die an dieses Protokoll in der Xamarin.iOS-Klasse MKMapViewDelegate gebunden sind. Wenn der Benutzer eine Anmerkung auswählt, sendet der MKMapView instance die Nachricht an seinen mapView:didSelectAnnotationView: Delegaten. Um dies in Xamarin.iOS zu behandeln, müssen wir die DidSelectAnnotationView (MKMapView mapView, MKAnnotationView annotationView) -Methode in der MKMapViewDelegate-Unterklasse wie folgt überschreiben:

public class SampleMapDelegate : MKMapViewDelegate
{
    public override void DidSelectAnnotationView (
        MKMapView mapView, MKAnnotationView annotationView)
    {
        var sampleAnnotation =
            annotationView.Annotation as SampleMapAnnotation;

        if (sampleAnnotation != null) {

            //demo accessing the coordinate of the selected annotation to
            //zoom in on it
            mapView.Region = MKCoordinateRegion.FromDistance(
                sampleAnnotation.Coordinate, 500, 500);

            //demo accessing the title of the selected annotation
            Console.WriteLine ("{0} was tapped", sampleAnnotation.Title);
        }
    }
}

Die oben gezeigte SampleMapDelegate-Klasse wird als geschachtelte Klasse im Controller implementiert, der die MKMapView instance enthält. In Objective-Csehen Sie häufig, dass der Controller mehrere Protokolle direkt innerhalb der -Klasse übernimmt. Da Protokolle jedoch an Klassen in Xamarin.iOS gebunden sind, werden die Klassen, die stark typisierte Delegaten implementieren, in der Regel als geschachtelte Klassen eingeschlossen.

Nachdem die Delegatklassenimplementierung eingerichtet wurde, müssen Sie nur eine instance des Delegaten im Controller instanziieren und wie hier gezeigt der -Eigenschaft des MKMapView-Objekts Delegate zuweisen:

public partial class Protocols_Delegates_EventsViewController : UIViewController
{
    SampleMapDelegate _mapDelegate;
    ...
    public override void ViewDidLoad ()
    {
        base.ViewDidLoad ();

        //set the map's delegate
        _mapDelegate = new SampleMapDelegate ();
        map.Delegate = _mapDelegate;
        ...
    }
    class SampleMapDelegate : MKMapViewDelegate
    {
        ...
    }
}

Um einen schwachen Delegaten zu verwenden, um dasselbe zu erreichen, müssen Sie die -Methode selbst in jeder Klasse binden, die von NSObject abgeleitet wird, und sie der WeakDelegate -Eigenschaft von MKMapViewzuweisen. Da die UIViewController -Klasse letztendlich von NSObject abgeleitet wird (wie jede Objective-C Klasse in CocoaTouch), können wir einfach eine Methode implementieren, mapView:didSelectAnnotationView: die direkt im Controller gebunden ist, und den Controller MKMapViewWeakDelegatedem zuweisen, wodurch die Notwendigkeit der zusätzlichen geschachtelten Klasse vermieden wird. Der folgende Code veranschaulicht diesen Ansatz:

public partial class Protocols_Delegates_EventsViewController : UIViewController
{
    ...
    public override void ViewDidLoad ()
    {
        base.ViewDidLoad ();
        //assign the controller directly to the weak delegate
        map.WeakDelegate = this;
    }
    //bind to the Objective-C selector mapView:didSelectAnnotationView:
    [Export("mapView:didSelectAnnotationView:")]
    public void DidSelectAnnotationView (MKMapView mapView,
        MKAnnotationView annotationView)
    {
        ...
    }
}

Beim Ausführen dieses Codes verhält sich die Anwendung genau wie bei der Ausführung der stark typisierten Delegatversion. Der Vorteil dieses Codes besteht darin, dass der schwache Delegat nicht die Erstellung der zusätzlichen Klasse erfordert, die erstellt wurde, als wir den stark typisierten Delegaten verwendet haben. Dies geht jedoch zu Lasten der Typsicherheit. Wenn Sie in der Auswahl, die an ExportAttributeübergeben wurde, einen Fehler machen würden, würden Sie dies erst zur Laufzeit herausfinden.

Ereignisse und Delegaten

Delegaten werden für Rückrufe in iOS ähnlich wie in .NET verwendet. Damit iOS-APIs und die Verwendung Objective-C von Delegaten eher wie .NET aussehen, macht Xamarin.iOS .NET-Ereignisse an vielen Stellen verfügbar, an denen Delegaten in iOS verwendet werden.

Beispielsweise konnte die frühere Implementierung, bei der auf MKMapViewDelegate eine ausgewählte Anmerkung geantwortet hat, auch in Xamarin.iOS mithilfe eines .NET-Ereignisses implementiert werden. In diesem Fall wird das Ereignis in MKMapView definiert und als bezeichnet DidSelectAnnotationView. Sie hätte eine EventArgs Unterklasse vom Typ MKMapViewAnnotationEventsArgs. Die View -Eigenschaft von MKMapViewAnnotationEventsArgs gibt Ihnen einen Verweis auf die Anmerkungsansicht, von der aus Sie mit der gleichen Implementierung fortfahren können, die Sie zuvor hatten, wie hier dargestellt:

map.DidSelectAnnotationView += (s,e) => {
    var sampleAnnotation = e.View.Annotation as SampleMapAnnotation;
    if (sampleAnnotation != null) {
        //demo accessing the coordinate of the selected annotation to
        //zoom in on it
        mapView.Region = MKCoordinateRegion.FromDistance (
            sampleAnnotation.Coordinate, 500, 500);

        //demo accessing the title of the selected annotation
        Console.WriteLine ("{0} was tapped", sampleAnnotation.Title);
    }
};

Zusammenfassung

In diesem Artikel wurde die Verwendung von Ereignissen, Protokollen und Delegaten in Xamarin.iOS beschrieben. Wir haben gesehen, wie Xamarin.iOS normale Ereignisse im .NET-Stil für Steuerelemente verfügbar macht. Als Nächstes haben wir mehr über Objective-C Protokolle erfahren, einschließlich ihrer Unterschiede zu C#-Schnittstellen und deren Verwendung durch Xamarin.iOS. Schließlich haben wir Delegaten aus Xamarin.iOS-Perspektive untersucht Objective-C . Wir haben erfahren, wie Xamarin.iOS stark und schwach typisierte Delegaten unterstützt und wie .NET-Ereignisse an Delegierenmethoden gebunden werden.