C# MKMapView.DequeueReusableAnnotation方法代码示例

            public override MKAnnotationView GetViewForAnnotation (MKMapView mapView, NSObject annotation)
            {
                MKAnnotationView anView;

                if (annotation is MKUserLocation)
                    return null; 

                if (annotation is MonkeyAnnotation) {

                    // show monkey annotation
                    anView = mapView.DequeueReusableAnnotation (mId);

                    if (anView == null)
                        anView = new MKAnnotationView (annotation, mId);
                
                    anView.Image = UIImage.FromFile ("monkey.png");
                    anView.CanShowCallout = true;
                    anView.Draggable = true;
                    anView.RightCalloutAccessoryView = UIButton.FromType (UIButtonType.DetailDisclosure);

                } else {

                    // show pin annotation
                    anView = (MKPinAnnotationView)mapView.DequeueReusableAnnotation (pId);

                    if (anView == null)
                        anView = new MKPinAnnotationView (annotation, pId);
                
                    ((MKPinAnnotationView)anView).PinColor = MKPinAnnotationColor.Green;
                    anView.CanShowCallout = true;
                }

                return anView;
            }

		MKAnnotationView GetViewForAnnotation(MKMapView mapView, IMKAnnotation annotation)
		{
			MKAnnotationView annotationView = null;

			if (annotation is MKUserLocation)
				return null;

			var anno = annotation as MKPointAnnotation;
			var customPin = GetCustomPin(anno);
			if (customPin == null)
			{
				throw new Exception("Custom pin not found");
			}

			annotationView = mapView.DequeueReusableAnnotation(customPin.Id);
			if (annotationView == null)
			{
				annotationView = new CustomMKAnnotationView(annotation, customPin.Id);
				annotationView.Image = UIImage.FromFile("pin.png");
				annotationView.CalloutOffset = new CGPoint(0, 0);
				annotationView.LeftCalloutAccessoryView = new UIImageView(UIImage.FromFile("monkey.png"));
				annotationView.RightCalloutAccessoryView = UIButton.FromType(UIButtonType.DetailDisclosure);
				((CustomMKAnnotationView)annotationView).Id = customPin.Id;
				((CustomMKAnnotationView)annotationView).Url = customPin.Url;
			}
			annotationView.CanShowCallout = true;

			return annotationView;
		}

            public override MKAnnotationView GetViewForAnnotation(MKMapView mapView, NSObject annotation)
            {
                var pin = (MKAnnotationView)mapView.DequeueReusableAnnotation("zombie");
                if (pin == null)
                {
                    pin = new MKAnnotationView(annotation, "zombie");
                    pin.Image = UIImage.FromFile("zombie.png");
                    pin.CenterOffset = new PointF(0, -30);
                }
                else
                {
                    pin.Annotation = annotation;
                }

                var zombieAnnotation = (ZombieAnnotation) annotation;
                if (zombieAnnotation.Zombie.IsMale)
                {
                    //pin.PinColor = MKPinAnnotationColor.Purple;
                }
                else
                {
                    //pin.PinColor = MKPinAnnotationColor.Red;
                }

                return pin;
            }

	  public override MKAnnotationView GetViewForAnnotation (MKMapView mapView, IMKAnnotation annotation)
		{
      var extendedAnnotation = annotation as ExtendedMapAnnotation;

	    if (extendedAnnotation == null) return null;

	    // try and dequeue the annotation view
	    var annotationView = mapView.DequeueReusableAnnotation(AnnotationIdentifier);

	    // if we couldn't dequeue one, create a new one
	    if (annotationView == null)
	    {
	      annotationView = new MKAnnotationView(extendedAnnotation, AnnotationIdentifier);
	    }
	    else // if we did dequeue one for reuse, assign the annotation to it
	      annotationView.Annotation = extendedAnnotation;

	    // configure our annotation view properties
	    annotationView.CanShowCallout = false;
	    annotationView.Selected = true;

	    if (!string.IsNullOrEmpty(extendedAnnotation.PinIcon))
	    {
	      annotationView.Image = UIImage.FromFile(extendedAnnotation.PinIcon);
	    }

	    return annotationView;
		}

			UIButton detailButton; // need class-level ref to avoid GC

			/// <summary>
			/// This is very much like the GetCell method on the table delegate
			/// </summary>
			public override MKAnnotationView GetViewForAnnotation (MKMapView mapView, NSObject annotation)
			{
				// try and dequeue the annotation view
				MKAnnotationView annotationView = mapView.DequeueReusableAnnotation(annotationIdentifier);
				
				// if we couldn't dequeue one, create a new one
				if (annotationView == null)
					annotationView = new MKPinAnnotationView(annotation, annotationIdentifier);
				else // if we did dequeue one for reuse, assign the annotation to it
					annotationView.Annotation = annotation;
		     
				// configure our annotation view properties
				annotationView.CanShowCallout = true;
				(annotationView as MKPinAnnotationView).AnimatesDrop = true;
				(annotationView as MKPinAnnotationView).PinColor = MKPinAnnotationColor.Green;
				annotationView.Selected = true;
				
				// you can add an accessory view, in this case, we'll add a button on the right, and an image on the left
				detailButton = UIButton.FromType(UIButtonType.DetailDisclosure);
				detailButton.TouchUpInside += (s, e) => { 
					var c = (annotation as MKAnnotation).Coordinate;
					new UIAlertView("Annotation Clicked", "You clicked on " +
					c.Latitude.ToString() + ", " +
					c.Longitude.ToString() , null, "OK", null).Show(); 
				};
				annotationView.RightCalloutAccessoryView = detailButton;
				annotationView.LeftCalloutAccessoryView = new UIImageView(UIImage.FromBundle("Images/Icon/29_icon.png"));
				//annotationView.Image = UIImage.FromBundle("Images/Apress-29x29.png");
				
				return annotationView;
			}

		public override MKAnnotationView GetViewForAnnotation (MKMapView mapView, IMKAnnotation annotation)
		{
			MKAnnotationView annotationView = null;
			MKPointAnnotation anno = null;

			if (annotation is MKUserLocation) {
				return null; 
			} else {
				anno = annotation as MKPointAnnotation;
			}

			string identifier = GetIdentifier (anno);

			if (identifier == "")
				throw new Exception ("No Identifier found for pin");

			annotationView = mapView.DequeueReusableAnnotation (identifier);

			if (annotationView == null)
				annotationView = new CustomMKPinAnnotationView (annotation, identifier);

			//This removes the bubble that pops up with the title and everything
			((CustomMKPinAnnotationView)annotationView).FormsIdentifier = identifier;
			annotationView.CanShowCallout = false;

			return annotationView;
		}

		public override MKAnnotationView GetViewForAnnotation(MKMapView mapView, NSObject annotation)
		{
			var pet = ((CustomAnnotation)annotation).Model;
			var petAnnotationType = GetPetAnnotationType (pet);

			var pin = (MapAnnotationView)mapView.DequeueReusableAnnotation(petAnnotationType);
			string pinImage = petAnnotationType + ".png";
			if (pin == null)
			{
				pin = new MapAnnotationView(annotation, petAnnotationType);
				pin.Image = UIImage.FromBundle(pinImage);
				pin.CenterOffset = new PointF (0, -15);
			}
			else
			{
				pin.Annotation = annotation;
			}

			pin.Draggable = _pinIsDraggable;
			pin.CanShowCallout = _canShowCallout;

			if (_canShowCallout) 
			{
				Task.Run( async () => pin.LeftCalloutAccessoryView = await GetImage(pet));
				pin.RightCalloutAccessoryView = GetDetailButton (pet);
			}
			return pin;
		}

        public override MKAnnotationView GetViewForAnnotation(MKMapView mapView, IMKAnnotation annotation)
        {
            // try and dequeue the annotation view
            MKAnnotationView annotationView = mapView.DequeueReusableAnnotation(annotationIdentifier);
            // if we couldn't dequeue one, create a new one
            if (annotationView == null)
                annotationView = new MKPinAnnotationView(annotation, annotationIdentifier);
            else // if we did dequeue one for reuse, assign the annotation to it
                annotationView.Annotation = annotation;

            // configure our annotation view properties
            annotationView.CanShowCallout = true;
            (annotationView as MKPinAnnotationView).AnimatesDrop = true;
            (annotationView as MKPinAnnotationView).PinColor = MKPinAnnotationColor.Red;
            annotationView.Selected = true;

            Assembly ass = this.GetType ().Assembly;

            var annotationImage =
                UIImage.FromBundle((annotation as BasicPinAnnotation).ImageAdress);

            annotationView.LeftCalloutAccessoryView = new UIImageView(
                ResizeImage.MaxResizeImage(annotationImage,(float)40,(float)20));
            return annotationView;
        }

        public override void ViewDidLoad()
        {
            mapView = new MKMapView();
            RectangleF frame = new RectangleF(0,0,320,360);

            mapView.Frame = frame;
            mapView.ShowsUserLocation = true;

            var myAnnotation = new MyAnnotation(new CLLocationCoordinate2D(0,0), "Home", "is where the heart is");
            mapView.AddAnnotationObject(myAnnotation);

            UIButton detailButton = UIButton.FromType(UIButtonType.DetailDisclosure);

            mapView.GetViewForAnnotation = delegate(MKMapView mapViewForAnnotation, NSObject annotation) {

                var anv = mapView.DequeueReusableAnnotation("thislocation");
                if (anv == null)
                {
                    anv = new MKPinAnnotationView(annotation, "thislocation");

                    detailButton.TouchUpInside += (s, e) => {
                        Console.WriteLine ("Tapped");
                    };
                    anv.RightCalloutAccessoryView = detailButton;
                }
                else
                {
                    anv.Annotation = annotation;
                }
                anv.CanShowCallout = true;
                return anv;
            };

            View.AddSubview(mapView);
        }

        MKAnnotationView GetViewForAnnotation(MKMapView mapView, NSObject annotation)
        {
            //Stop annotations
            if (annotation is StopAnnotation) {
                StopAnnotation stopAnn = annotation as StopAnnotation;

                //dequeue or create
                MKPinAnnotationView pin = mapView.DequeueReusableAnnotation(STOP_PIN_ID) as MKPinAnnotationView;
                if (pin==null){
                    pin = new MKPinAnnotationView(stopAnn, STOP_PIN_ID);
                    pin.CanShowCallout=true;
                }

                return pin;
            }//end is stop annotations
            return null;
        }

            public override MKAnnotationView GetViewForAnnotation(MKMapView mapView, NSObject annotation)
            {
                var pin = (MKAnnotationView)mapView.DequeueReusableAnnotation("zombie");
                if (pin == null)
                {
                    pin = new MKAnnotationView(annotation, "zombie");
                    pin.Image = UIImage.FromFile("zombie.png");
                    pin.CenterOffset = new PointF(0, -30);
                }
                else
                {
                    pin.Annotation = annotation;
                }

                pin.Draggable = true;

                return pin;
            }

        public override MKAnnotationView GetViewForAnnotation(MKMapView mapView, IMKAnnotation annotation)
        {
            MKAnnotationView annotationView = null;

            if (annotation is MKUserLocation)
                return null;

            if (annotation is ConferenceAnnotation) {

                // show conference annotation
                annotationView = mapView.DequeueReusableAnnotation (annotationId);

                if (annotationView == null)
                    annotationView = new MKAnnotationView (annotation, annotationId);

                annotationView.Image = UIImage.FromFile ("conference.png");
                annotationView.CanShowCallout = true;
            }

            return annotationView;
        }

		public override MKAnnotationView GetViewForAnnotation (MKMapView mapView, NSObject annotation)
