DEV Community: manoj

DSA: Linked List Javascript

manoj — Fri, 02 Aug 2024 12:57:18 +0000

LinkedList is the dynamic data structure, as we can add or remove elements at ease, and it can even grow as needed. Just like arrays, linked lists store elements sequentially, but don’t store the elements contiguously like an array.

We define a class Node having two properties: element and next. Element holds the data of a node while next holds the pointer to the next node, which is initialized to the null value.

Let's visualize the memory updates step-by-step:

Initial State:

head -> @A1
@A1: { value: 10, next: null }
tail -> @A1

After First Append:

head -> @A1
@A1: { value: 10, next: @B1 }
tail -> @B1
@B1: { value: 5, next: null }

After Second Append:

head -> @A1
@A1: { value: 10, next: @B1 }
@B1: { value: 5, next: @C1 }
tail -> @C1
@C1: { value: 16, next: null }

The entire list structure due to the updates to the next properties.

{
  value: 10,
  next: {
    value: 5,
    next: {
      value: 16,
      next: null
    }
  }
}

Conclusion

tail.next = newNode updates the next property of the current tail node to reference the new node.
This creates a chain of references starting from head and extending through each appended node.
Each append operation extends the linked list, making the new node part of the chain that head points to.

Therefore, while head itself doesn't change, the structure it references gets updated with each new node appended, because head.next (and subsequent next properties) form a chain that includes all nodes, old and new.

Demo

The Angular Advantage: Simplifying Development with Unidirectional Flow and Presentational Components

manoj — Fri, 05 Jul 2024 11:07:45 +0000

Simplifying Angular Applications: Unidirectional Data Flow and Presentational Components

Building complex Angular applications can lead to tangled logic and data management headaches. Traditional approaches often involve components manipulating data directly, making it difficult to track changes and maintain a consistent state. Here, we explore two key concepts that can significantly improve your Angular development experience: Unidirectional Data Flow and Presentational Components.

Unidirectional Data Flow: A Streamlined Approach

Imagine data flowing through your application like a river. Traditionally, this flow could be chaotic, with data changing hands between components in unpredictable ways. Unidirectional Data Flow introduces a clear path for this "river" of data. Here's how it works:

User interacts: A user clicks a button, selects an item, or submits a form.
Component dispatches action: The component responsible for handling the user interaction dispatches an action. Think of an action as a message containing information about the event.
Store updates state: A centralized store, managed by NgRx or a similar library, receives the action and updates the application state accordingly.
Component retrieves data: The component subscribes to a selector, a function that retrieves specific data slices from the updated state.
Component updates UI: Based on the retrieved data, the component updates the user interface (UI) to reflect the changes.

// actions.ts
export const increment = createAction('[Counter] Increment');
export const decrement = createAction('[Counter] Decrement');

// reducer.ts
const initialState = { count: 0 };

export const counterReducer = createReducer(
  initialState,
  on(increment, (state) => ({ count: state.count + 1 })),
  on(decrement, (state) => ({ count: state.count - 1 }))
);

// counter.component.ts
@Component({
  selector: 'app-counter',
  template: `
    <button (click)="dispatchIncrement()">Increment</button>
    <button (click)="dispatchDecrement()">Decrement</button>
    <p>Count: {{ count$ | async }}</p>
  `,
})
export class CounterComponent {
  count$ = this.store.select(selectCount);

  constructor(private store: Store<AppState>) {}

  dispatchIncrement() {
    this.store.dispatch(increment());
  }

  dispatchDecrement() {
    this.store.dispatch(decrement());
  }
}

This unidirectional flow offers several advantages:

Predictability: Since data flows in a single direction, it's easier to understand how changes in one part of the application affect others.
Debugging: With a clear path, debugging becomes simpler as you can pinpoint where data manipulations occur.
Testability: Unidirectional flow makes components easier to test in isolation, as they rely solely on actions and selectors for data.

Components as Presentational Layers: Keeping it Clean
Imagine your components as display cases in a museum. Their primary purpose is to showcase information, not manipulate it directly. By adopting the "presentational component" approach, you achieve this goal:

Components focus on presentation: These components handle user interactions and display data, but they don't modify the application state themselves.
Separation of concerns: This separation keeps your code organized and easier to maintain.
Reusable components: Presentational components often become reusable across different parts of your application since they don't rely on application-specific logic.
The Synergy of Unidirectional Data Flow and Presentational Components

// user-card.component.ts
@Component({
  selector: 'app-user-card',
  template: `
    <div *ngIf="user">
      <h2>{{ user.name }}</h2>
      <p>Email: {{ user.email }}</p>
    </div>
  `,
})
export class UserCardComponent {
  @Input() user: User | null = null;
}

Combining these two concepts creates a powerful development approach. Unidirectional data flow ensures predictable state management, while presentational components keep the logic clean and focused. This synergy leads to maintainable, testable, and scalable Angular applications.

Ready to Streamline Your Development?
Unidirectional data flow and presentational components represent a paradigm shift in Angular development. By embracing these strategies, you can build more robust and manageable applications, allowing you to focus on what matters most - delivering an exceptional user experience.

Why Unidirectional Data Flow with NgRx Wins for Large-Scale Angular Applications
While traditional two-way data binding and service layers with event emitters have their merits, for large-scale Angular applications, unidirectional data flow with NgRx offers several advantages:

1. Improved Scalability and Maintainability:
Complexity Management: Two-way data binding can become a tangled mess in large applications, making it difficult to track data flow and identify issues. NgRx provides a centralized store, simplifying state management and reducing the risk of bugs.
Predictable Changes: Unidirectional data flow ensures predictable state updates, making it easier to reason about how changes in one part of the application affect others. This becomes crucial as the application grows and components become more interconnected.

2. Enhanced Testability:
Isolated Testing: Components in a unidirectional flow architecture rely solely on actions and selectors to interact with the state. This allows for easier unit testing of components in isolation, as you don't need to mock complex data interactions.
Debugging Benefits: Since data changes follow a clear path, debugging becomes more efficient. You can pinpoint where state updates occur and identify the root cause of issues.

3. Better Performance and Data Consistency:
Immutable State: NgRx promotes immutability, meaning the state store never gets mutated directly. This improves performance and ensures data consistency across the application.
Performance Optimizations: NgRx offers features like memoization for selectors, which can improve performance by caching frequently used data slices.

4. Developer Experience and Team Collaboration:
Clear Communication: Unidirectional data flow fosters a clear understanding of how data flows within the application. This improves communication and collaboration within development teams.
Reusable Patterns: NgRx promotes well-defined patterns for actions, reducers, and selectors, making code more reusable and maintainable across different parts of the application.

While service layers with event emitters offer some benefits, they can still lead to complex data flows and tight coupling between components. Unidirectional data flow with NgRx provides a structured and scalable approach to managing application state, especially for large-scale Angular applications.

C# IEnumerables

manoj — Fri, 28 Jun 2024 02:54:53 +0000

Key Points:

What is IEnumerable?

IEnumerable is an interface in C# that allows you to iterate over a collection of items.
It is found in the System.Collections namespace for non-generic collections and System.Collections.Generic namespace for generic collections.

Methods and Properties

The primary method in IEnumerable is GetEnumerator(), which returns an IEnumerator.
IEnumerator provides the necessary methods (MoveNext(), Reset()) and property (Current) to iterate over a collection.

Common Usage

IEnumerable is commonly used with foreach loops to traverse collections such as arrays, lists, and other data structures.
It provides a standard way to iterate over any collection that implements the interface.

Examples of Methods

OfType<TResult>(IEnumerable): Filters the elements of an IEnumerable based on a specified type.
Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>): Concatenates two sequences.
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>): Groups the elements of a sequence according to a specified key selector function.

Visualize dependencies across your code with code maps in Visual Studio 2019

manoj — Thu, 14 Oct 2021 16:06:53 +0000

(1). In Solution Explorer, select the projects, assembly references, folders, files, types, or members that you want to map.

(2). On the Solution Explorer toolbar, choose Show on Code Map Create New Graph From Selected Nodes Button. Or, open the shortcut menu for one or a group of items and choose Show on Code Map.

