GraphQL with .NET Core Microservices.pdf

In this Webinar, will talk on GraphQL with .NET, that provides a modern and flexible approach to building APIs. It empowers developers to create efficient and tailored APIs that meet the specific needs of their applications and clients.

1. GraphQL
with .Net Core
Presenting by: Mudassir Qureshi
Demonstration by: Seemab Ashfaque Shaik
Webinar Session | GraphQL

2. Agenda
1.Intorduction to GraphQL with .Net Core
2.Why isGraphQL?
3.GraphQLCore Concepts
4.GraphQL vs REST
5.Creating aGraphQL Schema
6.Queries andMutationin GraphQL
7.GraphQL in Microservices Architecture
8.Summary
9.Case study or Demonstration
10.Q&A

3. GraphQLwith .Net Core

4. 1.Introduction to GraphQL with .NET Core
It was created by Facebook back in 2012 for use in their mobile applications, but it was madeopen
source in 2015 and has grown in popularity ever since.
GraphQL is a query language for APIs and a runtime for fulfilling those queries with your existing
data. GraphQL provides a complete and understandable description of the data in your API, gives
clients the power to ask for exactly what they need and nothing more, makes it easier to evolve
APIs over time, and enables powerful developer tools.
illustration
REST API

5. GraphQL is a query language for APIs, it gives power to the client to control the response on what
they need instead of the server deciding what to respond.
It sits between clients and backend services and fulfills the query for clients. GraphQL can
aggregate multiple resource requests into a single query.
1:1 What is GraphQL

6. 1.Declarative Data fetching.
2.Single Endpoints.
3.Strong Typing Systems.
4.Real-Time Data with Subscriptions.
5.Batching and Efficiency.
6.Evolutionary API.
7.Documentation and Introspection.
8.Wide Adoption.
1:2 Flexibility and efficiency in data retrieval

7. Why is GraphQL?
02

8. 1.Precision in Data Retrieval: GraphQL Addresses over-fetching.
2.Elimination of under-fetching:GraphQL tackles under-fetching.
3.Single Request for Multiple Resources: Efficient Network Usage.
4.Reduced Latency: Optimized Data Transfer.
5.Dynamic Responses: Adaptability to UI Requirements.
6.Improved Front-End Development: Empowerment of Front-End Developers.
7.Real-time Capabilities:Real-time Data Updates.
8.Schema Evolution:Graceful API Evolution.
Why GraphQL ?
In summary, GraphQL addresses the issues of over-fetching and under-fetching present
in REST, offers a streamlined approach with single requests for multiple resources, and
enhances overall efficiency in data transfer, making it a compelling choice for modern
API development.

9. 2.1 Over and Under-fetching issue in REST
▪Over-fetching is fetching too much data, meaning there is data in the response you don't use
and fetching less variables that are required at this point.
▪Under-fetching is not having enough data with a call to an endpoint, forcing you to call a second
endpoint,

10. Example

11. 2.2 Single request for multiple resources in GraphQL
One of the key features of GraphQL that contributes to its efficiency is the ability to request multiple
resources in a single query. This is in contrast to traditional REST APIs, where multiple endpoints
might need to be accessed to retrieve related data. In GraphQL, you can compose a single query to
obtain all the information you need.
Benefits:
1.Reduced Round Trips
2.Minimized Latency
3.Optimized Data Transfer
4.Simplified Client Logic
5.Hierarchical Structure
In summary, the ability to request multiple resources in a single query is a powerful feature of
GraphQL that streamlines data retrieval and contributes to more efficient communication between
clients and servers.

12. GraphQLCore Concepts
Queries, Mutations and Subscriptions
03

13. GraphQL has several core concepts that form the foundation of the query language and its
execution.
The Schema Definition Language (SDL):GraphQL has its own type system that’s used to define
the schema of an API. The syntax for writing schemas is called Schema Definition Language (SDL).
Here is an example of how we can use the SDL to define a simple type called Person:
1
3
2
Note that we just created a one-to-
many-relationship between Person
and Post since the posts field on
Person is actually an array of posts.

14. 3.1 Fetching Data with Queries
When working with REST APIs, data is loaded from specific endpoints. Each endpoint has a clearly
defined structure of the information that it returns. This means that the data requirements of a client are
effectively encoded in the URL that it connects to.
The approach that’s taken in GraphQL is radically different. Instead of having multiple endpoints that
return fixed data structures, GraphQL APIs typically only expose a single endpoint. This works because
the structure of the data that’s returned is not fixed. Instead, it’s completely flexible and lets the client
decide what data is actually needed.
Let’s take a look at an example query that a client could send to a server:
TheallPersonsfield in this query is called theroot fieldof the query. Everything that follows the rootfield,
is called thepayloadof the query. The only field that’s specified in this query’s payload isname.
This query would return a list of all persons
currently stored in the database.