#endif
		{
			MKPinAnnotationView mapPin = null;

			// https://bugzilla.xamarin.com/show_bug.cgi?id=26416
			var userLocationAnnotation = Runtime.GetNSObject(annotation.Handle) as MKUserLocation;
			if (userLocationAnnotation != null)
				return null;

			const string defaultPinId = "defaultPin";
			mapPin = (MKPinAnnotationView)mapView.DequeueReusableAnnotation(defaultPinId);
			if (mapPin == null)
			{
				mapPin = new MKPinAnnotationView(annotation, defaultPinId);
				mapPin.CanShowCallout = true;
			}

			mapPin.Annotation = annotation;
			AttachGestureToPin(mapPin, annotation);

			return mapPin;
		}

        public override MKAnnotationView GetViewForAnnotation(MKMapView mapView, NSObject annotation)
        {
            // if it's the user location just return 
            if (annotation is MKUserLocation)
                return null;

            MKAnnotationView anView;

            // show pin annotation
            anView = (MKPinAnnotationView)mapView.DequeueReusableAnnotation(pId);

            // if we didn't deque reuse
            if (anView == null)
                anView = new MKPinAnnotationView(annotation, pId);

            // set the accessory and pin
            ((MKPinAnnotationView)anView).PinColor = MKPinAnnotationColor.Red;
            anView.RightCalloutAccessoryView = UIButton.FromType(UIButtonType.DetailDisclosure);
            anView.CanShowCallout = true;

            // return the view
            return anView;
        }

        public override MKAnnotationView GetViewForAnnotation(MKMapView mapView, IMKAnnotation annotation)
        {
            if (Runtime.GetNSObject(annotation.Handle) is MKUserLocation)
            {
                return null;
            }

            var unifiedAnnotation = annotation as IUnifiedAnnotation;
            if (unifiedAnnotation == null)
            {
                return null;
            }

            var pinAnnotation = annotation as UnifiedPointAnnotation;
            if (pinAnnotation != null)
            {
                var data = pinAnnotation.Data;
                MKAnnotationView annotationView = null;

                if (data.Image == null)
                {
                    // Handle standard pins
                    var pinAnnotationView = (MKPinAnnotationView)mapView.DequeueReusableAnnotation(MKPinAnnotationIdentifier) ??
                        new MKPinAnnotationView(annotation, MKPinAnnotationIdentifier);

                    pinAnnotationView.PinTintColor = data.Color.ToUIColor();
                    annotationView = pinAnnotationView;
                }
                else {
                    // Handle pins with an image as pin icon
                    annotationView = mapView.DequeueReusableAnnotation(MKAnnotationIdentifier) ??
                        new MKAnnotationView(annotation, MKAnnotationIdentifier);

                    UpdateImage(annotationView, pinAnnotation.Data);
                }

                // Only show the callout if there is something to display
                annotationView.CanShowCallout = string.IsNullOrWhiteSpace(pinAnnotation.Data.Title) == false;

                if (annotationView.CanShowCallout
                    && _renderer.Element.PinCalloutTappedCommand != null
                    && pinAnnotation.Data != null)
                {
                    annotationView.RightCalloutAccessoryView = UIButton.FromType(UIButtonType.DetailDisclosure);
                }

                annotationView.Annotation = annotation;
                return annotationView;
            }

            return null;
        }