DEV Community: Sudha Subramaniam

How to create a .env file in an ASP.NET Core Web API project and use its values in the application configuration

Sudha Subramaniam — Thu, 23 May 2024 06:19:08 +0000

Install DotNetEnv

First, add the DotNetEnv package to your project. Right-click your project, then select NuGet Packages, search for DotNetEnv, and install it

Create a '.env' file

Create a .env file in the root of your project directory. Add your connection string and any other environment-specific settings you need.
Example '.env' :



ConnectionStrings__DBCon=YourSecureConnectionString

Update program.cs to load environment variables from the '.env' file and integrate them to the configuration

Example 'program.cs' :



using DotNetEnv;

// Load .env file
DotNetEnv.Env.Load();

//Configure connection string from environment variable
var connectionString = Environment.GetEnvironmentVariable("ConnectionStrings__DBCon");
if (string.IsNullOrEmpty(connectionString))
{
    throw new Exception("Connection string not found. Ensure the .env file is correctly configured and placed in the root directory.");

//Add connection string to the applications configuration system
builder.Configuration.AddInMemoryCollection(new Dictionary<string, string>
{ {"ConnectionStrings:DBCon", connectionString }
});

Reference Environment Variables in appsettings.json

Modify your appsettings.json to include placeholders for environment variables. These placeholders will be replaced by the values from the .env file when the application runs.



{% raw %}`{
  "ConnectionStrings": {
    "DBCon": "Environment variable not set"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*"
}
```
### Configure Environment Variables in Azure
Step 1: Open the Azure Portal
Step 2: In the left-hand menu, select Environment vairables under the Settings section.
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/em8xw4dw9o2ty0wsf2mp.png)
Step 3: Add a new setting for each environment variable you need. For example:
Name: ConnectionStrings__DBCon
Value: your-connection-string-here
Then save it.
By configuring environment variables in Azure, you ensure your application is secure, flexible, and maintainable.

Git and Github

Sudha Subramaniam — Wed, 05 Apr 2023 02:06:29 +0000

Git is a software that allows you to keep track of changes that you made to a project overtime. Git works by recording changes you make to a project, storing those changes and allowing to reference them as need.

All git commands follow the pattern git and in order to use git for a project, a project must first be initialized using the git init command in the project's root directory.

Git Project Workflow
A Git project has three parts:

A Working Directory: where files are created, edited, deleted, and organized
A Staging Area: where changes that are made to the working directory are listed
A Repository: where Git permanently stores changes as different versions of the project
The Git workflow consists of editing files in the working directory, adding files to the staging area, and saving changes to a Git repository.

Git commands

git init : The command sets up all the tools Git needs to begin tracking changes made to the project. It creates a new Git repository
git status: This command helps to check the status of changes made to the project
git add : In order for git to start tracking the project, it needs to be added in the staging area. We can add a file to staging area with git add filename
git diff : Using this command we can check the differences between the working directory and the staging area.git diff filename
git commit : Git commit is the last step in git workflow. Commits permanently stores changes from staging area inside the repository
git log : Often with Git, you’ll need to refer back to an earlier version of a project. Commits are stored chronologically in the repository and can be viewed with: git log (shows a list of all previous commits)
git show HEAD: In Git, the commit you are currently on is known as the HEAD commit. In many cases, the most recently made commit is the HEAD commit.

An overview of a typical Git project workflow:

Create a Git repository: Initialize a Git repository on your local machine or create one on a Git hosting service such as GitHub or GitLab.

Create a branch: Create a new branch for each new feature or bug fix you want to work on. This allows you to work on changes without affecting the main codebase.

Make changes: Make changes to the files in your branch using your preferred text editor or integrated development environment (IDE).

Stage changes: Use the Git command git add to stage the changes you've made. This tells Git which files you want to include in the next commit.

Commit changes: Use the Git command git commit to create a new commit with a descriptive message summarizing the changes you've made. Commits should be small and focused, addressing one specific feature or bug fix at a time.

Push changes: Use the Git command git push to push your committed changes to the remote repository on GitHub or GitLab.

Create a pull request: If you're working with a team, create a pull request to merge your changes into the main codebase. This allows other team members to review your changes before they are merged.

Resolve conflicts: If there are conflicts between your changes and the main codebase, resolve them by editing the affected files and committing the changes.

Merge changes: Once your changes have been approved and any conflicts have been resolved, merge your branch into the main codebase.

Update local repository: Use the Git command git pull to update your local repository with any changes that have been made by other team members.

Different ways of writing a function in Javascript

Sudha Subramaniam — Wed, 22 Feb 2023 17:47:33 +0000

Here are several ways to write functions in JavaScript:

Function declaration: This is the most common way of declaring a function in JavaScript. It uses the function keyword followed by the function name, parameter list in parentheses, and the function body in curly braces. For example:


`function addNumbers(x, y) {
  return x + y;
}`

Function expression: A function expression is created by assigning a function to a variable. It can be either an anonymous function or a named function. For example:

var addNumbers = function(x, y) {
  return x + y;
};

Arrow function: Arrow functions provide a shorter syntax for writing function expressions. They are denoted by a fat arrow => and do not require the function keyword. For example:

var addNumbers = (x, y) => {
  return x + y;
};

You can also omit the curly braces and return keyword for single-line arrow functions:

var addNumbers = (x, y) => x + y;

Function constructor: This method creates a function using the Function constructor. It takes a string of arguments and function body as parameters. For example:

var addNumbers = new Function('x', 'y', 'return x + y');

Generator function: A generator function returns an iterator object that can be used to iterate through a sequence of values. It is declared using the function* keyword and contains one or more yield statements. For example:


function* generateNumbers() {
  yield 1;
  yield 2;
  yield 3;
}

Immediately invoked function expression (IIFE): An IIFE is a function that is declared and invoked immediately. It is typically used to create a private scope for variables and functions. For example:

(function() {
  // code here
})();

These are some of the most common ways to write functions in JavaScript. Each has its own advantages and use cases, so it's important to choose the right method for your particular situation.

Runtime environment

Sudha Subramaniam — Wed, 15 Feb 2023 11:08:47 +0000

A runtime environment is where your program will be executed. JavaScript code may be executed in one of two runtime environments:

- A browser’s runtime environment
- The Node runtime environment

In each of these environments, different data values and functions are available, and these differences help distinguish front-end applications from back-end applications.

Front-end JavaScript applications are executed in a browser’s runtime environment and have access to the window object.
Back-end JavaScript applications are executed in the Node runtime environment and have access to the file system, databases, and networks attached to the server.

What is cookies? What is cache?

Sudha Subramaniam — Mon, 13 Feb 2023 21:05:42 +0000

Cookies are small text files that website stores in your browser which contain information pertaining to that website. Each time you return to that website, the data or cookie is sent back to the site.

Cookies may contain:

Usernames and passwords
Links that you've clicked on
Your cart information for buying online
Visitor tracking information
Your computer's general location in the world
Video's you've watched.

Cache
``
The cache is a portion of hard disk space where your web browser stores copies of internet files for re-use.

Your computer saves files from sites that you visit online.
When you have a cached copy of a website, it will load faster.