Category: .NET Core

As I look below , the code is a small part of what has been done – documentation, test, CI /CD

The src folder has this number of lines / words ( obtained with Powershell

Get-ChildItem -r “src” |?{!$_.PSIsContainer} | Select-Object { Get-Content $_.FullName  | Measure-Object -Line -Word  | Select-Object  -Property Lines,Words }

@{Lines=6; Words=6}
@{Lines=20; Words=112}
@{Lines=36; Words=154}
@{Lines=8; Words=39}
@{Lines=36; Words=131}
@{Lines=27; Words=53}
@{Lines=35; Words=135}
@{Lines=33; Words=86}
@{Lines=24; Words=84}
@{Lines=9; Words=14}
@{Lines=10; Words=16}
@{Lines=18; Words=78}
@{Lines=16; Words=31}
@{Lines=24; Words=45}
@{Lines=63; Words=143}
@{Lines=11; Words=41}
@{Lines=35; Words=86}
@{Lines=37; Words=65}
@{Lines=50; Words=99}
@{Lines=15; Words=30}

( And does not count the yaml for CI )

That counts for 513 lines and 1448 words…

So the code is a small part od the application …

HealthCheckVersion

Preparing a dll to be deployed to NuGet mneans to me:

1. XML documentation

2. Treat Warnings as errors

3. Adding sources to the nuget package

4. Versioning the package, adding description, licence and so on

5. Generating CD in artifacts

6. Deploying to NuGet

7. Adding Badge with Nuget and Licence to the readme

Where are the modifications:

1. In the .csproj – adding description
2. In the docker yaml – running dotnet pack
3. In the batch file that run the docker – collecting pkg folder with nuget package
4. In the CI yaml file for Github – collecting nuget package to the artifacts
5. In the readme  – using badge from shields.io

The modifications are at https://github.com/ignatandrei/HealthCheckVersion/tree/DeployNuGet

HealthCheckVersion

Now it is time to see a test application. For this I create a new .NET Core 3.1 ASP.NET application, add Xabaril ( to see the end result ) and add reference to my project. The Startup is:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;
using HCVersion;
using HealthChecks.UI.Client;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Diagnostics.HealthChecks;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.HttpsPolicy;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

namespace NetCore31HC
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            string name = Assembly.GetExecutingAssembly().GetName().Name;
            services.AddControllers();
            services.AddHealthChecks()
                .AddCheck<HealthCheckVersion>(name);
            services
                .AddHealthChecksUI(setup =>
                 {
                     setup.AddHealthCheckEndpoint("All", $"/hc");
                 })
                .AddInMemoryStorage()
                ;
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseHttpsRedirection();

            app.UseRouting();

            app.UseAuthorization();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
                endpoints.MapHealthChecks("/hc",new HealthCheckOptions()
                {
                    Predicate= _=> true,
                    ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse
                });
                endpoints.MapHealthChecksUI();
            });
        }
    }
}

And so I figure out the fact that I should not hardcode the name of the HealthCheck , but to put dinamically.  So I change also the readme file to acknowledge that.

Code at https://github.com/ignatandrei/HealthCheckVersion/releases/tag/testApp

HealthCheckVersion

Now it is time to write some code .  However, the implementation should be in a different class than the health check itself – to can be tested.

The code is as follows:

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.CompilerServices;

[assembly: InternalsVisibleTo("TestHealthCheckVersion")]

namespace HCVersion
{
    internal class HCV
    {
        static Version versionEntry;
        static Version versionHCV;
        static HCV()
        {
            var ass = Assembly.GetEntryAssembly();
            versionEntry = ass.GetName().Version;
            versionHCV = Assembly.GetExecutingAssembly().GetName().Version;

        }
        public string GetStartingAssemblyInformation()
        {
            return versionEntry.ToString();
        }
        public string GetHCVAssemblyInformation()
        {
            return versionHCV.ToString();
        }
    }
}

The internals visible to is for running tests successfully.

The code for getting the real Health Check is

using Microsoft.Extensions.Diagnostics.HealthChecks;
using System;
using System.Collections.Generic;
using System.Dynamic;
using System.Threading;
using System.Threading.Tasks;

namespace HCVersion
{
    public class HealthCheckVersion : IHealthCheck
    {
        public Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default)
        {
            var hcv = new HCV();
            var res = HealthCheckResult.Healthy(hcv.GetStartingAssemblyInformation(),
                new Dictionary<string, object>()
                {
                    {"Entry",hcv.GetStartingAssemblyInformation() },
                    {"HCV",hcv.GetHCVAssemblyInformation() }
                });

            return Task.FromResult( res);
        }
    }
}

You will find the code at https://github.com/ignatandrei/HealthCheckVersion/releases/tag/testWorks

HealthCheckVersion

Now it is time to add tests . Even if will not compile, the tests should show how the application behaves. Here are the tests:

using System;
using Xunit;

namespace TestHealthCheckVersion
{
    public class TestHCV
    {
        [Fact]
        public void TestStartAssemblyVersion()
        {
            #region Arrange
            var hcv = new HCV();
            #endregion
            #region Act
            string v = hcv.GetStartingAssemblyInformation();
            #endregion
            #region Assert
            Assert.Equal("1.0.0.0", v);
            #endregion
        }
        [Fact]
        public void TestHCVAssemblyVersion()
        {
            #region Arrange
            var hcv = new HCV();
            #endregion
            #region Act
            string v = hcv.GetHCVAssemblyInformation();
            #endregion
            #region Assert
            Assert.Equal("1.0.0.0", v);
            #endregion
        }
    }
}

The code ( again, even if not compile ) it is at https://github.com/ignatandrei/HealthCheckVersion/releases/tag/addingTests

HealthCheckVersion