C# 一分钟浅谈：GraphQL 客户端调用

Jimaks

发布于 2024-12-03 08:08:39

10300

代码可运行

文章被收录于专栏：大数据大数据

运行总次数：0

代码可运行

引言

随着互联网应用的发展，API 的设计模式也在不断进化。从传统的 RESTful API 到现代的 GraphQL API，后者以其灵活性和高效性逐渐受到开发者的青睐。本文将简要介绍如何在 C# 中调用 GraphQL API，并探讨一些常见的问题、易错点及如何避免这些问题。

什么是 GraphQL？

GraphQL 是一种用于 API 的查询语言，它允许客户端精确地请求所需的数据，而无需返回额外的字段。与 RESTful API 不同，GraphQL 可以在一个请求中获取多个资源的数据，从而减少网络请求次数，提高性能。

C# 调用 GraphQL API

基本步骤

安装必要的 NuGet 包：首先，我们需要安装一个 GraphQL 客户端库。常用的库有 GraphQL.Client 和 HotChocolate。这里我们使用 GraphQL.Client。

    dotnet add package GraphQL.Client.Http

创建 GraphQL 客户端：使用 GraphQL.Client 库创建一个客户端实例，连接到 GraphQL 服务器。

    using GraphQL.Client;
    using GraphQL.Client.Abstractions;
    using GraphQL.Client.Http;

    public class GraphQLClientService
    {
        private readonly IGraphQLClient _graphQLClient;

        public GraphQLClientService(string url)
        {
            _graphQLClient = new GraphQLHttpClient(url, new GraphQLHttpClientOptions
            {
                HttpMessageHandler = new HttpClientHandler
                {
                    // 可以配置代理、证书等
                }
            });
        }

        public async Task<T> QueryAsync<T>(string query, object variables = null)
        {
            var graphQLRequest = new GraphQLRequest
            {
                Query = query,
                Variables = variables
            };

            var response = await _graphQLClient.SendQueryAsync<T>(graphQLRequest);
            return response.Data;
        }
    }

编写查询：编写一个简单的 GraphQL 查询，例如获取用户信息。

    public class User
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Email { get; set; }
    }

    public class Program
    {
        public static async Task Main(string[] args)
        {
            var client = new GraphQLClientService("https://api.example.com/graphql");

            string query = @"
            query GetUser($id: Int!) {
                user(id: $id) {
                    id
                    name
                    email
                }
            }";

            var variables = new { id = 1 };

            var result = await client.QueryAsync<User>(query, variables);

            Console.WriteLine($"User ID: {result.Id}, Name: {result.Name}, Email: {result.Email}");
        }
    }

常见问题及易错点

查询语法错误：
- 问题：GraphQL 查询语法非常严格，任何拼写错误或语法错误都会导致请求失败。
- 解决方法：使用 GraphQL 模板工具或 IDE 插件进行语法检查，确保查询语句正确无误。
变量类型不匹配：
- 问题：传递给查询的变量类型必须与定义的类型一致，否则会引发错误。
- 解决方法：仔细检查变量的类型定义，确保传递的变量类型与查询中定义的类型一致。
响应数据结构不匹配：
- 问题：返回的数据结构与预期不符，导致反序列化失败。
- 解决方法：使用强类型模型类来接收响应数据，确保数据结构一致。
网络请求超时：
- 问题：网络请求超时，导致请求失败。
- 解决方法：设置合理的超时时间，并处理超时异常。
认证和授权：
- 问题：未提供必要的认证信息，导致请求被拒绝。
- 解决方法：在请求头中添加认证信息，如 Bearer Token。

代码案例

以下是一个完整的示例，展示了如何在 C# 中调用 GraphQL API 并处理常见问题。

using System;
using System.Net.Http;
using System.Threading.Tasks;
using GraphQL.Client;
using GraphQL.Client.Abstractions;
using GraphQL.Client.Http;

public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
}

public class GraphQLClientService
{
    private readonly IGraphQLClient _graphQLClient;

    public GraphQLClientService(string url)
    {
        _graphQLClient = new GraphQLHttpClient(url, new GraphQLHttpClientOptions
        {
            HttpMessageHandler = new HttpClientHandler
            {
                // 可以配置代理、证书等
            }
        });

        // 设置认证信息
        _graphQLClient.HttpClient.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_ACCESS_TOKEN");
    }

    public async Task<T> QueryAsync<T>(string query, object variables = null)
    {
        var graphQLRequest = new GraphQLRequest
        {
            Query = query,
            Variables = variables
        };

        try
        {
            var response = await _graphQLClient.SendQueryAsync<T>(graphQLRequest);
            if (response.Errors != null && response.Errors.Count > 0)
            {
                throw new Exception($"GraphQL Errors: {string.Join(", ", response.Errors)}");
            }

            return response.Data;
        }
        catch (HttpRequestException ex)
        {
            // 处理网络请求异常
            Console.WriteLine($"Network Error: {ex.Message}");
            throw;
        }
        catch (Exception ex)
        {
            // 处理其他异常
            Console.WriteLine($"Error: {ex.Message}");
            throw;
        }
    }
}

public class Program
{
    public static async Task Main(string[] args)
    {
        var client = new GraphQLClientService("https://api.example.com/graphql");

        string query = @"
        query GetUser($id: Int!) {
            user(id: $id) {
                id
                name
                email
            }
        }";

        var variables = new { id = 1 };

        try
        {
            var result = await client.QueryAsync<User>(query, variables);
            Console.WriteLine($"User ID: {result.Id}, Name: {result.Name}, Email: {result.Email}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Failed to fetch user: {ex.Message}");
        }
    }
}

案例：管理用户和订单

假设我们有一个电商系统，需要实现以下功能：

获取用户的详细信息。
创建一个新的订单。
更新订单的状态。
删除一个订单。

1. 获取用户的详细信息

首先，我们定义一个 User 类来表示用户信息，并编写一个查询来获取用户的详细信息。

public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
    public List<Order> Orders { get; set; }
}

public class Order
{
    public int Id { get; set; }
    public string ProductName { get; set; }
    public decimal Price { get; set; }
    public string Status { get; set; }
}

编写查询：

public class GraphQLClientService
{
    private readonly IGraphQLClient _graphQLClient;

    public GraphQLClientService(string url)
    {
        _graphQLClient = new GraphQLHttpClient(url, new GraphQLHttpClientOptions
        {
            HttpMessageHandler = new HttpClientHandler
            {
                // 可以配置代理、证书等
            }
        });

        // 设置认证信息
        _graphQLClient.HttpClient.DefaultRequestHeaders.Add("Authorization", "Bearer YOUR_ACCESS_TOKEN");
    }

    public async Task<T> QueryAsync<T>(string query, object variables = null)
    {
        var graphQLRequest = new GraphQLRequest
        {
            Query = query,
            Variables = variables
        };

        try
        {
            var response = await _graphQLClient.SendQueryAsync<T>(graphQLRequest);
            if (response.Errors != null && response.Errors.Count > 0)
            {
                throw new Exception($"GraphQL Errors: {string.Join(", ", response.Errors)}");
            }

            return response.Data;
        }
        catch (HttpRequestException ex)
        {
            // 处理网络请求异常
            Console.WriteLine($"Network Error: {ex.Message}");
            throw;
        }
        catch (Exception ex)
        {
            // 处理其他异常
            Console.WriteLine($"Error: {ex.Message}");
            throw;
        }
    }
}

