{"id":1569,"date":"2023-10-07T02:44:11","date_gmt":"2023-10-07T02:44:11","guid":{"rendered":"https:\/\/www.w3computing.com\/articles\/?p=1569"},"modified":"2023-10-07T02:44:13","modified_gmt":"2023-10-07T02:44:13","slug":"building-crud-api-with-csharp-graphql","status":"publish","type":"post","link":"https:\/\/www.w3computing.com\/articles\/building-crud-api-with-csharp-graphql\/","title":{"rendered":"Building a CRUD API with C# and GraphQL"},"content":{"rendered":"\n

Introduction<\/h2>\n\n\n\n

What is GraphQL?<\/h3>\n\n\n\n

GraphQL is a query language for APIs, as well as a runtime for executing those queries using a type system that you define for your data. Unlike other API standards that focus on defining fixed endpoints, GraphQL enables clients to request exactly the data they need, and no more. Developed by Facebook in 2012 and released as an open-source project in 2015, GraphQL provides a more efficient, flexible, and powerful alternative to the traditional REST API.<\/p>\n\n\n\n

At its core, GraphQL allows for declarative data fetching where a client can specify exactly what data it needs. Instead of multiple endpoints that return fixed sets of data, a GraphQL server exposes a single endpoint and responds with precisely the data a client asked for.<\/p>\n\n\n\n

Advantages of GraphQL over REST<\/h3>\n\n\n\n
    \n
  1. Flexibility for Clients<\/strong>: GraphQL empowers clients to shape the responses according to their needs. This means that applications can fetch the exact data they need, without over-fetching or under-fetching of data. This can be especially beneficial for mobile devices or slow network situations where minimizing the amount and size of the data is crucial.<\/li>\n\n\n\n
  2. Single Endpoint<\/strong>: Unlike REST where the design is based around having multiple endpoints for different resources, GraphQL typically exposes a single endpoint. This simplifies the process, reduces the number of requests, and makes versioning more straightforward.<\/li>\n\n\n\n
  3. Strongly Typed Schema<\/strong>: With GraphQL, the schema is strongly typed, meaning every data point has a specific type associated with it. This enables introspection, allowing clients to discover capabilities of the schema via the API itself. It also ensures that the data is consistent and adheres to a predetermined structure.<\/li>\n\n\n\n
  4. Reduction in Overhead<\/strong>: By allowing clients to request only the data they need, there’s a significant reduction in the amount of data transferred over the network, which can improve application performance, especially on slower connections.<\/li>\n\n\n\n
  5. Built-in Documentation<\/strong>: Thanks to its strongly-typed nature and introspection capabilities, GraphQL APIs can be auto-documented. Tools like GraphQL Playground provide interactive documentation for developers, reducing the effort required to keep documentation up-to-date.<\/li>\n\n\n\n
  6. Avoid Over-fetching and Under-fetching<\/strong>: One of the primary challenges with REST is the potential to over-fetch or under-fetch data. With GraphQL, the client specifies the required data, ensuring they get exactly what they need without unnecessary additional information or missing any crucial data points.<\/li>\n\n\n\n
  7. Easier Versioning<\/strong>: In REST, changes often require a new version of the endpoint, leading to versioning challenges. In GraphQL, new fields can be added to the schema without impacting existing queries, making versioning simpler and more intuitive.<\/li>\n\n\n\n
  8. Batching & Caching<\/strong>: Tools like DataLoader can be integrated with GraphQL to batch multiple requests into a single request, and cache requests to optimize performance.<\/li>\n<\/ol>\n\n\n\n

    While REST has its own set of advantages and is still widely used, GraphQL offers a more dynamic and flexible approach to designing and consuming APIs. Its focus on allowing clients to define their data requirements makes it particularly well-suited for today’s varied and rapidly evolving application needs.<\/p>\n\n\n\n

    Understanding the Basics of GraphQL<\/h2>\n\n\n\n

    To fully harness the capabilities of GraphQL when building our API with C#, it’s crucial to grasp some of its foundational concepts. Let’s delve into the basics of GraphQL and understand its main components.<\/p>\n\n\n\n

    GraphQL Schema<\/h3>\n\n\n\n

    At the heart of any GraphQL API is its schema. The schema defines the types of data you can query and the set of possible operations you can perform. It serves as a contract between the client and the server, describing the shape of the response the client can expect.<\/p>\n\n\n\n

    In essence, the schema outlines:<\/p>\n\n\n\n

      \n
    • What<\/strong> can be queried (Queries).<\/li>\n\n\n\n
    • How<\/strong> data can be changed (Mutations).<\/li>\n\n\n\n
    • The shape and structure<\/strong> of the data objects (Types).<\/li>\n<\/ul>\n\n\n\n

      Types<\/h3>\n\n\n\n

      GraphQL is a strongly typed language, and as such, the schema defines specific types that represent the shape of the data you can fetch.<\/p>\n\n\n\n

      Scalar Types<\/strong>: These are the primitives like Int<\/code>, Float<\/code>, String<\/code>, Boolean<\/code>, and ID<\/code>. While these are the default scalar types, you can also define custom scalars for your API if needed.<\/p>\n\n\n\n

      Object Types<\/strong>: These represent the kind of objects you can fetch from your service and the fields they contain. For instance, consider a Book<\/code> type:<\/p>\n\n\n

      type<\/span> Book<\/span> {\n  id<\/span>: ID!\n  title: String!\n  author: String!\n}<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
      The !<\/code> denotes that the field is non-nullable.<\/p>\n\n\n\n
      Enum Types<\/strong>: Enums are a special kind of scalar restricted to a particular set of allowed values. They’re useful when an object can be in one of a small set of possible states.<\/p>\n\n\n\n
      Queries<\/h3>\n\n\n\n
      Queries allow clients to request specific data as per their needs. They represent the “R” in “CRUD” (i.e., read operations). A client specifies what set of data it needs, and the server responds with the matching data.<\/p>\n\n\n\n
      For example, a simple query to fetch a book by its ID might look like:<\/p>\n\n\n
      query {\n  book(id: 1) {\n    title\n    author\n  }\n}<\/code><\/span><\/pre>\n\n\n
      Mutations<\/h3>\n\n\n\n
      While queries are all about fetching data, mutations are about modifying data. They represent the “C”, “U”, and “D” in “CRUD” (i.e., create, update, delete operations).<\/p>\n\n\n\n
      A mutation to add a new book might be structured as:<\/p>\n\n\n
      mutation {\n  addBook(title: \"New Book\"<\/span>, author<\/span>: \"John Doe\"<\/span>) {\n    id\n    title\n  }\n}<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      Resolvers and their role<\/h3>\n\n\n\n
      Resolvers are functions that handle the process of fetching the data for a particular field in your schema. Every field in a GraphQL schema is backed by a resolver. When a client sends a query or mutation to the server, the GraphQL server invokes the resolver for each field in the received request.<\/p>\n\n\n\n
      The role of a resolver is twofold:<\/p>\n\n\n\n
        \n
      1. Data Retrieval<\/strong>: It retrieves the requested data from the source, be it a database, another API, or any other data source.<\/li>\n\n\n\n
      2. Data Transformation<\/strong>: Resolvers can also transform the data before sending it back to the client, ensuring it matches the shape defined in the schema.<\/li>\n<\/ol>\n\n\n\n
        In essence, resolvers are the bridge between a GraphQL query and the actual backend logic that retrieves or modifies the data.<\/p>\n\n\n\n
        Setting Up GraphQL in C#<\/h2>\n\n\n\n
        To integrate GraphQL into our C# project, we need to leverage specific libraries that facilitate this integration. One of the most popular libraries for this purpose in the .NET ecosystem is HotChocolate. Alongside, to manage our database interactions, we’ll use Entity Framework Core. Let’s walk through the steps to set everything up.<\/p>\n\n\n\n
        Installing required NuGet packages<\/h3>\n\n\n\n
        HotChocolate<\/strong><\/p>\n\n\n\n
        HotChocolate is a GraphQL server for .NET. It provides all the essential tooling to set up a GraphQL endpoint with ease.<\/p>\n\n\n\n
        Using .NET CLI:<\/p>\n\n\n
        dotnet add package HotChocolate.AspNetCore\ndotnet add package HotChocolate.AspNetCore.Playground<\/code><\/span>Code language:<\/span> Bash<\/span> (<\/span>bash<\/span>)<\/span><\/small><\/pre>\n\n\n
        Using Visual Studio:<\/p>\n\n\n\n
          \n
        • Open the “NuGet Package Manager” or “Manage NuGet Packages for Solution”.<\/li>\n\n\n\n
        • Search for “HotChocolate.AspNetCore” and install it.<\/li>\n\n\n\n
        • Similarly, search for “HotChocolate.AspNetCore.Playground” and install it.<\/li>\n<\/ul>\n\n\n\n
          Entity Framework Core<\/strong><\/p>\n\n\n\n
          Entity Framework (EF) Core is an ORM (Object-Relational Mapper) that simplifies database operations in .NET applications.<\/p>\n\n\n\n
          Using .NET CLI (assuming SQL Server as the database, adjust accordingly if using another database provider):<\/p>\n\n\n
          dotnet add package Microsoft.EntityFrameworkCore\ndotnet add package Microsoft.EntityFrameworkCore.SqlServer<\/code><\/span>Code language:<\/span> Bash<\/span> (<\/span>bash<\/span>)<\/span><\/small><\/pre>\n\n\n
          Using Visual Studio:<\/p>\n\n\n\n
            \n
          • Open the “NuGet Package Manager”.<\/li>\n\n\n\n
          • Search for “Microsoft.EntityFrameworkCore” and install it.<\/li>\n\n\n\n
          • Similarly, search for “Microsoft.EntityFrameworkCore.SqlServer” and install it.<\/li>\n<\/ul>\n\n\n\n
            Integrating GraphQL middleware with ASP.NET Core<\/h3>\n\n\n\n
            Update Startup.cs<\/strong>:After installing the necessary packages, we need to configure our application to use HotChocolate and set up a GraphQL endpoint.<\/p>\n\n\n\n
            In Startup.cs<\/code>, add the following using directives:<\/p>\n\n\n
            using<\/span> HotChocolate;\nusing<\/span> HotChocolate.AspNetCore;<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
            In the ConfigureServices<\/code> method, register the GraphQL services:<\/p>\n\n\n
            public<\/span> void<\/span> ConfigureServices<\/span>(IServiceCollection services<\/span>)<\/span>\n{\n    services.AddDbContext<YourDbContextClass>(options => \n        options.UseSqlServer(Configuration.GetConnectionString(\"YourConnectionStringName\"<\/span>)));\n\n    services.AddGraphQL(sp => \n        SchemaBuilder.New()\n        .AddQueryType<YourQueryTypeClass>()\n        .AddMutationType<YourMutationTypeClass>()\n        .Create());\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
            In the Configure<\/code> method, integrate the GraphQL middleware and optionally the Playground (a GraphQL IDE) for testing:<\/p>\n\n\n
            public<\/span> void<\/span> Configure<\/span>(IApplicationBuilder app, IWebHostEnvironment env<\/span>)<\/span>\n{\n    \/\/ ... other middleware ...<\/span>\n\n    app.UseRouting();\n\n    app.UseEndpoints(endpoints =>\n    {\n        endpoints.MapGraphQL();\n    });\n\n    \/\/ If you want to use the GraphQL Playground for testing:<\/span>\n    app.UsePlayground();\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
            Define the DbContext and Models<\/strong>:At this point, you’d typically define your Entity Framework DbContext and related models, which would then be used to shape your GraphQL schema. Ensure that your DbContext is properly set up to interact with your database.<\/p>\n\n\n\n
            GraphQL Types, Queries, and Mutations<\/strong>:We briefly touched upon these in the previous section. You’ll now use C# classes to define these structures in conjunction with HotChocolate. For instance, if you have a Book<\/code> model, you might create a BookType<\/code> class to represent it in GraphQL.<\/p>\n\n\n\n
            With these configurations in place, you’re all set to start defining your GraphQL schema, types, and resolvers using C# and HotChocolate. As you proceed, you’ll find that HotChocolate offers a wide range of features, making it an excellent choice for building sophisticated GraphQL APIs in .NET.<\/p>\n\n\n\n
            Designing the Data Model<\/h2>\n\n\n\n
            The backbone of any database-driven application lies in its data model, which represents the structured data, relationships, and rules. When working with GraphQL and Entity Framework, it’s pivotal to have a clear understanding of the entities and their relationships, as this directly impacts the GraphQL schema and the queries\/mutations you will define.<\/p>\n\n\n\n
            Entities and their relationships<\/h3>\n\n\n\n
              \n
            1. Book<\/strong>:Represents a book with basic details.\n
                \n
              • Properties: Id<\/code>, Title<\/code>, ISBN<\/code>, PublicationDate<\/code>, AuthorId<\/code>, PublisherId<\/code><\/li>\n\n\n\n
              • Relationships:\n
                  \n
                • Many-to-One with Author<\/code>: A book has one author, but an author can write many books.<\/li>\n\n\n\n
                • Many-to-One with Publisher<\/code>: A book has one publisher, but a publisher can publish many books.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                • Author<\/strong>:Represents an author who writes books.\n
                    \n
                  • Properties: Id<\/code>, Name<\/code>, DateOfBirth<\/code>, Biography<\/code><\/li>\n\n\n\n
                  • Relationships:\n
                      \n
                    • One-to-Many with Book<\/code>: An author can write many books, but a book is written by one author.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                    • Publisher<\/strong>:Represents a publishing entity.\n
                        \n
                      • Properties: Id<\/code>, Name<\/code>, EstablishedDate<\/code>, Address<\/code><\/li>\n\n\n\n
                      • Relationships:\n
                          \n
                        • One-to-Many with Book<\/code>: A publisher can publish many books, but a book is published by one publisher.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n<\/li>\n<\/ol>\n\n\n\n
                          Setting up the Entity Framework context<\/h3>\n\n\n\n
                          Define the Entity Models<\/strong>:First, create a Models<\/code> folder in your project. Inside, define the entities:<\/p>\n\n\n
                          \/\/ Book.cs<\/span>\npublic<\/span> class<\/span> Book<\/span>\n{\n    public<\/span> int<\/span> Id { get<\/span>; set<\/span>; }\n    public<\/span> string<\/span> Title { get<\/span>; set<\/span>; }\n    public<\/span> string<\/span> ISBN { get<\/span>; set<\/span>; }\n    public<\/span> DateTime PublicationDate { get<\/span>; set<\/span>; }\n    public<\/span> Author Author { get<\/span>; set<\/span>; }\n    public<\/span> int<\/span> AuthorId { get<\/span>; set<\/span>; }\n    public<\/span> Publisher Publisher { get<\/span>; set<\/span>; }\n    public<\/span> int<\/span> PublisherId { get<\/span>; set<\/span>; }\n}\n\n\/\/ Author.cs<\/span>\npublic<\/span> class<\/span> Author<\/span>\n{\n    public<\/span> int<\/span> Id { get<\/span>; set<\/span>; }\n    public<\/span> string<\/span> Name { get<\/span>; set<\/span>; }\n    public<\/span> DateTime DateOfBirth { get<\/span>; set<\/span>; }\n    public<\/span> string<\/span> Biography { get<\/span>; set<\/span>; }\n    public<\/span> ICollection<Book> Books { get<\/span>; set<\/span>; }\n}\n\n\/\/ Publisher.cs<\/span>\npublic<\/span> class<\/span> Publisher<\/span>\n{\n    public<\/span> int<\/span> Id { get<\/span>; set<\/span>; }\n    public<\/span> string<\/span> Name { get<\/span>; set<\/span>; }\n    public<\/span> DateTime EstablishedDate { get<\/span>; set<\/span>; }\n    public<\/span> string<\/span> Address { get<\/span>; set<\/span>; }\n    public<\/span> ICollection<Book> Books { get<\/span>; set<\/span>; }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                          Setup the DbContext<\/strong>:In the root of your project or inside a Data<\/code> folder, create a new class for your DbContext:<\/p>\n\n\n
                          using<\/span> Microsoft.EntityFrameworkCore;\n\npublic<\/span> class<\/span> AppDbContext<\/span> : DbContext<\/span>\n{\n    public<\/span> AppDbContext<\/span>(DbContextOptions<AppDbContext> options<\/span>) : base<\/span>(options<\/span>)<\/span> { }\n\n    public<\/span> DbSet<Book> Books { get<\/span>; set<\/span>; }\n    public<\/span> DbSet<Author> Authors { get<\/span>; set<\/span>; }\n    public<\/span> DbSet<Publisher> Publishers { get<\/span>; set<\/span>; }\n\n    protected<\/span> override<\/span> void<\/span> OnModelCreating<\/span>(ModelBuilder modelBuilder<\/span>)<\/span>\n    {\n        \/\/ Define relationships and any other model configurations here<\/span>\n        modelBuilder.Entity<Book>()\n            .HasOne(b => b.Author)\n            .WithMany(a => a.Books)\n            .HasForeignKey(b => b.AuthorId);\n\n        modelBuilder.Entity<Book>()\n            .HasOne(b => b.Publisher)\n            .WithMany(p => p.Books)\n            .HasForeignKey(b => b.PublisherId);\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                          Configure DbContext in Startup.cs<\/strong>:Remember to register the AppDbContext<\/code> in the ConfigureServices<\/code> method:<\/p>\n\n\n
                          services.AddDbContext<AppDbContext>(options => \n    options.UseSqlServer(Configuration.GetConnectionString(\"YourConnectionStringName\"<\/span>)));<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                          With the data model designed and the Entity Framework context set up, we’re now prepared to dive into GraphQL specifics, linking our data model to GraphQL types, queries, and mutations.<\/p>\n\n\n\n
                          Creating the GraphQL Schema<\/h3>\n\n\n\n
                          With our data model ready, the next step is to represent these entities in our GraphQL schema. In HotChocolate, we create classes that represent GraphQL object types for each of our data entities.<\/p>\n\n\n\n
                          Defining Types<\/h3>\n\n\n\n
                          BookType<\/strong>:This will represent our Book<\/code> entity in the GraphQL schema.<\/p>\n\n\n
                          using<\/span> HotChocolate.Types;\nusing<\/span> YourNamespace.Models;\n\npublic<\/span> class<\/span> BookType<\/span> : ObjectType<\/span><Book<\/span>>\n{\n    protected<\/span> override<\/span> void<\/span> Configure<\/span>(IObjectTypeDescriptor<Book> descriptor<\/span>)<\/span>\n    {\n        descriptor.Description(\"Represents any book available in the store.\"<\/span>);\n\n        descriptor\n            .Field(b => b.Id)\n            .Description(\"Represents the unique ID for the book.\"<\/span>);\n\n        descriptor\n            .Field(b => b.ISBN)\n            .Description(\"Represents the unique ISBN number of the book.\"<\/span>);\n\n        descriptor\n            .Field(b => b.Author)\n            .ResolveWith<Resolvers>(b => b.GetAuthor(default<\/span>!, default<\/span>!))\n            .UseDbContext<AppDbContext>()\n            .Description(\"This is the author associated with the given book.\"<\/span>);\n\n        descriptor\n            .Field(b => b.Publisher)\n            .ResolveWith<Resolvers>(b => b.GetPublisher(default<\/span>!, default<\/span>!))\n            .UseDbContext<AppDbContext>()\n            .Description(\"This is the publisher that published the given book.\"<\/span>);\n    }\n\n    private<\/span> class<\/span> Resolvers<\/span>\n    {\n        public<\/span> Author GetAuthor<\/span>(Book book, [ScopedService] AppDbContext context<\/span>)<\/span>\n        {\n            return<\/span> context.Authors.FirstOrDefault(a => a.Id == book.AuthorId);\n        }\n\n        public<\/span> Publisher GetPublisher<\/span>(Book book, [ScopedService] AppDbContext context<\/span>)<\/span>\n        {\n            return<\/span> context.Publishers.FirstOrDefault(p => p.Id == book.PublisherId);\n        }\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                          AuthorType<\/strong>:This will represent our Author<\/code> entity in the GraphQL schema.<\/p>\n\n\n
                          using<\/span> HotChocolate.Types;\n\npublic<\/span> class<\/span> AuthorType<\/span> : ObjectType<\/span><Author<\/span>>\n{\n    protected<\/span> override<\/span> void<\/span> Configure<\/span>(IObjectTypeDescriptor<Author> descriptor<\/span>)<\/span>\n    {\n        descriptor.Description(\"Represents the author of the book.\"<\/span>);\n\n        descriptor\n            .Field(a => a.Id)\n            .Description(\"Represents the unique ID for the author.\"<\/span>);\n\n        descriptor\n            .Field(a => a.Books)\n            .ResolveWith<Resolvers>(a => a.GetBooks(default<\/span>!, default<\/span>!))\n            .UseDbContext<AppDbContext>()\n            .Description(\"This is the list of books authored by the given author.\"<\/span>);\n    }\n\n    private<\/span> class<\/span> Resolvers<\/span>\n    {\n        public<\/span> IEnumerable<Book> GetBooks<\/span>(Author author, [ScopedService] AppDbContext context<\/span>)<\/span>\n        {\n            return<\/span> context.Books.Where(b => b.AuthorId == author.Id);\n        }\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                          PublisherType<\/strong>:Representing our Publisher<\/code> entity in the GraphQL schema.<\/p>\n\n\n
                          using<\/span> HotChocolate.Types;\n\npublic<\/span> class<\/span> PublisherType<\/span> : ObjectType<\/span><Publisher<\/span>>\n{\n    protected<\/span> override<\/span> void<\/span> Configure<\/span>(IObjectTypeDescriptor<Publisher> descriptor<\/span>)<\/span>\n    {\n        descriptor.Description(\"Represents the publisher of the book.\"<\/span>);\n\n        descriptor\n            .Field(p => p.Id)\n            .Description(\"Represents the unique ID for the publisher.\"<\/span>);\n\n        descriptor\n            .Field(p => p.Books)\n            .ResolveWith<Resolvers>(p => p.GetBooks(default<\/span>!, default<\/span>!))\n            .UseDbContext<AppDbContext>()\n            .Description(\"This is the list of books published by the given publisher.\"<\/span>);\n    }\n\n    private<\/span> class<\/span> Resolvers<\/span>\n    {\n        public<\/span> IEnumerable<Book> GetBooks<\/span>(Publisher publisher, [ScopedService] AppDbContext context<\/span>)<\/span>\n        {\n            return<\/span> context.Books.Where(b => b.PublisherId == publisher.Id);\n        }\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                          The above types demonstrate how we can define GraphQL object types in HotChocolate and link them to our data model. The resolvers handle the logic of fetching related entities. The UseDbContext<AppDbContext>()<\/code> method ensures that we have a scoped database context available for each resolver.<\/p>\n\n\n\n
                          These GraphQL types will play a central role when we define our queries and mutations, shaping the data we can fetch or modify via our GraphQL API.<\/p>\n\n\n\n
                          Defining Queries and Mutations<\/h3>\n\n\n\n
                          Once our GraphQL types are set up, the next step is to define how we can interact with the data \u2014 both in terms of fetching (queries) and modifying (mutations). Let’s dive into creating these operations for our Book<\/code>, Author<\/code>, and Publisher<\/code> entities.<\/p>\n\n\n\n
                          Fetching data (Queries)<\/h4>\n\n\n\n
                          BookQueries<\/strong>:Queries related to fetching book data.<\/p>\n\n\n
                          using<\/span> HotChocolate;\nusing<\/span> HotChocolate.Data;\nusing<\/span> YourNamespace.Models;\nusing<\/span> YourNamespace.Data;\n\n[ExtendObjectType(name: \"Query\"<\/span>)<\/span>]\npublic<\/span> class<\/span> BookQueries<\/span>\n{\n    [UseDbContext(typeof(AppDbContext))<\/span>]\n    [UseFiltering<\/span>]\n    [UseSorting<\/span>]\n    public<\/span> IQueryable<Book> GetBooks<\/span>([ScopedService] AppDbContext context<\/span>)<\/span>\n    {\n        return<\/span> context.Books;\n    }\n\n    public<\/span> Book GetBook<\/span>(int<\/span> id, [ScopedService] AppDbContext context<\/span>)<\/span>\n    {\n        return<\/span> context.Books.FirstOrDefault(b => b.Id == id);\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                          AuthorQueries<\/strong>:Queries related to fetching author data.<\/p>\n\n\n
                          [ExtendObjectType(name: \"Query\"<\/span>)<\/span>]\npublic<\/span> class<\/span> AuthorQueries<\/span>\n{\n    public<\/span> Author GetAuthor<\/span>(int<\/span> id, [ScopedService] AppDbContext context<\/span>)<\/span>\n    {\n        return<\/span> context.Authors.FirstOrDefault(a => a.Id == id);\n    }\n\n    [UseDbContext(typeof(AppDbContext))<\/span>]\n    [UseFiltering<\/span>]\n    [UseSorting<\/span>]\n    public<\/span> IQueryable<Author> GetAuthors<\/span>([ScopedService] AppDbContext context<\/span>)<\/span>\n    {\n        return<\/span> context.Authors;\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                          PublisherQueries<\/strong>:Queries related to fetching publisher data.<\/p>\n\n\n
                          [ExtendObjectType(name: \"Query\"<\/span>)<\/span>]\npublic<\/span> class<\/span> PublisherQueries<\/span>\n{\n    public<\/span> Publisher GetPublisher<\/span>(int<\/span> id, [ScopedService] AppDbContext context<\/span>)<\/span>\n    {\n        return<\/span> context.Publishers.FirstOrDefault(p => p.Id == id);\n    }\n\n    [UseDbContext(typeof(AppDbContext))<\/span>]\n    [UseFiltering<\/span>]\n    [UseSorting<\/span>]\n    public<\/span> IQueryable<Publisher> GetPublishers<\/span>([ScopedService] AppDbContext context<\/span>)<\/span>\n    {\n        return<\/span> context.Publishers;\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                          Modifying data (Mutations)<\/h4>\n\n\n\n
                          BookMutations<\/strong>:Mutations related to modifying book data.<\/p>\n\n\n
                          using<\/span> HotChocolate;\nusing<\/span> YourNamespace.Models;\nusing<\/span> YourNamespace.Data;\n\n[ExtendObjectType(name: \"Mutation\"<\/span>)<\/span>]\npublic<\/span> class<\/span> BookMutations<\/span>\n{\n    public<\/span> Book AddBook<\/span>(Book book, [ScopedService] AppDbContext context<\/span>)<\/span>\n    {\n        context.Books.Add(book);\n        context.SaveChanges();\n        return<\/span> book;\n    }\n\n    public<\/span> Book UpdateBook<\/span>(int<\/span> id, Book book, [ScopedService] AppDbContext context<\/span>)<\/span>\n    {\n        var<\/span> existingBook = context.Books.Find(id);\n        if<\/span> (existingBook == null<\/span>)\n            throw<\/span> new<\/span> Exception($\"Book with ID {id}<\/span> not found.\"<\/span>);\n\n        existingBook.Title = book.Title;\n        \/\/ ... other updates ...<\/span>\n\n        context.SaveChanges();\n        return<\/span> existingBook;\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                          AuthorMutations<\/strong>:Mutations related to modifying author data.<\/p>\n\n\n
                          [ExtendObjectType(name: \"Mutation\"<\/span>)<\/span>]\npublic<\/span> class<\/span> AuthorMutations<\/span>\n{\n    public<\/span> Author AddAuthor<\/span>(Author author, [ScopedService] AppDbContext context<\/span>)<\/span>\n    {\n        context.Authors.Add(author);\n        context.SaveChanges();\n        return<\/span> author;\n    }\n\n    public<\/span> Author UpdateAuthor<\/span>(int<\/span> id, Author author, [ScopedService] AppDbContext context<\/span>)<\/span>\n    {\n        var<\/span> existingAuthor = context.Authors.Find(id);\n        if<\/span> (existingAuthor == null<\/span>)\n            throw<\/span> new<\/span> Exception($\"Author with ID {id}<\/span> not found.\"<\/span>);\n\n        existingAuthor.Name = author.Name;\n        \/\/ ... other updates ...<\/span>\n\n        context.SaveChanges();\n        return<\/span> existingAuthor;\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                          PublisherMutations<\/strong>:Mutations related to modifying publisher data.<\/p>\n\n\n
                          [ExtendObjectType(name: \"Mutation\"<\/span>)<\/span>]\npublic<\/span> class<\/span> PublisherMutations<\/span>\n{\n    public<\/span> Publisher AddPublisher<\/span>(Publisher publisher, [ScopedService] AppDbContext context<\/span>)<\/span>\n    {\n        context.Publishers.Add(publisher);\n        context.SaveChanges();\n        return<\/span> publisher;\n    }\n\n    public<\/span> Publisher UpdatePublisher<\/span>(int<\/span> id, Publisher publisher, [ScopedService] AppDbContext context<\/span>)<\/span>\n    {\n        var<\/span> existingPublisher = context.Publishers.Find(id);\n        if<\/span> (existingPublisher == null<\/span>)\n            throw<\/span> new<\/span> Exception($\"Publisher with ID {id}<\/span> not found.\"<\/span>);\n\n        existingPublisher.Name = publisher.Name;\n        \/\/ ... other updates ...<\/span>\n\n        context.SaveChanges();\n        return<\/span> existingPublisher;\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                          Implementing Resolvers<\/h2>\n\n\n\n
                          In GraphQL, resolvers are functions that determine how data for a particular field is fetched. They are central to GraphQL’s flexibility, allowing you to specify complex operations per field if needed. While in many cases, the default resolver (fetching a property directly from the parent object) is enough, sometimes we need to customize how a field is resolved, especially when dealing with relationships or aggregated data.<\/p>\n\n\n\n
                          Fetching Data<\/h3>\n\n\n\n
                          For our tutorial, let’s delve deeper into the process of fetching data by focusing on retrieving a list of books.<\/p>\n\n\n\n
                          Resolver for getting a list of books:<\/h4>\n\n\n\n
                          Resolvers in HotChocolate are typically methods inside our type classes. However, if we need to fetch related data or perform some operations, we can define a custom resolver.<\/p>\n\n\n\n
                          Let’s enhance our BookType<\/code> from earlier by adding a resolver that fetches the list of books:<\/p>\n\n\n
                          using<\/span> HotChocolate;\nusing<\/span> HotChocolate.Types;\nusing<\/span> YourNamespace.Data;\nusing<\/span> YourNamespace.Models;\nusing<\/span> System.Linq;\n\npublic<\/span> class<\/span> BookType<\/span> : ObjectType<\/span><Book<\/span>>\n{\n    protected<\/span> override<\/span> void<\/span> Configure<\/span>(IObjectTypeDescriptor<Book> descriptor<\/span>)<\/span>\n    {\n        descriptor.Description(\"Represents any book available in the store.\"<\/span>);\n\n        \/\/ ... other field definitions ...<\/span>\n\n        descriptor\n            .Field(b => b.Author)\n            .ResolveWith<Resolvers>(r => r.GetAuthor(default<\/span>!, default<\/span>!))\n            .UseDbContext<AppDbContext>()\n            .Description(\"This is the author associated with the given book.\"<\/span>);\n    }\n\n    private<\/span> class<\/span> Resolvers<\/span>\n    {\n        \/\/ This method is a resolver for the 'Author' field in the BookType.<\/span>\n        public<\/span> Author GetAuthor<\/span>(Book book, [ScopedService] AppDbContext context<\/span>)<\/span>\n        {\n            return<\/span> context.Authors.FirstOrDefault(a => a.Id == book.AuthorId);\n        }\n\n        \/\/ Custom resolver for fetching a list of books.<\/span>\n        public<\/span> IQueryable<Book> GetBooks<\/span>([ScopedService] AppDbContext context<\/span>)<\/span>\n        {\n            return<\/span> context.Books;\n        }\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                          Note the use of [ScopedService]<\/code> attribute on the context<\/code> parameter. This ensures that we have a scoped database context available in our resolver, which is essential for database operations. The UseDbContext<AppDbContext>()<\/code> directive is also important as it provides the scoped database context to our resolver.<\/p>\n\n\n\n
                          In this example:<\/p>\n\n\n\n
                            \n
                          • We’ve added the GetBooks<\/code> resolver that fetches all the books from the database.<\/li>\n\n\n\n
                          • The GetAuthor<\/code> resolver fetches the author for a particular book, demonstrating how we can fetch related data.<\/li>\n<\/ul>\n\n\n\n
                            When a client queries for a list of books, HotChocolate will automatically use the GetBooks<\/code> resolver to fetch the required data.<\/p>\n\n\n\n
                            Creating Data<\/h3>\n\n\n\n
                            Resolvers also play a crucial role when it comes to mutations, i.e., changing the data. When a client sends a mutation request, it’s the resolver that handles the operation and determines the data that’s returned.<\/p>\n\n\n\n
                            Resolver for adding a new book:<\/h4>\n\n\n\n
                            To allow clients to add a new book, we’ll define a mutation resolver. Mutations are typically separate from our type classes, and we’ll group them based on the operation’s entity.<\/p>\n\n\n\n
                            Let’s see how to create a resolver for adding a new book:<\/p>\n\n\n
                            using<\/span> HotChocolate;\nusing<\/span> HotChocolate.Types;\nusing<\/span> YourNamespace.Data;\nusing<\/span> YourNamespace.Models;\nusing<\/span> System.Linq;\n\npublic<\/span> class<\/span> BookMutations<\/span>\n{\n    [ExtendObjectType(name: \"Mutation\"<\/span>)<\/span>]\n    public<\/span> class<\/span> BookMutationType<\/span>\n    {\n        \/\/ Resolver for adding a new book<\/span>\n        public<\/span> Book AddBook<\/span>(\n            BookInput input, \/\/ Define an input type for<\/span> our mutation\n            [ScopedService] AppDbContext context<\/span>) \/\/ Scoped EF Core DbContext<\/span><\/span>\n        {\n            var<\/span> book = new<\/span> Book\n            {\n                Title = input.Title,\n                ISBN = input.ISBN,\n                PublicationDate = input.PublicationDate,\n                AuthorId = input.AuthorId,\n                PublisherId = input.PublisherId\n            };\n\n            context.Books.Add(book);\n            context.SaveChanges();\n\n            return<\/span> book;\n        }\n    }\n\n    \/\/ Define the input type for the 'AddBook' mutation<\/span>\n    public<\/span> class<\/span> BookInput<\/span>\n    {\n        public<\/span> string<\/span> Title { get<\/span>; set<\/span>; }\n        public<\/span> string<\/span> ISBN { get<\/span>; set<\/span>; }\n        public<\/span> DateTime PublicationDate { get<\/span>; set<\/span>; }\n        public<\/span> int<\/span> AuthorId { get<\/span>; set<\/span>; }\n        public<\/span> int<\/span> PublisherId { get<\/span>; set<\/span>; }\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                            Here’s the breakdown of the code:<\/p>\n\n\n\n
                              \n
                            • We have a BookMutationType<\/code> class that contains our mutation resolvers related to books.<\/li>\n\n\n\n
                            • The AddBook<\/code> method is our resolver for adding a new book. This method:\n
                                \n
                              • Takes in a BookInput<\/code> object which is a representation of our input data for the mutation.<\/li>\n\n\n\n
                              • Uses the provided AppDbContext<\/code> to add the new book to the database and save the changes.<\/li>\n\n\n\n
                              • Returns the newly added book.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                              • The BookInput<\/code> class is an input type that represents the shape of the data we expect from clients when they want to add a new book.<\/li>\n<\/ul>\n\n\n\n
                                With this setup, a client can now send a mutation request to add a new book. For instance, the client-side GraphQL mutation might look like:<\/p>\n\n\n
                                mutation {\n  addBook(input: {\n    title: \"New GraphQL Book\",\n    ISBN: \"123456789\",\n    publicationDate: \"2023-10-05\",\n    authorId: 1,\n    publisherId: 1\n  }) {\n    id\n    title\n  }\n}<\/code><\/span>Code language:<\/span> SQL (Structured Query Language)<\/span> (<\/span>sql<\/span>)<\/span><\/small><\/pre>\n\n\n
                                This mutation will use the AddBook<\/code> resolver to add a new book to the database and return the id<\/code> and title<\/code> of the newly added book.<\/p>\n\n\n\n
                                Updating Data<\/h3>\n\n\n\n
                                When it comes to updating data in our system through GraphQL, we’ll use mutation resolvers similar to creating data. The difference typically lies in how the resolver handles the provided input\u2014finding the existing data and updating its attributes.<\/p>\n\n\n\n
                                Resolver for updating an existing book’s details:<\/h4>\n\n\n\n
                                Let’s see how to create a resolver to update an existing book:<\/p>\n\n\n
                                using<\/span> HotChocolate;\r\nusing<\/span> HotChocolate.Types;\r\nusing<\/span> YourNamespace.Data;\r\nusing<\/span> YourNamespace.Models;\r\nusing<\/span> System.Linq;\r\n\r\n[ExtendObjectType(name: \"Mutation\"<\/span>)<\/span>]\r\npublic<\/span> class<\/span> BookUpdateMutations<\/span>\r\n{\r\n    \/\/ Resolver for updating a book's details<\/span>\r\n    public<\/span> Book UpdateBook<\/span>(\r\n        UpdateBookInput input, \/\/ Define an input type for<\/span> our mutation\r\n        [ScopedService] AppDbContext context<\/span>) \/\/ Scoped EF Core DbContext<\/span><\/span>\r\n    {\r\n        var<\/span> existingBook = context.Books.Find(input.Id);\r\n        \r\n        if<\/span> (existingBook == null<\/span>)\r\n            throw<\/span> new<\/span> GraphQLException($\"Book with ID {input.Id}<\/span> not found.\"<\/span>);\r\n\r\n        if<\/span> (!string<\/span>.IsNullOrEmpty(input.Title))\r\n            existingBook.Title = input.Title;\r\n\r\n        if<\/span> (!string<\/span>.IsNullOrEmpty(input.ISBN))\r\n            existingBook.ISBN = input.ISBN;\r\n\r\n        if<\/span> (input.PublicationDate.HasValue)\r\n            existingBook.PublicationDate = input.PublicationDate.Value;\r\n\r\n        if<\/span> (input.AuthorId.HasValue)\r\n            existingBook.AuthorId = input.AuthorId.Value;\r\n\r\n        if<\/span> (input.PublisherId.HasValue)\r\n            existingBook.PublisherId = input.PublisherId.Value;\r\n\r\n        context.SaveChanges();\r\n\r\n        return<\/span> existingBook;\r\n    }\r\n\r\n    \/\/ Define the input type for the 'UpdateBook' mutation<\/span>\r\n    public<\/span> class<\/span> UpdateBookInput<\/span>\r\n    {\r\n        public<\/span> int<\/span> Id { get<\/span>; set<\/span>; }\r\n        public<\/span> string<\/span>? Title { get<\/span>; set<\/span>; }\r\n        public<\/span> string<\/span>? ISBN { get<\/span>; set<\/span>; }\r\n        public<\/span> DateTime? PublicationDate { get<\/span>; set<\/span>; }\r\n        public<\/span> int<\/span>? AuthorId { get<\/span>; set<\/span>; }\r\n        public<\/span> int<\/span>? PublisherId { get<\/span>; set<\/span>; }\r\n    }\r\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                                Here’s what’s happening in the code:<\/p>\n\n\n\n
                                  \n
                                • The UpdateBook<\/code> method is our resolver for updating an existing book’s details. This method:\n
                                    \n
                                  • Fetches the existing book from the database using the provided Id<\/code> from the input.<\/li>\n\n\n\n
                                  • Checks if the book exists; if not, it throws an exception.<\/li>\n\n\n\n
                                  • Updates the book’s attributes based on the provided input.<\/li>\n\n\n\n
                                  • Saves the changes to the database.<\/li>\n\n\n\n
                                  • Returns the updated book.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                  • The UpdateBookInput<\/code> class represents the shape of the data we expect from clients when they want to update a book. The use of nullable fields allows clients to provide only the fields they wish to update.<\/li>\n<\/ul>\n\n\n\n
                                    A client-side GraphQL mutation for updating a book might look like:<\/p>\n\n\n
                                    mutation {\r\n  updateBook(input: {\r\n    id<\/span>: 1<\/span>,\r\n    title<\/span>: \"Updated GraphQL Book\"<\/span>,\r\n    ISBN<\/span>: \"987654321\"<\/span>\r\n  }) {\r\n    id\r\n    title\r\n    ISBN\r\n  }\r\n}<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                                    This mutation will use the UpdateBook<\/code> resolver to update the title and ISBN of the book with ID 1<\/code> and return the updated id<\/code>, title<\/code>, and ISBN<\/code>.<\/p>\n\n\n\n
                                    Deleting Data<\/h3>\n\n\n\n
                                    Deleting data through a GraphQL API involves creating a mutation resolver that interacts with the database to remove the specified entity based on the provided criteria.<\/p>\n\n\n\n
                                    Resolver for deleting a book:<\/h4>\n\n\n\n
                                    Let’s create a resolver to delete a book based on its ID:<\/p>\n\n\n
                                    using<\/span> HotChocolate;\r\nusing<\/span> HotChocolate.Types;\r\nusing<\/span> YourNamespace.Data;\r\nusing<\/span> YourNamespace.Models;\r\nusing<\/span> System.Linq;\r\n\r\n[ExtendObjectType(name: \"Mutation\"<\/span>)<\/span>]\r\npublic<\/span> class<\/span> BookDeleteMutations<\/span>\r\n{\r\n    \/\/ Resolver for deleting a book<\/span>\r\n    public<\/span> bool<\/span> DeleteBook<\/span>(\r\n        int<\/span> id, \/\/ We need only the ID to delete the book\r\n        [ScopedService] AppDbContext context<\/span>) \/\/ Scoped EF Core DbContext<\/span><\/span>\r\n    {\r\n        var<\/span> existingBook = context.Books.Find(id);\r\n        \r\n        if<\/span> (existingBook == null<\/span>)\r\n            throw<\/span> new<\/span> GraphQLException($\"Book with ID {id}<\/span> not found.\"<\/span>);\r\n\r\n        context.Books.Remove(existingBook);\r\n        context.SaveChanges();\r\n\r\n        return<\/span> true<\/span>; \/\/ Return true to indicate the operation was successful<\/span>\r\n    }\r\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                                    Here’s the breakdown:<\/p>\n\n\n\n
                                      \n
                                    • The DeleteBook<\/code> method is our resolver for deleting a book. This method:\n
                                        \n
                                      • Fetches the book to be deleted from the database using the provided id<\/code>.<\/li>\n\n\n\n
                                      • Checks if the book exists; if not, it throws an exception.<\/li>\n\n\n\n
                                      • Removes the book from the database.<\/li>\n\n\n\n
                                      • Saves the changes to the database.<\/li>\n\n\n\n
                                      • Returns true<\/code> to indicate the operation was successful.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\n\n\n
                                        For the client side, a GraphQL mutation to delete a book might look something like:<\/p>\n\n\n
                                        mutation {\r\n  deleteBook(id: 1)\r\n}<\/code><\/span><\/pre>\n\n\n
                                        This mutation will use the DeleteBook<\/code> resolver to delete the book with ID 1<\/code> and return true<\/code> if the operation was successful.<\/p>\n\n\n\n
                                        Deletion is a sensitive operation and should be approached with caution. Always ensure:<\/p>\n\n\n\n
                                          \n
                                        • Proper error handling.<\/li>\n\n\n\n
                                        • Adequate permissions and validations (you don’t want just anyone to delete data).<\/li>\n\n\n\n
                                        • Consider using soft deletes (marking data as deleted without actually removing it) if data retention is important for your use case.<\/li>\n<\/ul>\n\n\n\n
                                          Error Handling in GraphQL<\/h2>\n\n\n\n
                                          Effective error handling is essential in any API, and GraphQL is no exception. GraphQL APIs can emit a variety of errors, ranging from validation to server issues. These errors are conveyed to the client in the errors<\/code> field of the response.<\/p>\n\n\n\n
                                          Common GraphQL errors and their solutions:<\/h3>\n\n\n\n
                                            \n
                                          1. Field Validation Errors<\/strong>:\n
                                              \n
                                            • Cause<\/strong>: A request asks for a field that doesn’t exist.<\/li>\n\n\n\n
                                            • Solution<\/strong>: Check for typos or out-of-date schema on the client side.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                            • Argument Validation Errors<\/strong>:\n
                                                \n
                                              • Cause<\/strong>: The client might provide an argument that isn’t expected.<\/li>\n\n\n\n
                                              • Solution<\/strong>: Verify the arguments in the request and ensure they align with the schema.<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                              • Authentication and Authorization Errors<\/strong>:\n
                                                  \n
                                                • Cause<\/strong>: A client might try to access data they aren’t authorized to see, or they might not be authenticated.<\/li>\n\n\n\n
                                                • Solution<\/strong>: Ensure proper authentication and authorization mechanisms. Provide clear error messages so clients can act accordingly (e.g., re-authenticate or request access).<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                                • Query Depth Exceeding Limit<\/strong>:\n
                                                    \n
                                                  • Cause<\/strong>: To prevent overly complex queries that could lead to performance issues, GraphQL servers might limit query depth.<\/li>\n\n\n\n
                                                  • Solution<\/strong>: Restructure the query to reduce its depth or increase the server’s depth limit (with caution).<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                                  • Database Errors<\/strong>:\n
                                                      \n
                                                    • Cause<\/strong>: Issues related to fetching or writing data to the database.<\/li>\n\n\n\n
                                                    • Solution<\/strong>: These errors are usually handled server-side. Ensure the database connection is stable and that queries are structured correctly.<\/li>\n<\/ul>\n<\/li>\n<\/ol>\n\n\n\n
                                                      Implementing custom error handling:<\/h3>\n\n\n\n
                                                      With HotChocolate, you can add custom error handling to provide more context or to log errors for debugging.<\/p>\n\n\n\n
                                                      Custom Error Filter<\/strong>:Create a class that implements IErrorFilter<\/code> to customize error handling:<\/p>\n\n\n
                                                      using<\/span> HotChocolate;\r\n\r\npublic<\/span> class<\/span> CustomErrorFilter<\/span> : IErrorFilter<\/span>\r\n{\r\n    public<\/span> IError OnError<\/span>(IError error<\/span>)<\/span>\r\n    {\r\n        \/\/ You can inspect the error and decide what to do:<\/span>\r\n        \/\/ Log the error, modify the error message, etc.<\/span>\r\n        return<\/span> error.WithMessage($\"Custom Error: {error.Message}<\/span>\"<\/span>);\r\n    }\r\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                      Register the Error Filter<\/strong>:In Startup.cs<\/code>, register the custom error filter:<\/p>\n\n\n
                                                      services.AddGraphQL(...)\r\n        .AddErrorFilter<CustomErrorFilter>();<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                      Handle Errors in Resolvers<\/strong>:If you encounter an error in your resolver, you can throw a specific exception. This exception can then be handled by your error filter:<\/p>\n\n\n
                                                      [UseExceptionHandler<\/span>]\r\npublic<\/span> Book AddBook<\/span>(BookInput input, [ScopedService] AppDbContext context<\/span>)<\/span>\r\n{\r\n    \/\/ ... Logic ...<\/span>\r\n\r\n    if<\/span> (someErrorCondition)\r\n    {\r\n        throw<\/span> new<\/span> GraphQLException(\"A custom error occurred while adding the book.\"<\/span>);\r\n    }\r\n\r\n    \/\/ ... More Logic ...<\/span>\r\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                      In the example above, if someErrorCondition<\/code> is true, a custom error is thrown. This error will be captured by our CustomErrorFilter<\/code>, and the message will be modified before being sent to the client.<\/p>\n\n\n\n
                                                      Implementing Authorization and Authentication<\/h2>\n\n\n\n
                                                      Implementing authentication and authorization is essential to secure your GraphQL API. Authentication verifies the identity of a user, while authorization determines what an authenticated user can access.<\/p>\n\n\n\n
                                                      Integrating JWT with GraphQL:<\/h3>\n\n\n\n
                                                      Setting up JWT Middleware<\/strong>:First, ensure your application is set up to issue and validate JWT tokens, often done with ASP.NET Core’s built-in JWT bearer authentication middleware.<\/p>\n\n\n
                                                      \/\/ In Startup.cs - ConfigureServices method<\/span>\r\n\r\nservices.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)\r\n        .AddJwtBearer(options =>\r\n        {\r\n            options.TokenValidationParameters = new<\/span> TokenValidationParameters\r\n            {\r\n                ValidateIssuer = true<\/span>,\r\n                ValidateAudience = true<\/span>,\r\n                ValidateLifetime = true<\/span>,\r\n                ValidateIssuerSigningKey = true<\/span>,\r\n                ValidIssuer = Configuration[\"Jwt:Issuer\"<\/span>],\r\n                ValidAudience = Configuration[\"Jwt:Audience\"<\/span>],\r\n                IssuerSigningKey = new<\/span> SymmetricSecurityKey(Encoding.UTF8.GetBytes(Configuration[\"Jwt:Key\"<\/span>]))\r\n            };\r\n        });<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                      Applying Authentication to GraphQL<\/strong>:Ensure authentication middleware is applied before GraphQL in the request pipeline.<\/p>\n\n\n
                                                      \/\/ In Startup.cs - Configure method<\/span>\r\n\r\napp.UseAuthentication();\r\napp.UseAuthorization();<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                      Protecting specific fields or types with authorization:<\/h4>\n\n\n\n
                                                      With HotChocolate, you can use the [Authorize]<\/code> attribute to protect specific fields or types.<\/p>\n\n\n\n
                                                      Protecting a Type<\/strong>:You can protect an entire type by applying the [Authorize]<\/code> attribute. This ensures that only authenticated users can access this type.<\/p>\n\n\n
                                                      [Authorize<\/span>]\r\npublic<\/span> class<\/span> BookType<\/span> : ObjectType<\/span><Book<\/span>>\r\n{\r\n    \/\/ ... Type configuration ...<\/span>\r\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                      Protecting a Field<\/strong>:If you want to protect just a specific field, you can apply the [Authorize]<\/code> attribute to that field.<\/p>\n\n\n
                                                      public<\/span> class<\/span> BookType<\/span> : ObjectType<\/span><Book<\/span>>\r\n{\r\n    protected<\/span> override<\/span> void<\/span> Configure<\/span>(IObjectTypeDescriptor<Book> descriptor<\/span>)<\/span>\r\n    {\r\n        descriptor.Field(b => b.Title).Authorize();\r\n        \/\/ ... other configurations ...<\/span>\r\n    }\r\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                      Role-Based Authorization<\/strong>:You can also implement role-based authorization using the [Authorize]<\/code> attribute.<\/p>\n\n\n
                                                      \/\/ Only users with the \"Admin\" role can access this field<\/span>\r\ndescriptor.Field(b => b.ISBN).Authorize(\"Admin\"<\/span>);<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                      Custom Authorization<\/strong>:If you need more fine-grained control, you can implement custom authorization policies in ASP.NET Core and then reference them in your GraphQL types or fields.<\/p>\n\n\n
                                                      services.AddAuthorization(options =>\r\n{\r\n    options.AddPolicy(\"CustomPolicy\"<\/span>, policy => \r\n        policy.RequireClaim(\"CustomClaim\"<\/span>, \"ClaimValue\"<\/span>));\r\n});<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                      Then, in your GraphQL type:<\/p>\n\n\n
                                                      services.AddAuthorization(options =>\r\n{\r\n    options.AddPolicy(\"CustomPolicy\"<\/span>, policy => \r\n        policy.RequireClaim(\"CustomClaim\"<\/span>, \"ClaimValue\"<\/span>));\r\n});<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                      When implementing authentication and authorization, always test thoroughly to ensure security requirements are met. Consider edge cases and ensure that unauthorized access is effectively prevented. Make sure that error messages from authentication or authorization failures don’t reveal too much information about your system’s internal workings or configurations.<\/p>\n\n\n\n
                                                      Optimizing Your GraphQL API<\/h2>\n\n\n\n
                                                      As with any API, performance and scalability concerns are vital in GraphQL. One of the common pitfalls in GraphQL is the N+1 problem<\/strong>, where, for example, retrieving an author for each book in a list of books results in one request for the list and then an additional request for the author of each book.<\/p>\n\n\n\n
                                                      Luckily, a solution exists in the form of DataLoader<\/strong>. DataLoader is a generic utility that batches and caches requests, vastly improving the performance of our GraphQL API.<\/p>\n\n\n\n
                                                      Benefits of using DataLoader:<\/h3>\n\n\n\n
                                                        \n
                                                      1. Batching<\/strong>: Multiple requests to retrieve a type are batched into a single request, reducing the total number of database hits.<\/li>\n\n\n\n
                                                      2. Caching<\/strong>: Results from the database are cached in memory to prevent redundant requests during the lifecycle of a single GraphQL request.<\/li>\n<\/ol>\n\n\n\n
                                                        Batch and cache requests to reduce database hits:<\/h3>\n\n\n\n
                                                        Without DataLoader, if we had a query fetching multiple books and their authors, the execution might result in separate database requests for each author. With DataLoader, all these requests can be batched, and the authors fetched in a single query.<\/p>\n\n\n\n
                                                        Implementing DataLoader in C#:<\/h3>\n\n\n\n
                                                        Let’s see how we can implement DataLoader in a C# GraphQL setup:<\/p>\n\n\n\n
                                                        Install Required Packages<\/strong>:If you’re using HotChocolate, you can use its built-in DataLoader support. First, install the required package:<\/p>\n\n\n
                                                        Install-Package HotChocolate.DataLoader<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                        Create a DataLoader<\/strong>:For our example, let’s create an AuthorDataLoader<\/code> that fetches authors by their IDs.<\/p>\n\n\n
                                                        public<\/span> class<\/span> AuthorDataLoader<\/span> : BatchDataLoader<\/span><int<\/span>, Author<\/span>>\r\n{\r\n    private<\/span> readonly<\/span> AppDbContext _dbContext;\r\n\r\n    public<\/span> AuthorDataLoader<\/span>(AppDbContext dbContext<\/span>)<\/span>\r\n    {\r\n        _dbContext = dbContext;\r\n    }\r\n\r\n    protected<\/span> override<\/span> async<\/span> Task<IReadOnlyDictionary<int<\/span>, Author>> LoadBatchAsync(\r\n        IReadOnlyList<int<\/span>> keys, \r\n        CancellationToken cancellationToken)\r\n    {\r\n        return<\/span> await<\/span> _dbContext.Authors\r\n            .Where(a => keys.Contains(a.Id))\r\n            .ToDictionaryAsync(t => t.Id, cancellationToken);\r\n    }\r\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                        Use DataLoader in Resolvers<\/strong>:Now, when resolving fields, use the DataLoader to fetch data:<\/p>\n\n\n
                                                        public<\/span> class<\/span> BookType<\/span> : ObjectType<\/span><Book<\/span>>\r\n{\r\n    protected<\/span> override<\/span> void<\/span> Configure<\/span>(IObjectTypeDescriptor<Book> descriptor<\/span>)<\/span>\r\n    {\r\n        descriptor.Field(b => b.Author)\r\n            .ResolveWith<Resolvers>(r => r.GetAuthor(default<\/span>!, default<\/span>!));\r\n    }\r\n\r\n    private<\/span> class<\/span> Resolvers<\/span>\r\n    {\r\n        public<\/span> async<\/span> Task<Author> GetAuthor<\/span>(Book book, AuthorDataLoader authorLoader<\/span>)<\/span>\r\n        {\r\n            return<\/span> await<\/span> authorLoader.LoadAsync(book.AuthorId);\r\n        }\r\n    }\r\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                        In the example above, when multiple books are fetched, and the author for each book needs to be retrieved, DataLoader will ensure that authors are fetched in a single batch, dramatically reducing the number of database hits.<\/p>\n\n\n\n
                                                        Using DataLoader can greatly enhance the efficiency and performance of your GraphQL API, especially when dealing with complex queries that fetch related data. By batching and caching requests, DataLoader ensures that your API remains scalable and responsive even under heavy loads.<\/p>\n\n\n\n
                                                        Testing the CRUD Operations<\/h2>\n\n\n\n
                                                        Once you’ve set up your GraphQL API, it’s essential to test the CRUD operations to ensure everything works as expected. Tools like GraphQL Playground and Postman make this process straightforward and intuitive.<\/p>\n\n\n\n
                                                        Using GraphQL Playground or Postman:<\/h3>\n\n\n\n
                                                          \n
                                                        1. GraphQL Playground<\/strong>: This is an interactive, in-browser GraphQL IDE. If you’re using HotChocolate, GraphQL Playground comes integrated, and you can access it by navigating to \/graphql<\/code> in your browser after starting your server.<\/li>\n\n\n\n
                                                        2. Postman<\/strong>: Postman introduced support for GraphQL, allowing you to test GraphQL APIs just like any other API. To use Postman, set the HTTP verb to POST and set the body type to GraphQL. Provide the GraphQL endpoint URL, and you’re set to test your queries and mutations.<\/li>\n<\/ol>\n\n\n\n
                                                          Sample queries and mutations for testing:<\/h3>\n\n\n\n
                                                          Fetch all books<\/strong>:<\/p>\n\n\n
                                                          query {\r\n  getBooks {\r\n    id\r\n    title\r\n    author {\r\n      name\r\n    }\r\n  }\r\n}<\/code><\/span><\/pre>\n\n\n
                                                          Fetch a single book<\/strong>:<\/p>\n\n\n
                                                          query {\r\n  getBook(id: 1) {\r\n    title\r\n    ISBN\r\n    author {\r\n      name\r\n    }\r\n  }\r\n}<\/code><\/span><\/pre>\n\n\n
                                                          Add a new book<\/strong>:<\/p>\n\n\n
                                                          mutation {\r\n  addBook(input: {\r\n    title<\/span>: \"New Book\"<\/span>,\r\n    ISBN<\/span>: \"123-456\"<\/span>,\r\n    publicationDate<\/span>: \"2023-10-05\"<\/span>,\r\n    authorId<\/span>: 1<\/span>,\r\n    publisherId<\/span>: 2<\/span>\r\n  }) {\r\n    id\r\n    title\r\n  }\r\n}<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                          Update a book<\/strong>:<\/p>\n\n\n
                                                          mutation {\r\n  updateBook(input: {\r\n    id<\/span>: 1<\/span>,\r\n    title<\/span>: \"Updated Book Title\"<\/span>\r\n  }) {\r\n    id\r\n    title\r\n  }\r\n}<\/code><\/span>Code language:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
                                                          Delete a book<\/strong>:<\/p>\n\n\n
                                                          mutation {\r\n  deleteBook(id: 1)\r\n}<\/code><\/span><\/pre>\n\n\n
                                                          You can run these queries and mutations in either GraphQL Playground or Postman to test the operations of your GraphQL API. Ensure to check the responses for correctness and inspect any errors returned. It’s also wise to look into your database directly to verify that the expected changes (especially for mutations) took place.<\/p>\n\n\n\n
                                                          Best Practices<\/h3>\n\n\n\n
                                                          Ensuring best practices in your GraphQL API can lead to better performance, maintainability, and extensibility. Let’s delve into some important best practices to consider.<\/p>\n\n\n\n
                                                          Schema Design Recommendations:<\/h4>\n\n\n\n
                                                            \n
                                                          1. Descriptive Naming<\/strong>: Name your types and fields descriptively. Avoid jargon that clients of the API might not understand.<\/li>\n\n\n\n
                                                          2. Use Enums and Scalars<\/strong>: For fields that have a specific set of possible values, consider using Enums. Similarly, use custom scalars for specific data types not covered by GraphQL’s default scalars (like Date or DateTime).<\/li>\n\n\n\n
                                                          3. Avoid Null Where Possible<\/strong>: While GraphQL supports nullable types, it’s often better to avoid them unless there’s a compelling reason. This ensures clients always receive meaningful data.<\/li>\n\n\n\n
                                                          4. Limit Deep Nesting<\/strong>: While GraphQL allows clients to request deeply nested data, consider limiting the depth to prevent overly complex queries.<\/li>\n\n\n\n
                                                          5. Use Input Types for Mutations<\/strong>: Instead of having many arguments for mutations, group them into an input type for clarity.<\/li>\n<\/ol>\n\n\n\n
                                                            Versioning in GraphQL:<\/h4>\n\n\n\n
                                                              \n
                                                            1. Avoid Versioning if Possible<\/strong>: One of GraphQL’s strengths is its ability to evolve without versioning. Adding fields is non-breaking. Removing or changing fields can be managed by marking them as deprecated.<\/li>\n\n\n\n
                                                            2. Schema Extensions<\/strong>: If you must introduce breaking changes, consider extending the schema. For example, introduce new types or fields and deprecate old ones.<\/li>\n\n\n\n
                                                            3. Clear Deprecation Messages<\/strong>: When deprecating fields or types, provide clear and meaningful deprecation messages.<\/li>\n<\/ol>\n\n\n\n
                                                              Handling N+1 Problem:<\/h4>\n\n\n\n
                                                                \n
                                                              1. Use DataLoader<\/strong>: As covered earlier, DataLoader is an invaluable tool in resolving the N+1 problem by batching and caching requests.<\/li>\n\n\n\n
                                                              2. Opt for Batched Endpoints<\/strong>: If integrating with other services, consider batched endpoints that retrieve multiple items in one go.<\/li>\n\n\n\n
                                                              3. Limit Field Complexity<\/strong>: It’s good to allow clients the flexibility to request the data they need. However, it might be wise to implement query complexity analysis to prevent overly complicated queries.<\/li>\n<\/ol>\n\n\n\n
                                                                GraphQL’s flexibility can be a double-edged sword, leading to potential pitfalls like performance bottlenecks if not managed correctly. Leveraging best practices, utilizing tools like DataLoader, and regularly testing your API are all vital steps in ensuring your GraphQL API remains performant, secure, and scalable.<\/p>\n","protected":false},"excerpt":{"rendered":"
                                                                Introduction What is GraphQL? GraphQL is a query language for APIs, as well as a runtime for executing those queries using a type system that you define for your data. Unlike other API standards that focus on defining fixed endpoints, GraphQL enables clients to request exactly the data they need, and no more. Developed by […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_genesis_hide_title":false,"_genesis_hide_breadcrumbs":false,"_genesis_hide_singular_image":false,"_genesis_hide_footer_widgets":false,"_genesis_custom_body_class":"","_genesis_custom_post_class":"","_genesis_layout":"","_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[8,4],"tags":[],"class_list":["post-1569","post","type-post","status-publish","format-standard","category-csharp","category-programming-languages","entry"],"yoast_head":"\nBuilding a CRUD API with C# and GraphQL<\/title>\n<meta name=\"description\" content=\"GraphQL is a query language for APIs, as well as a runtime for executing those queries using a type system that you define for your data.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.w3computing.com\/articles\/building-crud-api-with-csharp-graphql\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Building a CRUD API with C# and GraphQL\" \/>\n<meta property=\"og:description\" content=\"GraphQL is a query language for APIs, as well as a runtime for executing those queries using a type system that you define for your data.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.w3computing.com\/articles\/building-crud-api-with-csharp-graphql\/\" \/>\n<meta property=\"article:published_time\" content=\"2023-10-07T02:44:11+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-10-07T02:44:13+00:00\" \/>\n<meta name=\"author\" content=\"w3compadmin\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"w3compadmin\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"18 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"TechArticle\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/building-crud-api-with-csharp-graphql\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/building-crud-api-with-csharp-graphql\\\/\"},\"author\":{\"name\":\"w3compadmin\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"headline\":\"Building a CRUD API with C# and GraphQL\",\"datePublished\":\"2023-10-07T02:44:11+00:00\",\"dateModified\":\"2023-10-07T02:44:13+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/building-crud-api-with-csharp-graphql\\\/\"},\"wordCount\":4068,\"commentCount\":0,\"articleSection\":[\"C#\",\"Programming Languages\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/building-crud-api-with-csharp-graphql\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/building-crud-api-with-csharp-graphql\\\/\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/building-crud-api-with-csharp-graphql\\\/\",\"name\":\"Building a CRUD API with C# and GraphQL\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\"},\"datePublished\":\"2023-10-07T02:44:11+00:00\",\"dateModified\":\"2023-10-07T02:44:13+00:00\",\"author\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\"},\"description\":\"GraphQL is a query language for APIs, as well as a runtime for executing those queries using a type system that you define for your data.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/building-crud-api-with-csharp-graphql\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/building-crud-api-with-csharp-graphql\\\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/building-crud-api-with-csharp-graphql\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Articles Home\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Programming Languages\",\"item\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/programming-languages\\\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Building a CRUD API with C# and GraphQL\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#website\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/\",\"name\":\"Developer Articles Hub\",\"description\":\"\",\"alternateName\":\"Developer Articles\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/#\\\/schema\\\/person\\\/a550b3e20d78bb4f79b7c6b7b53f0561\",\"name\":\"w3compadmin\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266\",\"url\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266\",\"contentUrl\":\"https:\\\/\\\/www.w3computing.com\\\/articles\\\/wp-content\\\/litespeed\\\/avatar\\\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266\",\"caption\":\"w3compadmin\"},\"sameAs\":[\"http:\\\/\\\/w3computing.com\\\/articles\"]}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Building a CRUD API with C# and GraphQL","description":"GraphQL is a query language for APIs, as well as a runtime for executing those queries using a type system that you define for your data.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.w3computing.com\/articles\/building-crud-api-with-csharp-graphql\/","og_locale":"en_US","og_type":"article","og_title":"Building a CRUD API with C# and GraphQL","og_description":"GraphQL is a query language for APIs, as well as a runtime for executing those queries using a type system that you define for your data.","og_url":"https:\/\/www.w3computing.com\/articles\/building-crud-api-with-csharp-graphql\/","article_published_time":"2023-10-07T02:44:11+00:00","article_modified_time":"2023-10-07T02:44:13+00:00","author":"w3compadmin","twitter_card":"summary_large_image","twitter_misc":{"Written by":"w3compadmin","Est. reading time":"18 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"TechArticle","@id":"https:\/\/www.w3computing.com\/articles\/building-crud-api-with-csharp-graphql\/#article","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/building-crud-api-with-csharp-graphql\/"},"author":{"name":"w3compadmin","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"headline":"Building a CRUD API with C# and GraphQL","datePublished":"2023-10-07T02:44:11+00:00","dateModified":"2023-10-07T02:44:13+00:00","mainEntityOfPage":{"@id":"https:\/\/www.w3computing.com\/articles\/building-crud-api-with-csharp-graphql\/"},"wordCount":4068,"commentCount":0,"articleSection":["C#","Programming Languages"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.w3computing.com\/articles\/building-crud-api-with-csharp-graphql\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.w3computing.com\/articles\/building-crud-api-with-csharp-graphql\/","url":"https:\/\/www.w3computing.com\/articles\/building-crud-api-with-csharp-graphql\/","name":"Building a CRUD API with C# and GraphQL","isPartOf":{"@id":"https:\/\/www.w3computing.com\/articles\/#website"},"datePublished":"2023-10-07T02:44:11+00:00","dateModified":"2023-10-07T02:44:13+00:00","author":{"@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561"},"description":"GraphQL is a query language for APIs, as well as a runtime for executing those queries using a type system that you define for your data.","breadcrumb":{"@id":"https:\/\/www.w3computing.com\/articles\/building-crud-api-with-csharp-graphql\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.w3computing.com\/articles\/building-crud-api-with-csharp-graphql\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/www.w3computing.com\/articles\/building-crud-api-with-csharp-graphql\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Articles Home","item":"https:\/\/www.w3computing.com\/articles\/"},{"@type":"ListItem","position":2,"name":"Programming Languages","item":"https:\/\/www.w3computing.com\/articles\/programming-languages\/"},{"@type":"ListItem","position":3,"name":"Building a CRUD API with C# and GraphQL"}]},{"@type":"WebSite","@id":"https:\/\/www.w3computing.com\/articles\/#website","url":"https:\/\/www.w3computing.com\/articles\/","name":"Developer Articles Hub","description":"","alternateName":"Developer Articles","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.w3computing.com\/articles\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/www.w3computing.com\/articles\/#\/schema\/person\/a550b3e20d78bb4f79b7c6b7b53f0561","name":"w3compadmin","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266","url":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266","contentUrl":"https:\/\/www.w3computing.com\/articles\/wp-content\/litespeed\/avatar\/bd481d404e42caa2763662a3bfe825f8.jpg?ver=1780141266","caption":"w3compadmin"},"sameAs":["http:\/\/w3computing.com\/articles"]}]}},"featured_image_src":null,"featured_image_src_square":null,"author_info":{"display_name":"w3compadmin","author_link":"https:\/\/www.w3computing.com\/articles\/author\/w3compadmin\/"},"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1569","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/comments?post=1569"}],"version-history":[{"count":13,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1569\/revisions"}],"predecessor-version":[{"id":1582,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/posts\/1569\/revisions\/1582"}],"wp:attachment":[{"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/media?parent=1569"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/categories?post=1569"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.w3computing.com\/articles\/wp-json\/wp\/v2\/tags?post=1569"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}