DEV Community: Isaac Ayodeji Ikusika

Using Git on Visual Studio

Isaac Ayodeji Ikusika — Mon, 23 Jan 2023 18:05:26 +0000

Visual Studio is a common tool with dotnet developers. It is an IDE where you can do all your developments without needing any other tool, even database management software. Last week, I saw someone who has Visual Studio use git bash to manage their git repo. I showed them how to use the git tool on the IDE and thought to write something about it.

You can clone an existing repo or start a new project entirely from Visual Studio without having to use any terminal. Everything you need is already in the IDE.

Let us start with cloning an existing repo.

When you open your Visual Studio (version >= 2019), you get this screen.

Let's assume you have a repo you want to clone.

Click on "Clone a repository" and you will get this page

Put the link of the repo you want to clone and click on clone

Voila, you have successfully cloned a repo.

To create a new repo from a new project, follow these steps:

Create your project

After your project is created, click on the "Git changes" tab beside the Solution Explorer.

If you cannot find the "Git changes" tab, click the View tab at the top of Visual Studio, you will find "Git changes" there.

When the Git changes tab come up, click on "Create new repository" and you will get this page

Fill the form with everything you want and you are good to go. Subsequent changes can be made in the "Git changes" tab.

NB: You must have your git set up before you can do all these. You may get some prompt to set up your git if you have not.

C# Open-Source Projects for beginners

Isaac Ayodeji Ikusika — Fri, 09 Dec 2022 15:26:05 +0000

Projects to contribute to:

Blazor-Spinner-CSS - 90% CSS and 10% C#
wj.Ocelot.Configuration - 100% C#

Many developers and beginners want to contribute to opensource projects, but they find it hard to due to these reasons and more:

Advanced projects: Most of the available projects are too advanced for beginners. A glance at the first code file already discourages them, not to mention the senior contributors of that project.
Inadequate open-source projects: This can also derive from the first point. I do check trending opensource C# projects every day and what I see are mostly official Microsoft projects. There are fewer individual projects available, well, maybe not trending.

These two points said, I have taken it upon myself to look for opensource C# projects and update this post with them.
If you find some, please add in the comments too.
Thank you 😊👨🏿‍💻👩🏿‍💻

Type safety and strong typing—what are these terms?

Isaac Ayodeji Ikusika — Sun, 09 Oct 2022 09:41:08 +0000

"C# is a strongly typed and type safe language". This is one of the first sentences you see as a C# newbie. I did not really care about the meaning of these words when I started out and I think it mostly is because I only saw them as a features of C# and nothing to worry about.

I understood that you cannot implicitly assign some types to each other and that was just it. I also believed that type safety and strong typing have the same meaning.

But I was wrong.

The type safety feature of a programming language simply means the language only allows you to perform the operations allowed by a data type.
Take for example, you cannot perform a IsNullOrEmpty() check on an integer value in C# because it is only allowed on string types.

This permission can happen during runtime and/or compile time, and that is when strong (or static) typing comes in. Strong typing means the permission check will happen at compile time while weak typing means the check will happen at runtime by throwing an exception.

In our example above, the compiler will tell us cannot convert from int to string, making C# strongly typed and type safe.

JavaScript conversely is weakly (or dynamically) typed but type safe. An example of this is how it provides you with a well-defined way to convert a string to an integer, but only gives you an error at runtime when you are parsing the wrong string.

It is advised to use generic collections in C# because the non-generic ones are not type safe. Check the examples below:

using System.Collections

//Stack
Stack myStack = new();
myStack.Push("Hello");
myStack.Push(23);

//Queues
Queue myQ = new();
myQ.Enqueue("Hello");
myQ.Enqueue(23);

//ArrayList
ArrayList myAL = new();
myAL.Add("Hello");
myAL.Add(23);
myAL.Add(DateTime.Now);

Notice that these types allow addition of any data type in them, unlike generic ones, for example:

using System.Collections.Generic

❌
Stack<int> myStack = new();
myStack.Push("Hello"); // => compile time error because the only int type is allowed
myStack.Push(23);

✅
Stack<int> myStack = new();
myStack.Push(80);
myStack.Push(23);

User-defined Conversions: Conversion between Custom Types

Isaac Ayodeji Ikusika — Sat, 20 Aug 2022 06:18:00 +0000

Have you ever got this compile time error error CS0029: Cannot implicitly convert type 'string' to 'int'? This happens when you want to pass a string value into an int variable.

var count = 1;
count = "20"; //you get the error

Because C# is statically typed, it will not allow it, hence, the error.

