静态抽象方法的替代方法是什么？

Question

我在尝试找出如何解决问题而无法在抽象类或接口中使用静态方法时遇到一些问题。考虑以下代码。我有很多继承自 AbsWizard 的 Wizard。每个向导都有一个 GetMagic(stringpell) 方法，该方法仅返回某些魔法词的魔法，但特定类型向导的所有实例都会响应同一组魔法词。

public abstract class AbsWizard
{
    public abstract Magic GetMagic(String magicword);
    public abstract string[] GetAvalibleSpells();
}

public class WhiteWizard : AbsWizard
{
    public override Magic GetMagic(string magicword)
    {
        //returns some magic based on the magic word
    }

    public override string[] GetAvalibleSpells()
    {
        string[] spells = {"booblah","zoombar"};
        return spells;
    }
}

public class BlackWizard : AbsWizard
{
    public override Magic GetMagic(string magicword)
    {
        //returns some magic based on the magic word
    }

    public override string[] GetAvalibleSpells()
    {
        string[] spells = { "zoogle", "xclondon" };
        return spells;
    }
}

我希望用户能够首先选择向导的类型，然后显示该类型的向导可以施展的法术列表。然后，当他们选择咒语时，程序将找到所选类型的所有（如果有的话）现有巫师，并让他们施展所选咒语。特定类型的所有巫师将始终具有相同的可用法术，并且我需要一种方法来确定特定类型的巫师可以施放的法术，而无需实际访问所选巫师类型的实例。

此外，我不想依赖于可能的向导类型或咒语的单独列表。相反，我宁愿通过 GetAvalibleSpells() 和反射来推断一切。例如我计划施展魔法如下：

    public static void CastMagic()
    {
        Type[] types = System.Reflection.Assembly.GetExecutingAssembly().GetTypes();
        List<Type> wizardTypes = new List<Type>();
        List<string> avalibleSpells = new List<string>();

        Type selectedWizardType;
        string selectedSpell;

        foreach (Type t in types)
        {
            if (typeof(AbsWizard).IsAssignableFrom(t))
            {
                wizardTypes.Add(t);
            }
        }

        //Allow user to pick a wizard type (assign a value to selectedWizardType)

        //find the spells the selected type of wizard can cast (populate availibleSpells)

        //Alow user to pick the spell (assign a value to  selectedSpell)

        //Find all instances, if any exsist, of wizards of type selectedWizardType and call GetMagic(selectedSpell);
    }

Answer 1

我认为这是非常糟糕的风格。您编写了代码，因此您应该知道其中有哪些向导类。通过反射运行所有类型并检查它们是否派生自 AbsWizard 的方式非常糟糕（而且很慢！）。

Answer 2

托管扩展性框架（可通过 .NET-4.0 之前版本的 codeplex 或内置 .NET 4.0 获得）在 System.ComponentModel.Composition 命名空间）就是为此构建的。假设您有一个服务，它可以要求用户选择一个向导，然后创建它。它使用向导提供者来创建向导，并且需要知道提供者创建的向导的名称和可用咒语（元数据）。您可能会使用如下接口：

namespace Wizardry
{
    using System.Collections.Generic;

    public interface IWizardProvider
    {
        IWizard CreateWizard();
    }

    public interface IWizard
    {
        IMagic GetMagic(string magicWord);
    }

    public interface IWizardProviderMetadata
    {
        string Name { get; }

        IEnumerable<string> Spells { get; }
    }
}

向导创建服务导入可用的向导提供程序，通过某种机制（在您的情况下为用户反馈）选择一个提供程序，并使用该提供程序来创建向导。

namespace Wizardry
{
    using System;
    using System.Collections.Generic;
    using System.ComponentModel.Composition;
    using System.Linq;

    public class UserWizardCreationService
    {
        [Import]
        private IEnumerable<Lazy<IWizardProvider, IWizardProviderMetadata>> WizardProviders { get; set; }

        public IWizard CreateWizard()
        {
            IWizard wizard = null;
            Lazy<IWizardProvider, IWizardProviderMetadata> lazyWizardProvider = null;
            IWizardProvider wizardProvider = null;

            // example 1: get a provider that can create a "White Wizard"
            lazyWizardProvider = WizardProviders.FirstOrDefault(provider => provider.Metadata.Name == "White Wizard");
            if (lazyWizardProvider != null)
                wizardProvider = lazyWizardProvider.Value;

            // example 2: get a provider that can create a wizard that can cast the "booblah" spell
            lazyWizardProvider = WizardProviders.FirstOrDefault(provider => provider.Metadata.Spells.Contains("booblah"));
            if (lazyWizardProvider != null)
                wizardProvider = lazyWizardProvider.Value;

            // finally, for whatever wizard provider we have, use it to create a wizard
            if (wizardProvider != null)
                wizard = wizardProvider.CreateWizard();

            return wizard;
        }
    }
}

然后，您可以创建并导出任意数量的带有咒语的向导提供者，并且创建服务将能够找到它们：

namespace Wizardry
{
    using System.ComponentModel.Composition;

    [Export(typeof(IWizardProvider))]
    [Name("White Wizard")]
    [Spells("booblah", "zoombar")]
    public class WhiteWizardProvider : IWizardProvider
    {
        public IWizard CreateWizard()
        {
            return new WhiteWizard();
        }
    }

    [Export(typeof(IWizardProvider))]
    [Name("White Wizard")]
    [Spells("zoogle", "xclondon")]
    public class BlackWizardProvider : IWizardProvider
    {
        public IWizard CreateWizard()
        {
            return new BlackWizard();
        }
    }
}

当然，您还需要实现向导。

namespace Wizardry
{
    using System;

    public class WhiteWizard : IWizard
    {
        public IMagic GetMagic(string magicWord)
        {
            throw new NotImplementedException();
        }
    }

    public class BlackWizard : IWizard
    {
        public IMagic GetMagic(string magicWord)
        {
            throw new NotImplementedException();
        }
    }
}

为了保持简洁，此代码使用自定义 NameAttribute 和 SpellsAttribute 作为比 ExportMetadataAttribute：

namespace Wizardry
{
    using System;

    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = true)]
    public abstract class MultipleBaseMetadataAttribute : Attribute
    {
    }

    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
    public abstract class SingletonBaseMetadataAttribute : Attribute
    {
    }

    public sealed class NameAttribute : SingletonBaseMetadataAttribute
    {
        public NameAttribute(string value) { this.Name = value; }
        public string Name { get; private set; }
    }

    public sealed class SpellsAttribute : MultipleBaseMetadataAttribute
    {
        public SpellsAttribute(params string[] value) { this.Spells = value; }
        public string[] Spells { get; private set; }
    }
}

Answer 3

添加另一个间接级别。 GetAvailableSpells 方法并不是真正的实例方法，因为它对于所有实例都是相同的。正如您所指出的，您不能拥有抽象静态方法，因此请将特定于类型的内容移至基于实例的类工厂中。在下面的示例中，AvailableSpells 是 MagicSchool 抽象类的一个方法，该抽象类具有具体子类 BlackMagic、WhiteMagic Wizard 也有子类型，但每个 Wizard 都可以返回它所属的 MagicSchool，为您提供类型安全的，与类型无关的方式来找出任何给定 Wizard 对象的咒语，无需单独的表或代码重复。

public abstract class MagicSchool
{
    public abstract string[] AvailableSpells { get; }
    public abstract Wizard CreateWizard();
}

public abstract class Wizard
{
    protected Wizard(MagicSchool school)
    {
        School = school;
    }

    public abstract Cast(string spell);

    MagicSchool School 
    {
        public get; 
        protected set;
    }
}

public class BlackMagic : MagicSchool
{
    public override AvailableSpells
    {
        get
        {
            return new string[] { "zoogle", "xclondon" };
        }
    }

    public override Wizard CreateWizard()
    {
        return new BlackWizard(this);
    }
}

public class BlackWizard : Wizard
{
    public BlackWizard(BlackMagic school)
        : base(school)
    {
        // etc
    }

    public override Cast(string spell)
    {
        // etc.
    }
}

// continue for other wizard types

Answer 4

首先，您应该真正考虑是否不能改变不使用巫师实例来发现其可用咒语的规则。我发现 原型模式 对于这类事情实际上非常有用。

但是，如果您确实无法做到这一点，您可以使用嵌套类和反射来发现特定具体 AbsWizard 派生体可以施放的可用咒语。这是一个例子：

public abstract class AbsWizard
{
    public abstract Magic GetMagic(String magicword);
    public abstract string[] GetAvalibleSpells();
}

public class WhiteWizard : AbsWizard
{
    // organizes all the spells available to the wizard...
    public sealed class Spells
    {
        // NOTE: Spells may be better off as a specific class, rather than as strings.
        // Then you could decorate them with a lot of other information (cost, category, etc).
        public const string Abracadabra = "Abracadabra";
        public const string AlaPeanutButterSandwiches = "APBS";
    }
}

