Vancouver BC Life

Wednesday, September 13, 2023

Browser background color or monitor brightness

Have you been in a situation where you are almost sitting the whole day in front of your browser and going through a document and find that the site's background color is too bright and you are tired of adjusting the brightness in your monitor.

Fear not, as you might not be the first person in that boat. In this article will show you exactly how to fix it.

1. First of all depending on your browser, usually it is `Ctrl + Shift + I` keys that should bring the Developer tools out.

2. Now all you need to do is, either click on the `<html ......\>`, or the <body ......\> tag.

3. You should now, see the `element { ...... }` tag in the right side.

4. Click on it and try to add the key and value like `background-color: darkgrey; ` or a suitable color for your needs.

5. See, if the background color of the page changes. It may not work always but atleast 7 of 10 times it should.

6. If it works, might be, the next part is updating the fonts color. For which you might need to add another key and value like `color: black; ` or a suitable color.

7. If it didn't work, I would suggest to keep on clicking on the sub sections under the `<html ....>` or `div` or `body` tag and keep trying to update the `background-color` element for each of it. Interesting part is when you click on each section, it more or less highlights the area that the specific section is responsible for.

8. One other option is to right click anywhere on the section you like the background color to be updated and select the `Inspect element` option, which should directly open the developer tools with that section.

Hope this article helped to relieve the paint to your eyes. If yes, please see if you like to make a donation in the 'Buy me a pop' button on the side bar but no compulsion.

Tuesday, August 29, 2023

C# vs Java programming comparison

This guide is for those who like to learn Java and are from the C# background or vice - versa or similar who are pretty much versed in it. I have documented the aspects which needs to be grasped and is different from C#.

1. First line of code can be say a Pgm.java file like below.

```
class Pgm
{
    public static void main(String[] args)
    {
        System.out.println("Learning Java!);
    }
}
```
a. The name of the file should be the same as the class inside. Main method is `main` here and string is String here.

2. Inheritance -
a. Use `extends` for inheriting from another class. This can be from one class only.
b. No virtual or override, instead methods of the same signatures are overridden.
c. Use `implements` to implement from an Interface and for multiple inheritance.
d. If not implementing an interface, mark it as abstract. Only abstract classes can have abstract fields.

3. Classes -
a. Avoid modifiers to it, at least when learning. If using public it has to be in its own file.

4. Lambda methods -
Similar to C#, use -> instead, like `Predicate<String> pred = s -> s.length() == 3;` and do `pred.test("111")` which returns `true` if matching the predicate.

5. Compiling the source code.
`javac Pgm.java`

6. Running the program.
`java Pgm`

7. Packages -
Like namespaces, supposed to be the name of the folder but no compilation errors will be issued.
Use like `package abc.def.ghi;`
When compiling, one may have to do `javac -d . Pgm.java` and when running `java abc.def.ghi.Pgm`

8. Statements -
a. All if, else, while and for loops are similar.
b. Switch cases can have multiple with comma separtions like `case SATURDAY, SUNDAY -> "week end";`

9. Encapsulation - No properties here for classes. Create your own getter and setter individual methods.

10. Concurrent List - To make a list concurrent or thread safe, you can do `List newList = Collections.synchronizedList(eles);`

11. Generics seem similar

Monday, August 14, 2023

?? and ??= Null coalescence operators C#

C# introduces the ?? and ??= operators which are known as the Null coalescence operators.

Purpose -
The ?? and ??= operators can help in cases where a comparison is made between two or more variable values and depending on the order in the statement, the variable valu is used.

Say for example there is variable either a and b to be returned by a method. Say if value is needed to be returned if it is not null and if yes, the value b is supposed to be returned.

```
public class NullCoal
{
public static int? Method(int? input)
{
    ....
    ....
    int? a;
    int? b;

    if(input > 10)
    {
        a = input * 6;
    }
    else
   {
        b = input * 7:;
   }

    return a ?? b;
}
}

```
In the above example, a is returned if it is not null or b is returned.

Similarly the ??= operator adds the assignment operation as well, which can be used like

```
int? a = null;
int? b = 1;

a ??= b;
```
where if a is not null, value of b is assigned to it, otherwise nothing happens with the above statement.

The null coalescence operator is a short form for writing the below code.