15. 3.2 Queries with Arguments
In GraphQL, each field can have zero or more arguments if that’s specified in the schema. For
example, the allPersons field could have a last parameter to only return up to a specific number of
persons. Here’s what a corresponding query would look like:
Ex.1
Ex.2
{
"allPersons" : [
{"name" : "Sarah"},
{"name" : "Alice"}
]
}
{
allPersons(id: "123")
{
name
age
}
}
{
"allPersons" : {
"name" : "Johnny",
"age: 29
}
}
output
output

16. 3.3 Writing Data with Mutations
Next to requesting information from a server, the majority of applications also need some way of
making changes to the data that’s currently stored in the backend. With GraphQL, these changes
are made using so-called mutations. There generally are three kinds of mutations:
•creating new data
•updating existing data
•deleting existing data
"createPerson": {
"name": "Bob",
"age": 36,
}
(The server response for themutation
would look as follows)

17. 4.GraphQL vs REST API
Here is the important difference between GraphQL and REST API.
GraphQL REST
GraphQL is an application layer server-side technology
which is developed by Facebook for executing queries
with existing data.
REST is a software architectural style that defines a set of
constraints for creating Web services.
It follows client-driven architecture. It follows server-driven architecture.
GraphQL can be organized in terms of a schema. REST can be arranged in terms of endpoints.
GraphQL is a growing community. REST is a large community.
The development speed in GraphQL is fast. The development speed in REST is Slow.
The learning curve in GraphQL is difficult. The learning curve in REST is moderate.
The identity is separated from how you fetch it. The endpoint you call in REST is the identity of an object.

18. 4.1GraphQLvs REST API
▪. GraphQL
In GraphQL, the server determines available resources.
Rest
The shape and size of the resource are determined by the
server in REST.
GraphQL provides high consistency across all platforms.It is hard to get consistency across all platforms.
The message format for GraphQL mutations should be a
string.
The message format for REST mutations can be anything.
It is strongly typed. It is weakly typed.
GraphQL API endpoints are single. REST API endpoints are multiple.
It uses metadata for
query validation.
It does not have machine-readable metadata cacheable.
Provides consistent and high-quality UX across all
operating systems.
It is difficult to get consistency across all operating
systems.
Partners of GraphQL require API customization.
It offers flexible public API that can easily enable new
applications.

19. 5.Creating aGraphQLSchema
A schema is like a contract between the server and the client. It defines what a GraphQL
API can and can't do, and how clients can request or change data. It's an abstraction
layer that provides flexibility to consumers while hiding backend implementation details.
Type system
{
hero {
name
appearsIn
}
}
{
"data": {
"hero": {
"name": "R2-D2",
"appearsIn": [
"NEWHOPE",
"EMPIRE",
"JEDI"
]
}
}
}

20. 5. 1Writing aGraphQLSchema
The GraphQL spec defines a language called the Schema Definition Language (SDL) to
write GraphQL schemas.
You use the available types defined by SDL to compose your GraphQL schema. We cover
four of the types in this article:
▪Object type
▪Scalar type
▪Query type
▪Mutation type
You’ll learn more about these types (and others) in upcoming articles.
It can be challenging to represent types as GraphQL schema, especially with complex
and extensive UIs. However, follow the four steps below to represent your types as a
GraphQL schema like a pro.

21. 5. 2Writing aGraphQLSchema
Step 1: Represent the nodes as object types:
Step 2: Add the scalar types as fields to the object types:
typeBlogPost{
}
type Author {
}
type BlogPost {
title: String!
content: String!}

