在Python编程中,Mark Lutz提到了术语mixin。我有C/ c++ / c#的背景,以前没有听说过这个术语。什么是mixin?
从这个例子的字里行间(我链接了这个例子,因为它很长),我假设这是一个使用多重继承来扩展类的情况,而不是适当的子类化。这样对吗?
为什么我要这样做,而不是把新功能放到一个子类?就此而言,为什么混合/多重继承方法会比使用组合更好呢?
mixin与多重继承的区别是什么?这只是语义上的问题吗?
在Python编程中,Mark Lutz提到了术语mixin。我有C/ c++ / c#的背景,以前没有听说过这个术语。什么是mixin?
从这个例子的字里行间(我链接了这个例子,因为它很长),我假设这是一个使用多重继承来扩展类的情况,而不是适当的子类化。这样对吗?
为什么我要这样做,而不是把新功能放到一个子类?就此而言,为什么混合/多重继承方法会比使用组合更好呢?
mixin与多重继承的区别是什么?这只是语义上的问题吗?
当前回答
我只是使用一个python mixin来实现python milters的单元测试。通常情况下,milter会与MTA交谈,这使得单元测试变得困难。测试mixin覆盖了与MTA对话的方法,并创建了一个由测试用例驱动的模拟环境。
所以,你使用一个未修改的milter应用程序,比如spfmilter,然后mixin TestBase,像这样:
class TestMilter(TestBase,spfmilter.spfMilter):
def __init__(self):
TestBase.__init__(self)
spfmilter.config = spfmilter.Config()
spfmilter.config.access_file = 'test/access.db'
spfmilter.spfMilter.__init__(self)
然后,在milter应用程序的测试用例中使用TestMilter:
def testPass(self):
milter = TestMilter()
rc = milter.connect('mail.example.com',ip='192.0.2.1')
self.assertEqual(rc,Milter.CONTINUE)
rc = milter.feedMsg('test1',sender='good@example.com')
self.assertEqual(rc,Milter.CONTINUE)
milter.close()
http://pymilter.cvs.sourceforge.net/viewvc/pymilter/pymilter/Milter/test.py?revision=1.6&view=markup
其他回答
首先,您应该注意,mixin只存在于多继承语言中。你不能在Java或c#中做mixin。
基本上,mixin是一个独立的基类型,为子类提供有限的功能和多态共振。如果你在用c#思考,考虑一个你不需要实际实现的接口,因为它已经实现了;你只是继承了它,并从它的功能中受益。
mixin的范围通常很窄,不需要扩展。
[编辑——至于为什么:]
既然你问了,我想我该解释一下原因。最大的好处是你不需要自己一遍又一遍地做。在c#中,mixin最大的好处可能来自于处置模式。无论何时实现IDisposable,您几乎总是希望遵循相同的模式,但最终要编写和重写相同的基本代码,只是略有变化。如果有一个可扩展的处置mixin,您可以节省大量额外的输入。
[编辑2 -回答你的其他问题]
mixin与多重继承的区别是什么?这只是语义上的问题吗?
是的。mixin和标准多重继承之间的区别只是语义上的问题;具有多重继承的类可以利用mixin作为多重继承的一部分。
mixin的目的是创建一个可以通过继承“混合”到任何其他类型的类型,而不影响继承类型,同时仍然为该类型提供一些有益的功能。
同样,考虑一个已经实现的接口。
我个人不使用mixins,因为我主要是用一种不支持mixins的语言开发的,所以我很难想出一个像样的例子来为您提供“啊哈!”的时刻。但我会再试一次。我将使用一个人为设计的示例——大多数语言已经以某种方式提供了该特性——但希望这将解释mixin应该如何创建和使用。是:
Suppose you have a type that you want to be able to serialize to and from XML. You want the type to provide a "ToXML" method that returns a string containing an XML fragment with the data values of the type, and a "FromXML" that allows the type to reconstruct its data values from an XML fragment in a string. Again, this is a contrived example, so perhaps you use a file stream, or an XML Writer class from your language's runtime library... whatever. The point is that you want to serialize your object to XML and get a new object back from XML.
本例中另一个重要的一点是,您希望以通用的方式执行此操作。你不希望为你想要序列化的每一个类型都实现一个“ToXML”和“FromXML”方法,你需要一些通用的方法来确保你的类型能够做到这一点,并且它只是工作。您希望代码重用。
如果您的语言支持它,您可以创建XmlSerializable mixin来完成您的工作。这种类型将实现ToXML和FromXML方法。它将使用一些对示例不重要的机制,能够从混合在其中的任何类型收集所有必要的数据,以构建由ToXML返回的XML片段,并且在调用FromXML时同样能够恢复该数据。
和. .就是这样。要使用它,您需要从XmlSerializable继承任何需要序列化为XML的类型。每当需要序列化或反序列化该类型时,只需调用ToXML或FromXML即可。事实上,由于XmlSerializable是一种成熟的多态类型,因此可以想象,您可以构建一个文档序列化器,它对原始类型一无所知,只接受一个XmlSerializable类型数组。
现在想象一下将这个场景用于其他事情,比如创建一个mixin,以确保每个混合它的类都记录每个方法调用,或者为混合它的类型提供事务性的mixin。这样的例子不胜枚举。
如果您只是将mixin视为一个小型的基本类型,用于在不影响类型的情况下向类型添加少量功能,那么您就很好了。
希望。:)
也许ruby中的一个例子会有所帮助:
你可以包含mixin Comparable并定义一个函数"<=>(other)", mixin提供了所有这些函数:
<(other)
>(other)
==(other)
<=(other)
>=(other)
between?(other)
它通过调用<=>(other)并返回正确的结果来实现这一点。
"instance <=> other"如果两个对象相等则返回0,如果instance大于other则返回小于0,如果other大于0则返回大于0。
大致总结一下上面所有的好答案:
States / Methods | Concrete Method | Abstract Method |
---|---|---|
Concrete State | Class | Abstract Class |
Abstract State | Mixin | Interface |
Mixin提供了一种在类中添加功能的方法,即您可以通过将模块包含在所需的类中来与模块中定义的方法进行交互。虽然ruby不支持多重继承,但提供了mixin作为实现这一目标的替代方案。
下面是一个示例,说明如何使用mixin实现多重继承。
module A # you create a module
def a1 # lets have a method 'a1' in it
end
def a2 # Another method 'a2'
end
end
module B # let's say we have another module
def b1 # A method 'b1'
end
def b2 #another method b2
end
end
class Sample # we create a class 'Sample'
include A # including module 'A' in the class 'Sample' (mixin)
include B # including module B as well
def S1 #class 'Sample' contains a method 's1'
end
end
samp = Sample.new # creating an instance object 'samp'
# we can access methods from module A and B in our class(power of mixin)
samp.a1 # accessing method 'a1' from module A
samp.a2 # accessing method 'a2' from module A
samp.b1 # accessing method 'b1' from module B
samp.b2 # accessing method 'a2' from module B
samp.s1 # accessing method 's1' inside the class Sample
mixin与多重继承的区别是什么?这只是语义上的问题吗?
mixin是一种有限形式的多重继承。在某些语言中,向类中添加mixin的机制(就语法而言)与继承的机制略有不同。
特别是在Python上下文中,mixin是一个父类,它为子类提供功能,但并不打算自己被实例化。
你可能会说,“这只是多重继承,而不是真正的mixin”,因为可能被混淆为mixin的类实际上可以被实例化和使用——所以这确实是语义上的,而且非常真实的区别。
多重继承示例
这个例子,来自文档,是一个OrderedCounter:
类OrderedCounter(计数器,OrderedDict): “计数器,记住第一次遇到的顺序元素” def __repr__(自我): 返回'%s(%r)' % (self.__class__. zip)。__name__ OrderedDict(自我) def __reduce__(自我): 回归自我。__class__进行(OrderedDict(自我),)
它从集合模块继承了Counter和OrderedDict。
Counter和OrderedDict都打算被实例化并单独使用。然而,通过将它们都子类化,我们可以拥有一个有序的计数器,并重用每个对象中的代码。
这是一种重用代码的强大方法,但也可能产生问题。如果发现其中一个对象存在bug,那么不加注意地修复它可能会在子类中创建一个bug。
Mixin的例子
mixin通常被推广为一种获得代码重用的方式,而不会出现协作多重继承(如OrderedCounter)可能存在的潜在耦合问题。当您使用mixin时,您使用的功能与数据不是紧密耦合的。
与上面的例子不同,mixin不打算单独使用。它提供了新的或不同的功能。
例如,标准库在socketserver库中有两个mixin。
可以创建每种类型服务器的分叉和线程版本 使用这些混合类。例如,ThreadingUDPServer是 创建如下: 类ThreadingMixIn, UDPServer: 通过 mix-in类首先出现,因为它覆盖了定义在 UDPServer。设置各种属性还会改变的行为 底层服务器机制。
在这种情况下,mixin方法覆盖UDPServer对象定义中的方法,以实现并发性。
重写的方法似乎是process_request,它还提供了另一个方法process_request_thread。这是来自源代码:
class ThreadingMixIn: """Mix-in class to handle each request in a new thread.""" # Decides how threads will act upon termination of the # main process daemon_threads = False def process_request_thread(self, request, client_address): """Same as in BaseServer but as a thread. In addition, exception handling is done here. """ try: self.finish_request(request, client_address) except Exception: self.handle_error(request, client_address) finally: self.shutdown_request(request) def process_request(self, request, client_address): """Start a new thread to process the request.""" t = threading.Thread(target = self.process_request_thread, args = (request, client_address)) t.daemon = self.daemon_threads t.start()
一个虚构的例子
这是一个主要用于演示目的的mixin -大多数对象将会进化到超出这个repr的有用性:
class SimpleInitReprMixin(object):
"""mixin, don't instantiate - useful for classes instantiable
by keyword arguments to their __init__ method.
"""
__slots__ = () # allow subclasses to use __slots__ to prevent __dict__
def __repr__(self):
kwarg_strings = []
d = getattr(self, '__dict__', None)
if d is not None:
for k, v in d.items():
kwarg_strings.append('{k}={v}'.format(k=k, v=repr(v)))
slots = getattr(self, '__slots__', None)
if slots is not None:
for k in slots:
v = getattr(self, k, None)
kwarg_strings.append('{k}={v}'.format(k=k, v=repr(v)))
return '{name}({kwargs})'.format(
name=type(self).__name__,
kwargs=', '.join(kwarg_strings)
)
用法是:
class Foo(SimpleInitReprMixin): # add other mixins and/or extend another class here
__slots__ = 'foo',
def __init__(self, foo=None):
self.foo = foo
super(Foo, self).__init__()
和用法:
>>> f1 = Foo('bar')
>>> f2 = Foo()
>>> f1
Foo(foo='bar')
>>> f2
Foo(foo=None)