JavaScript is dynamically typed at compile time, so it allows conversion of any type to another:

var count = 1
count = "20" // no error

Another instance where you get the error in C#:

long count = 100;
int myIntCount = count;

We can only solve this problem by converting from one type to another.

Let's talk about the main kinds of type conversion we have in C# dotnet.

Implicit conversion: This is straightforward. No exception throw, no data lost. The conversion always succeeds. Example of this is when you are converting a small numerical type to a larger one:

int count = 30;
long numberOfCount = count;

Explicit conversion: This is required when information might be lost in the conversion or when the conversion does not just succeed. Here, we use cast expression. An example is converting a larger numerical type to a small one:

long count = 30;
int numberOfCount = (int)count;

User-defined conversion: This is our main topic. It is performed by writing a custom method that does the conversion implicitly or explicitly. It is done to convert a custom type to another primitive or custom type. There are some rules to follow to get your conversion working.
- the conversion methods must be public and static
- use implicit and explicit keywords to define the kind of conversion you are implementing. As explained above, implicit conversions do not throw exception or data loss unlike explicit conversions.
- The type (or class) where you have the conversion method must be either a source type or a target type of that conversion. This means if you are converting from type A to type B, the conversion can be defined in either of the two types. For conversion from a custom to primitive type, the conversion is defined in the custom type.

Let's look at an example.


public class Person
{
    private readonly int age;

    public Person(int age)
    {
     //we added a constructor so we could initialise this type with a value 
//and then add a check and throw an exception. 
//It is not compulsory you do this.
     if (age < 16)
         throw new ArgumentException("You are too young for this conversion.");
     this.age = age;
   }

    public static implicit operator int(Person person) => person.age;
    public static explicit operator Person(int age) => new Person(age);

    public override string ToString() => $"I am {age} years old";
}

In the code above, we have a Person type that we want to convert to an integer and back.

Because age field in Person is an integer and can be easily converted to int without throwing an exception, we use an implicit conversion, hence,
public static implicit operator int(Person person) => person.age;

This is not true for a conversion of int to Person because it naturally cannot occur implicitly and it could throw an exception if the age is less than 16. So, we do an explicit conversion:

public static explicit operator Person(int age) => new Person(age);

Now let's test our conversion:


var person = new Person(17);

int number = person; //converting Person type to integer
Console.WriteLine(number);  // output: 17

Person anotherPerson = (Person)number; //converting integer type to Person
Console.WriteLine(anotherPerson);  // output: 17

That was conversion of a custom type to primitive type and back.

Now let's look at conversion of a custom type to another.

Let's add another type:


public class Employee
{
    public string Name { get; set; }
    public int Age { get; set; }

    public static explicit operator Person(Employee employee) => new Person(employee.Age); //conversion of Employee to Person

}

There is nothing particularly different from what we explained before in this code. We are converting from Employee to Person, so we have a conversion method that does that, using the explicit keyword because of an exception that could happen.

Please note that we can have this method on the Person class.

Testing this, we have:


var employee = new Employee {
    Age = 23,
    Name = "John"
};

Person myEmployeePerson = (Person)employee;
Console.WriteLine(myEmployeePerson.ToString()); //output: I am 23 years old

What I enjoy about C# is its extensibility. You should make use of this every chance you get. Type conversion is one of them and it will help you write cleaner code.
You can read more about this on Microsoft docs.

Understanding the Enumerable.Aggregate method in LINQ

Isaac Ayodeji Ikusika — Sun, 07 Aug 2022 08:44:00 +0000

TL/DR

the Aggregate method is an extension method of collections that inherit from IEnumerable
the method returns only one value of any type
It is an accumulation function same as sum, count etc.
it has 3 overloads

Some weeks ago, I had to display the expected total amount of money to be debited from a list of account in a specific year, month and week, starting from the first day the account was added to the system, based on a condition.

This is different from the summation of all the money to be debited from the account, because:

there is a condition to be followed in each iteration of the list of accounts
my return value is a tuple i.e. a tuple of three int values representing week, month and year deductions

The preferred method to use in this case is the Aggregate method. It is present in all C# collections that inherits from IEnumerable.

The Aggregate method performs an operation on each element in a list, taking the previous operations into account. For example, it performs an operation on the first two elements of a list and uses the result to operate on the third element and on and on to return a single value.

Consider this:

int[] numbers = { 1, 2, 3, 4, 5};

//we use aggregate to get the summation of the elements of the list

int summation = numbers.Aggregate((a, b) => a + b);

//summation will be 1 + 2 + 3 + 4 + 5 = 15

Accumulation Function

The Aggregate method is an accumulation function. An accumulation function combines the rows in a collection, performs an operation on each one of them and returns a single value. There are different accumulation functions in LINQ: Sum, Max, Min, Count and Average, but the Aggregate method can perform all the operations these methods perform and more.

One other advantage of Aggregate is that it performs operations on a collection of any type, unlike others that only work with numerical data types.

Consider this:


//flatten a list of countries to a string separated by comma

string[] countries = {"Nigeria", "Ghana", "Togo"};

string countriesToString = countries.Aggregate((a, b) => a + ", " + 
  b);

//countriesToString will be "Nigeria, Ghana, Togo"

Overloads of the Aggregate Method

The Aggregate method has three overloads, the first one is explained and used above.
However, I will add the signature of the first overload here and explain in C# terms.
The three overloads are:

1. public static TSource Aggregate<TSource>(this IEnumerable<TSource> source,  
Func<TSource, TSource, TSource> func);

2. public static TAccumulate Aggregate<TSource, TAccumulate>(this IEnumerable<TSource> source,  
TAccumulate seed,  
Func<TAccumulate, TSource, TAccumulate> func);

3. public static TResult Aggregate<TSource, TAccumulate, TResult>(this IEnumerable<TSource> source,  
TAccumulate seed,  
Func<TAccumulate, TSource, TAccumulate> func,  
Func<TAccumulate, TResult> resultSelector);

The aggregate method is generic, meaning it takes and returns any type, hence, the Aggregate<TSource> and others.
TSource here is the type of the elements of the Enumerable we are aggregating over. The this keyword here shows that the Aggregate function is an extension method of IEnumerable.
source is the collection we are aggregating over.
Func<TSource, TSource, TSource> is a delegate that returns the last TSource.

This is the same for other overloads. It represents the accumulator operation to be invoked on each element of the collection.

The second and third overloads have a parameter called seed i.e. TAccumulate seed.

This represents the initial accumulator value. It could be any type, it is saying, "start with this value".

The value of this seed determines the return value of the Aggregate

Let us use our numbers example from above.
Let's say we want to add 10 to the sum before adding other elements, this is what we do:

int[] numbers = {1, 2, 3, 4, 5};

//we use the seed parameter:

int summation = numbers.Aggregate(10, (a, b) => a + b);

//summation will be 10 + 1 + 2 + 3 + 4 + 5 = 25

The last overload has an extra delegate Func<TAccumulate, TResult> resultSelector, which is a function to transform the final value into the result value we want.

It means since the Aggregate value returns only one value, we can decide to perform another operation on the result we got.

Let's practice this with our countries example from above.


//flatten a list of countries to a string separated by comma
//add another west African country to the start of the list
//then convert these countries to upper case

string[] countries = {"Nigeria", "Ghana", "Togo"};

string countriesToUpper = countries.Aggregate("Liberia", (a, b) => a + ", " + 
  b, countryString => countryString.ToUpper());

//countriesToUpper will be "LIBERIA, NIGERIA, GHANA, TOGO"

NB: There is a better way to write the code above. We can convert the countries to upper case without the use of this overload.

Instead of using a lambda, we can use define a method outside the code block and use it inside the Aggregator method.

int[] numbers = {1, 2, 3, 4, 5};

//we use the seed parameter:

int result =  numbers.Aggregate(0, (a, b) =>
{
    return doMathsOnNumbers(a, b);
});

int doMathsOnNumbers(int first, int second)
{
    if (first > second)
        return first - second;
    return first + second;
};
//result will be 7

This method is fun and you should try it out. It sure will come handy one of these days.
You can read more on the Microsoft docs for this method.

Happy coding. 🚀

More on Number Systems: Working with Base Numbers: Part 2

Isaac Ayodeji Ikusika — Sun, 31 Jul 2022 08:39:42 +0000

The first part of this topic introduced and took us through number bases and converting them to base 10.
This post will explain what base 16 numbers are and how to convert from base 10 to other numbers.

Hexadecimals
This is base16. It is represented with numbers and alphabets A to F.
Beginners think it is a complex base because of the alphanumeric representation, but it is not, it is just like the other ones. The alphabet is just a way to make the numbers cleaner. They represent numbers 10-15 because 16 is the maximum number in this base.
For example:
9 base 10 is 9 in base 16
4 base 10 is 4 in base 16
10 base 10 is A in base 16
11 is B
15 is F
16 is 10
493 is 1ED
The reason for the inclusion of the alphabets is, HEX numbers get to tens of numbers in base 10. For example, the conversion of 493 gives 1 14 13 which is confusing because everyone would read 11413 at a glance, hence a way to make it clearer for readers: 1 E(14) D(13) i.e. 1ED 😀.

