zoukankan
html css js c++ java
反编译 Component重要类,全文解释 - 组件篇
using
System;
using
System.Security.Permissions;
using
System.Runtime.InteropServices;
namespace
System.ComponentModel
{
/**/
///
<summary>
///
组件类
///
</summary>
[DesignerCategory(
"
Component
"
), ClassInterface(ClassInterfaceType.AutoDispatch), ComVisible(
true
)]
public
class
Component : MarshalByRefObject, IComponent, IDisposable
{
static
Component()
{
//
用于定位Disposed事件的关键字,不懂,为什么不用一个常量呢?
Component.EventDisposed
=
new
object
();
}
/**/
///
<summary>
///
释放资源
///
</summary>
public
void
Dispose()
{
//
调用重载的释放方法
this
.Dispose(
true
);
GC.SuppressFinalize(
this
);
}
/**/
///
<summary>
///
是否资源
///
</summary>
///
<param name="disposing">
是否是主动释放资源
</param>
protected
virtual
void
Dispose(
bool
disposing)
{
if
(disposing)
{
//
防止并发还是重要的。
lock
(
this
)
{
//
如果我还在别人的容器里,要从容器中移动走。
//
在容器代码中,调用这个代码前,已经将Site属性设置为Null了。
if
((
this
.site
!=
null
)
&&
(
this
.site.Container
!=
null
))
{
this
.site.Container.Remove(
this
);
}
//
检查是否包含Disposed事件的拦截
if
(
this
.events
!=
null
)
{
//
注意,所有的事件都是放在这个Events中的,Disposed也是这样。
EventHandler disposedHandler
=
(EventHandler)
this
.events[Component.EventDisposed];
if
(disposedHandler
==
null
)
{
return
;
}
disposedHandler(
this
, EventArgs.Empty);
}
}
}
}
/**/
///
<summary>
///
垃圾收集器调用
///
</summary>
~
Component()
{
this
.Dispose(
false
);
}
/**/
///
<summary>
///
获取服务
///
</summary>
///
<param name="service">
要获取的服务类型
</param>
///
<returns>
服务的实例
</returns>
protected
virtual
object
GetService(Type service)
{
ISite site
=
this
.site;
if
(site
!=
null
)
{
//
服务的获取顺序是:Component -> Site -> Container
return
site.GetService(service);
}
return
null
;
}
/**/
///
<summary>
///
重载了对象的文本显示
///
</summary>
///
<returns>
新的文本
</returns>
public
override
string
ToString()
{
//
如果存在站点,名称像这样的: btnOk[System.Windows.Froms.Button]
ISite site
=
this
.site;
if
(site
!=
null
)
{
return
(site.Name
+
"
[
"
+
base
.GetType().FullName
+
"
]
"
);
}
return
base
.GetType().FullName;
}
/**/
///
<summary>
///
返回是否允许释放事件
///
</summary>
///
<remarks>
///
如果继承类也将EventHandler添加到Events中的话(参见Disposed的实现)
///
就可以通过重载此属性,来屏蔽所有事件的触发
///
</remarks>
protected
virtual
bool
CanRaiseEvents
{
get
{
return
true
;
}
}
/**/
///
<summary>
///
这个属性是被EventHandlerList访问的。实际上就是CanRaiseEvents属性
///
</summary>
internal
bool
CanRaiseEventsInternal
{
get
{
return
this
.CanRaiseEvents;
}
}
/**/
///
<summary>
///
返回组件所在的容器
///
</summary>
///
<remarks>
///
IComponent接口并没有定义这个属性,这里只是为了使用方便而已
///
容器是通过站点对象获取的。
///
</remarks>
[DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden), Browsable(
false
)]
public
IContainer Container
{
get
{
ISite site
=
this
.site;
if
(site
!=
null
)
{
return
site.Container;
}
return
null
;
}
}
/**/
///
<summary>
///
返回是否是设计模式
///
</summary>
///
<remarks>
///
和Container一样,为了方便使用添加的,实际数据的获取是通过站点获得的。
///
</remarks>
[Browsable(
false
), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
protected
bool
DesignMode
{
get
{
ISite site
=
this
.site;
if
(site
!=
null
)
{
return
site.DesignMode;
}
return
false
;
}
}
/**/
///
<summary>
///
所有事件的存储地
///
</summary>
///
<remarks>
///
通过自定义的EventHandlerList对象,Component实现了事件的统一管理,
///
可以屏蔽所有的事件触发(通过CanRaiseEventsInternal)
///
</remarks>
protected
EventHandlerList Events
{
get
{
if
(
this
.events
==
null
)
{
this
.events
=
new
EventHandlerList(
this
);
}
return
this
.events;
}
}
/**/
///
<summary>
///
返回/设置组件的站点对象
///
</summary>
///
<remarks>
///
Component的核心思想就是这里了,可是他很简单,就是注射Site,
///
就是注射了环境。
///
</remarks>
[Browsable(
false
), DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
public
virtual
ISite Site
{
get
{
return
this
.site;
}
set
{
this
.site
=
value;
}
}
/**/
///
<summary>
///
对象的释放事件
///
</summary>
///
<remarks>
///
通过拦截此事件,可以在拦截组件的释放。例如:
///
当前选择了一些组件,但如果组件被释放,选择的组件将减少。
///
</remarks>
[Browsable(
false
), EditorBrowsable(EditorBrowsableState.Advanced)]
public
event
EventHandler Disposed
{
add
{
this
.Events.AddHandler(Component.EventDisposed, value);
}
remove
{
this
.Events.RemoveHandler(Component.EventDisposed, value);
}
}
//
Fields
private
static
readonly
object
EventDisposed;
private
EventHandlerList events;
private
ISite site;
}
/**/
///
<summary>
///
Component专用的事件链表
///
</summary>
[HostProtection(SecurityAction.LinkDemand, SharedState
=
true
)]
public
sealed
class
EventHandlerList : IDisposable
{
/**/
///
<summary>
///
初始化对象,允许不传递parent
///
</summary>
public
EventHandlerList()
{
}
/**/
///
<summary>
///
传递Component的父对象初始化实例
///
</summary>
///
<param name="parent">
所在的组件
</param>
internal
EventHandlerList(Component parent)
{
this
.parent
=
parent;
}
/**/
///
<summary>
///
添加Handler
///
</summary>
///
<param name="key">
事件的查询关键字
</param>
///
<param name="value">
新的Handler
</param>
public
void
AddHandler(
object
key, Delegate value)
{
//
在链表中寻找这个事件
EventHandlerList.ListEntry entry
=
this
.Find(key);
if
(entry
!=
null
)
{
//
如果找到了,就合并成新的Handler,
entry.handler
=
Delegate.Combine(entry.handler, value);
}
else
{
//
如果没有找到,为链表添加新的头。
this
.head
=
new
EventHandlerList.ListEntry(key, value,
this
.head);
}
}
/**/
///
<summary>
///
添加一批新的Handlers
///
</summary>
///
<param name="listToAddFrom">
列表
</param>
public
void
AddHandlers(EventHandlerList listToAddFrom)
{
//
循环链表,一个个加
for
(EventHandlerList.ListEntry entry
=
listToAddFrom.head; entry
!=
null
; entry
=
entry.next)
{
this
.AddHandler(entry.key, entry.handler);
}
}
/**/
///
<summary>
///
释放资源
///
</summary>
public
void
Dispose()
{
this
.head
=
null
;
}
/**/
///
<summary>
///
寻找某个关键字的事件
///
</summary>
///
<param name="key">
要寻找的事件的关键字
</param>
///
<returns>
如果找到就返回他的结构,否则返回Null
</returns>
private
EventHandlerList.ListEntry Find(
object
key)
{
//
这里使用了while循环找,上面那个AddHandlers是用For。
EventHandlerList.ListEntry entry
=
this
.head;
while
(entry
!=
null
)
{
if
(entry.key
==
key)
{
break
;
}
entry
=
entry.next;
}
return
entry;
}
/**/
///
<summary>
///
在链表中移除某个Handler
///
</summary>
///
<param name="key">
事件关键字
</param>
///
<param name="value">
要移除的Handler
</param>
public
void
RemoveHandler(
object
key, Delegate value)
{
//
在链表中寻找,如果找到就Remove掉
EventHandlerList.ListEntry entry
=
this
.Find(key);
if
(entry
!=
null
)
{
entry.handler
=
Delegate.Remove(entry.handler, value);
}
}
/**/
///
<summary>
///
获取某个事件的Handler
///
</summary>
///
<param name="key">
事件的关键字
</param>
///
<returns>
如果找到事件,且没有设置屏蔽,就返回他
</returns>
public
Delegate
this
[
object
key]
{
get
{
EventHandlerList.ListEntry entry
=
null
;
//
如果所在组件设置了不触发事件,将不会Find,返回Null
if
((
this
.parent
==
null
)
||
this
.parent.CanRaiseEventsInternal)
{
entry
=
this
.Find(key);
}
if
(entry
!=
null
)
{
return
entry.handler;
}
return
null
;
}
set
{
//
相当与AddHandler
EventHandlerList.ListEntry entry
=
this
.Find(key);
if
(entry1
!=
null
)
{
entry1.handler
=
value;
}
else
{
this
.head
=
new
EventHandlerList.ListEntry(key, value,
this
.head);
}
}
}
//
Fields
private
ListEntry head;
private
Component parent;
//
存储所有Handler的结构
private
sealed
class
ListEntry
{
/**/
///
<summary>
///
构造新结构
///
</summary>
///
<param name="key">
当前新事件类型的关键字
</param>
///
<param name="handler">
新委托
</param>
///
<param name="next">
下一个结构(链表)
</param>
public
ListEntry(
object
key, Delegate handler, EventHandlerList.ListEntry next)
{
this
.next
=
next;
this
.key
=
key;
this
.handler
=
handler;
}
//
Fields
internal
Delegate handler;
internal
object
key;
internal
EventHandlerList.ListEntry next;
}
}
}
查看全文
相关阅读:
bzoj1002/luogu2144 轮状病毒 (dp)
bzoj1003/luogu1772 物流运输 (dijkstra+dp)
bzoj1007/luogu3194 水平可见直线 (单调栈)
[模板]群论
http 协议媒体格式
java加密类支持sha256,md5,HmacSha1,base64
java逐行读写借助buffereader/bufferwriter
java 基础io读写字节以及缓存读写字节
java log4i.properties
java 迭代器
原文地址:https://www.cnblogs.com/tansm/p/304656.html
最新文章
python 操作mysql
导包 模块
列表 字典推导式 内含三目运算
redis 数据库
Card(bestcoder #26 B)
ABK (枚举)
链表操作
Rescue
水果配载
To the Max
热门文章
Common Subsequence(dp)
Largest Rectangle in a Histogram
数的计数
去北京看奥运
suoi08 一收一行破 (tarjanLca+树状数组)
suoi07 区间平均++ (二分答案+前缀和)
luogu1970 花匠(dp)
luogu2024 食物链 (并查集)
luogu3646 巴厘岛的雕塑 (dp)
luogu1979 华容道 (dijkstra+bfs)
Copyright © 2011-2022 走看看