```
if( a is null)
{
a = 1;
}

```
instead it can be written as

```
a ??= 1;
```
What if there is more than two variables to check, in such cases say like below
```
return a ?? b ?? c;
```
the expression is evaluated from right to left like this
```
return a ?? ( b ?? c)
```

Wednesday, July 26, 2023

Rabbit Message Queue and Redis

In this article I will try to give some overview about why and when to use Rabbit Message Queue and Redis cache. Starting with Redis cache

Redis cache -

Mainly used for caching as call time to server ( say database server ) can delay. Using redis cache saves this time, as it is the cache of the database itself.
- Whenever a database write has happened, a worker class can update the cache to be in sync with the database.
Key value pair type of database supporting strings, int, lists, hash as values.
The list can used as stacks or queues and other data structures as well like linked list, circular queue and all.
Remember, the key has to be in lower case.
Redis say instead of sending many continuous updates in subsequent calls, these can be piped and send as a single call.
Calls can be direct or pub - sub type
StackExchange.Redis is a popular nuget package to perform almost all the database operations in the redis documentation.
redis - cli can be used locally to connect to the database and perform CRUD operations.
Convenience of using regex in calls to retrieve data fastly.

Rabbit Message Queue ( RMQ ) -

Queue or many queues behind an exchange.
The exchange does the routing to the particular queue based on the header information.
Data in a queue can be set to be durable, meaning data is not lost after RMQ is re started. For docker containers make sure to use common volumes across container restart(s).
Data in a durable queue can stay from two to three days.
MassTransit is one nuget package which can be used with different types of Enterprise service bus like RMQ, Azure queue, AWS queue, in memory queue and all without needing to write the adapters for each.
When a message is sent to a RMQ it first goes to the exchange and the exchange routes that message to its queue.
Used mainly for mass data transfers and Mass transit client consumes it almost in no time.
The main reason to use Enterprise service bus is to ensure reliability of the message sent. The recipient server may be busy with some operation(s) unable to provide cycles or bandwidth to consume the incoming messages from the client. These messages can be lost if not addressed in a timely manner, thereby giving poor experience to its caller.
Supports direct messaging to the recipient or publish subscriber mechanism where the Consumer is listening to the queue(s) in the RMQ for any new messages.

Writing Consumer in Mass transit should be as straight forward as implementing the `IConsumer` type and having a task named Consume with ConsumerContext parameter like below.


    public class AfceConsumer :
        IConsumer<AfceMessage>
    {

        public Task Consume(ConsumeContext context)
        {
            Console.WriteLine("Hello {name}", context.Message.Title);
            return Task.CompletedTask;
        }
    }

The above consumer will continuously consume each message one by one in almost no time when the message of type `AfceMessage` is available in the queue.
The AfceMessage can be any reference type like a class or a record or a struct.

Mass transit also has bulk message consumer to consume message in batches.

Asp .Net Configuration

In this article I will give some tips on how one can work with configuration with ASP .Net apps. Almost all or any ASP .Net app anyway have this `Microsoft.Extensions.Configuration.IConfiguration` or simply put it as type `IConfiguration`.

There are usually one or two `json` files `appsettings.json` or or and the `appsettings.Development.json`. These contain settings for the app to use depending on the type of environment the instance is being run on. The first is for production and the later for development environment and more can de added as well.

Now let's say or `appsettings.json` is like below. Most of these config have provision for logging settings. say in production, the default might be `Information` meaning anything below that like Debug or Trace might not be logged. For development, the default might be `Debug` meaning almost all except might be `Trace` may not be logged which deserves another article for sure.

{
"Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
...
...
}
},
"SomeApp": {
    "Host": "192.168.a.l",
    "Email": "abc@comp.co",
"Location":
{
"First": "Gatsby"
}
}

}}

In case we need to retrieve the Host address of our SomeApp, then in the class which is loaded by the ASP .Net server let's say `FirstService` class, the `IConfiguration` can be dependency injected and the app's settings retrieved like below.

public class FirstService
{
public readonly IConfiguration _configuration;

public FirstService(IConfiguration configuration)

{
_configuration = configuration

}

public void RunApp()

{

Console.WriteLine("Host Config - " + _configuration["SomeApp:Host"]);

}

}

