如何在 C# 中使用特定接口而不是通用接口？

Question

简介

假设我有一个类组装流水线。组装流水线包含多个步骤。每个步骤都可以执行：

public interface IStep
{
    IContext Execute(IContext context);
}

每个步骤都有一个特定的 IContext，其中包含一些关于要处理什么的信息。

组装流水线包含多个步骤。它们可以通过在组装流水线上调用 Execute 来执行：

public class Assemblyline
{
    private readonly List<IStep> _steps;

    public Assemblyline(List<IStep> steps)
    {
        _steps = steps;
    }

    public void Execute(IContext context)
    {
        foreach (var step in _steps)
        {
            step.Execute(context);
        }
    }
}

我有一个通用的 IContaxt 接口：

public interface IContext
{
    string Id { get; set; }
}

以及具体的上下文：

public interface IAbcContext : IContext
{
    string Abc { get; set; }
}

public interface IDefContext : IContext
{
    string Def { get; set; }
}

public class XyzContext : IAbcContext, IDefContext
{
    public string Id { get; set; }

    public string Abc { get; set; }

    public string Def { get; set; }
}

上下文可以通过特定的步骤来处理：

public class AbcStep : IStep
{
    public IContext Execute(IContext context)
    {
        var abcContext = (IAbcContext) context;
        abcContext.Abc = "some value for Abc";
        return abcContext;
    }

    public string Id { get; set; }
}


public class DefStep : IStep
{
    public IContext Execute(IContext context)
    {
        var defContext = (IDefContext)context;
        defContext.Def = "some value for Def";
        return defContext;

    }

    public string Id
    {
        get; set; }
}

这就是我可以执行代码的方式：

internal class Program
{
    private static void Main()
    {
        var steps = new List<IStep>();
        steps.Add(new AbcStep());
        steps.Add(new DefStep());

        var assemblyline = new Assemblyline(steps);

        var context = new XyzContext {Id = "1", Abc = "blabla", Def = "other value"};
        assemblyline.Execute(context);
    }
}

问题

在每个特定步骤中，我必须将 IContext 转换为我真正想要的类。看到这一行：

var abcContext = (IAbcContext) 上下文；

public class AbcStep : IStep
{
    public IContext Execute(IContext context)
    {
        var abcContext = (IAbcContext) context;
        abcContext.Abc = "some value for Abc";
        return abcContext;
    }

    public string Id { get; set; }
}

我希望我可以离开演员阵容，然后这样做：

public class AbcStep : IStep
{
    public IContext Execute(IAbcContext context)
    {
        context.Abc = "some value for Abc";
        return context;
    }

    public string Id { get; set; }
}

但后来我收到了这条消息：

接口成员'Execute(IContext)'未实现。

无论如何我可以删除演员表吗？也许使用泛型或其他东西？

Answer 1

是的，可以使用泛型和一些继承（代码中的 cmets）：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Test
{
    public interface IStep
    {
        IContext Execute(IContext context);
    }

    // Make a generic version also
    public interface IStep<T> : IStep where T : IContext
    {
        T Execute(T context);
    }

    public class Assemblyline
    {
        private readonly List<IStep> _steps;

        public Assemblyline(List<IStep> steps)
        {
            _steps = steps;
        }

        public void Execute(IContext context)
        {
            foreach (var step in _steps)
            {
                step.Execute(context);
            }
        }
    }

    public interface IContext
    {
        string Id { get; set; }
    }

    public interface IAbcContext : IContext
    {
        string Abc { get; set; }
    }

    public interface IDefContext : IContext
    {
        string Def { get; set; }
    }

    public class XyzContext : IAbcContext, IDefContext
    {
        public string Id { get; set; }

        public string Abc { get; set; }

        public string Def { get; set; }
    }

    // This will do the casting for you
    public abstract class BaseStep<T> : IStep<T> where T : IContext
    {
        public abstract T Execute(T context);

        public IContext Execute(IContext context)
        {
            return (IContext)Execute((T)context);
        }

    }

    // Now less code for you:
    public class AbcStep : BaseStep<IAbcContext>
    {
        public override IAbcContext Execute(IAbcContext context)
        {
            var abcContext = context;
            abcContext.Abc = "some value for Abc";
            return abcContext;
        }

        public string Id { get; set; }
    }


    public class DefStep : BaseStep<IDefContext>
    {
        public override IDefContext Execute(IDefContext context)
        {
            var defContext = context;
            defContext.Def = "some value for Def";
            return defContext;

        }

        public string Id
        {
            get;
            set;
        }
    }

    internal class Program
    {
        private static void Main()
        {
            var steps = new List<IStep>();
            steps.Add(new AbcStep());
            steps.Add(new DefStep());

            var assemblyline = new Assemblyline(steps);

            var context = new XyzContext { Id = "1", Abc = "blabla", Def = "other value" };
            assemblyline.Execute(context);
        }
    }

}

Answer 2

这不一定是你的问题，但它是我的，你的症状看起来一样。

不要尝试在静态类型语言中创建自己的动态类型系统。

铸造不好，因为它会在执行时失败，而不是在编译时。

每个模块都必须依赖于它实际需要的接口，而不是依赖于其他任何东西。使用您的示例：

interface IXyzStepWork
{
    void DoXyz();
}

interface IAbcStepWork
{
    void DoAbc();
}

interface IAbcXyzWork : IAbcStepWork, IXyzStepWork
{
}

class AbcStep
{
    private readonly IAbcStepWork work;

    public AbcStep(IAbcStepWork work)
    {
        this.work = work;
    }

    public void Execute()
    {
        work.DoAbc();
    }
}

class AbcXyzStep
{
    private readonly IAbcXyzWork work;

    public AbcXyzStep(IAbcXyzWork work)
    {
        this.work = work;
    }

    public void Execute()
    {
        work.DoAbc();
        work.DoXyz();
    }
}

接下来你可以编写IAssemblyLineItem，通过“step-classes”实现它并创建AssemblyLine，它将使用它。

是的，它很简单，很明显，不使用泛型。对我来说，这才是未来发展的正确方向。

UPD：如何在您的示例中创建单个装配线。

interface IAssemblyLineItem
{
    void Execute();
}

class AssemblyLineService
{
    public void ExecuteAll(IEnumerable<IAssemblyLineItem> items)
    {
        foreach (var item in items)
        {
            item.Execute();
        }
    }
}

通过“step-classes”实现IAssemblyLineItem，它会起作用。

及用法：

class Program
{
    static void Main(string[] args)
    {
        AbcXyzWork work = new AbcXyzWork();

        AbcStep abcStep = new AbcStep(work);

        AbcXyzStep abcxyzStep = new AbcXyzStep(work);

        AssemblyLineService line = new AssemblyLineService();

        line.ExecuteAll(new IAssemblyLineItem[] { abcStep, abcxyzStep });

        Console.ReadLine();
    }
}

注意：Program.Main 取决于系统的每个类 - 正如在您的初始示例中所做的那样。