Question

我正在研究一些代码来组织我们的事件定义/类别映射。我们的目标是能够定义“事件名称”以及关联类别，它几乎是一个静态过程。我们想要的是人们使用常量而不是一堆字符串到处都是。我们还需要在某处验证事件/类别，以及执行一些查找操作，例如按类别获取事件，反之亦然。

class EventMapping(object)
    def __init__(self, name, categories):
        self.name =  name
        self.categories=  categories
        EventRegistry.register(self)

    def __eq__(self, obj):
        if(isinstance(obj, str)):
            return obj==self.name
        if(isinstance(obj, EventMapping)):
            return obj.name ==self.name 
               and obj.categories==self.categories
        return False

    def __repr__(self):
        return self.name   

class Event():
    class MyCompontent():
        ComponentEvent = EventMapping("ComponentEvent", None)
        ComponentEventWCategory = EventMapping("ComponentEvent"
             , [Category.MyComponent.Useful])
    class Data():
         Created =EventMapping("Created", [Category.Data.All, Category.Data.Count]
         Updated= EventMapping("Updated", [Category.Data.All]
         Deleted= EventMapping("Deleted", [Category.Data.All, Category.Data.Count]

class Category():
    class MyComponent():
        Useful = "Useful"
    class Data():
        All= "All" 
        Count= "Count" 

class EventRegistry():
    @staticmethod
    def register( eventMapping):
        eventName= eventMapping.name
        #store locally...

    @staticmethod
    def events(category):
        #retreive events by category

    @staticmethod
    def category(event_name):
        #retreive categories by event name

有几件我不喜欢的事情：

在EventRegistry类中，我将它们存储两次，一次在Event Dictionary键中作为名称，并且值为一个类别列表。第二个是由类别名称和事件列表键入的相反类别字典。有没有更好的方法来实现这一目标？我基本上需要一种简单的方法来查找名称或类别。
我应该创建两个注册表吗？一个用于活动的第一类？
在使用事件时我们会这样做：

self.subscribe(Event.MyComponent.Useful) self.subscribe(Category.MyComponent.Useful)

然后我们使用注册表来验证事件是否存在，以及传递消息。是否有更简单的方法来实现像名称空间一样的包？

只是寻找一些关于更好的方法的反馈，或者要遵循的模式。我四处搜寻，找不到任何东西。即使你知道某些模块，我可以看一看并更好地了解更好的方法，但也很高兴看到它。

Answer 1

你为什么不去something more pythonic？

from collections import defaultdict


_linked = defaultdict(set)


class Linkable(object):

    def link(self, *others):
        _linked[self].update(others)
        for each in others:
            _linked[each].add(self)

    def unlink(self, *others):
        _linked[self].difference_update(others)
        for each in others:
            _linked[each].discard(self)

    def links(self):
        return set(_linked[self])


class NameHierarchy(object):

    def __init__(self, name, parent=None):
        self.name = name
        self.parent = parent or self
        self.path = parent.path + [self] if parent else [self]

    def __str__(self):
        return '.'.join(each.name for each in self.path)

    def add(self, name):
        if name not in self.__dict__:
            setattr(self, name, self.__class__(name, self))


class LinkedNameHierarchy(Linkable, NameHierarchy):
    pass


Category = LinkedNameHierarchy('Category')

Category.add('MyComponent')
Category.MyComponent.add('Useful')

Category.add('Data')
Category.Data.add('All')
Category.Data.add('Count')

Event = LinkedNameHierarchy('Event')

Event.add('MyComponent')
Event.MyComponent.add('ComponentEvent')
Event.MyComponent.add('ComponentEventWCategory')

Event.MyComponent.ComponentEventWCategory.link(Category.MyComponent.Useful)

Event.add('Data')
Event.Data.add('Created')
Event.Data.add('Updated')
Event.Data.add('Deleted')

Event.Data.Created.link(Category.Data.All, Category.Data.Count)
Event.Data.Updated.link(Category.Data.All)
Event.Data.Deleted.link(Category.Data.All, Category.Data.Count)


def show_links():
    print
    print '----8<--------8<--------8<--------8<--------8<--------8<----'
    for k, v in sorted(_linked.iteritems(), key=lambda x:str(x[0])):
        print
        print k
        for each in sorted(v, key=str):
            print '        ', each

show_links()

Event.Data.Created.unlink(Category.Data.Count)

show_links()

存在循环引用，通常会导致内存泄漏。在这种情况下，它是可以的，因为无论如何，只要proram运行，这些对象可能会存在。

Python事件类别映射设计

1 个答案: