博客园_首页

[小把戏] 之IBatis.Net系统分页问题的解决

2012-05-28T07:52:00Z

本文想解决园子里大家都关心的Ibatis.Net分页的实现问题。其实我也找了Ibatis.Net分页的解决方案，园子里有一些，奈何没有发现我想要的方式，大都的策略是调用两次SQL Statement,第一次，根据条件查询总记录条数，第二次，根据条件查询从第N行到M行的数据集合，不是这种不能满足条件，恰恰相反，这种写法，完全可以满足现有项目的需求，也很具备SQL调优空间，但有个的弊端，是通过一个查询写几遍。很难复用。感觉很是别扭，我看过在查询较多的系统里，到处充斥这分页的SQL语句，另外一点，本来我们码农们只要关心实现获取业务数据就行了，每次在实现功能的基础上，还要再加上分页的SQL语句，使原本的可能就复杂的语句，变得更加复杂和难以理解。

为此，我特地Reflect看了Ibatis.Net的源码。根据他的处理逻辑扩展了SqlMapper的接口，增加 IList<T> QueryForListWithPage<T>这种功能。本想通过注入的方式实现的，看过Java的筒子们曾用注入的方式搞定过。可惜Ibatis.Net没有发现这种方式（或许我才疏学浅，没有找到）。貌似MyBatis已经支持。但没有实践过。本文代码只针对Ibatis 1.62版本和使用MSSQL数据库。如果感觉此思路还不错，我的源码是共享滴，完全可以下载源码，改造成你想要的其它方式。

至于分页的SQL，个人偏好row_number这种方法，其它的如分页存储过程，TOP方式就不费笔墨了。

话多无益。直接上码

//获取学生列表（使用配置GetStudentList的sql，按照id升序排序获取从第八十个到第一百学生）
var list = mapper.QueryForListWithPage<T>("GetStudentList", paras, "id asc", 80, 100, ref count);

那么具体实现怎么写呢，我采用c#的扩展方法，扩展了Ibatis.Net标配的SqlMapper功能，看起来类似Ibatis.Net原生态的功能，但又没有破坏Ibatis源码，这种插件式，不会给原有的Ibatis引入任何的Bug.

public static class SqlMapperExtension
{
private const string PageSql =
"with cte as( select id0=row_number() over(order by {0}),* from ({1}) as cte1) select * from cte where id0 between @beginNo and @endNo";

private const string CountSql = "select count(*) {0}";

/// <summary>
/// 查询分页
/// </summary>
/// <typeparam name="T">泛型</typeparam>
/// <param name="mapper">mapper</param>
/// <param name="tag">SQL Statement的id</param>
/// <param name="paramObject">参数</param>
/// <param name="orderby">查询条件，必须确保数据库中有这一列</param>
/// <param name="beginNo">开始行数</param>
/// <param name="endNo">结束行数</param>
/// <param name="totalCount">总条数</param>
/// <returns>查询结果</returns>
public static IList<T> QueryForListWithPage<T>(this ISqlMapper mapper, string tag, object paramObject,string orderby, int beginNo, int endNo, ref int totalCount)
{
bool flag = false;
ISqlMapSession sqlMapSession = mapper.LocalSession;
if (sqlMapSession == null)
{
sqlMapSession = mapper.CreateSqlMapSession();
flag = true;
}
try
{
IMappedStatement mappedStatement = mapper.GetMappedStatement(tag);
IStatement statement = mappedStatement.Statement;
RequestScope request = statement.Sql.GetRequestScope(mappedStatement, paramObject, sqlMapSession);
string statementsql = request.PreparedStatement.PreparedSql;
string cmdPageSql = string.Format(PageSql, orderby, statementsql);
string cmdCountSql = string.Format(CountSql,statementsql.Substring(statementsql.ToLower().IndexOf("from")));

request.PreparedStatement.PreparedSql = cmdPageSql;
request.IDbCommand = new DbCommandDecorator(sqlMapSession.CreateCommand(statement.CommandType), request);
ApplyParameterMap(sqlMapSession, request.IDbCommand, request, statement, paramObject);
totalCount = GetCount(request, sqlMapSession, cmdCountSql);
request.IDbCommand.CommandText = request.PreparedStatement.PreparedSql;
AddCommandParameters(beginNo, endNo, request);
IList<T> result = RunQueryForList<T>(statement, request, sqlMapSession, paramObject, null, null);
return result;
}
finally
{
if (flag)
{
sqlMapSession.CloseConnection();
}
}
}
}

园友们若想直接拿来使用，可以下载附件文件，在引用Ibatis.Net的dll同时，在工程里再增加SqlMapperExtension这个类文件，就可以方便调用了。此方法在Ibatis.Net1.62版本下，使用MSSQL,已经通过测试验证。OK，如果你不想分页功能，那么就还是使用下面的方式。

var listall = mapper.QueryForList<T>(statementName, paras);

这样你只需要在sqlmapper的xml里写一个SQL语句，获取全部记录和获取分页记录(含有总条数)两件事就都可以搞定.

觉得好的话，别忘了顶一下哦，呵呵.

本文链接

ASP.NET MVC架构与实战系列之二：理解MVC路由配置

2012-05-28T07:49:00Z

在上一篇文章中，我简短的谈了一下MVC的底层运行机制，如果对MVC还不是很了解的朋友，可以作为入门的参照。接下来，我开始介绍关于URL路由的相关知识。URL路由不是MVC独有的，相反它是独立于MVC而单独存在的(在System.Web.Routing下)。因此，URL路由也能为传统的ASP.NET应用程序服务。我用一个简单的例子来解释路由，在我们的上一节的"ASP.NET MVC应用程序"中添加一个新的页面default.aspx，其后台代码如下：

protected void Page_Load(object sender, EventArgs e)
{
var originalPath = Request.Path;
HttpContext.Current.RewritePath(Request.ApplicationPath, false);
IHttpHandler handler = new MvcHttpHandler();
handler.ProcessRequest(HttpContext.Current);
HttpContext.Current.RewritePath(originalPath, false);
}

当执行请求页面default.aspx时，首先将请求的路径重写为"/"，而该路径会匹配路由{controller}/{action}/{id}，根据Global.asax路由配置，将映射为Home/Index/，从而输出Index.aspx的内容(而不是default.aspx的内容)，不禁要问：为什么default.aspx在MVC应用程序中当做普通的ASP.NET页面，而不是将该请求转化为路由执行？是不是在MVC中就不能使用普通的ASP.NET页面呢？如果不能，当有一天我希望将我的普通站点转化为MVC站点时，是否还需要重新开发？带着这些疑问，我们进一步来探讨如何在MVC中支持原有的ASP.NET页面。在Global.asax中的Application_Start()方法中添加以下代码：

protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RegisterRoutes(RouteTable.Routes);
RouteTable.Routes.RouteExistingFiles = true;
}

再次运行default.aspx会出现以前错误页面(找不到页面)。

刚才增加的代码：RouteTable.Routes.RouteExistingFiles = true(默认为false);表明MVC启用对现有Web页面的解析，此时尽管同样解析到路由{controller}/{action}/{id}上，但却找不到对应的控制器路由参数default.aspx，因而导致错误。接下来我们为它添加相关的路由设置，在Global.asax中添加以下代码：

//为default.aspx添加路由
routes.MapRoute(
"Start",
"default.aspx",
new { controller = "Home", action = "Index", id = UrlParameter.Optional }
);

删除或注释掉default.aspx.cs中的代码再次运行，会发现页面能正常解析。需要说明的是，URL路由的排列顺序非常关键，一旦找到第一个匹配的路由，将不会继续寻找剩下的路由了。是因为这里找到了匹配的路由Start，从而正确的映射到Home下的视图Index.aspx。为了更加深入理解路由解析的匹配规则，我们引入"路由匹配监控器"。添加引用"RouteDebug.dll"，并在Global.asax中注册检测代码以分别检测没有启用和启用(依靠RouteExistingFiles属性)ASP.NET页面解析两种情况。

protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RegisterRoutes(RouteTable.Routes);
//RouteTable.Routes.RouteExistingFiles = true;
RouteDebugger.RewriteRoutesForTesting(RouteTable.Routes);
}

未启用(默认)Web页面解析的路由监控图

启用Web页面解析的路由监控图

从图中我们发现，当启用Web页面解析时，比未启用适多出一个路由项，这是因为此时是从Global.asax中去寻找匹配的路由项。过程大概是这样的：首先会到路由表集合中寻找，如果找到匹配的路由定义则解析路由定义中的各个参数，依次获取参数映射的控制器/视图/参数信息，最后定位到指定控制器下的指定视图页面进行输出。相反，而过找不到对应的匹配路由则返回错误页面。

前面已提到过，URL路由的基本格式是: {controller}/{action}/{id}，但也存在很多变体，总的来说，都会把不包含在{}中的部分当成常量来处理。如：blog/{action}/{author}的正确映射应该为:blog/show/miracle，再比如{report}/{year}/{month}/{day}映射为:sale/2012/5/25。这样就非常好理解页面具有的功能。开发者一般都会通过Global.asax文件的Application_Start()来设置URL路由的定义，通过静态类RouteTable的Routes属性来设置路由。

public static void RegisterRoutes(RouteCollection routes)
{
routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
routes.Add(new Route("blog/{action}/{author}", new BlogRouteHandler()));
}

protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RegisterRoutes(RouteTable.Routes);
}

我们可以看出在路由中定义了两个路由参数:action和author。当用户发送URL请求http://server/blog/show/miracle时，根据路由的定义将进行映射，使得action映射为show，author映射为miracle，如果当用户发送请求http://server/blog/add时，由于找不到对应的路由也没有默认路由，此时URL路由将不会进行处理，而是作为普通的页面交由ASP.NET应用程序处理。在添加URL路由的同时，还可以设置路由参数的默认值。

public static void RegisterRoutes(RouteCollection routes)
{
routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
routes.Add(new Route("blog/{action}/{author}", new BlogRouteHandler())
{
Defaults = new RouteValueDictionary
{
{"action", "show"},
{"author", "miracle"}
}
});
}

现在用户就可以发送更多的请求了，如: http://server/blog将映射到http://server/blog/show/miracle上，http://server/blog/add将映射到http://server/blog/add上，而http://server/blog/add/miraclehe将映射到http://server/blog/add/miraclehe上。简单总结一句：如果对应的路由参数没有填充值的话，则使用默认值，否则使用对应的路由参数值。有时，为了适应一类URL的定义，可以用通配符(*)来表示。如:blog/query/{*values}，对应的映射可以包含如下：/blog/query/miracle/2012/05，/blog/query/miracle或/blog/query等。可能还需要为路由参数添加约束，以更好的满足参数的准确性。如：

public static void RegisterRoutes(RouteCollection routes)
{
routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
routes.Add(new Route("blog/{locale}/{year}", new BlogRouteHandler())
{
Constraints = new RouteValueDictionary
{
{"locale", "{a-z}{2}-{A-Z}{2}"},
{"year", @"\d{4}"}
}
});
}

对应的映射为：/blog/en-US/2012，而/blog/en-us/2012，/blog/en-US/12均不符合要求。介绍了关于默认值和约束的相关知识后，我们来看看Route类定义，主要包含以下属性：默认值Defaults、约束Constraints、命名空间DataTokens、URL路由以及路由处理程序RouteHandler，以下是其构造函数列表。

public Route(string url, IRouteHandler handler);
public Route(string url, RouteValueDictionary defaults, IRouteHandler handler);
public Route(string url, RouteValueDictionary defaults, RouteValueDictionary constraints, IRouteHandler handler);
public Route(string url, RouteValueDictionary defaults, RouteValueDictionary constraints, RouteValueDictionary dataTokens, IRouteHandler handler);

可以看出，最简单的构造函数只需要URL路由和路由处理程序，最复杂的则包含所有属性。

var route = new Route("blog/{action}/{author}",
new RouteValueDictionary { {"action", "show" }, {"author", "miracle"} },
new MvcRouteHandler());

可将(多个)路由添加到路由集合RouteCollection中，通过RouteTable.Routes属性来维护路由集合。

