Another Reading List

A .NET Manager’s Perspective on F#

Even though the title says it’s a manager’s perspective, the post actually contains elements of functional programming in general. Good read for intro to functional programming.


The beauty of Functional Programming

This post makes argument on why functional programming is good alternative to more mainstream language. I also like how it covers basic functional programming things like pure function, immutability, etc.


Learn all about Distributed Application Runtime (Dapr), Part 1

Dapr is a fairly new open source project that aim to help you to build multi-cloud, platform-agnostics APIs. It has lots of features, such as state management and pub-sub. This Azure Friday video introduces the concept.


Rock, Paper, Scissors, Lizard, Spock – Sample Application

Microsoft code example to demonstrate microservices that use multilanguage and built in Azure.


Bye bye Postman ! Let’s share your REST API calls in team, easily !

In the world of microservices, tools like Postman is a must today. REST Client is Postman-like, but better. With VS Code extension and versioning in your favorite source control, this is going to be replacing my Postman.


New Year Reading List

An Introduction to DataFrame

The cool in-memory schema-on-read DataFrame that is widely used in Python and other machine learning platform (Apache Spark, Databricks, etc) is coming to .NET. It does remind me of `DataSet` and `DataReader`.


Memory-wise apps with C# .NET

Very nice post by Ali, compiling from different sources and lay out how to write memory-efficient C# app.

20 Predictions about Software Development trends in 2020

An interesting perspective about what’s coming in 2020. From a quick glance, it looks like reasonable predictions.


Top 7 Modern programming languages to learn now

Rust is on the top, followed by Go. Two modern language which popularity has been gaining a lot of momentum lately. This post explains the basic of modern programming language and benefits of languages like Rust and Go.


Atomic Design Methodology

Online book by Brad Frost to explain the concept of atomic design. It’s a concept that mimic biological molecules and construct UI elements in a modular way for re-usability and maintainability.


C# Check if PropertyType is Null

You want to check if a property’s PropertyType is nullable. In the example below, only property `IsStudent` is nullable.

User.cs

public class User
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public bool? IsStudent { get; set; }
}

Checking if PropertyType is nullable is useable when adding column to `DataTable` object. If column to be added is nullable type, we need to explicitly set it.

To check if PropertyType is nullable, we can use `System.Nullable.GetUnderlyingType(Type nullableType)`, see example below and reference here.

public void GetUsers()
{
    System.Reflection.PropertyInfo[] properties = typeof(User).GetProperties();
    System.Reflection.PropertyInfo[] readableProperties = properties.Where(w => w.CanRead).ToArray();
    foreach (var property in readableProperties)
    {
        var propertyType = property.PropertyType;
        if (System.Nullable.GetUnderlyingType(propertyType) != null)
        {
            // It's a nullable type
        }
        else
        {
            // It's not a nullable type
        }
    }
}

Reference
Stackoverflow

Iterator, Enumerator and Yield Keyword

Note: The example code below is only used to demonstrate my point, by all means it’s not SOLID.

In Object Oriented Programming
Iterating is a process of repeating similar steps or functions.
Enumerating is an action of going through an entire collection of objects.

In C#
Iterator refers to set of functions to be executed on a collection.
For example:

Func<User, User> deactivate = (User u) =>
{
    u.IsActive = false;
    return u;
};

Enumerator refer to an object type that result from iterating through a collection.
For example:

IEnumerable<User> result = Users.Select(x => deactivate(x));

Complete code:

public class User
{
    public bool IsActive { get; set; }
}

public IEnumerable<User> DeactivateUsers()
{
    User[] Users = {
        new User { IsActive = true },
        new User { IsActive = true },
        new User { IsActive = true }
    };

    Func<User, User> deactivate = (User u) =>
    {
        u.IsActive = false;
        return u;
    };

    IEnumerable<User> result = Users.Select(x => deactivate(x));
    return result;
}

Yield Keyword
Yield keyword allow you to indicate that the code where it is being used is an iterator. The code must return a type of IEnumerable or IEnumerable<T>.

Continue from example above. We can write it different way, such as:

public IEnumerable<User> DeactivateUsers()
{
    User[] Users = {
        new User { IsActive = true },
        new User { IsActive = true },
        new User { IsActive = true }
    };

    List<User> result = new List<User>();

    foreach (var u in Users)
    {
        u.IsActive = false;
        result.Add(u);
    }

    return result;
}

Or another way, which utilize yield keyword to return Enumerator object for us.

public IEnumerable<User> DeactivateUsers()
{
    User[] Users = {
        new User { IsActive = true },
        new User { IsActive = true },
        new User { IsActive = true }
    };

    foreach (var u in Users)
    {
        u.IsActive = false;
        yield return u;
    }
}

References:
MSDN
Stackoverflow

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.

Reference: https://stackoverflow.com/a/17179923