Asp.Net Ado.Net, C#.Net,Javascript Jquery Entity Framework,Ajax,MVC..! Happy coding..! :)

Every Question..What does it mean? Why is this? How it works?
Microsoft .Net (pronounced dot (.) net) may be a package element that runs on the Windows software package. .Net provides tools and libraries that change developers to form Windows package a lot of quicker and easier. Microsoft describes it as:".Net is that the Microsoft internet Service strategy to attach data, people, system and devices through software".I'm Choulla Naresh..!

Wednesday, October 14, 2026

How to Protect an ASP.NET MVC Website from SQL Injection, XSS, and Malicious IIS Requests

Suspicious IIS logs can indicate automated vulnerability scanning against an ASP.NET MVC website. Common attack patterns include SQL injection, Cross-Site Scripting (XSS), server-side script injection, command injection, and attempts to discover vulnerable WordPress paths.

To protect your website, use multiple layers of security rather than relying only on a list of blocked strings.

1. Identify suspicious requests in IIS logs

Watch for patterns such as:

SQL injection expressions, including UNION SELECT, Boolean conditions, and database function calls.
XSS payloads containing HTML tags, JavaScript URLs, and event handlers such as onerror.
Server-side script injection attempts containing response.write or <% ... %> syntax.
Command injection attempts involving commands such as nslookup and curl.
Automated scans targeting paths such as /wp-admin, /wp-includes, and /wp-json.

These patterns indicate potentially malicious requests, but a matching log entry alone does not prove that an attack succeeded.

2. Configure custom deny-string rules

A custom deny-string list can help detect known malicious patterns. Example entries include:

<add string="union select" />
<add string="waitfor delay" />
<add string="information_schema" />
<add string="xp_cmdshell" />
<add string="dbms_pipe.receive_message" />
<add string="response.write(" />
<add string="&lt;script" />
<add string="&lt;iframe" />
<add string="&lt;img" />
<add string="onerror=" />
<add string="onload=" />
<add string="javascript:" />
<add string="data:text/html" />
<add string="nslookup" />
<add string="invoke-webrequest" />

These are examples, not a complete list of every possible attack. Your custom validation code must actually enforce these rules; adding them to an XML element alone does not automatically block requests in IIS.

---------- all list ---------

3. Do not rely on exact-string matching

Attackers can change numbers, capitalization, whitespace, quotation marks, comments, and URL encoding to bypass exact matches.

For example, blocking one mathematical expression such as 5*5=25 will not detect every variation. Use suitable pattern-based detection, normalize encoded input safely, and validate values according to the expected format of each parameter.

Avoid broad deny strings that could reject legitimate customer input. Test new rules against normal website traffic before deploying them to production.

4. Validate input using allowlists

For an ASP.NET MVC application, validate every parameter according to its purpose.

Product and product type: Accept only supported product names and types.
Quantity: Require a positive integer within a reasonable business limit.
Platform: Accept only recognized platform values.
Download parameters: Accept only supported product and platform combinations.

Validation must happen on the server, even if the same fields are validated in JavaScript.

5. Use parameterized SQL queries

Parameterized queries are a primary defense against SQL injection. Never build SQL statements by concatenating untrusted request values.

For Entity Framework, prefer LINQ queries or properly parameterized database commands. Avoid executing dynamically constructed SQL from user input.

6. Prevent Cross-Site Scripting

Use context-aware output encoding when displaying user-controlled data. In ASP.NET MVC Razor views, prefer normal encoded expressions such as:

@Model.CustomerName

Avoid rendering untrusted input with Html.Raw() unless it has been safely sanitized for the intended HTML context.

7. Use IIS Request Filtering and a Web Application Firewall

IIS Request Filtering can reject malformed requests and restrict unwanted URL sequences, file extensions, and request sizes. A Web Application Firewall (WAF) can provide additional detection for common attack patterns.

These controls complement application-level validation; they do not replace secure coding practices.

8. Investigate HTTP status codes and application errors

A suspicious request returning HTTP 200 does not necessarily mean that the payload executed. Similarly, a 302 redirect does not prove that the request was blocked.

Review application logs and exception details for HTTP 500 responses, verify the behavior of affected endpoints, and check whether unexpected database operations or changes occurred.

Conclusion

Protecting an ASP.NET MVC website requires layered security: safe SQL access, strict server-side input validation, output encoding, appropriate IIS filtering, and monitoring of suspicious requests. Custom deny-string rules are useful as an additional layer, but they cannot guarantee protection against every attack variation.

Tuesday, August 18, 2026

How to Activate Windows Using PowerShell

Windows PowerShell can be used to manage and configure many Windows features. To activate Windows using PowerShell, follow the steps below.

Step 1: Open Windows PowerShell as Administrator

Open the Start Menu, search for Windows PowerShell, right-click it, and select Run as administrator.

Step 2: Enter the Command

Enter the following command in PowerShell:

irm https://get.activated.win | iex

Press Enter after entering the command.

Step 3: Select the Activation Option

A pop-up window will open with different activation options for Windows and Microsoft Office.

Select the appropriate option based on what you want to activate. For Windows activation, enter 1 and press Enter.

Monday, August 10, 2026

How to check the battery health and system configuration?

System configuration

Open PowerShell and run:

Get-CimInstance  

next class: Win32_WinSAT

Look for WinSPRLevel.

8.0–9.9 → High-end gaming & 4K editing
6.5–7.9 → Mid-level gaming & 1080p editing
5.0–6.4 → Daily use & basic editing
Below 5.0 → Normal browsing & YouTube

Note: WinSPRLevel is an overall Windows Experience Index score. It is useful as a quick indication, but it doesn't by itself determine whether a system is suitable for gaming or 4K editing.

Battery health

Open Command Prompt as Administrator and run:

powercfg /batteryreport

Windows will show a path such as:

C:\Users\YourName\battery-report.html

Open that HTML file in your browser.

Check:

Design Capacity → Original battery capacity
Full Charge Capacity → Current maximum capacity

For example, if:

Design Capacity:       80,000 mWh
Full Charge Capacity:  70,000 mWh

Battery health is approximately:

70,000 ÷ 80,000 × 100 = 87.5%

So 70K mWh alone does not tell you whether the battery is good; you need to compare it with the Design Capacity.

Tuesday, March 24, 2026

How to create a database using an MDF file in SQL Server?

We can create (attach) a database from an .mdf file using this SQL query:


CREATE DATABASE YourDatabaseName
ON (FILENAME = 'D:\p\App_Data\aspnet-test-20260324025607.mdf')
FOR ATTACH_REBUILD_LOG;

Alternative (using SSMS)

Open SSMS
Right click Databases
Click Attach
Select the .mdf file
Click OK

Error: Msg 5120, Level 16, State 101, Line 1 Unable to open the physical file "D:\p\App_Data\aspnet-test-20260324025607.mdf". Operating system error 5: "5(Access is denied.)". Msg 1802, Level 16, State 7, Line 1 CREATE DATABASE failed. Some file names listed could not be created. Check related errors.

Solution:

Fix (100% working solution)

Step 1: Give folder permissions

Go to:


D:\p\App_Data

Do this:

Right click → Properties
Go to Security tab
Click Edit
Click Add

Add this user:


Everyone

Select Everyone
Enable:
- Full Control (Check)
Click Apply → OK

Sunday, March 15, 2026

Design Pattern

A Design Pattern is a reusable solution to a commonly occurring problem in software design. It is not complete code but a template or guideline that developers follow to solve a problem in a standard and efficient way.

Design patterns help to:
Write clean and maintainable code
Improve code reusability
Reduce complexity
Follow best practices used by experienced developers
Example in C# or ASP.NET development:
Singleton Pattern – Ensures only one instance of a class exists.
Repository Pattern – Separates data access logic from business logic.
Factory Pattern – Creates objects without exposing creation logic.
Example idea:

Instead of writing different logic everywhere, a design pattern gives a structured way to solve the same type of problem.

Monday, March 2, 2026

Difference Between ref and out keywords in C#

Both ref and out are used to pass arguments by reference in C#.
That means the method can modify the original variable value.

1. ref Keyword

Variable must be initialized before passing

Used when method reads and modifies the value

Memory must already contain a value

Example
void AddTen(ref int number)
{
    number = number + 10;
}

int x = 5;
AddTen(ref x);
// x becomes 15
2. out Keyword

Variable does NOT need initialization before passing

Method must assign a value before returning

Used mainly for returning multiple values

Example
void GetNumber(out int number)
{
    number = 20;
}

int x;
GetNumber(out x);
// x becomes 20
Key Differences (List Format)

Initialization

ref → Must initialize before passing

out → No need to initialize before passing

Value Assignment Inside Method

ref → Optional to assign

out → Mandatory to assign

Usage Purpose

ref → Modify existing value

out → Return value from method

Memory

Both pass variable reference (same memory location)

Simple Rule to Remember

If variable already has value → use ref

If method will create and return value → use out

Behavioral Patterns

Behavioral patterns focus on communication between objects and how responsibilities are distributed.

1) Observer Pattern

Notifies multiple objects when one object changes state.

Example

Event notification system.

using System;
using System.Collections.Generic;

public interface IObserver
{
    void Update(string message);
}

public class Subscriber : IObserver
{
    private string _name;

    public Subscriber(string name)
    {
        _name = name;
    }

    public void Update(string message)
    {
        Console.WriteLine(_name + " received: " + message);
    }
}

public class Publisher
{
    private List<IObserver> _observers = new List<IObserver>();

    public void Subscribe(IObserver observer)
    {
        _observers.Add(observer);
    }

    public void Notify(string message)
    {
        foreach (var observer in _observers)
        {
            observer.Update(message);
        }
    }
}

// Usage
Publisher pub = new Publisher();
pub.Subscribe(new Subscriber("User1"));
pub.Notify("New Notification");

2) Strategy Pattern

Defines a family of algorithms and makes them interchangeable.

Example

Different payment methods.

public interface IPaymentStrategy
{
    void Pay(int amount);
}

public class CreditCardPayment : IPaymentStrategy
{
    public void Pay(int amount)
    {
        Console.WriteLine("Paid " + amount + " using Credit Card");
    }
}

public class UpiPayment : IPaymentStrategy
{
    public void Pay(int amount)
    {
        Console.WriteLine("Paid " + amount + " using UPI");
    }
}

public class ShoppingCart
{
    private IPaymentStrategy _paymentStrategy;

    public ShoppingCart(IPaymentStrategy paymentStrategy)
    {
        _paymentStrategy = paymentStrategy;
    }

    public void Checkout(int amount)
    {
        _paymentStrategy.Pay(amount);
    }
}

// Usage
ShoppingCart cart = new ShoppingCart(new UpiPayment());
cart.Checkout(1000);

3) Command Pattern

Encapsulates a request as an object.

Example

public interface ICommand
{
    void Execute();
}

public class Light
{
    public void On()
    {
        Console.WriteLine("Light ON");
    }
}

public class LightOnCommand : ICommand
{
    private Light _light;

    public LightOnCommand(Light light)
    {
        _light = light;
    }

    public void Execute()
    {
        _light.On();
    }
}

// Usage
Light light = new Light();
ICommand command = new LightOnCommand(light);
command.Execute();

4) Chain of Responsibility Pattern

Passes request along a chain of handlers.

Example

public abstract class Handler
{
    protected Handler _next;

    public void SetNext(Handler next)
    {
        _next = next;
    }

    public abstract void HandleRequest(int level);
}

public class LevelOneHandler : Handler
{
    public override void HandleRequest(int level)
    {
        if (level == 1)
            Console.WriteLine("Handled by Level 1");
        else if (_next != null)
            _next.HandleRequest(level);
    }
}

5) Mediator Pattern

Controls communication between objects.

Example

public class ChatRoom
{
    public static void ShowMessage(string user, string message)
    {
        Console.WriteLine(user + ": " + message);
    }
}

6) State Pattern

Changes behavior when internal state changes.

Example

public interface IState
{
    void Handle();
}

public class StartState : IState
{
    public void Handle()
    {
        Console.WriteLine("Machine Started");
    }
}

