XML, Networking, and

Web Services
with .NET
DEEPTHI JHA S
Creating XML Documents

To create XML documents in Visual Studio Code, you can follow these steps:
 Open Visual Studio Code: Launch Visual Studio Code on your computer.
 Create a New File: Click on "File" in the menu bar, then select "New File" to
create a new file.
 Save the File with ".xml" Extension: Save the newly created file with a ".xml"
extension. You can do this by clicking on "File" > "Save As" and then providing a
file name with the ".xml" extension.
 Start Writing XML: Once the file is created and saved, you can start writing your
XML content. You can use XML syntax to structure your data as needed.
 Edit and Save: You can continue editing your XML document as needed.
Remember to save your changes regularly.
using System;
new XElement("Book", // Save the document to a
using System.Xml.Linq;
file
namespace CreateXmlDocument new document.Save("Library.xml"
XElement("Title", "To Kill a );
{ class Program Mockingbird"),
{ static void Main(string[] args) Console.WriteLine("XML
new
XElement("Author", "Harper
document created
{ // Create the root element successfully!");
Lee"),
XElement root = new
XElement("Library", new }
XElement("Year", "1960") ) );
new XElement("Book", }
// Create the XML document
new XElement("Title", "The }
Catcher in the Rye"), XDocument document = new
XDocument( new
new XElement("Author", "J.D.
Salinger"),
XDeclaration("1.0", "utf-8",
Output: xml document
"yes"),
new XElement("Year", "1951") created successfully.
root
),
);
XML ELEMENTS

 An XML element is everything from (including) the element's start tag

to (including) the element's end tag.

SYNTAX

 element-name is the name of the element. The name its case in the
start and end tags must match.
 attribute1, attribute2 are attributes of the element separated by
white spaces. An attribute defines a property of the element. It
associates a name with a value, which is a string of characters.
Empty Element and Example

 An empty element (element with no content) has following syntax

−<name attribute1 attribute2.../>
 Following is an example of an XML document using various XML
element −
XML Elements Rules

Following rules are required to be followed for XML elements −

 An element name can contain any alphanumeric characters. The only
punctuation mark allowed in names are the hyphen (-), under-score (_)
and period (.).
 Names are case sensitive. For example, Address, address, and
ADDRESS are different names.
 Start and end tags of an element must be identical.
 An element, which is a container, can contain text or elements as seen
in the above example.
XML Attributes

 Attributes are part of XML elements. An element can have multiple

unique attributes. Attribute gives more information about XML
elements. To be more precise, they define properties of elements. An
XML attribute is always a name-value pair.

Attributes are used to add a unique label to an element, place the label
in a category, add a Boolean flag, or otherwise associate it with some
string of data.
 Syntax:
XML Attributes

 In the this example, we have categorized the plants by including

attribute category and assigning different values to each of the
elements. Hence, we have two categories of plants, one flowers and
other shrubs. Thus, we have two plant elements with different
attributes.
Some things to consider when using attributes are:
 attributes cannot contain multiple values (elements can)
 attributes cannot contain tree structures (elements can)
 attributes are not easily expandable (for future changes)
 Example program for attributes
and elements
using System;
new XElement("Book",
using System.Xml.Linq;
new XAttribute("id", "2"),
class Program
new XElement("Title", "Learn
{ static void Main() XML"),
{ // Create a new XML document new XElement("Author", "Jane
Smith"),
XDocument xmlDoc = new XDocument(
new XElement("Year", "2021") )
new XDeclaration("1.0", "utf-8", "yes"), )
new XElement("Library", );
new XElement("Book", // Display the XML document
new XAttribute("id", "1"), Console.WriteLine(xmlDoc);
new XElement("Title", "C# // Save the XML document to a file
Programming"),
xmlDoc.Save("Library.xml");
new XElement("Author", "John
}
Doe"),
}
 Searching for a Single Node

Searching for a single node in a data structure using C# can vary depending on the type of data structure
you are dealing with. Here are steps for searching a single node in three common data structures: a binary
search tree (BST), a linked list, and a graph using depth-first search (DFS).

1. Binary Search Tree (BST)

 Steps:
1. Start at the root node.
2. Compare the target value with the value of the current node.
3. If they are equal, you have found the node.
4. If the target value is less than the current node's value, move to the left child and repeat from step 2.
5. If the target value is greater than the current node's value, move to the right child and repeat from step
2.
6. If you reach a null node, the target value is not in the tree.
 2. Linked List
 Steps:
1. Start at the head of the list.
2. Compare the target value with the value of the current node.
3. If they are equal, you have found the node.
4. If not, move to the next node and repeat from step 2.
5. If you reach the end of the list (null node), the target value is not in the list.
 3. Graph (using Depth-First Search)
 Steps:
1. Start at the given node.
2. Mark the node as visited.
3. Compare the target value with the value of the current node.
4. If they are equal, you have found the node.
5. If not, recursively search each adjacent (neighbor) node that has not been visited yet.
6. If all nodes connected to the start node are visited and the target node is not found, it
does not exist in the graph.
 Searching single node by using linked list

public Node Search(int data)

{
using System; public class Node {
Node current = head; public class Program
public int Data; public Node Next;
public Node(int data){ while (current != null) {

Data = data; Next = null;}} { if (current.Data == data) public static void Main(string[] args)

public class LinkedList{ {return current;} {LinkedList list = new LinkedList();

private Node head; current = list.Add(1); list.Add(2); list.Add(3);

current.Next } return null; list.Add(4);
public LinkedList()
} public void Display() Console.WriteLine("Linked List:");
{ head = null;} list.Display();
public void Add(int data){ { Node current = head;
int searchValue = 3;
Node newNode = new Node(data); while (current != null)
Node foundNode =
{ list.Search(searchValue);
if (head == null)
Console.Write(current.Data + " if (foundNode != null)
{ head = newNode;}
"); {Console.WriteLine($"Node with value
else{ Node current = head; while
current = current.Next; {searchValue} found.");
(current.Next != null)
} }else{ Console.WriteLine($"Node with
{ current = current.Next; }
value {searchValue} not found.");
current.Next = newNode; } } Console.WriteLine(); }}
}}}
 Search Axes

In XML, XPath (XML Path Language) is used to navigate through elements and attributes
in an XML document.
XPath uses a variety of expressions, including axes, to locate specific parts of an XML document.
Axes allow you to specify the direction of navigation relative to the current node.
Here are some common axes used in XPath:
1.Child Axis (/): Selects all child nodes of the current node.
Example: /bookstore/book selects all <book> elements that are children of the <bookstore>
element.
2.Parent Axis (..): Selects the parent of the current node.
Example: ../title selects the <title> element that is a parent of the current node.
3.Attribute Axis (@): Selects the attributes of the current node.
Example: @lang selects the lang attribute of the current node.
4.Self Axis (self::): Selects the current node itself.
Example: self::book selects the current node if it is a <book> element.
1.Descendant Axis (//): Selects all descendants (children, grandchildren, etc.) of the current
node.
Example: //author selects all <author> elements in the document.

2.Ancestor Axis (ancestor::): Selects all ancestors (parent, grandparent, etc.) of the current
node.
Example: ancestor::bookstore selects the <bookstore> element if it is an ancestor of the
current node.

3.Following Axis (following::): Selects all nodes that come after the current node in document
order.
Example: following::book selects all <book> elements that come after the current node.

4.Preceding Axis (preceding::): Selects all nodes that come before the current node in
document order.
Example: preceding::book selects all <book> elements that come before the current node.
 Where clause

In C# and .NET, the where clause is primarily used in two contexts:

1.Generics: In generics, the where clause allows you to specify constraints on type
parameters.
2. This ensures that the type arguments provided for a generic type or method meet
certain criteria.

2.LINQ (Language-Integrated Query): In LINQ, the where clause is used to filter

data from a sequence
3.Based on a specified condition.
4. Generics: In the context of generics, the where clause is used to impose constraints on the type
parameters used in a generic class or method. These constraints can include interfaces that the
type must implement, whether the type is a reference type or a value type, and whether it has a
parameter-less constructor.
 Where claus

 2. LINQ:In LINQ, the where clause is used to filter elements from a sequence based on a
specified condition. It is used in query expressions to narrow down the results to only those that
meet the given criteria.
 In this LINQ query, the where clause filters out the odd numbers from the list numbers, selecting
only the even numbers.
 In summary, the where clause in C# and .NET provides a way to apply constraints or conditions,
whether in the context of generics to specify requirements for type parameters or in LINQ to
filter elements from sequences.
 C# program demonstrating the use of the
where clause in a LINQ (Language-Integrated Query) query to filter a list
of integers.

using System; using System.Collections.Generic; using System.Linq;

class Program
{ static void Main()
{ // Initialize a list of integers
List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
// Use the where clause to filter the list for even numbers
var evenNumbers = numbers.Where(n => n % 2 == 0);
// Output the filtered list
Console.WriteLine("Even numbers:"); foreach (var num in evenNumbers)
{ Console.WriteLine(num);
} }}
Xml serialization

 XML serialization in C# and .NET allows you to convert objects into XML format
so that they can be easily stored, transported, or shared.
 This is particularly useful when you need to exchange data between different
systems or applications that use XML as a common format.

Here's a basic explanation of how XML serialization works in C#

and .NET:Attributes:
 In order to specify how an object should be serialized, you use attributes
provided by the System.Xml.Serialization namespace.

The two main attributes are:

 [Serializable]: This attribute marks a class as serializable, meaning its
instances can be converted into XML.
 [XmlElement]: This attribute specifies that a particular member of a class
should be serialized as an XML element.
NETWORKING

 Networking in XML typically refers to exchanging data between

different systems or applications using XML (extensile Markup
Language) as the format for the data. XML is a popular choice for
networking due to its simplicity, flexibility, and human-readable format.
Here's how networking with XML typically works:
 Data Representation: XML provides a way to represent structured
data in a text format. Data is organized into elements, attributes, and
text content within a hierarchical structure.
 Data Exchange: XML documents can be exchanged between different
systems or applications over a network. This exchange can occur
through various network protocols such as HTTP, FTP, SMTP, etc.
NETWORKING

 XML Parsers: Both the sender and receiver typically use XML parsers to process
XML documents. These parsers can read XML data, validate it against a schema if
necessary, and extract relevant information from it.
 Data Encoding: XML data can be encoded using different character encodings
such as UTF-8, UTF-16, etc. It's important for both the sender and receiver to agree
on the encoding to ensure proper data interpretation.
 XML Schema: In some cases, XML documents are validated against a schema to
ensure that they adhere to a specific structure and format. XML Schema Definition
(XSD) is commonly used for this purpose.
 Web Services: XML is often used in web services for communication between
different applications over the internet. SOAP (Simple Object Access Protocol) and
REST (Representational State Transfer) are two common architectures for
implementing web services using XML.
NETWORKING

 Serialization: XML data can be serialized into a string format for

transmission over the network and then deserialized back into XML
format on the receiving end.
 Security: When transmitting XML data over a network, security
considerations such as encryption and authentication may need to be
addressed to ensure the confidentiality and integrity of the data.
 Overall, networking with XML involves sending and receiving XML
documents over a network, parsing them, and extracting relevant
information to enable communication and data exchange between
different systems or applications.
 Networking - Web Application
with Client-Side Code
 A web application with client-side code is a type of software application that utilizes a combination of client-
side and server-side technologies to deliver dynamic and interactive content to users through web browsers.
 Client-Side Code: Client-side code refers to the scripts and programs that run directly on the user's web
browser. This code is primarily written in languages such as HTML (Hypertext Markup Language), CSS
(Cascading Style Sheets), and JavaScript. Here's what each of these languages does:
 HTML structures the content of web pages, defining elements like text, images, and links.
 CSS styles the appearance of HTML elements, controlling aspects such as colors, layout, and typography.
 JavaScript provides interactivity and dynamic behavior to web pages, enabling features like form
validation, animations, and AJAX (Asynchronous JavaScript and XML) requests.
 Server-Side Code: In addition to client-side code, web applications typically also include server-side code,
which runs on the web server. This code is responsible for processing requests from clients, interacting with
databases or other external resources, and generating dynamic content. Common technologies used for
server-side development include:
PHP,Python (with frameworks like Django or Flask),Ruby on Rails,Java (with frameworks like Spring or
Servlets),Node.js,ASP.NET (with C#)
 Networking: Networking plays a crucial role in web applications, facilitating communication between the
client (web browser) and the server. When a user interacts with a web application, their browser sends
HTTP requests to the server, which then processes these requests and returns HTTP responses containing
the requested data or resources.
 Asynchronous Communication: Modern web applications often utilize asynchronous communication
techniques to enhance user experience. This includes techniques like AJAX (Asynchronous JavaScript and
XML) and Fetch API, which allow the browser to make requests to the server in the background without
reloading the entire page. This enables dynamic updates and smoother interactions without interrupting
the user's workflow.
 Client-Server Interaction: In a web application with client-side code, much of the interaction between
the client and server occurs asynchronously through AJAX requests or similar techniques. The client-side
code can make requests to the server to fetch data or perform actions without needing to reload the entire
page. The server processes these requests and sends back responses, which the client-side code can then
use to update the user interface dynamically.
.NET Client and .NET Server

 .NET Client:
 A .NET client refers to an application or component that consumes services
provided by another application or server. This client application could be a
desktop application, a web application, a mobile app, or even another server.
 In the context of a .NET client, it could be developed using various
technologies within the .NET ecosystem, such as Windows Presentation
Foundation (WPF) for desktop applications, ASP.NET MVC or ASP.NET Core for
web applications, Xamarin for cross-platform mobile apps, or even .NET Core
or .NET Framework for general-purpose applications.
 The .NET client interacts with the .NET server by making requests to it and
processing the responses received.
 .NET Client and .NET Server

 .NET Server:
 A .NET server, on the other hand, refers to an application or component that provides services or resources to
clients. This server application could be hosting web services, APIs, databases, or other resources that clients need
to access.
 In the context of a .NET server, it could be developed using technologies like ASP.NET Web API, ASP.NET Core,
Windows Communication Foundation (WCF), or even plain .NET Core or .NET Framework for building server-side
applications.
 The .NET server listens for incoming requests from clients, processes those requests, performs necessary operations
(such as querying databases, executing business logic, etc.), and sends back responses to the clients.
In summary, in a .NET-based distributed system:
 The .NET client consumes services provided by the .NET server.
 The .NET server provides services or resources to the .NET client.
 Communication between the client and server can happen over various protocols such as HTTP, TCP, or
others supported by the .NET framework.
 Both the client and server components can be developed using various technologies within the .NET
ecosystem, depending on the specific requirements and constraints of the system.
.NET Client and External Party Web
Service

 .NET Client: ".NET" refers to a software framework developed by Microsoft that

primarily runs on Microsoft Windows. It provides a large library of predefined class code
to support a variety of programming needs, including web development, desktop
software development, and mobile app development.
 A ".NET client" typically refers to a software application or component developed using
the .NET framework that interacts with other software systems or services. This
interaction could involve sending requests, receiving responses, and processing data
from those services.
 External Party Web Service: An external party web service is a web-based service
provided by a third-party organization or entity. These services expose functionalities or
data over the internet, typically through standardized protocols like HTTP or HTTPS.
 External party web services are often used to integrate different systems or
applications. For example, a company's website might use an external party's payment
processing web service to handle online transactions securely.
 External Client and .NET Web
Service
 An "external client" in the context of a .NET web service refers to any application or system outside of the web
service itself that wants to interact with it. This interaction typically involves sending requests to the web service
to perform certain actions or retrieve data, and receiving responses back from the web service.
 A ".NET web service" is a web service built using the Microsoft .NET framework. It's a software system designed
to support interoperable machine-to-machine interaction over a network. In the context of .NET, this often
involves creating web services using technologies like ASP.NET Web API or Windows Communication Foundation
(WCF).
Here's how the interaction typically works:
 Client Sends Request: The external client, which could be a web application, mobile app, desktop application,
or another web service, sends a request to the .NET web service. This request could be in the form of an HTTP
request, SOAP message, or some other protocol supported by the web service.
 Web Service Processes Request: The .NET web service receives the request and processes it. This might
involve querying a database, performing business logic, or integrating with other systems.
 Web Service Sends Response: After processing the request, the .NET web service sends a response back to
the client. This response typically contains the result of the requested operation or any relevant data.
 Client Receives Response: The external client receives the response from the web service and can then take
appropriate action based on the information returned.
WCF - Windows Communication
Foundation

 Windows Communication Foundation (WCF) is a framework for building service-

oriented applications.
 Using WCF, you can send data as asynchronous messages from one service
endpoint to another.
 A service endpoint can be part of a continuously available service hosted by IIS, or it
can be a service hosted in an application
 Creating a WCF Project

Creating a WCF (Windows Communication Foundation) project in Microsoft Visual Studio is a straightforward
process. Here are the steps:
1.Open Visual Studio: Launch Microsoft Visual Studio from the start menu or desktop shortcut.
2.Create a New Project: Click on "Create a new project" or go to File > New > Project.
3.Select Project Type: In the "Create a new project" dialog, select the appropriate project template. For
creating a WCF project, you typically choose either "Visual C#" or "Visual Basic" (depending on your
preferred programming language) from the left panel, then select "WCF" from the middle panel.
4.Choose WCF Template: After selecting "WCF," you'll see various WCF project templates. Choose the
one that best fits your requirements. Common options include:
•WCF Service Library: This template is used to create a reusable WCF service library.
•WCF Service Application: This template creates a new WCF service hosted in IIS (Internet Information
Services).
•WCF Workflow Service Application: This template is used to create a WCF service that is hosted by
Workflow Service Host.
 Creating a WCF Project

5.Name Your Project: Give your project a name and choose the location where you want to save it. Then, click
"Create" or "OK."
6.Configure WCF Project: After the project is created, you may need to configure it depending on the selected
template. This might involve defining service contracts, data contracts, behaviors, endpoints, etc. You can find
these configurations in the web.config or app.config file depending on the type of WCF project you've
created.
7.Implement Service Contracts: If you've chosen a template that doesn't generate the service contracts
automatically, you'll need to define them yourself. These contracts specify the operations that the service
provides.
8.Implement Service Logic: Implement the logic for your WCF service. This includes writing the code that
defines the functionality of each operation defined in the service contract.
9.Test Your Service: Once your service is implemented, you can test it locally using Visual Studio's built-in
tools or by hosting it in IIS or another hosting environment.
10.Deploy Your Service (Optional): If you're satisfied with your service and want to make it available to
clients, you can deploy it to a production environment. This typically involves configuring endpoints, bindings,
and other settings in the deployment environment.
That's it! You've successfully created a WCF project in Microsoft Visual Studio. Make sure to build and test your
service thoroughly before deploying it to production.
Hosting a WCF Service

 Install Necessary Tools:

 Install .NET Core SDK: Ensure that you have the .NET Core SDK installed on your
machine. You can download it from the official .NET website.
 Create WCF Project:
 Open a terminal or command prompt.
 Create a new folder for your WCF project.
 Inside the folder, create your WCF service project using the .NET CLI (Command
Line Interface) by running the following command:
 dotnet new web --name MyWcfService
 This command creates a new ASP.NET Core web application project with the
necessary files and folder structure for hosting a WCF service.
 Hosting a WCF Service

 Implement Service Contract and Logic: Navigate to the newly created project folder
(MyWcfService) in your terminal.Implement your WCF service contract interface and service logic in the
generated C# files.
 Configure Service Endpoints: Configure your service endpoints in the appsettings.json file or in the
Startup.cs file. Define the appropriate bindings, addresses, and contracts for each endpoint.
 Run the WCF Service: In the terminal, navigate to the project folder (MyWcfService).Run the following
command to start the WCF servicedotnet run
 Test the Service: Once the service is running, you can test it using tools like WCF Test Client, browser,
or custom client applications to ensure that it's accessible and functioning correctly.
 Deploy (Optional): If you want to deploy your WCF service to a production environment,
 you can publish it using the .NET CLI: dotnet publish -c Release This command generates a set
of files that can be deployed to a hosting environment.