CodePattern.net

SOLID Principles - What Why and How

anil.awadh@gmail.com — Fri, 27 Sep 2024 21:34:00 -0700

Is SOLID a Design Pattern or Something Else?

SOLID is a set of design principles, not a design pattern. The five SOLID principles guide the structure and behavior of object-oriented design to make software more flexible, maintainable, and scalable. They don't provide concrete solutions like patterns do, but instead, they help you write better code by ensuring your classes and systems are well-structured and easier to modify or extend.

The SOLID Principles:

Single Responsibility Principle (SRP):
- A class should have only one reason to change. In other words, it should have only one job or responsibility.
Open/Closed Principle (OCP):
- Software entities (classes, modules, functions) should be open for extension but closed for modification. You should be able to add new functionality without changing existing code.
Liskov Substitution Principle (LSP):
- Objects of a superclass should be replaceable with objects of a subclass without affecting the correctness of the program. A derived class must be able to be used wherever the base class is expected.
Interface Segregation Principle (ISP):
- Clients should not be forced to depend on methods they do not use. Instead of one large interface, multiple smaller, more specific interfaces are preferable.
Dependency Inversion Principle (DIP):
- High-level modules should not depend on low-level modules. Both should depend on abstractions. Also, abstractions should not depend on details; details should depend on abstractions.

Interview Questions and Answers - Senior and Tech Lead level

anil.awadh@gmail.com — Fri, 27 Sep 2024 21:20:00 -0700

Design Patterns, Principles and Practices

Angular Questions

What is the use of Interceptors in Angular

C# Questions

Are out and ref type allowed in async methods?
Can you give a practical scenario for which you preferred abstract class instead of interface?
What is the order of inheritance declaration when you have interfaces and a base class? Can an interface keep before the base class while inheritance declaration?
What is the order of constructors executions in inheritances?

.net core Questions

What is circuit breaker and how it is implemented?
What are middlewares?
What is the order of execution of middlewares?
If you define multiple implementation of same interface in DI then which one will be served from .net core?

AWS Questions

How to share a private document of s3 to a client?
How you protect/secure your apis?
What is the VisbileTime in SQS?

Microservices Related Questions

Difference Between Design Patterns and Design Principles

anil.awadh@gmail.com — Fri, 27 Sep 2024 21:17:00 -0700

Design Patterns:

What are they?: Design patterns are reusable solutions to common problems encountered in software design. They are templates for how to solve a particular problem in different contexts. Patterns provide a structured approach to solve problems that developers frequently encounter.
Purpose: Provide a tried-and-tested approach to solving specific issues, ensuring consistency and maintainability in the codebase.
Examples:
- Creational Patterns (Factory, Singleton, Builder)
- Structural Patterns (Adapter, Facade, Composite)
- Behavioral Patterns (Observer, Strategy, Command)

Design Principles:

What are they?: Design principles are general guidelines that help developers create better, maintainable, and scalable software. They focus on writing code that is easy to maintain, extend, and understand, rather than solving specific design issues.
Purpose: Guide developers to write more robust and flexible software by applying general best practices.
Examples:
- SOLID Principles (Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, Dependency Inversion)
- DRY (Don’t Repeat Yourself)
- KISS (Keep It Simple, Stupid)
- YAGNI (You Ain’t Gonna Need It)

Key Differences:

Aspect	Design Pattern	Design Principles
Definition	Solution templates for specific problems	Guidelines for writing clean, maintainable code
Scope	Solves common software design issues	General best practices and rules to follow
Purpose	To provide a well-known structure to solve a design issue	To promote good coding practices and code maintainability
Examples	Singleton, Factory, Observer, Strategy	SOLID, DRY, KISS, YAGNI
Usage	Implemented as part of code architecture	Used as rules for the design and architecture of the system

What is the use of Interceptors in Angular

anil.awadh@gmail.com — Wed, 4 Sep 2024 18:44:00 -0700

In Angular, interceptors are a powerful feature of the HTTP Client module that allow you to modify or manipulate HTTP requests and responses. They are typically used to handle common tasks like adding headers, logging, error handling, authentication, caching, and more. Interceptors act as middleware for HTTP requests made by your Angular application.

Key Uses of Interceptors in Angular

Adding Headers or Tokens: Interceptors are often used to automatically attach headers or authentication tokens (like JWTs) to every HTTP request. This is particularly useful for ensuring that all outgoing requests have the necessary credentials to access protected resources.

import { Injectable } from '@angular/core';
import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
import { Observable } from 'rxjs';

