DEV Community: Aryan Absalan

Handling Passwords and Secret Keys using Environment Variables

Aryan Absalan — Mon, 14 Feb 2022 20:50:47 +0000

To save passwords and secret keys in environment variables on Windows, you will need to open Advance System Setting.

You can navigate to control panel > System and Security > System > Advanced system Settings.
Now in Advance System Setting click on Environment Variables.
Here we can add new user variables and new system variables. We will add user variable by clicking New under user variables.

In the new window you can add Variable name and Variable value and click ok.
Now, click Ok on Environment Variables window to save changes.

Access the environmental variables
To access these variables in our python script, we need to import the os module.
We can do that by using os.environ.get() method and passing the key we want to access.

If you are using .python-dotenv method you need to add a couple of lines at the start of your application.

from dotenv import load_dotenv
load_dotenv()

In case of Django project, you should add the above script at the top of wsgi.py and manage.py file.

from dotenv import load_dotenv #for python-dotenv method
load_dotenv() #for python-dotenv method

import os

user_name = os.environ.get('USER')
password = os.environ.get('password')

print(user_name, password)

###### output

username password

Python’s Virtual Environments

Aryan Absalan — Mon, 03 Jan 2022 08:10:05 +0000

execute the venv module, which is part of the Python standard library.
crating test-project folder
% cd test-project/
Creating an environment called venv
% python3 -m venv venv/

For activating the venv on Windows:
C:> \Scripts\activate.bat
installing the requirements of the project with:
pip install -r requirements.txt

You can deactivate a virtual environment by typing “deactivate”
you can Remove virtual environments using rm:
rm -r your_ENV

C# Static Class

Aryan Absalan — Thu, 26 Nov 2020 14:29:43 +0000

In C#, static means something which cannot be instantiated. You cannot create an object of a static class and cannot access static members using an object.

C# classes, variables, methods, properties, operators, events, and constructors can be defined as static using the static modifier keyword.

Static Class

A static class cannot be instantiated. All members of a static class are static and are accessed via the class name directly, without creating an instance of the class.

The following code is an example of a static class, CSharpCorner. We know that all members of the class are static.
public static class CSharpCorner

{

// Static fields

public static string Name = "C# Corner";

public static string Founder = "Mahesh Chand";

public static DateTime YearFounded = new DateTime(2000, 01, 01);

public static string Location = "Downingtown, PA";

public static string Description =

"Online community of software and data developers";

public static int GetAgeOfWebsite()

{

return 1;

}

}

Static classes have the following characteristics:
Static classes cannot contain Instance Constructors.
Static classes contain only static members.
Static classes cannot be instantiated.
Static classes are sealed. That means, you cannot inherit other classes from instance classes.
You can learn more about static classes here: Static Class in C#

Static Members

A static or non-static class static constructors, properties, methods, fields, operators, and events. Static properties and static methods are the most-used static members.

Static Constructor

Static constructor can't be parameterized.
Static constructor doesn't have any access modifier because it doesn't have message passing and is used during domain processing.
Static Constructor is used to initialize static data members of the class.

Static Field

A field with the static keyword represents a static field. Static fields can be declared as follows by using the static keyword.
public static class HistoryTeacher

{

// static field

public static string Subject = "History";

}

The following code calls a static field.
Console.WriteLine(HistoryTeacher.Subject);

When we declare static data members inside a class, it can be initialized with a value as shown above. All un-initialized static fields automatically get initialized to their default values when the class is loaded for the first time.

Static Property

Static properties are used to get or set the value of static data members of a class. The following code example declares four static properties.
public static class HistoryTeacher

{

// private fields

private static string name;

private static string school;

private static int rank;

private static int years;

// static properties

public static int Years { get => years; set => years = value; }

public static int Rank { get => rank; set => rank = value; }

public static string School { get => school; set => school = value; }

public static string Name { get => name; set => name = value; }

}

The following code example sets static property values.
HistoryTeacher.Name = "Mahesh Chand";

HistoryTeacher.Rank = 2;

HistoryTeacher.School = "Garnet Valley High School";

HistoryTeacher.Years = 5;

In the same way, you can access a static property by using the class name.
Console.WriteLine(HistoryTeacher.Name);

Static Method

Static methods are shared methods. They can be called with the class name and static method name only. You cannot instantiate a static method.

Static methods only use static data members to perform calculation or processing.

The following code example declares a static method that takes two int values as method arguments.
public static class HistoryTeacher

{

// static method

public static int CalculateScore(int rank, int years)

{

return rank * years;

}

}

The following code example calls a static method.
Console.WriteLine(HistoryTeacher.CalculateScore(3, 5));

Why use static classes and static members?

Static classes are used as containers for static members. Static methods and static properties are the most-used members of a static class. All static members are called directly using the class name. Static methods do a specific job and are called directly using a type name, rather than the instance of a type.

