Spargine is a collection of open-source assemblies and NuGet packages designed for .NET 10, which I have been developing and maintaining since the release of .NET Framework 2. These assemblies are not only a core part of my projects but are also actively deployed in production environments across several companies I collaborate with.

Get Spargine

You can access the source code and NuGet packages here:

• GitHub: Spargine 10
• NuGet: dotNetDaveNuGet

Modern .NET applications run in increasingly complex environments—multiple runtimes, operating systems, deployment models, and hosting scenarios. Yet many applications still rely on scattered framework calls, ad-hoc helpers, or duplicated logic just to answer basic questions such as Where is my app running?, What environment am I in?, or How many resources do I really have available?

That’s exactly the problem the App class in the DotNetTips.Spargine.Core assembly is designed to solve. The App class is a highly optimized, centralized utility that exposes fast, consistent access to application metadata, runtime details, and environment information. Every method and property is performance-focused, making it safe to use even in logging, diagnostics, and high-throughput scenarios.

Instead of reinventing this logic in every project, the App class gives you a single, reliable abstraction for interacting with the runtime environment—cleaner code, fewer bugs, and better insight into how your application is behaving.

Key Features

The App class provides a comprehensive set of methods that simplify working with application state, culture, diagnostics, and runtime behavior.

Culture and Localization

• ChangeCulture(string cultureName / CultureInfo culture)
  Updates the application culture for culture-sensitive operations.
• ChangeUICulture(CultureInfo culture)
  Modifies the UI culture used for localized resources.
• GetCultureNames(CultureTypes cultureType)
  Retrieves culture names based on the specified culture type.
• GetLocalizedString(ResourceManager resourceManager, string key, string cultureName)
  Fetches localized strings from a resource manager.

Application State

• ClearAppState()
  Clears all application state entries.
• GetAppState(string key, object? defaultValue)
  Retrieves a value from application state safely.
• RemoveAppState(string key)
  Removes a value from the application state.
• SetAppState(string key, object value)
  Stores a value in a thread-safe, case-insensitive application state dictionary.

Runtime and Environment

• ExecutingFolder()
  Returns the folder path containing the entry assembly.
• GetCommandLineArguments()
  Parses command-line arguments into a read-only dictionary.
• GetEnvironmentVariables()
  Retrieves environment variables for the current process.
• GetProcessorInformation()
  Provides detailed CPU information, including architecture, core count, and speed.
• MaxDegreeOfParallelism()
  Calculates the optimal number of concurrent tasks based on available processors.

Diagnostics and Process Control

• GenerateDiagnosticReport()
  Produces a detailed diagnostic report covering application, OS, framework, and memory information.
• IsRunning()
  Determines whether another instance of the application is already running.
• IsRunningFromAspNet()
  Detects whether the application is executing in an ASP.NET context.
• IsUserAdministrator()
  Checks whether the current user has administrative privileges.
• Kill()
  Immediately terminates the current process.
• RebootComputer()
  Reboots the system programmatically.
• ReferencedAssemblies()
  Loads all assemblies referenced by the running application.
• RunAsAdministrator()
  Restarts the application with elevated permissions when required.

Properties for Application and Runtime Insight

The App class also exposes a rich set of properties that surface critical runtime and system information.

• AppInfo
  Aggregated application metadata such as company name, configuration, version, and memory usage.
• CurrentCulture / CurrentUICulture
  The active culture and UI culture for the application.
• CurrentThreadId
  The identifier of the currently executing thread.
• FrameworkDescription
  A description of the .NET runtime hosting the application.
• InstalledUICulture
  The system’s default UI culture.
• OSArchitecture / OSDescription
  Operating system architecture and description.
• ProcessArchitecture
  Architecture of the current process.
• ProcessId / ProcessName / ProcessPath
  Core process identification details.
• StackTrace
  The current thread’s stack trace for diagnostics.
• WorkingSet
  The amount of physical memory currently used by the process.

Practical Use

In real-world applications, the App class shines most in diagnostics, logging, and environment validation. I frequently rely on it to capture detailed runtime context during application startup, exception handling, and performance analysis. Because the APIs are optimized and centralized, I can gather rich diagnostic data without cluttering my code or paying an unnecessary performance penalty.

Here are a few examples of data that can be gathered.

AppInfo

Company: "dotNetTips.com"
Configuration: "Release"
Copyright: "© David McCarter. All rights reserved."
Description: "Example App"
FileVersion: "18.0.125.55701"
MemoryAllocated: 5789824
Product: "My App"
ThreadAllocatedBytes: 3033712
Title: "My App"
TotalAllocatedBytes: 5774992
Version: "15.0.0.0"

GenerateDiagnosticReport()

Application: MyApp v15.0.0.0 OS: Microsoft Windows 10.0.19045 (X64) Framework: .NET 10.0.3 Memory Usage: 55 MB

GetProcessorInformation()

ActiveProcessorMask: 0x0000000000000fff
AllocationGranularity: 65536
MaximumApplicationAddress: 0x00007ffffffeffff
MinimumApplicationAddress: 0x0000000000010000
NumberOfProcessors: 12
PageSize: 4096
ProcessorArchitecture: X86
ProcessorLevel: 6
ProcessorRevision: 42243

Summary

The App class in DotNetTips.Spargine.Core provides a fast, reliable, and centralized way to interact with application metadata, runtime details, and environment information. By consolidating common tasks—such as culture management, diagnostics, process inspection, and system awareness—into a single, performance-focused utility, it eliminates boilerplate code and improves consistency across your projects. If you need deep insight into how your .NET applications run, the App class is a powerful tool you’ll reach for again and again.

Pick up any books by David McCarter by going to Amazon.com: http://bit.ly/RockYourCodeBooks

If you liked this article, please buy David a cup of Coffee by going here: https://www.buymeacoffee.com/dotnetdave

© The information in this article is copywritten and cannot be preproduced in any way without express permission from David McCarter.