You can also drag items from Solution Explorer, Class View, or Object Browser, into a new or existing code map. To include the parent hierarchy for your items, press and hold the Ctrl key while you drag items, or use the Include Parents button on the code map toolbar to specify the default action. You can also drag assembly files from outside Visual Studio, such as from Windows Explorer.

(3). The map shows the selected items within their containing assemblies.

(4). To explore items, expand them. Move the mouse pointer on top of an item, then click the chevron (down arrow) icon when it appears.

To expand all items, select them using Ctrl+A, then open the shortcut menu for the map and choose Group > Expand. However, this option isn't available if expanding all groups creates an unusable map or memory issues.

(5). Continue to expand items you are interested in, right down to the class and member level if necessary.

To see members that are in the code but don't appear on the map, click the Refetch Children icon Refetch Children Icon in the top left corner of a group.

(6). To see more items related to those on the map, select one and choose Show Related on the code map toolbar, then select the type of related items to add to the map. Alternatively, select one or more items, open the shortcut menu, and then choose the Show option for the type of related items to add to the map.

(7). The map shows the relationships. In this example, the map shows the methods called by the Find method and their location in the solution or externally.

(8). To simplify the map and focus on individual parts, choose Filters on the code map toolbar and select just the types of nodes and links you are interested in. For example, turn off display of Solution Folders, Assemblies, and Namespaces.

Ref: https://docs.microsoft.com/en-us/visualstudio/modeling/map-dependencies-across-your-solutions?view=vs-2019

C#: Casting and type conversions

manoj — Wed, 13 Oct 2021 15:21:22 +0000

C# is statically-type at compile time, after a variable is declared, it cannot be declared again or assigned a value of another type unless that type implicitly convertible to the variable's type.

Implicit conversions

For built-in numeric types, an implicit conversion can be made when the value to be stored can fit into the variable without being truncated or rounded off. For integral types, this means the range of the source type is a proper subset of the range for the target type. For example, a variable of type long (64-bit integer) can store any value that an int (32-bit integer) can store. In the following example, the compiler implicitly converts the value of num on the right to a type long before assigning it to bigNum.

// Implicit conversion. A long can
// hold any value an int can hold, and more!
int num = 2147483647;
long bigNum = num;

For a complete list of all implicit numeric conversions, see the Implicit numeric conversions section of the Built-in numeric conversions article.

For reference types, an implicit conversion always exists from a class to any one of its direct or indirect base classes or interfaces. No special syntax is necessary because a derived class always contains all the members of a base class.

Derived d = new Derived();
// Always OK.
Base b = d;

Explicit conversions

However, if a conversion cannot be made without a risk of losing information, the compiler requires that you perform an explicit conversion, which is called a cast. A cast is a way of explicitly informing the compiler that you intend to make the conversion and that you are aware that data loss might occur, or the cast may fail at runtime. To perform a cast, specify the type that you are casting to in parentheses in front of the value or variable to be converted. The following program casts a double to an int. The program will not compile without the cast.

class Test
{
    static void Main()
    {
        double x = 1234.7;
        int a;
        // Cast double to int.
        a = (int)x;
        System.Console.WriteLine(a);
    }
}
// Output: 1234

For a complete list of supported explicit numeric conversions, see the Explicit numeric conversions section of the Built-in numeric conversions article.
For reference types, an explicit cast is required if you need to convert from a base type to a derived type:

// Create a new derived type.
Giraffe g = new Giraffe();

// Implicit conversion to base type is safe.
Animal a = g;

// Explicit conversion is required to cast back
// to derived type. Note: This will compile but will
// throw an exception at run time if the right-side
// object is not in fact a Giraffe.
Giraffe g2 = (Giraffe)a;

A cast operation between reference types does not change the run-time type of the underlying object; it only changes the type of the value that is being used as a reference to that object. For more information, see Polymorphism.

Nullable.HasValue Property

manoj — Tue, 12 Oct 2021 15:48:23 +0000

Definition

Gets a value indicating whether the current Nullable object has a valid value of its underlying type.

public bool HasValue { get; }

true if the current Nullable object has a value; false if the current Nullable object has no value.

C# IEnumerables

manoj — Thu, 07 Oct 2021 17:12:11 +0000

IEnumerable:

