Question

我需要允许我的内容管道扩展使用类似于工厂的模式。我从字典类型开始：

public delegate T Mapper<T>(MapFactory<T> mf, XElement d);

public class MapFactory<T>
{
    Dictionary<string, Mapper<T>> map = new Dictionary<string, Mapper<T>>();

    public void Add(string s, Mapper<T> m)
    {
        map.Add(s, m);
    }

    public T Get(XElement xe)
    {
        if (xe == null) throw new ArgumentNullException(
            "Invalid document");
        var key = xe.Name.ToString();
        if (!map.ContainsKey(key)) throw new ArgumentException(
            key + " is not a valid key.");
        return map[key](this, xe);
    }

    public IEnumerable<T> GetAll(XElement xe)
    {
        if (xe == null) throw new ArgumentNullException(
            "Invalid document");
        foreach (var e in xe.Elements())
        {
            var val = e.Name.ToString();
            if (map.ContainsKey(val))
                yield return map[val](this, e);
        }
    }
}

以下是我想要存储的一种对象：

public partial class TestContent
{
    // Test type
    public string title;

    // Once test if true
    public bool once;

    // Parameters
    public Dictionary<string, object> args;

    public TestContent()
    {
        title = string.Empty;
        args = new Dictionary<string, object>();
    }

    public TestContent(XElement xe)
    {
        title = xe.Name.ToString();
        args = new Dictionary<string, object>();
        xe.ParseAttribute("once", once);
    }
}

XElement.ParseAttribute是一种可以按预期工作的扩展方法。它返回一个布尔值，如果成功则为true。

问题在于我有许多不同类型的测试，每个测试都以特定测试独有的方式填充对象。元素名称是MapFactory字典的关键。这种类型的测试虽然不典型，却说明了我的问题。

public class LogicTest : TestBase
{
    string opkey;
    List<TestBase> items;

    public override bool Test(BehaviorArgs args)
    {
        if (items == null) return false;
        if (items.Count == 0) return false;
        bool result = items[0].Test(args);
        for (int i = 1; i < items.Count; i++)
        {
            bool other = items[i].Test(args);
            switch (opkey)
            {
                case "And":
                    result &= other;
                    if (!result) return false;
                    break;
                case "Or":
                    result |= other;
                    if (result) return true;
                    break;
                case "Xor":
                    result ^= other;
                    break;
                case "Nand":
                    result = !(result & other);
                    break;
                case "Nor":
                    result = !(result | other);
                    break;
                default:
                    result = false;
                    break;
            }
        }
        return result;
    }

    public static TestContent Build(MapFactory<TestContent> mf, XElement xe)
    {
        var result = new TestContent(xe);
        string key = "Or";
        xe.GetAttribute("op", key);
        result.args.Add("key", key);
        var names = mf.GetAll(xe).ToList();
        if (names.Count() < 2) throw new ArgumentException(
              "LogicTest requires at least two entries.");
        result.args.Add("items", names);
        return result;
    }
}

我的实际代码涉及更多，因为工厂有两个字典，一个将XElement转换为要写入的内容类型，另一个用于读者创建实际游戏对象。

我需要在代码中构建这些工厂，因为它们将字符串映射到委托。我有一个包含其中几个工厂的服务。任务是使这些工厂类可用于内容处理器。处理器本身及其用作参数的上下文都没有任何已知的挂钩来附加IServiceProvider或等效的。

有什么想法吗？

Answer 1

我需要根据需要创建一个数据结构，而无需访问基础类，因为它们来自第三方，在本例中为XNA Game Studio。只有一种方法可以做到这一点，我知道......静态地。

public class TestMap : Dictionary<string, string>
{
    private static readonly TestMap map = new TestMap();

    private TestMap()
    {
        Add("Logic", "LogicProcessor");
        Add("Sequence", "SequenceProcessor");
        Add("Key", "KeyProcessor");
        Add("KeyVector", "KeyVectorProcessor");
        Add("Mouse", "MouseProcessor");
        Add("Pad", "PadProcessor");
        Add("PadVector", "PadVectorProcessor");
    }

    public static TestMap Map
    {
        get { return map; }
    }

    public IEnumerable<TestContent> Collect(XElement xe, ContentProcessorContext cpc)
    {
        foreach(var e in xe.Elements().Where(e => ContainsKey(e.Name.ToString()))) 
        {
            yield return cpc.Convert<XElement, TestContent>(
                e, this[e.Name.ToString()]);
        }
    }
}

我更进了一步，为每种类型的TestBase创建了内容处理器：

/// <summary>
/// Turns an imported XElement into a TestContent used for a LogicTest
/// </summary>
[ContentProcessor(DisplayName = "LogicProcessor")]
public class LogicProcessor : ContentProcessor<XElement, TestContent>
{
    public override TestContent Process(XElement input, ContentProcessorContext context)
    {
        var result = new TestContent(input);
        string key = "Or";
        input.GetAttribute("op", key);
        result.args.Add("key", key);
        var items = TestMap.Map.Collect(input, context);
        if (items.Count() < 2) throw new ArgumentNullException(
              "LogicProcessor requires at least two items.");
        result.args.Add("items", items);
        return result;
    }
}

任何引用或访问类的尝试（如调用TestMap.Collect）都会生成基础静态类（如果需要）。我基本上将代码从LogicTest.Build移到了处理器。我还在处理器中执行任何所需的验证。

当我开始阅读这些课程时，我会让ContentService帮忙。

从XNA内容管道扩展中访问服务

1 个答案: