JholJhapata - User contributions [en]

SudokuSolver

2025-06-01T08:13:52Z

Admin: Created page with "Here’s a simple Sudoku Solver in C# using backtracking. It works on a standard 9x9 Sudoku grid. SudokuSolver using System; using S..."

Here’s a simple Sudoku Solver in C# using backtracking. It works on a standard 9x9 Sudoku grid.

[[File:SudokuSolver.png|thumb|SudokuSolver]]

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace sudoku_console
{
internal class Program
{
static int SIZE = 9;
public static void Main()
{
int[,] board = {
{5, 3, 0, 0, 7, 0, 0, 0, 0},
{6, 0, 0, 1, 9, 5, 0, 0, 0},
{0, 9, 8, 0, 0, 0, 0, 6, 0},
{8, 0, 0, 0, 6, 0, 0, 0, 3},
{4, 0, 0, 8, 0, 3, 0, 0, 1},
{7, 0, 0, 0, 2, 0, 0, 0, 6},
{0, 6, 0, 0, 0, 0, 2, 8, 0},
{0, 0, 0, 4, 1, 9, 0, 0, 5},
{0, 0, 0, 0, 8, 0, 0, 7, 9}
};
if (Solve(board))
{
PrintBoard(board);
Console.ReadLine();
}
else
{
Console.WriteLine("No solution exists.");
}
}
static bool Solve(int[,] board, bool isTimer = false)
{
for (int row = 0; row < SIZE; row++)
{
for (int col = 0; col < SIZE; col++)
{
if (board[row, col] == 0)
{
for (int num = 1; num <= 9; num++)
{
if (IsValid(board, row, col, num))
{
board[row, col] = num;
if (isTimer)
Thread.Sleep(1000);
if (Solve(board))
return true;
board[row, col] = 0; // backtrack
}
}
return false; // no valid number found
}
}
}
return true; // board is solved
}
static bool IsValid(int[,] board, int row, int col, int num)
{
for (int x = 0; x < SIZE; x++)
{
if (board[row, x] == num || board[row, x] == num)
return false;
}
for (int x = 0; x < SIZE; x++)
{
if (board[x, col] == num || board[x, col] == num)
return false;
}
int startRow = row / 3 * 3;
int startCol = col / 3 * 3;
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
if (board[startRow + i, startCol + j] == num)
return false;
}
}
return true;
}
static void PrintBoard(int[,] board)
{
for (int i = 0; i < SIZE; i++)
{
for (int j = 0; j < SIZE; j++)
{
Console.Write(board[i, j] + " ");
}
Console.WriteLine();
}
}
}
}

File:SudokuSolver.png

2025-06-01T08:12:48Z

Admin:

SudokuSolver

State Management in ASP.NET

2022-08-03T12:21:58Z

Admin: /* OutProc */

As we all know, '''HTTP''' or '''HTTPS''' is stateless protocol. It just cleans up or we can say removes all the resources/references that were serving a specific request in the past.

Stateless means, whenever we visit a website, our browser communicates with the respective server depending on our requested functionality or the request. In this case HTTP/HTTPs doesn't remember what website or URL we visited, or in other words we can say it doesn't hold the state of a previous website that we visited before closing our browser, that is called stateless.

So our browsers are stateless.

== State Management Types ==
[[File:State Management Techniques.png|none|State Management Techniques]]

== Client-side | Techniques ==
=== View State ===
[[ASP.NET View State|View State]] is the method to preserve the Value of the Page and Controls between round trips. It is a Page-Level State Management technique. View State is turned on by default and normally serializes the data in every control on the page regardless of whether it is actually used during a post-back.Please keep in mind though, that while cookies and sessions can be accessed from all your pages on your website, ViewState values are not carried between pages.

=== Hidden field ===
[[ASP.NET Hidden Field|Hidden Field]] is non visual control in ASP.NET where we can save the value. This is one of the types of client-side state management tools. It stores the value between the roundtrip. Anyone can see Hidden Field details by simply viewing the source of document.
=== Cookies ===
[[ASP.NET Cookies|Cookies]] is a small piece of information stored on the client machine. Its is used to store user preference information like Password, City, SessionId etc on client machines. We need to import namespace called Systen.Web before we use cookie(HttpCookie).
=== Control State ===
The '''control state''' is a way to save a control’s state information when the EnableViewState property is turned off. Unlike ViewState a developer can’t turn off control state. The control state can be implemented only in controls that you implement. ControlState is used to store small amounts of critical information. Heavy usage of ControlState can impact the performance of application because it involves '''serialization''' and '''deserialization''' for its functioning.

There are two methods('''SaveControlState''' and '''LoadControlState''') which we have to implement in your custom control and on '''OnInit''' method of the control we need to add the call for the '''Page.RegisterRequiresControlState()''' method with the instance of the control to register.