Here is a list of few use cases of static classes.
A Math class with all static methods. Static classes are useful and provide an easy way to access its members that does not need to work differently for different objects.
Above listed CSharpCorner class. We know the value of CSharpCorner class members such as its founder, launch date, location, and description, will never change regardless of its objects.
App Configuration class that has all static settings about an app and the values of settings don’t change based on the objects or users.
A DatabaseConfig class that may have members such as database name, server name, port number, and even a connection string. We know that these values will not change for objects.
Static classes and static members are useful because they do not require instances created for each new object. That means, they consume fewer resources and no duplication of the same class or member is needed in memory.

Static members make code cleaner.

In theory, a static should give better performance compare to an instance. However, it is unnoticeable.

Complete Code Example

Here is a complete program that shows how to use static class and static members.
using System;

namespace StaticInCSharp

{

class Program

{

static void Main(string[] args)

{

Console.WriteLine(HistoryTeacher.Subject);

HistoryTeacher.Name = "Mahesh Chand";

HistoryTeacher.Rank = 2;

HistoryTeacher.School = "Garnet Valley High School";

HistoryTeacher.Years = 5;

Console.WriteLine(HistoryTeacher.Name);

Console.WriteLine(HistoryTeacher.CalculateScore(3, 5));

Console.ReadKey();

}

}

public static class HistoryTeacher

{

// static field

public static string Subject = "History";

// private fields

private static string name;

private static string school;

private static int rank;

private static int years;

// static properties

public static int Years { get => years; set => years = value; }

public static int Rank { get => rank; set => rank = value; }

public static string School { get => school; set => school = value; }

public static string Name { get => name; set => name = value; }

// static method

public static int CalculateScore(int rank, int years)

{

return rank * years;

}

}

}

The Object-Oriented Programming in C#

Aryan Absalan — Thu, 26 Nov 2020 14:23:48 +0000

The Object-Oriented Programming in C#

The Object-Oriented Programming (OOPs) in C# is a design approach where we think in terms of real-world objects rather than functions or methods. Unlike procedural programming language, here in oops, programs are organized around objects and data rather than action and logic.

OOPs, provide 4 principles. They are

Encapsulation

Inheritance

Polymorphism

Abstraction

We will discuss all these principles in detail using some real-time examples.
But first, we define some simple classes.

Class and Objects from Layman Point of View.
From the layman point of view, we can define a class as a blueprint of a specific object. Every living and non-living thing is considered as objects such as Car, People, Place, etc. Again, each and every object has some color, shape, properties, and functionalities.

For example, consider the luxury car Ferrari. Here, Ferrari is an object of the luxury car type. The luxury car is a class that specifies some characteristics such as speed, color, shape, etc. So any car manufactures company that makes a car and if that car meets all those requirements, then it is an object of the luxury car type.

If you take the example BMW, Lamborghini, and Cadillac, then all these cars are an object of the ‘Luxury Car’ class. Here, ‘Luxury Car’ is a class and every single car (BMW, Lamborghini, and Cadillac) is an object of the luxury car class. Now, let us understand what exactly class and objects from the programming point of view.

Class and Objects from Programming Language Point of View.
Here we are going to understand the class and objects from the C# programming language point of view. But this is also applicable to any object-oriented programming language like java and c++.

Class:
A class is simply a user-defined data type that represents both state and behavior. The state represents the properties and behavior is the action that objects can perform.

In other words, we can say that a class is the blueprint/plan/template that describes the details of an object. A class is a blueprint from which the individual objects are created. In C#, a Class is composed of three things i.e. a name, attributes, and operations.

Objects:
It is an instance of a class. A class is brought live by creating objects. An object can be considered as a thing that can perform activities. The set of activities that the object performs defines the object’s behavior.

All the members of a class can be accessed through the object. To access the class members, we need to use the dot (.) operator. The dot operator links the name of an object with the name of a member of a class.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace ClassDemo

{

class Program

{

    static void Main(string[] args)

    {



        Console.WriteLine("Example of defining a class in C#, setting its properties and calling its method/s.");



        // defining the first object of student class as tim

        Student tim = new Student();

        // setting the poblic attributes for the first object

        tim.FirstName = "Tim";

        tim.LastName = "Timmabc";





        // defining the second object of student class as jim

        Student jim = new Student();

        // setting the poblic attributes for the second object

        jim.FirstName = "Jim";

        jim.LastName = "Jimmxyz";



        //Calling the Display method for both objects

        tim.Display();

        jim.Display();



        Console.ReadKey();

    }

}



class Student

{

    //Public properties

    public string FirstName { get; set; }

    public string LastName { get; set; }



    //Default constructor.

    public Student()

    {

    }



    //Public method

    public void Display()

    {

        Console.WriteLine("\t Student first name:  " + this.FirstName);

        Console.WriteLine("\t Student last name:  " + this.LastName);

    }

}