The `_configuration["SomeApp:Host"]` should give the address value which is "192.168.a.l", in this case.
The `_configuration["SomeApp:Host:Location:First"]` should give the location value and so on.

Similarly additional configurations as json files can be added to be loaded in the `Startup` or the `Program` class as well. The fetching mechanism need not be a string key, it can be
_configuration.Get<P>() to bind the configuration to type `P` and be retrieved in a more strict type way as well.

Adding newer extension method(s) to struct types C#

In this article, I will demonstrate on how one can add additional methods to existing struct types like int, string, char, long, etc,.

This can be beneficial when the existing methods for that type is like not handful for a certain situation say like reversing a string. Some of existing method say for string type includes `.ToUpper()`, `.ToLower()`, `.Trim()` and so on.

Let us call our new method Reverse().

First we need to have `static` class for it and `static` method like below.

```

public static class AfceClass

{

public static string Reverse(this string theStr)
{

string theStrNew;

foreach(char ch in theStr)
{

thStrNew =+ ChangeCase(ch) ;

}

return thStrNew;

}

public static string ChangeCase(char chr)

{

// steps to change or negate the char case
return chr.toUpper();

}

```

Note, the use of the `this` keyword to the parameters which more or less makes the method chain.

Now, if you find any variables of type string, it should also have the Reverse() method as well and documentation if added in the comments for that method.

Extension method can be used of types other than struct or for user defined types as well. One aspect is the static class should not be nested in the same class where one is using it as well.

Sample using the generic type

```

public static class AfceClass

{

public static E NewExtMethod<E, T>(this T theStr)
{

E theStrNew;

....

...

return thStrNew;

}

```
Now with Generics, the NewExtMethod<E, T> should populate with any types but make sure to pass the E and T types.

This can be further refined to be populated with only certain types with the `where` clause like below.

```

public static class AfceClass

{

public static E NewExtMethod<E, T>(this T theStr) where T : long, int where E : long
{

E theStrNew;

....

...

return thStrNew;

}

```

Usage - One can use this to have like a common method say like add leading zeros to an int or a long and return as a string or even use as user types with much more options.

Monday, June 5, 2023

C# quality features

In this article I will document about some of the nice features C# has to offer. This include reason(s) for choosing C# in terms of the amount of time needed to bring that app or technology to the market. This could only be a subset of all the features available or known yet.

1. Entity Framework model - Helps in building apps with a decent list of SQL database support like SQLite, MSSQL, Oracle and all. All these are supported by simply inheriting the DBContext to your class and having declared `DBSet<Type>` in that class. You may install the entity framework CLI tool for migrations like below.

// Installs the CLI ef tool
dotnet tool install --global dotnet-ef

// Installs the nuget package for EF operations in your project
dotnet add package Microsoft.EntityFrameworkCore.Design

// Creates new migration for the model just created like Type
dotnet ef migrations add InitialCreate

// Updates the model to the database
dotnet ef database update

Benefits are no prior database knowledge or tools are required to create and manage the database and tables and all. The class `Type` easily translates to the table (schema) in the database. Having said that a good database architect knowledge helps in designing and updating the database with primary and foreign keys and all. Other than that it is a nice practice to commit the migrations to the source control.

2. OData support - If you are building a MVC app with API's returning a bigger set of data like a list of objects. This new* library helps to pass custom query to filter and sort the returned data by just adding an annotation to the specific controller like `[EnableQuery]`. This in turn reduces the extra lines of code needed to be written in the controllers to perform the same.

3. Razor pages support - If you are building a web app then Razor pages of the ASP .Net can help. Razor is the templating pages from MS. You can have both the C# code and the HTML in them. This helps in building web pages for the front end and accessing or calculating the data in the C# code. This can include independent services created and running using the Dependency injection adhering to the D (Dependency Inversion) in the SOLID principles of the OOP design pattern. Pages end with .razor extension was initially created as a component. Higher components can call the lower (or inner) components and data can be passed to them using the `[Parameter]` or `[CascadingParameter]` as annotations to the individual properties. Blazor uses razor pages and .cshtml pages can include .razor pages declared like <ComponentName /> html tags

4. Multi threading or parallel programming -

