ASP.

Net Using C#

Question 1. What is asp.net? What are advance features of

asp.net?
Ans. ASP.NET is a web application framework developed by Microsoft for building
dynamic web applications and services. It allows developers to create web applications using
programming languages such as C#, Visual Basic, and F#. ASP.NET provides a robust and
scalable platform for building web applications, with built-in features for security,
performance, and reliability.

Some advanced features of ASP.NET include:

ASP.NET Core: This is a cross-platform, high-performance framework for building modern,

cloud-based web applications. It is a complete rewrite of ASP.NET, designed to be modular,
lightweight, and highly scalable.

MVC (Model-View-Controller) Architecture: ASP.NET MVC provides a powerful pattern for

building web applications by separating the application into three main components: models
(representing data), views (representing user interface), and controllers (handling user
requests and responses). This architectural pattern promotes clean code, separation of
concerns, and testability.

Web API: ASP.NET Web API allows developers to build RESTful web services using standard
HTTP methods (GET, POST, PUT, DELETE) and JSON or XML as data formats. It simplifies the
process of creating APIs for communication between different systems or devices.

Entity Framework: Entity Framework is an object-relational mapping (ORM) framework that

simplifies data access by enabling developers to work with database objects as .NET objects.
It provides a higher level of abstraction over database operations, reducing the need for
writing SQL queries manually and improving productivity.

Dependency Injection: ASP.NET Core supports dependency injection, allowing developers to

easily manage and inject dependencies into their application components. This promotes
loose coupling, modularity, and testability by enabling better separation of concerns and
facilitating unit testing.
Middleware Pipeline: ASP.NET Core introduces a middleware pipeline that allows developers
to customize the request processing pipeline by adding, removing, or configuring
middleware components. This provides greater flexibility and control over the request-
handling process, enabling developers to implement cross-cutting concerns such as
authentication, logging, and caching.

Razor Pages: Razor Pages is a lightweight alternative to MVC for building web applications
with ASP.NET Core. It simplifies the development of page-focused applications by combining
HTML mark up with C# code directly within the same file, resulting in cleaner and more
maintainable code.

These advanced features of ASP.NET empower developers to build modern, scalable, and
high-performance web applications while improving productivity and reducing development
time.

2. Explain the life cycle of a web page with relevant events.

Ans The life cycle of a web page refers to the sequence of events that occur from
the moment a user requests a page until the response is sent back to the user's
browser. In the context of ASP.NET, the life cycle of a web page typically follows
these main stages:

Page Request: The life cycle begins when a user requests a page by entering a
URL in their browser or clicking a link. The request is sent to the web server,
where the ASP.NET runtime handles it.

Page Initialization: In this stage, the ASP.NET runtime initializes the page and its
controls. This includes creating an instance of the page class, initializing control
properties, and setting up control hierarchy.

Page Load: During the page load stage, the page and its controls are populated
with data and their properties are set. This is where data binding occurs, and any
code specified in the Page_Load event handler is executed. This stage is
commonly used to initialize page content and perform tasks that need to be
executed every time the page is requested.

Postback Event Handling: If the page contains controls that can cause a postback
(such as buttons or dropdown lists), and the user triggers a postback by interacting
with these controls, the ASP.NET runtime raises postback events. These events
include Button_Click, DropDownList_SelectedIndexChanged, etc. The
corresponding event handlers in the code-behind file are executed to process user
input or trigger actions.

Page Load (again): After post back event handling is complete, the page load
stage is executed again. This allows the page and its controls to be reinitialized
and updated based on any changes resulting from the postback events.
 Validation: If the page contains validation controls such as
RequiredFieldValidator or RegularExpressionValidator, ASP.NET performs
validation during this stage. If validation fails, appropriate error messages are
displayed to the user.

Event Preprocessing: Before raising any additional events or executing the final
stage, ASP.NET performs event preprocessing. This includes determining the
target control for the next event and updating control state.

Rendering: In the rendering stage, ASP.NET generates the HTML markup for the
page and its controls based on their current state. This markup is then sent back to
the user's browser as the response.

Unload: Finally, the unload stage occurs, where ASP.NET releases resources
associated with the page and its controls. This includes closing database
connections, releasing memory, and cleaning up any other resources used during
the page's lifecycle.

Understanding the life cycle of a web page is essential for developing and
troubleshooting ASP.NET applications, as it helps developers understand when
and where to place code for initializing controls, handling user input, performing
validation, and other tasks.

3. What do you mean by literal control? Explain how it is useful in

table server control with example.
Ans. A literal control in ASP.NET is a server-side control that allows developers to
output text, HTML, or other content directly to the page without any additional
formatting or processing. It is primarily used to display static text or HTML content
within a web page.

