博客园_蛙蛙池塘

蛙蛙推荐：Backbone官方文档翻译

2011-12-10T10:03:00Z

Backbone是一个非常棒的javascript MVC框架，使用它开发web应用，可以让你的客户端代码更少，更清新，更容易维护，更帅，下面是对官方文档的翻译

翻译未完成，而且不是特别的忠实于原文，因为我英语非常的差，所以是按自己的理解来翻译的，看英文没有压力的同学尽量看英文原文，或帮助我一起翻译，谢谢。

Backbone为开发Javascript应用程序提供了一套架构，包括基于健值对儿(attributes)和自定义事件的Model，具有丰富的枚举API(译注：依赖于underscore的集合操作)的Collections，以及可以声明自定义事件处理函数的View，并且可以把这些连接到一个现有的RESTful的JSON接口。

这个项目托管在GitHub上，并且有带有注释的代码,以及在线测试套件,示例和系列指南

您可以在Github的问题页面提交bug或讨论功能，在Freenode #documentcloud频道进行IRC交流，或在google group提出问题，以及发送twitter给@documentcloud

Backbone是DocumentCloud的一个开源组件。

下载和依赖

开发版本 41kb 全部源码及注释

生产环境版本 4.6k 打包并且Gzip压缩

Backone唯一的硬依赖就是Underscore.js,为了让Backbone.Route支持RESTfull持久化和历史以及让Backbone.View来操作Dom，需要包含json2.js，还有jQuery或Zepto.

0.50+更新

我们借此机会澄清一些0.5.0版本里的一些命名。Controller现在叫Router,refresh现在叫reset,以前的saveLocation和setLocation函数，现在用navigate替换了，Backbone.sync方法现在支持jquery.ajax的任何选项了，如果你想使用pushState特性，必须确保调用了History.Start

简介

开发web应用程序时，都会涉及大量的javascript，你要学习的第一件事就是阻止数据直接写在Dom上。用jquery的选择器和回调可以很容易的创建web应用，很直接的操作 DOM，并且很容易的和服务器端数据库之间进行数据同步。但要开发一个富客户端应用则需要一套更有条理的方法。

Backbone里，Models代表你的数据，它可以创建，校验，销毁，以及把数据保存到服务器。每当UI的动作触发了Model的一个属性变化时，Model会引发一个change时间，所有的Views可以在收到事件时呈现自己所包含的Model的数据，或者重新呈现数据。你不需要写胶水代码来通过id来查找dom元素，并手动更新HTML-当Model发生改变，View只需简单的更新自己。

下面的很多例子可以运行。点击“play”按钮可以执行他们。（译注：在这里不能点，到原页面点去）

Backbone.Events

Events是一个可以附加给任何对象的模块，它让对象提供绑定和触发自定义命名事件的能力。Events不需要在绑定前定义，并且可以传递参数，如下。

var object = {};

_.extend(object, Backbone.Events);

object.bind("alert", function(msg) {
  alert("Triggered " + msg);
});

object.trigger("alert", "an event");

bind

object.bind(event, callback, [context])

给对象绑定一个callback，callback会在event(根据一个字符串指定)触发时调用，如果你在一个页面上有大量的Event，你可以使用冒号隔开来进行命名空间划分，如poll:start或change:selection

为了给callback调用时提供一个上下文，你可以提供第三个参数，如model.bind('change',this.render, this)

如果一个callback绑定在一个all的事件上，则当任何事件发生时都会被调用，并且回调的第一个参数就是事件名字。下面这个例子是把一个对象的所有事件都代理给另一个对象。

proxy.bind("all", function(eventName) {
  object.trigger(eventName);
});

unbind

object.unbind([event], [callback])

移除掉之前绑定在一个对象上的事件处理回调，如果callback没指定，则移除指定事件的所有回调，如果event没指定，则移除该对象上的所有事件。

object.unbind("change", onChange);  // Removes just the onChange callback.

object.unbind("change");            // Removes all "change" callbacks.

object.unbind();                    // Removes all callbacks on object.

trigger

object.trigger(event, [args])*

触发给定的event的callbacks，指定的args会传递给callbacks。

Backbone.Model

Models是任何Javascript程序的核心，它包括程序的交互式数据以及数据相关的一大部分逻辑：如类型转换，验证，计算属性，访问控制。你可以扩展Backbone.Model来增加领域模型的方法和属性，并提供一个基本的变更（译注：CRUD等）功能。

下面这是一个例子，它定义了一个Model，并增加了自定义方法，设置了属性，绑定了一个特定属性变化事件(change:color)。如果你运行了下面的代码，浏览器侧栏会改变成你输入的颜色。(译注：请到原文地址进行演示)

var Sidebar = Backbone.Model.extend({
  promptColor: function() {
    var cssColor = prompt("Please enter a CSS color:");
    this.set({color: cssColor});
  }
});

window.sidebar = new Sidebar;

sidebar.bind('change:color', function(model, color) {
  $('#sidebar').css({background: color});
});

sidebar.set({color: 'white'});

sidebar.promptColor();

extend

Backbone.Model.extend(properties, [classProperties])

要创建一个你自己的Model，你需要extend一个Backbone.Model并提供实例属性properties，也可以使用可选的classProperties直接附加在构造函数上。(译注：没用过classProperties)

extend可以正确的设置javascript原型链，你可以继续extend你定义好的Model,子类会自动继承父类的成员，并且可以在子类里覆盖父类成员，实现子类自定义的逻辑。

var Note = Backbone.Model.extend({

  initialize: function() { ... },

  author: function() { ... },

  coordinates: function() { ... },

  allowedToEdit: function(account) {
    return true;
  }

});

var PrivateNote = Note.extend({

  allowedToEdit: function(account) {
    return account.owns(this);
  }

});

javascript没有提供简单的办法调用父类的方法-就是高层的javascript原型链上同名的函数，如果你自己的Model覆盖了Backbone.Model的默认的方法如set,save等，并且你要调用父类的实现，你就必须显式的调用它，如下：

var Note = Backbone.Model.extend({
  set: function(attributes, options) {
    Backbone.Model.prototype.set.call(this, attributes, options);
    ...
  }
});

constructor/initialize

new Model([attributes])

当你创建一个Model的实例时，你可以通过attributes传递初始值，这些值会被在Model上进行set，如果你的Model定义了一个initialize方法，它会在创建实例时被调用。

new Book({
  title: "One Thousand and One Nights",
  author: "Scheherazade"
});

get

model.get(attribute)

获取model的指定attribute的当前值，如note.get('title')

set

model.set(attributes, [options])

给model设置一个或多个attribute，如果有attribute的值改变了model的状态，change事件将被触发，除非你通过options参数设置了{silent:tru}。特定attribute的change事件也会触发，所以你只关心特定属性的变化的话，可以只订阅特定的事件，如chagne:title或change:content

note.set({title: "October 12", content: "Lorem Ipsum Dolor Sit Amet..."});

如果model定义了validate方法，当调用set时会先调用该方法，如果验证失败，model的attributes将不会改变，并且set方法会返回false。你可以通过options传递一个error的callback来捕获这种情况，你也可以订阅model的error事件来统一捕获这种验证出错的情况。

escapte

model.escape(attribute)

如果简单的使用get,，则返回原始的attribute，如果你需要把取出的值插入到html里，为了防止XSS攻击，你可以使用escape

var hacker = new Backbone.Model({
  name: "<script>alert('xss')</script>"
});

alert(hacker.escape('name'));

has

model.has(attribute)

如果指定的attribute不为null也不会undefined的话返回true。