OfType<TResult>(IEnumerable) - Filters the elements of an IEnumerable based on a specified type.

Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>) - Concatenates two sequences.

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>) - Groups the elements of a sequence according to a specified key selector function.

Entity Framework Core Fluent API

manoj — Wed, 06 Oct 2021 13:58:21 +0000

Entity Framework Fluent API is used to configure domain classes to override conventions.
EF Fluent API is based on a Fluent API design pattern (a.k.a Fluent Interface) where the result is formulated by method chaining.

In Entity Framework Core, the ModelBuilder class acts as a Fluent API. By using it, we can configure many different things, as it provides more configuration options than data annotation attributes.

Entity Framework Core Fluent API configures the following aspects of a model:

Model Configuration: Configures an EF model to database mappings. Configures the default Schema, DB functions, additional data annotation attributes and entities to be excluded from mapping.
Entity Configuration: Configures entity to table and relationships mapping e.g. PrimaryKey, AlternateKey, Index, table name, one-to-one, one-to-many, many-to-many relationships etc.
Property Configuration: Configures property to column mapping e.g. column name, default value, nullability, Foreignkey, data type, concurrency column etc.

Below attributes has been most recommeneded.

HasOne method is used to configure the one side of a one to many relationship, or one end of a one to one relationship.

One To One Relationship

The following example illustrates the use of HasOne with WithOne to configure a one-to-one relationship:

public class SampleContext : DbContext
{
    public DbSet<Author> Authors { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Author>()
            .HasOne(a => a.Biography)
            .WithOne(b => b.Author);
    }
}
public class Author
{
    public int AuthorId { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public AuthorBiography Biography { get; set; }
}
public class AuthorBiography
{
    public int AuthorBiographyId { get; set; }
    public string Biography { get; set; }
    public int AuthorId { get; set; }
    public Author Author { get; set; }
}

One To Many Relationship

This example illustrates the use of the HasOne method together with the WithMany method to configure a one-to-many relationship:

public class SampleContext : DbContext
{
    public DbSet<Employee> Employees { get; set; }
    public DbSet<Company> Companies { get; set; }
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Employee>()
        .HasOne(e => e.Company)
        .WithMany(c => c.Employees);
    }
public class Company
{
    public int Id { get; set; }
    public string Name { get; set; }
    public ICollection<Employee> Employees { get; set; }
}
public class Employee
{
    public int Id { get; set; }
    public string Name { get; set; }
    public Company Company { get; set; }
}

Configure Cascade Delete using Fluent API

Cascade delete automatically deletes the child row when the related parent row is deleted. For example, if a Grade is deleted, then all the Students in that grade should also be deleted from the database automatically.

Use the OnDelete method to configure the cascade delete between Student and Grade entities, as shown below.

modelBuilder.Entity<Grade>()
    .HasMany<Student>(g => g.Students)
    .WithOne(s => s.Grade)
    .HasForeignKey(s => s.CurrentGradeId)
    .OnDelete(DeleteBehavior.Cascade);

The OnDelete() method cascade delete behaviour uses the DeleteBehavior parameter. You can specify any of the following DeleteBehavior values, based on your requirement.

Cascade: Dependent entities will be deleted when the principal entity is deleted.
ClientSetNull: The values of foreign key properties in the dependent entities will be set to null.
Restrict: Prevents Cascade delete.
SetNull: The values of foreign key properties in the dependent entities will be set to null.

Fluent API HasIndex Method

HasIndex method is used to create a database index on the column mapped to the specified entity property. By default, indexes are created for foreign keys and alternate keys. You may wish to create indexes on other properties to speed up data retrieval:

public class SampleContext : DbContext
{
    public DbSet<Book> Books { get; set; }
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Book>()
            .HasIndex(b => b.Isbn);
    }
}
public class Book
{
    public int BookId { get; set; }
    public string Title { get; set; }
    public string Isbn { get; set; }
}

Specifying the Maximum Length on a Property

In the following example, the Name property should be no longer than 50 characters. If you make the value longer than 50 characters, you will get a DbEntityValidationException exception. If Code First creates a database from this model it will also set the maximum length of the Name column to 50 characters.

modelBuilder.Entity<Department>().Property(t => t.Name).HasMaxLength(50);

The Fluent API HasColumnName Method