public static void RegisterRoutes(RouteCollection routes)
{
routes.Add(new Route("blog/{action}/{author}",
new RouteValueDictionary { {"action", "show" }, {"author", "miracle"} },
new MvcRouteHandler()));
}

大家可能会发现，添加路由有MapRoute和Add两个方法，那到底有什么区别的。MapRoute是RouteCollection的扩展方法，同时还有IngnoreRoute，而Add则是实例方法，相对来说要使用Add来调用比较复杂(包含刚才提到的5大属性)，而MapRoute则相对简洁。

public static void RegisterRoutes(RouteCollection routes)
{
routes.MapRoute(
"Article", // 路由名称
"blog/{action}/{author}", // 带有参数的 URL
new { controller = "Home", action = "show", author = "miracle" }
);
}

细心的朋友会发现，在MapRoute中指定了路由名称(可选)，到底有什么用呢？先看以下生成链接(在下一篇文章中将提到)的代码：

<%= Html.RouteLink("Miracle's Blog", "Article", new { action = "compose" }) %>

此时在URL路由匹配时就直接按照名称解析，同时可以不用指定默认的路由参数，而不用遍历匹配以提高匹配效率。另一种优化路由的方式是将最常见的路由存放在路由表的最前面(只要找到第一个则不再寻找)。

有时，我们需要自定义路由约束(需要实现IRouteConstraint的Match方法)以满足更复杂的路由需求。假定路由为: blog/miracle/{year}/{month}/{day}。此时year参数的参考值：2000~2012，month为:1~12， day为：28、29、30或31(根据月份而定)。分别添加YearRouteConstraint类、MonthRouteConstraint类和DayRouteConstraint类。

public class YearRouteConstraint : IRouteConstraint
{
public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
{
if (routeDirection == RouteDirection.IncomingRequest &&
parameterName.ToLower() == "year")
{
var year = 0;
if (int.TryParse(values["year"].ToString(), out year))
{
return year >= 2000 && year <= 2012;
}
return false;
}
return false;
}
}

public class MonthRouteConstraint : IRouteConstraint
{
public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
{
if (routeDirection == RouteDirection.IncomingRequest &&
parameterName.ToLower() == "month")
{
var month = 0;
if (int.TryParse(values["month"].ToString(), out month))
{
return month >= 1 && month <= 12;
}
return false;
}
return false;
}
}

public class DayRouteConstraint : IRouteConstraint
{
public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
{
if (routeDirection == RouteDirection.IncomingRequest &&
parameterName.ToLower() == "day")
{
var month = 0;
if (!int.TryParse(values["month"].ToString(), out month)) return false;
if (month <= 0 || month > 12) return false;

var day = 0;
if (!int.TryParse(values["day"].ToString(), out day)) return false;

switch (month)
{
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
return day <= 31;
case 4:
case 6:
case 9:
case 11:
return day <= 31;
case 2:
return day <= 28;//不计闰年
}
}
return false;
}

接下来，我们可以来利用自定义约束配置路由。

//配置自定义约束
routes.MapRoute("Article", "blog/{year}/{month}/{day}",
new
{
controller = "blog",
action = "show",
author = "miracle",
year = "",
month = "",
day = ""
},
new
{
year = new YearRouteConstraint(),
month = new MonthRouteConstraint(),
day = new DayRouteConstraint()
});

现在如果运行http://server/blog/show/miracle/2012/4/31将报错，因为不符合日期约束。

本文链接

Lua的协同程序

2012-05-28T07:39:00Z

Lua是一种简单，可扩展，可移植及高效的脚本语言。在嵌入式系统，移动设备，web服务器，游戏等方面都能见到它的身影。lua其中最吸引人的一点事它能很方便地与C语言或者其他语言。

这里说的是lua语言中的协同程序（coroute），也有人翻译成为协作程序

基本函数和语法

coroutine就是lua的协同程序

先讲一下coroutine的语法：

coroutine.create()

创建coroutine，返回coroutine，参数是一个函数，当和resume配合使用的时候就唤醒函数调用

coroutine.resume()

重启coroutine，和create配合使用

coroutine.yield()

挂起coroutine，将coroutine设置为挂起状态，这个和resume配合使用能有很多有用的效果

coroutine.status()

查看coroutine的状态

注：coroutine的状态有三种：dead，suspend，running，具体什么时候有这样的状态请参考下面的程序

coroutine.wrap（）

创建coroutine，返回一个函数，一旦你调用这个函数，就进入coroutine，和create功能重复

coroutine.running()

返回正在跑的coroutine，一个coroutine就是一个线程，当使用running的时候，就是返回一个corouting的线程号

使用下面的程序来了解一下这几个函数的基本用法:

co = coroutine.create(
function(i)
print(i);
end
)

coroutine.resume(co, 1) -- 1
print(coroutine.status(co)) -- dead

print("----------")

co = coroutine.wrap(
function(i)
print(i);
end
)

co(1)

print("----------")

co2 = coroutine.create(
function()
for i=1,10 do
print(i)
if i == 3 then
print(coroutine.status(co2)) --running
print(coroutine.running()) --thread:XXXXXX
end
coroutine.yield()
end
end
)

coroutine.resume(co2) --1
coroutine.resume(co2) --2
coroutine.resume(co2) --3

print(coroutine.status(co2)) -- suspended
print(coroutine.running()) --nil

print("----------")

返回数据：

coroutine.running就可以看出来,coroutine在底层实现就是一个线程。当create一个coroutine的时候就是在新线程中注册了一个事件。当使用resume触发事件的时候，create的coroutine函数就被执行了，当遇到yield的时候就代表挂起当前线程，等候再次resume触发事件。

分析学习coroutine的时候经常遇到的一个程序

源程序可以看这里

我稍微做了点修改，增加了一下分隔符：

function foo (a)
print("foo", a) -- foo 2
return coroutine.yield(2 * a) -- return: a , b
end

co = coroutine.create(function (a , b)
print("co-body", a, b) -- co-body 1 10
local r = foo(a + 1)

print("co-body2", r)
local r, s = coroutine.yield(a + b, a - b)

print("co-body3", r, s)
return b, "end"
end)

print("main", coroutine.resume(co, 1, 10)) -- true, 4
print("------")
print("main", coroutine.resume(co, "r")) -- true 11 -9
print("------")
print("main", coroutine.resume(co, "x", "y")) -- true 10 end
print("------")
print("main", coroutine.resume(co, "x", "y")) -- false cannot resume dead coroutine
print("------")

这个程序返回：

很神奇，也很让人看不懂

先理解下下面几点：

resume一定是在主线程的，yield是在子线程（coroutine）的
resume可以带参数
当coroutine是suspend状态的时候，参数是作为coroutine的参数传入的

当coroutine是suspend状态的时候，参数是作为coroutine的参数传入的
resume返回值有两种情况
- 当coroutine是suspend状态的时候，返回是是bool [yield params]
  bool是这个resume操作是否成功
  
  yield params是当前coroutine的yield的参数
- 当coroutine是dead状态的时候，返回值是bool [function return]
  bool是这个resume操作是否成功
  
