DEV Community: Md: Shariar haque

Single Responsibility Principle (SRP)

Md: Shariar haque — Fri, 27 Dec 2024 19:23:02 +0000

Check out my new blog on SRP:
https://www.linkedin.com/pulse/single-responsibility-principle-srp-shahriar-haque-sg5dc/?trackingId=NPTx50dRh1ZELXPacS7JuA%3D%3D

Protfolio

Md: Shariar haque — Fri, 27 Dec 2024 19:20:43 +0000

🌟 Excited to share my personal portfolio website! 🌐
Take a look to explore my projects, skills, and what I’ve been working on. Feedback is always welcome! 🚀
👉 Visit: https://shahriarhaque.netlify.app

Portfolio #WebDeveloper #SoftwareEngineer #ReactJS #DotNetCore

Dependency Injection Explained in C#

Md: Shariar haque — Mon, 29 Jul 2024 09:07:48 +0000

Dependency Injection (DI) in C#:

Dependency Injection is a design pattern used to achieve Inversion of Control (IoC) between classes and their dependencies. Instead of a class creating its dependencies, they are provided from outside, typically by an IoC container.

When a class (ClassA) needs to use another class (ClassB), you can inject (pass) the dependency into ClassA, rather than having ClassA create an instance of ClassB internally.

Example

Without Dependency Injection:

public class ClassB
{
    public int Calculate() => 100;
}

public class ClassA
{
    private readonly ClassB _classB = new ClassB();

    public int TenPercent()
    {
        return (int)(_classB.Calculate() * 0.1);
    }
}

public class Program
{
    public static void Main()
    {
        ClassA classA = new ClassA();
        Console.WriteLine("Ten Percent: " + classA.TenPercent());
    }
}

In this example, ClassA creates its own instance of ClassB, making it tightly coupled to ClassB.

With Dependency Injection:

Define Interfaces:

Create an interface IClassB to abstract the dependency:

   public interface IClassB
   {
       int Calculate();
   }

Implement the Interface:

Implement the interface in ClassB:

   public class ClassB : IClassB
   {
       public int Calculate() => 100;
   }

Inject Dependencies:

Modify ClassA to accept an IClassB instance through its constructor:

   public class ClassA
   {
       private readonly IClassB _classB;

       public ClassA(IClassB classB)
       {
           _classB = classB;
       }

       public int TenPercent()
       {
           return (int)(_classB.Calculate() * 0.1);
       }
   }

Setup Dependency Injection:

In a real-world application, you use a DI container (like Microsoft.Extensions.DependencyInjection) to manage dependencies:

   public class Program
   {
       public static void Main()
       {
           // Create a service collection and configure DI
           var serviceCollection = new ServiceCollection();
           serviceCollection.AddTransient<IClassB, ClassB>();
           serviceCollection.AddTransient<ClassA>();

           // Build the service provider
           var serviceProvider = serviceCollection.BuildServiceProvider();

           // Resolve and use the service
           var classA = serviceProvider.GetService<ClassA>();
           Console.WriteLine("Ten Percent: " + classA.TenPercent());
       }
   }

Benefits

Loose Coupling: ClassA is not dependent on a concrete implementation of ClassB; it relies on the IClassB interface.
Reusability: You can easily switch ClassB with another implementation (e.g., ClassC) without changing ClassA.
Improved Testability: Mock dependencies can be injected for unit testing.
Simpler Maintenance: Dependencies are managed centrally and can be easily updated or replaced.
Concurrent Development: Teams can work on different components independently, as long as they adhere to the same interfaces.
Better Design: Promotes separation of concerns and follows the SOLID principles.

This way, you get more flexible, maintainable, and testable code by applying Dependency Injection.

How to change HTML text using JavaScript DOM

Md: Shariar haque — Tue, 02 Jul 2024 11:02:51 +0000

Html

<!DOCTYPE html>
<html>
  <head>
    <title>Hello, World!</title>
    <link rel="stylesheet" href="styles.css" />
  </head>
  <body>
      <button type="submit" id="btn">click here to show time  </button>
      <p id="t"></p>
      <script src="script.js"></script>
  </body>
