主页 / user-835073

D G's questions

Martin Hope
D G
Asked: 2024-09-02 01:29:41 +0800 CST
  • 6

这是一个用来说明问题的简单例子。我想让背景颜色取决于输入。

<Entry
    BackgroundColor="{Binding Source={RelativeSource Self}, Path=Text}" />
// or
<Entry
    BindingContext="{Binding Source={RelativeSource Self}}"
    BackgroundColor="{Binding Text}" />

两者都具有以下输出。

在此处输入图片描述

然而，如果我按如下方式简化它，它就不再起作用。

<Entry
    BindingContext="{RelativeSource Self}"
    BackgroundColor="{Binding Text}" />

为了进行比较，我们可以简化

ItemsSource="{Binding Source={StaticResource people}}"

到

ItemsSource="{StaticResource people}"

问题

罪魁祸首是谁？

c#
Martin Hope
D G
Asked: 2024-08-13 05:57:49 +0800 CST
  • 5

引用官方文档标题“ Compiled bindings”：

重要提示：对于定义该Source属性的任何绑定表达式，编译绑定均被禁用。这是因为该Source属性始终使用标记扩展进行设置x:Reference，而标记扩展在编译时无法解析。此外，多重绑定目前不支持编译绑定。

我不明白为什么Source总是使用 设置属性，x:Reference而我们知道也可以使用Source={StaticResource xyz}。那么在这种情况下，编译绑定也被禁用了吗？

maui
Martin Hope
D G
Asked: 2024-08-08 18:22:08 +0800 CST
  • 5

我有在业务服务中使用的错误类。OneOf<>使用可区分联合允许服务方法从多个可能结果中返回一个结果。

// Errors
public record Error(string Code, string Description);
public sealed record NotDeleted(int Id, string EntityName) : Error("NotDeleted",
        $"{EntityName} with Id = {Id} cannot be deleted.");
public sealed record NotFound(int Id, string EntityName) : Error("NotFound",
        $"{EntityName} with Id = {Id} cannot be found.");

// Business Services
public sealed class MovieService(AppDbContext db)
{
    private readonly AppDbContext _db = db;
    public async Task<OneOf<NotFound, NotDeleted, Movie>> DeleteMovieAsync(int id, CancellationToken ct)
    {
        var movie = await _db.Movies
                .Include(m => m.Genres)
                .FirstOrDefaultAsync(m => m.Id == id, ct);

        if (movie is null)
            return new NotFound(id, nameof(Movie));

        _db.Movies.Remove(movie);

        return await _db.SaveChangesAsync(ct) > 0
            ? movie
            : new NotDeleted(id, nameof(Movie));
    }
}

业务服务被注入到端点。

// Endpoints
public static class MovieEndpoints
{
    public static void MapMovieEndpoints(this IEndpointRouteBuilder app)
    {
        var group = app.MapGroup("api/movies");
        group.MapDelete("{id}", DeleteMovieAsync);
    }
    private static async Task<Results<ProblemHttpResult, Ok<MovieResponse>>>
        DeleteMovieAsync(int id, MovieService ms, CancellationToken ct)
    {
        var result = await ms.DeleteMovieAsync(id, ct);

        return result.Match<Results<ProblemHttpResult, Ok<MovieResponse>>>(
           notFoundError => notFoundError.ToProblemDetails(),
           notDeletedError => notDeletedError.ToProblemDetails(),
           movie => TypedResults.Ok(movie.MapToMovieResponse()));
    }
}

我扩展Error类以生成ProblemDetails如下内容。我如何登录内部ToProblemDetails()（以 表示// Logging goes here!）？

// Mappers
public static class ErrorMapper
{
    private static ProblemHttpResult ToProblemDetails(Error error, int statusCode)
    {
        // Logging goes here!
        return TypedResults.Problem(new ProblemDetails
        {
            Title = error.Code,
            Detail = error.Description,
            Status = statusCode
        });
    }
    public static ProblemHttpResult ToProblemDetails(this NotFound error)
        => ToProblemDetails(error, StatusCodes.Status404NotFound);

    public static ProblemHttpResult ToProblemDetails(NotDeleted error)
        => ToProblemDetails(error, StatusCodes.Status500InternalServerError);
}
c#
Martin Hope
D G
Asked: 2024-06-12 12:02:20 +0800 CST
  • 6

当我调试以下代码时，我发现我注册的单例生命周期在执行到之后SqliteConnection从内部解析时并不是单例。AddDbContextGetAsync("")

我添加了以下内容来验证单例是否失败。

if (!ReferenceEquals(_sharedConnection, connection))
    throw new ApplicationException("SqliteConnection should be singleton.");

罪魁祸首是什么？解决方法是什么？完整代码如下。

正在测试的 Web API

public class AppDbContext(DbContextOptions<AppDbContext> o) : DbContext(o);

public class Program
{
    public static void Main(string[] args)
    {
        var builder = WebApplication.CreateBuilder(args);
        var app = builder.Build();

        app.MapGet("/", (AppDbContext db) => "Hello");

        app.Run();
    }
}

测试

public class CustomWebAppFactory : WebApplicationFactory<Program>
{
    private static SqliteConnection _sharedConnection = null!;

    protected override void ConfigureWebHost(IWebHostBuilder builder)
    {
        base.ConfigureWebHost(builder);

        builder.ConfigureTestServices(services =>
        {
            services.RemoveAll(typeof(SqliteConnection));
            services.RemoveAll(typeof(DbContextOptions<AppDbContext>));

            services.AddSingleton(provider =>
            {
                var connection = new SqliteConnection("DataSource=:memory:");
                return connection;
            });

            services.AddDbContext<AppDbContext>((provider, options) =>
            {
                var connection = provider.GetRequiredService<SqliteConnection>();

                if (!ReferenceEquals(_sharedConnection, connection))
                    throw new ApplicationException("SqliteConnection should be singleton.");

                options.UseSqlite(connection);
            });

            var provider = services.BuildServiceProvider();

            if (_sharedConnection != null)
                throw new ApplicationException("_sharedConnection should be null before reaching the following line.");

            _sharedConnection = provider.GetRequiredService<SqliteConnection>();
        });
    }
}

public class TrivialTest
{
    [Fact]
    public async Task Should_return_OK()
    {
        using var factory = new CustomWebAppFactory();
        using var client = factory.CreateClient();
        var response = await client.GetAsync("");
        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
    }
}
c#