12 MARKS

14 1. Write a detailed explanation of the following:

o The process of creating .NET projects.
o Inheritance in C# with examples.
o The benefits of ADO.NET, data binding, and its
integration with data source controls.
The Process of Creating .NET Projects
Creating a .NET project involves several steps using the .NET framework or .NET Core, primarily
through Visual Studio or the .NET CLI. Here's an overview:
1. Setting Up the Environment:
o Install the latest version of Visual Studio (with the .NET workload) or the .NET SDK if
using CLI.
2. Creating a New Project:
o Using Visual Studio:
1. Open Visual Studio.
2. Click Create a new project.
3. Choose the desired project template (e.g., Console App, ASP.NET Web App,
Class Library, etc.).
4. Configure the project by providing a name, location, and solution name.
5. Select the target framework (e.g., .NET 6, .NET 7).
o Using the .NET CLI:
1. Open the terminal/command prompt.
2. Run the command:
dotnet new <template> -n <ProjectName>
For example:
dotnet new console -n MyConsoleApp
3. Coding the Project:
o Write code in the main project file (e.g., Program.cs for console apps) and other
necessary files.
o Utilize libraries and frameworks as required.
4. Building the Project:
 o Using Visual Studio: Press Ctrl+Shift+B or click Build > Build Solution.
o Using the .NET CLI: Run:
dotnet build
5. Running the Project:
o Visual Studio: Press F5 to run in Debug mode or Ctrl+F5 for Release mode.
o CLI: Use:
dotnet run
6. Publishing the Application (Optional):
o Visual Studio provides a Publish option to package and deploy the app.
o CLI:
dotnet publish -c Release

Inheritance in C# with Examples

Inheritance in C# allows a class (child/derived class) to inherit properties, methods, and fields from
another class (parent/base class). It facilitates code reusability and a hierarchical class structure.
Key Points:
1. Base Class: The class being inherited.
2. Derived Class: The class that inherits.
3. Syntax:
class BaseClass
{
// Members
}

class DerivedClass : BaseClass

{
// Additional Members
}
Example:
using System;
class Animal {
public void Eat() {
Console.WriteLine("This animal eats food.");
}
}
class Dog : Animal {
public void Bark() {
Console.WriteLine("The dog barks.");
}
}
class Program {
static void Main() {
Dog myDog = new Dog();
myDog.Eat(); // Inherited from Animal
myDog.Bark(); // Defined in Dog
}
}
Output:
This animal eats food.
The dog barks.
Types of Inheritance in C#:
• Single Inheritance: One base class, one derived class.
• Multi-Level Inheritance: Derived class becomes the base class for another.
• Hierarchical Inheritance: Multiple derived classes inherit from a single base class.

Benefits of ADO.NET, Data Binding, and Integration with Data Source Controls
ADO.NET (Active Data Objects for .NET):
ADO.NET is a set of classes for interacting with data sources such as databases. It provides a bridge
between an application and data sources.
Benefits:
1. Disconnected Data Access:
 o Allows working with a local copy of the data, minimizing database connection usage.
2. High Performance:
o Efficient data handling through lightweight components.
3. Scalability:
o Handles large datasets efficiently.
4. Support for Multiple Data Sources:
o Works with SQL Server, Oracle, MySQL, and more.
5. XML Integration:
o Supports XML for data representation and manipulation.
Key Components:
• Connection: Establishes a connection to the database.
• Command: Executes SQL queries.
• DataReader: Reads data in a forward-only, read-only manner.
• DataSet/DataTable: Stores data locally for disconnected operations.
Data Binding:
Data binding connects UI elements with data sources, allowing seamless interaction and
synchronization.
Benefits:
1. Simplifies UI Development:
o Automatically reflects changes in the data source.
2. Reduces Boilerplate Code:
o No need for manual data transfer between UI and code.
3. Two-Way Binding:
o Updates the UI when the data source changes and vice versa.
Example: In a Windows Forms application:
textBox1.DataBindings.Add("Text", dataSet.Tables["Employees"], "Name");
Integration with Data Source Controls:
Data source controls in ASP.NET (like SqlDataSource, ObjectDataSource) facilitate easy binding to
data without requiring extensive code.
Benefits:
1. Declarative Data Access:
 o Allows specifying data operations directly in the markup.
2. Automatic CRUD Support:
o Simplifies operations like Create, Read, Update, Delete.
3. Improved Maintainability:
o Centralized control over data access logic.
Example with SqlDataSource:
<asp:SqlDataSource ID="SqlDataSource1" runat="server"
ConnectionString="<%$ ConnectionStrings:MyConnectionString %>"
SelectCommand="SELECT * FROM Employees">
</asp:SqlDataSource>

<asp:GridView ID="GridView1" runat="server" DataSourceID="SqlDataSource1">

</asp:GridView>
In this example, GridView automatically binds to the data fetched by SqlDataSource.

14 1. Elaborate on the following:

o How the Base Class Library supports development in
.NET.
o String manipulation and file handling in C# with
examples.
o Key features and benefits of ASP.NET web services.
1. How the Base Class Library (BCL) Supports Development in .NET
The Base Class Library (BCL) is a core component of the .NET Framework, providing a rich set of
reusable classes, interfaces, and value types that support common functionality required in software
development. It acts as a foundation for building applications in .NET.
Key Contributions of BCL:
• Extensive API Support: Includes classes for collections, file and data handling, networking,
threading, and more.
• Simplified Development: Provides pre-written, optimized code to handle complex operations,
reducing the need to write everything from scratch.
 • Platform Independence: Ensures compatibility across different operating systems supported
by .NET.
• Integration with CLR: Works seamlessly with the Common Language Runtime (CLR) to
enable memory management, exception handling, and type safety.
Examples:
• String Manipulation: Classes like System.String, System.Text.StringBuilder.
• File Handling: Classes like System.IO.File, System.IO.Directory.
• Data Access: Classes like System.Data for interacting with databases.

2. String Manipulation and File Handling in C#

String Manipulation
String manipulation in C# is performed using the System.String class and System.Text.StringBuilder for
efficiency in specific cases.
Concatenation: Joining strings using + or string.Concat().
Example: string fullName = firstName + " " + lastName;
Substring: Extract part of a string.
Example: string sub = text.Substring(7, 5);
Replace: Replace text in a string.
Example: string replaced = sentence.Replace("apples", "oranges");
Split & Join: Split strings into arrays or join arrays into strings.
Example: string[] fruits = csv.Split(',');
Trim: Remove whitespace or characters.
Example: string trimmed = padded.Trim();
Example 1: String Methods
string str = "Hello, World!";
Console.WriteLine(str.ToUpper()); // Output: HELLO, WORLD!
Console.WriteLine(str.Substring(7)); // Output: World!
Console.WriteLine(str.Replace("World", "C#")); // Output: Hello, C#!
Example 2: Using StringBuilder for Efficiency
var sb = new System.Text.StringBuilder("Hello");
sb.Append(", World!");
Console.WriteLine(sb.ToString()); // Output: Hello, World!
File Handling
File handling in C# uses the System.IO namespace to perform operations like creating, reading, writing,
and deleting files.
Create & Write: Use File.WriteAllText() or File.AppendAllText().
Example: File.WriteAllText("example.txt", "Hello, World!");
Read: Use File.ReadAllText() or File.ReadAllLines().
Example: string content = File.ReadAllText("example.txt");
Check Existence: Use File.Exists().
Example: if (File.Exists(path)) { Console.WriteLine("File exists."); }
Delete: Use File.Delete().
Example: File.Delete("example.txt");
Example 1: Writing to a File
using System.IO;

File.WriteAllText("example.txt", "Hello, File Handling!");

Example 2: Reading from a File
using System.IO;

string content = File.ReadAllText("example.txt");

Console.WriteLine(content); // Output: Hello, File Handling!
Example 3: Appending to a File
using System.IO;

File.AppendAllText("example.txt", "\nAppending this text.");

3. Key Features and Benefits of ASP.NET Web Services

ASP.NET Web Services are a technology for building interoperable, distributed applications over the
web.
Key Features:
1. Interoperability: Built on standards like SOAP and XML, enabling communication between
diverse systems.
2. Ease of Development: Simplifies the process with attributes like [WebMethod] for exposing
methods as services.
3. Scalability: Supports high-traffic applications with robust features.
 4. State Management: Can maintain user state across web requests using session management
techniques.
5. Security: Includes built-in support for authentication and encryption.
Benefits:
1. Language Independence: Services can be consumed by applications written in various
programming languages.
2. Platform Independence: Clients and servers can run on different operating systems.
3. Reduced Development Time: Reusability of services reduces coding effort.
4. Rich Tool Support: Seamless integration with Visual Studio for development and debugging.
Example: Creating an ASP.NET Web Service
[WebService(Namespace = "http://example.com/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
public class HelloWorldService : System.Web.Services.WebService {
[WebMethod]
public string SayHello(string name) {
return $"Hello, {name}!";
}
}
Example: Consuming a Web Service
HelloWorldService service = new HelloWorldService();
string message = service.SayHello("John");
Console.WriteLine(message); // Output: Hello, John!