The HasColumnName attribute is applied to a property to specify the database column that the property should map to when the entity's property name and the database column name differ. The following example maps the Title property in the Book entity to a database column named Description in the Books table:

public class SampleContext : DbContext
{
    public DbSet<Book> Books { get; set; }
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Book>()
            .Property(b => b.Title).HasColumnName("Description");
    }
}
public class Book
{
    public int BookId { get; set; }
    public string Title { get; set; }
    public Author Author { get; set; }
}

EF Core: DbContext

manoj — Tue, 05 Oct 2021 13:34:29 +0000

The DbContext class is an integral part of Entity Framework. An instance of DbContext represents a session with the database which can be used to query and save instances of your entities to a database. DbContext is a combination of the Unit Of Work and Repository patterns.

DbContext in EF Core allows us to perform following tasks:

Manage database connection
Configure model & relationship
Querying database
Saving data to the database
Configure change tracking
Caching
Transaction management

To use DbContext in our application, we need to create the class that derives from DbContext, also known as context class. This context class typically includes DbSet properties for each entity in the model. Consider the following example of context class in EF Core.

public class SchoolContext : DbContext
{
    public SchoolContext()
    {

    }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
    }
    //entities
    public DbSet<Student> Students { get; set; }
    public DbSet<Course> Courses { get; set; }
}

In the example above, the SchoolContext class is derived from the DbContext class and contains the DbSet properties of Student and Course type. It also overrides the OnConfiguring and OnModelCreating methods. We must create an instance of SchoolContext to connect to the database and save or retrieve Student or Course data.

The OnConfiguring() method allows us to select and configure the data source to be used with a context using DbContextOptionsBuilder. Learn how to configure a DbContext class at here.

The OnModelCreating() method allows us to configure the model using ModelBuilder Fluent API.

Default logging providers in ASP.NET Core

manoj — Fri, 01 Oct 2021 17:27:48 +0000

Main() method in the Program class in Program.cs file is the entry point for an asp.net core application. This method calls CreateDefaultBuilder() method performs several tasks like

Setting up the web server
Loading the host and application configuration from various configuration sources and Configuring logging

The following is the code snippet from CreateDefaultBuilder() method.

.ConfigureLogging((hostingContext, logging) =]
{
    logging.AddConfiguration(hostingContext.Configuration.GetSection("Logging"));
    logging.AddConsole();
    logging.AddDebug();
    logging.AddEventSourceLogger();
})

As part of configuring logging, CreateDefaultBuilder() method adds the following 3 logging providers by default. This is the reason when we run the asp.net core project we see the log displayed both on the console and on the debug window in Visual Studio.

Console
Debug
EventSource

CreateDefaultBuilder() method looks for Logging section in the application configuration file appsettings.json.

Logging section in appsettings.json

The following is the Logging section in appsettings.json file on my machine.

"Logging": {
  "LogLevel": {
    "Default": "Warning",
    "Microsoft": "Information"
  }
}

LogLevel is used to control how much log data is logged or displayed.

EF Core - Migrations

manoj — Wed, 29 Sep 2021 16:44:29 +0000

Step 1. Install EF Core DB Provider
Install NuGet Package for the provider of the DB, we want to access, here we want to access MS SQL Server DB, so we need to install.

Microsoft.EntityFrameworkCore.SqlServer NuGet package
Microsoft.EntityFrameworkCore.Design NuGet package

Step 2. Install EF Core Tools
Along with DB provider package, also need to install EF tools to execute EF Core commands.
These make it easier to perform several EF Core-related tasks in your project at design time, such as migrations, scaffolding(demonstrate to solve problem or offering support), etc.
Note: Migrations are a way of defining the schema(representation of a plan or theory) of your database.

In order to execute EF Core commands from Package Manager Console,
search for the Microsoft.EntityFrameworkCore.Tools package (v 5.0.9) from NuGet UI & install.

Step 3. Create Model & Context Classes
We first write the code, which means Model classes, and on the basis of these classes our tables are auto-generated inside the database.

Model:

Context:

Step 4. Create Connection String
To create these tables in the database we have to define our connection string where we will define our server and database name.
Connection string you need to write inside the appsetting.json file

