BranchesTags

Repository files navigation

Windows Service Extensions

Building a basic Windows Service that does some long-running background work is trivial, using .NET's UseWindowsService() (from the Platform Extensions package Microsoft.Extensions.Hosting.WindowsServices) and Microsoft.Extensions.Hosting.BackgroundService from Microsoft.Extensions.Hosting.Abstractions.

Running as a Windows Service and running BackgroundServices are two separate things though, and they are not connected in any way. A non-service console app can run background services, and so can and do web applications. Each of those are different hosting environments, with their own lifetimes.

This project exists of a few classes that make building reliable Windows Services easier, to gap this disconnect.

Lifetime

The following improvements are included in this library:

  • OnStart() can fail because of invalid service configuration, quit the application when that happens (by kmcclellan).
  • On consumer OS Windows 10+, shutting down the computer will actually hibernate the OS. Services won't get another OnStart() call when the computer starts again, nor will your background services be notified. Now they will.
  • It also can notify your BackgroundServices about user session changes, i.e. logon, logoff and others.
  • When an exception occurs during your BackgroundService's lifetime, .NET Platform Extensions < 6 didn't stop the application host. Now it does, but it doesn't report an error to the Service Control Manager. With this extension, it does, as well as setting a process exit code: 13 in both cases ("invalid data").

Installation

Through NuGet:

> Install-Package CodeCaster.WindowsServiceExtensions

Usage

These methods from this package allow your IHostedServices to tell the Windows Service Control Manager about errors, and respond to Windows Service events relating to sessions (user logon/logoff) and power state (shutdown/hibernate/resume):

  • On your Host Builder, call UseWindowsServiceExtensions() instead of UseWindowsService().
  • Instead of letting your service inherit BackgroundService, inherit from CodeCaster.WindowsServiceExtensions.WindowsServiceBackgroundService.
  • Implement protected Task TryExecuteAsync(CancellationToken stoppingToken) instead of ExecuteAsync(CancellationToken stoppingToken).
  • Implement the method public override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { ... } and do your thing when it's called with a certain status.
  • Implement the method public override bool OnSessionChange(SessionChangeDescription changeDescription) { ... } and do your thing when it's called with a certain status.

Do note that the statuses received can vary. You get either ResumeSuspend, ResumeAutomatic or both reported to OnPowerEvent(), never neither, after a machine wake, reboot or boot.

Documentation

For examples and more specific documentation, see https://codecasternl.github.io/WindowsServiceExtensions/.

Upgrading from v2 to v3

If you're one of the souls that use this library (who are you?), you'll want to upgrade to v3.0 after upgrading your projects to .NET 6.

Changes:

  • The DI extension method IHostBuilder.UsePowerEventAwareWindowsService() is now called UseWindowsServiceExtensions() because we do more than power events now.
  • The long-running hosted service base class CodeCaster.WindowsServiceExtensions.PowerEventAwareBackgroundService was renamed to CodeCaster.WindowsServiceExtensions.Service.WindowsServiceBackgroundService, because the former didn't have enough "Service" in its name.
  • Instead of BackgroundService.ExecuteAsync(), which is now sealed, override WindowsServiceBackgroundService.TryExecuteAsync() to do your long-running work.

Extended upgrading docs: see https://codecasternl.github.io/WindowsServiceExtensions/upgrading-v2-v3.

Contributing

Please file an issue or PR. Even if you use this and are happy with it.

About

Create resilient Windows Services that get informed about power and session events.

codecasternl.github.io/WindowsServiceExtensions/

Topics

windows-service

Resources

Readme
MIT license
Activity

Stars

