Monday Reading List

Don’t snapshot your UI components, make assertions!

Great post discussing unit test and the reason behind making assertions vs snapshot UI. More of philosophical that hopefully shape how you think about unit testing. Good read.

Something to Know about gRPC in ASP.NET Core 3

gRPC is on the rise! And so is ASP.NET Core 3! But wait, it’s not working in Azure App Service? Head on to this post to learn why. But, hey, maybe it will be fixed soon.

AI Terms Every Beginner Should Know: an Abbreviations Glossary

This is the kind of post I like. I would start learning about AI but hardly can explain it to others. Knowing the terms definitely helps, and it makes you look like an expert!

Hacking ASP.NET apps and turning them onto Zombies

Interesting post about ASP.NET. Even though this is security related, it’s not one of those boring security. It’s about hacking, injecting malicious code into ASP.NET app. And more importantly, how to prevent it.

Fast Data is Forcing New Strategies in DevOps

Probably not worth your time to read. But I do like that it argues real-time streaming data has its own challenge in DevOps. It also offer high-level solutions / approach to the challenge.

Good Reads This Week

DevOps Before and After Kubernetes

This is a fun read, a lil bit of educational, but more of informative IMO. Anoop explains how Kubernetes has changed DevOps: automation. And with idempotency and immutability, we can increase efficiency and economics benefits in DevOps-ing Kubernetes.


Exploring the Visual Studio Test Platform

34-minute video that goes back to basic: unit testing, why we need it and how to do it. But this one goes even deeper, how to do it in Visual Studio, Visual Studio Code and Azure Pipelines, executing tests in parallel, migrating, diagnostics crashes and much more! Worth your 34 minutes.


Think Like A Startup When Launching Your Analytics Program

Build your analytics program with startup mindset. Yes, it may not be a technical read, more of philosophical, but still a good read regardless.


Come discuss your side projects! [July 2019]

I thought this thread is pretty cool, people come together to discuss their own side projects. Get some creative ideas going and some of the projects are actually really cool! This thread is for July 2019, but there is a new thread every month.


ASP.NET Core 3.0 Exception Handling

Have you ever used `try/catch` blocks but still miss some errors? Dino explains a more effective way to trap exceptions that go unnoticed and unhandled in ASP.NET Core 3.0


Go team proposes parametric polymorphism

Generics is coming to Go language! Parametric Polymorphism, a fancy way to say Generics, however, is still in a draft. But, let’s hope it’s going to be released soon.

Unit Test Internal Members

Applies to .Net application in Visual Studio 2010 and up.

Say I have C# project (call it QC project). In the project, I have class that has internal member(s) like this:

namespace QC
    public class PersonService
        public bool PromotePerson(string userName)

        internal bool FindPerson(string userName)

For unit test, I’d created separate project (call it QCTest project). Because internal members can only be accessed in same assembly, I won’t be able to invoke `QC.PersonService.FindPerson(string userName)` method from QCTest project.

To overcome this issue, in `AssemblyInfo.cs` of project being tested (in my case, QC project), simply add

[assembly: InternalsVisibleTo("QCTest")]

After rebuilding my solution, I am able to access `QC.PersonService.FindPerson(string userName)` in my QCTest project.

As an added bonus, if you use mock library like Moq or Rhino and try to mock internal members, you most likely need to add:

[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")]

What is `DynamicProxyGenAssembly2` ?

DynamicProxyGenAssembly2 is a temporary assembly built by mocking systems that use CastleProxy like Moq or NSubsitute. It is generated when the mock is needed and disposed of after the tests are finished.


WebApi ExceptionHandling.ExceptionHandler Sometimes Does Not Handle Global Exception. What ?!

See previous post on how to implement ExceptionHandler.

ExceptionHandler supposed to handle exception globally, but sometimes it does not… what ?!

There are few cases where ExceptionHandler will not capture exception. One of them is when CORS is enabled, see this.

To ensure ExceptionHandling to always capture exception, try:
1. If inherit from ExceptionHandler, override its method `ShouldHandle()`.

        public override bool ShouldHandle(ExceptionHandlerContext context)
            return true;

2. Instead of ExceptionHandling.ExceptionHandler, inherit and implement it’s interface `ExceptionHandling.IExceptionHandler`.

Application Insights Intrumentation Key in Web.config

When using Azure Application Insights in ASP.Net application, by default, Visual Studio insert IntrumentationKey in ApplicationInsights.config.

To allow multiple environments tracking, move IntrumentationKey to Web.config by following this steps:

  1. Remove IntrumentationKey from ApplicationInsights.config. If you have MVC application, don’t forget to modify ApplicationInsights’ script (usually in View\Shared\_Layout.cshtml), replace:

    {instrumentationKey:"your instrumentation key"}


  2. Add new app settings for IntrumentationKey in Web.config under <appSettings>

    <add key="InstrumentationKey" value="your instrumentation key" />
  3. In Global.asax.cs, Application_Start() method, add:

    Microsoft.ApplicationInsights.Extensibility.TelemetryConfiguration.Active.InstrumentationKey = System.Web.Configuration.WebConfigurationManager.AppSettings["InstrumentationKey"];

That’s it for the configuration changes. Everything else is the same including tracking custom event or page view.
With this configuration, you will be able to define InstrumentationKey in Release management for each environments.

String as a Reference Type and Immutable

In .Net, string object is reference type, however when we pass the value like this

void Main()
    string s = "Test";

    Console.WriteLine("TestString: " + s); // Output is: TestString: Test

public static void TestString(string s)
    s = "TestString";

Why is the output “TestString: Test”, we know for sure string is a reference type and we assign new value to our parameter in TestString() method.

Turn out, beside being a reference type, string is also an immutable, which mean its value can’t be modified or changed. So when we assign new value to our parameter in TestString() method, it actually create new string object. It acts like value type but it isn’t a value type, it’s a reference type with immutable behavior.