Step 5. Install dotnet ef tool
Open Developer PowerShell Terminal from visual studio (View → Terminal) and run below command

>dotnet tool install --global dotnet-ef

Step 6. Create Database using Migration
Run the below command in Developer PowerShell Terminal to create the initial migration script.

>dotnet ef migrations add BaseMigration --context EmployeeContext

In the above,"BaseMigration" is descriptive name of the migration. "EmployeeContext" is context name.

We have only created the migration script which is responsible for creating the database and its table. But we’ve not created the actual database and tables. So, let’s execute the migration script and generate the database and tables. Therefore, executing the migration scripts we have to execute ‘update-database’ command.

>dotnet ef database update

Step 7. Update Database using Migration
After initial migration , you add additional fields or change existing field in your model then your model and your database are now out of sync.
We must apply model changes to your database schema. To create a new migration run below command

dotnet ef migrations add AddPaymentkeyToEmployee

In the above, "AddPaymentkeyToEmployee" is descriptive name of the migration. Note that we give migrations a descriptive name, to make it easier to understand the project history later.

Since this isn't the project's first migration, EF Core now compares your updated model against a snapshot of the old model, before the column was added or modified; the model snapshot is one of the files generated by EF Core when you add a migration, and is checked into source control. Based on that comparison, EF Core detects that a column has been added, and adds the appropriate migration.
You can now apply your migration as before:

>dotnet ef database update

Ref: https://docs.microsoft.com/en-us/ef/core/

AutoMapper in C#

manoj — Tue, 28 Sep 2021 17:14:35 +0000

AutoMapper in C# is a mapper between two objects. That is AutoMapper is an object-object mapper. It maps the properties of two different objects by transforming the input object of one type to the output object of another type.

It also provides some interesting facts to take the dirty work out of figuring out how to map an object of type A with an object of type B as long as the object of type B follows AutoMapper’s established convention.

Let’s discuss the step-by-step procedure to use AutoMapper in C#.

1: Installing the AutoMapper library

The AutoMapper is an open-source library present in GitHub. To install this library, open the Package Manager Console window and then type the following command and press enter key to install the AutoMapper library in your project:

> Install-Package AutoMapper

Once you installed the AutoMapper library, then it will add a reference to the AutoMapper dll which you can find in the project references section as shown in the below image.

2: Initializing or Configuring the AutoMapper

Once you have defines your types (i.e. classes) then you can create a mapper for the two types using the constructor of MapperConfiguration class. You can create only one MapperConfiguration instance per AppDomain and should be instantiated during the application start-up. The syntax to create the MapperConfiguration instance is given below.

//Initialize the mapper
  var config = new MapperConfiguration(cfg =>
               cfg.CreateMap<Employee, EmployeeDTO>()
            );

The type on the left is the source type i.e. TSource, in our example, it will be going to Employee object, and the type on the right is the destination type i.e. TDestination, in our example, it will be going to EmployeeDTO object. So, two maps the Employee with EmployeeDTO, you need to create the mapper configuration.

using System;
using AutoMapper;
namespace AutoMapperDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            //Initialize the mapper
            var config = new MapperConfiguration(cfg =>
                    cfg.CreateMap<Employee, EmployeeDTO>()
                );

            //Creating the source object
            Employee emp = new Employee
            {
                Name = "James",
                Salary = 20000,
                Address = "London",
                Department = "IT"
            };

            //Using automapper
            var mapper = new Mapper(config);
            var empDTO = mapper.Map<EmployeeDTO>(emp);
            //OR
            //var empDTO2 = mapper.Map<Employee, EmployeeDTO>(emp);

            Console.WriteLine("Name:" + empDTO.Name + ", Salary:" + empDTO.Salary + ", Address:" + empDTO.Address + ", Department:" + empDTO.Department);
            Console.ReadLine();
        }
    }

    public class Employee
    {
        public string Name { get; set; }
        public int Salary { get; set; }
        public string Address { get; set; }
        public string Department { get; set; }
    }

    public class EmployeeDTO
    {
        public string Name { get; set; }
        public int Salary { get; set; }
        public string Address { get; set; }
        public string Department { get; set; }
    }
}

Ref: https://dotnettutorials.net/lesson/automapper-in-c-sharp/