Routes 难以配置多个路由

/v1/Tenants/{TenantId}

路由正在工作，但是

/v1/Tenants/{TenantName}

路由不工作，我不确定发生了什么问题？此外，这是设计过滤标准的正确方法还是具有过滤标准的正确方法

//Request DTO
[Route("/v1/Tenants/{TenantName}", "GET")]
public class TenantRequestByTenantName: IReturn<TenantResponse>
{
    public string TenantName { get; set; }
}

//Request DTO
[Route("/v1/Tenants/{TenantId}", "GET")]
public class TenantRequestById : IReturn<TenantResponse>
{
    public int? TenantId { get; set; }
}

//Response DTO
public class TenantResponse
{
    public ITenantEntity Result { get; set; }
    public ResponseStatus ResponseStatus { get; set; }
}

public class RestaurantService : Service
{
    public object Any(TenantRequestById request)
    {
        return this.GetTenant(request);
    }

    public object Any(TenantRequestByTenantName request)
    {
        return this.GetTenant(request);
    }

    private object GetTenant(object whereConditions)
    {
        return new TenantResponse
        {
            Result = new TenantManager().GetRow(whereConditions)
        };
    }
}

//请求DTO
[路由（“/v1/Tenants/{TenantName}”，“GET”）]
公共类租户RequestByTenantName:IReturn
{
公共字符串租户名称{get；set；}
}
//请求DTO
[路由（“/v1/Tenants/{TenantId}”，“GET”）]
公共类租户请求ById:IReturn
{
public int？TenantId{get；set；}
}
//响应DTO
公屋租户回应
{
公共实体结果{get；set；}
公共响应status ResponseStatus{get；set；}
}
公共类餐厅服务：服务
{
任何公共对象（租户请求）
{
返回此.GetTenant（请求）；
}
任何公共对象（租户请求ByTenantName请求）
{
返回此.GetTenant（请求）；
}
私有对象GetTenant（对象条件）
{
返回新租户响应
{
结果=新租户管理器（）.GetRow（whereConditions）
};
}
}

由于两条路线处理同一条路线，因此路线不明确，即：

/v1/Tenants/xxx

您需要有单独的路线，例如：

[Route("/v1/tenants/{TenantId}")]
public class TenantRequestById { ... }

[Route("/v1/tenants/by-name/{TenantName}")]
public class TenantRequestByTenantName { ... }

或者，您可以使用一个服务来处理这两个请求，具体取决于它是否为整数：

然后，在服务实现中，您可以检查Slug是否为整数Id，以选择适当的查询，例如：

public object Get(GetTechnology request)
{
    int id;
    var tech = int.TryParse(request.Slug, out id)
        ? Db.SingleById<Technology>(id)
        : Db.Single<Technology>(x => x.Slug == request.Slug.ToLower());

    return new GetTechnologyResponse {
        Result = tech,
    };
}

public对象获取（GetTechnology请求）
{
int-id；
var tech=int.TryParse（request.Slug，out id）
？数据库单字节id（id）
：Db.Single（x=>x.Slug==request.Slug.ToLower（））；
返回新的GetTechnologyResponse{
结果=技术，
};
}

我将继续采用分离路线方法，我认为它将在整个应用程序中保持一致。谢谢你的帮助！

var response = client.Get(GetTechnology { Id = 1 });

var response = client.Get(GetTechnology { Slug = "servicestack" });

public object Get(GetTechnology request)
{
    int id;
    var tech = int.TryParse(request.Slug, out id)
        ? Db.SingleById<Technology>(id)
        : Db.Single<Technology>(x => x.Slug == request.Slug.ToLower());

    return new GetTechnologyResponse {
        Result = tech,
    };
}