  yield params是当前coroutine的yield的参数

先对照上面几条看一个简单的例子:

co = coroutine.create(
function (a , b)
print("params", a, b)
return coroutine.yield(3, 3)
end
)
coroutine.resume(co, 1, 2);
print(coroutine.resume(co, 4, 5))

理解完上面这个程序，再看看coroutine2的程序,这里把每个输出执行了哪些步骤列出来了：

print("main", coroutine.resume(co, 1, 10)) 执行了：
print("co-body", 1, 10)

print("foo", 2)

coroutine.resume(co, 1, 10) 返回 true, 4 (!!这里的4是yield的参数)

print("main", true, 4)
print("main", coroutine.resume(co, "r")) 执行了：
foo(a) 返回了 "r" (这是由yield返回的)

print("co-body2", "r")

coroutine.resume(co, "r") 返回 true, 11 -9 (!!这里的a和b还是用1和10计算的)

print("main" , true, 11 -9)
print("main", coroutine.resume(co, "x", "y"))执行了：
local r, s = coroutine.yield(a + b, a - b) r和s值为x和y

print("co-body3", "x", "y")

return b, "end" //此时coroutine线程结束，为dead状态

coroutine.resume(co, "x", "y") 返回值为 true 10 end

print("main" , true 10 end)
print("main", coroutine.resume(co, "x", "y"))执行了：
由于coroutine.resume(co, "x", "y")已经dead了，所以这里返回false

参考文章

Luai: Lua reference manual interface: about

lua_manual

《lua程序设计》

本文基于署名-非商业性使用 3.0许可协议发布，欢迎转载，演绎，但是必须保留本文的署名叶剑峰（包含链接http://www.cnblogs.com/yjf512/），且不得用于商业目的。如您有任何疑问或者授权方面的协商，请与我联系。

本文链接

创建Windows服务(Windows Services)N种方式总结

2012-05-28T07:38:00Z

最近由于工作需要，写了一些windows服务程序，有一些经验，我现在总结写出来。
目前我知道的创建创建Windows服务有3种方式:
a.利用.net框架类ServiceBase
b.利用组件Topshelf
c.利用小工具instsrv和srvany

下面我利用这3种方式,分别做一个windows服务程序，程序功能就是每隔5秒往程序目录下记录日志:

a.利用.net框架类ServiceBase

本方式特点:简单，兼容性好

通过继承.net框架类ServiceBase实现

第1步: 新建一个Windows服务

public partial class Service1 : ServiceBase
{
readonly Timer _timer;

private static readonly string FileName = Path.GetDirectoryName ( Assembly.GetExecutingAssembly ( ).Location ) + @"\" + "test.txt";

public Service1 ( )
{
InitializeComponent ( );

_timer = new Timer ( 5000 )
{
AutoReset = true ,
Enabled = true
};

_timer.Elapsed += delegate ( object sender , ElapsedEventArgs e )
{
this.witre ( string.Format ( "Run DateTime {0}" , DateTime.Now ) );
};
}

protected override void OnStart ( string [ ] args )
{
this.witre ( string.Format ( "Start DateTime {0}" , DateTime.Now ) );
}

protected override void OnStop ( )
{
this.witre ( string.Format ( "Stop DateTime {0}" , DateTime.Now ) + Environment.NewLine );
}

void witre ( string context )
{
StreamWriter sw = File.AppendText ( FileName );
sw.WriteLine ( context );
sw.Flush ( );
sw.Close ( );
}

}

第2步: 添加Installer

[RunInstaller ( true )]
public partial class Installer1 : System.Configuration.Install.Installer
{
private ServiceInstaller serviceInstaller;
private ServiceProcessInstaller processInstaller;

public Installer1 ( )
{
InitializeComponent ( );

processInstaller = new ServiceProcessInstaller ( );
serviceInstaller = new ServiceInstaller ( );

processInstaller.Account = ServiceAccount.LocalSystem;
serviceInstaller.StartType = ServiceStartMode.Automatic;

serviceInstaller.ServiceName = "my_WindowsService";
serviceInstaller.Description = "WindowsService_Description";
serviceInstaller.DisplayName = "WindowsService_DisplayName";

Installers.Add ( serviceInstaller );
Installers.Add ( processInstaller );
}
}

第3步:安装,卸载
Cmd命令
installutil WindowsService_test.exe (安装Windows服务)
installutil /u WindowsService_test.exe (卸载Windows服务)

代码下载:http://files.cnblogs.com/aierong/WindowsService_test.rar

b.利用组件Topshelf

本方式特点:代码简单,开源组件,Windows服务可运行多个实例

Topshelf是一个开源的跨平台的服务框架，支持Windows和Mono，只需要几行代码就可以构建一个很方便使用的服务. 官方网站:http://topshelf-project.com

第1步:引用程序集TopShelf.dll和log4net.dll

第2步:创建一个服务类MyClass,里面包含两个方法Start和Stop,还包含一个定时器Timer,每隔5秒往文本文件中写入字符

public class MyClass
{
readonly Timer _timer;

private static readonly string FileName = Directory.GetCurrentDirectory ( ) + @"\" + "test.txt";

public MyClass ( )
{
_timer = new Timer ( 5000 )
{
AutoReset = true ,
Enabled = true
};

_timer.Elapsed += delegate ( object sender , ElapsedEventArgs e )
{
this.witre ( string.Format ( "Run DateTime {0}" , DateTime.Now ) );
};
}

void witre ( string context )
{
StreamWriter sw = File.AppendText ( FileName );
sw.WriteLine ( context );
sw.Flush ( );
sw.Close ( );
}

public void Start ( )
{
this.witre ( string.Format ( "Start DateTime {0}" , DateTime.Now ) );
}

public void Stop ( )
{
this.witre ( string.Format ( "Stop DateTime {0}" , DateTime.Now ) + Environment.NewLine );
}

}

第3步:使用Topshelf宿主我们的服务，主要是Topshelf如何设置我们的服务的配置和启动和停止的时候的方法调用

class Program
{
static void Main ( string [ ] args )
{
HostFactory.Run ( x =>
{
x.Service<MyClass> ( ( s ) =>
{
s.SetServiceName ( "ser" );
s.ConstructUsing ( name => new MyClass ( ) );
s.WhenStarted ( ( t ) => t.Start ( ) );
s.WhenStopped ( ( t ) => t.Stop ( ) );
} );

x.RunAsLocalSystem ( );

//服务的描述
x.SetDescription ( "Topshelf_Description" );
//服务的显示名称
x.SetDisplayName ( "Topshelf_DisplayName" );
//服务名称
x.SetServiceName ( "Topshelf_ServiceName" );

} );
}
}

第4步: cmd命令

ConsoleApp_Topshelf.exe install (安装Windows服务)

ConsoleApp_Topshelf.exe uninstall (卸载Windows服务)

代码下载:http://files.cnblogs.com/aierong/ConsoleApp_Topshelf.rar

c.利用小工具instsrv和srvany

本方式特点:代码超级简单,WindowsForm程序即可,并支持程序交互(本人最喜欢的特点),好像不支持win7,支持xp win2003

首先介绍2个小工具:

instsrv.exe:用以安装和卸载可执行的服务

srvany.exe:用于将任何EXE程序作为Windows服务运行

这2个工具都是是Microsoft Windows Resource Kits工具集的实用的小工具

你可以通过下载并安装Microsoft Windows Resource Kits获得 http://www.microsoft.com/en-us/download/details.aspx?id=17657

第1步: 新建WindowsForm程序

public partial class Form1 : Form
{
Timer _timer;

private static readonly string FileName = Application.StartupPath + @"\" + "test.txt";

public Form1 ( )
{
InitializeComponent ( );
}

private void Form1_Load ( object sender , EventArgs e )
{
_timer = new Timer ( )
{
Enabled = true ,
Interval = 5000
};

_timer.Tick += delegate ( object _sender , EventArgs _e )
{
this.witre ( string.Format ( "Run DateTime {0}" , DateTime.Now ) );
};
}

void _timer_Tick ( object sender , EventArgs e )
{
throw new NotImplementedException ( );
}

void witre ( string context )
{
StreamWriter sw = File.AppendText ( FileName );
sw.WriteLine ( context );
sw.Flush ( );
sw.Close ( );
}

private void button1_Click ( object sender , EventArgs e )
{
MessageBox.Show ( "Hello" );
}

}

第2步:安装,卸载

服务的安装步骤分5小步:

(1)打开CMD,输入以下内容，其中WindowsForms_WindowsService为你要创建的服务名称

格式:目录绝对路径\instsrv WindowsForms_WindowsService 目录绝对路径\srvany.exe

例如:

D:\TempWork\win\Debug\instsrv.exe WindowsForms_WindowsService D:\TempWork\win\Debug\srvany.exe

(2)regedit打开注册表编辑器,找到以下目录

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\WindowsForms_WindowsService

(3)鼠标右键单击WindowsForms_WindowsService，创建一个"项"，名称为"Parameters"

(4)鼠标左键单击"Parameters",在右边点击鼠标右键，创建一个"字符串值"(REG_SZ)，名称为"Application"，数值数据里填写目录下可执行文件的绝对路径+文件名

例如:

D:\TempWork\win\Debug\WindowsFormsApplication_Exe.exe

(5)打开services.msc服务控制面板，找到WindowsForms_WindowsService服务，鼠标右键-属性-登陆，勾选"允许服务与桌面交互"

启动服务,可以看到程序界面

卸载服务

D:\TempWork\win\Debug\instsrv.exe WindowsForms_WindowsService REMOVE

代码下载:http://files.cnblogs.com/aierong/WindowsFormsApplication_Exe.rar

本文链接

Javascript中的对象和原型(一)

2012-05-28T07:20:00Z

Javascript中的对象和原型(一)
面向对象的语言（如Java）中有类的概念，而通过类可以创建任意多个具有相同属性和方法的对象。但是，JavaScript 没有类的概念，因此它的对象也与基于类的语言中的对象有所不同。
要了解面向对象，首先就要了解Javascript中的对象和原型。这篇文章中主要学习一下Javascript中的对象。
一关于对象
对象其实就是一种引用类型。而对象的值就是引用类型的实例。在JavaScript 中引用类型是一种数据结构，将数据和功能组织在一起。它也常被称做为类，但JavaScript 中却没有类的概念。虽然JavaScript 是一门面向对象的语言，却不具备传统面向对象语言所支持的类和接口等基本结构。
二对象的创建以及常用操作
1.使用new运算符
1 <script>
2 var user = new Object(); //使用new运算符创建一个对象
3 user.name = '念在三角湖畔'; //给对象添加属性
4 user.age = 22;
5 user.address = '湖北武汉';
6 alert(user.name + " " +user.age);//返回 '念在三角湖畔湖北武汉'
7 </script>
说明：上面的方式中new关键字可以省略，即var user = new Objext();等价于 var user = Object();
2.使用JSON数组创建
关于JSON的一些知识可以百度上搜索下。
简单的JSON数组: {name:'念在三角湖畔',age:22,address:'湖北武汉'}
//使用JSON符号创建
/*
简单的JSON数组:{name:'念在三角湖畔',age:22,address:'湖北武汉'}
/
var user = {
name:'念在三角湖畔',
age:22,
address:'湖北武汉'
};
alert(user.name + " " +user.age);//返回 '念在三角湖畔湖北武汉'
3.传统赋值方式
//传统赋值
var user = {};
user.name = '念在三角湖畔'; //给对象添加属性
user.age = 22;
user.address = '湖北武汉';
alert(user.name + " " +user.age);//返回 '念在三角湖畔湖北武汉'
4.属性的调用
对于对象属性的调用有两种方式：
拿上面的例子来说，上面我们已经用了其中一种方式，也就是'.'运算符，调用方法如下：
alert(user.name + " " +user.age);//返回 '念在三角湖畔湖北武汉'
另一种方法：
alert(user['name'] + " " +user['age']);//返回 '念在三角湖畔湖北武汉
5.给对象添加方法
给对象添加方法和给变量添加一个属性其实大同小异。具体代码如下：
var user = {
name:'念在三角湖畔', //给对象添加属性
age:22,
address:'湖北武汉',
showInfo:function(){//添加一个方法
alert(this.name+" "+this.age+" "+this.address);//返回 '念在三角湖畔 22 湖北武汉'
},
showHello:showHello//将对象外部的方法添加到对象
};
function showHello(){
alert("Hello!");
}
user.showInfo();//调用方法
user.showHello();
6.删除对象的属性
删除对象的属性用delete操作符。格式：delete 对象名称.属性名称*
var user = {
name:'念在三角湖畔', //给对象添加属性
age:22,
address:'湖北武汉'
};
alert(user.name);//返回‘念在三角湖畔’
delete user.name;//删除user的name属性
alert(user.name);//返回‘undefined’
三总结
这里比较浅显的讲述了一下Javascript中对象的创建和对象方法的添加以及对象属性的删除。对象在javascript面向对象中是一个比较重要的，也算是一个比较基础的部分，只有弄清楚了对象的一些常用操作才能够进行面向对象开发。

本文链接

开发企业应用系统需要掌握的知识技能

2012-05-28T06:46:00Z

1. 概述

本篇文章主要是对开发方面及项目管理方面的知识技能内容进行规划及调侃，这是一篇自我调侃的建议。在这篇文章中我把掌握程度分为了解、熟悉、精通。了解指的是知道这个事物并且会使用这个事物。熟悉指的是对这个事物的使用和应用非常了解，出现问题能快速解决问题。精通指的是对这个事物的原理已经掌握，并知道这个事物的来龙去脉。因为开发一个优秀的企业应用系统需要掌握知识点实在太多，在这里我抛砖引玉把按能力分为初级、普通、高级三种等级并对相关的知识技能进行分类，也系统通过这种形式跟大家探讨，可以把知识技能分的更合理更加科学，让新来的程序员可以对照着这张表格进行规划学习路径，让老程序员可以对照着进行技术改进。

2. 知识技能的三种等级

2.1. 初级

分类	知识技能	程度	参考资料
软件开发方法	面向对象	了解	《C#面向对象基础教程》
程序语言	C#语言	了解	MSND
	SQL语言	了解	MSND
	HTML	了解
	CSS	了解	《CSS2.0参考手册》《CSS3.0参考手册》
	Javascript	了解
Web技术	Asp.net	了解	MSND
.Net框架技术	Ado.net	了解	MSND
数据库技术	SQL Server 2005	了解
其他软件	IIS服务器	了解
其他软件	Office软件	了解
领域知识	领域知识	了解

2.2. 普通

分类	知识技能	程度	参考资料
过程管理	CMMI	了解	《适用于开发的能力成熟度集成模型(CMMI-DEV) 1.2版》
	RUP	了解	《Rational Unified Process 2000 参考手册》
	敏捷开发	了解	《敏捷软件开发：原则、模式与实践》《硝烟中的 Scrum 和 XP》《Scrum Checklists》
软件开发方法	面向对象	熟悉	《C#面向对象基础教程》《面向对象分析与设计(UML.2.0版)》《深入浅出面向对象分析与设计》
软件开发方法	测试驱动开发（TDD）	了解
分析设计	设计模式及准则	熟悉	《企业应用架构模式》《新版设计模式手册C#》《大话设计模式》《面向对象设计原则》《类库开发设计准则》《软件界面设计准则》《数据库设计准则》
分析设计	重构	熟悉	《重构》《重构：改善既有代码的设计》
基础知识	算法	熟悉	《C#数据结构》
	内存、进程和线程管理	了解	《WINDOWS程序员指南--DLL和内存管理》《Win32 API详解》
	协议	了解	《HTTP协议详解》《TCP-IP详解卷合集(卷一卷二卷三)》
	CLR	了解	《框架设计 CLR Via C#》
	英语	熟悉
程序语言	C#语言	熟悉	MSND
	SQL语言	熟悉	MSND
	HTML	熟悉
	XML语言	了解
	CSS	熟悉	《CSS2.0参考手册》《CSS3.0参考手册》
	Javascript	熟悉
	UML语言	了解
Web技术	Asp.net	熟悉	MSND
	Microsoft Ajax	熟悉	MSND
	JQuery	熟悉	《jQuery 中文参考》
.Net框架技术	Ado.net	熟悉	MSND
	WCF	熟悉
	WF	熟悉
	NHibernate	熟悉	《Hibernate开发指南》《NHibernate中文参考》
	Spring.net	熟悉
数据库技术	SQL Server 2005	熟悉
其他软件	IIS服务器	了解
其他软件	Office软件	了解
领域知识	领域知识	熟悉

2.3. 高级

分类	知识技能	程度	参考资料
过程管理	CMMI	熟悉	《适用于开发的能力成熟度集成模型(CMMI-DEV) 1.2版》
	RUP	熟悉	《Rational Unified Process 2000 参考手册》
	敏捷开发	熟悉	《敏捷软件开发：原则、模式与实践》《硝烟中的 Scrum 和 XP》《Scrum Checklists》
软件开发方法	面向对象	精通	《C#面向对象基础教程》《面向对象分析与设计(UML.2.0版)》《深入浅出面向对象分析与设计》
软件开发方法	测试驱动开发（TDD）	精通
分析设计	设计模式及准则	精通	《企业应用架构模式》《新版设计模式手册C#》《大话设计模式》《面向对象设计原则》《类库开发设计准则》《软件界面设计准则》《数据库设计准则》
分析设计	重构	精通	《重构》《重构：改善既有代码的设计》
基础知识	算法	精通	《C#数据结构》
	内存、进程和线程管理	精通	《WINDOWS程序员指南--DLL和内存管理》《Win32 API详解》
	协议	精通	《HTTP协议详解》《TCP-IP详解卷合集(卷一卷二卷三)》
	CLR	精通	《框架设计 CLR Via C#》
	英语	熟悉
程序语言	C#语言	精通	MSND
	SQL语言	精通	MSND
	HTML	精通
	XML语言	精通
	CSS	精通	《CSS2.0参考手册》《CSS3.0参考手册》
	Javascript	精通
	UML语言	精通
Web技术	Asp.net	精通	MSND
	Microsoft Ajax	精通	MSND
	JQuery	精通	《jQuery 中文参考》
.Net框架技术	Ado.net	精通	MSND
	WCF	精通
	WF	精通
	NHibernate	精通	《Hibernate开发指南》《NHibernate中文参考》
	Spring.net	精通
数据库技术	SQL Server 2005	精通
其他软件	IIS服务器	了解
其他软件	Office软件	了解
领域知识	领域知识	熟悉

本文链接

我和我的HoorayOS

2012-05-28T06:44:00Z

HoorayOS是我在我去年8月份开始构想，9月份开始编写的一个开源的web桌面类应用框架。它的前身是EonerCMS，因为那会公司准备重新开发自己的CMS系统，以应用于一些中小型的网站，于是也就有了这片文章《关于CMS后台展示/操作方式的个人拙见》

直到今年2月，我正式将作品开源，其目的有二，一是因为我觉得差不多可以拿出手了，该有的功能差不多完整了，即时有缺少，比如文件夹、多桌面、应用码头（这些功能在最新版本里都已实现），但这已经不影响一个系统的正常使用了，已经具备二次开发的条件了，其二就是毕竟开发快半年了，自己的毅力有点变弱，我不是一个很高尚的人，所以我很渴望能通过HoorayOS给我的生活带点收入，不用太多，至少能证明我这半年的努力不是一场闹剧。

开源后我把框架改名叫HoorayOS，因为近半年的开发，我发现这种模式不能局限于CMS，因为这种web桌面式的操作模式如果用在后台，那就大大失去了它的魅力，所以我将它改名，并美其名曰叫框架，因为我不做太多的功能，个性化的功能我一律摒弃，我只做框架本身可能会涉及到的功能。这样可以方便二次开发人员专注于系统开发，而不是修改框架。

开源后，得到了大部分人的支持，但这名字也惹来了一些人的吐槽。至今我也很后悔当初改名叫Hooray Desktop会不会更好，毕竟OS这个饼画的太大了，大到我自己都有点吃不下。

开源后的那一阵子，动力还是挺足的。原因在于有很多人联系我，说想和我合作，帮他们二次开发系统，因为工作原因，大部分我还是推了，因为二次开发的项目太大，加上我不能全职开发，只能抽下班时间进行开发，开发周期比正常开发要长一倍左右，所以只接了几个简单定制的系统，因为功能不多，加上价钱合理，顺理成章的就接了。那段时间是美好的，有人为你的梦想买单，我相信那种感觉你也有过。

开源让我得到了好多，不仅仅是物质上的。我建了QQ群，吸引了很多HoorayOS爱好者，大家提了很多意见，发现了很多bug，为了后期更新版本减少了很大工作量，让我能听取更多方面的意见，融会贯通之后整理出合适的方案，再进行开发，同时还不用我测试，新版本上线都会有一帮人在测试。开源让我的开发效率提升了一个档次，这要换在以前，在制作新功能前，要一个人想好久；开发好后，又要一个个浏览器去测试。

至今，HoorayOS已经更新了4个版本了，后续框架基本的功能大致都完善好后，我将会考虑引入第三方的产品，比如网盘，因为框架本身很难做到这类功能，通过第三方的api进行连接，以插件的形式接入，让开发者想使用的时候只需修改一个参数就可以实现各种不同的第三方api，大大提高开发效率。

HoorayOS具体能走多远我不知道，但我知道它是我第一个正式的作品，我希望让大家都知道它，因为它承载着我的一个未完成的梦想。

本文链接

XAML实例教程系列 - 命名空间(NameSpace)

2012-05-28T06:14:00Z

上一篇曾提及XAML中，每个对象元素的声明是对.NET类进行一次实例化操作。XAML作为声明类语言，如何识别对象元素，并如何在.NET Framework中找到对应映射类呢？本篇将引入命名空间（NameSpace）的概念,涉及内容如下：

NameSpace命名空间格式
核心NameSpace命名空间
设计类NameSpace命名空间
自定义NameSpace命名空间
XAML命名空间的x:Class属性
XAML命名空间的x:Name属性和x:Key属性
XAML的x:ClassModifier属性和x:FieldModifier属性
Silverlight命名空间和Windows 8命名空间的不同

XAML命名空间的概念和C#代码中的Using，VB.Net代码中的Import相似，其作用是为对象元素的实例化提供引用类库声明。

简单的理解，当在XAML页面中需要调用某控件对象时，需要提前对该控件对象的类库进行引用声明，而定义XAML命名空间是类库引用声明的一种方法。

本篇将使用Visual Studio 11创建一个简单的Silverlight 5项目，通过对比Windows 8和Silverlight项目的命名空间，帮助理解命名空间的使用。

项目名：XamlGuideSL

Visual Studio 11生成的Silverlight 5默认命名空间代码如下：

对比上一篇Windows 8实例的命名空间代码：

通过比较以上两个命名空间定义，我们可以发现Windows 8和Silverlight 5具有类似的命名空间，例如：

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

xmlns:mc=http://schemas.openxmlformats.org/markup-compatibility/2006

在移植Silverlight项目到Windows 8平台过程中，WinRT XAML可以兼容Silverlight XAML代码，轻松实现应用平台移植。

NameSpace命名空间格式

在以上代码中<UserControl>或<Page>作为页面Root对象元素被声明，其开始标签<UserControl>或<Page>中，包含了多个“xmlns”特性，在XAML语法规则中，“xmlns”是属于强制关键字，被用来声明一个命名空间。其语法结构为“xmlns:”+“命名空间前缀名”，而对于默认命名空间，无需定义命名空间前缀名。

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

以上四个命名空间是Visual Studio 11创建默认项目时自动生成的，其中分别映射了实例化一个Silverlight或Windows 8空白页面所需要的公共类库。

核心NameSpace命名空间

在以上四个命名空间中，“xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"”和“xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"”是一个XAML页面的核心命名空间，

对于这两个命名空间的详细解释如下：

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"是默认命名空间，其中包含Silverlight或Windows 8核心类，提供两者基础应用元素支持，作为核心类库命名空间，无需定义命名空间前缀名，该命名空间默认作用于整个页面，从上述代码中可以看出<UserControl>，<Page>都属于该命名空间下的元素对象。作为默认命名空间，直接映射多个.Net Framework核心类库，例如，System.Windows, System.Windows.UIElements, System.Windows.Controls 等类库。
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"引用默认XAML类库，其中包含大量XAML语言通用功能类，其作用对页面XAML提供基础以及扩展功能支持。这个命名空间使用“x”作为前缀名，表示在XAML页面中可以使用“x:”引用该类库。其常用语法结构如下：<x:元素名 />。例如: <Grid x:Name=“LayoutRoot”/>

一个完整的XAML页面必须具备以上两个命名空间，否则将无法正常实例化。

设计类NameSpace命名空间

在设计XAML页面时，Visual Studio和Expression Blend同样需要XAML命名空间支持，帮助实现设计工具内的视图设计模式。所用到的默认命名空间如下：

xmlns:d=http://schemas.microsoft.com/expression/blend/2008，该命名空间引用Expression Blend辅助设计类库，对Visual Studio和Expression Blend视图设计模式提供支持，其实际设计中主要提供设计视图页面尺寸定制。
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"，该命名空间引用XAML语言辅助类库，对XAML提供辅助设计支持，主要功能是为XAML语法解析器提供辅助解释功能，例如，使用mc:Ignorable=“d”告知XAML解析器以“xmlns:d”为前缀的元素引用在运行时被忽略。从前文代码中可以看到，xmlns:d命名空间前缀名，使用Expression Blend辅助设计类库中的DesignHeight和DesignWidth，分别定义在设计工具下视图模式中页面显示尺寸，d:DesignHeight="300" d:DesignWidth="400"。正常来说，XAML语法解析器无法识别DesignHeight和DesignWidth，xmlns:mc命名空间则提供Ignorable标识在运行时忽略该引用声明，避免了在编译时XAML语法报错。

自定义NameSpace命名空间

在实际项目中，经常会遇到调用自定义控件类库，其调用方法可以从默认XAML命名空间声明转换得来。

例如，如果需要添加DataGrid数据控件到XamlGuideSL项目中，首先需要添加System.Windows.Controls.Data.dll引用文件到Silverlight项目引用文件目录，

然后在页面头部声明DataGrid控件所需要的命名空间，XAML页面才能在.Net Framework中初始化该控件。

从上图可以看出，添加命名空间引用时，Visual Studio 11自动智能感知，查询当前引用类库列表中所有可用引用，选择“System.Windows.Controls”,代码将自动填充到XAML页面。

自定义声明一个命名空间：xmlns:datagrid="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Data"这段代码中包含三部分的信息：

“xmlns:datagrid”命名空间前缀名，这个前缀名可以由开发人员自定义，但是必须由“xmlns:”作为起始，也就是说，datagrid可以被任何字符替换。根据开发命名标准，推荐开发人员使用简单的控件名表示，提高代码可读性；
“clr-namespace:System.Windows.Controls”表示该命名空间将映射到System.Windows.Controls 公共语言运行环境命名空间类；
“assembly=System.Windows.Controls.Data"”表示DataGrid隶属于System.Windows.Controls.Data.dll动态连接库中，在编译时，该DLL文件将被封装到XAP压缩文件包中。

完成声明后，调用方法如下：

<datagrid:DataGrid />

在本篇实例中，使用Expression Blend生成Sample DataSource，绑定到DataGrid控件作为演示（具体步骤这里不再重复，可参考：Expression Blend实例中文教程(6) - 项目控件和用户交互控件快速入门），最终调用和显示效果如下：

XAML命名空间的x:Class属性

Silverlight和基于C#,VB.NET的Windows 8 Metro应用是用户界面代码和后台逻辑代码分离的。其中XAML代码用于绘制用户界面，后台逻辑代码可由开发人员喜好选择C#或者Visual Basic。XAML既然继承自XML，也就是说, 其本身不具备事件控制的代码特性。而为了使XAML能够实现与后台逻辑代码交互，则需要在XAML页面代码开始时声明x:Class属性，使其赋值当前页面对应后台页面命名空间，Runtime语法解析器将根据x:Class提供的页面命名空间名自动创建一个类，该类继承自x:Class属性隶属对象元素。完成类创建后，将判断是否该页面是否具有同名后台代码类，如果有，将合并当前生成类到后台代码类中。XAML的x:Class属性只能在页面的根元素中声明一次，表示在页面创建时，保证其包含的所有元素对象仅能被实例化一次。其声明语法格式如下：

<元素对象 x:Class=“命名空间.调用类名;assembly=程序集名称”…>

</元素对象>

下面我们尝试从实例中理解x:Class属性，在XamlGuideSL项目中,<UserControl>定义x:Class="XamlGuideSL.MainPage", 其含义是该XAML页面继承自UserControl对象元素，其对应的后台代码页面为“XamlGuideSL.MainPage.cs”,XAML语法解析器将自动检测并且链接该XAML页面到“XamlGuideSL.MainPage.MainPage.cs”，在XAML实例化时，将执行“XamlGuideSL.MainPage.cs”后台代码中的构造函数。

从Visual Studio 11默认生成后台代码中可以看出当前页面命名空间是“XamlGuideSL”，Mainpage类继承自UserControl。在构造函数MainPage()中，将执行InitializeComponent()方法，对XAML页面对象元素进行属性设置，数据绑定以及声明事件等操作。由此可见，InitializeComponent()方法在Silverlight应用初始化时具有非常重要的作用，不能从构造函数中删除。而在创建新的构造函数时，也必须调用该方法，对XAML对象元素进行实例化操作。

XAML命名空间的x:Name属性和x:Key属性

在XAML代码设计时，经常需要对控件或者资源进行命名，所需要使用的属性是x:Name和x:Key。下面的表格对两者使用范围进行对比和描述：

在实际项目中，控件元素和资源的命名规则是只在需要的时候对控件和资源进行命名操作，这样的好处有以下几点：

减小XAP文件或应用尺寸，加快InitializeComponent初始化调用速度;
易于项目维护;

XAML的x:ClassModifier属性和x:FieldModifier属性

x:ClassModifier属性和x:FieldModifier属性主要功能是支持在XAML中设置后台对应代码类存取属性.

x:ClassModifier属性仅能被用于根元素对象，例如，<UserControl>；

x:FieldModifier属性仅能被用于控件元素对象，例如,<TextBox>；

在XAML代码中使用x:ClassModifier属性和x:FieldModifier属性后，客户端编译后，会在.g.cs或者.g.vb自动生成代码中重新设置类存取属性。这里需要注意，对于x:ClassModifier根元素对象类存取属性的控制，在XAML代码中修改后，必须同时手工修改对应后台代码中对应元素对象类的存取属性。例如：在下面代码中修改UserControl类存取属性为internal,

同时也需要修改对应后台代码XamlGuideSL.MainPage类的存取属性，Visual Studio 11默认创建属性为Public，

查看.g.cs自动生成代码，

MainPage的类存取属性被编译为internal。

由此，x:FieldModifier属性的使用不需要手工修改对应控件后台代码存取属性，直接由XAML设置即可。

Silverlight命名空间和Windows 8命名空间的不同

例如，我们将添加新的引用“MyAssembly.dll”到项目，并且添加新的命名空间"MyAssembly.MyNamespace"到XAML代码，在Silverlight中，命名空间定义：

xmlns:local="clr-namespace:MyAssembly.MyNamespace;assembly:MyAssembly"

在Windows 8中，命名空间将使用“using”替换“clr-namespace“，

xmlns:local="using:MyAssembly.MyNamespace"

今天暂时介绍到这里，欢迎留言讨论。

源代码下载

欢迎大家留言交流，或者加入QQ群交流学习：

22308706(一群) 超级群500人
37891947(二群) 超级群500人
100844510(三群) 高级群200人
32679922(四群) 超级群500人
23413513(五群) 高级群200人
32679955(六群) 超级群500人
88585140(八群) 超级群500人
128043302(九群企业应用开发推荐群) 高级群200人
101364438(十群) 超级群500人
68435160(十一群企业应用开发推荐群)超级群500人

本文链接

新浪微博SDK for .Net 4.0第二版正式发布了。

2012-05-28T06:10:00Z

可以去此处查看第一版的特性和使用方法

首先感谢各位热心博友提出了意见和建议，有了大家的支持，做起事情来就更有动力了^_^

第二版SDK的一些新特性

采用了新浪官方主推的OAuth2.0进行授权和认证
所有接口都升级到了官方V2版的API，也就是说可以用官方V2版的API机型操作了
参考了官方PHP版的SDK，将授权认证的方法和API操作的方法独立成了两个类，逻辑上更清晰了

使用方法

第一步：授权认证

传统方式（适用于Web项目）

初始化OAuth类
获取Authorize地址
访问Authorize地址并进行授权，取得code
使用OAuth类的GetAccessTokenByAuthorizationCode方法获得AccessToken
完成

模拟登录方式（适用于Winform项目和其他项目类型）

初始化OAuth类
调用OAuth类中的ClientLogin方法，传入账号、密码以及绑定回调地址（ClientLogin方法模拟了上述整个授权过程，实现了一件登录和授权）
完成

第二步：实例化操作类

至此，授权完成了。接下来用刚才的OAuth作为参数来实例化一个Client操作类。

Client实例化以后，通过API命名空间，即可调用各种方法。

简单的使用案例

基于正常的授权认证流程

//初始化oAuth，准备认证
var oauth = new NetDimension.Weibo.OAuth("1028898141", "78be07c9bcfa30b7871788d3778ce131");
/*
* 正常的流程或Web流程：
* 1. 获取授权地址
* 2. 访问授权地址
* 3. 授权成功后自动跳转至callback指定的网站，并获得code
* 4. 通过code换取access token
*/

var url = oauth.GetAuthorizeURL("https://api.weibo.com/oauth2/default.html", ResponseType.Code);//根据授权方法，获得授权地址。
System.Diagnostics.Process.Start(url);//模拟弹窗，Console方式直接打开了浏览器，Web项目可以根据需求来使用iframe、新窗口等打开此页面。
//打开浏览器，进行授权流程，之后会跳转到callback指定的网址，并获得code
//填写刚才得到的code
Console.Write("请填写浏览器地址中的Code参数：");
var code = Console.ReadLine();
//根据code获取AccessToken
var accessToken = oauth.GetAccessTokenByAuthorizationCode(code, "https://api.weibo.com/oauth2/default.html");//注意：callback指定的url必须一致
//看看我们获得的access token
Console.WriteLine(accessToken);
//至此，我们已经获得了AccessToken

使用简化流程之后的ClientLogin方法

//初始化oAuth，准备认证
var oauth = new NetDimension.Weibo.OAuth("1028898141", "78be07c9bcfa30b7871788d3778ce131");
//简化的认证流程，直接调用ClientLogin。这个方法不需要去申请password方式的认证，只是模拟了上面的步骤并进行了封装
var result = oauth.ClientLogin("<你的微博账号>", "<你的微博地址>", "https://api.weibo.com/oauth2/default.html");
//返回值为bool型，为true则表示授权、登录成功。为false的话，要不密码错了，要不就是回调地址和新浪后台里面填写的不一样

Console.WriteLine(oauth.AccessToken);
//看看这里获得的AccessToken，理论上应该是和上面那种方法获得的Token一样。

接口调用示例

在上面的步骤中获得AccessToken后，直接将OAuth对象作为参数来实例化一个操作类Client实例。之后的事情，你懂的^_^

//实例化一个操作类，用刚才成功获得了AccessToken的OAuth实例
NetDimension.Weibo.Client Sina = new NetDimension.Weibo.Client(oauth);
//调用各种方法吧
Console.WriteLine(Sina.API.Statuses.FriendsTimeline());//获取最新微博
Console.WriteLine(Sina.API.Statuses.Update("发布一条微博来测试下火力！" + DateTime.Now.ToLongTimeString()));//发条微博测试下，不加后面的时间，会产生Exception，不能重复发微博
//来个取数据的例子
var mentions = Sina.API.Statuses.Mentions();//通过“提到我的微博”接口来获得数据
//到 http://open.weibo.com/wiki/2/statuses/mentions 查一下mentions的数据结构，接下来咱们操作下数据。
foreach (var status in mentions.statuses)
{
if (status.IsDefined("user"))//这里要判断下是不是有user这个项，一般微博被删除了就不会返回user，直接xxx.user要出错。
{
Console.WriteLine(string.Format("{0} 说：{1}", status.user.screen_name, status.text));//打印用户名和他说的内容
}
}

类及方法简要说明

SDK中的相关方法及方法中的返回值与官方API一致，因此不对此部分内容进行列举。详细的返回内容请参考官方的API文档。

OAuth类，封装了授权、认证、登录等操作方法。

OAuth类
OAuth	构造函数
GetAuthorize	获取应用授权地址，并设置返回方式
GetAccessTokenByAuthorizationCode	通过code方式获取AccessToken
GetAccessTokenByAuthorizationCode	通过password方式获得AccessToken，需要官方申请权限。
GetAccessTokenByRefreshToken	通过token方式获取AccessToken，也需要官方申请权限后才能获得RefreshToekn
ClientLogin	客户端登录，使用模拟code授权的方式完成授权和登录过程（俗称一键登录）
VerifierAccessToken	验证AccessToken的有效性

Client类，封装了官方API中微博各项操作方法。所有方法均按照分类封装在API命名空间中，方法按照官方的文档进行了分类。参数及返回值可参考官方文档，此处就不再一一列举。

Client类
Client	构造函数
API	官方所有接口方法的封装。已经按照官方文档中的分类对各方法进行了封装，方法名称也基本和官方的API保持一致。返回值为JSON，使用DynamicJson进行了动态化，可直接使用xxx.xxx.xxx的形式获取内容，返回内容的数据结构请参考官方文档。

本人微博：http://weibo.com/xuanchenlin

项目托管地址：http://weibosdk.codeplex.com

欢迎关注，欢迎交流！

本文链接

Cowboy 源码分析(十)

2012-05-28T05:10:00Z

在上一篇中，由于我对 erlang:decode_packet/3 方法的不理解，所以造成了对 cowboy_http_protocol:request/2 方法的困惑，这一篇，我将结合 erlang Debugger 工具和 HttpFox 工具来看看，究竟是怎么回事。Debugger 我就不多说了，了解erlang的朋友，应该都知道这个工具，如果你是初学，没用过这个工具，可以参考我之前的一篇文章，使用 debugger 简单调试 erlang 简单介绍了这个工具。HttpFox An HTTP analyzer addon for Firefox，HttpFox monitors and analyzes all incoming and outgoing HTTP traffic between the browser and the web servers. 简单说，HttpFox 可以用来抓取 HTTP 包。

首先，启动 debugger：debugger:start(). 如果出现下图的界面，表示启动成功：

接着，添加 cowboy_http_protocol 模块，并设置断点，如下图：

好了，接下来，我们启动 cowboy_examples：cowboy_examples:start(). 服务器启动完成，

我们打开火狐，同时启动 HttpFox，访问 http://localhost:8080/ 如下图:

同时，debugger会出现如下界面：

我们点击 Next 往下走，当我们程序走到 cowboy_http_protocol:wait_request/1 时，我们就可以从调试器中，右下角的监视器中看到从Socket中读取的数据Data了，如下图：

这个Data完整的数据如下：

<<"GET / HTTP/1.1\r\nHost: localhost:8080\r\nUser-Agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:12.0) Gecko/20100101 Firefox/12.0\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\nAccept-Language: zh-cn,zh;q=0.8,en-us;q=0.5,en;q=0.3\r\nAccept-Encoding: gzip, deflate\r\nConnection: keep-alive\r\n\r\n">>

对比我们从 HttpFox 看到的数据，如下图：

这里，我们发现，两者的内容是一模一样的，只不过 HttpFox 工具，把排版弄好看了，每一行的数据分开显示。

我们继续往下走，看下 cowboy_http_protocol:parse_request/1 方法：

我们从监视器可以看到， Buffer，Request，Rest 的值，分别如下：

Rest = <<"Host: localhost:8080\r\nUser-Agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:12.0) Gecko/20100101 Firefox/12.0\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\nAccept-Language: zh-cn,zh;q=0.8,en-us;q=0.5,en;q=0.3\r\nAccept-Encoding: gzip, deflate\r\nConnection: keep-alive\r\nCache-Control: max-age=0\r\n\r\n">>
Request = {http_request,'GET',{abs_path,<<"/">>},{1,1}}
Buffer = <<"GET / HTTP/1.1\r\nHost: localhost:8080\r\nUser-Agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:12.0) Gecko/20100101 Firefox/12.0\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\nAccept-Language: zh-cn,zh;q=0.8,en-us;q=0.5,en;q=0.3\r\nAccept-Encoding: gzip, deflate\r\nConnection: keep-alive\r\nCache-Control: max-age=0\r\n\r\n">>

现在来看，我们对 erlang:decode_packet(http_bin, Buffer, []) 这个方法，比以前是不是了解更多了，如果你觉得这样还不够，那么可以看下源码，欢迎大家跟我分享。

知道了 Request 和 Rest 的值，我们就可以很好的了解 cowboy_http_protocol:request/2 方法：

request({http_request, Method, {abs_path, AbsPath}, Version},
State=#state{socket=Socket, transport=Transport,
req_keepalive=Keepalive, max_keepalive=MaxKeepalive,
onresponse=OnResponse, urldecode={URLDecFun, URLDecArg}=URLDec}) ->
URLDecode = fun(Bin) -> URLDecFun(Bin, URLDecArg) end,
{Path, RawPath, Qs} = cowboy_dispatcher:split_path(AbsPath, URLDecode),
ConnAtom = if Keepalive < MaxKeepalive -> version_to_connection(Version);
true -> close
end,
parse_header(#http_req{socket=Socket, transport=Transport,
connection=ConnAtom, pid=self(), method=Method, version=Version,
path=Path, raw_path=RawPath, raw_qs=Qs, onresponse=OnResponse,
urldecode=URLDec}, State);

