委托书涉及不涉及归属的问题？_百度知道
委托书涉及不涉及归属的问题？
我有更好的答案
他委托别人也要签委托书，还不如直接在合同上签字呢！再说，他委托你们的合伙人就更不合适了。
采纳率：64%
来自团队：
为您推荐：
其他类似问题
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。最高法院:不符合土地竞买条件而委托他人竞买属恶意串通!已签署的成交确认书无效!
我的图书馆
最高法院:不符合土地竞买条件而委托他人竞买属恶意串通!已签署的成交确认书无效!
本文由作者赐稿并授权民商事裁判规则公众号重新编辑整理，转载须在文首醒目注明作者和来源(侵权必究)。&&最高人民法院因不符合土地竞买条件而委托他人参加竞买的行为属于恶意串通，所签署的成交确认书无效杨巍& &裁判要旨国有土地使用权招标、拍卖、挂牌中，当事人因不符合竞买条件而委托他人参与竞买土地的行为属于恶意串通，根据《招标拍卖挂牌出让国有建设用地使用权规定》第二十五条的规定，受托人与国土资源局签署的成交确认书无效。&案情简介一、莱芜市国土资源局拍卖一宗土地，莱芜正顺公司因拖欠政府土地出让金不符合竞买条件，故由山东正顺集团和魏晓东签署协议，委托魏晓东参与竞买，竞得后由莱芜正顺公司进行开发建设。后魏晓东竞得该宗土地，与莱芜市国土资源局签署成交确认书。&二、原审法院判决确认莱芜市国土资源局与魏晓东签署的成交确认书无效。&三、魏晓东不服，向最高法院申请再审。最高法院认为魏晓东的再审申请不符合《中华人民共和国行政诉讼法》（1990年版）第六十三条第二款的规定，决定不对该案提起再审。&败诉原因最高法院认定魏晓东与莱芜市国土资源局签署的成交确认书无效的原因在于，莱芜正顺公司因拖欠政府土地出让金不符合竞买条件，委托魏晓东参与竞买，这一行为属于恶意串通参与竞买。根据《招标拍卖挂牌出让国有建设用地使用权规定》第二十五条的规定，中标人、竞得人采取行贿、恶意串通等非法手段中标或者竞得的，中标、竞得结果无效。因此，案涉土地成交确认书因违反了上述规定而无效。&败诉教训、经验总结前事不忘、后事之师。为避免未来发生类似败诉，提出如下建议：一、根据《招标拍卖挂牌出让国有建设用地使用权规定》第二十五条的规定，中标人、竞得人有下列行为之一的，中标、竞得结果无效：（1）提供虚假文件隐瞒事实的；（2）采取行贿、恶意串通等非法手段中标或者竞得的。据此，当事人参加土地竞买过程中实施上述行为的，成交确认书无效。&二、目前司法实践倾向于认同国有土地使用权招标、拍卖、挂牌中国土资源部门与竞得人签署成交确认书形成的是行政法律关系。根据《中华人民共和国行政诉讼法》第六十三条的规定，“人民法院审理行政案件，以法律和行政法规、地方性法规为依据。……人民法院审理行政案件，参照规章。”因《招标拍卖挂牌出让国有建设用地使用权规定》是国土资源部出台的规章，故可参照该规定认定成交确认书的效力。&相关法律规定《招标拍卖挂牌出让国有建设用地使用权规定》第二十五条& 中标人、竞得人有下列行为之一的，中标、竞得结果无效；造成损失的，应当依法承担赔偿责任：（一）提供虚假文件隐瞒事实的；（二）采取行贿、恶意串通等非法手段中标或者竞得的。&《中华人民共和国行政诉讼法》（1990年版）第六十三条& 人民法院院长对本院已经发生法律效力的判决、裁定，发现违反法律、法规规定认为需要再审的，应当提交审判委员会决定是否再审。上级人民法院对下级人民法院已经发生法律效力的判决、裁定，发现违反法律、法规规定的，有权提审或者指令下级人民法院再审。&《中华人民共和国行政诉讼法》（2017年版）第九十二条& 各级人民法院院长对本院已经发生法律效力的判决、裁定，发现有本法第九十一条规定情形之一，或者发现调解违反自愿原则或者调解书内容违法，认为需要再审的，应当提交审判委员会讨论决定。最高人民法院对地方各级人民法院已经发生法律效力的判决、裁定，上级人民法院对下级人民法院已经发生法律效力的判决、裁定，发现有本法第九十一条规定情形之一，或者发现调解违反自愿原则或者调解书内容违法的，有权提审或者指令下级人民法院再审。&以下为该案在最高法院审理阶段，裁判文书中“本院认为”部分就该问题的论述《招标拍卖挂牌出让国有建设用地使用权规定》第二十五条规定：“中标人、竞得人有下列行为之一的，中标、竞得结果无效; 造成损失的，应当依法承担赔偿责任：(一)提供虚假文件隐瞒事实的；(二)采取行贿、恶意串通等非法手段中标或者竞得的。”本案中，根据一审法院对你的调查材料以及你与山东正顺建设集团有限公司签订的协议看，你参加竞买的目的不是竞得后自己进行开发建设，而是由莱芜市正顺房地产开发有限公司进行开发建设，莱芜正顺公司因拖欠政府土地出让金不符合竞买条件，由山东正顺集团和你签署协议，委托你参与竞买，这一行为属于恶意串通参与竞买。依据上述事实和规定，原审判决确认莱芜市国土资源局与你签署的成交确认书无效并无不当。至于你提出的原审判决程序违法以及被申诉人为非法低价获得土地利用各种手段排斥竞争等申诉理由，没有提供相关证据予以证实,依法难以支持。&案件来源魏晓东与莱芜市泰和房地产开发有限公司、莱芜市国土资源局土地行政拍卖驳回再审申请通知书，[最高人民法院(2013)行监字第64号]。作者简介
馆藏&21877
TA的最新馆藏
喜欢该文的人也喜欢Trying to create two dictionaries of emitted delegates to allow for improved performance when dynamically getting/setting the values of properties.
Properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance)
.Where(p =& p.CanRead && !p.GetIndexParameters().Any())
.AsEnumerable();
PropertyGetters = Properties.ToDictionary(p =& p.Name, p =& (Func&object, object&)Delegate.CreateDelegate(typeof(Func&object, object&), p.GetGetMethod()));
PropertySetters = Properties.Where(p =& p.GetSetMethod() != null)
.ToDictionary(p =& p.Name, p =& (Action&object, object&)Delegate.CreateDelegate(typeof(Action&object, object&), p.GetSetMethod()));
However I get the following exception:
Cannot bind to the target method because its signature or security
transparency is not compatible with that of the delegate type.
From what I have read this will be caused by static/indexed/value type properties, the Properties collection contains no static or indexed properties but I do however need this to work for value type properties such as int and double.
How can I create the getters/setters that I need while keeping my code abstract and avoiding generics?
解决方案 Ok ended up finding my answer from this question:
More specifically this article:
Here is the jist of the code that I ended up with:
public class Helper
private IDictionary&string, Func&object, object&& PropertyGetters { }
private IDictionary&string, Action&object, object&& PropertySetters { }
public static Func&object, object& CreateGetter(PropertyInfo property)
if (property == null)
throw new ArgumentNullException("property");
var getter = property.GetGetMethod();
if (getter == null)
throw new ArgumentException("The specified property does not have a public accessor.");
var genericMethod = typeof(Helper).GetMethod("CreateGetterGeneric");
MethodInfo genericHelper = genericMethod.MakeGenericMethod(property.DeclaringType, property.PropertyType);
return (Func&object, object&)genericHelper.Invoke(null, new object[] { getter });
public static Func&object, object& CreateGetterGeneric&T, R&(MethodInfo getter) where T : class
Func&T, R& getterTypedDelegate = (Func&T, R&)Delegate.CreateDelegate(typeof(Func&T, R&), getter);
Func&object, object& getterDelegate = (Func&object, object&)((object instance) =& getterTypedDelegate((T)instance));
return getterD
public static Action&object, object& CreateSetter(PropertyInfo property)
if (property == null)
throw new ArgumentNullException("property");
var setter = property.GetSetMethod();
if (setter == null)
throw new ArgumentException("The specified property does not have a public setter.");
var genericMethod = typeof(Helper).GetMethod("CreateSetterGeneric");
MethodInfo genericHelper = genericMethod.MakeGenericMethod(property.DeclaringType, property.PropertyType);
return (Action&object, object&)genericHelper.Invoke(null, new object[] { setter });
public static Action&object, object& CreateSetterGeneric&T, V&(MethodInfo setter) where T : class
Action&T, V& setterTypedDelegate = (Action&T, V&)Delegate.CreateDelegate(typeof(Action&T, V&), setter);
Action&object, object& setterDelegate = (Action&object, object&)((object instance, object value) =& { setterTypedDelegate((T)instance, (V)value); });
return setterD
public Helper(Type type)
var Properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance)
.Where(p =& p.CanRead && !p.GetIndexParameters().Any()).AsEnumerable();
PropertyGetters = Properties.ToDictionary(p =& p.Name, p =& CreateGetter(p));
PropertySetters = Properties.Where(p =& p.GetSetMethod() != null)
.ToDictionary(p =& p.Name, p =& CreateSetter(p));
The generated delegates on average seem to be 80% faster than using reflection, so I am happy with the result!
本文地址： &
力图打造发射代表了两个词典，以便提高性能时，动态获取/设置属性的值。
属性= type.GetProperties（BindingFlags.Public | BindingFlags.Instance）
。凡（P =＆GT; p.CanRead和放大器;＆安培;！p.GetIndexParameters（）任何（）。）
.AsEnumerable（）;
PropertyGetters = Properties.ToDictionary（p值=＆GT; p.Name，p值=＆GT;（Func键＆所述;对象时，对象＆）Delegate.CreateDelegate（typeof运算（Func键＆所述;对象时，对象＆），p.GetGetMethod（）））;
PropertySetters = Properties.Where（P =＆GT;！p.GetSetMethod（）= NULL）
.ToDictionary（P =＆GT; p.Name，P =＆GT;（动作＆LT;对象，对象＆）Delegate.CreateDelegate（typeof运算（动作＆LT;对象，对象＆），p.GetSetMethod（）））;
不过，我得到以下异常：
无法绑定到目标方法，因为其签名或安全
透明度不与委托类型兼容。
从我读这会被静电/索引/值类型属性引起的，属性 collection不包含静态或索引的属性，但是，但是我确实需要这为值类型的属性，如 INT 和双。工作
我怎样才能创建的getter /我需要同时保持我的code抽象，避免仿制药制定者？
解决方案 确定最终从这个问题找到我的答案：
MethodInfo.Invoke 性能问题
更具体的这篇文章：
扫一扫关注官方微信class DelegatingCollection&T& : Collection&T& {
private val innerList = mutableListOf&T&()
override val size: Int
get() = innerList.size
override fun contains(element: T): Boolean = innerList.contains(element)
override fun containsAll(elements: Collection&T&): Boolean = innerList.addAll(elements)
override fun isEmpty(): Boolean = innerList.isEmpty()
override fun iterator(): Iterator&T& = innerList.iterator()
当你实现Collection接口的时候，需要重写这几个方法，这里面的代码量是很多的，但是如果用了委托，那么代码就是这样的
class DelegatingCollection2&T&(innerList: Collection&T& = mutableListOf&T&()) : Collection&T& by innerList
这么简单？就能实现那几个方法？我们来看一下生成的代码
是不是省去了很多手写的代码量，下面我们来介绍这种属性。
委托模式(Delegate)
Kotlin支持委托模式，是允许对象组合实现与继承相同的代码复用的，简单来说就是操作的对象不用自己去执行，而是将任务交给另一个对象操作，这样的模式就叫委托模式，被操作的对象叫委托。
委托模式是有两个对象参与处理同一个请求，接受请求的对象将请求委托给另一个对象来处理。
同样我们用上面集合的栗子，现在我们已经是委托到一个对象了，如果我们要修改集合里面的方法的时候，可以直接重写，而不用重复的去写新的方法，下面我们来在一个集合里面插入数据，并且获取插入的次数。
下面代码是默认实现MutableCollection接口，获取插入的次数
class DefaultCollection&T& : MutableCollection&T& {
private val innerList = mutableListOf&T&()
private var addedSum = 0
override fun add(element: T): Boolean {
addedSum++
return innerList.add(element)
override fun addAll(elements: Collection&T&): Boolean {
addedSum += elements.size
return innerList.addAll(elements)
override val size: Int
get() = innerList.size
override fun contains(element: T): Boolean = innerList.contains(element)
override fun containsAll(elements: Collection&T&): Boolean = innerList.addAll(elements)
override fun isEmpty(): Boolean = innerList.isEmpty()
override fun iterator(): MutableIterator&T& = innerList.iterator()
override fun clear() = innerList.clear()
override fun remove(element: T): Boolean = innerList.remove(element)
override fun removeAll(elements: Collection&T&): Boolean = innerList.removeAll(elements)
override fun retainAll(elements: Collection&T&): Boolean {
TODO("not implemented")
实现类委托
class DelegatingCollection3&T&(private val innerList: MutableCollection&T& = HashSet&T&()) : MutableCollection&T& by innerList {
private var addedSum = 0
override fun add(element: T): Boolean {
addedSum++
return innerList.add(element)
override fun addAll(elements: Collection&T&): Boolean {
addedSum += elements.size
return innerList.addAll(elements)
是不是省去很多无用的代码，只需要重写我们需要的方法add和addAll，其他没有写出来的方法全部都交给委托来实现。
而且没有对底层集合的实现方法引入任何的依赖，所以对被调用的操作具有完全的控制，如不用担心集合是不是通过循环中调用add来实现addAll。
委托属性(Delegate Properties)
有一种属性，在使用的时候每次都要手动实现它，但是可以做到只实现一次，并且放到库中，一直使用，这种属性称为委托属性。
委托属性包括：
- 延迟属性(lazy properties)：数据只在第一次被访问的时候计算。
- 可观察属性(observable properties)：监听得到属性变化通知。
- Map委托属性(Storing Properties in a Map)：将所有属性存在Map中。
class Foo {
var p: String by Delegate()
委托模式的语法是val/var &property name&: &Type& by &expression&在by后面的expression就是委托的部分，会将属性的get()和set()委托给getValue()和setValue()方法。
class Foo {
private val delegate = Delegate()
var p: String
set(value: String) = delegate.setValue(..., value)
get() = delegate.getValue(...)
委托属性不需要实现任何的接口，但是要提供getValue()方法(如果是var的话要提供setValue()方法)，方法前加operator关键字。
下面是一个自定义的Delegate类：
class Delegate {
operator fun getValue(thisRef: Any?, property: KProperty&*&): String {
return "$thisRef, thank you for delegating '${property.name}' to me!"
operator fun setValue(thisRef: Any?, property: KProperty&*&, value: String) {
println("$value has been assigned to '${property.name} in $thisRef.'")
当从委托属性p获取到Deletage的的实例时，Deletage的getValue就会被调用，getValue函数中的第一个参数就是p获取到的实例，第二个参数就是属性p。
val e = Example()
println(e.p)
打印出来的内容是：
Example@33a17727, thank you for delegating ‘p’ to me!
由于p是var类型的，所有可以调用setValue函数，前两个参数与getValue参数一样，第三个就是要赋予的值：
e.p = "NEW"
这下打印出来的内容就是：
NEW has been assigned to ‘p’ in Example@33a17727.
注意：自 Kotlin1.1起可以在函数或代码块中声明一个委托属性，因此委托属性不一定是类的成员
Kotlin的标准库中对于一些有用的委托提供了工厂(Factory)方法，这些接口在Kotlin标准库中声明。
interface ReadOnlyProperty&in R, out T& {
operator fun getValue(thisRef: R, property: KProperty&*&): T
interface ReadWriteProperty&in R, T& {
operator fun getValue(thisRef: R, property: KProperty&*&): T
operator fun setValue(thisRef: R, property: KProperty&*&, value: T)
延迟属性 Lazy
函数lazy()接收一个Lambdas表达式，然后并返回一个Lazy &T&的实例，它可以作为实现lazy属性的委托：第一次调用get()函数的时候会向执行Lambdas传递到lazy()函数，并且保存结果，后面调用的get()函数会直接返回报错的结果。
首先我们来看一个栗子，里面先不用到lazy，我们来看如何
fun loadName(person: Person): String {
println("Load Name for ${person.name}")
return person.name
fun loadAge(person: Person): Int {
println("Load Age for ${person.age}")
return person.age
class Person(val name: String, val age: Int) {
private var _names: String? = null
val newName: String
if (_names == null) {
_names = loadName(this)
return _names!!
private var _ages: Int? = null
val newAge: Int
if (_ages == null) {
_ages = loadAge(this)
return _ages!!
fun main(args: Array&String&) {
val p = Person("Alice", 23)
p.newName.println()
p.newName.println()
首先先判断_names是否为空，然后通过一个方法，里面进行了一些操作，来赋予_names值，最后newName的值即为_names。
打印的内容：
那么如果我们用lazy来代替这种写法会是什么样的呢？
fun loadName(person: Person): String {
fun loadAge(person: Person): Int {
class Person(val name: String) {
val newName by lazy { loadName(this) }
val newAge by lazy { loadAge(this) }
fun main(args: Array&String&) {
打印出来的内容，和上面是一模一样的。
对比一下，当我们的属性越来越多，那么重复的代码也就越来越多，使用lazy省去了很多多余的代码。
默认地，对于lazy属性的计算是加了同步锁（synchronized） 的： 这个值只在一个线程被计算，并且所有的线程会看到相同的值。
如果要将同步锁关闭，可以多个线程同步执行，就加LazyThreadSafetyMode.PUBLICATION参数即可：
val lazyValue: String by lazy(LazyThreadSafetyMode.PUBLICATION) {
println("computed!")
"Hello"
如果要关掉线程安全配置，就加LazyThreadSafetyMode.NONE参数即可：
val lazyValue: String by lazy(LazyThreadSafetyMode.NONE) {
println("computed!")
"Hello"
可观察属性 Observable
Delegates.observable()有两个参数：初始化值和handler，每次对属性赋值操作，都会回调该handler方法（在属性赋值后执行），该方法里面有三个参数，分别是：被赋值的属性，旧值和新值。
举个例子：
import kotlin.properties.Delegates
class User {
var name: String by Delegates.observable("&no name&") {
prop, old, new -&
println("$old -& $new")
fun main(args: Array&String&) {
val user = User()
user.name = "first"
user.name = "second"
在User类中，&no name&就是初始化值，{}包住的代码块就是handler方法，pro, old, new就是该方法的三个参数，打印出来的内容为：
&no name& -& first
first -& second
如果需要拦截修改属性值动作并禁止修改，可以使用vetoable()取代observable()，handler需要返回一个Boolean，true表示同意修改，false表示禁止修改，该回调会在属性值修改前调用。
将上面的例子里面的observable()修改为vetoable()后：
import kotlin.properties.Delegates
class User {
var name: String by Delegates.vetoable("&no name&") {
prop, old, new -&
println("$old -& $new")
fun main(args: Array&String&) {
val user = User()
user.name = "first"
user.name = "second"
打印的结果是：
如果改为true，那就跟observable()打印的一样了：
Map委托属性(Storing Properties in a Map)
可以用Map作为委托用于委托属性，多用于JSON解析上。
下面举个栗子，一个类里面有一个Map存放一些属性，通过setAttribute来设置这些属性：
class Person {
private val _attributes = hashMapOf&String, String&()
fun setAttribute(attrName: String, value: String) {
_attributes[attrName] = value
val name: String
get() = _attributes["name"]!!
val company: String
get() = _attributes["company"]!!
val address: String
get() = _attributes["address"]!!
val email: String
get() = _attributes["email"]!!
fun main(args: Array&String&) {
val p = Person()
val data = mapOf("name" to "Dmitry", "company" to "JetBrains")
for ((attrName, value) in data)
p.setAttribute(attrName, value)
println(p.name)
然后我们将这些属性委托给Map，再将代码简写一下
class Person2(private val attributes: Map&String, String&) {
val name: String by
attributes
val company: String by
attributes
val address: String by
attributes
val email: String by
attributes
fun main(args: Array&String&) {
val data = mapOf("name" to "Dmitry", "company" to "JetBrains")
val p = Person2(data)
println(p.name)
同样对比，省去重复代码，我们来看一下生成的代码是什么样子的：
public final class Person2 {
static final KProperty[] $$delegatedProperties = new KProperty[]{(KProperty)Reflection.property1(new PropertyReference1Impl(Reflection.getOrCreateKotlinClass(Person2.class), "name", "getName()Ljava/lang/S")), (KProperty)Reflection.property1(new PropertyReference1Impl(Reflection.getOrCreateKotlinClass(Person2.class), "company", "getCompany()Ljava/lang/S")), (KProperty)Reflection.property1(new PropertyReference1Impl(Reflection.getOrCreateKotlinClass(Person2.class), "address", "getAddress()Ljava/lang/S")), (KProperty)Reflection.property1(new PropertyReference1Impl(Reflection.getOrCreateKotlinClass(Person2.class), "email", "getEmail()Ljava/lang/S"))};
private final Map name$
private final Map company$
private final Map address$
private final Map email$
private final M
public final String getName() {
Map var1 = this.name$
KProperty var3 = $$delegatedProperties[0];
return (String)MapsKt.getOrImplicitDefaultNullable(var1, var3.getName());
public final String getCompany() {
Map var1 = this.company$
KProperty var3 = $$delegatedProperties[1];
return (String)MapsKt.getOrImplicitDefaultNullable(var1, var3.getName());
public final String getAddress() {
Map var1 = this.address$
KProperty var3 = $$delegatedProperties[2];
return (String)MapsKt.getOrImplicitDefaultNullable(var1, var3.getName());
public final String getEmail() {
Map var1 = this.email$
KProperty var3 = $$delegatedProperties[3];
return (String)MapsKt.getOrImplicitDefaultNullable(var1, var3.getName());
public Person2(@NotNull Map attributes) {
Intrinsics.checkParameterIsNotNull(attributes, "attributes");
this.attributes =
this.name$delegate = this.
this.company$delegate = this.
this.address$delegate = this.
this.email$delegate = this.
局部委托属性（1.1 起）
fun main(args: Array&String&) {
example("localDelegate")
fun example(value: String) {
val localDelegate by lazy {
print("first ")
localDelegate.println()
localDelegate.println()
现在，Kotlin支持局部委托属性。
委托属性要求
下面的代码是个委托类Delegate，里面有两个函数，一个是getValue函数，一个是setValue函数。
class Delegate {
operator fun getValue(thisRef: Any?, property: KProperty&*&): String {
return "$thisRef, thank you for delegating '${property.name}' to me!"
operator fun setValue(thisRef: Any?, property: KProperty&*&, value: String) {
println("$value has been assigned to '${property.name} in $thisRef.'")
只读属性（read-only，使用val定义）
委托类需提供getValue函数，参数要求：
- thisRef：第一个参数，必须是属性对应的类或父类型。(上面的thisRef: Any?)
- property：第二个参数，必须是“KProperty&*&”或它的父类型(上面的property: KProperty&*&)。
- 函数返回类型必须跟属性同类型（或者子类型）。
可变属性（mutable，使用var定义）
委托类需提供getValue函数和setValue函数，参数要求：
- thisRef：第一个参数，同getValue对应的参数
- property：第二个参数，同getValue对应的参数
- 新增(new value)：第三个参数，类型必须跟属性一样或其父类型。
getValue() 和setValue()函数可以作为委托类的成员函数或者扩展函数来使用。 当需要委托一个属性给一个不是原来就提供这些函数的对象的时候，后者更为方便。
两种函数都需要用operator关键字修饰。
委托类可以实现ReadOnlyPropery和ReadWriteProperty接口中的带operator的方法，这些接口在Kotlin标准库中声明：
interface ReadOnlyProperty&in R, out T& {
operator fun getValue(thisRef: R, property: KProperty&*&): T
interface ReadWriteProperty&in R, T& {
operator fun getValue(thisRef: R, property: KProperty&*&): T
operator fun setValue(thisRef: R, property: KProperty&*&, value: T)
提供委托（自 1.1 起）
provideDelegate为提供委托，它可以为属性提供对象委托逻辑，可能的使用场景是在创建属性时（而不仅在其 getter 或 setter 中）检查属性一致性。
provideDelegate 的参数与 getValue 相同：
- thisRef —— 必须与属性所有者类型（对于扩展属性——指被扩展的类型）相同或者是它的超类型。
- property —— 必须是类型 KProperty&*& 或其超类。
例如，在绑定之前检查属性名称：
class ResourceLoader(resId: ResourceID) {
operator fun provideDelegate(thisRef: MyUI, prop: KProperty&*&): ReadOnlyProperty&MyUI, String& {
checkProperty(thisRef, prop.name)
// 创建委托
private fun checkProperty(thisRef: MyUI, name: String) {
fun MyUI.bindResource(id: ResourceID): ResourceLoader {
return ResourceLoader(id)
class MyUI {
val image by bindResource(ResourceID.image_id) //bindResource()产生委托对象
val text by bindResource(ResourceID.text_id)
在创建 MyUI 实例期间，为每个属性调用provideDelegate方法，并立即执行必要的验证。
如果没有这种拦截属性与其委托之间的绑定的能力，为了实现相同的功能， 你必须显式传递属性名：
class MyUI {
val image by bindResource(ResourceID.image_id, "image")
val text by bindResource(ResourceID.text_id, "text")
fun &T& MyUI.bindResource(
id: ResourceID&T&,
propertyName: String
): ReadOnlyProperty&MyUI, T& {
checkProperty(this, propertyName)
由于暂时没用的这个提供委托，所以在这里也不过多的介绍，上面是官网的一个栗子。
一个委托实例
下面来看一个自定义的Delegate，用来访问SharedPreference，这段代码是Kotlin for Android Developer的示例：
class Preference&T&(val context: Context, val name: String, val default: T) : ReadWriteProperty&Any?, T& {
val prefs by lazy { context.getSharedPreferences("default", Context.MODE_PRIVATE) }
override fun getValue(thisRef: Any?, property: KProperty&*&): T {
return findPreference(name, default)
override fun setValue(thisRef: Any?, property: KProperty&*&, value: T) {
putPreference(name, value)
private fun &U& findPreference(name: String, default: U): U = with(prefs) {
val res: Any = when (default) {
is Long -& getLong(name, default)
is String -& getString(name, default)
is Int -& getInt(name, default)
is Boolean -& getBoolean(name, default)
is Float -& getFloat(name, default)
else -& throw IllegalArgumentException("This type can be saved into Preferences")
private fun &U& putPreference(name: String, value: U) = with(prefs.edit()) {
when (value) {
is Long -& putLong(name, value)
is String -& putString(name, value)
is Int -& putInt(name, value)
is Boolean -& putBoolean(name, value)
is Float -& putFloat(name, value)
else -& throw IllegalArgumentException("This type can be saved into Preferences")
使用的时候：
class ExampleActivity : AppCompatActivity(){
var a: Int by Preference(this, "a", 0)
fun whatever(){
println(a)
这样就很方便了，再也不用去重复写getSharedPreference()、commit()、edit()、apply()之类的东西了。
105 次点击 &
请尽量让自己的回复能够对别人有帮助
支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
支持 @ 本站用户；支持表情（输入 : 提示），见
记住登录状态
委托模式已经被证明是实现继承的一个很好的替代方式，在扩展一个基类并且重写方法时，基类就必须依赖子类的实现，当不断地修改的时候，基类就会失去当初的性质，Kotlin中就将类默认为final，确保不会被修改。
有一种模式是装饰器模式，本质就是创建一个新类，实现与基类一样的接口，并且将类的实现作为一个字段保存，这样就能在基类不被修改就能直接修改基类的实例。但是这样的缺点是会造成很多的样板代码。
class DelegatingCollection&T& : Collection&T& {
private val innerList = mutableListOf&T&()
override val size: Int
get() = innerList.size
override fun contains(element: T): Boolean = innerList.contains(element)
override fun containsAll(elements: Collection&T&): Boolean = innerList.addAll(elements)
override fun isEmpty(): Boolean = innerList.isEmpty()
override fun iterator(): Iterator&T& = innerList.iterator()
当你实现Collection接口的时候，需要重写这几个方法，这里面的代码量是很多的，但是如果用了委托，那么代码就是这样的
class DelegatingCollection2&T&(innerList: Collection&T& = mutableListOf&T&()) : Collection&T& by innerList
这么简单？就能实现那几个方法？我们来看一下生成的代码
是不是省去了很多手写的代码量，下面我们来介绍这种属性。
委托模式(Delegate)
Kotlin支持委托模式，是允许对象组合实现与继承相同的代码复用的，简单来说就是操作的对象不用自己去执行，而是将任务交给另一个对象操作，这样的模式就叫委托模式，被操作的对象叫委托。
委托模式是有两个对象参与处理同一个请求，接受请求的对象将请求委托给另一个对象来处理。
同样我们用上面集合的栗子，现在我们已经是委托到一个对象了，如果我们要修改集合里面的方法的时候，可以直接重写，而不用重复的去写新的方法，下面我们来在一个集合里面插入数据，并且获取插入的次数。
下面代码是默认实现MutableCollection接口，获取插入的次数
class DefaultCollection&T& : MutableCollection&T& {
private val innerList = mutableListOf&T&()
private var addedSum = 0
override fun add(element: T): Boolean {
addedSum++
return innerList.add(element)
override fun addAll(elements: Collection&T&): Boolean {
addedSum += elements.size
return innerList.addAll(elements)
override val size: Int
get() = innerList.size
override fun contains(element: T): Boolean = innerList.contains(element)
override fun containsAll(elements: Collection&T&): Boolean = innerList.addAll(elements)
override fun isEmpty(): Boolean = innerList.isEmpty()
override fun iterator(): MutableIterator&T& = innerList.iterator()
override fun clear() = innerList.clear()
override fun remove(element: T): Boolean = innerList.remove(element)
override fun removeAll(elements: Collection&T&): Boolean = innerList.removeAll(elements)
override fun retainAll(elements: Collection&T&): Boolean {
TODO("not implemented")
实现类委托
class DelegatingCollection3&T&(private val innerList: MutableCollection&T& = HashSet&T&()) : MutableCollection&T& by innerList {
private var addedSum = 0
override fun add(element: T): Boolean {
addedSum++
return innerList.add(element)
override fun addAll(elements: Collection&T&): Boolean {
addedSum += elements.size
return innerList.addAll(elements)
是不是省去很多无用的代码，只需要重写我们需要的方法add和addAll，其他没有写出来的方法全部都交给委托来实现。
而且没有对底层集合的实现方法引入任何的依赖，所以对被调用的操作具有完全的控制，如不用担心集合是不是通过循环中调用add来实现addAll。
委托属性(Delegate Properties)
有一种属性，在使用的时候每次都要手动实现它，但是可以做到只实现一次，并且放到库中，一直使用，这种属性称为委托属性。
委托属性包括：
- 延迟属性(lazy properties)：数据只在第一次被访问的时候计算。
- 可观察属性(observable properties)：监听得到属性变化通知。
- Map委托属性(Storing Properties in a Map)：将所有属性存在Map中。
class Foo {
var p: String by Delegate()
委托模式的语法是val/var &property name&: &Type& by &expression&在by后面的expression就是委托的部分，会将属性的get()和set()委托给getValue()和setValue()方法。
class Foo {
private val delegate = Delegate()
var p: String
set(value: String) = delegate.setValue(..., value)
get() = delegate.getValue(...)
委托属性不需要实现任何的接口，但是要提供getValue()方法(如果是var的话要提供setValue()方法)，方法前加operator关键字。
下面是一个自定义的Delegate类：
class Delegate {
operator fun getValue(thisRef: Any?, property: KProperty&*&): String {
return "$thisRef, thank you for delegating '${property.name}' to me!"
operator fun setValue(thisRef: Any?, property: KProperty&*&, value: String) {
println("$value has been assigned to '${property.name} in $thisRef.'")
当从委托属性p获取到Deletage的的实例时，Deletage的getValue就会被调用，getValue函数中的第一个参数就是p获取到的实例，第二个参数就是属性p。
val e = Example()
println(e.p)
打印出来的内容是：
Example@33a17727, thank you for delegating ‘p’ to me!
由于p是var类型的，所有可以调用setValue函数，前两个参数与getValue参数一样，第三个就是要赋予的值：
e.p = "NEW"
这下打印出来的内容就是：
NEW has been assigned to ‘p’ in Example@33a17727.
注意：自 Kotlin1.1起可以在函数或代码块中声明一个委托属性，因此委托属性不一定是类的成员
Kotlin的标准库中对于一些有用的委托提供了工厂(Factory)方法，这些接口在Kotlin标准库中声明。
interface ReadOnlyProperty&in R, out T& {
operator fun getValue(thisRef: R, property: KProperty&*&): T
interface ReadWriteProperty&in R, T& {
operator fun getValue(thisRef: R, property: KProperty&*&): T
operator fun setValue(thisRef: R, property: KProperty&*&, value: T)
延迟属性 Lazy
函数lazy()接收一个Lambdas表达式，然后并返回一个Lazy &T&的实例，它可以作为实现lazy属性的委托：第一次调用get()函数的时候会向执行Lambdas传递到lazy()函数，并且保存结果，后面调用的get()函数会直接返回报错的结果。
首先我们来看一个栗子，里面先不用到lazy，我们来看如何
fun loadName(person: Person): String {
println("Load Name for ${person.name}")
return person.name
fun loadAge(person: Person): Int {
println("Load Age for ${person.age}")
return person.age
class Person(val name: String, val age: Int) {
private var _names: String? = null
val newName: String
if (_names == null) {
_names = loadName(this)
return _names!!
private var _ages: Int? = null
val newAge: Int
if (_ages == null) {
_ages = loadAge(this)
return _ages!!
fun main(args: Array&String&) {
val p = Person("Alice", 23)
p.newName.println()
p.newName.println()
首先先判断_names是否为空，然后通过一个方法，里面进行了一些操作，来赋予_names值，最后newName的值即为_names。
打印的内容：
那么如果我们用lazy来代替这种写法会是什么样的呢？
fun loadName(person: Person): String {
fun loadAge(person: Person): Int {
class Person(val name: String) {
val newName by lazy { loadName(this) }
val newAge by lazy { loadAge(this) }
fun main(args: Array&String&) {
打印出来的内容，和上面是一模一样的。
对比一下，当我们的属性越来越多，那么重复的代码也就越来越多，使用lazy省去了很多多余的代码。
默认地，对于lazy属性的计算是加了同步锁（synchronized） 的： 这个值只在一个线程被计算，并且所有的线程会看到相同的值。
如果要将同步锁关闭，可以多个线程同步执行，就加LazyThreadSafetyMode.PUBLICATION参数即可：
val lazyValue: String by lazy(LazyThreadSafetyMode.PUBLICATION) {
println("computed!")
"Hello"
如果要关掉线程安全配置，就加LazyThreadSafetyMode.NONE参数即可：
val lazyValue: String by lazy(LazyThreadSafetyMode.NONE) {
println("computed!")
"Hello"
可观察属性 Observable
Delegates.observable()有两个参数：初始化值和handler，每次对属性赋值操作，都会回调该handler方法（在属性赋值后执行），该方法里面有三个参数，分别是：被赋值的属性，旧值和新值。
举个例子：
import kotlin.properties.Delegates
class User {
var name: String by Delegates.observable("&no name&") {
prop, old, new -&
println("$old -& $new")
fun main(args: Array&String&) {
val user = User()
user.name = "first"
user.name = "second"
在User类中，&no name&就是初始化值，{}包住的代码块就是handler方法，pro, old, new就是该方法的三个参数，打印出来的内容为：
&no name& -& first
first -& second
如果需要拦截修改属性值动作并禁止修改，可以使用vetoable()取代observable()，handler需要返回一个Boolean，true表示同意修改，false表示禁止修改，该回调会在属性值修改前调用。
将上面的例子里面的observable()修改为vetoable()后：
import kotlin.properties.Delegates
class User {
var name: String by Delegates.vetoable("&no name&") {
prop, old, new -&
println("$old -& $new")
fun main(args: Array&String&) {
val user = User()
user.name = "first"
user.name = "second"
打印的结果是：
如果改为true，那就跟observable()打印的一样了：
Map委托属性(Storing Properties in a Map)
可以用Map作为委托用于委托属性，多用于JSON解析上。
下面举个栗子，一个类里面有一个Map存放一些属性，通过setAttribute来设置这些属性：
class Person {
private val _attributes = hashMapOf&String, String&()
fun setAttribute(attrName: String, value: String) {
_attributes[attrName] = value
val name: String
get() = _attributes["name"]!!
val company: String
get() = _attributes["company"]!!
val address: String
get() = _attributes["address"]!!
val email: String
get() = _attributes["email"]!!
fun main(args: Array&String&) {
val p = Person()
val data = mapOf("name" to "Dmitry", "company" to "JetBrains")
for ((attrName, value) in data)
p.setAttribute(attrName, value)
println(p.name)
然后我们将这些属性委托给Map，再将代码简写一下
class Person2(private val attributes: Map&String, String&) {
val name: String by
attributes
val company: String by
attributes
val address: String by
attributes
val email: String by
attributes
fun main(args: Array&String&) {
val data = mapOf("name" to "Dmitry", "company" to "JetBrains")
val p = Person2(data)
println(p.name)
同样对比，省去重复代码，我们来看一下生成的代码是什么样子的：
public final class Person2 {
static final KProperty[] $$delegatedProperties = new KProperty[]{(KProperty)Reflection.property1(new PropertyReference1Impl(Reflection.getOrCreateKotlinClass(Person2.class), "name", "getName()Ljava/lang/S")), (KProperty)Reflection.property1(new PropertyReference1Impl(Reflection.getOrCreateKotlinClass(Person2.class), "company", "getCompany()Ljava/lang/S")), (KProperty)Reflection.property1(new PropertyReference1Impl(Reflection.getOrCreateKotlinClass(Person2.class), "address", "getAddress()Ljava/lang/S")), (KProperty)Reflection.property1(new PropertyReference1Impl(Reflection.getOrCreateKotlinClass(Person2.class), "email", "getEmail()Ljava/lang/S"))};
private final Map name$
private final Map company$
private final Map address$
private final Map email$
private final M
public final String getName() {
Map var1 = this.name$
KProperty var3 = $$delegatedProperties[0];
return (String)MapsKt.getOrImplicitDefaultNullable(var1, var3.getName());
public final String getCompany() {
Map var1 = this.company$
KProperty var3 = $$delegatedProperties[1];
return (String)MapsKt.getOrImplicitDefaultNullable(var1, var3.getName());
public final String getAddress() {
Map var1 = this.address$
KProperty var3 = $$delegatedProperties[2];
return (String)MapsKt.getOrImplicitDefaultNullable(var1, var3.getName());
public final String getEmail() {
Map var1 = this.email$
KProperty var3 = $$delegatedProperties[3];
return (String)MapsKt.getOrImplicitDefaultNullable(var1, var3.getName());
public Person2(@NotNull Map attributes) {
Intrinsics.checkParameterIsNotNull(attributes, "attributes");
this.attributes =
this.name$delegate = this.
this.company$delegate = this.
this.address$delegate = this.
this.email$delegate = this.
局部委托属性（1.1 起）
fun main(args: Array&String&) {
example("localDelegate")
fun example(value: String) {
val localDelegate by lazy {
print("first ")
localDelegate.println()
localDelegate.println()
现在，Kotlin支持局部委托属性。
委托属性要求
下面的代码是个委托类Delegate，里面有两个函数，一个是getValue函数，一个是setValue函数。
class Delegate {
operator fun getValue(thisRef: Any?, property: KProperty&*&): String {
return "$thisRef, thank you for delegating '${property.name}' to me!"
operator fun setValue(thisRef: Any?, property: KProperty&*&, value: String) {
println("$value has been assigned to '${property.name} in $thisRef.'")
只读属性（read-only，使用val定义）
委托类需提供getValue函数，参数要求：
- thisRef：第一个参数，必须是属性对应的类或父类型。(上面的thisRef: Any?)
- property：第二个参数，必须是“KProperty&*&”或它的父类型(上面的property: KProperty&*&)。
- 函数返回类型必须跟属性同类型（或者子类型）。
可变属性（mutable，使用var定义）
委托类需提供getValue函数和setValue函数，参数要求：
- thisRef：第一个参数，同getValue对应的参数
- property：第二个参数，同getValue对应的参数
- 新增(new value)：第三个参数，类型必须跟属性一样或其父类型。
getValue() 和setValue()函数可以作为委托类的成员函数或者扩展函数来使用。 当需要委托一个属性给一个不是原来就提供这些函数的对象的时候，后者更为方便。
两种函数都需要用operator关键字修饰。
委托类可以实现ReadOnlyPropery和ReadWriteProperty接口中的带operator的方法，这些接口在Kotlin标准库中声明：
interface ReadOnlyProperty&in R, out T& {
operator fun getValue(thisRef: R, property: KProperty&*&): T
interface ReadWriteProperty&in R, T& {
operator fun getValue(thisRef: R, property: KProperty&*&): T
operator fun setValue(thisRef: R, property: KProperty&*&, value: T)
提供委托（自 1.1 起）
provideDelegate为提供委托，它可以为属性提供对象委托逻辑，可能的使用场景是在创建属性时（而不仅在其 getter 或 setter 中）检查属性一致性。
provideDelegate 的参数与 getValue 相同：
- thisRef —— 必须与属性所有者类型（对于扩展属性——指被扩展的类型）相同或者是它的超类型。
- property —— 必须是类型 KProperty&*& 或其超类。
例如，在绑定之前检查属性名称：
class ResourceLoader(resId: ResourceID) {
operator fun provideDelegate(thisRef: MyUI, prop: KProperty&*&): ReadOnlyProperty&MyUI, String& {
checkProperty(thisRef, prop.name)
// 创建委托
private fun checkProperty(thisRef: MyUI, name: String) {
fun MyUI.bindResource(id: ResourceID): ResourceLoader {
return ResourceLoader(id)
class MyUI {
val image by bindResource(ResourceID.image_id) //bindResource()产生委托对象
val text by bindResource(ResourceID.text_id)
在创建 MyUI 实例期间，为每个属性调用provideDelegate方法，并立即执行必要的验证。
如果没有这种拦截属性与其委托之间的绑定的能力，为了实现相同的功能， 你必须显式传递属性名：
class MyUI {
val image by bindResource(ResourceID.image_id, "image")
val text by bindResource(ResourceID.text_id, "text")
fun &T& MyUI.bindResource(
id: ResourceID&T&,
propertyName: String
): ReadOnlyProperty&MyUI, T& {
checkProperty(this, propertyName)
由于暂时没用的这个提供委托，所以在这里也不过多的介绍，上面是官网的一个栗子。
一个委托实例
下面来看一个自定义的Delegate，用来访问SharedPreference，这段代码是Kotlin for Android Developer的示例：
class Preference&T&(val context: Context, val name: String, val default: T) : ReadWriteProperty&Any?, T& {
val prefs by lazy { context.getSharedPreferences("default", Context.MODE_PRIVATE) }
override fun getValue(thisRef: Any?, property: KProperty&*&): T {
return findPreference(name, default)
override fun setValue(thisRef: Any?, property: KProperty&*&, value: T) {
putPreference(name, value)
private fun &U& findPreference(name: String, default: U): U = with(prefs) {
val res: Any = when (default) {
is Long -& getLong(name, default)
is String -& getString(name, default)
is Int -& getInt(name, default)
is Boolean -& getBoolean(name, default)
is Float -& getFloat(name, default)
else -& throw IllegalArgumentException("This type can be saved into Preferences")
private fun &U& putPreference(name: String, value: U) = with(prefs.edit()) {
when (value) {
is Long -& putLong(name, value)
is String -& putString(name, value)
is Int -& putInt(name, value)
is Boolean -& putBoolean(name, value)
is Float -& putFloat(name, value)
else -& throw IllegalArgumentException("This type can be saved into Preferences")
使用的时候：
class ExampleActivity : AppCompatActivity(){
var a: Int by Preference(this, "a", 0)
fun whatever(){
println(a)
这样就很方便了，再也不用去重复写getSharedPreference()、commit()、edit()、apply()之类的东西了。
&最高记录 67
& kotlintc.com Kotlin中国，致力于构建完善的 Kotlin 中文社区，Kotlin语言爱好者的学习家园。
Powered by
&o&服务器由
赞助 &·&CDN 由
VERSION: V3.0.0&·&1.s&·&为了更好的体验，本站推荐使用 Chrome 或 Firefox 浏览器
登录和大家一起探讨吧
记住登录状态
还不是会员