if (note.has("title")) {
  ...
}

unset

model.unset(attribute, [options])

在model内部的attributes键值对里删除指定的attribute，并且会触发change事件，除非通过options参数设置了silent。

clear

model.clear([options])

移除model里的所有的attributes，并且会触发change事件，除非通过options设置了silent。

model.id

model的一个特殊属性，它可以是任意一个字符串(整数或guid),如果你给model设置了id attribute，它会成为model的一个直接的属性(译注：不需要用get获取)。你可以通过id在collections里查找Model，并且用它来生成model的默认URL(译注：就是model和api交互使用的RESTfull url)。

cid

model.cid

model的一个特殊属性，它是在model第一次在创建时自动分配的一个唯一标示符。当model还没保存到服务器的时候，model还没有id属性，而这时候需要在UI上显示，所以需要一个client id，它们类似c1,c2,c3 ...

attributes

model.attributes

attributes属性用来保存model的内部状态。请使用set来修改它，而不要直接修改它。如果你要获取它，请使用toJSON方法。

defaults

model.defaults or model.defaults()

defaults哈希(或方法)可以给model指定默认的attributes。当创建model的实例时，没有设置的attribute将使用默认值。

var Meal = Backbone.Model.extend({
  defaults: {
    "appetizer":  "caesar salad",
    "entree":     "ravioli",
    "dessert":    "cheesecake"
  }
});

alert("Dessert will be " + (new Meal).get('dessert'));

请记住，在javascript里，对象是通过引用传递的，所以包含在对象里的默认值，是所有实例共享的

toJSON

model.toJSON()

返回model.attributes的JSON对象副本。它可以用来进行持久化，序列化，或者在view处理model的数据时使用。这个名字不是太好，因为它不是返回一个JSON字符串，但你可以使用JSON.stringify_method)来获取JSON字符串

var artist = new Backbone.Model({
  firstName: "Wassily",
  lastName: "Kandinsky"
});

artist.set({birthday: "December 16, 1866"});

alert(JSON.stringify(artist));

fetch

model.fetch([options])

通过服务器来重置model的状态。常用于model里还没有任何数据时，或者要保持model里的数据始终是服务器端的最新版本。如果从服务器上拉下的数据和model当前的数据不一样，则会触发change事件。可以在options参数里使用success和error回调函数来处理fetch成功和失败的情况，这两个回调执行时会传入model和response参数。

// Poll every 10 seconds to keep the channel model up-to-date.
setInterval(function() {
  channel.fetch();
}, 10000);

save

mode.save([attributes],[options])

通过Backbone.sync把model保存到数据库（或其它的持久层），如果提供了attributes参数，则只保存这里提到的attribute，没提到的attribute不会更新。如果model包含validate方法，且验证失败，那么model不会保存成功。如果model.isNew为true，将会触发create(HTTP POST),如果model已经在服务器存在(译注：model的id已经存在)，将触发update(HTTP PUT)

下面这个例子演示了我们重写的Backbone.sync在model第一次save的时候引发create method，而第二次save的时候引发update method.

Backbone.sync = function(method, model) {
  alert(method + ": " + JSON.stringify(model));
  model.id = 1;
};

var book = new Backbone.Model({
  title: "The Rough Riders",
  author: "Theodore Roosevelt"
});

book.save();

book.save({author: "Teddy"});

save的第二个options参数里可以设置success和error callback来处理save成功和失败的情况,这两个callback会传入mode和response参数。如果model包含validate且校验失败或服务端返回非200应答，或返回错误的text或JSON应答(译注：比如服务器返回的应答不能parse成JSON)。

book.save({author: "F.D.R."}, {error: function(){ ... }});

destroy

model.destroy([options]) 通过Backbone.sync在服务端销毁model，options参数里可以接受success和error回调。destroy方法会触发model的destroy事件，并且该事件向上冒泡给包含该model的collections

book.destroy({success: function(model, response) {
  ...
}});

validate

model.validate(attributes)

这是一个默认没定义的方法，我们鼓励你定义它来实现你的自定义验证逻辑。该方法会在调用set和save时执行，并传递要保存或设置的attributes进来。如果这些属性通过了验证，则该方法什么都不要返回，如果验证失败，则可以返回一个字符串或者一个对象（译注：会传道error事件的callback里）。如果验证出错，set和save将不会继续执行，并且会触发error事件。

var Chapter = Backbone.Model.extend({
  validate: function(attrs) {
    if (attrs.end < attrs.start) {
      return "can't end before it starts";
    }
  }
});

var one = new Chapter({
  title : "Chapter One: The Beginning"
});

one.bind("error", function(model, error) {
  alert(model.get("title") + " " + error);
});

one.set({
  start: 15,
  end:   10
});

error事件可以进行比较粗粒度的错误处理，但如果你要再一个view里保存一个model时想显式的处理错误，则可以在save或set方法里直接指定error callback来处理错误及阻止error事件触发。

account.set({access: "unlimited"}, {
  error: function(model, error) {
    alert(error);
  }
});

url

model.url()

返回model在服务器端对应的资源的相对url。如果你的model不用Backbone自动生成的url进行同步，则覆盖该方法实现你自己的逻辑。默认情况下，如果model在collection里，生成的url如/[collection.url]/[model.id]，如果model不在collections里，则生成的url如/[urlRoot]/model.id

要通过Collection.url来生成url，确保你定义了它。或者定义urlRoot属性，则所有该model的实例都共享该属性。如果model的id是101，且它所在的Backbone.Collection的url是/document/7/notes,将会生成/documents/7/notes/101

urlRoot

model.urlRoot

如果model不在collection里的话，指定urlRoot来让默认的url方法能够生成类似/[/urlRoot]/id这样的url.

var Book = Backbone.Model.extend({urlRoot : '/books'});

var solaris = new Book({id: "1083-lem-solaris"});

alert(solaris.url());

parse

model.parse(response)

parse在fetch和save时服务端返回数据时调用，该方法传入原始的response对象，你需要返回attribute键值对给model的set方法。该方法默认的实现不做任何操作，简单的返回JSON应答。如果你已经存在一个现有的API不符合model所需要的数据格式，可以覆盖该方法用自定义的逻辑对返回的数据进行转换。（译注：如果要用现有的API，你甚至可以在model里定义sync方法来完全定义特定model的CRUD行为）

(译注：这里略了一些ror的文字)

clone

model.clone()

返回具有相同attributes的model实例。

isNew

mode.isNew()

指示该model是否保存到服务端，如果model还没有id属性，则认为它还没保存到服务端。

change

model.change()

手工触发change事件，如果你之前在set的时候设置了silent:true来阻止触发change事件，你可以在这样多次set后，调用一次change方法来引发一次change事件。

hasChanged

model.hasChanged([attribute])

上次触发change事件后model是否进行了变化，如果指定了attribute，则表示该attribute是否进行了变化。

请注意，此方法一般在如下情况下使用，就是在change的回调里去查看指定的attribute是否发生了变化

book.bind("change", function() {
  if (book.hasChanged("title")) {
    ...
  }
});

changeAttributes

model.changeAttributes([attributes])

返回model里进行了变化的attributes，如果指定了attributes参数则返回这些指定的attribute里变化的attribute。这可以得到哪些属性将修改到服务器，以及选择性的向服务器同步数据。

previous

model.previous(attribute)

在change事件回调里，它可以访问指定attribute的旧的值。

var bill = new Backbone.Model({
  name: "Bill Smith"
});

bill.bind("change:name", function(model, name) {
  alert("Changed name from " + bill.previous("name") + " to " + name);
});