a. Libraries like `System.Threading.Monitor` helps to lock thread execution to a single thread. Parameters include passing `timeout`(s), `bool ref flag` to check if thread is running ( in critical section ) or not. b. `Sempahore(minThreadCount = 0, maxThreadCount = 3)` contructor to support OS level named semaphores which can be utilized by other programs in the OS as well using the same name. `SemaphoreSlim` to make use of the program level semaphores to control a small number of threads to run in parallel. c. Data structures like `Interlocked.Increment(.... int ....)` or `Decrement()` help in parallel threads increasing or decreasing a number. `ConcurrentDictionary`,`ConcurrentQueue`, `ConcurrentBag` types can be used for thread safe data type operations. d. A simple `lock(obj) { ... }` loop can be used for running or making thread safe single thread operation(s). e. Parallel.Invoke(action1, action2, ..... ) is used to run as many actions as needed in parallel.

5. LINQ - Language Integrated Query - Can be used on almost any `Enumerable` type which helps in mainly filtering and ordering data using .Select( ..... ) and .Where( ...... ) clauses in the enumerable types. Benefits include a ton of time saved writing the `foreach` or any loops with conditions to iterate and all with almost a single line in many cases*. 6. Actions or Funcs or Delegates Actions<T> are delegates but have no return value to them, unlike Funcs<T, U> for which the last parameter of type U can be the return type of the method.

7. Generics Used in classes or methods are types which can be passed as different types and a subset of types can be specified. These help in class or method overriding meaning saving duplicate methods for each different methods. 8. Dependency Injection In order to achieve the inversion of control support in the SOLID principles, C# offers injecting the Services or Types as dependencies during load time in an ASP .Net app like `builder.Services.AddScoped<IService, Service>();` . The type Service can be Transient, Scoped or Singleton depending on the lifetime needed. Transient is new instance every time, Scoped is one instance for the lifetime of the app and the Singleton is the same instance forever like a `static` type.

9. HttpFactory for clients Often there can be issues when trying to make http calls in terms of the resources utilized in the OS. The HttpFactory or the HttpClient typed cient can be injected to a particular service to let the DI handle such resources and try and avoid the socke exhaustion issues, HttpClientFactory helps to create http named clients which can be used in the app anywhere with the same settings. Or a factory for each different client can be created during launch and used within the app interchangeably. 10. Grpc support Google's newer RPC using the http protocol internally is gaining ground in terms of the security offered during transportation and the communications. C# has OOB support for this, be it starting a complete client server app, enabling and making gRPC calls from the CLI and all.

11. Mock or Stub testing There is a popular C# nuget package called `Moq` which help in creating stub or mock objects for interfaces with method definitions. This can be initiated to -Arrange the test data as desired to be returned by each or all the methods and -Assert ed at last to test the parts or services not covered by the stub or mock. This is mainly used when calling such dependencies (as mocks) include network or app being up and running. These are mainly used in unit test(s) and provide a reasonable coverage to the programs in that repository when deploying in the CI/ CD pipelines. Apart from helping write valuable test(s), this helps in building TDD apps and promotes programmers write unit tests first and then the classes after the interfaces. This helps in updating the OOP programs following say L (Linquist substitution) and O (Extend but not modify used classes) in SOLID priciples.

12. Dotnet CLI One important aspect of the C# development worth mentioning is the CLI support. When installed on popular OS, C# can be easily compiled using `dotnet build` and run using `dotnet run Debug`, be it powershell or bash and all.

13. Configuration management App configuration(s) are easily stored in `appsettings.json` for production and`appsettings.Development.json` for development. Indidividual json files with setting can be loaded on services load and used within the app as `IConfiguration _configuration` type which can load a setting like { "AppName": "AppOne" } and retrieved easily as `var appName = _configuration["AppName"];` within the app.

14. Parallel For loop `Paraller.For` or `Paraller.ForEach` loop is new feature where the loop runs in parallel and thread safety should be kept in mind when writing such programs.

15. Editor `Visual Studio` is supposed to be the go to editor as it is from MS as well. Having said that `VSCode the MS version` is no less powerful compared to its multi OS support and some nice extensions such as `C#`, `C# Extensions`, `Roslynator`, `GitHub Copilot`, `.Net Extension Pack`, `.Net Core Test Explorer` and `Solarized` as well.