Question

我希望有一个泛型服务，即 -

public interface IFooService<T> 
{
   Task<T> Get(int id);
}

但是，服务结构不允许使用泛型类或泛型方法。我也试过像

这样的东西

public interface INinjaService : IService, IFooService<SuperNinja>
{


}

但它没有选择继承的接口说明

服务类型＆＃39; Omni.Fabric.Services.NinjaService＆＃39;没有实现任何服务接口。服务接口是派生的接口来自＆＃39; Microsoft.ServiceFabric.Services.Remoting.IService＆＃39;类型。

我似乎无法在Service Fabric文档或stackoverflow上找到对泛型的任何引用。要么它仍然太新，要么我可能走错了路。有没有人有幸实现这种模式？可以吗？它应该完成吗？

NinjaService按要求

public class NinjaService : StatelessService, INinjaService
{

    public NinjaService(StatelessServiceContext serviceContext) : base(serviceContext)
    {
    }


    protected override IEnumerable<ServiceInstanceListener> CreateServiceInstanceListeners()
    {
            return new[] { new ServiceInstanceListener(context => this.CreateServiceRemotingListener(context)) };
    }


    public Task<SuperNinja> Get(int id)
    {
        return Task.FromResult(new SuperNinja());
    }
}

使用代码（从Owin WebApi服务调用

    public async Task<SuperNinja> Get(int key)
    {
        try
        {
            INinjaService service = ServiceProxy.Create<INinjaService>(new Uri("fabric:/Omni.Fabric/Services"));

            var t = await service.Get(key).ConfigureAwait(false);

            return t;
        }
        catch (Exception ex)
        {
            throw;
        }
    }

Answer 1

Service Fabric 中的服务可以实现通用接口：

interface IMyService<T>
{
    T Foo();
}

class Stateful1 : StatefulService, IMyService<string>
{
    public Stateful1(StatefulServiceContext context)
        : base(context)
    { }

    public string Foo()
    {
        // do foo
    }
}

这很好。

不支持是远程过程调用（RPC）的通用接口。这特定于Service Remoting通信栈，这是您使用IService和Remoting通信监听器的。

所以在你的情况下，不，还没有支持泛型。但这是特定服务通信堆栈的限制，而不是一般服务的限制，当然您可以使用any communication stack you want。

Answer 2

Service Fabric正在使用此扩展方法删除非服务类型接口

internal static class ServiceTypeExtensions
{
    public static Type[] GetServiceInterfaces(this Type serviceType)
    {
        List<Type> typeList = new List<Type>(((IEnumerable<Type>)serviceType.GetInterfaces()).Where(t => typeof(IService).IsAssignableFrom(t)));

        typeList.RemoveAll(t => t.GetNonServiceParentType() != null);

        return typeList.ToArray();
    }

    internal static Type GetNonServiceParentType(this Type type)
    {
        List<Type> typeList = new List<Type>(type.GetInterfaces());
        if (typeList.RemoveAll(t => t == typeof(IService)) == 0)
            return type;
        foreach (Type type1 in typeList)
        {
            Type serviceParentType = type1.GetNonServiceParentType();
            if (serviceParentType != null)
                return serviceParentType;
        }
        return null;
    }
}

并检查结果

if (serviceInterfaces.Length == 0 && !serviceType.IsAbstract)
    throws the exception in question

所以我找到了这个案例的解决方法

public interface IServiceWrapper : IService
{
}

public interface INinjaService : IServiceWrapper, IFooService<SuperNinja>
{
}

<强>已更新

经过一番调查后，我发现代理正在检查所有接口父母是否需要像IService一样，这意味着

  Type serviceParentType = serviceInterfaceType.GetNonServiceParentType();
  if (serviceParentType != null)
     throws another exception

因此，您需要从IFooService<T>派生IService，目前不支持。

不支持泛型:(

Answer 3

这个答案可能会迟到，但它可能对某人有所帮助。我通过确保服务类中实现的每个接口都继承自IService来解决这个问题。在您的情况下，您将拥有以下内容：

public interface IFooService<T> : IService
{
   Task<T> Get(int id);
}
public interface INinjaService : IFooService<SuperNinja>
{

}
public class NinjaService : StatelessService, INinjaService
{
}

试试吧，它应该有效。如果您需要在服务中实现多个接口，我已尝试以下选项：

public interface MyInterfaceA : IService { }
public interface MyInterfaceB : IService { }
public class MyServiceAB : StatelessService, MyInterfaceA, MyInterfaceB
{
}

或

public interface MyInterfaceA : IService { }
public interface MyInterfaceB : IService { }
public interface MyInterfaceC : MyInterfaceA, MyInterfaaceB { }
public class MyServiceC : StatelessService, MyInterfaceC
{
}

希望有所帮助。

Answer 4

因为我想从一个服务调用另一个服务，所以我要做的解决方法是传递一个带有Type名称的字符串，并使用反射名称调用另一个方法。

    public async Task<Result> GetResultAsync(Site site, string indexableType, SearchQuery searchQuery)
    {
        using (var provider = new Provider(Logger))
        {
            var indexableT = typeof(IIndexable).Assembly
                                        .GetTypes()
                                        .FirstOrDefault(t => typeof(IIndexable).IsAssignableFrom(t) && t.Name == indexableType);


            if (indexableT != null)
            {
                var generic = provider
                                .GetType()
                                .GetMethod("METHOD_NAME_IN_PROVIDER"))
                                .MakeGenericMethod(indexableT);                    

                //This is the same as calling: await provider.METHOD_NAME_IN_PROVIDER<T>(site, searchQuery);
                return await (Task<Result>) generic.Invoke(provider, new object[] { site, searchQuery });
            }

            return null;
        }
    }

希望它可以帮助某人。

具有通用服务的服务结构

4 个答案: