0

是否有一种优雅的（或任何）方法可以在 C# 中实现以下目标？

  • 让我们有一个不允许直接实例化（非公共构造）的类ItemBase（进一步可派生为Item1， ...） - 以防止用户创建任何“未跟踪”的.Item2Item*
  • 让我们有一个非静态类Manager，它的实例（允许多个）只能创建和提供实例Item*（因为它们会跟踪生成的实例并做一些额外的工作）。
  • 让我们有一个可选要求：Manager实例想要操纵托管Item实例的非公共成员（类似于Managera friendof Item*）。
  • 如果Manager不强迫 是 的推导，那就太好了Item*。
  • 如果反射越少越好。

笔记：

  • 如果可能，请将此视为思考如何以最佳和优雅的方式实施特定问题解决方案的过程中提出的问题。我希望它是通用的，不，我没有资源，是的，我已经尝试了一些变体，但没有一个能满足我的需求。谢谢你。

  • 据我所知，没有可接受friend的替代方法（任何一种似乎都很好），所以internal只是提供了“特殊”（但公开）的修改方法，用户必须知道，这些方法不适合他：o (InternalsVisibleToAttributeItemBase

  • 我喜欢这个解决方案，但我无法发明如何允许多个Manager实例使用它。

4

2 回答 2

0

好吧，放弃。如果这可能有助于完全理解目的，那么我（目前）最终得到的解决方案不太糟糕。传递创建函数是通过静态构造函数（用户无法访问）完成的，不幸的是，丑陋的是它们的调用......

知道如何让它变得更好吗？

项目定义： 

namespace SpecialFactory
{
    public enum ItemType
    {
        Item1,
        Item2,
        // ... Anyone deriving the Item* should add an item here
    }

    public abstract class ItemBase
    {
        public abstract ItemType Id {get;}

        public static void RegisterAllCreators()
        {
            // Force static constructors invocation
            var it = Item1.ClassId | Item2.ClassId; // Anyone deriving the Item* should ensure invocation of Manager.RegisterCreator
        }
    }

    public class Item1 : ItemBase
    {
        static Item1()
        {
            Manager.RegisterCreator(ItemType.Item1, () => new Item1());
        }

        protected Item1()
        {
        }

        public static   ItemType ClassId => ItemType.Item1;
        public override ItemType Id      => ClassId;
    }

    public class Item2 : ItemBase
    {
        static Item2()
        {
            Manager.RegisterCreator(ItemType.Item2, () => new Item2());
        }

        protected Item2()
        {
        }

        public static   ItemType ClassId => ItemType.Item2;
        public override ItemType Id      => ClassId;
    }
}

管理者：

namespace SpecialFactory
{
    public class Manager
    {
        static Manager()
        {
            ItemBase.RegisterAllCreators();
        }

        protected static Dictionary<ItemType, Func<ItemBase>> creators = new Dictionary<ItemType, Func<ItemBase>>();
        protected readonly List<ItemBase> managedItems = new List<ItemBase>();

        protected ItemBase CreateItem(ItemType type)
        {
            ItemBase item = null;

            if (creators.ContainsKey(type))
            {
                if ((item = creators[type]()) != null)
                    managedItems.Add(item);
            }

            return item;    
        }

        public static void RegisterCreator(ItemType type, Func<ItemBase> creator)
        {
            if (!creators.ContainsKey(type))
                creators[type] = creator;
        }

        public Manager()
        {

        }

        public ItemBase Test(ItemType type)
        {
            // var notAllowed = new Item1();
            var allowed = CreateItem(type);

            return allowed;
        }
    }
}

考试：

namespace SpecialFactory
{
    class Program
    {
        static void Main(string[] args)
        {
            var m1 = new Manager();
            var m2 = new Manager();

            var i1 = m1.Test(ItemType.Item1);
            var i2 = m2.Test(ItemType.Item2);
        }
    }
}
于 2015-09-11T15:36:26.483 回答
0

我认为这可能会回答您的问题：

public class ItemBase

{
    protected ItemBase()
    {

    }
    public void PublicMethod() { }
    public int PublicProperty { get; set; }
}

public class Factory
{
    private class PrivateItemBase : ItemBase
    {
        public void PrivateMethod() { }
        public int PrivateProperty { get; set; }
    }

    public Factory(int id)
    {

    }

    public IEnumerable<ItemBase> Items { get; private set; }
    public ItemBase CreateItem()
    {
        PrivateItemBase rValue = new PrivateItemBase();

        rValue.PrivateMethod();
        rValue.PrivateProperty = 4;

        return rValue;
    }
}
于 2015-09-11T15:00:18.723 回答