bill.set({name : "Bill Jones"});

previousAttributes

model.previousAttributes()

返回model的变化前的attributes副本，他一般用来比较model的多个版本之间的区别，以及在发生错误的时候把attributes回滚到以前的版本。

本文链接

蛙蛙推荐：gevent并发发送UDP包演示

2011-12-03T02:18:00Z

gevent是一个非常棒的python异步IO库，一般的示例都是用他来做高并发的tcp server，其实它也能很好的工作在udp上，而且超时，并发数都能很好的控制。

#!/usr/bin/env python
#-*- coding:utf8 -*-

import DNS #http://pydns.sourceforge.net/
from gevent import spawn, joinall,socket,sleep
from gevent.coros import BoundedSemaphore
from datetime import datetime
import random

DNS.ParseResolvConf()
SERVER = (DNS.defaults['server'][0],53)
SERVER = ('8.8.8.8',53) #临时使用google的dns
TIMEOUT = 10 
lock = BoundedSemaphore(50) #并发数限制，防止同时pending的请求太多

statis = {} #统计信息
def log(domain,status,responsetime):
    statis.setdefault(status, 0)
    statis[status] += 1
    print '%s %s %s' % (domain, status, responsetime)

def getreq(domain, qtype):
    '根据域名和查询类型得到dns请求的字节流'
    m = DNS.Lib.Mpacker()
    m.addHeader(id=random.randint(0,65535),
        qr=0,
        opcode=0,
        aa=0,
        tc=0,
        rd=1,
        ra=0,
        z=0,
        rcode=0,
        qdcount=1,
        ancount=0,
        nscount=0,
        arcount=0)
    m.addQuestion(domain, qtype, DNS.Class.IN)
    return m.getbuf()

def monitorone(domain): 
    try:
        lock.acquire()

        start = datetime.now()
        client = socket.socket(
                family=socket.AF_INET, 
                type=socket.SOCK_DGRAM,
                proto=socket.IPPROTO_UDP)
        client.settimeout(TIMEOUT)

        req = getreq(domain, DNS.Type.MX) #封包
        client.sendto(req, SERVER) #发包
        (rsp, (ip, port)) = client.recvfrom(512) #收包
        u = DNS.Lib.Munpacker(rsp) #解包
        rsp = DNS.Lib.DnsResult(u, {})

        end = datetime.now()
        responsetime = (end - start).microseconds
        log(domain, rsp.header['status'], responsetime)
    except Exception, ex:
        log(domain, ex.message, 0)
    finally:
        lock.release()

#加载域名列表并解析
list = [spawn(monitorone, domain.strip()) 
    for domain in open('./domains.txt')]
joinall(list) 
global statis
print statis

以上代码是从一个文本里加载一个域名列表，然后以50并发的速度去google dns查询DNS应答，记录应答状态码和响应时间。

本文链接

蛙蛙推荐：sqlserver三种分页方式性能比较

2011-07-30T12:50:00Z

Liwu_Items表，CreateTime列建立聚集索引

第一种，sqlserver2005特有的分页语法

declare @page int
declare @pagesize int
set @page = 2
set @pagesize = 12 

SET STATISTICS IO on
SELECT  a.* FROM (
SELECT ROW_NUMBER() OVER (ORDER BY b.CreateTime DESC) AS [ROW_NUMBER], b.* 
   FROM [dbo].[Liwu_Items] AS b   ) AS a
   WHERE a.[ROW_NUMBER] BETWEEN @pagesize + 1 AND (@page*@pagesize)
   ORDER BY a.[ROW_NUMBER]

结果：

(12 行受影响)
表 'Liwu_Items'。扫描计数 1，逻辑读取 7 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。

逻辑读是7次

执行计划：

主要开销都在聚集索引扫描了。

第二种，用两个top分别正序和倒序排列，共另个子查询来实现分页，

declare @page int
declare @pagesize int
set @page = 2
set @pagesize = 12

SET STATISTICS IO on
select * from (
    select top (@pagesize) * from 
        (select top (@page*@pagesize) * from Liwu_Items order by CreateTime desc) a
    order by CreateTime asc) b 
 order by CreateTime desc

结果

(12 行受影响)
表 'Liwu_Items'。扫描计数 1，逻辑读取 7 次，物理读取 0 次，预读 317 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。

执行计划

执行计划和第一种差不多，但两个排序占的资源挺多的。

第三种，最垃圾的一种，用not in字句实现的，如下

declare @page int
declare @pagesize int
set @page = 2
set @pagesize = 12

SET STATISTICS IO on
select top(@pagesize) * from Liwu_Items
    where ItemId not in(    
    select top((@page-1)*@pagesize) ItemId from Liwu_Items order by CreateTime desc)
order by CreateTime Desc

结果

(12 行受影响)
表 'Worktable'。扫描计数 1，逻辑读取 70 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。
表 'Liwu_Items'。扫描计数 2，逻辑读取 18 次，物理读取 0 次，预读 0 次，lob 逻辑读取 0 次，lob 物理读取 0 次，lob 预读 0 次。

性能最差，对两个表进行处理，逻辑读都很高，汗。

执行计划

这执行计划都看不懂，嵌套循环和表假脱机占了很大的资源。

总结:第二种分页方法和第一种分页方法效率差不多，但第二种可用于老版本的sqlserver甚至access，最后一种别用。

本文链接

蛙蛙推荐：神马ORM都是浮云，看看史上最简单最好用的OleDbHelper

2011-07-30T10:55:00Z

摘要：大多数据库都支持OleDb，OleDb的参数化查询不支持命名参数，参数用?表示就行，赋值是按顺序赋值的。今天把Sqlserver迁移到Access，顺手写了个简单的OleDbHelper，由于OleDb的通用性，应该也可以访问其它的数据库，而且参数化查询也不怕sql注入，性能应该也会太差。

以下为完整代码，不到50行

 1 class OledbHelper
 2 {
 3     private string _strconn;
 4     public OledbHelper(string strconn)
 5     {
 6         _strconn = strconn;
 7     }
 8     public T ExecuteScalar<T>(string sql, params object[] args)
 9     {
10         using (OleDbConnection conn = new OleDbConnection(_strconn))
11         {
12             return (T)MakeCommand(conn, sql, args).ExecuteScalar();                
13         }
14     }
15     public void ExecuteNonQuery(string sql, params object[] args)
16     {
17         using (OleDbConnection conn = new OleDbConnection(_strconn))
18         {
19             MakeCommand(conn, sql, args).ExecuteNonQuery();
20         }          
21     }
22     public IDataReader ExecuteReader(string sql, params object[] args)
23     {
24         OleDbConnection conn = new OleDbConnection(_strconn);
25         try
26         {
27             OleDbCommand cmd = MakeCommand(conn, sql, args);
28             return cmd.ExecuteReader(CommandBehavior.CloseConnection);
29         }
30         catch
31         {
32             conn.Close();
33             throw;
34         }
35     }
36     public OleDbCommand MakeCommand(OleDbConnection conn, string sql, params object[] args)
37     {
38         OleDbCommand cmd = new OleDbCommand(sql, conn);
39         if (conn.State != ConnectionState.Open)
40             conn.Open();
41         for (int i = 0; i < args.Length; i++)
42         {
43             cmd.Parameters.AddWithValue(i.ToString(), args[i]);
44         }
45         return cmd;
46     }
47 }

使用示例