Colour white in CSS, #fff is a hexadecimal number, which, when converted, gives 4095. Wonder why colour codes are represented this way?

Conversion of decimal numbers to other bases
We learned last week that base 10 numbers are decimals. So let us see how to convert these numbers to other bases.

4 to base 2
11 to base 8
493 to base 16

In the last conversion from other bases to decimal, we used multiplication. Here, we are going to use division.
To convert a decimal number to another base, you keep dividing it by that base until you have 0 left and the remainder is less than that base then you read the remainder from bottom to top.

4 => 4/2 = 2 r 0
2/2 = 1 r 0
1/2 = 0 r 1
our answer is 100.

11 to base 8

11 => 11/8 = 1 r 3
1/8 = 0 r 1
our answer is 13

493 to base 16
493 => 493/16 = 30 r 13
30/16 = 1 r 14
1/16 = 0 r 1
we have 1 14 13, which is 1ED in hexadecimal

To convert from a base other than decimal to another, you need to convert to decimal before you do the final conversion.

You can do these conversions on your calculator, but I like to think it is a good practice to understand how things work under the hood.

Enjoy. 🚀

More on Number Systems: Working with Base Numbers: Part 1

Isaac Ayodeji Ikusika — Sat, 23 Jul 2022 05:28:00 +0000

In my previous post, I talked about working with binary and bitwise operators. I realized that for us to really understand how these operators work, we need to understand two things:

base numbers
how the operators work with these numbers under the hood

This post talks about base numbers, and how we come by them.
It is divided into bits (permit my pun), so the post will not be too long and boring.

Base numbers are numbers that are used to represent numeric values on the number system. They are basically numbers. Nothing more.
They just occur in other bases, the most popular being base10 or Decimal.
base 2 is Binary
base 8 is Octal
base 16 is HexaDecimal

The way to represent these bases is by saying n subscript base, e.g., 2 subscript 8 is 2 base 8. I cannot find a way to represent this in this post.
Base 10 numbers do not use these subscripts because we assume all numbers are in base 10 unless specified.
Numbers can occur in many bases, these are just the most common ones.
Base10 numbers are the traditional numbers we are used to: 1, 2, 3...9, 10.

Base numbers follow a pattern. Each base has a maximum representation of that base minus 1. For base 10, it is 9, 2 is 1 and 8 is 7. We are going to exemplify this with base10.
1, 2, ... 8, 9, 10, 11, 12, 13...98, 99, 100, 101 etc.

Notice that when the "numbers" get to 9, they went back to 1 and 0, same as when it got to 99, we added two zeros to the right side of 1. That is how tens, hundreds, thousands, etc. are represented - by the rightmost number.
This same pattern goes for other bases:
2 in base two is 10
8 in base eight is 10
16 in base 16 is 10 etc.

How this works is that the numbers start off as unit, then when you get to the maximum representation, you go to tens, and keep adding 1 till you get to the maximum number again.
That is why:
11 is 11 in base 10
3 is 11 in base 2
9 is 11 in base 8
17 is 11 in base 16.

We are going to learn more about base 2 and base 16 in the next lesson.

Conversion across Bases

First, we are going to talk about converting from other bases to base 10, then from 10 to other bases, and then across bases that are not 10.

Conversion from a base to base 10 is straightforward. You just raise each unit of the number to the power of its bases reducing it by index of each unit of the number.

For example, let's convert these numbers to base 10:

11 base 8
207 base 8
11 base 2
81 base 4

11 base 8 = 1*8^1 + 1*8^0 = 8 + 1 = 9 base 10
207 base 8 = 2*8^2 + 0*8^1 + 7*8^0 = 64 + 0 + 7 = 71
11 base 2 = 1*2^1 + 1*2^0 = 2 + 1 = 3
81 base 4 = 8*4^1 + 8*4^0 = 32 + 8 = 40

Please note that ^ represents power e.g. 2^2 is 2*2 = 4, 3^3 is 3*3*3 = 24

This post is, as a matter of fact, more about mathematics than coding, but trust me, you need it to advance in your career as a software developer.
Please stay tuned for the continuation. 😀

Enum Flags in C#

Isaac Ayodeji Ikusika — Sat, 09 Jul 2022 07:36:29 +0000

TL;DR