我们可以从 debugger工具上看到，这些参数的值：

好了，今天就到这，下一篇，我们将继续跟大家分享，接下来的代码，谢谢大家支持。

本文链接

Fetch XML Link Entity 数量限制10个，那就不用LinkEntity吧

2012-05-28T04:58:00Z

页面上有一个Lookup field，当选择一个记录时，同时要把这个记录的其他值也带到本页面来，其中有好多是Lookup来的。

开始我用LinkEntity来取得它们的名字值，但是后来发现LinkEntity有数量限制，每条查询语句只能有10个LinkEntity，超过就报错，Advanced Find里也是一样的。

所以，用LinkEntity并不是一个好办法，而且我只是要取得一个名字的值而已，直觉告诉我不用那么麻烦的。

研究了一下，其实Fetchxml取的Lookup的值，不仅有GUID,名字的值也取到了，只不过名字值要经过一定的步骤转化才能拿到。

下面是具体方法：

首先，我们从返回的xml对象中取出我们的要的元素：

var county = oXmlDoc.getElementsByTagName("my_county")[0];

调用一个方法来取得名字值：

var countyName= GetAttributeName(county);

GetAttributeName方法，其实就是把字符串转化为Xml Node，再对里面的属性进行分析，得到我们要的那个属性的值：