@Injectable()
export class AuthInterceptor implements HttpInterceptor {
  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
    const authToken = 'your-auth-token'; // Replace with actual token retrieval logic
    const clonedRequest = req.clone({
      headers: req.headers.set('Authorization', `Bearer ${authToken}`)
    });
    return next.handle(clonedRequest);
  }
}

Error Handling: Interceptors can catch errors from HTTP responses and handle them in a consistent way across your application. For example, you might want to log errors, display notifications, or redirect users to a login page if a 401 Unauthorized response is detected.

import { Injectable } from '@angular/core';
import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent, HttpErrorResponse } from '@angular/common/http';
import { Observable, throwError } from 'rxjs';
import { catchError } from 'rxjs/operators';

@Injectable()
export class ErrorInterceptor implements HttpInterceptor {
  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
    return next.handle(req).pipe(
      catchError((error: HttpErrorResponse) => {
        console.error('Error occurred:', error);
        // Handle error, e.g., show a notification
        return throwError(() => error);
      })
    );
  }
}

Logging Requests and Responses: Interceptors can log information about outgoing HTTP requests or incoming responses, which is useful for debugging and monitoring.

import { Injectable } from '@angular/core';
import { HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
import { Observable, tap } from 'rxjs';

@Injectable()
export class LoggingInterceptor implements HttpInterceptor {
  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
    console.log('Request made to:', req.url);
    return next.handle(req).pipe(
      tap(event => {
        console.log('Response received from:', req.url, event);
      })
    );
  }
}

Caching: Interceptors can be used to implement client-side caching strategies by storing responses in a cache and serving cached responses instead of making new HTTP requests.
Modifying Requests or Responses: You can modify the request or response data (like adding query parameters or transforming the response body) before it reaches the component or service making the request.

How to Use Interceptors in an Angular Application

Create the Interceptor: Define the interceptor by implementing the HttpInterceptor interface.

Register the Interceptor: Register the interceptor in the providers array of your Angular module, usually in app.module.ts:

import { HTTP_INTERCEPTORS } from '@angular/common/http';
import { AuthInterceptor } from './path-to-auth-interceptor';
import { ErrorInterceptor } from './path-to-error-interceptor';

@NgModule({
  // ...
  providers: [
    { provide: HTTP_INTERCEPTORS, useClass: AuthInterceptor, multi: true },
    { provide: HTTP_INTERCEPTORS, useClass: ErrorInterceptor, multi: true },
  ],
})
export class AppModule { }

The multi: true flag is important because it tells Angular to keep the existing interceptors and add the new ones, rather than replacing them.

Benefits of Using Interceptors

Centralized Logic: Interceptors allow you to centralize logic that applies to all HTTP requests or responses, making the code cleaner and more maintainable.
Consistency: Ensures consistent behavior for all HTTP requests (like error handling, logging, and authorization).
Reusability: Easily reusable across multiple components and services.

Summary

Interceptors in Angular provide a mechanism to modify or handle HTTP requests and responses globally. They are a versatile tool that helps you implement cross-cutting concerns like authentication, logging, error handling, and caching efficiently.

Would you like more details on a specific use case of Angular interceptors, or perhaps a code example tailored to your project?

Super Funda of OOPs in C# - Part 1

anil.awadh@gmail.com — Tue, 27 Apr 2021 12:04:00 -0700

C# Language is an Object Oriented Programming model language from Microsoft which is evolving with day by day. It is a leading programming language in Microsoft stacks. As per the standard guidelines of this language, it behaves in following manner while making a type(class) ready to work -

1. Default initialization:

Variables are initializes with default values if you don't initialize them explicitly while declaration. As per the MSDN,

"All the variable initializers for a class are implicitly run directly before the invocation of whichever base class constructor is invoked".

Instance & static variables can be initialized at the point of its declaration.

Instance variables - Initialization is happen just before the call of constructor.
Static variables - Initialization is happen just before the first usage call of the member or just before the first instance creation of that class.

2. Default inheritance