Use the Flags attribute on your enum type
Use bit values as the enum representation because it allows you to use bitwise operators
Add up enums into a variable using the "|" operator
Use the HasFlags() method to determine whether one or more bit fields are set in an enumeration value.

You must have worked on a feature that involves switching between multiple options, and if you are a C# developer, you know you could easily do that with the enum type.

The enum type is a built-in value type which is the short form of the Enumeration type. Microsoft describes the enum as a type defined by a set of named constants of the underlying integral numeric type. This means that instead of having your options as numerical values, enums provide a way for you to use their representation.

A typical enum type is like this:

enum ColorTypicalEnum: int
{
   None = 0,
   Black = 1,
   Red = 2,
   Green = 4,
   Blue = 8
}

The int type in front of the type tells the compiler the numerical type you want your enum represented as.

Flags in enum is an attribute that indicates that an enum type can be treated as a bit field. These bit fields are now grouped in a set of flags.
Here, you can represent the int in form of the enum fields as a bit. This makes working with the enum easier than the typical type.

[Flag]
enum ColorWithFlag: int
{
   None = 0,
   Black = 1,
   Red = 2,
   Green = 4,
   Blue = 8,
   ... //after some really, really long color listing
   ThisColorIsSoRare = 268435456
}

The bit values here would be hard to comprehend and even easier to get wrong, e.g., how is ThisColorIsSoRare = 268435456? Good question, that is why you use bitwise operations instead.
So, we use the left shift operator:

[Flag]
enum ColorWithFlag: int
{
   None = 0,
   Black = 1,
   Red = 1 << 1, //2
   Green = 1 << 2, //4
   Blue = 1 << 3, //8
   ...
   ThisColorIsSoRare = 1 << 60, //268435456
   AllColors = int32.MaxValue
}

Now, to the most interesting part of using flags. Because the Flag attribute allows you to use bitwise operations, you can easily do cool stuff like this:

// group all the primary colors (i.e. red, blue, and green) into one variable
var primaryColors = ColorWithFlag.Red | ColorWithFlag.Green | 
                    ColorWithFlag.Blue

//this sums the integer representation of the color in the `primaryColors` variable, so if you do

var primaryColorsIntegerValue = (int)primaryColors;
//you would get 14

You can check if a color exists in the primary color variable using the HasFlag (which inner workings is a bitwise operation) method.

var isPrimaryColor = primaryColors.HasFlag(ColorWithFlag.Black);
//this returns false

There is a massive chance you use Enums in your present or next project, so you be ready to use this knowledge of flags. It will make your code cleaner.

Please do check the provided links for a better understanding and examples.

Test Driven Development - Explained

Isaac Ayodeji Ikusika — Thu, 04 Nov 2021 04:45:29 +0000

Test Driven Development (TDD) in layman's language is a way of testing a piece of code before writing the actual code.

The first time I saw this explained, I was confused. It was completely abstract to me - How or why would I test a code I have not written? I think I felt this way because most of the research I did concerning this topic was always about adding two numbers or did not use [near] real examples, so I'm going to use my story to explain this term in this article.

I used to work in a company that writes API for financial companies, so I was given a task - display all active customers that have more than $400 in their account.
Easy task! I wrote the code:

var activeCustomersWith400 = Customers.Where(cus => cus.IsActive && cus.Balance > 400)

//pardon my C# and LINQ 😏

Yes, that's correct, then I wrote the test for it after manually testing/making sure my code works - by debugging. That is not TDD approach.

TDD approach is:

Creating test methods (or a class with methods) specifically for that task to:
- test that the customers returned are active
- test that they have $400 in their account
- any other test you want, making sure they go along with the requirements of the task.
Running the tests. They will obviously fail, or your IDE or compiler complains about errors, since you do not have the function that does the task in your actual code yet.
Fix the errors by writing the function, then run the test again. Keep running the tests and making changes to your function until all the tests pass.

In conclusion, TDD approach is better than just jumping in the code because:

It defeats the need for debugging. This is because you already laid down how you want your code to behave in the tests, you just write code to follow that behavior. This is the strong point of TDD.
It makes you think about small chunks of code at a time. This is required in functional programming.
It improves productivity because developers have to focus on that part of code they are working on.
You do not need manual testing to know your code works.
One important advantage of TDD to me is how it helps in Behavior driven development (BDD).

Some people argue that TDD wastes time, maybe they are right, but to me, the advantages listed above outweigh this argument and I can say for a fact that it does not waste time, especially when you have your test setup ready from onset.

Thank you for reading.