</html>

javaScript

document.addEventListener('DOMContentLoaded',function()
{
  const btn = document.getElementById('btn');

  btn.addEventListener('click', function(){


    OnChange();

  });

});

function OnChange(){
      document.getElementById('t').innerHTML=Date();


}

style css

body{
  padding: 25px;
}
.title {
    color: #5C6AC4;
}
#btn{
  background-color:orange;
  border: none;
  border-radius: 12px;
  color: white;
  padding: 15px 32px;
  text-align: center;
  text-decoration: none;
  display: inline-block;
  font-size: 16px;

}
#btn:hover{

   background-color: #04AA6D; /* Green */
  border: none;
  color: white;
  padding: 15px 32px;
  text-align: center;
  text-decoration: none;
  display: inline-block;
  font-size: 16px;
}
p{
  font-size: 24px;
 color: blue;
}

Why Beginners Should Start Writing Code in a Plain Text Editor

Md: Shariar haque — Thu, 27 Jun 2024 09:59:26 +0000

*As a beginner, writing code in a plain text editor like Notepad can be a beneficial practice. *
Here’s why:

Focus on Fundamentals: By using a simple text editor, you’ll concentrate on understanding the core concepts of coding without relying on the conveniences provided by advanced Integrated Development Environments (IDEs).
Learn the Basics: You’ll become familiar with the syntax and structure of your code, which helps in developing a strong foundation.
Appreciate the Tools: Starting with a basic editor makes you appreciate the powerful features of IDEs when you transition to using them, such as code completion, debugging tools, and integrated version control.
Develop Attention to Detail: Without automatic syntax highlighting and error checking, you’ll develop a keen eye for detail, catching mistakes early and understanding error messages more thoroughly.
Minimal Distractions: A plain text editor offers a distraction-free environment, allowing you to focus solely on writing and understanding code.

Starting with a simple text editor like Notepad can be a great way to build your coding skills and establish a strong programming foundation. Once you’re comfortable with the basics, you can gradually move on to more advanced tools and environments.

Store Procedure for getting all Items from Item table MSSQL

Md: Shariar haque — Thu, 27 Jun 2024 05:22:56 +0000

use Shop; -- table name shop
CREATE PROCEDURE AllItems -- procedure name AllItems
AS
SELECT *FROM Item
GO;

EXEC AllItem; -- retrive procedure

JWT

Md: Shariar haque — Sun, 09 Jun 2024 10:43:23 +0000

JSON Web Token compact URL-safe means of representing claims to be transferred between two parties securely. These tokens are often used in authentication and authorization protocols.

Structure: JWTs consist of three parts separated by dots: Header, Payload, and Signature. These parts are base64url encoded JSON strings.

Header: Contains information about the type of token (JWT) and the signing algorithm used.
Payload: Contains the claims. Claims are statements about an entity (typically, the user) and additional data. There are three types of claims: registered, public, and private claims.
Signature: To create the signature part, you need to take the encoded header, the encoded payload, a secret, the algorithm specified in the header, and sign that.

Authentication: When a user logs in, the server generates a JWT and sends it to the client. The client stores the token, usually in local storage or a cookie.
Authorization: When the client makes subsequent requests to the server, it includes the JWT in the request, typically in the Authorization header. The server then verifies the JWT to ensure it's valid and hasn't been tampered with. It then uses the information in the token to determine if the user is authorized to access the requested resources.
Statelessness: JWTs are stateless, meaning the server doesn't need to keep a record of the tokens it issues. This makes JWTs ideal for use in distributed systems and APIs.
Expiration: JWTs can have an expiration time (in the Payload), after which they're no longer considered valid. This adds an extra layer of security as even if a token is stolen, it will only be valid for a limited time.
Security: To ensure the integrity of the token, it's important to sign it using a secret key known only to the server. This prevents tampering with the token by unauthorized parties.

JWTs provide a flexible and secure way of transmitting information between parties and are widely used in modern web development for authentication and authorization purposes.