Web Services Deep Dive

There are 3 parts of WCF applications:

• WCF Service: core part of application, define BS logic and could be anything like calculating data, retrieving information from DB, process order. It has:
  - Service contract: Specifies what operation are provided to clients
  - Data contract: Specifies data structure that are exchanged between the service and client.
• WCF Service Host: is responsible for hosting the WCF service, like listening for incoming request, managing lifetime, provide necessary binding. Withous a Host, the service can not be accessed, it can be hosted such as:
  - IIS (internet information service) which means service runs inside IIS as As application;
  - Self-Hosting which means we can host service inside console application etc.;
  - WAS (windows activation service) which means more advanced version of IIS and enable non-HTTP protocol like TCP.
• Service Client: is the application or service that use the WCF service, it calls the methods from service and use them, the client can be any kind of application (web,desktop,mobile) that needs to communicate with the service. The client typically uses a proxy class generated by tools,VS which acts as an intermediary to call service methods. Example: Calling GetWeather() method from proxy class which is use WeatherService (see below)

Fundamentals of WCF:

Suppose we have 2 clients: One of them wants to use WebService which sends data over the network by using HTTP protocol and want reply in XML formati (HTTP + XML e.g., SOAP/REST over HTTP), the other client wants to use WebService which sends data over the network by using TCP protocol and replying in binary format (TCP + Binary).

The problem in here is, we need to create 2 different Services for 2 different clients. WCF is solving this problem writing one single service which can be used by 2 different clients-either they want same protocol or a different protocol ex: basicHttpBinding → for HTTP + XML or netTcpBinding → for TCP + Binary. We don’t define the protocol name inside the WebService class itself, instead we configure it in the WCF configuration (app.config/web.config) under the <endpoint> element.

Without WCF we can create simpler,lighweight approach SOAP based service which can use ASMX. In application we choose ASP.NET Web Application (ASMX) template. But WCF offering more features like WS-* standarts, reliable messaging and more, so if need full SOAP features we use WCF on .NET framework. It only runs on Windows as part of .NET framework. In application we choose WCF Service Application app from template.

If we need SOAP on cross-platform (Windows,Linux, MacOS) but limited features we use SoapCore library as WCF not supported on .NET Core (now .NET5/6/7/8). SoapCore is not typically used for client-side, is mainly used for server-side. If we want to build a client-side service we use ServiceModel.Http library, it allow the client-side functionality of WCF in .Net Core but itself does not support server-side.

Key terms:

• ServiceContract: Interface define service's operation, using [ServiceContract] and [OperationContract] attributes
• DataContract: Class define data structure used by service using [DataContract] and [DataMember] attributes

application programming interface, is set of rules and protocols that define how different software app can interact with each other. It doesn’t have to involve the Web. It has 2 types, such as local APIs (e.g., a C# class library) or remote APIs (e.g., REST APIs or SOAP APIs).

Local API (No Internet) means: we're writing a C# desktop app to manipulate files. We use the .NET File API provided by the framework to perform tasks ( using the File and Directory classes and streams FileStream, StreamReader, StreamWriter ) like reading, writing, or deleting files.

WEB API: is type of Remote API allow different applications communicate with each other over WEB, using HTTP(S) as protocol. Commonly used to enable web app, mobile app and other system to interact with external services and exchange data. RESTful APIs (which use JSON or XML over HTTP) and GraphQL APIs are types of Web APIs. ASP.NET Web API (or just Web API) Used to build RESTful services.

Key Distinction: Both are designed for communication over the web. All Web Services are Web APIs, but not all Web APIs are Web Services.

These define the format of data exchanged between client and server.

• Accept Header: Tells the server what the client expects in the response (e.g., application/json, application/xml).
• Content-Type: Tells the server what the format of the data is in the request body (e.g., during a POST).

POST /api/users HTTP/1.1
Content-Type: application/json

{
  "name": "FS",
  "email": "firuza@example.com"
}

• void: Returns nothing (common for DELETE).
• HttpResponseMessage: Direct control over the response, including StatusCode.

Found in System.Net.Http, HttpClient sends requests and receives responses. Using IHttpClientFactory is best practice to manage instance lifetimes and avoid socket exhaustion.

public class ApiService {
    private readonly IHttpClientFactory _httpClientFactory;

    public ApiService(IHttpClientFactory httpClientFactory) {
        _httpClientFactory = httpClientFactory;
    }

    public async Task<string> GetDataAsync() {
        var client = _httpClientFactory.CreateClient();
        var response = await client.GetAsync("https://api.example.com/");
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadAsStringAsync();
    }
}

Web API uses different libraries to convert .NET objects to JSON:

• Newtonsoft.Json (Json.NET): Feature-rich, best for complex scenarios in older ASP.NET Web API.
• System.Text.Json: High performance, low memory, default for modern .NET Core.
• JSON.stringify(): The JavaScript equivalent used on the Client-side.

OpenAPI is the standard for describing RESTful APIs. It generates a structured JSON description of your endpoints, formats, and auth methods, allowing tools like Postman or Swagger UI to interact with your API without manual documentation.

Setup:

// In Startup.cs or Program.cs
services.AddSwaggerGen();

app.UseSwagger();
app.UseSwaggerUI(c => {
    c.SwaggerEndpoint("/swagger/v1/swagger.json", "My API v1");
});

Asynchronous JavaScript and XML is a technique to update parts of a web page without a full refresh.

• Async: The page stays functional while waiting for the server.
• Dynamic: Updates only specific elements (e.g., search results, comments).

Modern Implementation (Fetch API):

function loadData() {
    fetch('https://api.example.com/posts/1')
        .then(response => response.json())
        .then(data => {
            document.getElementById('content').innerHTML = JSON.stringify(data);
        })
        .catch(error => console.error('Error:', error));
}