If a class is not inheriting to any base class then, .net implicitly provide an inheritance to its Object class. It is interesting, no? Object plays mother roles for delegate, array, struct, enum or nullable value type.(every non-pointer type in C# is convertible to object.) Now, you would be thinking, what if my class is derived one? In this case too we indirectly have Object class derived through multilevel inheritance.

public class MyBaseClass

{

}

is the same as-

public class MyBaseClass : Object

{

}
Now, you can understand the mystery of providing default constructor, right? Yes, it is the Object class's parameter-less constructor.

http://referencesource.microsoft.com/#mscorlib/system/object.cs,d9262ceecc1719ab

3. Default constructor:

A default constructor is provided for class's object creation if no constructor is explicitly given by user. a special code block which is guaranteed to be executed while the creation of variables to make a class instance workable.
A base class constructor is automatically called. C# Language provides options to explicitly called base class constructors in which we can specify which base constructor is to be called by passing appropriate parameters. This constructor chaining is provided by language to avoid duplicate codes.
Static Constructor- It invoked just before the-

(1) First invocation of static method or (2) First time an instance of that class is created.

@AnilAwadh

dot net core specific production issues

anil.awadh@gmail.com — Sun, 25 Apr 2021 15:08:00 -0700

1. HTTP Error 500.35 - ASP.NET Core does not support multiple apps in the same app pool

Just create another app-pool for non-managed code and use that.

How to use Consul in Production Server for Service Discoveries

anil.awadh@gmail.com — Thu, 22 Apr 2021 11:42:00 -0700

HashiCorp's consul is the good pick for service mesh and service discovery. While developing microservices, we need some service discoveries mechanism so that our services/Web-APIs get registered themselves with a centralized service-repository. A Web API gateway (like ocelot etc.) then can use the consul to serve the request.

Using Consul in Production Deployment

In a production deployment, we need to install consul on each node(host/machine/container) where our services are and we want them to register with consul. The Consul can run in two modes i.e.

server-agent (maintains the state) and
client-agent (light-weight process, must be installed on each & every node where our microservices are running).

The Consul, needs to be running up constantly for the Production servers and for that have two ways-

let the consul up and running from a command prompt window
install consul as a windows service

The first solution looks very awkward. If by accidently someone closes that command prompt window, consul will stop working. So, we can think for the second approach that is installing consul as a windows service.

How to install consul as a Windows Service?

Download the consul from here- https://www.consul.io/downloads
Unzip the consul in a folder where you want to keep the consul and its config
Go to that folder and create a folder lets name it "config"
Inside the "config" folder, create a "config.json" file and put below content-

{

"datacenter": "east-aws",

"data_dir": "c:\\consul\\config",

"log_level": "INFO",

"node_name": "WebServer",

"server": true,

"bind_addr": "10.0.0.217",

"bootstrap": true,

"ui_config": {"enabled": true},

"log_file": "c:\\consul\\log\\consul.log"

}

Run the below command from the command prompt to install the consul as a windows service-

 sc.exe create "Consul" binPath= "c:\\consul\\Consul.exe agent -config-dir=c:\\consul\\config" start= auto

Then to start consul service, type below command-
```
 sc.exe start Consul
```
Go the services and check if your consul is up and running

That's it!

@AnilAwadh

Installing Perl and its module in Windows OS

anil.awadh@gmail.com — Mon, 10 Aug 2020 19:24:00 -0700

This article covers straight-forward steps to install the Perl and modules. The MS Windows doesn't have Perl installed and needs to be setup. There are two widely available environmental flavors: -

ActiveState Perl (offers free community as well as commercial versions)
Strawberry Perl (open-source)

Strawberry Perl

My preferred Perl environment pick was the Strawberry distribution for below stated reasons: -

Strawberry Perl is Open-source
Closer to UNIX system environment
Loaded with so many external libraries
Database clients
CPAN (Comprehensive Perl Archive Network) direct access to use required modules which minimize the hurdles for looking the relevant binaries.

How to Install Strawberry Perl:

Go to the website http://strawberryperl.com/ and download the Windows installer.
Run the downloaded setup and complete the installation.
Once installed, go to start menu and type 'perl'. It will show you the 'Perl (command line)', click on that.
You will get the command line where you can run the Perl commands. To check the Perl version, type-
```
perl -v
```
Next step is to install cpanm so that we can use it to install modules from CPAN. Type below command on the command-line: -
```
cpan App::cpanminus
```
Now, let's see how cpanm can be used to install needed modules:-
```
cpanm Module::Name
```

We can use also install modules from shell as well using below commands: -

perl -MCPAN -e shell

install Email::Send

install Math::Round

install Time::HiRes

Conclusion

Perl is a modern programming language and mostly being used in scripting and writing applications. It's environment setup in MS Windows for 32 as well as 64 bit can be done by choosing your suited environment like ActiveState and Strawberry. Strawberry is the open source, and facilitate an easy install of modules from CPAN.

Dynamics 365 Business Central (Dynamics NAV)

anil.awadh@gmail.com — Fri, 6 Sep 2019 21:40:00 -0700

This article is intended to highlight the key points relating to Dynamics 365 Business Central (the new SaaS version of Dynamics NAV since 2018). Let's explore Dynamics NAV in following aspects:

General aspect and
Technical aspect

Dynamics 365 Business Central: In General Aspects

An intelligent ERP (Enterprise Resource Management) software made by Microsoft
Works as a centralized platform for managing businesses processes
Helps businesses in managing their back-end operations
Helps in
- Orders planning & deliveries, inventory, warehousing, picking to shipping
- Forecasting demands, automating invoices
- Scheduling & purchasing (supply chain management)
- Budgeting and capacity management
Consists of important modules like
- Warehouse management
- Inventory management
- Financial management
- Manufacturing management
- Human resource management
- Project management
- Service management
- Retail & E-Commerce
- Business Intelligence
- Sales & Marketing capabilities (not full-fledged)
Can be used by
- Service Industry
- Manufacturing Industry
- Distributors Industry
- Any industry by customizing it as per requirements
User Interfaces
- Easy, modern & user-friendly interface
- Drag and drop customization of pages
Compliances
- GDPR support
Licensing model
- For updated details, please refer Microsoft Updates...
- In case of NAV
  - There are two plans
    - Starter Pack
    - Extended Pack
  - Manufacturing & Warehouse capabilities are not available in Starter pack and only Financials, Distribution and Professional service modules are available. Also, there is some limitation in terms of concurrent users, read only accesses.
- In case of Dynamics 365 Business Central:
  - Three plans
    - Team Member License (around $8 per user per month)
    - Essential License (around $70 per user per month)
    - Premium License (around $100 per user per month)
  - For exact price, please refer Resellers)