//获取单个值
public static string GetTagName(byte tagid)
{
    return _db.ExecuteScalar<string>("select TagName from Liwu_Tags where TagId=?", tagid);
}
//普通查询，参数的赋值很自然简单，代码最终也很简短
//需要注意的是access的"日期/时间"列不能用DateTime类型赋值，要ToString一下，如下
public static void AddTags(long itemid, IEnumerable<byte> tagids)
{

    foreach (var tagid in tagids)
    {
        if (!_db.ExecuteReader("select * from Liwu_TagLines where ItemId=? and TagId=?", itemid, tagid).Read())
        {
            _db.ExecuteNonQuery("insert into Liwu_TagLines values (?,?,?)",
                tagid, itemid, DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss"));
        }
    }

}
//带条件的分页查询，性能还行，查询出来的DataReader可以直接去绑定数据控件去
//分页sql有些长，所以代码有些乱，好在修改的地方不太多
public static IDataReader GetItems(int page = 1, int tagid = -1)
{
    const int pagesize = 12;
    string sql1 = string.Empty;
    if (tagid == -1)
        sql1 = string.Format("select top {0} * from Liwu_Items order by CreateTime desc", page * pagesize);
    else
        sql1 = string.Format("select top {0} item.* from Liwu_Items as item inner join Liwu_TagLines as line"
            + " on line.ItemId = item.ItemId  where tagid= ? order by item.CreateTime desc", pagesize * page);
    string sql2 = string.Format("select top {0} * from ({1}) order by CreateTime", pagesize, sql1);
    string sql = string.Format("select * from ({0}) order by CreateTime desc", sql2);

    return tagid == -1 ? _db.ExecuteReader(sql) : _db.ExecuteReader(sql, tagid);
}

本文链接

蛙蛙推荐：用javascript作一个通用向导

2011-07-09T04:48:00Z

摘要：向导可以让你的网站用户快速上手使用你的web应用，提高网站的吸引力。向导一般分为好几个步骤，每个步骤收集一些数据，并且支持退回功能，所有步骤完成后可以得到每一步的收集结果。这里给大家展示一种比较通用，灵活且简单的向导框架。

1、界面设计

index.html:只提供了一个向导显示位置的占位符

<html>
    <head>
        <title>礼物推荐向导</title>
        <meta http-equiv="content-type" content="text/html; charset=utf-8">
        <link rel="stylesheet" type="text/css" href="style.css">
        <script src="jquery.js" type="text/javascript"></script>
        <script src="wizard.js" type="text/javascript"></script>
    </head>
    <body>
        <div id="wizard"></div>
    </body>
</html>

style.css:默认情况下向导里有一个h2呈现的标题，一个ul呈现的主要内容，一个div呈现的按钮条，我们简单设计了一下他们的默认外观，实际应用中大家可以自由的美化它们。

body{
    margin:0;   
}
/*向导容器*/
#wizard{
    height:400px;
    width:600px;
    background-color:#999;
}
/*向导的主体内容，用列表展示*/
#wizard ul{
    margin:10px;
    height:80%;
}
/*横向显示列表内容*/
#wizard li{
    display:inline-block;
    margin:10px;
    cursor:pointer;
}
/*列表的标题*/
#wizard h2{
    margin:10px;
}
/*列表的功能条，如返回按钮*/
#wizard .bar{
    margin:10px;
    clear:both;
}

2、准备每一步骤

向导可以分为每一步骤，每个步骤需要呈现内容，捕捉用户选择，提供标题等功能，我们让每一步都自己负责自己的事情，但要符合我们规定的一些契约。

每一个步骤用一个函数表示，第一个参数data_key是选择本步骤数据的关键字，一般用于上一个步骤的结果决定下一个步骤显示数据的情况，第二个参数result_callback是个回调函数，就是在本步骤获取结果时调用，它用于和向导类进行通信，向导类在得到上一步的结果后存储结果并跳向到下一步。

该函数返回一个二元组，第一个元素是本步骤的标题，第二个元素是本步骤主体部分的UI。

我们的示例是一个礼物推荐系统，共分三步，第一步选择送礼对象，第二步选择关键字，其中第一步的选择结果会影响到第二步显示，第三步选择价格区间，如下就是代码的实现，其中绘制界面和事件捕捉用了jquery来简化操作。

function step1(data_key, result_callback){
    var targets = ['女朋友','男朋友','父亲','妈妈','孩子'];
    var warpper = $('<ul></ul>')
    $.each(targets, function(k,v){
        $('<li>'+v+'</li>').click(function(){result_callback(v)}).appendTo(warpper);
    });
    return ['第一步:请选择送礼物的对象',warpper];
}
function step2(data_key, result_callback){
    var tags = {
        '女朋友':['创意','可爱','浪漫','激情','实用','数码',
                '自制','毛绒玩具','衣服','包包'],
        '男朋友':['男士用品','温馨','实用','数码','创意','衣物'],
        '父亲'  :['男士用品','健康','植物','衣物'],
        '妈妈'  :['温馨','健康','创意','护肤品','实用'],
        '孩子'  :['玩具','学习用品','实用','数码']
    };
    var warpper = $('<ul></ul>')
    $.each(tags[data_key], function(k,v){
        $('<li>'+v+'</li>').click(function(){result_callback(v)}).appendTo(warpper);
    });
    return ['第二步:请选择关键词',warpper];   
}
function step3(data_key, result_callback){
    var price_level = ['便宜','普通','稍贵','贵重'];
    var warpper = $('<ul></ul>')
    $.each(price_level, function(k,v){
        $('<li>'+v+'</li>').click(function(){result_callback(v)}).appendTo(warpper);
    });
    return ['第三步:请选择价格区间',warpper];
}

3、向导类的实现

向导类要设置向导所在的DOM元素，要执行的步骤列表，向导完成后执行的回调，向导还应该提供上一步和下一步的方法，所以我们用一个类来表示向导，在构造函数里传入DOM容器，步骤列表和回调函数，用prototype给类增加三个方法。render用来呈现某一步骤的UI，并在本步骤收集结果的回调里推向下一步，如果本步骤是最后一步，则调用向导执行完成的回调函数。

另外两个next和back函数分别是执行上一个步骤和下一个步骤，这两个函数实用index的私有变量来维持整个向导的状态

function Wizard(container, steps, callback){
    this.container = container; //向导容器
    this.steps = steps;         //向导步骤
    this.callback = callback;   //向导执行完毕执行的回调
    this.collect_data = [];     //保存向导每一步骤的结果
    this.index = -1;            //当前执行在那一步骤
}
//绘制某一步骤
Wizard.prototype.render = function(step, this_result){
    var me = this;
    //执行该步骤并得到该步骤的UI
    var to_append = step(this_result,function(result){
        me.collect_data.push(result); //收集本步骤结果
        //向导执行完毕时调用回调函数，否则执行下一步
        if(me.collect_data.length == me.steps.length) 
            me.callback(me.collect_data);
        else
            me.next(result);
    });
    //绘制本步骤的UI
    this.container.empty();
    this.container.append("<h2>"+to_append[0]+"</h2>");
    this.container.append(to_append[1]); 
    if(this.index > 0){
        //后退按钮
        this.container.append($("<div class='bar'><a href='javascript:;'>后退</a></div>")
            .click(function(){me.back()}
                ));
    }
}
//执行下一步
Wizard.prototype.next = function(this_result){
    if(this.index >= this.steps.length -1)
        return;
    var step = this.steps[++this.index];
    this.render(step,this_result);
}
//后退到上一步
Wizard.prototype.back = function(){
    if(this.index <= 0)
        return;
    var step = this.steps[--this.index];
    //步骤回到上一步，但上一步的数据需要上上一步的结果来决定
    this.collect_data = this.collect_data.slice(0, this.index);
    this.render(step, this.collect_data[this.index - 1]);
}

