C# TypedEventHandler类代码示例

        /// <summary>Call this method in Loaded event as the event will be automatically 
        /// deregistered when the FrameworkElement has been unloaded. </summary>
        public static void RegisterBackKey(Page page)
        {
            var callback = new TypedEventHandler<CoreDispatcher, AcceleratorKeyEventArgs>(
                delegate(CoreDispatcher sender, AcceleratorKeyEventArgs args)
                {
                    if (!args.Handled && args.VirtualKey == VirtualKey.Back &&
                        (args.EventType == CoreAcceleratorKeyEventType.KeyDown || 
                            args.EventType == CoreAcceleratorKeyEventType.SystemKeyDown))
                    {
                        var element = FocusManager.GetFocusedElement();
                        if (element is FrameworkElement && PopupHelper.IsInPopup((FrameworkElement)element))
                            return;

                        if (element is TextBox || element is PasswordBox || element is WebView)
                            return; 

                        if (page.Frame.CanGoBack)
                        {
                            args.Handled = true;
                            page.Frame.GoBack();
                        }
                    }
                });

            page.Dispatcher.AcceleratorKeyActivated += callback;

            SingleEvent.RegisterEvent(page,
                (p, h) => p.Unloaded += h,
                (p, h) => p.Unloaded -= h,
                (o, a) => { page.Dispatcher.AcceleratorKeyActivated -= callback; });
        }

		public MainPage()
		{
			this.InitializeComponent();
			NavigationCacheMode = Windows.UI.Xaml.Navigation.NavigationCacheMode.Required;

			AppCallbacks appCallbacks = AppCallbacks.Instance;
			// Setup scripting bridge
			_bridge = new WinRTBridge.WinRTBridge();
			appCallbacks.SetBridge(_bridge);

			appCallbacks.RenderingStarted += () => { RemoveSplashScreen(); };

#if !UNITY_WP_8_1
			appCallbacks.SetKeyboardTriggerControl(this);
#endif
			appCallbacks.SetSwapChainPanel(GetSwapChainPanel());
			appCallbacks.SetCoreWindowEvents(Window.Current.CoreWindow);
			appCallbacks.InitializeD3DXAML();

			splash = ((App)App.Current).splashScreen;
			GetSplashBackgroundColor();
			OnResize();
			onResizeHandler = new WindowSizeChangedEventHandler((o, e) => OnResize());
			Window.Current.SizeChanged += onResizeHandler;

#if UNITY_WP_8_1
			onRotationChangedHandler = new TypedEventHandler<DisplayInformation, object>((di, o) => { OnRotate(di); });
			ExtendedSplashImage.RenderTransformOrigin = new Point(0.5, 0.5);
			var displayInfo = DisplayInformation.GetForCurrentView();
			displayInfo.OrientationChanged += onRotationChangedHandler;
			OnRotate(displayInfo);

			SetupLocationService();
#endif
		}

 public GeofencingService(TypedEventHandler<GeofenceMonitor, object> stateChange, TypedEventHandler<GeofenceMonitor, object> statusChanged, CoreDispatcher dispatcher)
 {
     Messenger.Default.Register<SetupGeofencingMessage>(this, async message => await SetupGeofencesAsync(message));
     this.stateChange = stateChange;
     this.statusChanged = statusChanged;
     this.dispatcher = dispatcher;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="DbControllerQueryAttributeChecker"/> class.
        /// </summary>
        /// <param name="missingAttributeHandler">The event handler for types with missing attributes.
        /// Cannot be null.</param>
        /// <exception cref="ArgumentNullException"><paramref name="missingAttributeHandler"/> is null.</exception>
        /// <param name="typesToIgnore">Optional array of types to ignore. If a type is in this collection, it will
        /// never be invoked by the <paramref name="missingAttributeHandler"/>.</param>
        public DbControllerQueryAttributeChecker(
            TypedEventHandler<DbControllerQueryAttributeChecker, EventArgs<Type>> missingAttributeHandler,
            params Type[] typesToIgnore)
        {
            if (missingAttributeHandler == null)
                throw new ArgumentNullException("missingAttributeHandler");

            _missingAttributeHandler = missingAttributeHandler;
            _typesToIgnore = typesToIgnore;

            var filter = new TypeFilterCreator
            {
                IsClass = true,
                IsAbstract = false,
                IsInterface = false,
                RequireAttributes = false,
                Interfaces = new Type[] { typeof(IDbQuery) },
                MatchAllInterfaces = true,
                RequireInterfaces = false,
                RequireConstructor = false,
                IsEnum = false
            };

            new TypeFactory(filter.GetFilter(), LoadTypeHandler);
        }

        /// <summary>
        /// Constructor initializes necessary variables and reads in saved constraints from text file.
        /// </summary>
        public MainWindow()
        {
            InitializeComponent();

            string fileName = @"Stored_Constraints.txt";
            Debug.WriteLine(DateTime.Now.ToString());
            filePath = System.IO.Path.Combine(Directory.GetCurrentDirectory(), fileName);
            dateTimesForConstraints = new Dictionary<string, string>();

            backgroundListener = new SpeechRecognizer();
            constraints = new List<string>();
            BLResultGenerated = new TypedEventHandler<SpeechContinuousRecognitionSession, SpeechContinuousRecognitionResultGeneratedEventArgs>(blResultGenerated);
            backgroundListener.ContinuousRecognitionSession.ResultGenerated += BLResultGenerated;

            constraints = readInConstraintsFromFile();
            currentlyStoredConstraints = constraints.ToList();
            updateConstraintsWindow(constraints);

            this.Closing += OnAppClosing;

            var waitOn = loadOnStart();
            while (waitOn.Status != AsyncStatus.Completed) { }
            var ff = backgroundListener.ContinuousRecognitionSession.StartAsync();

            notifyIcon = new NotifyIcon();
            notifyIcon.Icon = new System.Drawing.Icon("trayImage.ico");
            notifyIcon.Visible = true;
            notifyIcon.DoubleClick +=
                delegate (object sender, EventArgs args)
                {
                    this.Show();
                    this.WindowState = WindowState.Normal;
                };
        }

		private static void OnProviderChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
		{
			var searchBox = (SearchBox)d;
			CleanSuggestionRequestedEventHandlers(searchBox);
			var eventHandler = new TypedEventHandler<SearchBox, SearchBoxSuggestionsRequestedEventArgs>(searchBox_SuggestionsRequested);
			_suggestionRequestedEventHandlers.Add(searchBox, eventHandler);
			searchBox.SuggestionsRequested += eventHandler;
		}

 /// <summary>Call this method in Loaded event as the event will be automatically 
 /// deregistered when the FrameworkElement has been unloaded. </summary>
 /// <param name="page">The page. </param>
 /// <param name="handler">The event handler. </param>
 public static void RegisterAcceleratorKeyActivated(FrameworkElement page, TypedEventHandler<CoreDispatcher, AcceleratorKeyEventArgs> handler)
 {
     page.Dispatcher.AcceleratorKeyActivated += handler;
     SingleEvent.RegisterEvent(page, (p, h) => p.Unloaded += h, (p, h) => p.Unloaded -= h, (o, a) =>
     {
         page.Dispatcher.AcceleratorKeyActivated -= handler;
     });
 }

        /*public static class myGlobals
        {
            public static int procNum { get; private set; }

            public static void newProc(int i)
            {
                procNum = i;
            }
        }*/
      
        public MainPage()
        {
            this.InitializeComponent();
            InitSettings();
            m_mediaPropertyChanged = new TypedEventHandler<SystemMediaTransportControls, SystemMediaTransportControlsPropertyChangedEventArgs>(SystemMediaControls_PropertyChanged);
            EnumerateWebcamsAsync();
            startDevice();
            showCam();
        }

 private void RegisterShaken()
 {
     shakenHandler = new TypedEventHandler<Accelerometer, AccelerometerShakenEventArgs>(OnShaken);
     accelerometer = Accelerometer.GetDefault();
     if (accelerometer != null)
     {
         accelerometer.Shaken += shakenHandler;
     }
 }

 public static void SendToastWithActionNotification(string toastXML, TypedEventHandler<ToastNotification, System.Object> toastActived)
 {
     Windows.Data.Xml.Dom.XmlDocument badgeDOM = new Windows.Data.Xml.Dom.XmlDocument();
     badgeDOM.LoadXml(toastXML);
     ToastNotification toast = new ToastNotification(badgeDOM);
     if (toastActived != null)
     {
         toast.Activated += toastActived;
     }
     ToastNotificationManager.CreateToastNotifier().Show(toast);
 }

        public static void Show(
            string title, 
            string message = null,
            string furtherMessage = null,
            TypedEventHandler<ToastNotification, object> onActivate = null,
            TypedEventHandler<ToastNotification, ToastDismissedEventArgs> onDismiss = null)
        {
            // Get a toast XML template
            var toastXml = ToastNotificationManager.GetTemplateContent(ToastTemplateType.ToastImageAndText01);

            // Fill in the text elements
            var stringElements = toastXml.GetElementsByTagName("text");

            var textIndex = 0;
            //Add the title
            stringElements[textIndex].AppendChild(toastXml.CreateTextNode(title));
            textIndex++;

            //Add the message
            if (!string.IsNullOrEmpty(message))
            {
                stringElements[textIndex].AppendChild(toastXml.CreateTextNode(message));
                textIndex++;
            }

            //Add the further message
            if (!string.IsNullOrEmpty(furtherMessage))
            {
                stringElements[textIndex].AppendChild(toastXml.CreateTextNode(furtherMessage));
            }

            // Specify the absolute path to an image
            var imagePath = "file:///" + Path.GetFullPath("Resources/logo_512.png");
            var imageElements = toastXml.GetElementsByTagName("image");
            var namedItem = imageElements[0].Attributes.GetNamedItem("src");

            if (namedItem != null)
                namedItem.NodeValue = imagePath;

            var toast = new ToastNotification(toastXml);

            if (onActivate != null)
            {
                toast.Activated += onActivate;
            }

            if (onDismiss != null)
            {
                toast.Dismissed += onDismiss;
            }

            ToastNotificationManager.CreateToastNotifier(AppId).Show(toast);
        }

        public MainWindow()
        {
            InitializeComponent();

            recognizer = new SpeechRecognizer();
            List<String> constraints = new List<string>();
            //recognizer.Constraints.Add(new SpeechRecognitionListConstraint(constraints));
            IAsyncOperation<SpeechRecognitionCompilationResult> op = recognizer.CompileConstraintsAsync();
            resultGenerated = new TypedEventHandler<SpeechContinuousRecognitionSession, SpeechContinuousRecognitionResultGeneratedEventArgs>(UpdateTextBox);
            recognizer.ContinuousRecognitionSession.ResultGenerated += resultGenerated;
            OnStateChanged = new TypedEventHandler<SpeechRecognizer, SpeechRecognizerStateChangedEventArgs>(onStateChanged);
            recognizer.StateChanged += OnStateChanged;
            op.Completed += HandleCompilationCompleted;
        }

        public ScannerPage()
        {


            InitializeComponent();

            int ver = Scanner.MWBgetLibVersion();
            int v1 = (ver >> 16);
            int v2 = (ver >> 8) & 0xff;
            int v3 = (ver & 0xff);
            libVersion = String.Format("{0}.{1}.{2}", v1, v2, v3);

            System.Diagnostics.Debug.WriteLine("Lib version: " + libVersion);

            processingHandler = new DoWorkEventHandler(bw_DoWork);
            previewFrameHandler = new TypedEventHandler<ICameraCaptureDevice, Object>(cam_PreviewFrameAvailable);

            bw.WorkerReportsProgress = false;
            bw.WorkerSupportsCancellation = true;

            bw.DoWork += processingHandler;

        }

 /// <summary>
 /// Invoked when this page is about to be displayed in a Frame.
 /// </summary>
 /// <param name="e">Event data that describes how this page was reached.  The Parameter
 /// property is typically used to configure the page.</param>
 protected override void OnNavigatedTo(NavigationEventArgs e)
 {
     dataChangedHandler = new TypedEventHandler<ApplicationData, object>(DataChangedHandler);
     applicationData.DataChanged += dataChangedHandler;
 }

        private void Page_Loaded(object sender, RoutedEventArgs e)
        {
            object apiKey = null;

            if (Windows.Storage.ApplicationData.Current.RoamingSettings.Values.TryGetValue("FlickrApiKey", out apiKey))
            {
                FlickrApiKey.Text = (string)apiKey;
            }

            object username = null;

            if (Windows.Storage.ApplicationData.Current.RoamingSettings.Values.TryGetValue("FlickrUsername", out username))
            {
                FlickrUsername.Text = (string)username;
            }

            if (_displayHandler == null)
            {
                _displayHandler = Page_OrientationChanged;
                _layoutHandler = Page_LayoutChanged;
            }
            DisplayProperties.OrientationChanged += _displayHandler;
            ApplicationLayout.GetForCurrentView().LayoutChanged += _layoutHandler;
            SetCurrentOrientation(this);
        }