好的，这样Id和Name都有了，就可以给目标设值了。

本文链接

ASP.NET MVC 简单的分页思想与实现

2012-05-28T04:26:00Z

作为一个程序猿，数据分页是每个人都会遇到的问题。解决方案更是琳琅满目，花样百出。但基本的思想都是差不多的。

下面给大家分享一个简单的分页器，让初学者了解一下最简单的分页思想，以及在ASP.NET MVC中的简单实现与应用。

一，定义分页器类

在ASP.NET MVC中，分页的数据源可能是各种不同的类型，所以最好使用泛型来定义。

public class PagingHelper<T>

二，基本三要素

实现分页人所共知的三个基本属性:

DataSource：数据源，要知道数据源共计多少条数据，会对应一个数据源的方法－Count()，
PageSize：来描述每页显示的记录的条数。
PageIndex：当前页的索引值，一般第一页的索引值为0，当然为了表示方便，可以从1开始，并且后面默认为从1开始。

//分页数据源
public IEnumerable<T> DataSource { get;private set; }
//每页显示记录的数量
public int PageSize { get; private set; }
//当前页数
public int PageIndex { get; set; }

三，扩展属性

有了上述三要素，我们可以推论其他三个重要属性

PageCount：总页数，其值取大于或等于 DataSource.Count/PageSize 的最小整数，比如5.2页，其实就是6页。
HasPrev：用来判断是否有上一页，如果索引 PageIndex 从1开始，那就是判断 PageIndex > 1 是否成立。
HasNext：用力判断是否有下一页，如果索引 PageIndex 从1开始，需判断 PageIndex < PageCount 是否成立。