public class ControlWebControl : Control
{
private string _strStateToSave;
protected override void OnInit(EventArgs e)
{
Page.RegisterRequiresControlState(this);
base.OnInit(e);
}
protected override object SaveControlState()
{
return _strStateToSave;
}
protected override void LoadControlState(object state)
{
if (state != null)
{
_strStateToSave = state.ToString();
}
}
}

=== Query Strings ===
[[ASP.NET Query Strings|Query string]] is one of the techniques in Web applications to send data from one page to another. A query string consists of two parts, field and value, and each of pair separated by ampersand (&). The ?(question mark in a query string indicates the beginning of a query string and it's value.

== Server-side | Technique ==
=== Session State ===
==== InProc ====
==== OutProc ====
ASP.NET session state is designed to enable you to easily store user session data in different sources for your ASP.NET applications. By default, session state values and information are stored in memory within the ASP.NET process. Alternatively, you can store [[OutProc Session SQLServer|session data in a SQL Server database]], where it can be shared by multiple Web servers. For more information about session state, see Implementing a Session-State Store Provider and Session-State Modes.

=== Application State ===

OutProc Session SQLServer

2022-08-03T10:47:17Z

Admin:

ASP.NET session state is designed to enable you to easily store user session data in different sources for your ASP.NET applications. By default, session state values and information are stored in memory within the ASP.NET process. Alternatively, you can store session data in a SQL Server database, where it can be shared by multiple Web servers. For more information about session state, see Implementing a Session-State Store Provider and Session-State Modes.

=== Configure SQL Server to store ASP.NET session state ===

Before you can actually store a session state in SQL server, you need to configure it. This configuration is done via a command line tool called ASPNET_REGSQL.EXE. You can store the session state in three possible locations within the SQL Server:

{| class="wikitable"
|-
! Command !! Description
|-
| -S <server> || Species the IP address or the name of SQL server in which you want to store the session state
|-
| -U || Specifies the user ID to be used when connecting to the SQL Server
|-
| -P || Specifies the password to be used when connecting to the SQL Server
|-
| -E || Indicates that you want to use integrated security when connecting to the SQL Server
|-
| -ssadd || Adds support for the SQLServer mode session state
|-
| -ssremove || Removes support for the SQLServer mode session state
|-
| -sstype || Type of session state support. This option can be: 
t for temporary storage 
p for persistent storage 
c for custom storage
|-
| -d <database> || The name of the custom database to use if -sstype switch is "c"
|}

It opens command prompt. Type the following command to create the SQL State Database tables and procedures.

'''C:\%windir%\Microsoft.NET\Framework\<versionNumber>\'''

For creating default Database for SQL State.

'''aspnet_regsql.exe -S XXXXX -U XX -P XXXXXXXXX -ssadd -sstype p'''

Update <sessionState> tag in '''web.congif'''

<system.web>
<sessionState mode="SQLServer" sqlConnectionString="data source=DESKTOP-ABGPQE5; user id=sa;password=XXXXXXXXX;" cookieless="false" timeout="20"/>
</system.web>

OutProc Session SQLServer

2022-07-29T15:29:16Z

Admin: Created page with "ASP.NET session state is designed to enable you to easily store user session data in different sources for your ASP.NET applications. By default, session state values and info..."

ASP.NET session state is designed to enable you to easily store user session data in different sources for your ASP.NET applications. By default, session state values and information are stored in memory within the ASP.NET process. Alternatively, you can store session data in a SQL Server database, where it can be shared by multiple Web servers. For more information about session state, see Implementing a Session-State Store Provider and Session-State Modes.

=== Configure SQL Server to store ASP.NET session state ===

Before you can actually store a session state in SQL server, you need to configure it. This configuration is done via a command line tool called ASPNET_REGSQL.EXE. You can store the session state in three possible locations within the SQL Server:

{| class="wikitable"
|-
! Command !! Description
|-
| -S <server> || Species the IP address or the name of SQL server in which you want to store the session state
|-
| -U || Specifies the user ID to be used when connecting to the SQL Server
|-
| -P || Specifies the password to be used when connecting to the SQL Server
|-
| -E || Indicates that you want to use integrated security when connecting to the SQL Server
|-
| -ssadd || Adds support for the SQLServer mode session state
|-
| -ssremove || Removes support for the SQLServer mode session state
|-
| -sstype || Type of session state support. This option can be: 
t for temporary storage 
p for persistent storage 
c for custom storage
|-
| -d <database> || The name of the custom database to use if -sstype switch is "c"
|}

It opens command prompt. Type the following command to create the SQL State Database tables and procedures.

'''C:\%windir%\Microsoft.NET\Framework\<versionNumber>\'''

For creating default Database for SQL State.

'''aspnet_regsql.exe -S XXXXX -U XX -P XXXXXXXXX -ssadd -sstype p'''

Update <sessionState> tag in '''web.congif'''

<system.web>
<sessionState mode="SQLServer" sqlConnectionString="data source=DESKTOP-ABGPQE5; user id=sa;password=9fc300a7;" cookieless="false" timeout="20"/>
</system.web>

Threading

2020-11-29T18:14:16Z

2020-02-23T13:03:00Z

Admin:

Simple Factory Pattern returns an instance of one of several possible classes depending on the type of data provided. It is quite common to return a common parent class and common methods, but each may perform a task differently or optimize for different data or behaviors.

The classes in Simple Factory Pattern will have the same parent class and methods but will perform the task differently dependent of the type of data supplied.

Let's take a look at the diagram to get a high-level view of how the Simple Factory Pattern works in C#.
[[File:Simple Factory Pattern Diagram.png|Simple Factory Pattern]]
[[File:Simple Factory Pattern.png|Simple Factory Pattern]]

In the diagram Manufacture is a base class, and classes Permanent Employee and Contract Employee are derived from it, the Manufacture class decides which of the subclasses to return, depending on the arguments provided.

The developer using the Manufacture class doesn’t really care which of the subclasses is returned, because each of them have the same methods but will have different implementations. How the factory class(Manufacture class) decides which one to return, is entirely up to what data is supplied.
== Business Requirement Example ==
* We need two types of employee permanent and contract.
* Contract employee's Salary is 80000 and Bonus is 1000.
* Permanent employee's Salary is 50000 and Bonus is 5000.
=== Code Example ===
class EmployeeTypes
{
public int Id { get; set; }
public string Name { get; set; }
}
class Employees
{
public string Name { get; set; }
public EmployeeTypes EmployeeType { get; set; }
public int Salary { get; set; }
public int Bonus { get; set; }
}
class Program
{
static void Main(string[] args)
{
EmployeeTypes _contractEmplyeeType = new EmployeeTypes
{
Id = 2,
Name = "Contract Emplyee"
};
EmployeeTypes _permanentEmplyeeType = new EmployeeTypes
{
Id = 1,
Name = "Permanent Emplyee"
};
Employees _contractEmplyee = create("Jhon" , _contractEmplyeeType);
Employees _permanentEmplyee = create("Mario", _permanentEmplyeeType);
}
static Employees create(string name,EmployeeTypes employeeType)
{
Employees _employee = new Employees();
if(employeeType.Id==1)
{
_employee.Salary = 50000;
_employee.Bonus = 5000;
}
else if(employeeType.Id == 2)
{
_employee.Salary = 80000;
_employee.Bonus = 1000;
}
_employee.EmployeeType = employeeType;
return _employee;
}
}
== Problem ==
The above solves our business requirement but we have some drawbacks..
* Tightly coupled business logic.
* Need more development and testing effort when any changes required because we need to update the create() function every-time.
* Violating [[Single Responsibility Principle]] as '''Main''' function/class is responsible for object creation and payment declaration.
* Violating [[Open-Closed Principle|Open-Closed-principle]] as we need to change the main function/class every time when we need a new type of employee.

== Solution ==
Let's take a look at the below solution:
* We have decoupled Employee by using '''IEmployee''' interface.
* '''EmployeeFactory''' is responsible for object creation.
* '''Main''' function/class not responsible for object creation, so we don't have to change it when there is an update in salary/bonus or we have a new type of employee.
=== Code Example ===
public interface IEmployee
{
void setSalary();
void setBonus();
}
class PermanentEmployee : IEmployee
{
public string Name { get; set; }
public EmployeeTypes EmployeeType { get; set; }
public int Salary { get; set; }
public int Bonus { get; set; }
public void setBonus()
{
Bonus = 5000;
}
public void setSalary()
{
Salary = 50000;
}
}
class ContractEmployee : IEmployee
{
public string Name { get; set; }
public EmployeeTypes EmployeeType { get; set; }
public int Salary { get; set; }
public int Bonus { get; set; }
public void setBonus()
{
Bonus = 1000;
}
public void setSalary()
{
Salary = 80000;
}
}
class EmployeeFactory
{
public IEmployee GetEmployee(string name, EmployeeTypes employeeType)
{
IEmployee _employee= null;
if (employeeType.Id == 1)
{
_employee = new PermanentEmployee()
{
Name = name
};
}
else if (employeeType.Id == 2)
{
_employee = new ContractEmployee()
{
Name = name
};
}
return _employee;
}
}
class EmployeeTypes
{
public int Id { get; set; }
public string Name { get; set; }
}
class Program
{
static void Main(string[] args)
{
EmployeeTypes _contractEmplyeeType = new EmployeeTypes
{
Id = 2,
Name = "Contract Emplyee"
};
EmployeeTypes _permanentEmplyeeType = new EmployeeTypes
{
Id = 1,
Name = "Permanent Emplyee"
};
EmployeeFactory employeeFactory = new EmployeeFactory();
IEmployee _contractEmplyee = employeeFactory.GetEmployee("Jhon" , _contractEmplyeeType);
_contractEmplyee.setBonus();
_contractEmplyee.setSalary();
IEmployee _permanentEmplyee = employeeFactory.GetEmployee("Mario", _permanentEmplyeeType);
_permanentEmplyee.setBonus();
_permanentEmplyee.setSalary();
}
}
== Advantage of Simple Factory Pattern ==
This follows the [[Open-Closed Principle|Open-Closed-principle]]: Our Employee class is closed, as we have a fixed set of Employee, which we hire, but we are open for new Employees.

Further: Each new Employee have their set of functions. The Permanent Employee doesn't care what/how to do a Contract Employee ([[Single Responsibility Principle]]).

Last but not least, we decoupled different Employee types from the Main function. The main function needs only to know how to handle.

Factory Method Design Pattern

2020-02-23T11:25:19Z

Admin:

Simple Factory Pattern

2020-02-23T10:44:52Z

Admin:

Simple Factory Pattern returns an instance of one of several possible classes depending on the type of data provided. It is quite common to return a common parent class and common methods, but each may perform a task differently or optimize for different data or behaviors.

The classes in Simple Factory Pattern will have the same parent class and methods but will perform the task differently dependent of the type of data supplied.

Let's take a look at the diagram to get a high-level view of how the Simple Factory Pattern works in C#.
[[File:Simple Factory Pattern Diagram.png|Simple Factory Pattern]]
[[File:Simple Factory Pattern.png|Simple Factory Pattern]]

In the diagram Manufacture is a base class, and classes Permanent Employee and Contract Employee are derived from it, the Manufacture class decides which of the subclasses to return, depending on the arguments provided.

The developer using the Manufacture class doesn’t really care which of the subclasses is returned, because each of them have the same methods but will have different implementations. How the factory class(Manufacture class) decides which one to return, is entirely up to what data is supplied.
== Business Requirement Example ==
* We need two types of employee permanent and contract.
* Contract employee's Salary is 80000 and Bonus is 1000.
* Permanent employee's Salary is 50000 and Bonus is 5000.
=== Code Example ===
class EmployeeTypes
{
public int Id { get; set; }
public string Name { get; set; }
}
class Employees
{
public string Name { get; set; }
public EmployeeTypes EmployeeType { get; set; }
public int Salary { get; set; }
public int Bonus { get; set; }
}
class Program
{
static void Main(string[] args)
{
EmployeeTypes _contractEmplyeeType = new EmployeeTypes
{
Id = 2,
Name = "Contract Emplyee"
};
EmployeeTypes _permanentEmplyeeType = new EmployeeTypes
{
Id = 1,
Name = "Permanent Emplyee"
};
Employees _contractEmplyee = create("Jhon" , _contractEmplyeeType);
Employees _permanentEmplyee = create("Mario", _permanentEmplyeeType);
}
static Employees create(string name,EmployeeTypes employeeType)
{
Employees _employee = new Employees();
if(employeeType.Id==1)
{
_employee.Salary = 50000;
_employee.Bonus = 5000;
}
else if(employeeType.Id == 2)
{
_employee.Salary = 80000;
_employee.Bonus = 1000;
}
_employee.EmployeeType = employeeType;
return _employee;
}
}
== Problem ==
The above solves our business requirement but we have some drawbacks..
* Tightly coupled business logic.
* Need more development and testing effort when any changes required because we need to update the create() function every-time.
* Violating [[Single Responsibility Principle]] as '''Main''' function/class is responsible for object creation and payment declaration.
* Violating [[Open-Closed Principle|Open-Closed-principle]] as we need to change the main function/class every time when we need a new type of employee.

== Solution ==
Let's take a look at the below solution:
* We have decoupled Employee by using '''IEmployee''' interface.
* '''EmployeeFactory''' is responsible for object creation.
* '''Main''' function/class not responsible for object creation, so we don't have to change it when there is an update in salary/bonus or we have a new type of employee.
=== Code Example ===
public interface IEmployee
{
void setSalary();
void setBonus();
}
class PermanentEmployee : IEmployee
{
public string Name { get; set; }
public EmployeeTypes EmployeeType { get; set; }
public int Salary { get; set; }
public int Bonus { get; set; }
public void setBonus()
{
Bonus = 5000;
}
public void setSalary()
{
Salary = 50000;
}
}
class ContractEmployee : IEmployee
{
public string Name { get; set; }
public EmployeeTypes EmployeeType { get; set; }
public int Salary { get; set; }
public int Bonus { get; set; }
public void setBonus()
{
Bonus = 1000;
}
public void setSalary()
{
Salary = 80000;
}
}
class EmployeeFactory
{
public IEmployee GetEmployee(string name, EmployeeTypes employeeType)
{
IEmployee _employee= null;
if (employeeType.Id == 1)
{
_employee = new PermanentEmployee()
{
Name = name
};
}
else if (employeeType.Id == 2)
{
_employee = new ContractEmployee()
{
Name = name
};
}
return _employee;
}
}
class EmployeeTypes
{
public int Id { get; set; }
public string Name { get; set; }
}
class Program
{
static void Main(string[] args)
{
EmployeeTypes _contractEmplyeeType = new EmployeeTypes
{
Id = 1,
Name = "Contract Emplyee"
};
EmployeeTypes _permanentEmplyeeType = new EmployeeTypes
{
Id = 1,
Name = "Permanent Emplyee"
};
EmployeeFactory employeeFactory = new EmployeeFactory();
IEmployee _contractEmplyee = employeeFactory.GetEmployee("Jhon" , _contractEmplyeeType);
_contractEmplyee.setBonus();
_contractEmplyee.setSalary();
IEmployee _permanentEmplyee = employeeFactory.GetEmployee("Mario", _permanentEmplyeeType);
_permanentEmplyee.setBonus();
_permanentEmplyee.setSalary();
}
}
== Advantage of Simple Factory Pattern ==
This follows the [[Open-Closed Principle|Open-Closed-principle]]: Our Employee class is closed, as we have a fixed set of Employee, which we hire, but we are open for new Employees.

Further: Each new Employee have their set of functions. The Permanent Employee doesn't care what/how to do a Contract Employee ([[Single Responsibility Principle]]).

Last but not least, we decoupled different Employee types from the Main function. The main function needs only to know how to handle.

File:Factory Method Design Pattern.png

2020-02-23T10:43:20Z

Admin:

Factory Method Design Pattern

Simple Factory Pattern

2020-02-23T10:36:06Z

Admin:

Simple Factory Pattern returns an instance of one of several possible classes depending on the type of data provided. It is quite common to return a common parent class and common methods, but each may perform a task differently or optimize for different data or behaviors.

The classes in Simple Factory Pattern will have the same parent class and methods but will perform the task differently dependent of the type of data supplied.

Let's take a look at the diagram to get a high-level view of how the Simple Factory Pattern works in C#.
[[File:Simple Factory Pattern Diagram.png|Simple Factory Pattern]]
[[File:Simple Factory Pattern.png|Simple Factory Pattern]]

In the diagram Manufacture is a base class, and classes Permanent Employee and Contract Employee are derived from it, the Manufacture class decides which of the subclasses to return, depending on the arguments provided.

The developer using the Manufacture class doesn’t really care which of the subclasses is returned, because each of them have the same methods but will have different implementations. How the factory class(Manufacture class) decides which one to return, is entirely up to what data is supplied.
== Business Requirement Example ==
* We need two types of employee permanent and contract.
* Contract employee's Salary is 80000 and Bonus is 0.
* Permanent employee's Salary is 50000 and Bonus is 5000.
=== Code Example ===
class EmployeeTypes
{
public int Id { get; set; }
public string Name { get; set; }
}
class Employees
{
public string Name { get; set; }
public EmployeeTypes EmployeeType { get; set; }
public int Salary { get; set; }
public int Bonus { get; set; }
}
class Program
{
static void Main(string[] args)
{
EmployeeTypes _contractEmplyeeType = new EmployeeTypes
{
Id = 2,
Name = "Contract Emplyee"
};
EmployeeTypes _permanentEmplyeeType = new EmployeeTypes
{
Id = 1,
Name = "Permanent Emplyee"
};
Employees _contractEmplyee = create("Jhon" , _contractEmplyeeType);
Employees _permanentEmplyee = create("Mario", _permanentEmplyeeType);
}
static Employees create(string name,EmployeeTypes employeeType)
{
Employees _employee = new Employees();
if(employeeType.Id==1)
{
_employee.Salary = 50000;
_employee.Bonus = 5000;
}
else if(employeeType.Id == 2)
{
_employee.Salary = 80000;
_employee.Bonus = 0;
}
_employee.EmployeeType = employeeType;
return _employee;
}
}
== Problem ==
The above solves our business requirement but we have some drawbacks..
* Tightly coupled business logic.
* Need more development and testing effort when any changes required because we need to update the create() function every-time.
* Violating [[Single Responsibility Principle]] as '''Main''' function/class is responsible for object creation and payment declaration.
* Violating [[Open-Closed Principle|Open-Closed-principle]] as we need to change the main function/class every time when we need a new type of employee.

== Solution ==
Let's take a look at the below solution:
* We have decoupled Employee by using '''IEmployee''' interface.
* '''EmployeeFactory''' is responsible for object creation.
* '''Main''' function/class not responsible for object creation, so we don't have to change it when there is an update in salary/bonus or we have a new type of employee.
=== Code Example ===
public interface IEmployee
{
void setSalary();
void setBonus();
}
class PermanentEmployee : IEmployee
{
public string Name { get; set; }
public EmployeeTypes EmployeeType { get; set; }
public int Salary { get; set; }
public int Bonus { get; set; }
public void setBonus()
{
Bonus = 5000;
}
public void setSalary()
{
Salary = 50000;
}
}
class ContractEmployee : IEmployee
{
public string Name { get; set; }
public EmployeeTypes EmployeeType { get; set; }
public int Salary { get; set; }
public int Bonus { get; set; }
public void setBonus()
{
Bonus = 0;
}
public void setSalary()
{
Salary = 80000;
}
}
class EmployeeFactory
{
public IEmployee GetEmployee(string name, EmployeeTypes employeeType)
{
IEmployee _employee= null;
if (employeeType.Id == 1)
{
_employee = new PermanentEmployee()
{
Name = name
};
}
else if (employeeType.Id == 2)
{
_employee = new ContractEmployee()
{
Name = name
};
}
return _employee;
}
}
class EmployeeTypes
{
public int Id { get; set; }
public string Name { get; set; }
}
class Program
{
static void Main(string[] args)
{
EmployeeTypes _contractEmplyeeType = new EmployeeTypes
{
Id = 1,
Name = "Contract Emplyee"
};
EmployeeTypes _permanentEmplyeeType = new EmployeeTypes
{
Id = 1,
Name = "Permanent Emplyee"
};
EmployeeFactory employeeFactory = new EmployeeFactory();
IEmployee _contractEmplyee = employeeFactory.GetEmployee("Jhon" , _contractEmplyeeType);
_contractEmplyee.setBonus();
_contractEmplyee.setSalary();
IEmployee _permanentEmplyee = employeeFactory.GetEmployee("Mario", _permanentEmplyeeType);
_permanentEmplyee.setBonus();
_permanentEmplyee.setSalary();
}
}
== Advantage of Simple Factory Pattern ==
This follows the [[Open-Closed Principle|Open-Closed-principle]]: Our Employee class is closed, as we have a fixed set of Employee, which we hire, but we are open for new Employees.

Further: Each new Employee have their set of functions. The Permanent Employee doesn't care what/how to do a Contract Employee ([[Single Responsibility Principle]]).

Last but not least, we decoupled different Employee types from the Main function. The main function needs only to know how to handle.

File:Simple Factory Pattern Diagram.png

2020-02-23T10:35:45Z

Admin:

Simple Factory Pattern

2020-02-23T10:01:04Z

2020-02-08T16:25:47Z

2020-01-23T13:30:32Z

Admin:

As we all know, '''HTTP''' or '''HTTPS''' is stateless protocol. It just cleans up or we can say removes all the resources/references that were serving a specific request in the past.

Stateless means, whenever we visit a website, our browser communicates with the respective server depending on our requested functionality or the request. In this case HTTP/HTTPs doesn't remember what website or URL we visited, or in other words we can say it doesn't hold the state of a previous website that we visited before closing our browser, that is called stateless.

So our browsers are stateless.

== State Management Types ==
[[File:State Management Techniques.png|none|State Management Techniques]]

== Client-side | Techniques ==
=== View State ===
View State is the method to preserve the Value of the Page and Controls between round trips. It is a Page-Level State Management technique. View State is turned on by default and normally serializes the data in every control on the page regardless of whether it is actually used during a post-back.Please keep in mind though, that while cookies and sessions can be accessed from all your pages on your website, ViewState values are not carried between pages. 

'''Points of ViewState:'''
* ViewState does not hold the controls, rather it holds the values of the form controls and their corresponding ID's that would otherwise be lost due to a post back because they do not post with the form.
* ViewState is not used to hold session data or to transmit data between pages.
* ViewState does not recreate the dynamically created controls of a page.
* It does not restore the values to the controls after a post back operation.
* ViewState for a control is disabled, still the value would be retained after a post back of the page occurs, for input controls like TextBox or DropDownList.

So, ViewState represents the state of a page when it was last processed on the web server. It holds the values of a control that has been dynamically changed.

'''How does ViewState work?'''

When the page is first created all controls are serialized to the ViewState, which is rendered as a hidden form field named __ViewState. This hidden field corresponds to the server side object known as the ViewState. ViewState for a page is stored as key-value pairs using the System.Web.UI.StateBag object. When a post back occurs, the page de-serializes the ViewState and recreates all controls. The ViewState for the controls in a page is stored as base 64 encoded strings in name - value pairs. When a page is reloaded two methods pertaining to ViewState are called, namely the LoadViewState method and SaveViewState method. The following is the content of the __ViewState hidden field as generated for a page in my system.

[[File:ViewState.png|ViewState]]

'''ViewState can be enabled and disabled in any of the following ways:'''

* Control Level
* Page Level
* Application Level
* Machine Level

=== Hidden field ===
=== Cookies ===
=== Control State ===
=== Query Strings ===
== Server-side | Technique ==
=== Session State ===
==== InProc ====
==== OutProc ====
=== Application State ===

File:ViewState.png

2020-01-23T13:29:57Z

Admin:

ViewState

State Management in ASP.NET

2020-01-05T15:46:27Z

Admin: Created page with "As we all know, '''HTTP''' or '''HTTPS''' is stateless protocol. It just cleans up or we can say removes all the resources/references that were serving a specific request in t..."

File:State Management Techniques.png

2020-01-05T15:39:46Z

Admin:

State Management Techniques

ASP.NET page life cycle

2020-01-05T12:46:23Z

Admin: Created page with "When an ASP.NET page runs, the page goes through a series of processing steps, which is know as page life cycle. These include initialization, instantiating controls, restorin..."

When an ASP.NET page runs, the page goes through a series of processing steps, which is know as page life cycle. These include initialization, instantiating controls, restoring and maintaining state, running event handler code, and rendering.
== Various stages or events of ASP.Net page life cycle ==
[[File:ASP.NET Page Life Cycle.png|frameless|ASP.NET Page Life Cycle]]
=== PreInit ===
* Check the IsPostBack property to determine whether this is the first time the page is being processed.
* Create or re-create dynamic controls.
* Set a master page dynamically.
* Set the Theme property dynamically.
'''Note''' : If the request is a postback then the values of the controls have not yet restored from the [[View State in ASP.NET|view state]]. If you set a control property at this stage, its value might be overwritten in the next event.
protected void Page_PreInit(object sender, EventArgs e)
{
}

=== Init ===
* This event fires after each control has been initialized.
* Each control's UniqueID is set and any skin settings have been applied.
* Use this event to read or initialize control properties.
* The "Init" event is fired first for the bottom-most control in the hierarchy, and then fired up the hierarchy until it is fired for the page itself.
protected void Page_Init(object sender, EventArgs e)
{
}

=== InitComplete ===
* Until now the viewstate values are not yet loaded, hence you can use this event to make changes to the view state that you want to ensure are persisted after the next postback.
* Raised by the Page object.
* Use this event for processing tasks that require all initialization to be complete.
protected void Page_InitComplete(object sender, EventArgs e)
{
}

=== OnPreLoad ===
* Raised after the page loads view state for itself and all controls, and after it processes postback data that is included with the Request instance.
* Before the Page instance raises this event, it loads view state for itself and all controls, and then processes any postback data included with the Request instance.
* Loads ViewState: ViewState data are loaded to controls.
* Loads Postback data: Postback data are now handed to the page controls.
protected override void OnPreLoad(EventArgs e)
{
}

=== Load ===
* The Page object calls the OnLoad method on the Page object, and then recursively does the same for each child control until the page and all controls are loaded. The Load event of individual controls occurs after the Load event of the page.
* This is the first place in the page lifecycle that all values are restored.
* Most code checks the value of IsPostBack to avoid unnecessarily resetting state.
* You may also call Validate and check the value of IsValid in this method.
* You can also create dynamic controls in this method.
* Use the OnLoad event method to set properties in controls and establish database connections.
protected void Page_Load(object sender, EventArgs e)
{
}

=== PostBack Event(s) ===
* ASP.NET now calls any events on the page or its controls that caused the PostBack to occur.
* Use these events to handle specific control events, such as a Button control's Click event or a TextBox control's TextChanged event.
* In a postback request, if the page contains validator controls, check the IsValid property of the Page and of individual validation controls before performing any processing.
* This is just an example of a control event. Here it is the button click event that caused the postback.
protected void Button1_Click(object sender, EventArgs e)
{
}

=== LoadComplete ===
* Raised at the end of the event-handling stage.
* Use this event for tasks that require that all other controls on the page be loaded.
protected void Page_LoadComplete(object sender, EventArgs e)
{
}

=== OnPreRender ===
* Raised after the Page object has created all controls that are required in order to render the page, including child controls of composite controls.
* The Page object raises the PreRender event on the Page object, and then recursively does the same for each child control. The PreRender event of individual controls occurs after the PreRender event of the page.
* The PreRender event of individual controls occurs after the PreRender event of the page.
* Allows final changes to the page or its control.
* This event takes place before saving ViewState, so any changes made here are saved.
* For example: After this event, you cannot change any property of a button or change any viewstate value.
* Each data bound control whose DataSourceID property is set calls its DataBind method.
* Use the event to make final changes to the contents of the page or its controls.
protected override void OnPreRender(EventArgs e)
{
}

=== OnSaveStateComplete ===
* Raised after view state and control state have been saved for the page and for all controls.
* Before this event occurs, ViewState has been saved for the page and for all controls.
* Any changes to the page or controls at this point will be ignored.
* Use this event perform tasks that require the view state to be saved, but that do not make any changes to controls.
protected override void OnSaveStateComplete(EventArgs e)
{
}
=== Render Method ===
* This is a method of the page object and its controls (and not an event).
* The Render method generates the client-side HTML, Dynamic Hypertext Markup Language (DHTML), and script that are necessary to properly display a control at the browser.
=== UnLoad ===
* This event is used for cleanup code.
* At this point, all processing has occurred and it is safe to dispose of any remaining objects, including the Page object.
* Cleanup can be performed on:
# Instances of classes, in other words objects
# Closing opened files
# Closing database connections.
* This event occurs for each control and then for the page.
* During the unload stage, the page and its controls have been rendered, so you cannot make further changes to the response stream.
* If you attempt to call a method such as the Response.Write method then the page will throw an exception.
protected void Page_UnLoad(object sender, EventArgs e)
{
}

File:ASP.NET Page Life Cycle.png

2020-01-05T11:57:26Z

Admin:

ASP.NET Page Life Cycle

Constructor

2020-01-05T08:31:52Z

Admin:

A '''constructor''' is a special method of the class which gets automatically invoked whenever an instance of the class is created. Like methods, a constructor also contains the collection of instructions that are executed at the time of Object creation. It is used to assign initial values to the data members of the same class.

class Software
{
// Constructor
public Software() { }
// Some Code........
}
// an object is created of Software class,
// So above constructor is called
Software sw = new Software();

== Points About Constructors ==
# Constructor of a class must have the same name as the class name in which it resides.
# A constructor can not be abstract, final, static and Synchronized.
# Within a class, you can create only one static constructor.
# A constructor doesn’t have any return type, not even void.
# A static constructor cannot be a parameterized constructor.
# A class can have any number of constructors.
# Access modifiers can be used in constructor declaration to control its access i.e which other class can call the constructor.
== Different between Constructors and Method ==
{| class="wikitable"
|-
! Constructor !! Method
|-
| A constructor is used to initialize an object || A method is used to expose the behavior of an object
|-
| The constructor must not have a return type || The method has or not have a return type
|-
| A constructor must be the same as the class name || Method name may or may not be same as the class name
|-
| A constructor is invoked implicitly || A method is invoked explicitly
|}
== Types of Constructor ==
=== Default Constructor ===
A constructor without any parameters is called a default constructor. If we do not create constructor the class will automatically call default constructor when an object is created.
public class User
{
public string firstName;
public string lastName;
public User()
{
firstName = "Soumya";
lastName = "Das";
}
}
class Program
{
static void Main(string[] args)
{
User user = new User();
Console.WriteLine("Full Name:" + user.firstName + " " + user.lastName);
Console.ReadLine();
}
}
=== Parametrized Constructor ===
A constructor with at least one parameter is called a parametrized constructor.
public class User
{
public string firstName;
public string lastName;
public User(string firstName, string lastName)
{
this.firstName = firstName;
this.lastName = lastName;
}
}
class Program
{
static void Main(string[] args)
{
User user = new User("Soumya","Das");
Console.WriteLine("Full Name:" + user.firstName + " " + user.lastName);
Console.ReadLine();
}
}
=== Copy Constructor ===
The constructor which creates an object by copying variables from another object is called a copy constructor.
public class User
{
public string firstName;
public string lastName;
public User()
{
}
public User(User user)
{
this.firstName = user.firstName;
this.lastName = user.lastName;
}
}
class Program
{
static void Main(string[] args)
{
User user = new User();
user.firstName = "Soumya";
user.lastName = "Das";
User user1 = new User(user);
Console.WriteLine("Full Name:" + user.firstName + " " + user.lastName);
Console.ReadLine();
}
}
=== Private Constructor ===
A private constructor is a special instance constructor. It is generally used in classes that contain static members only. If a class has one or more private constructors and no public constructors, other classes (except nested classes) cannot create instances of this class. The use of private constructor is to serve [[Singleton Design Pattern]].
* One use of private constructor is when we have the only static member.
* It provides the implementation of [[Singleton Design Pattern]].
* Once we provide constructor (private/public/any) the compiler will not add the no parameter public constructor to any class.
class Program
{
static void Main(string[] args)
{
SingleTon obj1 = SingleTon.getInstance;
obj1.printText("obj1");
SingleTon obj2 = SingleTon.getInstance;
obj2.printText("obj2");
Console.WriteLine("Main End");
Console.ReadLine();
}
}
class SingleTon
{
private static int objectCounter = 0;
private static SingleTon instance;
private SingleTon()
{
objectCounter++;
Console.WriteLine("objectCounter : " + objectCounter.ToString());
}
public static SingleTon getInstance
{
get
{
if(instance == null)
instance = new SingleTon();
return instance;
}
}
public void printText(string strData)
{
Console.WriteLine(strData);
}
}
=== Static Constructor ===
A static constructor is used to initialize any static data, or to perform a particular action that needs to be performed once only. It is called automatically before the first instance is created or any static members are referenced.
==== Static Constructor Characteristic ====
* A static constructor does not take any access modifiers.
* A static constructor does not have a parameter.
* A static constructor is called automatically to initialize the class before the first instance is created or any static members are referenced.
* A static constructor cannot be called directly.
* The user has no control over when the static constructor is executed in the program.
* A typical use of static constructors is when the class is using a log file and the constructor is used to write entries to this file.
* A class can have only one static constructor.
* It can access only static members of a class.
public class User
{
public string firstName;
public string lastName;
public static string location;
public User()
{
}
static User()
{
location = "India";
}
}
class Program
{
static void Main(string[] args)
{

Console.WriteLine("Static variable:" + User.location);
Console.ReadLine();
}
}