Learn GraphQL with .Net Core For Absolute Beginners

Write your first GraphQL query, learn the basic syntax to read data, and use the viewer field to fetch id, name, avatar, url, login, and createdAt with IntelliSense.

Explore how to use arguments in GraphQL queries by passing name and owner to the repository field, and using the order argument to fetch the repository creation date.

Explore how a GraphQL schema defines fields, descriptions, types, and mandatory arguments. Understand repository queries require order and name, and how dotnet core projects define schemas as API documentation.

Explore GraphQL aliases to fetch data from multiple fields with user friendly names. Use aliases to avoid argument conflicts and retrieve repository name and owner data in one request.

Learn how GraphQL fragments enable reusable field sets to simplify repository queries, avoid repetition, and produce cleaner, more efficient queries using fragment syntax and on type.

Use variables in GraphQL queries to pass dynamic values for name and owner, replacing hardcoded values in a dotnet core repository query and making queries more flexible.

Learn to use GraphQL mutations to insert data by creating a project with a create project mutation and input, and review id, owner ID, and createdAt in the payload.

Open build studio, create a new ASP.NET Core web project named Scarlett GraphQL Project, choose .NET 7, then remove controllers to focus on GraphQL API development with .NET Core.

Create a public interface for the GraphQL API called Emanuel Repository, defining CRUD methods for menus: get all menus, get menu by ID, add menu, update menu, and delete menu.

Create a menu repository that implements manual repository interface and exposes get all menus, get menu by id, add, update, and delete.

Explore how dotnet core dependency injection uses interfaces and an IoC container to register a menu repository via AddTransient, enabling automatic resolution and easy access to repository methods.

Install essential NuGet packages to enable GraphQL endpoints in a .NET core project, and test them in a browser using GraphQL playground for interactive exploration.

Organize your GraphQL project with folders for type, schema, query, and mutation to simplify building GraphQL types, queries, mutations, and the schema for your API.

Map the menu model to the GraphQL type system by creating a MenuType that extends ObjectGraphType<Menu> and expose fields like id, name, price, and description.

Learn to build GraphQL queries in .NET Core to fetch all menus or a single menu by ID, using list and single record query patterns with a menu repository.

Define a GraphQL schema that wires queries and future mutations, create a menu schema class with the full namespace, and inject the menu query.

Configure the GraphQL server in .NET Core by registering menu type, query, and schema, enabling GraphQL with auto schema, and adding the GraphQL playground middleware.

Run the project to test GraphQL queries in the API via the graphical playground, explore the schema, and query fields like ID, name, price, and description.

Create GraphQL mutations to add, update, and delete menu items using a menu input type and mutation class, wiring the schema and program registrations for browser testing.

Explore performing GraphQL mutations for data modification, including create, update, and delete operations with variables and menu input types; this browser-based example uses hard-coded data before adding a MySQL database.

Learn how entity framework core, a dotnet orm, simplifies database access by mapping data to objects and handling sql under the hood, with SQL Server, MySQL, and SQLite support.

Learn the code-first approach with entity framework core by creating a GraphQL DbContext and DbSet properties to map database tables, and configure the connection string and provider in program file.

Add a database connection string in appsettings.json and configure entity framework core to use sql server with the GraphQL db context, enabling the web app to connect to the database.

Modify the menu repository to use Entity Framework Core with GraphQL DbContext, replace hardcoded data with database access, and implement CRUD operations with SaveChanges and migrations.

learn how to create and apply code-first migrations in .net core using entity framework core tools, add migrations, and update the database to synchronize your models with tables.

Seed initial data into the menu table using the code-first migration approach with Entity Framework in .NET Core, update the database, and query menus via GraphQL.

Learn how to build a GraphQL backend with .NET Core for a restaurant app. Map categories to menus and understand relation between the tables to support mobile and web bookings.

Build a GraphQL restaurant app on .NET Core with category, menu, and reservation tables and a one-to-many relationship between categories and menus for browsing and bookings via a GraphQL endpoint.

Add models for category, menu, and reservation; define category id, name, image URL; establish one-to-many with a collection navigation property; set category id as foreign key and include reservation fields.

Add DbSet properties for categories, menu, and reservations to the GraphQL DbContext, update appsettings.json with a restaurant database connection string, and prepare for adding services in the next lesson.

Implement category and reservation services by creating repositories, wiring up GraphQL context with a DbContext, and enabling CRUD operations, then register these interfaces in the program.

Create and map GraphQL types for category type and reservation type by extending object graph type, defining fields from their properties, and duplicating the menu type.

Learn to build GraphQL queries for menu, categories, and reservations in a .NET Core project by reusing and renaming query classes, injecting category and reservation repositories, and wiring get methods.

Register multiple query classes as fields in a single root query, and wire them into a root schema using dependency injection in ASP.NET Core. Include menu, category, and reservation queries.

Register GraphQL queries and schema in the program.cs to enable the GraphQL server, including category, menu, and reservation queries and the root query, with route schema handling all tasks.

Seed data is added to the database by providing a code snippet, creating migrations, and updating the database, then verify categories, menu, and reservations with GraphQL queries.

Execute a nested query in GraphQL to fetch categories and menus in a single request, by reusing the menu query, injecting a repository, and retrieving data from multiple tables.

Learn to create input types for GraphQL mutations, adding menu, category, and reservation input types, and register them in the pro game dot csv file.

Reuse existing menu mutation patterns to implement category and reservation mutations, including add, update, and delete operations. Register these mutations in a root mutation and schema to enable GraphQL operations.

Learn to test GraphQL mutations in a .NET Core app by creating and executing add category, create menu, and create reservation mutations, and querying categories, menus, and reservations.

Create an Azure web app for a GraphQL API by selecting a subscription and configuring a resource group. Deploy code with the dotnet runtime and download the publish profile.

Create an Azure SQL database in the Azure portal, configure a server and admin login, set firewall rules, then deploy the web app and pin the database to the dashboard.

Publish your ASP.NET Core web app to Azure by updating the Azure SQL connection string, using a publish profile, and selecting self-contained deployment, then access the live site from anywhere.

Learn GraphQL with Dotnet core from scratch in this beginner‑focused course led by Ashwin. Build real‑world projects and add a high‑demand GraphQL skill to your portfolio, with restful API prerequisites.

Master GraphQL basics (queries, arguments, schemas, aliases, fragments, variables, and mutations) while building a dotnet core project, implementing dependency injection, connecting GraphQL to a MySQL database, and deploying to Azure.

Explore how GraphQL, a language for building and querying APIs, began at Facebook in 2012, open-sourced in 2015, and now runs across languages that support json.

Learn why GraphQL reduces underfetching and overfetching with a single endpoint, letting you fetch posts, comments, and likes by fields, an alternative to REST for complex data.

Explore GraphQL in GitHub with GraphQL Explorer to write queries against the GitHub API, sign in to authorize permissions, and review responses before integrating GraphQL in a dotnet core project.

Learn how to write a first GraphQL query to read data, using the query keyword and fields like id, name, avatar, login, and created at, and view the json responses.

Learn to use arguments in GraphQL by passing name and owner to the repository field in a query, using parentheses, and see the creation date returned.

Explore how GraphQL schemas define query structure, field descriptions, and required arguments, using the GitHub GraphQL schema as a guide, with examples of repository queries and subfields.

Learn how aliases in GraphQL resolve argument conflicts by querying multiple repositories in a single request, using user-friendly alias names and selective fields.

Learn how to use fragments in GraphQL to reuse a common set of fields across repositories, using the fragment keyword, on keyword, and the three-dot syntax to call the fragment.

Learn to use variables in GraphQL queries with .NET core, passing dynamic name and owner values, and defining required string variables to replace hard-coded values.

Explore how GraphQL handles mutations to insert data, using a create project mutation with input objects, variables, and a payload return including id, createdAt, and url.