//分页总页数
public int PageCount { get;private set; }
//是否有前一页
public bool HasPrev { get { return PageIndex > 1; } }
//是否有下一页
public bool HasNext { get { return PageIndex < PageCount; } }

四，核心方法

最后就是需要实现分页的核心－获取分页数据的方法:

GetPagingData()：获取当页的数据，一般常用的手段是跳过PageIndex*PageSize条记录，然后取PageSize条数据。

在.NET中有很多方法可以实现这一过程，这里介绍2个最简单的:

方法1,从序列的指定位置返回指定数量的连续元素:

public static IEnumerable<TSource> Take<TSource>( this IList<TSource> list, int start, int count )
{
for ( int index = start; index < Math.Min( start + count, list.Count ); index++ )
{
yield return list[index];//yield关键字的用法大家可以参详其他文章
}
}

那么我们的GetPagingData()方法就要这么写:

//获取当前页数据
public IEnumerable<T> GetPagingData()
{
return DataSource.ToList<T>().Take((PageIndex-1)×PageSize,PageSize);
}

其实我更倾向与第二种方法，就是使用IEnumerable<T>的扩展方法:

Skip(int count)：跳过序列中指定数量的元素，然后返回剩余的元素
Take(int count)：从序列的开头返回指定数量的连续元素。

那么我们的GetPagingData()只需要这么写就完事:

//获取当前页数据
public IEnumerable<T> GetPagingData()
{
return DataSource.Skip((PageIndex - 1) * PageSize).Take(PageSize);
}

这句代码就是跳过 PageIndex - 1) * PageSize 条数据，再取 PageSize 条数据，刚刚好就是我们需要的当前页的数据。

五，构造函数

实例化一个分页器的时候，我们需要对它进行初始化:

public PagingHelper(int pageSize, IEnumerable<T> dataSource)
{
this.PageSize = pageSize > 1 ? pageSize : 1;
this.DataSource = dataSource;
PageCount = (int)Math.Ceiling(dataSource.Count() / (double)pageSize);
}

真正的使用中，你可以重写分页器类，根据你的需要来控制哪些字段是只读的。比如你想随时改变页面元素的数量，那么你可以把PageSize设置为可读写的属性。

至此，这个分页器我们就完工拉。

六，与ASP.NET MVC的简单结合

首先我们通过VS创建一个空的基于Razor视图引擎的ASP.NET MVC3 Web应用程序，命名为JohnConnor.Web

对创建过程或Razor不太了解的看官，请移步 ASP.NET MVC Razor视图引擎攻略 <传送门> ，这里就不再赘述了。

然后我们需要进行以下几步

1，Models文件夹下，添加Student.cs文件，添加以下代码，为了演示方便这里模拟了一个数据源，实际中的数据源可能来自数据库。

public class Student
{
public int Id { get; set; }
public string Name { get; set; }
}
public static class Students
{
public static IEnumerable<Student> data
{
get
{
return new List<Student>()
{
new Student{ Id=0, Name="John"},
new Student{ Id=1, Name="Marry"},
new Student{ Id=2, Name="Andy"},
new Student{ Id=3, Name="Tom"},
new Student{ Id=4, Name="Lydia"},
new Student{ Id=5, Name="Chris"},
new Student{ Id=6, Name="Justin"},
new Student{ Id=7, Name="Susan"}
};
}
}
}

2，Models文件夹下，添加PagingHelper.cs文件，添加我们上述分页器类。

public class PagingHelper<T>
{
//分页数据源
public IEnumerable<T> DataSource { get; private set; }
//每页显示记录的数量
public int PageSize { get; private set; }
//当前页数
public int PageIndex { get; set; }
//分页总页数
public int PageCount { get; private set; }

//是否有前一页
public bool HasPrev { get { return PageIndex > 1; } }
//是否有下一页
public bool HasNext { get { return PageIndex < PageCount; } }
//构造函数
public PagingHelper(int pageSize, IEnumerable<T> dataSource)
{
this.PageSize = pageSize > 1 ? pageSize : 1;
this.DataSource = dataSource;
PageCount = (int)Math.Ceiling(dataSource.Count() / (double)pageSize);
}
//获取当前页数据
public IEnumerable<T> GetPagingData()
{
return DataSource.Skip((PageIndex - 1) * PageSize).Take(PageSize);
}
}

3，在Controller文件夹下添加控制器命名为HomeController，添加以下代码。

public class HomeController : Controller
{
public ActionResult Index(int pageIndex=1)
{
PagingHelper<Student> StudentPaging = new PagingHelper<Student>(2, Students.data);//初始化分页器
StudentPaging.PageIndex = pageIndex;//指定当前页
return View(StudentPaging);//返回分页器实例到视图
}
}

4，在View文件夹下添加Home文件夹，并新增视图文件Index.cshtml，添加以下代码。

@using JohnConnor.Web.Models
@model PagingHelper<Student>
@{
ViewBag.Title = "Index";
}
<h2>Index</h2>
@foreach (var Data in Model.GetPagingData())
{
<p>ID:@Data.Id Name:@Data.Name</p>
}
<p>
@if (Model.HasPrev)
{
<a href="@Url.Action("Index", "Home", new { pageIndex = Model.PageIndex - 1 })">上一页</a>
}
else
{
<em style="color:Gray">上一页</em>
}
@if (Model.HasNext)
{
<a href="@Url.Action("Index", "Home", new { pageIndex = Model.PageIndex + 1 })">下一页</a>
}
else
{
<em style="color:Gray">下一页</em>
}
</p>

5，在Global.asax中配置路由，我们修改一下默认路由就可以了。

public static void RegisterRoutes(RouteCollection routes)
{
routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

routes.MapRoute(
"Default", // 路由名称
"{controller}/{action}/{pageIndex}", // 带有参数的 URL
new { controller = "Home", action = "Index", pageIndex = UrlParameter.Optional } // 参数默认值
);

}

现在保存之后F5运行，就可以看到一个简单的分页程序了。

URL在进行了路由配置之后，也不会再是http://localhost:1234/Home/Index?pageIndex=1

而变成了http://localhost:1234/Home/Index/1 这样的静态URL，更简洁，更美观。

---------------------------------------End---------------------------------------

这篇中的提到分页器，只是一个很简易的分页思想的实现，其实本身的性能还是有待提高的。

希望能抛砖引玉，哪位大神能分享出性能更强大的分页程序。

文章中最后提到了URL重写与优化，如果看官们有兴趣，可以参见我之前的文章：

ASP.NET MVC URL重写与优化(初级篇)-使用Global路由表定制URL

ASP.NET MVC URL重写与优化(进阶篇)-继承RouteBase玩转URL

本文链接

Ubuntu 12.04 LTS 上安装swift1.4.8

2012-05-28T04:25:00Z

0.环境
1.安装依赖库
2.准备磁盘
3.构建ring
4.安装swift

4.1 apt-get install安装
4.2源代码安装

5.更改配置文件
6.启动服务

0.环境

操作系统：ubuntu 12.04 LTS，swift版本：1.4.8。四台机器，IP地址分别为：

192.168.1.11,

192.168.1.12,

192.168.1.13,

192.168.1.14.

由于swift的全分布式特点，故每个节点都作为存储节点，并选用192.168.1.11作为proxy server。

磁盘分区如下：

1.安装依赖库

所有节点都需要安装的：

python-netifaces
python-setuptools
python-eventlet
python-pastedeploy
python-xattr
xfsprogs

以上软件包可以直接使用apt-get install来安装。一个比较特殊的包：python-webob。该包在ubuntu软件源中的版本是1.1.1（ubuntu12.04）.而这个版本有个bug，会导致swift client使用HEAD无法正常的获取content-length。比如，获取文件尺寸，得到的结果永远是 13。解决方法是在ubuntu软件包网站下载1.0.8版本的deb安装包，然后手工安装。安装包我已经下载，见附件。

2.准备磁盘

选取某一个磁盘分区做存储，本例使用sda5.

mkfs.xfs -i size=1024 /dev/sda5

在/etc/fstab中添加

/dev/sda5 /srv/node/sda5 xfs noatime,nodiratime,nobarrier,logbufs=8 0 0

挂载磁盘分区

sudo mount /srv/node/sda5

3.构建ring

swift-ring-builder account.builder create 18 3 1

18: 用于指定分区数。分区数目为2的幂次，如18，则分区数是2的18次方。

3：文件副本数目

1：分区移动的最小时间间隔，单位是小时。

swift-ring-builder account.builder add z1-192.168.1.11:6002/sda5 100
swift-ring-builder account.builder add z2-192.168.1.12:6002/sda5 100
swift-ring-builder account.builder add z3-192.168.1.13:6002/sda5 100
swift-ring-builder account.builder add z4-192.168.1.14:6002/sda5 100

100 代表设备的权重。可以根据磁盘的容量设定对应值，比如2T的100，则1T的可以是50。