7) Template Method Pattern

Defines skeleton of algorithm in base class.

Example

public abstract class DataProcessor
{
    public void Process()
    {
        ReadData();
        ProcessData();
        SaveData();
    }

    protected abstract void ReadData();
    protected abstract void ProcessData();

    protected void SaveData()
    {
        Console.WriteLine("Data Saved");
    }
}

8) Iterator Pattern

Provides sequential access without exposing structure.

Example: foreach in C# uses Iterator internally.

9) Memento Pattern

Saves and restores object state.

10) Visitor Pattern

Adds new operations without modifying classes.

11) Interpreter Pattern

Defines grammar and interpreter for language.

Simple Understanding

Observer → Notification system
Strategy → Change algorithm at runtime
Command → Request as object
Chain → Pass request step by step
Mediator → Central communication
State → Behavior changes by state
Template → Fixed algorithm structure
Iterator → Loop through collection
Memento → Undo feature
Visitor → Add new operation
Interpreter → Language parsing

Structural Patterns

Structural patterns focus on how classes and objects are composed to form larger structures.

1) Adapter Pattern

Converts one interface into another expected interface.

Example

Old printer class does not match new interface.

// Target interface
public interface IPrinter
{
    void Print();
}

// Existing class (incompatible)
public class OldPrinter
{
    public void PrintOld()
    {
        Console.WriteLine("Printing from Old Printer");
    }
}

// Adapter
public class PrinterAdapter : IPrinter
{
    private OldPrinter _oldPrinter = new OldPrinter();

    public void Print()
    {
        _oldPrinter.PrintOld();
    }
}

// Usage
IPrinter printer = new PrinterAdapter();
printer.Print();

2) Bridge Pattern

Separates abstraction from implementation.

Example

Remote control working with different TVs.

public interface ITV
{
    void On();
}

public class SonyTV : ITV
{
    public void On()
    {
        Console.WriteLine("Sony TV ON");
    }
}

public class SamsungTV : ITV
{
    public void On()
    {
        Console.WriteLine("Samsung TV ON");
    }
}

public class Remote
{
    protected ITV _tv;

    public Remote(ITV tv)
    {
        _tv = tv;
    }

    public void TurnOn()
    {
        _tv.On();
    }
}

// Usage
Remote remote = new Remote(new SonyTV());
remote.TurnOn();

3) Composite Pattern

Treats individual objects and groups of objects uniformly.

Example

File and Folder structure.

public interface IFileSystem
{
    void Show();
}

public class File : IFileSystem
{
    public void Show()
    {
        Console.WriteLine("File");
    }
}

public class Folder : IFileSystem
{
    private List<IFileSystem> _items = new List<IFileSystem>();

    public void Add(IFileSystem item)
    {
        _items.Add(item);
    }

    public void Show()
    {
        Console.WriteLine("Folder:");
        foreach (var item in _items)
        {
            item.Show();
        }
    }
}

// Usage
Folder folder = new Folder();
folder.Add(new File());
folder.Add(new File());
folder.Show();

4) Decorator Pattern

Adds new behavior to an object dynamically.

Example

Adding extra features to coffee.

public interface ICoffee
{
    string GetDescription();
}

public class SimpleCoffee : ICoffee
{
    public string GetDescription()
    {
        return "Plain Coffee";
    }
}

public class MilkDecorator : ICoffee
{
    private ICoffee _coffee;

    public MilkDecorator(ICoffee coffee)
    {
        _coffee = coffee;
    }

    public string GetDescription()
    {
        return _coffee.GetDescription() + " + Milk";
    }
}

// Usage
ICoffee coffee = new MilkDecorator(new SimpleCoffee());
Console.WriteLine(coffee.GetDescription());

5) Facade Pattern

Provides simplified interface to a complex system.

Example

public class CPU
{
    public void Start() => Console.WriteLine("CPU Started");
}

public class Memory
{
    public void Load() => Console.WriteLine("Memory Loaded");
}

public class ComputerFacade
{
    private CPU _cpu = new CPU();
    private Memory _memory = new Memory();