Literal controls are useful in conjunction with other server controls, such as the table
server control, to dynamically generate HTML content based on data or conditions.
Here's an example of how a literal control can be used with a table server control:

asp
Copy code
<%@ Page Language="C#" AutoEventWireup="true"
CodeBehind="WebForm1.aspx.cs" Inherits="WebApplication1.WebForm1" %>

<!DOCTYPE html>

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
<title></title>
</head>
<body>
<form id="form1" runat="server">
<asp:Table ID="myTable" runat="server">
<asp:TableRow>
 <asp:TableCell>
<asp:Literal ID="literal1" runat="server"></asp:Literal>
</asp:TableCell>
<asp:TableCell>
<asp:Literal ID="literal2" runat="server"></asp:Literal>
</asp:TableCell>
</asp:TableRow>
</asp:Table>
</form>
</body>
</html>
In this example, we have a simple ASP.NET web form containing a table server
control (<asp:Table>) with two rows and two columns. Inside each cell of the table,
we have a literal control (<asp:Literal>) to display content dynamically.

Now, let's see how we can dynamically populate the literals with content in the code-
behind file:

csharp
Copy code
using System;

namespace WebApplication1
{
public partial class WebForm1 : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
// Populate the literals with content
literal1.Text = "Hello, ";
literal2.Text = "World!";
}
}
}
In the Page_Load event handler, we are dynamically setting the Text property of each
literal control to display the desired content. When the page is rendered, the content
assigned to the literals will be included within the table cells.

This example demonstrates how literal controls can be used to inject dynamic content
into HTML elements, providing flexibility and control over the presentation of data
within ASP.NET web applications.

4. What is a .Net Assembly? Explain different kind of Assemblies.

Ans. In the .NET framework, an assembly is a fundamental unit of deployment
that contains compiled code, metadata, and resources needed to execute a program
or library. It is essentially a collection of one or more files that are treated as a
single deployment unit. Assemblies play a crucial role in the execution and
management of .NET applications.
 There are several types of assemblies in the .NET framework:

Single-file Assembly: Also known as standalone assemblies, single-file

assemblies contain all the necessary components (code, metadata, and resources)
in a single executable file with the extension .exe for executables or .dll for
libraries. These assemblies are self-contained and do not require additional
dependencies to run.

Multi-file Assembly: Multi-file assemblies consist of multiple files, with one

primary file (either an executable or a DLL) referencing other satellite files
containing additional code, metadata, or resources. This type of assembly is less
common than single-file assemblies and is typically used for large applications
where splitting the code into multiple files enhances manageability.

Private Assembly: Private assemblies are deployed within the application's

directory or subdirectory and are accessible only to that application. They do not
need to be registered in the Global Assembly Cache (GAC) and are suitable for
applications that do not need to be shared across multiple applications or systems.

Shared Assembly: Shared assemblies are installed in the Global Assembly Cache
(GAC), which is a machine-wide repository for storing assemblies that can be
shared across multiple applications. Shared assemblies are assigned a strong
name, which consists of the assembly's identity, version, culture information, and
a digital signature, to ensure uniqueness and integrity.

Satellite Assembly: Satellite assemblies contain localized resources such as

strings, images, or other data specific to a particular language or culture. These
assemblies are used to support localization and allow applications to display
content in different languages without modifying the main executable or
assembly.

Dynamic Assembly: Dynamic assemblies are generated dynamically at runtime

using reflection or the System.Reflection.Emit namespace. They are not stored as
separate files on disk but are created in memory as needed. Dynamic assemblies
are often used in scenarios such as code generation, dynamic code compilation, or
dynamic proxy creation.

Each type of assembly serves a specific purpose and provides developers with
flexibility in deploying, managing, and executing .NET applications and libraries.
Understanding the different types of assemblies is essential for effective
application deployment and maintenance in the .NET ecosystem.

Question 5. Explain the principal and design of .Net

frame work.

The .NET Framework is a software development platform developed by Microsoft

that provides a comprehensive set of libraries, tools, and runtime environments for
building and running various types of applications, including web, desktop,
mobile, and cloud-based applications. It is designed to facilitate rapid application
development, improve developer productivity, and ensure interoperability across
different programming languages and platforms. The principal and design
principles of the .NET Framework can be summarized as follows:

Interoperability: The .NET Framework is built on the Common Language

Runtime (CLR), which provides a common execution environment for all .NET
languages. This allows developers to write code in multiple languages such as C#,
Visual Basic, F#, and more, and seamlessly interoperate between them within the
same application. Additionally, the .NET Framework supports interoperability
with existing COM components, enabling integration with legacy systems and
third-party libraries.

Language Independence: The .NET Framework is designed to be language-