swift-ring-builder account.builder可以检测配置，确认无误后，使用swift-ring-builder account.builder rebalance重新平衡。成功之后会在当前目录生成 account.ring.gz 文件。

使用同样的方式构建 container和object的ring。container服务端口是6001，object的服务端口是6000。特别需要注意的是：一旦ring投入使用，更改配置的时候要针对该ring，不能重新构建，否则，很多数据可能会404.

最后将生成的account.ring.gz,container.ring.gz,object.ring.gz分发至各个节点的/etc/swift目录。

4.安装swift

4.1 apt-get install安装
sudo apt-get install swift即可。

4.2源代码安装
   从github上下载源代码。

git clone https://github.com/openstack/swift.gitswift
cd swift
git checkout 1.4.8   #使用git tag 可以查看所有的版本
sudo python setup.py install --record log.txt   # --record log.txt 可以记录安装信息，需要卸载的时候只需执行sudo cat file.txt | xargs rm -rf 。
注：使用apt-get install 安装的方式更利于维护和升级。如果要做二次开发的话，使用源代码安装比较好。
5.更改配置文件
    所有的节点都需要配置文件如下：

     /etc/rsyncd.conf     #所有机器配置一样，系统中没有，见附件。
    /etc/default/rsync   #系统自带，只需要将RSYNC_ENABLE=false更改为RSYNC_ENABLE=true。
    /etc/swift/swift.conf
    /etc/swift/account-server.conf
     /etc/swift/container-server.conf
     /etc/swift/object-server.conf

        proxy server还要 /etc/swift/proxy-server.conf。除此之外，proxy-server需要安装memcached(sudo apt-get install memcached)做缓存。
        其他的配置见附件。

6.启动服务
如果采用源代码安装，则需要添加swift用户(当然也可以不添加，在配置文件里面指定相应的用户名即可)

sudo groupadd swift
sudo useradd swift -g swift.
    更改文件的所有者：

sudo chown -R swift:swift /etc/swift
sudo chown -R swift:swift /srv/node
    所有节点启动服务：

sudo swift-init object-server start
sudo swift-init object-replicator start
sudo swift-init object-updater start
sudo swift-init object-auditor start
sudo swift-init container-server start
sudo swift-init container-replicator start
sudo swift-init container-updater start
sudo swift-init container-auditor start
sudo swift-init account-server start
sudo swift-init account-replicator start
sudo swift-init account-auditor start
    启动proxy-server :

sudo swift-init proxy-server start

参考资料：
                1.openstack 官方文档http://docs.openstack.org/trunk/openstack-object-storage/admin/content/ch_installing-openstack-object-storage.html
                2. 使用Swauth认证多节点安装Swift http://blog.csdn.net/cywosp/article/details/7428769

通过为知笔记发布

附件列表

本文链接

[开源]KJFramework.Message 高性能二进制消息框架 - 多元素数组的高性能优化

2012-05-28T04:25:00Z

框架的介绍:

1. 已经完成了对于消息内部类型的支持(int, short, long, uint, ushort, ulong, bool ,float, double, byte, sbyte, byte[], decimal, DateTime, IntPtr, Guid)
2. 支持内部序列化元数据(.NET可序列化的对象)
3. 对于智能对象内部的“智能对象”提供支持。支持迭代元数据转换。

[说明：]
KJFramework框架中内置了一套，可以将网络传输实体自动转换为二进制元数据的能力框架。
使用此框架，将使得用户不在关心底层传输时对于二进制编码/解码的繁琐过程，解放程序员的脑力劳动。
目前此内置框架被初步定义在命名空间：KJFramework.Messages内，拥有独立Assembly.
对于智能二进制消息框架, 内部提供了对于诸多类型的支持，甚至可以用于在不编写序列化代码的情况下，
将一个网络传输实体转换为二进制操作。
这一切的操作，都全部由内部框架完成，通过简单的属性标签，就可以实现很强大的转换功能。
目前智能二进制消息框架中，仍保留了内部扩展能力，日后扩展后，将会通过配置文件来增强配置能力。

新优化

1. 我们不难发现，在数据的传输中，如果在特定的场景下，对于数组的元素数量需求很高，那这将是一个很大的性能瓶颈。
经过测试，我们定义：数组元素个数10，为性能瓶颈的边界值，如果一个数组元素超过此数量则会产生非常大的性能瓶颈。
所以，就在现在，我们特地为常用的数组类型增加了对于超大量数组元素个数的高性能支持，这是一个令人兴奋的优化点。
此次优化所涉及的数组元素类型有： int[], short[], float[], double[], byte[]
2. 除此之外，我们还发现，原来框架中对于byte[]类型的序列化/反序列化并没有提供很好的高性能支持，本次更新中，我们特地
提供了对于这个类型的高性能序列化/反序列化实现。
3. 为本次的更新提供了相关的单元测试

新能力

1. 新增轻量级序列化/反序列化帮助器

(1). 增加了DataHelper, 这是一个轻量级的序列化/反序列化帮助器
哦，是的，框架中除了需要为智能对象提供序列化/反序列化之外，我们的程序中
还会经常涉及到一些其余数据类型的二进制数据操作，在以往，我们不得不单独为
这些类型做数据处理，现在，这一切都会变得容易起来，那就是我们提供了轻量级的
DataHelper! 好吧，当你的工作中涉及到int, long, array,等等小数据类型的二进制操作时，
就来尝试一下吧。

2. 新增对于.NET可空值类型的支持:

(1). 这是一个令人振奋人心的消息，不是吗？当我们定制协议的时候，再也不会为了某些值类型的协议字段是否需要下发而苦恼了！现在，一切都变得更加美好，如果我们在定制自定义实体的时候，期望某些值类型字段在某些场景下不需要参与序列化，以省去
消息序列化的大小，那么，尝试把这些字段设置为可空类型吧(比如 int?,double?,short?......等等).
(2). 通过对于可空类型序列化/反序列化成本的评估，我们发现，为当前框架加入此能力，并不会明显的拖慢原有框架性能，
只会在原有速度上平均慢去 60~100ms+(量级序列化/反序列化的效果), 所以，我们认为这种成本是可以接受的。
2. 增加了对于可空类型序列化/反序列化的多个单元测试

3. 可自定义的固定字节长度类型:

在我们的系统中，通常会存在一种可预知长度的小对象，而这种对象有的时候还是不可缺少的，比如如下这个例子:

//这个UID类型只是一个例子，实际中可能还会包含多个能力字段
public class UID : IntellectObject
{
[IntellectProperty(0)]
public int UserId { get; set; }
[IntellectProperty(1)]
public bool IsDirty { get; set; }
}

从上述类定义我们不难看出，一个UID类型标示了一个唯一用户，这种对象，在很多业务场景下都是非常常见的。
然而，在服务间的通讯协议上，这种类型的传递也是很频繁的。那么，如果通讯协议中频繁的包含此对象，其实是很消耗性能的，为什么呢？
因为，按照此框架的规定，用户自定义的类型，在序列化/反序列化的时候是需要遵循TLV模式的。这样的话，每次每一个字段都会带有4个字节的长度(L).
对于很多系统中的对象，TLV是没有问题的，但是总有类似于上述的自定义对象，在序列化的时候完全可以把这4个字节的长度给省去。

那么，该怎么办呢？让我们来考虑以下消息场景，好吧，我们定义了一个消息，来传递该对象:

public class DemoMessage : IntellectObject
{
[IntellectProperty(0)]
public UID Uid { get; set; }

/*Other properties.*/
}

每一次这种消息的传递，我们都不得不使用TLV的形式，将UID对象进行序列化，每次都有字节数量上的冗余。那么，我们何不进行以下优化呢？

#新能力：

我们特地的考虑到了以上需求，为KJFramework.Message消息框架内部增加了对于此场景的支持。对于新版本的更新中，我们外露了一个类型
"FixedTypeManager", 通过该类型，使得用户可以在程序初始化的时候打入自定义的固定字节数类型需求。
当然，我们需要为这个上述的自定义类型提供自身的处理器，并将处理器加入到框架内部的处理器集合中。这一切看起来就像是这样：

internal class UIDIntellectTypeProcessor : IntellectTypeProcessor
{
#region Constructor

public UIDIntellectTypeProcessor()
{
_supportedType = typeof (UID);
}

#endregion

#region Overrides of IntellectTypeProcessor

/// <summary>
/// 从第三方客户数据转换为元数据
/// </summary>
/// <param name="attribute">当前字段标注的属性</param>
/// <param name="value">第三方客户数据</param>
/// <returns>返回转换后的元数据</returns>
/// <exception cref="Exception">转换失败</exception>
public override byte[] Process(IntellectPropertyAttribute attribute, object value)
{
UID uid = (UID) value;
//fixed data length.
byte[] data = new byte[5];
Buffer.BlockCopy(BitConverter.GetBytes(uid.UserId), 0, data, 0, 4);
data[4] = (byte) (uid.IsDirty ? 1 : 0);
return data;
}

/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="attribute">当前字段标注的属性</param>
/// <param name="data">元数据</param>
/// <returns>返回转换后的第三方客户数据</returns>
/// <exception cref="Exception">转换失败</exception>
public override object Process(IntellectPropertyAttribute attribute, byte[] data)
{
return Process(attribute, data, 0, 5);
}

/// <summary>
/// 从元数据转换为第三方客户数据
/// </summary>
/// <param name="attribute">当前字段标注的属性</param>
/// <param name="data">元数据</param>
/// <param name="offset">元数据所在的偏移量</param>
/// <param name="length">元数据长度</param>
/// <returns>返回转换后的第三方客户数据</returns>
/// <exception cref="Exception">转换失败</exception>
public override object Process(IntellectPropertyAttribute attribute, byte[] data, int offset, int length = 0)
{
int userId = BitConverter.ToInt32(data, offset);
bool isDirty = BitConverter.ToBoolean(data, offset + 4);
return new UID {UserId = userId, IsDirty = isDirty};
}

#endregion
}

当然，在程序初始化的时候还需要执行一句话，这句话看起来就像这样：

//add UID type to fixed binary data length type.
FixedTypeManager.Add(typeof (UID), 5);

这句话的意思是说，我的系统中，我需要为UID类型设定为支持固定字节数的类型。以后，再遇到UID类型序列化/反序列化的时候，
就会使用给出的字节长度来解析，整个的序列化/反序列化过程中，就不会存在L(4个字节的长度)了。怎么样，这一切都变得更简洁了，不是吗？
一个完整的Test Case,就像下面这样~

[TestMethod]
[Description("对于自定义可固定字节数类型的测试")]
public void FixedTypeManagaerTest()
{
//regist customer type processor.
IntellectTypeProcessorMapping.Instance.Regist(new UIDIntellectTypeProcessor());
//add UID type to fixed binary data length type.
FixedTypeManager.Add(typeof (UID), 5);
FixedFieldMessage fieldMessage = new FixedFieldMessage{Uid = new UID {UserId = 1, IsDirty = true}};
fieldMessage.Bind();
Assert.IsTrue(fieldMessage.IsBind);
//head total length(4) + property 0 id(1) + property 0 value(5)
Assert.IsTrue(fieldMessage.Body.Length == 10);
PrintBytes(fieldMessage.Body);

FixedFieldMessage newObj = IntellectObjectEngine.GetObject<FixedFieldMessage>(fieldMessage.Body);
Assert.IsNotNull(newObj);
Assert.IsTrue(newObj.Uid.UserId == 1);
Assert.IsTrue(newObj.Uid.IsDirty);
}

怎么样，还不错吧？快快来体验吧！

与此框架类似的通用组件:

ProtoBuffer - Google.

此框架的应用:

可以将此框架应用到网络对象的传输上，也就是说，当我们做一个分布式系统的时候，

只需要使用此框架，我们将无需再关心底层消息对象的序列化和反序列化细节，这一切的

工作将会由框架内部来完成。

性能指标:

此框架的基于.NETFRAMEWORK 4.0开发

测试平台:

CPU: Intel(R)Xeon(R)CPU X5670 @2.93GHz @2.93GHz (2处理器)

System: Windows Server 2008 R2 Enterprise

定义：复杂对象，内部包含了多个数组类型的成员，比如string[], int[]，

内部还嵌套了其余类。