public static void CastMagic()
{
    Type[] types = System.Reflection.Assembly.GetExecutingAssembly().GetTypes();
    List<Type> wizardTypes = new List<string>();
    List<string> avalibleSpells = new List<string>();

    Type selectedWizardType;
    string selectedSpell;

    foreach (Type t in types)
    {
        if (typeof(AbsWizard).IsAssignableFrom(t))
        {
            // find a nested class named Spells and search it for public spell definitions
            // better yet, use an attribute to decorate which class is the spell lexicon
            var spellLexicon = Type.FromName( t.FullName + "+" + "Spells" );
            foreach( var spellField in spellLexicon.GetFields() )
               // whatever you do with the spells...
        }
    }
}

有很多方法可以改进上面的代码。

首先，您可以定义自己的自定义属性，您可以在每个向导的嵌套类上标记该属性以识别拼写词典。

其次，使用字符串来定义可用的咒语可能最终会受到一些限制。您可能会发现定义所有可用咒语的全局静态列表更容易（作为某种类，我们将其称为Spell）。然后，您可以根据此列表而不是字符串来定义向导的可用咒语。

第三，考虑为这个东西创建一个外部配置，而不是嵌入的嵌套类。它更灵活并且可能更容易维护。然而，编写如下代码可能会很好：

WhiteWizard.Spells.Abracadabra.Cast();

最后，考虑为每个向导派生创建一个静态字典来管理可用咒语列表，以便您可以避免多次执行反射（这是昂贵的）。

Answer 5

由于咒语与向导的类型相关，因此我将通过属性来执行此操作：

[AttributeUsage(AttributeTargets.Class)]
public class SpellsAttribute : Attribute
{
    private string[] spells;
    public WizardAttribute(params string[] spells)
    {
        this.spells = spells;
    }

    public IEnumerable<string> Spells
    {
        get { return this.spells ?? Enumerable.Empty<string>(); }
    }
}

然后您声明一个向导类型，如下所示：

[Spells("booblah","zoombar")]
public class WhiteWizard : AbsWizard
{
    public override Magic GetMagic(string magicWord) { ... }
}

然后从程序集中加载向导类型的类可以检查每个向导类是否具有此属性，如果是这样，则使可用的类型（或引发异常）。

Answer 6

这能满足您的需要吗？根据需要将每种类型的向导添加到工厂。向导永远不会在您的库之外实例化，而只会在库内实例化。对于图书馆外的人来说，要获得巫师，他们会致电工厂以获取支持给定咒语的巫师。工厂自己设立。只需向工厂注册每个新向导即可。

public class Magic
{
}

public abstract class AbsWizard
{
    public abstract Magic GetMagic(String magicword);
    public abstract string[] GetAvalibleSpells();

    internal AbsWizard()
    {
    }
}

public class WhiteWizard : AbsWizard
{
    public override Magic GetMagic(string magicword)
    {
        return new Magic();
    }

    public override string[] GetAvalibleSpells()
    {
        string[] spells = { "booblah", "zoombar" };
        return spells;
    }
}


public static class WizardFactory
{
    private static Dictionary<string, List<AbsWizard>> _spellsList = new Dictionary<string, List<AbsWizard>>();

    /// <summary>
    /// Take the wizard and add his spells to the global spell pool.  Then register him with that spell.
    /// </summary>
    /// <param name="wizard"></param>
    private static void RegisterWizard(AbsWizard wizard)
    {
        foreach (string s in wizard.GetAvalibleSpells())
        {
            List<AbsWizard> lst = null;
            if (!_spellsList.TryGetValue(s, out lst))
            {
                _spellsList.Add(s, lst = new List<AbsWizard>());
            }
            lst.Add(wizard);
        }
    }

    public string[] GetGlobalSpellList()
    {
        List<string> retval = new List<string>();
        foreach (string s in _spellsList.Keys)
        {
            retval.Add(s);
        }
        return retval.ToArray<string>();
    }

    public List<AbsWizard> GetWizardsWithSpell(string spell)
    {
        List<AbsWizard> retval = null;
        _spellsList.TryGetValue(spell, out retval);
        return retval;
    }

    static WizardFactory()
    {
        RegisterWizard(new WhiteWizard());
    }
}

Answer 7

使用工厂类来实例化您的向导。工厂有一个

public static string[] GetSpellsForWizardType(Type wizardType)

方法可以让你确定巫师可以施展哪些法术。工厂还调用相同的方法来构造一个新的向导实例并设置其法术集。