22. 5. 3Writing aGraphQLSchema
Similarly, add a property called name of type String to the Author object.
Step 3: Represent the relationships
type Author
{name: String!
type BlogPost {
title: String!
content: String!
// It's required that every blog post has an author
//Hence the exclamation (!) to mark it as required
hasAuthor: Author!}

23. 5. 4Writing aGraphQLSchema
Similarly, the edge connecting an Author node to its BlogPosts is named hasBlog. Add a
field hasBlog of type BlogPost, inside the Author type to represent this relationship.
The square brackets around [BlogPost] indicates that the hasBlog field is stored as an
array. Because an author can be associated with 0, 1, or more blog posts, so the one-to-
many relationship was indicated by the asterisk (*) in the data graph.
type Author {name: String!
# An author can have more than one blog post
# Hence representing this as an array [BlogPost]
hasBlog: [BlogPost]}

24. 5. 5Writing aGraphQLSchema
The Last Step: Define queries and mutations:
While object types help you represent the data graph, they don’t help you define the
operations on it. To include the operations on the data graph, you need Query types and
Mutation types. The Query types define the read operations, and the Mutation types
define the write operations on the data graph. They define the type signatures of
operations that are used by your application to read or write data.
type Query {
# Return all blog posts
# Satisfies the data requirement for the first page
getAllBlogs(): [BlogPost] }
type BlogPost {title: String!content: String!
# It's required that every blog post has an author
# Hence the exclamation (!) to mark it as required
hasAuthor: Author! }
type Author {name: String!
# An author can have more than one blog post
# hence representing this as an array [blogpost]
hasBlog: [BlogPost]}

25. 5. 6Writing aGraphQLSchema
Next, you need an operation to fetch a specific blog post. To enable this operation, you
need to associate a unique ID with every blog post. The ID of a blog post is used to
fetch the blog content for the second application screen.
ID is a scalar type in GraphQL that represents a unique identifier and is added as a field
to the BlogPost and Author object type to uniquely identify each Author and their
BlogPosts.
type BlogPost
{
id: ID!
title: String!
content: String!
hasAuthor: Author!
}
type Author {
id: ID!
name: String!
hasBlog: [BlogPost]
}

26. 5. 7Writing aGraphQLSchema
Now, you can extend the Query type in the schema by adding a getBlogPost field; this
field can fetch a blog post with its unique ID.
type Query {
# Return all blog posts
# Satisfies the data requirement for the
first page
getAllBlogs(): [BlogPost]
# Returns a single blog post given it's ID.
getBlogPost(id: ID!): BlogPost
}
type Mutation
{
addBlogPost(title: String!, content: String!, authorID: ID!):
BlogPost
}
Similarly, you can add fields to the Mutation type to create
new objects. For example, here is a Mutation field to create
new blog posts:

27. 5. 8Writing aGraphQLSchema
We have successfully created the GraphQL schema for your simple blog application:
type Query
{
getAllBlogs(): [BlogPost]
getBlogPost(id: ID!): BlogPost
}
type Mutation
{
addBlogPost(title: String!, content: String!,
authorID: ID!): BlogPost!
}
type BlogPost
{id: ID!title: String!content:
String!hasAuthor: Author!
}
type Author {id: ID!name:
String!hasBlog: [BlogPost]
}

28. 6 Queries and Mutation in GraphQL
Queries:Queries are used to retrieve data from the GraphQLserver. They are analogous
to the `GET` method in RESTful APIs.
- Queries define the shape of the data that the client wants to fetch, including the fields
and nested fields.
- Queries are read-only operations and do not modify the data on the server.
- Example query:
query {
users {
id
name
email
}
}
This query requests the `id`, `name`, and `email` fields for all users from the server.

29. 6.1 Queries and Mutation inGraphQL
Mutations: Mutations are used to modify or create data on the GraphQL server. They are
analogous to `POST`, `PUT`, `PATCH`, or `DELETE` methods in RESTful APIs.
- Mutations define operations that modify the data, such as creating, updating, or
deleting objects.
- Mutations can have input parameters to pass data to the server.
- Example mutation:
mutation {
createUser(input: { name: "John Doe", email: "[email protected]" }) {
id
name
email
}
}
This mutation creates a new user with the specified `name` and `email`, and then returns
the `id`, `name`, and `email` of the newly created user.

30. 6.2 Queries and Mutation inGraphQL
Both queries and mutations are executed by sending a GraphQL request to the server
over HTTP or other transport protocols. The server processes the request, executes the
query or mutation, and returns the requested data or confirmation of the mutation.
queries are used for reading data from the server, while mutations are used
formodifyingor creating data on the server inGraphQL.

31. 7.GraphQLin Microservices Architecture
GraphQL in Microservice Architecture:
- Flexible Data Aggregation: In a microservice architecture, different services often
manage distinct subsets of data. GraphQL acts as an efficient data aggregation layer,
allowing clients to retrieve data from multiple services with a single request. This flexibility
reduces chattiness and overhead associated with multiple API calls.
Service Autonomy: Each microservice can expose its GraphQL schema, representing
the data it manages. This autonomy enables teams to independently develop, deploy, and
scale their services, while still providing a unified API surface for clients.
Versioning and Evolution: GraphQL's schema-based approach facilitates versioning
and evolution of microservices. Services can evolve their schemas independently, adding
or deprecating fields as needed, without impacting clients consuming their data.

32. 7.1GraphQLin Microservices Architecture
Efficient Communication: GraphQL's fine-grained control over data fetching enables
clients to request only the data they need, minimizing overfetching and underfetching.
This efficient communication between clients and services improves performance and
reduces network traffic.
Tooling and Ecosystem: GraphQL's growing ecosystem offers tooling and libraries
tailored for microservices, such as schema stitching for federated architectures and
performance monitoring tools. These resources simplify development, integration, and
management of GraphQL-based microservices.
GraphQL serves as a powerful middleware layer in microservice architectures, facilitating
efficient data aggregation, service autonomy, versioning, and efficient communication
between clients and services.

33. 8 Summary
In conclusion, GraphQL in .NET Core presents a compelling solution for modern API
development, offering flexibility, efficiency, and a unified approach to data fetching. By
leveraging GraphQL's query language and schema-based approach, developers can
streamline data retrieval, minimize overfetching and underfetching, and empower clients
with precise control over the data they receive. While there may be challenges such as a
learning curve and implementation complexity, the benefits of GraphQL, including
improved performance, reduced network traffic, and enhanced developer productivity,
make it a valuable addition to the .NET Core ecosystem. With its growing popularity and
robust tooling support, GraphQL in .NET Core is poised to shape the future of API
development, enabling teams to build scalable, efficient, and user-centric applications.

34. Demonstration

35. Thank you