Multiple round trips – multiple requests required to complete an execution before you can proceed<\/li>\n<\/ul>\nOver-fetching and under-fetching are two of the common problems you would often encounter when working with REST APIs. This is explained in more detail in the next section.<\/p>\n
The Problem of Under-Fetching and Over-Fetching Explained<\/h2>\n
Here is a typical example of REST endpoints for a typical application that manages blog posts.<\/p>\n
GET \/blogposts\r\nGET \/blogposts\/{blogPostId}\r\nGET \/authors\r\nGET \/authors\/{authorId}<\/pre>\nTo aggregate the data, you will have to make several calls to the endpoints shown here. Note that a request to the \/blogposts endpoint would fetch the list of blogposts together with authorId<\/code>, but it will not return author data. You need to make a call to \/authors\/{authorId}<\/code> multiple times to get author details of the authors. This problem is known as under-fetching since your API payload contains less data than you need. You can take advantage of Backend for Frontend or the Gateway Aggregation pattern to solve this problem. Still, in either case, you will need multiple calls to the API endpoints.<\/p>\nOn the contrary, your API payload might be too verbose as well. For example, you might want to know only details of the blogposts by calling the \/blogposts endpoint, but your payload will also contain authorId<\/code>. This problem is known as over-fetching, which implies that your API payload comprises more data than you need, hence consuming more network bandwidth. Here’s where GraphQL comes to the rescue.<\/p>\nBuilding Blocks of GraphQL<\/h2>\n
The main building blocks of GraphQL comprise schemas and types.<\/p>\n
Schema<\/h3>\n
In GraphQL, there is just one endpoint. This endpoint provides a schema used to inform API consumers about the functionality available for clients to consume, i.e., what data they may expect and what actions they can perform. A Schema in GraphQL is a class that extends the Schema class of the GraphQL.Types<\/code> namespace.<\/p>\nGraphQL has three primary operations: Query for reading data, Mutation for writing data, and Subscription for receiving real-time updates. A schema contains Query, Mutation, and a Subscription..<\/p>\n
\n- Query – In GraphQL, you can take advantage of queries for fetching or consuming data efficiently. The consumer or the client can mention the field or fields it needs instead of getting data for all the fields from a particular type. The client can only consume the fields that the API has exposed.<\/li>\n
- Mutation – In GraphQL, mutations are used to add, modify, or delete data. The client can only take advantage of the mutations that the schema has exposed to modify the data. In other words, a GraphQL client cannot manipulate data exposed by the API unless there is an appropriate mutation available.<\/li>\n
- Subscriptions – In GraphQL, subscriptions allow a server to send data to its clients, notifying them when events occur. Subscriptions support event-driven architectures, and they use WebSockets to provide real-time notifications.<\/li>\n<\/ul>\n
GraphQL Object Types<\/h3>\n
One of the essential components of GraphQL schema is the object type, used to describe the kind of item that may be retrieved through your API. Object Types in GraphQL are represented using GraphQL.Types.ObjectGraphType<\/code> class and contain fields and methods.<\/p>\nImplementing a GraphQL API in ASP.NET Core<\/h2>\n
Now leverage all learned thus far to build an application that uses GraphQL for performing CRUD operations.<\/p>\n
Getting Started: The Solution Structure<\/h3>\n
Figure 2 below illustrates the solution structure of the completed application.<\/p>\n
![\"Image](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/2021\/10\/word-image-5.png\")
<\/p>\n
Figure 2: Application structure<\/strong><\/p>\nAs you can see, there is only one project in the Solution for the sake of simplicity. The DataAccess and GraphQL solution folders are under the root of the project. The Models solution folder is under the DataAccess solution folder. So, when this project is compiled, the following three libraries will be generated:<\/p>\n
\n- BlogPostsmanagementSystem.dll<\/li>\n
- BlogPostsManagementSystem.DataAccess.dll<\/li>\n
- BlogPostsManagementSystem.DataAccess.Models.dll<\/li>\n<\/ul>\n
To help understand the organization of your code, including the dependencies, you can take advantage of CodeMaps in Visual Studio. Figure 3 below shows the CodeMap for this solution generated in Visual Studio 2019.<\/p>\n
![\"Image](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/2021\/10\/word-image-6.png\")
<\/p>\n
Figure 3: Organization of Code and Dependencies as Viewed using CodeMaps<\/strong><\/p>\nSteps to build a GraphQL API in ASP.NET Core 5<\/h3>\n
To build the application discussed in this article, follow these steps:<\/p>\n
\n- Create a new ASP.NET Core 5 application<\/li>\n
- Install the NuGet Packages<\/li>\n
- Create the Models<\/li>\n
- Create the Data Context<\/li>\n
- Register the Data Context<\/li>\n
- Create the Repositories<\/li>\n
- Add Services to the Container<\/li>\n
- Build the GraphQL Schema<\/li>\n
- Query<\/li>\n
- Mutation<\/li>\n
- Subscription<\/li>\n
- Create the Resolvers<\/li>\n
- Configure the GraphQL Middleware<\/li>\n<\/ol>\n
Create a new ASP.NET Core 5 Application<\/h3>\n
First off, create a new ASP.NET Core 5 project. To do this, execute the following command at the shell:<\/p>\n
dotnet new web -f net5.0 --no-https --name BlogPostsManagementSystem<\/pre>\nWhen you execute the above command, a new ASP.NET Core 5 project without HTTPS support will be created in the current directory.<\/p>\n
You can now take advantage of Visual Studio 2019 to open the project and make changes as needed. You\u2019ll use this project in the sections that follow.<\/p>\n
Install the NuGet Packages<\/h3>\n
In this example, you\u2019ll take advantage of HotChocolate for working with GraphQL. Hot Chocolate is an open-source .NET GraphQL platform that adheres to the most current GraphQL specifications. It serves as a wrapper around the GraphQL library, making building a full-fledged GraphQL server easier.<\/p>\n
HotChocolate is very simple to set up and configure and removes the clutter from creating GraphQL schemas. You can take advantage of HotChocolate to create a GraphQL layer on top of your existing application layer.<\/p>\n
Since support for GraphQL is not in-built in ASP.NET Core, you\u2019ll need to install the necessary NuGet packages via the NuGet Package Manager or the NuGet Package Manager Console.<\/p>\n
You\u2019ll need to install the following packages:<\/p>\n
HotChocolate.AspNetCore\r\nHotChocolate.AspNetCore.Playground\r\nMicrosoft.EntityFrameworkCore.InMemory<\/pre>\nTo do this, run the following commands at the NuGet Package Manager Console Window:<\/p>\n
Install-Package HotChocolate.AspNetCore\r\nInstall-Package HotChocolate.AspNetCore.Playground\r\nInstall-Package Microsoft.EntityFrameworkCore.InMemory<\/pre>\nAlternatively, you can install these packages by executing the following commands at the shell:<\/p>\n
dotnet add package HotChocolate.AspNetCore\r\ndotnet add package HotChocolate.AspNetCore.Playground\r\ndotnet add package Microsoft.EntityFrameworkCore.InMemory<\/pre>\nRun the application now, then add \/playground<\/code> to the URL to view the playground. . Here\u2019s how the output will look in the web browser.<\/p>\n![\"A](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/2021\/10\/a-screenshot-of-a-computer-description-automatica.png\")
<\/p>\n
Figure 4: Output from web browser<\/strong><\/p>\nCreate the Models<\/h3>\n
Create a solution folder called DataAccess<\/em> at the root of the project. Create another solution folder inside the DataAccess<\/em> folder called Models<\/em>; this is where the entity classes will go.<\/p>\nTo make things simple, you\u2019ll use two model classes in this example named Author<\/em> and BlogPost<\/em>. Select your project in the Solution Explorer Window<\/em>, right-click and select Add -> New Folder<\/em>. Inside this folder, create two .cs files named Author.cs<\/em> and BlogPost.cs<\/em> with the following content:<\/p>\nAuthor.cs<\/strong><\/p>\nusing HotChocolate;\r\nusing HotChocolate.Types;\r\nnamespace BlogPostsManagementSystem.DataAccess.Models\r\n{\r\n public class Author\r\n {\r\n [GraphQLType(typeof(NonNullType<IdType>))]\r\n public int Id { get; set; }\r\n [GraphQLNonNullType]\r\n public string FirstName { get; set; }\r\n [GraphQLNonNullType]\r\n public string LastName { get; set; }\r\n }\r\n}<\/pre>\nBlogPost.cs<\/strong><\/p>\nusing HotChocolate;\r\nusing HotChocolate.Types;\r\nnamespace BlogPostsManagementSystem.DataAccess.Models\r\n{\r\n public class BlogPost\r\n {\r\n public int Id { get; set; }\r\n [GraphQLType(typeof(NonNullType<StringType>))]\r\n public string Title { get; set; }\r\n [GraphQLNonNullType]\r\n public int AuthorId { get; set; }\r\n }\r\n}<\/pre>\nThe BlogPost<\/code> class contains a reference to the Author<\/code> class. Hence a BlogPost<\/code> can be written by only one author, but an author can write many blog posts.<\/p>\nBuild the DataContext<\/h3>\n
This example takes advantage of Entity Framework Core (in-memory) to work with data. Create a class called ApplicationDbContext<\/code> inside the DataAccess<\/em> solution folder of your project and write the following code in it:<\/p>\nApplicationDbContext.cs<\/strong><\/p>\nusing BlogPostsManagementSystem.DataAccess.Models;\r\nusing Microsoft.EntityFrameworkCore;\r\nnamespace BlogPostsManagementSystem.DataAccess\r\n{\r\n public class ApplicationDbContext : DbContext\r\n {\r\n public ApplicationDbContext(DbContextOptions\r\n <ApplicationDbContext> options) : base(options)\r\n {\r\n }\r\n public DbSet<Author> Authors { get; set; }\r\n public DbSet<BlogPost> BlogPosts { get; set; }\r\n protected override void OnModelCreating\r\n (ModelBuilder modelBuilder)\r\n {\r\n Author author1 = new Author\r\n {\r\n Id = 1,\r\n FirstName = \"Joydip\",\r\n LastName = \"Kanjilal\"\r\n };\r\n Author author2 = new Author\r\n {\r\n Id = 2,\r\n FirstName = \"Steve\",\r\n LastName = \"Smith\"\r\n };\r\n Author author3 = new Author\r\n {\r\n Id = 3,\r\n FirstName = \"Anand\",\r\n LastName = \"Narayanaswamy\"\r\n };\r\n modelBuilder.Entity<Author>().HasData(\r\n author1, author2, author3); \r\n modelBuilder.Entity<BlogPost>().HasData(\r\n new BlogPost\r\n {\r\n Id = 1,\r\n Title = \"Introducing C# 10.0\",\r\n AuthorId = 1\r\n },\r\n new BlogPost\r\n {\r\n Id = 2,\r\n Title = \"Introducing Entity Framework \r\n Core\",\r\n AuthorId = 2\r\n },\r\n new BlogPost\r\n {\r\n Id = 3,\r\n Title = \"Introducing Kubernetes\",\r\n AuthorId = 1\r\n },\r\n new BlogPost\r\n {\r\n Id = 4,\r\n Title = \"Introducing Machine Learning\",\r\n AuthorId = 2\r\n },\r\n new BlogPost\r\n {\r\n Id = 5,\r\n Title = \"Introducing DevSecOps\",\r\n AuthorId = 3\r\n }\r\n );\r\n }\r\n }\r\n}<\/pre>\nRegister a Data Context Factory<\/h3>\n
Now that the data context is ready, you should register it. However, you’ll register a DbContextFactory<\/code> in lieu of registering a DbContext<\/code> instance since it would allow for easy creation of DbContext<\/code> instances in the application when needed.<\/p>\nYou might often want to perform multiple units-of-work within a single HTTP request. In such cases, you can use the AddDbContextFactory<\/code> method to register a factory (in the ConfigureServices<\/code> method of the Startup<\/code> class) for creating DbContext<\/code> instances. Then you can leverage constructor injection to access the factory in your application.<\/p>\nThe following code snippet illustrates how you can take advantage of the AddDbContextFactory<\/code> method to register a DbContextFactory<\/code> instance:<\/p>\nservices.AddDbContextFactory<ApplicationDbContext>(\r\noptions => options.UseInMemoryDatabase(\"BlogsManagement\"));<\/pre>\nThe above code informs Entity Framework Core to create an in-memory database named BlogsManagement<\/em>.<\/p>\nCreate the Repositories<\/h3>\n
Create an interface named IAuthorRepository<\/code> in a file called IAuthorRepository.cs<\/em> inside the DataAccess<\/em> solution folder of your project with the following code in there. Make sure the interfaces are public.<\/p>\nIAuthorRepository.cs<\/strong><\/p>\n public interface IAuthorRepository\r\n {\r\n public List<Author> GetAuthors();\r\n public Author GetAuthorById(int id);\r\n public Task<Author> CreateAuthor(Author author);\r\n }<\/pre>\nCreate another interface named IBlogPostRepository<\/code> in the same folder with the following code:<\/p>\nIBlogRepository.cs<\/strong><\/p>\n public interface IBlogPostRepository\r\n {\r\n public List<BlogPost> GetBlogPosts();\r\n public BlogPost GetBlogPostById(int id);\r\n }<\/pre>\nThe AuthorRepository<\/code> and BlogPostRepository<\/code> classes will implement the interfaces IAuthorRepository<\/code> and IBlogPostRepository<\/code>, respectively.<\/p>\nCreate a file named AuthorRepository.cs<\/em> in the DataAccess<\/em> solution folder with the following code:<\/p>\nAuthorRepository.cs<\/strong><\/p>\nusing BlogPostsManagementSystem.DataAccess.Models;\r\nusing Microsoft.EntityFrameworkCore;\r\nusing System.Collections.Generic;\r\nusing System.Linq;\r\nusing System.Threading.Tasks;\r\nnamespace BlogPostsManagementSystem.DataAccess\r\n{\r\n public class AuthorRepository : IAuthorRepository\r\n {\r\n private readonly IDbContextFactory\r\n <ApplicationDbContext> _dbContextFactory;\r\n public AuthorRepository(IDbContextFactory\r\n <ApplicationDbContext> dbContextFactory)\r\n {\r\n _dbContextFactory = dbContextFactory;\r\n using (var _applicationDbContext = \r\n _dbContextFactory.CreateDbContext())\r\n {\r\n _applicationDbContext.Database\r\n .EnsureCreated();\r\n }\r\n }\r\n public List<Author> GetAuthors()\r\n {\r\n using (var applicationDbContext = \r\n _dbContextFactory.CreateDbContext())\r\n {\r\n return applicationDbContext.Authors.ToList();\r\n }\r\n }\r\n public Author GetAuthorById(int id)\r\n {\r\n using (var applicationDbContext = \r\n _dbContextFactory.CreateDbContext())\r\n {\r\n return applicationDbContext.Authors.\r\n SingleOrDefault(x => x.Id == id);\r\n }\r\n }\r\n public async Task<Author> CreateAuthor(Author author)\r\n {\r\n using (var applicationDbContext = \r\n _dbContextFactory.CreateDbContext())\r\n {\r\n await applicationDbContext.Authors\r\n .AddAsync(author);\r\n await applicationDbContext.SaveChangesAsync();\r\n return author;\r\n }\r\n }\r\n }\r\n}<\/pre>\nInside the same solution folder, create a file named BlogPostRepository.cs<\/em>. Replace the default generated code using the following code:<\/p>\nBlogPostRepository.cs<\/strong><\/p>\nusing BlogPostsManagementSystem.DataAccess.Models;\r\nusing Microsoft.EntityFrameworkCore;\r\nusing System.Collections.Generic;\r\nusing System.Linq;\r\nnamespace BlogPostsManagementSystem.DataAccess\r\n{\r\n public class BlogPostRepository : IBlogPostRepository\r\n {\r\n private readonly IDbContextFactory\r\n <ApplicationDbContext> _dbContextFactory;\r\n public BlogPostRepository(IDbContextFactory\r\n <ApplicationDbContext> dbContextFactory)\r\n {\r\n _dbContextFactory = dbContextFactory;\r\n using (var applicationDbContext =\r\n _dbContextFactory.CreateDbContext())\r\n {\r\n applicationDbContext.Database\r\n .EnsureCreated();\r\n }\r\n }\r\n public List<BlogPost> GetBlogPosts()\r\n {\r\n using (var applicationDbContext =\r\n _dbContextFactory.CreateDbContext())\r\n {\r\n return applicationDbContext\r\n .BlogPosts.ToList();\r\n }\r\n }\r\n public BlogPost GetBlogPostById(int id)\r\n {\r\n using (var applicationDbContext =\r\n _dbContextFactory.CreateDbContext())\r\n {\r\n return applicationDbContext.BlogPosts\r\n .SingleOrDefault(x => x.Id == id);\r\n }\r\n }\r\n }\r\n}<\/pre>\nAdd Services to the Container<\/h3>\n
You should now add the following services in the ConfigureServices<\/code> method of the Startup<\/code> class so that you can take advantage of dependency injection to access instances of these types.<\/p>\nservices.AddScoped<IAuthorRepository, AuthorRepository>();\r\nservices.AddScoped<IBlogPostRepository, BlogPostRepository>();<\/pre>\nBuild the GraphQL Schema<\/h3>\n
A GraphQL Schema comprises the following:<\/p>\n
\n- Query<\/li>\n
- Mutations<\/li>\n
- Subscriptions<\/li>\n<\/ul>\n
Since GraphQL is not bound to any language or framework, it is not adept at understanding the CLR classes, i.e., C# POCO classes. In GraphQL, types are used to specify the fields of the domain classes you would like to expose. You’ll now create two classes, namely AuthorType<\/code> in a file named AuthorType.cs<\/em> and another class named BlogPostType<\/code> in a file called BlogPostType.cs<\/em>.<\/p>\nTo create a type in GraphQL, you should create a class that extends ObjectGraphType<T><\/code> and pass your entity type as an argument. You should also register the properties of the class as Field<\/em> types so that GraphQL can recognize this type.<\/p>\nCreate your GraphQL<\/em> folder, then create the following two classes in the files AuthorType.cs<\/em> and BlogPostType.cs<\/em> , respectively inside the folder.<\/p>\nAuthorType.cs<\/strong><\/p>\nusing BlogPostsManagementSystem.DataAccess.Models;\r\nusing HotChocolate.Types;\r\nnamespace BlogPostsManagementSystem.GraphQL\r\n{\r\n public class AuthorType : ObjectType<Author>\r\n {\r\n protected override void Configure(IObjectTypeDescriptor<Author> descriptor)\r\n {\r\n descriptor.Field(a => a.Id).Type<IdType>();\r\n descriptor.Field(a => \r\n a.FirstName).Type<StringType>();\r\n descriptor.Field(a => \r\n a.LastName).Type<StringType>();\r\n descriptor.Field<BlogPostResolver>(b => \r\n b.GetBlogPosts(default, default));\r\n }\r\n }\r\n}<\/pre>\nBlogPostType.cs<\/strong><\/p>\nusing BlogPostsManagementSystem.DataAccess.Models;\r\nusing HotChocolate.Types;\r\nnamespace BlogPostsManagementSystem.GraphQL\r\n{\r\n public class BlogPostType : ObjectType<BlogPost>\r\n {\r\n protected override void \r\n Configure(IObjectTypeDescriptor<BlogPost> descriptor)\r\n {\r\n descriptor.Field(b => b.Id).Type<IdType>();\r\n descriptor.Field(b => b.Title).Type<StringType>();\r\n descriptor.Field(b => b.AuthorId).Type<IntType>();\r\n descriptor.Field<AuthorResolver>(t => \r\n t.GetAuthor(default, default));\r\n }\r\n }\r\n}<\/pre>\nQuery<\/h3>\n
You also need a class that would fetch author and blog post-related data. To do this, create a file called AuthorQuery.cs<\/em> with the following content inside.<\/p>\nQuery.cs<\/strong><\/p>\nusing BlogPostsManagementSystem.DataAccess;\r\nusing BlogPostsManagementSystem.DataAccess.Models;\r\nusing HotChocolate;\r\nusing HotChocolate.Subscriptions;\r\nusing System.Collections.Generic;\r\nusing System.Threading.Tasks;\r\nnamespace BlogPostsManagementSystem.GraphQL\r\n{\r\n public class Query\r\n {\r\n public async Task<List<Author>> \r\n GetAllAuthors([Service] \r\n IAuthorRepository authorRepository,\r\n [Service] ITopicEventSender eventSender)\r\n {\r\n List<Author> authors = \r\n authorRepository.GetAuthors();\r\n await eventSender.SendAsync(\"ReturnedAuthors\", \r\n authors);\r\n return authors;\r\n }\r\n public async Task<Author> GetAuthorById([Service]\r\n IAuthorRepository authorRepository,\r\n [Service] ITopicEventSender eventSender, int id)\r\n {\r\n Author author = \r\n authorRepository.GetAuthorById(id);\r\n await eventSender.SendAsync(\"ReturnedAuthor\", \r\n author);\r\n return author;\r\n }\r\n public async Task<List<BlogPost>> \r\n GetAllBlogPosts([Service] IBlogPostRepository \r\n blogPostRepository,\r\n [Service] ITopicEventSender eventSender)\r\n {\r\n List<BlogPost> blogPosts = \r\n blogPostRepository.GetBlogPosts();\r\n await eventSender.SendAsync(\"ReturnedBlogPosts\", \r\n blogPosts);\r\n return blogPosts;\r\n }\r\n public async Task<BlogPost> GetBlogPostById([Service] \r\n IBlogPostRepository blogPostRepository,\r\n [Service] ITopicEventSender eventSender, int id)\r\n {\r\n BlogPost blogPost = \r\n blogPostRepository.GetBlogPostById(id);\r\n await eventSender.SendAsync(\"ReturnedBlogPost\",\r\n blogPost);\r\n return blogPost;\r\n }\r\n }\r\n}<\/pre>\nMutation<\/h3>\n
GraphQL uses mutation to allow the clients or consumers of an API to add, remove or modify data on the servers. You will need a query type to read data – this was discussed earlier.<\/p>\n
Create a class called Mutation<\/code> in a file named Mutation.cs<\/em> inside the GraphQL solution folder and add the following code:<\/p>\nMutation.cs<\/strong><\/p>\nusing BlogPostsManagementSystem.DataAccess;\r\nusing BlogPostsManagementSystem.DataAccess.Models;\r\nusing HotChocolate;\r\nusing HotChocolate.Subscriptions;\r\nusing System.Threading.Tasks;\r\nnamespace BlogPostsManagementSystem.GraphQL\r\n{\r\n public class Mutation\r\n {\r\n public async Task<Author> CreateAuthor([Service] \r\n AuthorRepository authorRepository,\r\n [Service] ITopicEventSender eventSender, int id,\r\n string firstName,string lastName)\r\n {\r\n var data = new Author\r\n {\r\n Id = id,\r\n FirstName = firstName,\r\n LastName = lastName\r\n };\r\n var result = await \r\n authorRepository.CreateAuthor(data);\r\n await eventSender.SendAsync(\"AuthorCreated\", \r\n result);\r\n return result;\r\n }\r\n }\r\n}<\/pre>\nSubscription<\/h3>\n
You can take advantage of subscriptions in GraphQL to integrate real-time functionality in your GraphQL applications. Subscriptions enable servers to send data to subscribed clients to notify them when an event occurs. Subscriptions use WebSockets<\/code> to allow clients to subscribe to notifications emails in real-time. The server executes the query again and then sends the updated results to the subscribed event.<\/p>\nNow, create a class named Subscription<\/code> in a file called Subscription.cs<\/em> and replace the default code with the following:<\/p>\nSubscription.cs<\/strong><\/p>\nusing BlogPostsManagementSystem.DataAccess.Models;\r\nusing HotChocolate;\r\nusing HotChocolate.Execution;\r\nusing HotChocolate.Subscriptions;\r\nusing HotChocolate.Types;\r\nusing System.Collections.Generic;\r\nusing System.Threading;\r\nusing System.Threading.Tasks;\r\nnamespace BlogPostsManagementSystem.GraphQL\r\n{\r\n public class Subscription\r\n {\r\n [SubscribeAndResolve]\r\n public async ValueTask<ISourceStream<Author>> \r\n OnAuthorCreated([Service] \r\n ITopicEventReceiver eventReceiver,\r\n CancellationToken cancellationToken)\r\n {\r\n return await eventReceiver.SubscribeAsync\r\n <string, Author>(\"AuthorCreated\", \r\n cancellationToken);\r\n }\r\n [SubscribeAndResolve]\r\n public async ValueTask<ISourceStream\r\n <List<Author>>> OnAuthorsGet([Service] \r\n ITopicEventReceiver eventReceiver,\r\n CancellationToken cancellationToken)\r\n {\r\n return await eventReceiver.SubscribeAsync<string, \r\n List<Author>>(\"ReturnedAuthors\", \r\n cancellationToken);\r\n }\r\n [SubscribeAndResolve]\r\n public async ValueTask<ISourceStream<Author>> \r\n OnAuthorGet([Service] ITopicEventReceiver \r\n eventReceiver, CancellationToken cancellationToken)\r\n {\r\n return await eventReceiver.SubscribeAsync<string, \r\n Author>(\"ReturnedAuthor\", cancellationToken);\r\n }\r\n [SubscribeAndResolve]\r\n public async ValueTask<ISourceStream<BlogPost>> \r\n OnBlogPostsGet([Service] ITopicEventReceiver \r\n eventReceiver, CancellationToken cancellationToken)\r\n {\r\n return await eventReceiver.SubscribeAsync<string, \r\n BlogPost>(\"ReturnedBlogPosts\", cancellationToken);\r\n }\r\n [SubscribeAndResolve]\r\n public async ValueTask<ISourceStream<BlogPost>> \r\n OnBlogPostGet([Service] ITopicEventReceiver \r\n eventReceiver, CancellationToken cancellationToken)\r\n {\r\n return await eventReceiver.SubscribeAsync<string, \r\n BlogPost>(\"ReturnedBlogPost\", cancellationToken);\r\n }\r\n }\r\n}<\/pre>\nCreate the Resolvers<\/h3>\n
A resolver is a function responsible for populating data for one field of your schema. In other words, it is a function that resolves the value of a type of field within a schema. Resolvers can return objects and scalars such as Strings, Numbers, or Booleans. You can define how it populates the data, including fetching data from a third-party API or back-end database.<\/p>\n
Create a class called AuthorResolver<\/code> in a file named AuthorResolver.cs<\/em> inside the GraphQL<\/em> solution folder with the following code:<\/p>\nAuthorResolver.cs<\/strong><\/p>\nusing BlogPostsManagementSystem.DataAccess;\r\nusing BlogPostsManagementSystem.DataAccess.Models;\r\nusing HotChocolate;\r\nusing HotChocolate.Resolvers;\r\nusing System.Linq;\r\nnamespace BlogPostsManagementSystem.GraphQL\r\n{\r\n public class AuthorResolver\r\n {\r\n private readonly IAuthorRepository _authorRepository;\r\n public AuthorResolver([Service] IAuthorRepository \r\n authorService)\r\n {\r\n _authorRepository = authorService;\r\n }\r\n public Author GetAuthor(BlogPost blog, \r\n IResolverContext ctx)\r\n {\r\n return _authorRepository.GetAuthors().Where\r\n (a => a.Id == blog.AuthorId).FirstOrDefault();\r\n }\r\n }\r\n}<\/pre>\nCreate another class named BlogPostResolver<\/code> in a file called BlogPostResolver.cs<\/em> with the following code:<\/p>\nBlogPostResolver.cs<\/strong><\/p>\nusing BlogPostsManagementSystem.DataAccess;\r\nusing BlogPostsManagementSystem.DataAccess.Models;\r\nusing HotChocolate;\r\nusing HotChocolate.Resolvers;\r\nusing System.Collections.Generic;\r\nusing System.Linq;\r\nnamespace BlogPostsManagementSystem.GraphQL\r\n{\r\n public class BlogPostResolver\r\n {\r\n private readonly IBlogPostRepository \r\n _blogPostRepository;\r\n public BlogPostResolver([Service] \r\n IBlogPostRepository blogPostRepository)\r\n {\r\n _blogPostRepository = blogPostRepository;\r\n }\r\n public IEnumerable<BlogPost> GetBlogPosts(\r\n Author author, IResolverContext ctx)\r\n {\r\n return _blogPostRepository.GetBlogPosts()\r\n .Where(b => b.AuthorId == author.Id);\r\n }\r\n }\r\n}<\/pre>\nConfiguring the GraphQL Middleware<\/h3>\n
Write the following code in the ConfigureServices<\/code> method of the Startup<\/code> class to add GraphQLServer<\/code> to the container:<\/p>\nservices.AddGraphQLServer();<\/pre>\nA GraphQL server can expose data via GraphQL API endpoints so that the same data can be consumed by the clients (mobile clients, web clients, etc.) or the consumers of the API.<\/p>\n
Next, write the following code in the Configure<\/code> method of the Startup<\/code> class to configure the GraphQL<\/code> endpoint:<\/p>\npublic void Configure(IApplicationBuilder app, IWebHostEnvironment env)\r\n {\r\n if (env.IsDevelopment())\r\n {\r\n app.UseDeveloperExceptionPage();\r\n app.UsePlayground(new PlaygroundOptions\r\n {\r\n QueryPath = \"\/graphql\",\r\n Path = \"\/playground\"\r\n });\r\n }\r\n app.UseWebSockets();\r\n app\r\n .UseRouting()\r\n .UseEndpoints(endpoints =>\r\n {\r\n endpoints.MapGraphQL();\r\n });\r\n }\r\n }<\/pre>\nAt this moment, your ConfigureServices<\/code> method should look like this:<\/p>\npublic void ConfigureServices(IServiceCollection services)\r\n {\r\n services.AddDbContextFactory<ApplicationDbContext>(\r\n options => options.UseInMemoryDatabase(\"BlogsManagement\"));\r\n services.AddInMemorySubscriptions();\r\n services.AddScoped<IAuthorRepository, \r\n AuthorRepository>();\r\n services.AddScoped<IBlogPostRepository, \r\n BlogPostRepository>();\r\n services\r\n .AddGraphQLServer()\r\n .AddType<AuthorType>()\r\n .AddType<BlogPostType>()\r\n .AddQueryType<Query>()\r\n .AddMutationType<Mutation>()\r\n .AddSubscriptionType<Subscription>();\r\n }<\/pre>\nYou should include the following namespaces in the Startup.cs<\/em> file:<\/p>\nusing BlogPostsManagementSystem.DataAccess;\r\nusing BlogPostsManagementSystem.GraphQL;\r\nusing HotChocolate.AspNetCore;\r\nusing HotChocolate.AspNetCore.Playground;\r\nusing Microsoft.AspNetCore.Builder;\r\nusing Microsoft.AspNetCore.Hosting;\r\nusing Microsoft.EntityFrameworkCore;\r\nusing Microsoft.Extensions.DependencyInjection;\r\nusing Microsoft.Extensions.Hosting;<\/pre>\nHere\u2019s the complete source code of the Startup<\/code> class for your reference:<\/p>\nStartup.cs<\/strong><\/p>\nusing BlogPostsManagementSystem.DataAccess;\r\nusing BlogPostsManagementSystem.GraphQL;\r\nusing HotChocolate.AspNetCore;\r\nusing HotChocolate.AspNetCore.Playground;\r\nusing Microsoft.AspNetCore.Builder;\r\nusing Microsoft.AspNetCore.Hosting;\r\nusing Microsoft.EntityFrameworkCore;\r\nusing Microsoft.Extensions.DependencyInjection;\r\nusing Microsoft.Extensions.Hosting;\r\nnamespace BlogPostsManagementSystem\r\n{\r\n public class Startup\r\n {\r\n public void ConfigureServices(IServiceCollection services)\r\n {\r\n services.AddDbContextFactory<ApplicationDbContext>(\r\n options => options.UseInMemoryDatabase(\"BlogsManagement\"));\r\n services.AddInMemorySubscriptions();\r\n services.AddScoped<IAuthorRepository, \r\n AuthorRepository>();\r\n services.AddScoped<IBlogPostRepository, \r\n BlogPostRepository>();\r\n services\r\n .AddGraphQLServer()\r\n .AddType<AuthorType>()\r\n .AddType<BlogPostType>()\r\n .AddQueryType<Query>()\r\n .AddMutationType<Mutation>()\r\n .AddSubscriptionType<Subscription>();\r\n }\r\n public void Configure(IApplicationBuilder app, IWebHostEnvironment env)\r\n {\r\n if (env.IsDevelopment())\r\n {\r\n app.UseDeveloperExceptionPage();\r\n app.UsePlayground(new PlaygroundOptions\r\n {\r\n QueryPath = \"\/graphql\",\r\n Path = \"\/playground\"\r\n });\r\n }\r\n app.UseWebSockets();\r\n app\r\n .UseRouting()\r\n .UseEndpoints(endpoints =>\r\n {\r\n endpoints.MapGraphQL();\r\n });\r\n }\r\n }\r\n}<\/pre>\nGraphQL in Action!<\/h2>\n
Now it\u2019s time to execute GraphQL queries using HotChocolate. Run the application, remembering to have \/playground<\/code> in the URL.<\/p>\nQuery<\/h3>\n
Here\u2019s an example of a GraphQL query you can use to get the data about all authors.<\/p>\n
query {\r\n allAuthors{\r\n id\r\n firstName\r\n lastName\r\n }\r\n}<\/pre>\nWhen you execute this query, here\u2019s how the output would look like:<\/p>\n
![\"Image](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/2021\/10\/word-image-7.png\")
<\/p>\n
Figure 5: Query output<\/strong><\/p>\nIf you would like to get the data about a particular author together with the blogs they have written, you can take advantage of the following query instead.<\/p>\n
query {\r\n authorById (id: 1){\r\n id\r\n firstName\r\n lastName\r\n blogPosts\r\n {\r\n id\r\n title\r\n }\r\n }\r\n}<\/pre>\nRun the above query. Figure 6 below shows the output in the Playground tool.<\/p>\n
![\"Image](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/2021\/10\/word-image-8.png\")
<\/p>\n
Figure 6: Output in Playground tool<\/strong><\/p>\nMutation<\/h3>\n
Now write the following query to test mutation:<\/p>\n
mutation{\r\n createAuthor(id: 4, firstName: \"Scott\", lastName: \"Miller\"){\r\n id\r\n firstName\r\n lastName\r\n }\r\n}<\/pre>\nWhen you run it, you\u2019ll observe that the CreateAuthor<\/code> method of your Mutation<\/code> class is called. Note that the breakpoint is hit successfully.<\/p>\n![\"Image](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/2021\/10\/word-image-9.png\")
<\/p>\n
Figure 7: CreateAuthor method<\/strong><\/p>\nSubscription<\/h3>\n
To test Subscription, execute the application, browse to the \/playground endpoint, and write the query shown below:<\/p>\n
subscription{\r\n onAuthorsGet\r\n {\r\n id\r\n firstName\r\n lastName\r\n }\r\n}<\/pre>\nWhen you click the Execute<\/em> button, the application subscribes to the OnAuthorGet<\/code> event.<\/p>\n![\"Image](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/2021\/10\/word-image-10.png\")
<\/p>\n
Figure 8: Click Execute button<\/strong><\/p>\nNext, launch the same URL in another browser window and write and execute the query shown in Figure 9.<\/p>\n
![\"Image](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/2021\/10\/word-image-11.png\")
<\/p>\n
Figure 9: Launch and execute the query<\/strong><\/p>\nThis query will trigger the OnAuthorsGet<\/code> event as shown in Figure 10.<\/p>\n![\"Image](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/2021\/10\/word-image-12.png\")
<\/p>\n
Figure 10<\/strong>: The OnAuthorsGet event<\/strong><\/p>\nSummary<\/h2>\n
GraphQL is an open-source API standard developed by Facebook that provides a powerful, flexible, and versatile alternative to REST. GraphQL supports declarative data fetching, which allows the user to specify precisely the data it needs. HotChocolate, an implementation of GraphQL, can be used to create GraphQL servers in ASP.NET Core.<\/p>\n
If you liked this article, you might also like\u00a0Building and consuming GraphQL API in ASP.NET Core 3.1 – Simple Talk (red-gate.com)<\/a>.<\/em><\/p>\n","protected":false},"excerpt":{"rendered":"GraphQL is a platform-independent, language-neutral query language and may be used to run queries and retrieve data. Joydip Kanjilal explains how to use GaphQI in an ASP.NET Core 5 app.…<\/p>\n","protected":false},"author":221905,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[143538,53],"tags":[5134],"coauthors":[50381],"class_list":["post-92678","post","type-post","status-publish","format-standard","hentry","category-dotnet-development","category-featured","tag-sql-prompt"],"acf":[],"_links":{"self":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/92678","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/users\/221905"}],"replies":[{"embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/comments?post=92678"}],"version-history":[{"count":5,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/92678\/revisions"}],"predecessor-version":[{"id":92691,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/92678\/revisions\/92691"}],"wp:attachment":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/media?parent=92678"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/categories?post=92678"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/tags?post=92678"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/coauthors?post=92678"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
![\"Image](\"https:\/\/www.red-gate.com\/simple-talk\/wp-content\/uploads\/2021\/10\/word-image-4.png\")
<\/p>\n