independent, meaning that developers can choose the programming language that
best suits their requirements and preferences while leveraging the same set of
class libraries and runtime services provided by the framework. This promotes
code reuse, reduces development time, and enhances developer flexibility.

Base Class Library (BCL): The .NET Framework includes a rich and extensive
Base Class Library (BCL) that provides a wide range of pre-built classes and APIs
for common programming tasks such as file I/O, networking, data access,
cryptography, and more. The BCL abstracts away low-level details and
complexities, allowing developers to focus on solving higher-level problems and
building robust applications.

Security: Security is a fundamental principle of the .NET Framework, and it

provides various features and mechanisms to help developers build secure
applications. These include code access security (CAS), which controls the
permissions granted to code based on its origin and identity, role-based security
for controlling access to resources based on user roles, cryptography for
encrypting and securing sensitive data, and more.

Portability and Cross-Platform Compatibility: With the introduction of .NET Core

(now known as .NET), the .NET Framework has become more portable and cross-
platform. .NET Core is an open-source, modular implementation of the .NET
Framework that runs on Windows, Linux, and macOS, making it easier for
developers to build and deploy applications across different operating systems and
environments.

Performance and Scalability: The .NET Framework is designed to deliver high

performance and scalability for demanding applications. The CLR includes a just-
in-time (JIT) compiler that converts Intermediate Language (IL) code into native
machine code at runtime, optimizing performance. Additionally, the framework
provides features such as asynchronous programming, multi-threading, and
memory management to support scalable and responsive applications.

Developer Productivity: The .NET Framework aims to enhance developer

productivity by providing powerful development tools, integrated development
 environments (IDEs) such as Visual Studio, and a rich ecosystem of third-party
libraries, frameworks, and components. Features such as automatic memory
management (garbage collection), rich debugging capabilities, and extensive
documentation further contribute to improving developer efficiency and reducing
time-to-market for applications.

Overall, the .NET Framework is built on principles of interoperability, language

independence, security, portability, performance, and developer productivity,
making it a versatile and powerful platform for building a wide range of
applications for different domains and industries.

6 What is GIT? Also define its types.

Ans Git is a distributed version control system (DVCS) used for tracking changes in
source code during software development. It was created by Linus Torvalds in 2005 and has
since become one of the most widely used version control systems in the world. Git provides
a decentralized and flexible approach to version control, enabling multiple developers to
collaborate on a project simultaneously and manage changes efficiently.

Key features of Git include:

Distributed Version Control: Git is a distributed version control system, meaning that each
developer working on a project has a complete copy of the repository, including the entire
history of changes. This allows developers to work offline, make local commits, and
synchronize changes with remote repositories when connected to a network.

Branching and Merging: Git provides powerful branching and merging capabilities, allowing
developers to create lightweight branches to work on new features or experiment with
changes without affecting the main codebase. Branches can be easily merged back into the
main branch (often called the "master" branch) when ready.

Fast and Efficient: Git is designed to be fast and efficient, even when dealing with large
repositories and complex histories. It uses techniques such as delta compression, shallow
cloning, and pack files to optimize performance and minimize storage space.

Data Integrity: Git uses cryptographic hashing to ensure the integrity of repository data. Each
commit is uniquely identified by a hash value computed from the contents of the commit,
including the parent commits, author, timestamp, and commit message. This allows Git to
detect and prevent corruption or tampering of repository data.

Collaboration: Git facilitates collaboration among developers by providing features such as

remote repositories, pull requests, and code reviews. Developers can push their changes to a
shared remote repository, review each other's code, and merge changes through a structured
workflow.

Types of Git repositories include:

Local Repository: A local repository is a copy of a Git repository stored on a developer's

local machine. It contains the entire history of the project and allows developers to work
offline, make commits, and manage branches locally.

Remote Repository: A remote repository is a copy of a Git repository hosted on a remote

server, such as GitHub, GitLab, or Bitbucket. Remote repositories serve as centralized hubs
for collaborating on a project, allowing multiple developers to push and pull changes from a
shared location.

Bare Repository: A bare repository is a special type of repository that does not have a
working directory. It contains only the version history and metadata of a Git repository,
making it ideal for serving as a central remote repository in a collaborative workflow.

Forked Repository: A forked repository is a copy of a remote repository created by a

developer to contribute changes back to the original project. Forks allow developers to
experiment with changes without affecting the original repository and submit pull requests to
propose their changes for inclusion in the upstream project.
7 Explain difference between ADO and ADO.NET.
Ans Git is a distributed version control system (DVCS) used for tracking changes in
source code during software development. It was created by Linus Torvalds in 2005
and has since become one of the most widely used version control systems in the
world. Git provides a decentralized and flexible approach to version control, enabling
multiple developers to collaborate on a project simultaneously and manage changes
efficiently.