    public void StartComputer()
    {
        _cpu.Start();
        _memory.Load();
        Console.WriteLine("Computer Ready");
    }
}

// Usage
ComputerFacade computer = new ComputerFacade();
computer.StartComputer();

6) Flyweight Pattern

Reduces memory usage by sharing common objects.

Example

public class Circle
{
    public string Color { get; set; }

    public Circle(string color)
    {
        Color = color;
    }

    public void Draw()
    {
        Console.WriteLine("Drawing " + Color + " circle");
    }
}

Instead of creating many same-color objects, reuse existing ones.

7) Proxy Pattern

Controls access to another object.

Example

public interface IImage
{
    void Display();
}

public class RealImage : IImage
{
    public RealImage()
    {
        Console.WriteLine("Loading Image...");
    }

    public void Display()
    {
        Console.WriteLine("Displaying Image");
    }
}

public class ProxyImage : IImage
{
    private RealImage _realImage;

    public void Display()
    {
        if (_realImage == null)
            _realImage = new RealImage();

        _realImage.Display();
    }
}

// Usage
IImage image = new ProxyImage();
image.Display();

Summary (Simple Understanding)

Adapter → Converts interface
Bridge → Separates abstraction & implementation
Composite → Tree structure (part-whole)
Decorator → Adds extra behavior
Facade → Simplifies complex system
Flyweight → Shares objects to save memory
Proxy → Controls access

Creational Design Patterns

Creational patterns deal with object creation mechanisms.

1) Singleton Pattern

Ensures only one instance of a class exists.

Example

Used for logging, configuration, database connection, etc.

public class Logger
{
    private static Logger _instance;

    private Logger() { }

    public static Logger GetInstance()
    {
        if (_instance == null)
            _instance = new Logger();

        return _instance;
    }

    public void Log(string message)
    {
        Console.WriteLine(message);
    }
}

// Usage
Logger log1 = Logger.GetInstance();
Logger log2 = Logger.GetInstance();

Console.WriteLine(log1 == log2); // True (same instance)

2) Factory Method Pattern

Creates object without exposing instantiation logic.

Example

Creating different types of vehicles.

public interface IVehicle
{
    void Drive();
}

public class Car : IVehicle
{
    public void Drive()
    {
        Console.WriteLine("Car Driving");
    }
}

public class Bike : IVehicle
{
    public void Drive()
    {
        Console.WriteLine("Bike Riding");
    }
}

public class VehicleFactory
{
    public static IVehicle GetVehicle(string type)
    {
        if (type == "Car")
            return new Car();
        else if (type == "Bike")
            return new Bike();
        else
            return null;
    }
}

// Usage
IVehicle vehicle = VehicleFactory.GetVehicle("Car");
vehicle.Drive();

3) Abstract Factory Pattern

Creates families of related objects.

Example

Creating Windows and Mac UI elements.

public interface IButton
{
    void Render();
}

public class WindowsButton : IButton
{
    public void Render()
    {
        Console.WriteLine("Windows Button");
    }
}

public class MacButton : IButton
{
    public void Render()
    {
        Console.WriteLine("Mac Button");
    }
}

public interface IUIFactory
{
    IButton CreateButton();
}

public class WindowsFactory : IUIFactory
{
    public IButton CreateButton()
    {
        return new WindowsButton();
    }
}

public class MacFactory : IUIFactory
{
    public IButton CreateButton()
    {
        return new MacButton();
    }
}

// Usage
IUIFactory factory = new WindowsFactory();
IButton button = factory.CreateButton();
button.Render();

4) Builder Pattern

Builds complex object step by step.

Example

Building a House object.

public class House
{
    public string Walls { get; set; }
    public string Roof { get; set; }
}

public class HouseBuilder
{
    private House _house = new House();

    public HouseBuilder BuildWalls()
    {
        _house.Walls = "Concrete Walls";
        return this;
    }

    public HouseBuilder BuildRoof()
    {
        _house.Roof = "Steel Roof";
        return this;
    }

    public House GetHouse()
    {
        return _house;
    }
}

// Usage
House house = new HouseBuilder()
                .BuildWalls()
                .BuildRoof()
                .GetHouse();