*想看看在这里测试的复杂对象到底有多复杂吗？附上测试类的代码

*在我们的测试中，使用的是下列代码中的TestObject. 从下列代码中可以看到，此类型拥有很多的数组，而且还包含了其他的子类型

public class TestObject : IntellectObject
{
private TestObject1 _obj;
[IntellectProperty(7)]
public TestObject1 Obj
{
get { return _obj; }
set { _obj = value; }
}

private int[] _mm;
[IntellectProperty(0)]
public int[] Mm
{
get { return _mm; }
set { _mm = value; }
}

private TestObject1[] _pp;
[IntellectProperty(27)]
public TestObject1[] Pp
{
get { return _pp; }
set { _pp = value; }
}

private String[] _uu;
[IntellectProperty(28)]
public String[] Uu
{
get { return _uu; }
set { _uu = value; }
}

private TestObject2[] _nn;
[IntellectProperty(30)]
public TestObject2[] Nn
{
get { return _nn; }
set { _nn = value; }
}

private String[] _jj;
[IntellectProperty(26)]
public String[] Jj
{
get { return _jj; }
set { _jj = value; }
}

private int _wokao;
[IntellectProperty(4)]
public int Wokao
{
get { return _wokao; }
set { _wokao = value; }
}

private int _wocao;
[IntellectProperty(2)]
public int Wocao
{
get { return _wocao; }
set { _wocao = value; }
}

private string _woqunimade;
[IntellectProperty(3)]
public string Woqunimade
{
get { return _woqunimade; }
set { _woqunimade = value; }
}

private byte[] _metadata;
[IntellectProperty(13)]
public byte[] Metadata
{
get { return _metadata; }
set { _metadata = value; }
}

private byte _metadata1;
[IntellectProperty(15)]
public byte Metadata1
{
get { return _metadata1; }
set { _metadata1 = value; }
}

private TestObject2 _obj2;
[IntellectProperty(16)]
public TestObject2 Obj2
{
get { return _obj2; }
set { _obj2 = value; }
}

private DateTime _time;
[IntellectProperty(100)]
public DateTime Time
{
get { return _time; }
set { _time = value; }
}

}

public class TestObject1 : IntellectObject
{
private string _haha;
[IntellectProperty(0)]
public string Haha
{
get { return _haha; }
set { _haha = value; }
}

private Colors _colors;
[IntellectProperty(1)]
public Colors Colors
{
get { return _colors; }
set { _colors = value; }
}
}

[Serializable]
public class TestObject2 : IClassSerializeObject
{
private int _nice;
public int Nice
{
get { return _nice; }
set { _nice = value; }
}
}

*请注意: 由于性能的提升, 我们在2012年02月28日更新了性能指标!

序列化复杂对象(DEBUG)：

.次数 100000: 1100(ms) *此值根据测试机器的配置不同而不同，仅供参考
.Gen0回收次数: 30
.Gen1回收次数: 12
.Gen2回收次数: 1

反序列化复杂对象(DEBUG)：

.次数 100000: 863(ms) *此值根据测试机器的配置不同而不同，仅供参考
.Gen0回收次数: 22
.Gen1回收次数: 1
.Gen2回收次数: 0

序列化复杂对象(RELEASE)：

.次数 100000: 950(ms) *此值根据测试机器的配置不同而不同，仅供参考
.Gen0回收次数: 30
.Gen1回收次数: 12
.Gen2回收次数: 1

反序列化复杂对象(RELEASE)：

.次数 100000: 610(ms) *此值根据测试机器的配置不同而不同，仅供参考
.Gen0回收次数: 22
.Gen1回收次数: 1
.Gen2回收次数: 0

*具体的测试截图, 请查看源代码Pictures目录下的图片.

数据段格式图:

更高的自定义需求:

在此框架中，对于每一个可以序列化的类型(int, string .....等等)，都会为其配备一个智能类型处理器(IIntellectTypeProcessor)，在框架的使用中，这些处理器都是默认的，如果，您感觉还有更好的实现能够加速

当前的序列化或者反序列化流程，那么，您可以在您的系统初始化的时候，使用自己的智能类型处理器来替换系统

现有的。这样，就达到了可自定义类型序列化和反序列化的标准和算法 :) 当然，您也可以选择添加一个新的处理器。

其次，在KJFramework.Message中，我们能看到，每一个可序列化的字段，都需要一个智能属性标记[IntellectPropery]

而每个这种标记都需要为序列化的字段提供一个唯一的数字序号，就比如：[IntellectProperty(0)] ，如果当您的自定义类型，需要为一个特殊的字段做特殊处理的时候，可以选择为一个特殊的编号字段来定制一个特殊的智能类型处理器。

比如，我们的登录消息，如果有一个字段用来存储密码，而我们恰巧需要为此字段进行MD5加密。

那么，该怎么办呢？当然，办法有很多种，我们可以选择先进行MD5的加密，然后再赋值，也可以选择如下的方式：

/*以下为代码示例*/
public class LogonMessage : IntellectObject
{
[IntellectProperty(0)]
public string UserName{get;set;}

//可以看到，Password字段的序号为1.
//我们就可以单独添加一个字段处理器来处理每一个消息实体内包含有序号1的字段
[IntellectProperty(1)]
public string Password{get;set;}
}

*请不用担心，KJFramework.Message内部会对此操作做特殊的支持，好来完成您的特殊需求 :)

更专业的需求:

现在我们已经为一个智能对象(IntellectObject)加入了描述自身的能力(New)。也就是说，使用者随时随地

都可以通过如下调用来得到当前对象的字符串形式描述信息。

IntellectObject.ToString();

当得到了一个对象的描述信息后，我们就能够很轻松的将其记录到日志文件中，这是不是很方便呢?

在日后，我们将会不停地更新这套框架，这也就意味着，会有越来越多的功能在以后会被加入，

如果您感兴趣，我们希望您能够持续关注。

附:

此框架目前已经能够达到初步的商用层次，完全可以当做网络消息协议的序列化和反序列化转换层来使用，

相信使用过GOOGLE的ProtoBuffer的朋友都应该明白了。我会一直更新此框架，如果您的项目中有此类需求，

那么您可以选择尝试一下这套框架，不会让您失望的 :)

项目地址：http://message.codeplex.com/

目前此项目已经发布了Release版本，您可以选择直接下载二进制文件使用，或者下载源代码 :)

如果在使用此框架的途中，有任何问题，您也可以选择与我联系，我将提供最优的技术支持。

QQ:250623008

Email: Kevin.Jee@live.cn

谢谢.

本文链接

业务模型的价值(程序员的另外一条出路)

2012-05-28T04:25:00Z

都说技术人员应该重视业务的学习和培养，只有精通业务了才能更好的发挥技术。其实我是不太赞成这句话的，为什么？从我的个人经历和经验来看，这是对的。当然世事无绝对，站在我们程序员的角度讲，我绝对建议技术人员始终要以技术为主业务为辅的观点。可能有些朋友要来火了，技术辅助业务应该是业务大于技术，凡事都是相对的。如果以业务为主，就等于把自己的小命送给公司管了，如果以技术为主那么小命还是自己保管的。这句话经历过的人才会懂，我就不解释了。

1：业务、技术如何平衡

中国的行情我想我们都了解，对于一般的企业来说，技术不重要，重要的是能在最短的时间内出东西。80%的IT企业都是属于这种类型的，他们要求程序员快速的熟悉业务知识，然后就开始参与项目的开发。

大部分是重复劳动，程序员都在做些基本的增、删、改、查的工作。而且这些工作都是经过层层封装的，程序员接触到的技术面非常的窄。长期这样下去定力不足的程序员就会受到周围环境的影响。有的可能选择转行，有的可能选择做业务、做实施。其实这个时候我们应该勇于的选择，应该坚持自己的理想。当然这需要兴趣的支撑。

改行我就不发表看法了，毕竟人各有志。这篇文章讨论的主题是业务和技术的结合，如何在技术和业务之间提炼核心的领域模型，让我们的技术更有用武之地。

那么站在公司的角度讲我们应该多去学习业务知识，技术一般都是放在一些架构师手上，我们只要学会使用公司的框架就行了。

技术辅助于业务，搞业务的人始终觉得业务大于技术，技术人员应该听他们的。这种现象很普遍，至少我接触到的公司都是这样的。他们让程序员改什么就改什么，因为他们不懂程序的错综复杂，可能一点点的不合理都有可能造成程序的整体结构变动，带来的工作量可能是开发的几倍。领导又可能会说，你们能不能设计一个很模块化的，高内聚低耦合的插件系统或者又是什么新的名词。我们可能很无语，因为他们不懂技术？哪有一劳永逸的系统啊；

其实矛盾点就在于如果我们技术人员用大精力去学习业务知识，我们相对学习技术的时间会很少，那么我们就是把自己和公司绑在了一起。这个时候我们考虑的问题的角度是不同的，如果你重视业务那么你可能需要公司对你的提拔或者说是你的饭碗是捏在公司手上的，如果公司哪天看你不顺眼，你就失业了。如果我们的技术一直是领先的，那么我不怕你公司不要我，我到哪里都是能生活的。可能说这句话有点自私，但是我到觉得程序员应该学会保护自己。[王清培版权所有，转载请给出署名]

如果真的觉得你的领导值得你去追随，那么你就好好学习业务吧；如果公司真的没有值得你付出的地方，那请你好好学习技术吧；

2：程序员如何学习业务

我们程序员该如何学习业务？我觉得我们应该有选择的学习，不要所有东西都学。

一个公司的业务可能很简单也可能很复杂，我们要选择跟系统相关的业务，做哪块我们学习哪块，最重要的是有业务模型的概念在脑子里，这中模型化的思想可以看看《领域驱动设计》。

为什么要说有业务模型的概念呢？其实这是一种慢慢培养我们设计能力的方式。程序员学习业务知识在概念上一定要明确，不能模糊，因为这些概念都要在系统中体现的。如果我们理解上是模模糊糊的那么我们写的代码也是含糊不清的，在和同事交流的时候我们的模块可能造成其他模块的不明确，这时候瓶颈就来了。

我们学习业务知识一定要记得能否在代码中体现整体结构，能否提炼出业务模型；

图1:

我们学习业务知识要适当的归类，将某一条业务线上的对象抽象出来。

如果我们能善于在代码中表达业务，那么这和光使用技术来实现基本功能要强了很多。至少这是设计类的工作。(设计能力体现技术层次)

3：结合业务、技术提炼业务模型

在和一些搞领域模型的人聊天的时候，能感受到很强烈的模型感。他们对业务的理解很苛刻，不允许存在半点模糊。为什么要强调这么细致呢？这能使他们的模型更加健壮稳固。往往他们的竞争力非常的明显，精通业务和技术。

但是又与我们所见到的业务不同，他们能将业务顺利的过度到代码上。他们能将业务梳理的很工整，我们只要稍微了解一点业务就可以参与项目的开发，在代码中完全是按照业务的模型来构造的。这种人一旦熟悉了某个行业之后，是绝对的领域专家了。

总结：

其实上面废话一堆，也算是我最近来的一点小小的感悟吧。

技术是我们程序员的生命线，只有在技术上占据绝对的优势才能保住饭碗。然后将我们的技术提升到一个建模境界，那就真的技术服务于人了。谢谢；

本文链接

博客园_首页

[小把戏] 之IBatis.Net系统分页问题的解决

ASP.NET MVC架构与实战系列之二：理解MVC路由配置

Lua的协同程序

创建Windows服务(Windows Services)N种方式总结

Javascript中的对象和原型(一)

开发企业应用系统需要掌握的知识技能

我和我的HoorayOS

XAML实例教程系列 - 命名空间(NameSpace)

新浪微博SDK for .Net 4.0第二版正式发布了。

Cowboy 源码分析(十)

Fetch XML Link Entity 数量限制10个，那就不用LinkEntity吧

ASP.NET MVC 简单的分页思想与实现

Ubuntu 12.04 LTS 上安装swift1.4.8

4.1 apt-get install安装 sudo apt-get install swift即可。

[开源]KJFramework.Message 高性能二进制消息框架 - 多元素数组的高性能优化

业务模型的价值(程序员的另外一条出路)

4.1 apt-get install安装
sudo apt-get install swift即可。