Key features of Git include:

Distributed Version Control: Git is a distributed version control system, meaning that
each developer working on a project has a complete copy of the repository, including
the entire history of changes. This allows developers to work offline, make local
commits, and synchronize changes with remote repositories when connected to a
network.

Branching and Merging: Git provides powerful branching and merging capabilities,
allowing developers to create lightweight branches to work on new features or
experiment with changes without affecting the main codebase. Branches can be easily
merged back into the main branch (often called the "master" branch) when ready.
Fast and Efficient: Git is designed to be fast and efficient, even when dealing with
large repositories and complex histories. It uses techniques such as delta compression,
shallow cloning, and pack files to optimize performance and minimize storage space.

Data Integrity: Git uses cryptographic hashing to ensure the integrity of repository
data. Each commit is uniquely identified by a hash value computed from the contents
of the commit, including the parent commits, author, timestamp, and commit
message. This allows Git to detect and prevent corruption or tampering of repository
data.

Collaboration: Git facilitates collaboration among developers by providing features

such as remote repositories, pull requests, and code reviews. Developers can push
their changes to a shared remote repository, review each other's code, and merge
changes through a structured workflow.

Types of Git repositories include:

Local Repository: A local repository is a copy of a Git repository stored on a

developer's local machine. It contains the entire history of the project and allows
developers to work offline, make commits, and manage branches locally.

Remote Repository: A remote repository is a copy of a Git repository hosted on a

remote server, such as GitHub, GitLab, or Bitbucket. Remote repositories serve as
centralized hubs for collaborating on a project, allowing multiple developers to push
and pull changes from a shared location.

Bare Repository: A bare repository is a special type of repository that does not have a
working directory. It contains only the version history and metadata of a Git
repository, making it ideal for serving as a central remote repository in a collaborative
workflow.

Forked Repository: A forked repository is a copy of a remote repository created by a

developer to contribute changes back to the original project. Forks allow developers
to experiment with changes without affecting the original repository and submit pull
requests to propose their changes for inclusion in the upstream project.

Q. 8 Explain ADO.NET Object Model.

Ans. ADO.NET provides a comprehensive object model for working with data in a
managed environment, typically within .NET applications. The ADO.NET object
model is based on a set of classes and interfaces provided in the System.Data
namespace, which encapsulate various data access functionalities. Here's an overview
of the key components of the ADO.NET object model:

Connections (SqlConnection):

SqlConnection: Represents a connection to a data source, such as a database. It is used

to establish a connection, execute commands, and manage transactions.
Commands (SqlCommand, SqlDataAdapter):

SqlCommand: Represents a SQL statement or stored procedure to be executed against

a database. It is used to execute queries, stored procedures, or data manipulation
statements.
SqlDataAdapter: Represents a bridge between a dataset and a data source for
retrieving and updating data. It populates datasets or data tables with data from the
database and updates changes back to the database.
Data Readers (SqlDataReader):

SqlDataReader: Provides a forward-only, read-only stream of data from a data source.

It is optimized for high-performance data access and is typically used for read-only
scenarios where data needs to be retrieved efficiently and sequentially.
Datasets and Data Tables (DataSet, DataTable):

DataSet: Represents an in-memory cache of data that can hold multiple data tables,
relationships, and constraints. It is disconnected from the data source and can store
data retrieved from one or more database tables.
DataTable: Represents a single table of data within a dataset. It consists of rows and
columns and provides methods for adding, deleting, and modifying data rows.
Data Adapters (DataAdapter):

DataAdapter: Acts as a bridge between a dataset and a data source for retrieving and
updating data. It consists of four commands (SelectCommand, InsertCommand,
UpdateCommand, DeleteCommand) that are used to fetch, insert, update, and delete
data in the dataset.
Data Views (DataView):

DataView: Represents a customized view of a data table that can be sorted, filtered,
and navigated. It provides a flexible way to display and interact with data within a
data table.
Data Access Events:

ADO.NET provides various events such as RowUpdating, RowUpdated, FillError,

etc., which allow developers to handle data access events and perform custom actions
during data retrieval, updates, or error handling.
Transactions (Transaction):

Transaction: Represents a database transaction that groups a series of database

operations into a single unit of work. ADO.NET supports explicit transaction
management using the Transaction class, allowing developers to commit or rollback
transactions as needed.
The ADO.NET object model provides a powerful and flexible framework for building
data-driven applications in .NET. It supports various data access scenarios, including
connected and disconnected data access, data binding, data manipulation, and
transaction management. Developers can use the ADO.NET object model to interact
with various data sources, including relational databases, XML files, and more, within
their .NET applications.