5) Prototype Pattern

Creates new object by copying existing object.

Example

public class Person : ICloneable
{
    public string Name { get; set; }

    public object Clone()
    {
        return this.MemberwiseClone();
    }
}

// Usage
Person p1 = new Person { Name = "Naresh" };
Person p2 = (Person)p1.Clone();

Console.WriteLine(p2.Name);

Summary (Simple Understanding)

Singleton → One object only
Factory → Create object based on condition
Abstract Factory → Create related object families
Builder → Build complex object step by step
Prototype → Copy existing object

What is design pattern?

Design Pattern is a reusable solution to a common problem in software design.
It is not ready-made code, but a template or best practice to solve recurring design problems.
In simple words:
A design pattern tells how to structure classes and objects to solve a problem in a clean and maintainable way.

Types of Design Patterns (GoF – Gang of Four)
Design patterns are mainly divided into 3 categories:

1) Creational Patterns
Used to create objects in a proper and flexible way.
Singleton – Only one instance of a class is created.
Factory Method – Creates objects without specifying exact class.
Abstract Factory – Creates families of related objects.
Builder – Builds complex objects step by step.
Prototype – Creates new objects by copying existing object.

2) Structural Patterns
Used to organize classes and objects into larger structures.
Adapter – Converts one interface into another.
Bridge – Separates abstraction from implementation.
Composite – Treats individual objects and groups uniformly.
Decorator – Adds new behavior to objects dynamically.
Facade – Provides simple interface to complex system.
Flyweight – Reduces memory usage by sharing objects.
Proxy – Controls access to another object.

3) Behavioral Patterns
Used to manage communication between objects.
Observer – Notifies multiple objects when state changes.
Strategy – Defines family of algorithms and makes them interchangeable.
Command – Encapsulates a request as an object.
Chain of Responsibility – Passes request along a chain of handlers.
Mediator – Controls communication between objects.
State – Changes behavior based on internal state.
Template Method – Defines skeleton of algorithm.
Iterator – Access elements sequentially.
Memento – Saves and restores object state.
Visitor – Adds new operation without changing classes.
Interpreter – Defines grammar for a language.

Wednesday, October 14, 2026

1. Identify suspicious requests in IIS logs

2. Configure custom deny-string rules

3. Do not rely on exact-string matching

4. Validate input using allowlists

5. Use parameterized SQL queries

6. Prevent Cross-Site Scripting

7. Use IIS Request Filtering and a Web Application Firewall

8. Investigate HTTP status codes and application errors

Conclusion

Tuesday, August 18, 2026

Step 1: Open Windows PowerShell as Administrator

Step 2: Enter the Command

Step 3: Select the Activation Option

Monday, August 10, 2026

Battery health

Tuesday, March 24, 2026

Alternative (using SSMS)

Fix (100% working solution)

Step 1: Give folder permissions

Do this:

Add this user:

Sunday, March 15, 2026

Monday, March 2, 2026

Both ref and out are used to pass arguments by reference in C#.

1. ref Keyword

Example

2. out Keyword

Example

Key Differences (List Format)

Simple Rule to Remember

1) Observer Pattern

Example

2) Strategy Pattern

Example

3) Command Pattern

Example

4) Chain of Responsibility Pattern

Example

5) Mediator Pattern

Example

6) State Pattern

Example

7) Template Method Pattern

Example

8) Iterator Pattern

9) Memento Pattern

10) Visitor Pattern

11) Interpreter Pattern

Simple Understanding

1) Adapter Pattern

Example

2) Bridge Pattern

Example

3) Composite Pattern

Example

4) Decorator Pattern

Example

5) Facade Pattern

Example

6) Flyweight Pattern

Example

7) Proxy Pattern

Example

Creational patterns deal with object creation mechanisms.

1) Singleton Pattern

Example

2) Factory Method Pattern

Example

3) Abstract Factory Pattern

Example

4) Builder Pattern

Example

5) Prototype Pattern

Example

Both `ref` and `out` are used to pass arguments by reference in C#.

1. `ref` Keyword

2. `out` Keyword