feat(Timer): remove Task.Run support wpf

[ArgoZhang]

Link issues

fixes #5895

Summary By Copilot

This pull request refactors the OnStart method in the Timer.razor.cs file to simplify the code and improve its readability. The most notable changes include making the method asynchronous, removing unnecessary Task.Run calls, and simplifying state updates.

Refactoring of OnStart method:

• Changed the OnStart method from private Task to private async Task to directly handle asynchronous operations without wrapping them in Task.Run.
• Removed the Task.Run block and consolidated the logic to simplify the flow, ensuring state updates (StateHasChanged) and event invocations (OnTimeout) are directly handled.
• Replaced await InvokeAsync(StateHasChanged) with a direct call to StateHasChanged to streamline the state update process.

Regression?

• Yes
• No

Risk

• High
• Medium
• Low

Verification

• Manual (required)
• Automated

Packaging changes reviewed?

• Yes
• No
• N/A

☑️ Self Check before Merge

⚠️ Please check all items below before review. ⚠️

• Doc is updated/provided or not needed
• Demo is updated/provided or not needed
• Merge the latest code from the main branch

Summary by Sourcery

Simplify asynchronous operations in the Timer component by refactoring the OnStart method.

Enhancements:

• Make the OnStart method asynchronous, removing the need for Task.Run.
• Streamline state updates within the OnStart method.

[sourcery-ai]

Reviewer's Guide by Sourcery

This pull request refactors the OnStart method in Timer.razor.cs to remove the use of Task.Run and simplify asynchronous operations and state updates. The method is now async Task, directly handling delays and state changes.

No diagrams generated as the changes look simple and do not need a visual representation.

File-Level Changes

Change	Details	Files
Refactor the OnStart method to remove Task.Run and simplify async logic.	Changed the method signature from private Task to private async Task. Removed the Task.Run wrapper around the core timer logic. Moved the timer logic directly into the OnStart method. Replaced await InvokeAsync(StateHasChanged) with StateHasChanged. Simplified the timeout handling logic, removing the InvokeAsync wrapper.	src/BootstrapBlazor/Components/Timer/Timer.razor.cs

Assessment against linked issues

Issue	Objective	Addressed	Explanation
#5895	Remove Task.Run support in the Timer component for WPF.	✅

Possibly linked issues

• feat(Timer): remove Task.Run support wpf #5895: The PR removes Task.Run calls in the Timer component's OnStart method, directly addressing the issue request.

---

Tips and commands

Interacting with Sourcery

• Trigger a new review: Comment @sourcery-ai review on the pull request.
• Continue discussions: Reply directly to Sourcery's review comments.
• Generate a GitHub issue from a review comment: Ask Sourcery to create an
  issue from a review comment by replying to it. You can also reply to a
  review comment with @sourcery-ai issue to create an issue from it.
• Generate a pull request title: Write @sourcery-ai anywhere in the pull
  request title to generate a title at any time. You can also comment
  @sourcery-ai title on the pull request to (re-)generate the title at any time.
• Generate a pull request summary: Write @sourcery-ai summary anywhere in
  the pull request body to generate a PR summary at any time exactly where you
  want it. You can also comment @sourcery-ai summary on the pull request to
  (re-)generate the summary at any time.
• Generate reviewer's guide: Comment @sourcery-ai guide on the pull
  request to (re-)generate the reviewer's guide at any time.
• Resolve all Sourcery comments: Comment @sourcery-ai resolve on the
  pull request to resolve all Sourcery comments. Useful if you've already
  addressed all the comments and don't want to see them anymore.
• Dismiss all Sourcery reviews: Comment @sourcery-ai dismiss on the pull
  request to dismiss all existing Sourcery reviews. Especially useful if you
  want to start fresh with a new review - don't forget to comment
  @sourcery-ai review to trigger a new review!

Customizing Your Experience

Access your dashboard to:

• Enable or disable review features such as the Sourcery-generated pull request
  summary, the reviewer's guide, and others.
• Change the review language.
• Add, remove or edit custom review instructions.
• Adjust other review settings.

Getting Help

• Contact our support team for questions or feedback.
• Visit our documentation for detailed guides and information.
• Keep in touch with the Sourcery team by following us on X/Twitter, LinkedIn or GitHub.

[Copilot]

Pull Request Overview

This PR refactors the Timer component’s OnStart method to simplify asynchronous handling and improve readability by removing the Task.Run call.

• Changed OnStart from synchronous wrapping to an async method with proper state updates.
• Removed the Task.Run block and replaced some InvokeAsync calls with direct StateHasChanged calls.

Comments suppressed due to low confidence (1)

src/BootstrapBlazor/Components/Timer/Timer.razor.cs:180

• Removing the Task.Run block means the timer loop now runs on the UI thread, which might lead to UI blocking if the countdown operation is extensive. Consider using a background timer or a dedicated task to offload this processing.

_ = Task.Run(async () => {

[Copilot]

[nitpick] If using await Task.Yield() to force an async context switch, please consider adding a brief comment explaining its purpose to aid future maintainers.

Suggested change

	StateHasChanged();
	StateHasChanged();
	// Force an asynchronous context switch to ensure UI updates are processed before continuing.

[sourcery-ai]

Hey @ArgoZhang - I've reviewed your changes - here's some feedback:

Overall Comments:

• Consider updating the PR title to more accurately reflect the changes, as the modified code relates to a Blazor component rather than WPF.
• Could you add a brief explanation for the addition of await Task.Yield() at the start of the OnStart method?

Here's what I looked at during the review

• 🟡 General issues: 1 issue found
• 🟢 Security: all looks good
• 🟢 Testing: all looks good
• 🟢 Complexity: all looks good
• 🟢 Documentation: all looks good

---

Sourcery is free for open source - if you like our reviews please consider sharing them ✨

• X
• Mastodon
• LinkedIn
• Facebook

_{Help me be more useful! Please click 👍 or 👎 on each comment and I'll use the feedback to improve your reviews.}

[sourcery-ai]

suggestion (performance): Synchronous ResetEvent.WaitOne call inside an async method.

Using ResetEvent.WaitOne is a blocking operation and may block the async state machine if executed on a UI or a limited thread pool thread. Consider leveraging an asynchronous wait mechanism to avoid potential deadlocks or UI freezes.

Suggested implementation:

                if (IsPause)
                {
                    await Task.Run(() => ResetEvent.WaitOne());
                    AlertTime = DateTime.Now.Add(CurrentTimespan).ToString("HH:mm:ss");
                }

Make sure the surrounding method is declared as async and that any callers are updated accordingly. This change leverages an asynchronous wait for the ResetEvent to avoid blocking the async flow.