Implementing GraphQL in .NET Core

In the modern web development landscape, GraphQL has emerged as a powerful alternative to REST for API development. It allows clients to request exactly the data they need, leading to more efficient and flexible APIs. In this article, we will explore how to implement GraphQL in .NET Core, providing a clean, professional, and engaging overview with real-world examples.

What is GraphQL?

GraphQL is a query language for APIs and a runtime for executing those queries by leveraging your existing data. It allows clients to request specific data and aggregate results from multiple sources, providing a more efficient and flexible approach compared to traditional REST APIs.

Setting Up a .NET Core Project

Step 1: Create a New .NET Core Project
First, create a new .NET Core Web API project using the .NET CLI:

dotnet new webapi -n GraphQLDemo
cd GraphQLDemo

Step 2: Add Required NuGet Packages
Add the necessary NuGet packages for GraphQL. We’ll use `HotChocolate`, a popular GraphQL server for .NET:

dotnet add package HotChocolate.AspNetCore
dotnet add package HotChocolate.Data.EntityFramework
dotnet add package Microsoft.EntityFrameworkCore.InMemory

Define Your Data Model

For this example, we’ll create a simple data model for a book store.

Step 3: Create the Book Model

public class Book
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Author { get; set; }
    public decimal Price { get; set; }
}

Step 4: Set Up the DbContext

public class BookContext : DbContext
{
    public DbSet<Book> Books { get; set; }

    public BookContext(DbContextOptions<BookContext> options)
        : base(options)
    {
    }
}

Configure GraphQL in .NET Core

Step 5: Configure Services in Startup
In the `Startup.cs` file, configure the services for Entity Framework and GraphQL:

public void ConfigureServices(IServiceCollection services)
{
    services.AddPooledDbContextFactory<BookContext>(options => options.UseInMemoryDatabase("BookDb"));

    services
        .AddGraphQLServer()
        .AddQueryType<Query>()
        .AddMutationType<Mutation>()
        .AddFiltering()
        .AddSorting();
}

Step 6: Create the GraphQL Schema

Query Type
Define the queries for retrieving data. In `Query.cs`:

public class Query
{
    [UseDbContext(typeof(BookContext))]
    [UseFiltering]
    [UseSorting]
    public IQueryable<Book> GetBooks([ScopedService] BookContext context) =>
        context.Books;
}

Mutation Type
Define the mutations for modifying data. In `Mutation.cs`:

public class Mutation
{
    [UseDbContext(typeof(BookContext))]
    public async Task<Book> AddBookAsync(Book book, [ScopedService] BookContext context)
    {
        context.Books.Add(book);
        await context.SaveChangesAsync();
        return book;
    }
}

Step 7: Configure the Request Pipeline
In the `Configure` method of `Startup.cs`, add GraphQL middleware:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }

    app.UseRouting();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapGraphQL();
    });
}

Testing Your GraphQL API

Step 8: Seed Initial Data
In `Startup.cs`, seed some initial data:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // ... existing code ...

    using (var scope = app.ApplicationServices.CreateScope())
    {
        var context = scope.ServiceProvider.GetRequiredService<BookContext>();
        context.Database.EnsureCreated();
        context.Books.AddRange(
            new Book { Title = "C# in Depth", Author = "Jon Skeet", Price = 45.99M },
            new Book { Title = "Pro ASP.NET Core 3", Author = "Adam Freeman", Price = 50.00M }
        );
        context.SaveChanges();
    }
}

Step 9: Query and Mutation Examples
To test your GraphQL API, you can use tools like GraphiQL or Postman. Here are some example queries and mutations:

Query Example

{
    books {
        id
        title
        author
        price
    }
}

Mutation Example

mutation {
    addBook(book: { title: "GraphQL for .NET Developers", author: "John Doe", price: 29.99 }) {
        id
        title
        author
        price
    }
}

Conclusion

Implementing GraphQL in .NET Core offers a flexible and efficient way to handle API requests. By separating concerns and allowing clients to specify exactly what data they need, you can build more responsive and performant applications. This article provided a step-by-step guide to setting up a GraphQL API using .NET Core and HotChocolate, complete with real-world examples. Dive into GraphQL and enhance your .NET Core applications today!