2 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Used by

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Add copy buttons to all 
 blocks\n(function() {\n function addCopyButtons() {\n document.querySelectorAll('pre code').forEach(function(codeBlock) {\n if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;\n codeBlock.parentElement.setAttribute('data-copy-added', 'true');\n \n var btn = document.createElement('button');\n btn.textContent = 'Copy';\n btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';\n btn.onmouseover = function() { this.style.opacity = '1'; };\n btn.onmouseout = function() { this.style.opacity = '0.7'; };\n btn.onclick = function() {\n navigator.clipboard.writeText(codeBlock.textContent).then(function() {\n btn.textContent = 'Copied!';\n setTimeout(function() { btn.textContent = 'Copy'; }, 1500);\n });\n };\n codeBlock.parentElement.style.position = 'relative';\n codeBlock.parentElement.appendChild(btn);\n });\n }\n \n addCopyButtons();\n \n // Re-run on dynamic content\n var observer = new MutationObserver(addCopyButtons);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Add Copy Buttons to Code Blocks");
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
BranchesTags
Repository files navigation
Windows Service Extensions
Building a basic Windows Service that does some long-running background work is trivial, using .NET's UseWindowsService() (from the Platform Extensions package Microsoft.Extensions.Hosting.WindowsServices) and Microsoft.Extensions.Hosting.BackgroundService from Microsoft.Extensions.Hosting.Abstractions.
Running as a Windows Service and running BackgroundServices are two separate things though, and they are not connected in any way. A non-service console app can run background services, and so can and do web applications. Each of those are different hosting environments, with their own lifetimes.
This project exists of a few classes that make building reliable Windows Services easier, to gap this disconnect.
Lifetime
The following improvements are included in this library:
  • OnStart() can fail because of invalid service configuration, quit the application when that happens (by kmcclellan).
  • On consumer OS Windows 10+, shutting down the computer will actually hibernate the OS. Services won't get another OnStart() call when the computer starts again, nor will your background services be notified. Now they will.
  • It also can notify your BackgroundServices about user session changes, i.e. logon, logoff and others.
  • When an exception occurs during your BackgroundService's lifetime, .NET Platform Extensions < 6 didn't stop the application host. Now it does, but it doesn't report an error to the Service Control Manager. With this extension, it does, as well as setting a process exit code: 13 in both cases ("invalid data").
Installation
Through NuGet:
> Install-Package CodeCaster.WindowsServiceExtensions

Usage
These methods from this package allow your IHostedServices to tell the Windows Service Control Manager about errors, and respond to Windows Service events relating to sessions (user logon/logoff) and power state (shutdown/hibernate/resume):
  • On your Host Builder, call UseWindowsServiceExtensions() instead of UseWindowsService().
  • Instead of letting your service inherit BackgroundService, inherit from CodeCaster.WindowsServiceExtensions.WindowsServiceBackgroundService.
  • Implement protected Task TryExecuteAsync(CancellationToken stoppingToken) instead of ExecuteAsync(CancellationToken stoppingToken).
  • Implement the method public override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { ... } and do your thing when it's called with a certain status.
  • Implement the method public override bool OnSessionChange(SessionChangeDescription changeDescription) { ... } and do your thing when it's called with a certain status.
Do note that the statuses received can vary. You get either ResumeSuspend, ResumeAutomatic or both reported to OnPowerEvent(), never neither, after a machine wake, reboot or boot.
Documentation
For examples and more specific documentation, see https://codecasternl.github.io/WindowsServiceExtensions/.
Upgrading from v2 to v3
If you're one of the souls that use this library (who are you?), you'll want to upgrade to v3.0 after upgrading your projects to .NET 6.
Changes:
  • The DI extension method IHostBuilder.UsePowerEventAwareWindowsService() is now called UseWindowsServiceExtensions() because we do more than power events now.
  • The long-running hosted service base class CodeCaster.WindowsServiceExtensions.PowerEventAwareBackgroundService was renamed to CodeCaster.WindowsServiceExtensions.Service.WindowsServiceBackgroundService, because the former didn't have enough "Service" in its name.
  • Instead of BackgroundService.ExecuteAsync(), which is now sealed, override WindowsServiceBackgroundService.TryExecuteAsync() to do your long-running work.
Extended upgrading docs: see https://codecasternl.github.io/WindowsServiceExtensions/upgrading-v2-v3.
Contributing
Please file an issue or PR. Even if you use this and are happy with it.
About
Create resilient Windows Services that get informed about power and session events.
codecasternl.github.io/WindowsServiceExtensions/
Topics
windows-service
Resources
Readme
MIT license
Activity
Stars
2 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Force GitHub README to respect dark mode\n(function() {\n var style = document.createElement('style');\n style.textContent = '\n .markdown-body {\n color-scheme: dark light;\n }\n .markdown-body pre { background: #161b22 !important; }\n .markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }\n .markdown-body table th, .markdown-body table td { border-color: #30363d !important; }\n .markdown-body img { background: #0d1117; }\n .markdown-body blockquote { border-left-color: #8b949e; }\n .markdown-body hr { border-color: #30363d; }\n ';\n document.head.appendChild(style);\n})();", "GitHub Dark Mode README Fix");
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
Windows Service Extensions
Building a basic Windows Service that does some long-running background work is trivial, using .NET's UseWindowsService() (from the Platform Extensions package Microsoft.Extensions.Hosting.WindowsServices) and Microsoft.Extensions.Hosting.BackgroundService from Microsoft.Extensions.Hosting.Abstractions.
Running as a Windows Service and running BackgroundServices are two separate things though, and they are not connected in any way. A non-service console app can run background services, and so can and do web applications. Each of those are different hosting environments, with their own lifetimes.
This project exists of a few classes that make building reliable Windows Services easier, to gap this disconnect.
Lifetime
The following improvements are included in this library:
  • OnStart() can fail because of invalid service configuration, quit the application when that happens (by kmcclellan).
  • On consumer OS Windows 10+, shutting down the computer will actually hibernate the OS. Services won't get another OnStart() call when the computer starts again, nor will your background services be notified. Now they will.
  • It also can notify your BackgroundServices about user session changes, i.e. logon, logoff and others.
  • When an exception occurs during your BackgroundService's lifetime, .NET Platform Extensions < 6 didn't stop the application host. Now it does, but it doesn't report an error to the Service Control Manager. With this extension, it does, as well as setting a process exit code: 13 in both cases ("invalid data").
Installation
Through NuGet:
> Install-Package CodeCaster.WindowsServiceExtensions

Usage
These methods from this package allow your IHostedServices to tell the Windows Service Control Manager about errors, and respond to Windows Service events relating to sessions (user logon/logoff) and power state (shutdown/hibernate/resume):
  • On your Host Builder, call UseWindowsServiceExtensions() instead of UseWindowsService().
  • Instead of letting your service inherit BackgroundService, inherit from CodeCaster.WindowsServiceExtensions.WindowsServiceBackgroundService.
  • Implement protected Task TryExecuteAsync(CancellationToken stoppingToken) instead of ExecuteAsync(CancellationToken stoppingToken).
  • Implement the method public override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { ... } and do your thing when it's called with a certain status.
  • Implement the method public override bool OnSessionChange(SessionChangeDescription changeDescription) { ... } and do your thing when it's called with a certain status.
Do note that the statuses received can vary. You get either ResumeSuspend, ResumeAutomatic or both reported to OnPowerEvent(), never neither, after a machine wake, reboot or boot.
Documentation
For examples and more specific documentation, see https://codecasternl.github.io/WindowsServiceExtensions/.
Upgrading from v2 to v3
If you're one of the souls that use this library (who are you?), you'll want to upgrade to v3.0 after upgrading your projects to .NET 6.
Changes:
  • The DI extension method IHostBuilder.UsePowerEventAwareWindowsService() is now called UseWindowsServiceExtensions() because we do more than power events now.
  • The long-running hosted service base class CodeCaster.WindowsServiceExtensions.PowerEventAwareBackgroundService was renamed to CodeCaster.WindowsServiceExtensions.Service.WindowsServiceBackgroundService, because the former didn't have enough "Service" in its name.
  • Instead of BackgroundService.ExecuteAsync(), which is now sealed, override WindowsServiceBackgroundService.TryExecuteAsync() to do your long-running work.
Extended upgrading docs: see https://codecasternl.github.io/WindowsServiceExtensions/upgrading-v2-v3.
Contributing
Please file an issue or PR. Even if you use this and are happy with it.
About
Create resilient Windows Services that get informed about power and session events.
codecasternl.github.io/WindowsServiceExtensions/
Topics
windows-service
Resources
Readme
MIT license
Activity
Stars
2 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Highlight search terms from Google/DuckDuckGo/Bing referrer\n(function() {\n var ref = document.referrer;\n var terms = [];\n \n if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {\n var url = new URL(ref);\n var q = url.searchParams.get('q') || url.searchParams.get('p');\n if (q) {\n terms = q.split(/\\s+/).filter(function(t) { return t.length > 2; });\n }\n }\n \n if (terms.length === 0) return;\n \n var style = document.createElement('style');\n style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';\n document.head.appendChild(style);\n \n function highlight(node) {\n if (node.nodeType === 3) { // text node\n var text = node.textContent;\n var found = false;\n terms.forEach(function(term) {\n var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\') + ')', 'gi');\n if (regex.test(text)) {\n found = true;\n var frag = document.createDocumentFragment();\n var parts = text.split(regex);\n parts.forEach(function(part, i) {\n if (i % 2 === 0) {\n frag.appendChild(document.createTextNode(part));\n } else {\n var span = document.createElement('span');\n span.className = 'userscript-highlight';\n span.textContent = part;\n frag.appendChild(span);\n }\n });\n node.parentNode.replaceChild(frag, node);\n }\n });\n } else if (node.nodeType === 1 && node.childNodes) { // element\n var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];\n if (!skipTags.includes(node.tagName)) {\n Array.from(node.childNodes).forEach(highlight);\n }\n }\n }\n \n highlight(document.body);\n \n // Re-highlight on dynamic content\n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1 || node.nodeType === 3) highlight(node);\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Highlight Search Terms");
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
Windows Service Extensions
Building a basic Windows Service that does some long-running background work is trivial, using .NET's UseWindowsService() (from the Platform Extensions package Microsoft.Extensions.Hosting.WindowsServices) and Microsoft.Extensions.Hosting.BackgroundService from Microsoft.Extensions.Hosting.Abstractions.
Running as a Windows Service and running BackgroundServices are two separate things though, and they are not connected in any way. A non-service console app can run background services, and so can and do web applications. Each of those are different hosting environments, with their own lifetimes.
This project exists of a few classes that make building reliable Windows Services easier, to gap this disconnect.
Lifetime
The following improvements are included in this library:
  • OnStart() can fail because of invalid service configuration, quit the application when that happens (by kmcclellan).
  • On consumer OS Windows 10+, shutting down the computer will actually hibernate the OS. Services won't get another OnStart() call when the computer starts again, nor will your background services be notified. Now they will.
  • It also can notify your BackgroundServices about user session changes, i.e. logon, logoff and others.
  • When an exception occurs during your BackgroundService's lifetime, .NET Platform Extensions < 6 didn't stop the application host. Now it does, but it doesn't report an error to the Service Control Manager. With this extension, it does, as well as setting a process exit code: 13 in both cases ("invalid data").
Installation
Through NuGet:
> Install-Package CodeCaster.WindowsServiceExtensions

Usage
These methods from this package allow your IHostedServices to tell the Windows Service Control Manager about errors, and respond to Windows Service events relating to sessions (user logon/logoff) and power state (shutdown/hibernate/resume):
  • On your Host Builder, call UseWindowsServiceExtensions() instead of UseWindowsService().
  • Instead of letting your service inherit BackgroundService, inherit from CodeCaster.WindowsServiceExtensions.WindowsServiceBackgroundService.
  • Implement protected Task TryExecuteAsync(CancellationToken stoppingToken) instead of ExecuteAsync(CancellationToken stoppingToken).
  • Implement the method public override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { ... } and do your thing when it's called with a certain status.
  • Implement the method public override bool OnSessionChange(SessionChangeDescription changeDescription) { ... } and do your thing when it's called with a certain status.
Do note that the statuses received can vary. You get either ResumeSuspend, ResumeAutomatic or both reported to OnPowerEvent(), never neither, after a machine wake, reboot or boot.
Documentation
For examples and more specific documentation, see https://codecasternl.github.io/WindowsServiceExtensions/.
Upgrading from v2 to v3
If you're one of the souls that use this library (who are you?), you'll want to upgrade to v3.0 after upgrading your projects to .NET 6.
Changes:
  • The DI extension method IHostBuilder.UsePowerEventAwareWindowsService() is now called UseWindowsServiceExtensions() because we do more than power events now.
  • The long-running hosted service base class CodeCaster.WindowsServiceExtensions.PowerEventAwareBackgroundService was renamed to CodeCaster.WindowsServiceExtensions.Service.WindowsServiceBackgroundService, because the former didn't have enough "Service" in its name.
  • Instead of BackgroundService.ExecuteAsync(), which is now sealed, override WindowsServiceBackgroundService.TryExecuteAsync() to do your long-running work.
Extended upgrading docs: see https://codecasternl.github.io/WindowsServiceExtensions/upgrading-v2-v3.
Contributing
Please file an issue or PR. Even if you use this and are happy with it.
About
Create resilient Windows Services that get informed about power and session events.
codecasternl.github.io/WindowsServiceExtensions/
Topics
windows-service
Resources
Readme
MIT license
Activity
Stars
2 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Strip utm_, fbclid, gclid, etc. from all links on page\n(function() {\n var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',\n 'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',\n 'ref', 'ref_src', 'source', 'medium', 'campaign'];\n \n function cleanUrl(url) {\n try {\n var u = new URL(url, window.location.origin);\n var changed = false;\n trackingParams.forEach(function(p) {\n if (u.searchParams.has(p)) {\n u.searchParams.delete(p);\n changed = true;\n }\n });\n return changed ? u.toString() : url;\n } catch (e) {\n return url;\n }\n }\n \n function cleanLinks() {\n document.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n \n cleanLinks();\n \n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1) {\n if (node.tagName === 'A') cleanLinks();\n node.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Remove Tracking Parameters from Links");
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
BranchesTags
Repository files navigation
Windows Service Extensions
Building a basic Windows Service that does some long-running background work is trivial, using .NET's UseWindowsService() (from the Platform Extensions package Microsoft.Extensions.Hosting.WindowsServices) and Microsoft.Extensions.Hosting.BackgroundService from Microsoft.Extensions.Hosting.Abstractions.
Running as a Windows Service and running BackgroundServices are two separate things though, and they are not connected in any way. A non-service console app can run background services, and so can and do web applications. Each of those are different hosting environments, with their own lifetimes.
This project exists of a few classes that make building reliable Windows Services easier, to gap this disconnect.
Lifetime
The following improvements are included in this library:
  • OnStart() can fail because of invalid service configuration, quit the application when that happens (by kmcclellan).
  • On consumer OS Windows 10+, shutting down the computer will actually hibernate the OS. Services won't get another OnStart() call when the computer starts again, nor will your background services be notified. Now they will.
  • It also can notify your BackgroundServices about user session changes, i.e. logon, logoff and others.
  • When an exception occurs during your BackgroundService's lifetime, .NET Platform Extensions < 6 didn't stop the application host. Now it does, but it doesn't report an error to the Service Control Manager. With this extension, it does, as well as setting a process exit code: 13 in both cases ("invalid data").
Installation
Through NuGet:
> Install-Package CodeCaster.WindowsServiceExtensions

Usage
These methods from this package allow your IHostedServices to tell the Windows Service Control Manager about errors, and respond to Windows Service events relating to sessions (user logon/logoff) and power state (shutdown/hibernate/resume):
  • On your Host Builder, call UseWindowsServiceExtensions() instead of UseWindowsService().
  • Instead of letting your service inherit BackgroundService, inherit from CodeCaster.WindowsServiceExtensions.WindowsServiceBackgroundService.
  • Implement protected Task TryExecuteAsync(CancellationToken stoppingToken) instead of ExecuteAsync(CancellationToken stoppingToken).
  • Implement the method public override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { ... } and do your thing when it's called with a certain status.
  • Implement the method public override bool OnSessionChange(SessionChangeDescription changeDescription) { ... } and do your thing when it's called with a certain status.
Do note that the statuses received can vary. You get either ResumeSuspend, ResumeAutomatic or both reported to OnPowerEvent(), never neither, after a machine wake, reboot or boot.
Documentation
For examples and more specific documentation, see https://codecasternl.github.io/WindowsServiceExtensions/.
Upgrading from v2 to v3
If you're one of the souls that use this library (who are you?), you'll want to upgrade to v3.0 after upgrading your projects to .NET 6.
Changes:
  • The DI extension method IHostBuilder.UsePowerEventAwareWindowsService() is now called UseWindowsServiceExtensions() because we do more than power events now.
  • The long-running hosted service base class CodeCaster.WindowsServiceExtensions.PowerEventAwareBackgroundService was renamed to CodeCaster.WindowsServiceExtensions.Service.WindowsServiceBackgroundService, because the former didn't have enough "Service" in its name.
  • Instead of BackgroundService.ExecuteAsync(), which is now sealed, override WindowsServiceBackgroundService.TryExecuteAsync() to do your long-running work.
Extended upgrading docs: see https://codecasternl.github.io/WindowsServiceExtensions/upgrading-v2-v3.
Contributing
Please file an issue or PR. Even if you use this and are happy with it.
About
Create resilient Windows Services that get informed about power and session events.
codecasternl.github.io/WindowsServiceExtensions/
Topics
windows-service
Resources
Readme
MIT license
Activity
Stars
2 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Auto-enable theater mode on YouTube\n(function() {\n function tryTheater() {\n var btn = document.querySelector('button[aria-label=\"Theater mode\"], ytd-player #player button[title=\"Theater mode\"]');\n if (btn && !btn.classList.contains('activated')) {\n btn.click();\n }\n }\n \n // Try immediately\n tryTheater();\n \n // Try after navigation (SPA)\n var lastUrl = location.href;\n setInterval(function() {\n if (location.href !== lastUrl) {\n lastUrl = location.href;\n setTimeout(tryTheater, 500);\n }\n }, 1000);\n \n // Also try on player load\n var observer = new MutationObserver(tryTheater);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "YouTube Theater Mode Default");
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
Windows Service Extensions
Building a basic Windows Service that does some long-running background work is trivial, using .NET's UseWindowsService() (from the Platform Extensions package Microsoft.Extensions.Hosting.WindowsServices) and Microsoft.Extensions.Hosting.BackgroundService from Microsoft.Extensions.Hosting.Abstractions.
Running as a Windows Service and running BackgroundServices are two separate things though, and they are not connected in any way. A non-service console app can run background services, and so can and do web applications. Each of those are different hosting environments, with their own lifetimes.
This project exists of a few classes that make building reliable Windows Services easier, to gap this disconnect.
Lifetime
The following improvements are included in this library:
  • OnStart() can fail because of invalid service configuration, quit the application when that happens (by kmcclellan).
  • On consumer OS Windows 10+, shutting down the computer will actually hibernate the OS. Services won't get another OnStart() call when the computer starts again, nor will your background services be notified. Now they will.
  • It also can notify your BackgroundServices about user session changes, i.e. logon, logoff and others.
  • When an exception occurs during your BackgroundService's lifetime, .NET Platform Extensions < 6 didn't stop the application host. Now it does, but it doesn't report an error to the Service Control Manager. With this extension, it does, as well as setting a process exit code: 13 in both cases ("invalid data").
Installation
Through NuGet:
> Install-Package CodeCaster.WindowsServiceExtensions

Usage
These methods from this package allow your IHostedServices to tell the Windows Service Control Manager about errors, and respond to Windows Service events relating to sessions (user logon/logoff) and power state (shutdown/hibernate/resume):
  • On your Host Builder, call UseWindowsServiceExtensions() instead of UseWindowsService().
  • Instead of letting your service inherit BackgroundService, inherit from CodeCaster.WindowsServiceExtensions.WindowsServiceBackgroundService.
  • Implement protected Task TryExecuteAsync(CancellationToken stoppingToken) instead of ExecuteAsync(CancellationToken stoppingToken).
  • Implement the method public override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { ... } and do your thing when it's called with a certain status.
  • Implement the method public override bool OnSessionChange(SessionChangeDescription changeDescription) { ... } and do your thing when it's called with a certain status.
Do note that the statuses received can vary. You get either ResumeSuspend, ResumeAutomatic or both reported to OnPowerEvent(), never neither, after a machine wake, reboot or boot.
Documentation
For examples and more specific documentation, see https://codecasternl.github.io/WindowsServiceExtensions/.
Upgrading from v2 to v3
If you're one of the souls that use this library (who are you?), you'll want to upgrade to v3.0 after upgrading your projects to .NET 6.
Changes:
  • The DI extension method IHostBuilder.UsePowerEventAwareWindowsService() is now called UseWindowsServiceExtensions() because we do more than power events now.
  • The long-running hosted service base class CodeCaster.WindowsServiceExtensions.PowerEventAwareBackgroundService was renamed to CodeCaster.WindowsServiceExtensions.Service.WindowsServiceBackgroundService, because the former didn't have enough "Service" in its name.
  • Instead of BackgroundService.ExecuteAsync(), which is now sealed, override WindowsServiceBackgroundService.TryExecuteAsync() to do your long-running work.
Extended upgrading docs: see https://codecasternl.github.io/WindowsServiceExtensions/upgrading-v2-v3.
Contributing
Please file an issue or PR. Even if you use this and are happy with it.
About
Create resilient Windows Services that get informed about power and session events.
codecasternl.github.io/WindowsServiceExtensions/
Topics
windows-service
Resources
Readme
MIT license
Activity
Stars
2 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Remove or un-stick sticky/fixed headers that block content\n(function() {\n function unstick() {\n document.querySelectorAll('header, nav, [role=\"banner\"], .header, .navbar, .sticky, .fixed-top, [style*=\"position: fixed\"], [style*=\"position:sticky\"]').forEach(function(el) {\n if (el.style.position === 'fixed' || el.style.position === 'sticky' || \n getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {\n el.style.position = 'static';\n el.style.top = 'auto';\n el.style.zIndex = 'auto';\n }\n });\n }\n \n unstick();\n \n var observer = new MutationObserver(unstick);\n observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });\n})();", "Kill Sticky Headers");
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
Windows Service Extensions
Building a basic Windows Service that does some long-running background work is trivial, using .NET's UseWindowsService() (from the Platform Extensions package Microsoft.Extensions.Hosting.WindowsServices) and Microsoft.Extensions.Hosting.BackgroundService from Microsoft.Extensions.Hosting.Abstractions.
Running as a Windows Service and running BackgroundServices are two separate things though, and they are not connected in any way. A non-service console app can run background services, and so can and do web applications. Each of those are different hosting environments, with their own lifetimes.
This project exists of a few classes that make building reliable Windows Services easier, to gap this disconnect.
Lifetime
The following improvements are included in this library:
  • OnStart() can fail because of invalid service configuration, quit the application when that happens (by kmcclellan).
  • On consumer OS Windows 10+, shutting down the computer will actually hibernate the OS. Services won't get another OnStart() call when the computer starts again, nor will your background services be notified. Now they will.
  • It also can notify your BackgroundServices about user session changes, i.e. logon, logoff and others.
  • When an exception occurs during your BackgroundService's lifetime, .NET Platform Extensions < 6 didn't stop the application host. Now it does, but it doesn't report an error to the Service Control Manager. With this extension, it does, as well as setting a process exit code: 13 in both cases ("invalid data").
Installation
Through NuGet:
> Install-Package CodeCaster.WindowsServiceExtensions

Usage
These methods from this package allow your IHostedServices to tell the Windows Service Control Manager about errors, and respond to Windows Service events relating to sessions (user logon/logoff) and power state (shutdown/hibernate/resume):
  • On your Host Builder, call UseWindowsServiceExtensions() instead of UseWindowsService().
  • Instead of letting your service inherit BackgroundService, inherit from CodeCaster.WindowsServiceExtensions.WindowsServiceBackgroundService.
  • Implement protected Task TryExecuteAsync(CancellationToken stoppingToken) instead of ExecuteAsync(CancellationToken stoppingToken).
  • Implement the method public override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { ... } and do your thing when it's called with a certain status.
  • Implement the method public override bool OnSessionChange(SessionChangeDescription changeDescription) { ... } and do your thing when it's called with a certain status.
Do note that the statuses received can vary. You get either ResumeSuspend, ResumeAutomatic or both reported to OnPowerEvent(), never neither, after a machine wake, reboot or boot.
Documentation
For examples and more specific documentation, see https://codecasternl.github.io/WindowsServiceExtensions/.
Upgrading from v2 to v3
If you're one of the souls that use this library (who are you?), you'll want to upgrade to v3.0 after upgrading your projects to .NET 6.
Changes:
  • The DI extension method IHostBuilder.UsePowerEventAwareWindowsService() is now called UseWindowsServiceExtensions() because we do more than power events now.
  • The long-running hosted service base class CodeCaster.WindowsServiceExtensions.PowerEventAwareBackgroundService was renamed to CodeCaster.WindowsServiceExtensions.Service.WindowsServiceBackgroundService, because the former didn't have enough "Service" in its name.
  • Instead of BackgroundService.ExecuteAsync(), which is now sealed, override WindowsServiceBackgroundService.TryExecuteAsync() to do your long-running work.
Extended upgrading docs: see https://codecasternl.github.io/WindowsServiceExtensions/upgrading-v2-v3.
Contributing
Please file an issue or PR. Even if you use this and are happy with it.
About
Create resilient Windows Services that get informed about power and session events.
codecasternl.github.io/WindowsServiceExtensions/
Topics
windows-service
Resources
Readme
MIT license
Activity
Stars
2 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Universal Dark Mode - works on any site\n(function() {\n var enabled = true;\n \n function applyDarkMode() {\n if (!enabled) return;\n \n // Create style element if it doesn't exist\n var style = document.getElementById('universal-dark-mode-style');\n if (!style) {\n style = document.createElement('style');\n style.id = 'universal-dark-mode-style';\n document.head.appendChild(style);\n }\n \n // Dark mode CSS - inverts colors but preserves images/video\n style.textContent = '\n /* Invert everything except media */\n html {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #1a1a2e !important;\n }\n \n /* Restore images, videos, iframes, canvas */\n img, video, iframe, canvas, svg, picture, [style*=\"background-image\"] {\n filter: invert(1) hue-rotate(180deg) !important;\n }\n \n /* Preserve specific elements that should not be inverted */\n .no-dark-mode, .no-dark-mode *,\n [data-theme=\"light\"], [data-theme=\"light\"],\n .ace_editor, .ace_editor *,\n .CodeMirror, .CodeMirror *,\n .monaco-editor, .monaco-editor *,\n .markdown-body pre, .markdown-body pre *,\n .highlight, .highlight *,\n pre code, pre code * {\n filter: none !important;\n }\n \n /* Fix common UI elements */\n .modal, .popup, .dropdown-menu, .tooltip, .popover {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #2d2d44 !important;\n border-color: #444 !important;\n }\n \n /* Scrollbars */\n ::-webkit-scrollbar { background: #1a1a2e !important; }\n ::-webkit-scrollbar-thumb { background: #444 !important; }\n ::-webkit-scrollbar-thumb:hover { background: #555 !important; }\n \n /* Selection */\n ::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ';\n }\n \n function removeDarkMode() {\n var style = document.getElementById('universal-dark-mode-style');\n if (style) style.remove();\n }\n \n // Toggle with Alt+Shift+D\n document.addEventListener('keydown', function(e) {\n if (e.altKey && e.shiftKey && e.key === 'D') {\n e.preventDefault();\n enabled = !enabled;\n if (enabled) {\n applyDarkMode();\n console.log('[Universal Dark Mode] Enabled');\n } else {\n removeDarkMode();\n console.log('[Universal Dark Mode] Disabled');\n }\n }\n });\n \n // Apply on load\n applyDarkMode();\n \n // Re-apply on dynamic content\n var observer = new MutationObserver(function(mutations) {\n if (enabled && !document.getElementById('universal-dark-mode-style')) {\n applyDarkMode();\n }\n });\n observer.observe(document.head, { childList: true });\n \n console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');\n})();", "Universal Dark Mode");
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
BranchesTags
Repository files navigation
Windows Service Extensions
Building a basic Windows Service that does some long-running background work is trivial, using .NET's UseWindowsService() (from the Platform Extensions package Microsoft.Extensions.Hosting.WindowsServices) and Microsoft.Extensions.Hosting.BackgroundService from Microsoft.Extensions.Hosting.Abstractions.
Running as a Windows Service and running BackgroundServices are two separate things though, and they are not connected in any way. A non-service console app can run background services, and so can and do web applications. Each of those are different hosting environments, with their own lifetimes.
This project exists of a few classes that make building reliable Windows Services easier, to gap this disconnect.
Lifetime
The following improvements are included in this library:
  • OnStart() can fail because of invalid service configuration, quit the application when that happens (by kmcclellan).
  • On consumer OS Windows 10+, shutting down the computer will actually hibernate the OS. Services won't get another OnStart() call when the computer starts again, nor will your background services be notified. Now they will.
  • It also can notify your BackgroundServices about user session changes, i.e. logon, logoff and others.
  • When an exception occurs during your BackgroundService's lifetime, .NET Platform Extensions < 6 didn't stop the application host. Now it does, but it doesn't report an error to the Service Control Manager. With this extension, it does, as well as setting a process exit code: 13 in both cases ("invalid data").
Installation
Through NuGet:
> Install-Package CodeCaster.WindowsServiceExtensions

Usage
These methods from this package allow your IHostedServices to tell the Windows Service Control Manager about errors, and respond to Windows Service events relating to sessions (user logon/logoff) and power state (shutdown/hibernate/resume):
  • On your Host Builder, call UseWindowsServiceExtensions() instead of UseWindowsService().
  • Instead of letting your service inherit BackgroundService, inherit from CodeCaster.WindowsServiceExtensions.WindowsServiceBackgroundService.
  • Implement protected Task TryExecuteAsync(CancellationToken stoppingToken) instead of ExecuteAsync(CancellationToken stoppingToken).
  • Implement the method public override bool OnPowerEvent(PowerBroadcastStatus powerStatus) { ... } and do your thing when it's called with a certain status.
  • Implement the method public override bool OnSessionChange(SessionChangeDescription changeDescription) { ... } and do your thing when it's called with a certain status.
Do note that the statuses received can vary. You get either ResumeSuspend, ResumeAutomatic or both reported to OnPowerEvent(), never neither, after a machine wake, reboot or boot.
Documentation
For examples and more specific documentation, see https://codecasternl.github.io/WindowsServiceExtensions/.
Upgrading from v2 to v3
If you're one of the souls that use this library (who are you?), you'll want to upgrade to v3.0 after upgrading your projects to .NET 6.
Changes:
  • The DI extension method IHostBuilder.UsePowerEventAwareWindowsService() is now called UseWindowsServiceExtensions() because we do more than power events now.
  • The long-running hosted service base class CodeCaster.WindowsServiceExtensions.PowerEventAwareBackgroundService was renamed to CodeCaster.WindowsServiceExtensions.Service.WindowsServiceBackgroundService, because the former didn't have enough "Service" in its name.
  • Instead of BackgroundService.ExecuteAsync(), which is now sealed, override WindowsServiceBackgroundService.TryExecuteAsync() to do your long-running work.
Extended upgrading docs: see https://codecasternl.github.io/WindowsServiceExtensions/upgrading-v2-v3.
Contributing
Please file an issue or PR. Even if you use this and are happy with it.
About
Create resilient Windows Services that get informed about power and session events.
codecasternl.github.io/WindowsServiceExtensions/
Topics
windows-service
Resources
Readme
MIT license
Activity
Stars
2 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Used by
Contributors
Languages