4、小结

本向导结构简单，可定制性强，结合了javascript的函数式编程特性和面向对象的特性，体现了javascript的强大和便利。

其中wizard类里界面绘制的部分和步骤函数里界面绘制的部分还是存在一些耦合，继续重构的话，可以把所有绘制界面的部分再抽象到一起，使界面改动更方便。

本文链接

蛙蛙推荐：写了一个简单的延迟队列

2011-07-07T02:47:00Z

写了一个简单的延迟队列，用于处理短时大量请求的情况，可以设置队列处理Handler，每次取队列的时间间隔，以及每次取多少队列项进行处理。

队列处理是同步执行。

public class LazyQueue<T>
{
    public LazyQueue(Action<T> handler, int inteval, int onecount)
    {
        _handler = handler;
        _inteval = inteval;
        _onecount = onecount;
        _t = new Thread(ThreadProc);
        _t.Name = "LazyQueue";
        _t.IsBackground = true;
    }
    public void EnQueue(T item)
    {
        lock (_queue)
        {
            _queue.Enqueue(item);
        }
    }
    public void Start()
    {
        _t.Start();
    }

    private void ThreadProc(object state)
    {
        while (true)
        {
            try
            {
                List<T> tempItems = new List<T>(_onecount);
                lock (_queue)
                {
                    for (int i = _onecount - 1; i >= 0; i--)
                    {
                        if (_queue.Count > 0)
                        {
                            tempItems.Add(_queue.Dequeue());
                        }
                    }
                }
                tempItems.ForEach(_handler);

            }
            catch (Exception ex)
            {
                System.Diagnostics.Trace.TraceError("ThreadProc error:{0}", ex);
            }

            Thread.Sleep(_inteval);
        }
    }

    private Queue<T> _queue = new Queue<T>();
    private Action<T> _handler = null;
    private int _inteval = 0;
    private int _onecount = 0;
    private Thread _t = null;
}

本文链接

蛙蛙推荐：javascript异步任务流

2011-06-07T03:05:00Z

如下一些任务，每个任务都是异步执行的，因为它们都要去网络上取一些数据，而且不知道什么时间能执行完成。

function output(msg){
    $("#debug").append("<p>"+msg+"</p>");
}
function work1(callback){
    output("begin work1");
    $.get('data.js', function(data){
        output("end work1");
        if(typeof callback == 'function'){
            callback();
        }
    });
}
function work2(callback){
    output("begin work2");
    $.get('data.js', function(data){
        output("end work2");
        if(typeof callback == 'function'){
            callback();
        }
    });
}
function work3(callback){
    output("begin work3");
    $.get('data.js', function(data){
        output("end work3");
        if(typeof callback == 'function'){
            callback();
        }
    });
}

如果我们同步调用这些任务，

work1();
work2();
work3();

会出现如下结果

begin work1
begin work2
begin work3
end work1
end work2
end work3

但我们想第一个任务完成后再执行第二个任务，依次类推，如果不借助异步框架的支持，我们就需要修改work1,work2,work3的代码，让他们完成后执行相应的后续任务,这样以后要修改任务流就需要改动具体任务的代码，变化点比较分散。

也可以在开始执行任务前准备一些回调函数，然后再开始，这样封装了变化点，提高了代码的可读性，大致如下

var callback3 = function(){work3();};
var callback2 = function(){work2(callback3);};
var callback1 = function(){work1(callback2);}
callback1();

执行结果如下

begin work1
end work1
begin work2
end work2
begin work3
end work3

可以看到这段代码虽然执行结果符合预期，但可读性和可维护性太差了，一大串匿名函数，而且写的顺序还得仔细注意，所以我写了个小框架了让它变的简单。

function AsyncWorkManager(){
    this.works = [];
}
AsyncWorkManager.prototype.addWork = function(callee, caller){
    if(typeof callee!= 'function')
        throw {name:"TypeError",message:"work must be a function"};
    this.works.push([callee, caller]);
};
AsyncWorkManager.prototype.start = function(){  
    var me = this;
    var arr = [];
    var j = 0;
    for(var i = this.works.length - 1;i >=0; i--){
        var fun = function(){
            var work = me.works[j++];
            work[0].call(work[1],arr.pop());
        };
        arr.push(fun);
    }
    arr.pop()();
};

代码很少，但效果很好，再次写调度代码就简单了，如下。

var manager = new AsyncWorkManager();
manager.addWork(work1);
manager.addWork(work2);
manager.addWork(work3);
manager.start();

本文链接

蛙蛙推荐：css背景图片固定居中，div阴影，背景半透明，div圆角，DIV渐变

2011-04-23T08:38:00Z

很久不更新博客，整理了CSS的一些常用效果，尽量兼容多的浏览器，包括背景图片固定居中，div阴影，背景半透明，div圆角，DIV渐变等。

