DEV Community: Ballcapz

How I added a dark theme to my website!

Ballcapz — Wed, 14 Apr 2021 14:50:57 +0000

Using Detect Dark mode

Changing the color scheme of a website is basically a requirement these days, and I decided to add a nice and simple version for my new, lightweight blog.
A few weeks ago, I discovered a new media query while browsing the web, and I knew I had to try it out!

I ended up using the media query of prefers-color-scheme to get the user's preferred color scheme, instead of using a toggle switch for now.

I will eventually end up with a nice toggle or switch somewhere, but I really wanted to just play around with this media query I found out about!

It ended up being far simpler, and acts almost as a "native" application for the user, being that it ties into the browser's preferred color scheme.

The media query is relatively straight forward, and I implemented it like this.

@media (prefers-color-scheme: dark) {
  :root {
    --black: #ffffff;
    --white: #232c33;
    --off-white: #111111;
    --blue-hl: var(--pewter);
    --blue: #3a6a92;
  }
}

And in my case, right before this media query I am using the following to set my normal colors for my site:

:root {
  --blue: #172a3a;
  --blue-hl: #3a6a92;
  --black: #232c33;
  --pewter: #76949f;
  --white: #ffffff;
  --off-white: #fdfdfd;
}

All in all, it took me about 15 minutes to setup, just tweaking the colors when the switch to darkmode happened, and I had my website ready to go!

Install Spacemacs on Windows

Ballcapz — Sat, 18 Jul 2020 17:32:29 +0000

General Install

Download the .zip archive by following the Windows instructions on the GNU Software Website. I decided to go with the most recent version at this time for windows (emacs 26.3).
Move the .zip to wherever you would like to have emacs installed and extract all (either 7zip or the native windows unzip in file explorer will work)
Once emacs is unzipped, navigate to the emacs-<version>/bin directory in file explorer, copy the path (by clicking the the top bar and copying) so we can add it the the path
Open up environment variables, find the system path environment variable (the ones on the bottom), click edit, then add, and finally paste the emacs path.
For easier access to open emacs, navigate back to the bin folder and find the runemacs.exe file; right click on it and select send to > desktop(create shortcut) and create a shortcut on your desktop to start emacs easily.

Congratulations Emacs is installed (and possibly ready to use?)

I'm am going to go a bit further and install spacemacs as the config because it gives a nice base to work off, provides easy extension points, and I personally prefer vim style navigation and editing as it is what I started on (as well as being easier on the wrist most of the time)

Install And Configure Spacemacs

Visit the Spacemacs website
If you have opened emacs, locate your .emacs.d file, which should live in %USERPROFILE%\appdata\roaming\.emacs.d, and delete it. Back it up or add it to source control if you want it for future use.
Run the following command, replacing %USERPROFILE% with the path to your appdata folder; In my case C:\Users\zach\appdata\roaming

git clone https://github.com/syl20bnr/spacemacs C:\%USERPROFILE%\appdata\roaming\.emacs.d

This will put the spacemacs config in the .emacs.d folder.

Finally, open up emacs and run through configuration to get your preferences set up and installed.
From here, the Spacemacs docs give lots of ideas on how to customize and extend your editor and capabilities within emacs.

Useful links

Link To Original Post:
https://www.ballcapz.dev/blog/spacemacs-windows-install/

Adding Dependency Injection to .NET Core Console Applications on Windows

Ballcapz — Wed, 20 Nov 2019 16:22:57 +0000

App.cs

Add App.cs file to the project
Add a Run method to the App.cs file, as shown below

// This is now equivalent to Main in Program.cs
public void Run()
{
    Console.WriteLine("Hello from App.cs");
}

The App.cs class that will be used to run the application.
Program.cs will be used to do the setup and register the IOC container, and the App.cs will contain all of the running console application code.

appsettings.json

Add a json configuration file to the project and name it appsettings.json

Install Nuget Package Microsoft.Extensions.DependencyInjection
Install Nuget Package Microsoft.Extensions.Configuration
Install Nuget Package Microsoft.Extensions.Configuration.Binder
Install Nuget Package Microsoft.Extensions.Configuration.Json
IMPORTANT: Open appsettings.json properties, and change Copy To Output Directory, to Copy if newer or Copy always

Add the following to Program.cs

static void Main(string[] args)
{
    var services = ConfigureServices();

    var serviceProvider = services.BuildServiceProvider();

    // calls the Run method in App, which is replacing Main
    serviceProvider.GetService<App>().Run();
}

private static IServiceCollection ConfigureServices()
{
    IServiceCollection services = new ServiceCollection();

    var config = LoadConfiguration();
    services.AddSingleton(config);

    // required to run the application
    services.AddTransient<App>();

    return services;
}

public static IConfiguration LoadConfiguration()
{
    var builder = new ConfigurationBuilder()
        .SetBasePath(Directory.GetCurrentDirectory())
        .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);

    return builder.Build();
}

This registers the appsettings.json with the .net core Dependency Injection container, and allows us to use the configuration file for things like connection strings and logging directories.

Using Configuration In The App

Dependency Inject the registered configuration

// in App.cs
private readonly IConfiguration _config;

public App(IConfiguration config)
{
    _config = config;
}

Add a configuration section and value to appsettings.json:

{
    "Runtime": {
    "LogOutputDirectory": "C:\\temp\\programLog.txt"
   }
}

Use this configuration in App.cs

public void Run()
{
    var logDirectory = _config.GetValue<string>("Runtime:LogOutputDirectory");
    // Using serilog here, can be anything
    var log = new LoggerConfiguration()
        .WriteTo.Console()
        .WriteTo.File(logDirectory)
        .CreateLogger();

    log.Information("Serilog logger information");
    Console.WriteLine("Hello from App.cs");
}

Register Interfaces with Concrete Objects

Add the files IUser.cs and User.cs to the project
In the Program.cs method ConfigureServices() add:

services.AddTransient<IUser, User>();

Which makes the ConfigureServices() look like:

private static IServiceCollection ConfigureServices()
{
    IServiceCollection services = new ServiceCollection();

    var config = LoadConfiguration();
    services.AddSingleton(config);

    services.AddTransient<IUser, User>();

    services.AddTransient<App>();

    return services;
}

This allows us to write our code against our interface. In order to do so, we need to "inject" the interface into our App.cs

private readonly IConfiguration _config;
private readonly IUser _user;

public App(IConfiguration config, IUser user)
{
    _config = config;
    _user = user;
}

...
// using the IUser
_user.TruncateName("Jerry     ");
...

Conclusion

Setting up dependency injection and configuration in this manner allows us to use configuration easily throughout our Console applicaiton, as well as giving us the ability to program against interface. This helps keep our code losely coupled and testable, along with giving us the ability to extend our application easily beyond the scope of a Console application.

Code Example On Github:
https://github.com/Ballcapz/Console-Application-Dependency-Injection

Link To Original Post:
https://www.ballcapz.dev/blog/dotnet-core-dependency-injection/