History
- In 2000, Navision Software A/S company merged with Damgard A/S
- In 2002, Microsoft acquisition this merged company and given a new name "Microsoft Business Solutions"
- In 2005, Microsoft renamed it to Microsoft Dynamics Nav

Dynamics NAV: In Technical Aspects

Back-end
- Uses MSSQL
  - Accessible
  - can be accesse via SQL Server Management Studio
Front-end
- Modern, User-Friendly interface
Expose to outer world communication
- Web pages as a Web Service (requires registering & publishing) for read/update NAV data. Refer
- Web client services
- Access NAV data directly from MSSQL
- File exchange (via shared-folder) with folder listener feature. Nav application server can create a folder listener.

Starting with Events in WPF and MVVM pattern using PRISM library

anil.awadh@gmail.com — Fri, 21 Dec 2018 12:49:00 -0700

This article is written to address beginners who want to know how to start with events in MVVM. This article covers the click event for the explanation. Through the given small bullet steps in this article, a novice programmer can easily understand the flow-mechanism by seeing where and how to write the event handling related code part.

There are a lot of frameworks available with WPF like Gala Soft, PRISM and so on; in this article explanation, PRISM framework has been used in WPF MVVM.

Article will illustrate the whole process through simple steps with snapshots and bit of important explanation of that thing:

Step by Step Project creation
Explaination of View-model code

a) Step by Step Project Creation

Add New WPF library project in solution:
Create the project structure by adding required items.
Create new Folder with name “VIEWS” and under this folder create a view of any type either window or user control. For now, I am using control type window:
With this our folder structure looks like below:
Install one package for PRISM i.e. click on Tools > NuGet Package Manager > package manger solution
And browse PRISM .CORE for our created library
Open the Window1.xaml in order to write some controls. After writing xaml for performing click operation this is how code & UI looks:
Here I highlighted the bindings of text box controls of First Name and Last Name which plays important role when we write anything in textbox and access this data in our corresponding view model properties.
Now I am going to create View Model Folder and under that I will write the code for my View i.e. first name, last name and the click me button.

b) Some explanation about above view model code:

We created two similar name properties as we mentioned in view i.e. for first name and last name. And in order to capture the click of BUTTON I created a ICOMMAND event delegate with same name as we set in UI i.e. ”Event Command”

One thing you have seen in above code that I inherited a class EventBaseClass what’s the role of this class?

Whenever our view model interacts with WPF UI there is role of two way binding in order to perform this there is one event called INotifyPropertyChanged that we have to use on every view model we create ,that tells the view model properties that some value is updated from UI.

****NOTE: In order to connect the basic thing that everyone miss that we have to connect both View and View Model . For that open your window1.xaml.cs file and in the constructor bind data context with our view model. like below:

That's it! Hope you enjoyed the article.