<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <title>CSS test</title>
    <style type="text/css">
        body
        {
            margin: 0; /*背景图片固定居中
            http://www.w3school.com.cn/css/pr_background-position.asp
            http://www.198484.com/?action=show&id=51
            */
            background-image: url('images/bg1.jpg');
            background-attachment: fixed;
            background-position: center;
            background-repeat: no-repeat;
        }
        #header
        {
        }
        #inner-header
        {
            margin: 0 auto;
            width: 960px;
            background-color: Gray;
            height: 80px; /*布局块阴影，如果不想支持低版本IE可去掉滤镜
            http://blog.imbolo.com/cross-browsers-css-shadow/
            */
            box-shadow: 3px 3px 4px #000;
            -moz-box-shadow: 3px 3px 4px #000;
            -webkit-box-shadow: 3px 3px 4px #000;
            filter: progid:DXImageTransform.Microsoft.Shadow(Strength=4, Direction=135, Color='#000000');
            -ms-filter: "progid:DXImageTransform.Microsoft.Shadow(Strength=4, Direction=135, Color='#000000')";
        }
        #main
        {
            background-color: Gray;
            margin: 10 auto;
            width: 960px;
            min-height: 500px;
            height: auto; /*
            背景半透明
            http://blog.csdn.net/zenwong/archive/2008/08/29/2846546.aspx
            */
            filter: alpha(opacity=70); /*IE*/
            -moz-opacity: 0.7; /*Mozilla*/
            opacity: 0.7; /*FF*/ /*
            圆角效果，不考虑低版本IE
            http://blog.imbolo.com/creating-rounded-corners-with-css/
            */
            -moz-border-radius: 20px;
            -webkit-border-radius: 20px;
            border-radius: 20px;
        }
        #footer
        {
            margin: 0 auto;
            width: 960px;
            height: 100px; /*渐变效果
            http://www.zhangxinxu.com/wordpress/?p=743
            */
            filter: alpha(opacity=100 finishopacity=50 style=1 startx=0,starty=0,finishx=0,finishy=150) progid:DXImageTransform.Microsoft.gradient(startcolorstr=red,endcolorstr=blue,gradientType=0);
            -ms-filter: alpha(opacity=100 finishopacity=50 style=1 startx=0,starty=0,finishx=0,finishy=150) progid:DXImageTransform.Microsoft.gradient(startcolorstr=red,endcolorstr=blue,gradientType=0); /*IE8*/
            background-color: Gray; /* 一些不支持背景渐变的浏览器 */
            background: -moz-linear-gradient(top, red, rgba(0, 0, 255, 0.5));
            background: -webkit-gradient(linear, 0 0, 0 bottom, from(#ff0000), to(rgba(0, 0, 255, 0.5)));
            background: -o-linear-gradient(top, red, rgba(0, 0, 255, 0.5));
        }
    </style>
    <!--[if IE]>
    <style type="text/css">
        #main
        {
            height: 500px;
        }
        body
        {
            text-align:center;
        }
        #inner-header
        {
        text-align:left;
        }
    </style>
    <![endif]-->
</head>
<body>
    <div id="header">
        <div id="inner-header">
            <h1>
                CSS Demo</h1>
        </div>
    </div>
    <div id="main">
    </div>
    <div id="footer">
    </div>
</body>
</html>

本文链接

蛙蛙推荐：用.net 4.0构建新浪微博开发平台应用

2011-03-05T15:13:00Z

摘要：现在很多互联网应用都推出了开放平台，开心，人人，新浪，淘宝，豆瓣，腾讯，还有飞信也即将推出开放平台，大多数开发平台都会用OAuth认证，并提供返回json数据的Rest接口，用.NET 4.0的新特性来开发这些平台的应用有着天然的优势，一起来看看。

认证

要想使用开发平台的数据和接口，第一步肯定是登录和认证，OAuth被越来越多的开放平台所认可和使用，TerryLee已经介绍过在.NET里如何实现OAuth认证，不过是针对豆瓣平台的一些示例代码，新浪微博的OAuth认证有一些不同的地方,一会儿我会标识出来。sarlmolapple为新浪提供了新浪微博开放平台的c#版本SDK，但没有完全对新浪微博的所有接口进行支持。因此我借鉴了两位的代码写了个针对新浪微博的精简版的OAuth认证，因为简单，如果大家想开发其它开放平台的应用，也可以很快比猫画虎做出来。

首先还是要下载别人写好的OAuthBase.cs文件，然后继承该类写一些自定义的逻辑，后来发现只通过子类来实现自定义逻辑还不好使，所以迫不得已还是修改了OAuthBase.cs类，因为新浪微博开放平台要求生成OAuth签名时，多了一个Verifier参数，所以在生成basestring时（GenerateSignatureBase方法）要加上这个参数。

//NOTE:add by onlytiancai@gmail.com 兼容sina登录,参考了http://code.google.com/p/opensinaapi/
if (!string.IsNullOrEmpty(Verifier) && httpMethod == "GET")
{
    parameters.Add(new QueryParameter(oAauthVerifier, Verifier));
}

准备一下OAuth认证的配置项，这些配置项大家可以在数据库里配置或者写个自定义配置节在Web.config里配置，为了简单，我就先写死了，如下

public class OAuthConfig
{
    public static OAuthConfig Instance = new OAuthConfig();
    public OAuthConfig()
    {
        RequestTokenUri = "http://api.t.sina.com.cn/oauth/request_token";
        AuthorizeUri = "http://api.t.sina.com.cn/oauth/authorize";
        AccessTokenUri = "http://api.t.sina.com.cn/oauth/access_token";
        ApiKey = "xxxx"; //在新浪微博开放平台申请
        ApiKeySecret = "xxxxxxxxxxxxxxxxxx";//在新浪微博开放平台申请
    }
    public string RequestTokenUri { get; set; }

    public string ApiKey { get; set; }

    public string ApiKeySecret { get; set; }

    public string AuthorizeUri { get; set; }

    public string AccessTokenUri { get; set; }
}

请求open api接口时一般要拼写PostData格式的数据，而PostData的格式是类似"?p1=a&p2=b&p3=c"，这种格式，要手动拼写这样格式的字符串很麻烦，所以我们想要一种优雅的方式，比如

get_request(new {p1="a", p2="b", p3="c"})

这个参数是一个c# 3.5的匿名类，然后在get_request方法里可以通过反射获取到属性名和值，构建成PostData格式，但这样做性能会稍差一些，我们可以用另外一种相近的格式，如下

get_request(new Pairs { { "p1", "a" }, {"p2", "b"}, "p3", "c" } )

这里的参数是一个Pairs类，后面的大括号套着大括号是.net 3.5的集合初始化语法，这个Pairs是我在(Using C# 3.0 Anonymous Types as Dictionaries )这篇博客的评论里看到的，我略微修改了一下，如下

public class Pairs : List<KeyValuePair<String, String>>
{
    public void Add(String key, String value)
    {
        Add(new KeyValuePair<string, string>(key, value));
    }

    public string ToPostData(Func<string, string> valueHandler = null)
    {
        StringBuilder sb = new StringBuilder();
        foreach (var pair in this)
        {
            if (sb.Length > 0)
                sb.Append("&");
            sb.AppendFormat("{0}={1}", pair.Key, valueHandler == null 
                ? pair.Value : valueHandler(pair.Value));
        }
        return sb.ToString();
    }
}

我只增加了一个ToPostData的方法，其中有一个可选的参数用来在拼接PostData时对参数值进行处理，可选参宿是.net 4.0提供的机制，如果不提供这个参数，我就按原文拼写参数值

我继承OAuthBase写了一个OAuthHelper类，其中OAuthRequest方法用来发送一个OAuth请求，如下

public string OAuthRequest(string uri, Pairs data = null, string method = "GET")
{
    //1、准备获取签名所需参数
    string nonce = GenerateNonce();
    string timeStamp = GenerateTimeStamp();
    if (data == null)
        data = new Pairs();
    data.Add("source", OAuthConfig.Instance.ApiKey); //添加默认的source参数
    uri += uri.IndexOf("?") > 0 ? "&" : "?";
    uri += data.ToPostData(str => UrlEncode(str)); //防止参数里有",%,="等字符

    //2、获取签名
    string normalizeUrl, normalizedRequestParameters;
    string sig = GenerateSignature(
        new Uri(uri),
        OAuthConfig.Instance.ApiKey,
        OAuthConfig.Instance.ApiKeySecret,
        Token,
        TokenSecret,
        method,
        timeStamp,
        nonce,
        OAuthBase.SignatureTypes.HMACSHA1,
        out normalizeUrl,
        out normalizedRequestParameters);
    normalizedRequestParameters = normalizedRequestParameters + "&" 
        + OAuthSignatureKey + "=" + HttpUtility.UrlEncode(sig);

    //3、发送WEB请求并接受数据
    HttpWebRequest request = (HttpWebRequest)WebRequest.Create(
        method == "POST" ? normalizeUrl : normalizeUrl + "?" + normalizedRequestParameters);
    request.Method = method;
    if (method == "POST")
    {
        using (StreamWriter sw = new StreamWriter(request.GetRequestStream()))
        {
            sw.Write(normalizedRequestParameters);
        }
    }

    using (HttpWebResponse response = (HttpWebResponse)request.GetResponse())
    {
        using (StreamReader reader = new StreamReader(request.GetResponse()
            .GetResponseStream(), System.Text.Encoding.UTF8))
        {
            return reader.ReadToEnd();
        }
    }
}

具体步骤我都做了注释，其中GenerateNonce，GenerateTimeStamp，UrlEncode，GenerateSignature都是父类提供的方法，直接调用即可，根据名字也很容易想出它的功能，如果你做的不是新浪微博开放平台的应用，这里可能要相应的做一些小改动。

然后是进行OAuth的三步认证，第一步获取RequestToken，第二步让用户进行授权，一般情况下会提示用户登录新浪微博或者提示用户授权或拒绝授权你的应用访问用户的新浪微博数据，第三步就是拿到AccessToken去访问受限的资源，具体过程大家可以看这里。有了上面我们写的方法，这三步就很简单了。

/// <summary>
/// 登录第一步：获取RequestToken
/// </summary>
public void GetRequestToken()
{
    string response = OAuthRequest(OAuthConfig.Instance.RequestTokenUri);
    if (response.Length > 0)
    {
        NameValueCollection qs = HttpUtility.ParseQueryString(response);
        if (qs[OAuthTokenKey] != null)
        {
            this.Token = qs[OAuthTokenKey];
            this.TokenSecret = qs[OAuthTokenSecretKey];
        }
    }
}

/// <summary>
/// 登录第二部：Response.Redirect到这个页面，提示用户授权
/// </summary>
/// <param name="callbackUri">用户认证成功后返回的地址</param>
/// <returns></returns>
public string GetAuthorizeUri(string callbackUri)
{
    return string.Format("{0}?oauth_token={1}&&oauth_callback={2}",
        OAuthConfig.Instance.AuthorizeUri,
        this.Token, callbackUri);
}

/// <summary>
/// 登录第三部：获取AccessToken，成功登录
/// </summary>
public void GetAccessToken()
{
    string response = OAuthRequest(OAuthConfig.Instance.AccessTokenUri);
    if (response.Length > 0)
    {
        NameValueCollection qs = HttpUtility.ParseQueryString(response);
        if (qs[OAuthTokenKey] != null)
        {
            this.Token = qs[OAuthTokenKey];
            this.TokenSecret = qs[OAuthTokenSecretKey];
        }
    }
}

其中Token和TokenSecret是OAuthHelper的两个string类型成员。

获取JSON数据

一般开放平台的接口可以返回xml格式或JSON格式的数据，如果解析XML数据会很不通用，每一个接口需要写一个方法，而返回json的话.NET 4.0提供的JavaScriptSerializer可以对json数据进行序列化和反序列化，json格式的数据可以反序列化成Dictionary<string, object>类型或其类型的数组，其中object又是一个Dictionary<string, object>，但我们对Dictionary的操作会很麻烦，我们想办法吧它转换成一个c# 4.0的dynamic类型，这里有篇帖子（Turning JSON into a ExpandoObject ）介绍了如何去做，我在此基础上改动了一下，并提供了一个直接把open api返回的数据转换成ExpandoObject的方法，如下。

/// <summary>
/// 发送OAuth请求，并把返回的json结果转换成dynamic类型
/// </summary>
/// <param name="uri">请求地址，请确保返回json数据</param>
/// <param name="data">请求数据</param>
/// <param name="method">HttpMethod</param>
/// <returns></returns>
public ExpandoObject OAuthRequestDynamic(string uri, Pairs data = null, string method = "GET")
{
    string result = OAuthRequest(uri, data, method);
    if (result == null)
        return null;
    return Expando(result);
}

public static ExpandoObject Expando(string json)
{
    JavaScriptSerializer serializer = new JavaScriptSerializer();
    object obj = serializer.DeserializeObject(json);
    if (obj is ICollection)
        return Expando(new Dictionary<string, object>() { { "arr", obj } });
    else
        return Expando((Dictionary<string, object>)obj);
}

//http://coderjournal.com/2010/07/turning-json-into-a-expandoobject/
private static ExpandoObject Expando(IDictionary<string, object> dictionary)
{
    var expando = new ExpandoObject();
    var expandoDic = (IDictionary<string, object>)expando;

    foreach (var item in dictionary)
    {
        bool alreadyProcessed = false;

        if (item.Value is IDictionary<string, object>)
        {
            expandoDic.Add(item.Key, Expando((IDictionary<string, object>)item.Value));
            alreadyProcessed = true;
        }
        else if (item.Value is ICollection)
        {
            var itemList = new List<object>();
            foreach (var item2 in (ICollection)item.Value)
                if (item2 is IDictionary<string, object>)
                    itemList.Add(Expando((IDictionary<string, object>)item2));
                else
                    itemList.Add(Expando(new Dictionary<string, object> { { "Unknown", item2 } }));

            if (itemList.Count > 0)
            {
                expandoDic.Add(item.Key, itemList);
                alreadyProcessed = true;
            }
        }
        if (!alreadyProcessed)
            expandoDic.Add(item);
    }

    return expando;
}

这下可好了，访问opan api，直接返回的就是带类型的了，省了解析的工序了，和Python差不多，直接写出成员就行。

开发第一个应用

去新浪微博开放平台注册一个账户，得到app key和app key secret，然后就可以开发测试应用了，新建一个Default.aspx页，摆放如下控件。

<div>
    <asp:Button ID="btnLogin" runat="server" Text="登录" OnClick="btnLogin_Click" />
    <asp:Button ID="btnTimeline" runat="server" OnClick="btnTimeline_Click" Text="timeline" />
    <p>
        <asp:Label ID="lblMessage" runat="server" Text="未登录"></asp:Label>
    </p>
    <asp:Repeater ID="rpt1" runat="server">
        <ItemTemplate>
            <p>
               <img src="<%# Eval("user.profile_image_url") %>" alt="" />
　　　　　　　　 <b><%# Eval("user.name") %>:</b><%# Eval("text")%>(<%# Eval("created_at")%>)
            </p>
        </ItemTemplate>
    </asp:Repeater>
</div>

控件的功能根据名字可以推测出来，先看登录

protected void btnLogin_Click(object sender, EventArgs e)
{
    OAuthHelper oauth = new OAuthHelper();
    oauth.GetRequestToken();
    Session["oauth_token"] = oauth.Token;
    Session["oauth_token_secret"] = oauth.TokenSecret;
    string url = oauth.GetAuthorizeUri("http://localhost:1812/");
    Response.Redirect(url);
}

先获取RequestToken，然后获取用户认证页地址，重定向过去，提示用户登录，用户登录完了之后会返回到calback uri，这里填写是本页，新浪会在返回的页面上提供oauth_verifier参数，如果有这个参数就说明是用户登录成功返回的，所以我们要在Page_Load里做一些处理，困了，就不写那么多说明了，大家看看，大多都是借鉴了sarlmolapple的示例代码。

protected void Page_Load(object sender, EventArgs e)
  {
      Session[Guid.NewGuid().ToString()] = 1; //生成cookie里的sessionid，防止Redirect回来丢失Session
      if (!Page.IsPostBack)
      {
          OAuthHelper oauth = new OAuthHelper();
          if (Request["oauth_verifier"] != null)
          {
              oauth.Token = Session["oauth_token"].ToString();
              oauth.TokenSecret = Session["oauth_token_secret"].ToString();
              oauth.Verifier = Request["oauth_verifier"];
              oauth.GetAccessToken();
              Session["oauth_token"] = oauth.Token; ;
              Session["oauth_token_secret"] = oauth.TokenSecret;

              Response.Redirect("/Default.aspx");
          }
          if (Session["oauth_token"] != null)
          {
              this.lblMessage.Text = "登录成功";
              this.btnLogin.Visible = false;
              this.btnTimeline.Visible = true;
          }
          else
          {
              this.lblMessage.Text = "未登录";
              this.btnLogin.Visible = true;
              this.btnTimeline.Visible = false;
          }
      }
  }

登录成功后，我们获取public_timeline，并直接绑定在Repeater上，不做任何解析，你猜能不能用。

protected void btnTimeline_Click(object sender, EventArgs e)
{
    OAuthHelper oauth = new OAuthHelper();
    oauth.Token = Session["oauth_token"].ToString();
    oauth.TokenSecret = Session["oauth_token_secret"].ToString();
    dynamic json = oauth.OAuthRequestDynamic(
 　　　　"http://api.t.sina.com.cn/statuses/public_timeline.json",
        new Pairs { { "count", "5" } });
    rpt1.DataSource = json.arr;
    rpt1.DataBind();
}

猜对了，不能用，但是加上如下代码就能用了

protected new object Eval(string expression)
{
    string[] arr = expression.Split('.');
    object obj = this.Page.GetDataItem();
    IDictionary<string, object> items = obj as IDictionary<string, object>;
    if (items != null)
    {
        if (arr.Length == 1)
            return items[arr[0]];
        else if (arr.Length == 2)
            return ((IDictionary<string, object>)items[arr[0]])[arr[1]];
        else
            throw new NotSupportedException("哥，表达式too长了,不支持呀。");
    }
    else return DataBinder.Eval(this.Page.GetDataItem(), expression);
}

以上代码是在网上找到的一段，出处忘了，我在它的基础上修改了一下，支持了json的二级数据的绑定,可以直接在Eval里写“user.name”这样的表达式。

public_timeline返回的json样子大概是如下

[
    {
        "created_at" : "Tue Nov 30 14:34:35 +0800 2010",
        "text" : "吃力不讨好的事情我是坚决不会再做了，RI你个仙人！发飙~~~~我只想说档次和素质在那里去了，
　　　　　　你也就只能在这种地方混！",
        "truncated" : false,
        "in_reply_to_status_id" : "",
        "annotations" : 
        [

        ],
        "in_reply_to_screen_name" : "",
        "geo" : null,
        "user" : 
        {
            "name" : "习惯寂寞吗",
            "domain" : "",
            "geo_enabled" : true,
            "followers_count" : 5,
            "statuses_count" : 61,
            "favourites_count" : 0,
            "city" : "1",
            "description" : "",
            "verified" : false,
            "id" : 1676792942,
            "gender" : "f",
            "friends_count" : 26,
            "screen_name" : "习惯寂寞吗",
            "allow_all_act_msg" : false,
            "following" : false,
            "url" : "http://1",
            "profile_image_url" : "http://tp3.sinaimg.cn/1676792942/50/1284648784",
            "created_at" : "Wed Dec 30 00:00:00 +0800 2009",
            "province" : "51",
            "location" : "四川 成都"
        },
        "favorited" : false,
        "in_reply_to_user_id" : "",
        "id" : 3978753419,
        "source" : "<a href=\"http://t.sina.com.cn\" rel=\"nofollow\">新浪微博</a>"
    },
...
]

最后来张图吧

本文链接

如何高效的利用新浪微博获取信息

2011-03-03T23:25:00Z

如果您是新浪微博用户，您是否被海量的微博信息占去了大量的时间，您是否想省时，省力，高效的获取公共信息并了解好友动态？
　　在这个信息爆炸的时代，我们需要的不是大量的可有可无的信息，而是少量的对我们有用的信息。微博是一个获取信息的很好的来源，有大量有意思的有价值的信息在里面，但也有很多刷屏的，抱怨的，发广告的，发无用信息的人。再就是你关注的一个人不可能发每一条信息都是有价值的，那样的话这个人就太累了，大多数人发布微博都是很随性的，除了那些有特殊目的的官方的微博。
　　这样当你关注的人到200以上之后，你就对信息无所适从了，新浪微博默认是按照信息的发布时间倒序排列的，你不可能时时刻刻关注这微博，但你不时时刻刻关注微博，很有可能你看微博的时候看到的都是人家发牢骚的信息，而你正在工作的时候发了一条对你很有价值的信息。
　　如果你是个微博新手的话，第一个先要学习的是对关注的人进行分类，否则关注的人多了，微博就没法儿用了，成了负担，而不是工具。
　　我的方案是把亲朋好友分一组，就是你的同事，家人，闺秘，哥们都分到一个好友组，每天每条都看，如果上班时间来不及看，可以在下班回家路上用wap版看。其实这些人是你最关心的人，你更在乎他们的动态，这也是微博的SNS的功能做在。根据我的经验，和你关系比较好的朋友也就几十个人，如果没有话痨的话，每天也就更新100条左右，100条微博，在路上大约花半小时就能阅读完和回复完。通过这些交互，你能和你最好的便宜保持联系。
　　然后把名人，网友，同行，冷笑话，新闻等根据自己的分类标准手工分类，然后每天看这个分类里转发数最多的前三十条围脖，既省时，又高效，还不会错过精彩有价值围脖。比如我就分了IT，娱乐，网友，新闻，编程，移动互联网这么几个组，每天回家路上看完好友的微博后就看这些分类的转发数最多的微博。其实说白了，对于不是自己的好友，根本就不用关注，以后新浪微博肯定会推出list的功能，就是给你把微博上的人分好类，你只要关注这个list，这个list里的所有的人发布的微博都能看到，而且我大胆预测下，新浪微博还会提供每个list一个时间段内转发数或评论数最多的top n条微博，因为现在的话题功能就有这功能了，你可以搜索一个关键字，然后可以只看原创的，或只看今天转发数最多的，甚至可以看只带图的，只带视频的，和你一个城市人发的微博，筛选条件很多很全，我再大胆预测一下，以后这些自定义的筛选条件可以收藏，以后你看完亲朋好友的微博后直接查看这个筛选条件的微博就行了，省时，省力，高效，没压力。
　　当然，现在新浪的list功能还没有完全开放，每个list里转发最多的微博功能也没提供，只是beta api里提供了一些接口，我根据此接口开发了一个原型应用：
1、如果你给微博分了组，鼠兔网微阅读功能录后显示你关注的每个分组里今日发表的转发数最多的前30条微博。
2、官方提供了两个预制的列表，一个是笑话专刊，一个是互联网专刊，都把相关的内容按转发数进行排序：
　　2.1、前者针对普通人，把冷笑话精选，全球奇闻趣事，当时我震惊了，段子，猫扑等比较经典的冷笑话微博当天发布的内容进行了聚合，并按照转发数排序，你直接可以看到今天最流行的笑话是什么，放松你一天紧张工作的心情。
　　2.2、后者互联网专刊是针对产品经理和互联网感兴趣的朋友，聚合了李开复，蔡文胜，王煜全,月光博客，互联网哪些事，新浪科技，创业邦,techweb，网站分析工会等互联网名人的微博。
3、微阅读功能除了能在PC上阅读，也可以使用微阅读手机版在手机上阅读，只要你的手机能上网（比如大多数诺基亚手机）就可以阅读，做的比较简单是xhtml2.0的，我觉得信息阅读类的手机应用没太必要用android,iphone等原生程序来呈现，就网页程序就挺好的，挺多加一些HTML5的效果加强用户体验。
4、如果你平时有收藏有价值信息的习惯，你还可以把你每天收藏的好微博发布成微博报分享给大家，如果你每天分享的微博都很有价值，很给力，满足和你同样兴趣的朋友，相信你的微博报会越来越受欢迎的，这里有一些小建议提供给要制作自己的微博报的同学
　　4.1、尽量保持你的微博报有一个明显的主题，比如娱乐，健康，笑话，旅游等，这样更容易得到同一兴趣的读者。
　　4.2、尽量在固定的时间点发布微博报，这样读者可以固定的时间来收取报纸
　　4.3、报纸条目尽量少而精，为用户节省阅读时间，一期报纸最好不要超过30条微博条目。
5、默认你创办的微博报只能用PC或者比较高级的浏览器查看，但我也提供了相关API，欢迎iphone,android等手机开发者开发鼠兔网微博杂志的手机客户端哦

本文链接