Create one class per file. This will allow for easy navigation. Currently you have put 2 classes in the Dropdownlist.cs file. This should instead of split into multiple files based on the classes they contain.

I see that there are a bunch of abbreviations that you have used - Accid for AccountId, AccName for AccountName and Acclist for AccountList.

You write code so that someone else might be able to read it

Abbreviations are usually done when we as the programmer assumes something. But this assumption might not be totally obvious to the person reading your code.

As a programmer, one of the strongest skills you can develop is to name your variables properly -- your future self and your co-workers will find it very easy to understand your code.

Please change this wherever required.

Consider this query that you have written:

var query = connection.Execute(@"INSERT INTO transaction(account_id,amount,date,note)
                        SELECT a.account_id,@amount, @date, @note
                        FROM account AS a
                        WHERE a.account_name=@account", new { amount = amount, date = date, note=note, account=account});

Here, your substitutions are amount, date, note and account. For which the query parameters are of the same name. In such a case C# allows you to use the variable name directly instead of specifying it again in the anonymous class

So you can write this as

var query = connection.Execute(@"...", new { amount, date, note, account })

Read more about Anonymous classes here. They will be used widely in production code.

In HomeController.AllTransactionsList, I see that you have used multiple connections for making the different queries. Accordingly you have used multiple readers, and multiple command objects.

All this can be done with a single connection, reader and command object called sequentially one after another.

Currently multiline strings are being separated by closing one line and using the + operator to concatenate. When we are writing queries that are long, this option will become hard to maintain.

C# has an easier way to do this using the Verbatim Literal - @. Read about it here and use it instead of concatenation.

Give this a read and implement it. Our formatting is loosely based on this.

"There are only 3 problems in computer science - Naming things and off-by-one exceptions"

Always always always name things properly.

Using string.Format is definitely one way of doing substitution in SQL queries, but such an operation is still open to SQL Injection. The right way to do something like this that is protected from SQL Injection is to use "prepared statements".

Here is some documentation of how to do it with Npgsql. Please change all queries to use prepared statements instead of string.Format

There are a lot of unnecessary files being committed into the repository. Use a proper .gitignore file and refresh the repository so that only the code is committed.

I see here: https://github.com/santosh-kumar-metikoti/Expense-Manager/blob/main/WebApplication4/Controllers/HomeController.cs#L37 and in other places that you have chosen to return a data set or a data table.

While this is OK, a better approach would be to return a model that is strongly typed instead. For example, in the Index() action of the controller, you want to return a list of transactions, so I would choose to do something like this:

public class TransactionsViewModel
{
  public List<Transaction> Transactions {get; set;}
}

public class Transaction
{
  public string Account { get; set; }
  // other fields
}

and populate Transactions accordingly based on what you retrieve from the Data Set.

The advantage with that is that the contract between your action and your view is a strict contract at this time. This means that any change on either side will throw compiler errors. Currently you are using: https://github.com/santosh-kumar-metikoti/Expense-Manager/blob/main/WebApplication4/Views/Home/Index.cshtml#L45-L53 a string in order to retrieve information from each row (@row["account"]) - this is error prone because if someone misspells the word account then we will only know at runtime instead of at compile time.

In the case of using a model, this would look like:

<td>@Model.Account</td>

Which is checked at compile time ✔️

Please change all your actions to return Models instead of returning Data Table / Data Set

Note

There will be an additional looping through the data set / table in order to populate the list, but we will deal with that shortly.