public class Program
{
    public static async Task Main(string[] args)
    {
        var client = new GraphQLClientService("https://api.example.com/graphql");

        string getUserQuery = @"
        query GetUser($id: Int!) {
            user(id: $id) {
                id
                name
                email
                orders {
                    id
                    productName
                    price
                    status
                }
            }
        }";

        var getUserVariables = new { id = 1 };

        try
        {
            var user = await client.QueryAsync<User>(getUserQuery, getUserVariables);
            Console.WriteLine($"User ID: {user.Id}, Name: {user.Name}, Email: {user.Email}");
            foreach (var order in user.Orders)
            {
                Console.WriteLine($"Order ID: {order.Id}, Product: {order.ProductName}, Price: {order.Price}, Status: {order.Status}");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Failed to fetch user: {ex.Message}");
        }
    }
}

2. 创建一个新的订单

接下来，我们定义一个 CreateOrderInput 类来表示创建订单的输入参数，并编写一个突变来创建新的订单。

public class CreateOrderInput
{
    public int UserId { get; set; }
    public string ProductName { get; set; }
    public decimal Price { get; set; }
}

public class CreateOrderResult
{
    public Order Order { get; set; }
}

编写突变：

public class Program
{
    public static async Task Main(string[] args)
    {
        var client = new GraphQLClientService("https://api.example.com/graphql");

        string createOrderMutation = @"
        mutation CreateOrder($input: CreateOrderInput!) {
            createOrder(input: $input) {
                id
                productName
                price
                status
            }
        }";

        var createOrderVariables = new { input = new CreateOrderInput { UserId = 1, ProductName = "Laptop", Price = 999.99m } };

        try
        {
            var result = await client.QueryAsync<CreateOrderResult>(createOrderMutation, createOrderVariables);
            Console.WriteLine($"Created Order ID: {result.Order.Id}, Product: {result.Order.ProductName}, Price: {result.Order.Price}, Status: {result.Order.Status}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Failed to create order: {ex.Message}");
        }
    }
}

3. 更新订单的状态

定义一个 UpdateOrderInput 类来表示更新订单的输入参数，并编写一个突变来更新订单的状态。

public class UpdateOrderInput
{
    public int OrderId { get; set; }
    public string Status { get; set; }
}

public class UpdateOrderResult
{
    public Order Order { get; set; }
}

编写突变：

public class Program
{
    public static async Task Main(string[] args)
    {
        var client = new GraphQLClientService("https://api.example.com/graphql");

        string updateOrderMutation = @"
        mutation UpdateOrder($input: UpdateOrderInput!) {
            updateOrder(input: $input) {
                id
                productName
                price
                status
            }
        }";

        var updateOrderVariables = new { input = new UpdateOrderInput { OrderId = 1, Status = "Shipped" } };

        try
        {
            var result = await client.QueryAsync<UpdateOrderResult>(updateOrderMutation, updateOrderVariables);
            Console.WriteLine($"Updated Order ID: {result.Order.Id}, Product: {result.Order.ProductName}, Price: {result.Order.Price}, Status: {result.Order.Status}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Failed to update order: {ex.Message}");
        }
    }
}

4. 删除一个订单

定义一个 DeleteOrderInput 类来表示删除订单的输入参数，并编写一个突变来删除订单。

public class DeleteOrderInput
{
    public int OrderId { get; set; }
}

public class DeleteOrderResult
{
    public bool Success { get; set; }
}

编写突变：

public class Program
{
    public static async Task Main(string[] args)
    {
        var client = new GraphQLClientService("https://api.example.com/graphql");

        string deleteOrderMutation = @"
        mutation DeleteOrder($input: DeleteOrderInput!) {
            deleteOrder(input: $input) {
                success
            }
        }";

        var deleteOrderVariables = new { input = new DeleteOrderInput { OrderId = 1 } };

        try
        {
            var result = await client.QueryAsync<DeleteOrderResult>(deleteOrderMutation, deleteOrderVariables);
            if (result.Success)
            {
                Console.WriteLine("Order deleted successfully.");
            }
            else
            {
                Console.WriteLine("Failed to delete order.");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Failed to delete order: {ex.Message}");
        }
    }
}