C# Action.?.Invoke方法代码示例

		internal ChildProgressBar(int maxTicks, string message, Action scheduleDraw, ProgressBarOptions options = null, Action<ProgressBarHeight> growth = null)
			: base(maxTicks, message, options)
		{
			_scheduleDraw = scheduleDraw;
			_growth = growth;
			_growth?.Invoke(ProgressBarHeight.Increment);
		}

        public static void RunSyncOrAsyncWithLock(object lockObject, Action action, Action whenComplete = null)
        {
            if (Monitor.TryEnter(lockObject))
            {
                try
                {
                    action();
                }
                finally
                {
                    Monitor.Exit(lockObject);
                }

                whenComplete?.Invoke();
            }
            else
            {
                MvxAsyncDispatcher.BeginAsync(() =>
                    {
                        lock (lockObject)
                        {
                            action();
                        }

                        whenComplete?.Invoke();
                    });
            }
        }

        public static IToken Parse(string text, int startPosition = 0, Action<IToken, int, string> callback = null)
        {
            if (string.IsNullOrWhiteSpace(text))
                return new NullToken();

            if (text.StartsWith("'") && text.IndexOf('\'', 1) <= 0)
                return new StringToken(text.Substring(1));

            List<string> blocks = text.SplitIntoBlocks(new[] {'\'', '\'', '"', '"', '^', '^', '{', '}', '(', ')'}, true,
                StringUtils.DelimiterInclude.IncludeSeparately);

            string simplifed = "";
            List<IToken> subResults = new List<IToken>();

            int currentPosition = startPosition;
            for (int i = 0; i < blocks.Count; i += 3)
            {
                string start = blocks[i];
                string entry = blocks[i + 1];
                IToken subResult = null;
                switch (start)
                {
                    case "\"":
                    case "'":
                        subResult = new StringToken(entry);
                        callback?.Invoke(subResult, currentPosition, "'" + entry + "'");
                        break;
                    case "^":
                        subResult = Parse(entry);
                        callback?.Invoke(subResult, currentPosition, "'" + entry + "'");
                        break;
                    case "{":
                        subResult = new ExpressionToken(null, new SubstitutionOperator(), Parse(entry));
                        callback?.Invoke(subResult, currentPosition, "{" + entry + "}");
                        break;
                    case "(":
                        subResult = Parse(entry, currentPosition + 1, callback);
                        break;
                    default:
                        simplifed += entry;
                        break;
                }
                if (subResult != null)
                {
                    simplifed += $"█{subResults.Count}█";
                    subResults.Add(subResult);
                }
                if (callback != null)
                    currentPosition += start.Length + entry.Length + blocks[i + 2].Length;
            }

            IToken result = ParseExpressionNoBrackets(simplifed, startPosition, callback);
            result = SubstituteValues(result, subResults);

            return result ?? new StringToken(text);
        }

        public Task Show(Action OnPresented = null)
        {
            if (showTask != null)
            {
                showTask.TrySetResult(false);
                showTask.TrySetCanceled();
            }
            else {
                showTask = new TaskCompletionSource<bool>();
            }
            adsInterstitial = new Interstitial(CrossAdmobManager.AdmobKey);
            var request = Request.GetDefaultRequest();
            adsInterstitial.AdReceived += (sender, args) =>
            {
                if (adsInterstitial.IsReady)
                {
                    var window = UIApplication.SharedApplication.KeyWindow;
                    var vc = window.RootViewController;
                    while (vc.PresentedViewController != null)
                    {
                        vc = vc.PresentedViewController;
                    }
                    adsInterstitial.PresentFromRootViewController(vc);
                    OnPresented?.Invoke();
                }
            };

            adsInterstitial.ScreenDismissed += (sender, e) => {
                if (showTask != null)
                {
                    showTask.TrySetResult(adsInterstitial.IsReady);
					showTask = null;

                }
			};

			adsInterstitial.ReceiveAdFailed += (sender, e) =>
			{
				OnPresented?.Invoke();
				showTask.TrySetResult(false);
				showTask.TrySetCanceled();
				showTask = null;
			};

			if (testDevicesId != null)
			{
				testDevicesId.Add(Request.SimulatorId);
				request.TestDevices = testDevicesId.ToArray();
			}
            adsInterstitial.LoadRequest(request);
            return Task.WhenAll(showTask.Task);
        }

        protected ILifetimeScope CreateContainer(Action<ContainerBuilder> setupCallback = null)
        {
            var builder = new ContainerBuilder();

            var fakeEnvironment = builder.RegisterFake<IEnvironmentInformation>();

            fakeEnvironment
                .GetIsInDesignTime()
                .Returns(false);

            fakeEnvironment
                .GetIsDebugging()
                .Returns(true);

            builder.RegisterModule(
                new DefaultWiringModule(fakeEnvironment));

            builder.RegisterFake<IThreadDelay>();

            setupCallback?.Invoke(builder);

            return activeContainer = builder
                                         .Build()
                                         .BeginLifetimeScope();
        }

 public override void GetResourceStream(string resourcePath, Action<Stream> streamAction)
 {
     using (var input = Assets.Open(resourcePath))
     {
         streamAction?.Invoke(input);
     }
 }

        /// <summary>
        /// Returns average microseconds an action takes when run for the specified runForMs
        /// </summary>
        /// <param name="fn">What to run</param>
        /// <param name="times">How many times to run for each iteration</param>
        /// <param name="runForMs">Minimum ms to run for</param>
        /// <param name="setup"></param>
        /// <param name="warmup"></param>
        /// <param name="teardown"></param>
        /// <returns></returns>
        public static double Measure(Action fn,
            int times = 1,
            int runForMs = 2000,
            Action setup = null,
            Action warmup = null,
            Action teardown = null)
        {
            setup?.Invoke();

            // Warmup for at least 100ms. Discard result.
            if (warmup == null)
                warmup = fn;

            GC.Collect();

            MeasureFor(() => warmup(), 100);

            // Run the benchmark for at least 2000ms.
            double result = MeasureFor(() =>
            {
                for (var i = 0; i < times; i++)
                    fn();
            }, runForMs);

            teardown?.Invoke();

            return result;
        }

        public void RegisterDependencies(Action<ContainerBuilder> build)
        {
            var cb = new ContainerBuilder();
            build?.Invoke(cb);
            cb.Update(DependencyContainer);

        }

        /// <summary>
        /// This will show a MessageDialog with a YES/NO option. It will run an action based on the actoin parameter.
        /// </summary>
        /// <param name="message">Message to show.</param>
        /// <param name="title">Title of the message.</param>
        /// <param name="yesAction">The action that should be run upon confirmation</param>
        /// <param name="noAction">The action that should be run upon rejection</param>
        /// <returns>true if user indicates "Yes", false otherwise</returns>
        static public async Task<bool> ConfirmActionAsync(string message, string title, Action yesAction, Action noAction = null)
        {
            var commandresult =
            await new MessageDialog(message, title)
                                {
                                       Commands =
                                       {
                                           new UICommand
                                           {
                                               Label = "Yes",
                                               Invoked = command => yesAction()
                                           },
                                           new UICommand
                                           {
                                               Label = "No",
                                               Invoked = command => noAction?.Invoke()
                                           }
                                       },
                                       DefaultCommandIndex = 1,
                                       CancelCommandIndex = 1,
                                       Options = MessageDialogOptions.AcceptUserInputAfterDelay,
                                }
            .ShowAsync();

            return commandresult.Label == "Yes";
        }

        public MainPage()
        {
            InitializeComponent();

            for (int i = 0; i < 20; i++)
            {
                var twnk = new TwinkleStar(i);
                _tinkleCanvas.Children.Add(twnk);
                _stars.Add(twnk);
            }

            for (int i = 0; i < 3; i++)
            {
                var ballon = new FloatingBallon(i);
                _tinkleCanvas.Children.Add(ballon);
            }

            _nextTapAction = () =>
            {
                _typeOfPresentWheel.Spin();
                _nextTapAction = null;
            };

            Windows.UI.ViewManagement.ApplicationView.GetForCurrentView().Title = "Grattis";

            _bandIO.Connect();
            _bandIO.Pulled += () =>
            {
                if ((DateTime.UtcNow - _lastAcccelerometerAction).TotalSeconds < 1)
                    return;
                _lastAcccelerometerAction = DateTime.UtcNow;
                Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => _nextTapAction?.Invoke());
            };
        }

		public static void IsTrue( this bool target, Action action )
		{
			if ( target )
			{
				action?.Invoke();
			}
		}

        public static void Display(string text, Action dismissed = null)
        {
            var window = ((AppDelegate)UIApplication.SharedApplication.Delegate).Window;

            var alertView = new BlurredAlertView(text);
            var blur = UIBlurEffect.FromStyle(UIBlurEffectStyle.Dark);
            var blurView = new UIVisualEffectView(blur);
            blurView.Frame = new CGRect(0, 0, window.Frame.Width, window.Frame.Height);
            blurView.AutoresizingMask = UIViewAutoresizing.All;

            blurView.ContentView.Add(alertView.View);
            blurView.Alpha = 0;
            blurView.AutoresizingMask = UIViewAutoresizing.All;
            window.Add(blurView);

            UIView.Animate(0.3, 0, UIViewAnimationOptions.CurveEaseIn, () => blurView.Alpha = 1, null);

            alertView._button.GetClickedObservable().Take(1).Subscribe(_ => {
                UIView.Animate(0.3, 0, UIViewAnimationOptions.CurveEaseIn, () => blurView.Alpha = 0, () => {
                    blurView.RemoveFromSuperview();
                    alertView.View.RemoveFromSuperview();
                    dismissed?.Invoke();
                });
            });
        }

        private InMemoryTestStore CreateTransient(Action initializeDatabase, Action deleteDatabase)
        {
            initializeDatabase?.Invoke();

            _deleteDatabase = deleteDatabase;
            return this;
        }

 internal static IObjectContainer CreateDefaultGlobalContainer(IRuntimeConfigurationProvider configurationProvider = null, Action<IObjectContainer> registerGlobalMocks = null)
 {
     var instance = new ContainerBuilder();
     var globalContainer = instance.CreateGlobalContainer(configurationProvider);
     registerGlobalMocks?.Invoke(globalContainer);
     return globalContainer;
 }

		public void GetSticker (IceCream iceCream, Action<MSSticker> completion)
		{
			if (iceCream.Base == null || iceCream.Scoops == null || iceCream.Topping == null)
				throw new Exception ("Stickers can only be created for completed ice creams");

			// Determine the URL for the sticker.
			var fileName = $"{iceCream.Base.RawValue}{iceCream.Scoops.RawValue}{iceCream.Topping.RawValue}.png";
			var url = Path.Combine (cacheURL, fileName);

			// Check if the sticker already exists at the URL
			if (!NSFileManager.DefaultManager.FileExists (url)) {
				
				// Create the sticker image and write it to disk.
				var image = iceCream.RenderSticker (false);
				var imageData = image?.AsPNG ();
				if (image == null || imageData == null)
					throw new Exception ("Unable to build image for ice cream");

				try {
					File.WriteAllBytes (url, imageData.ToArray ());
				} catch {
					throw new Exception ("Failed to write sticker image to cach");
				}
			}

			NSError error;
			var sticker = new MSSticker (new NSUrl ($"file://{url}"), "Ice Cream", out error);

			if (error != null)
				throw new Exception ($"Failed to write image to cache, error: {error.LocalizedDescription}");

			completion?.Invoke (sticker);
		}