博客园_Zero to one distance

Javascript 面向对象编程

2012-01-09T10:45:00Z

转帖，只为学习专用
　　Javascript 是一个类C的语言，他的面向对象的东西相对于C++/Java 比较奇怪，但是其的确相当的强大，在 Todd 同学的“对象的消息模型”一文中我们已经可以看到一些端倪了。这两天有个前同事总在问我 Javascript 面向对象的东西，所以，索性写篇文章让他看去吧，这里这篇文章主要想从一个整体的角度来说明一下 Javascript 的面向对象的编程。（成文比较仓促，应该有不准确或是有误的地方，请大家批评指正）

另，这篇文章主要基于 ECMAScript 5，旨在介绍新技术。关于兼容性的东西，请看最后一节。

初探

我们知道 Javascript 中的变量定义基本如下：

var name = 'Chen Hao';
var email = 'haoel (@) hotmail.com';
var website = 'http://coolshell.cn';

如果要用对象来写的话，就是下面这个样子：

var chenhao = {
　　    name :'Chen Hao',
　　    email : 'haoel (@) hotmail.com',
　　    website : 'http://coolshell.cn'
};

于是，我就可以这样访问：

//以成员的方式
chenhao.name;
chenhao.email;
chenhao.website;
//以 hash map 的方式
chenhao["name"];
chenhao["email"];
chenhao["website"];

关于函数，我们知道 Javascript 的函数是这样的：

var doSomething = function(){
   alert ('Hello World.');
};

于是，我们可以这么干：

var sayHello = function(){
   var hello = "Hello, I'm "+ this.name
                + "， my email is: " + this.email
                + "， my website is: " + this.website;
   alert (hello);
};
//直接赋值，这里很像C/C++的函数指针
chenhao.Hello = sayHello;
chenhao.Hello ();

相信这些东西都比较简单，大家都明白了。可以看到 javascript 对象函数是直接声明，直接赋值，直接就用了。runtime 的动态语言。

还有一种比较规范的写法是：

//我们可以看到， 其用 function 来做 class。
var Person = function(name, email, website){
    this.name = name;
    this.email = email;
    this.website = website;
    this.sayHello = function(){
        var hello = "Hello, I'm "+ this.name  + "， \n" +
                    "my email is: " + this.email + "， \n" +
                    "my website is: " + this.website;
        alert (hello);
    };
};
var chenhao = new Person ("Chen Hao", "haoel@hotmail.com",
                                     "http://coolshell.cn");
chenhao.sayHello ();

顺便说一下，要删除对象的属性，很简单：

delete chenhao['email']

上面的这些例子，我们可以看到这样几点：

Javascript 的数据和成员封装很简单。没有类完全是对象操作。纯动态！
Javascript function 中的 this 指针很关键，如果没有的话，那就是局部变量或局部函数。
Javascript 对象成员函数可以在使用时临时声明，并把一个全局函数直接赋过去就好了。
Javascript 的成员函数可以在实例上进行修改，也就是说不同实例相同函数名的行为不一定一样。

属性配置 – Object.defineProperty

先看下面的代码：

//创建对象
var chenhao = Object.create (null);
//设置一个属性
Object.defineProperty ( chenhao,
                'name', { value:  'Chen Hao',
                          writable:     true,
                          configurable: true,
                          enumerable:   true });
//设置多个属性
Object.defineProperties ( chenhao,
    {
        'email'  : { value:  'haoel@hotmail.com',
                     writable:     true,
                     configurable: true,
                     enumerable:   true },
        'website': { value: 'http://coolshell.cn',
                     writable:     true,
                     configurable: true,
                     enumerable:   true }
    }
);

下面就说说这些属性配置是什么意思。

writable：这个属性的值是否可以改。
configurable：这个属性的配置是否可以改。
enumerable：这个属性是否能在 for…in 循环中遍历出来或在 Object.keys 中列举出来。
value：属性值。
get ()/set (_value)：get 和 set 访问器。

Get/Set 访问器

关于 get/set 访问器，它的意思就是用 get/set 来取代 value（其不能和 value 一起使用），示例如下：

var  age = 0;
Object.defineProperty ( chenhao,
            'age', {
                      get: function() {return age+1;},
                      set: function(value) {age = value;}
                      enumerable : true,
                      configurable : true
                    }
);
chenhao.age = 100; //调用 set
alert (chenhao.age); //调用 get 输出 101（get 中 +1 了）;

我们再看一个更为实用的例子——利用已有的属性(age)通过 get 和 set 构造新的属性(birth_year)：

Object.defineProperty ( chenhao,
            'birth_year',
            {
                get: function() {
                    var d = new Date ();
                    var y = d.getFullYear ();
                    return ( y - this.age );
                },
                set: function(year) {
                    var d = new Date ();
                    var y = d.getFullYear ();
                    this.age = y - year;
                }
            }
);
alert (chenhao.birth_year);
chenhao.birth_year = 2000;
alert (chenhao.age);

这样做好像有点麻烦，你说，我为什么不写成下面这个样子：

var chenhao = {
    name: "Chen Hao",
    email: "haoel@hotmail.com",
    website: "http://coolshell.cn",
    age: 100,
    get birth_year () {
        var d = new Date ();
        var y = d.getFullYear ();
        return ( y - this.age );
    },
    set birth_year (year) {
        var d = new Date ();
        var y = d.getFullYear ();
        this.age = y - year;
    }
};
alert (chenhao.birth_year);
chenhao.birth_year = 2000;
alert (chenhao.age);

是的，你的确可以这样的，不过通过 defineProperty ()你可以干这些事：

1）设置如 writable，configurable，enumerable 等这类的属性配置。

2）动态地为一个对象加属性。比如：一些 HTML 的 DOM 对像。

查看对象属性配置

如果查看并管理对象的这些配置，下面有个程序可以输出对象的属性和配置等东西：

//列出对象的属性.
function listProperties (obj)
{
    var newLine = "<br />";
    var names = Object.getOwnPropertyNames (obj);
    for (var i = 0; i < names.length; i++) {
        var prop = names[i];
        document.write (prop + newLine);
        // 列出对象的属性配置（descriptor）动用 getOwnPropertyDescriptor 函数。
        var descriptor = Object.getOwnPropertyDescriptor (obj, prop);
        for (var attr in descriptor) {
            document.write ("..." + attr + ': ' + descriptor[attr]);
            document.write (newLine);
        }
        document.write (newLine);
    }
}
listProperties (chenhao);

call，apply， bind 和 this

关于 Javascript 的 this 指针，和C++/Java 很类似。我们来看个示例：（这个示例很简单了，我就不多说了）

function print (text){
    document.write (this.value + ' - ' + text+ '<br>');
}
var a = {value: 10, print : print};
var b = {value: 20, print : print};
print ('hello');// this => global, output "undefined - hello"
a.print ('a');// this => a, output "10 - a"
b.print ('b'); // this => b, output "20 - b"
a['print']('a'); // this => a, output "10 - a"

我们再来看看 call 和 apply，这两个函数的差别就是参数的样子不一样，另一个就是性能不一样，apply 的性能要差很多。（关于性能，可到 JSPerf 上去跑跑看看）

print.call (a, 'a'); // this => a, output "10 - a"
print.call (b, 'b'); // this => b, output "20 - b"
print.apply (a, ['a']); // this => a, output "10 - a"
print.apply (b, ['b']); // this => b, output "20 - b"

但是在 bind 后，this 指针，可能会有不一样，但是因为 Javascript 是动态的。如下面的示例

var p = print.bind (a);
p('a');             // this => a, output "10 - a"
p.call (b, 'b');     // this => a, output "10 - b"
p.apply (b, ['b']);  // this => a, output "10 - b"

继承和重载

通过上面的那些示例，我们可以通过 Object.create ()来实际继承，请看下面的代码，Student 继承于 Object。

var Person = Object.create (null);
Object.defineProperties
(
    Person,
    {
        'name'  : {  value: 'Chen Hao'},
        'email'  : { value : 'haoel@hotmail.com'},
        'website': { value: 'http://coolshell.cn'}
    }
);
Person.sayHello = function () {
    var hello = "<p>Hello, I am "+ this.name  + "， <br>" +
                "my email is: " + this.email + "， <br>" +
                "my website is: " + this.website;
    document.write (hello + "<br>");
}
var Student = Object.create (Person);
Student.no = "1234567"; //学号
Student.dept = "Computer Science"; //系
//使用 Person 的属性
document.write (Student.name + ' ' + Student.email + ' ' + Student.website +'<br>');
//使用 Person 的方法
Student.sayHello ();
//重载 SayHello 方法
Student.sayHello = function (person) {
    var hello = "<p>Hello, I am "+ this.name  + "， <br>" +
                "my email is: " + this.email + "， <br>" +
                "my website is: " + this.website + "， <br>" +
                "my student no is: " + this. no + "， <br>" +
                "my departent is: " + this. dept;
    document.write (hello + '<br>');
}
//再次调用
Student.sayHello ();
//查看 Student 的属性（只有 no 、 dept 和重载了的 sayHello）
document.write ('<p>' + Object.keys (Student) + '<br>');

通用上面这个示例，我们可以看到，Person 里的属性并没有被真正复制到了 Student 中来，但是我们可以去存取。这是因为 Javascript 用委托实现了这一机制。其实，这就是 Prototype，Person 是 Student 的 Prototype。

当我们的代码需要一个属性的时候，Javascript 的引擎会先看当前的这个对象中是否有这个属性，如果没有的话，就会查找他的 Prototype 对象是否有这个属性，一直继续下去，直到找到或是直到没有 Prototype 对象。

为了证明这个事，我们可以使用 Object.getPrototypeOf ()来检验一下：

Student.name = 'aaa';
//输出 aaa
document.write ('<p>' + Student.name + '</p>');
//输出 Chen Hao
document.write ('<p>' +Object.getPrototypeOf (Student) .name + '</p>');

于是，你还可以在子对象的函数里调用父对象的函数，就好像 C++ 里的 Base::func () 一样。于是，我们重载 hello 的方法就可以使用父类的代码了，如下所示：

//新版的重载 SayHello 方法
Student.sayHello = function (person) {
    Object.getPrototypeOf (this) .sayHello.call (this);
    var hello = "my student no is: " + this. no + "， <br>" +
                "my departent is: " + this. dept;
    document.write (hello + '<br>');
}

这个很强大吧。

组合

上面的那个东西还不能满足我们的要求，我们可能希望这些对象能真正的组合起来。为什么要组合？因为我们都知道是这是 OO 设计的最重要的东西。不过，这对于 Javascript 来并没有支持得特别好，不好我们依然可以搞定个事。

首先，我们需要定义一个 Composition 的函数：（target 是作用于是对象，source 是源对象），下面这个代码还是很简单的，就是把 source 里的属性一个一个拿出来然后定义到 target 中。

function Composition (target, source)
{
    var desc  = Object.getOwnPropertyDescriptor;
    var prop  = Object.getOwnPropertyNames;
    var def_prop = Object.defineProperty;
    prop (source) .forEach (
        function(key) {
            def_prop (target, key， desc (source, key))
        }
    )
    return target;
}

有了这个函数以后，我们就可以这来玩了：

//艺术家
var Artist = Object.create (null);
Artist.sing = function() {
    return this.name + ' starts singing...';
}
Artist.paint = function() {
    return this.name + ' starts painting...';
}
//运动员
var Sporter = Object.create (null);
Sporter.run = function() {
    return this.name + ' starts running...';
}
Sporter.swim = function() {
    return this.name + ' starts swimming...';
}
Composition (Person, Artist);
document.write (Person.sing () + '<br>');
document.write (Person.paint () + '<br>');
Composition (Person, Sporter);
document.write (Person.run () + '<br>');
document.write (Person.swim () + '<br>');
//看看 Person 中有什么？（输出：sayHello,sing,paint,swim,run）
document.write ('<p>' + Object.keys (Person) + '<br>');

Prototype 和继承

我们先来说说 Prototype。我们先看下面的例程，这个例程不需要解释吧，很像C语言里的函数指针，在C语言里这样的东西见得多了。

var plus = function(x，y){
    document.write ( x + ' + ' + y + ' = ' + (x+y) + '<br>');
    return x + y;
};
var minus = function(x，y){
    document.write (x + ' - ' + y + ' = ' + (x-y) + '<br>');
    return x - y;
};
var operations = {
    '+': plus,
    '-': minus
};
var calculate = function(x， y， operation){
    return operations[operation](x， y);
};
calculate (12, 4, '+');
calculate (24, 3, '-');

那么，我们能不能把这些东西封装起来呢，我们需要使用 prototype。看下面的示例：

var Cal = function(x， y){
    this.x = x;
    this.y = y;
}
Cal.prototype.operations = {
    '+': function(x， y) { return x+y;},
    '-': function(x， y) { return x-y;}
};
Cal.prototype.calculate = function(operation){
    return this.operations[operation](this.x， this.y);
};
var c = new Cal (4, 5);
Cal.calculate ('+');
Cal.calculate ('-');

这就是 prototype 的用法，prototype 是 javascript 这个语言中最重要的内容。网上有太多的文章介始这个东西了。说白了，prototype 就是对一对象进行扩展，其特点在于通过“复制”一个已经存在的实例来返回新的实例，而不是新建实例。被复制的实例就是我们所称的“原型”，这个原型是可定制的（当然，这里没有真正的复制，实际只是委托）。上面的这个例子中，我们扩展了实例 Cal，让其有了一个 operations 的属性和一个 calculate 的方法。

这样，我们可以通过这一特性来实现继承。还记得我们最最前面的那个 Person 吧，下面的示例是创建一个 Student 来继承 Person。

function Person (name, email, website){
    this.name = name;
    this.email = email;
    this.website = website;
};
Person.prototype.sayHello = function(){
    var hello = "Hello, I am "+ this.name  + "， <br>" +
                "my email is: " + this.email + "， <br>" +
                "my website is: " + this.website;
    return hello;
};
function Student (name, email, website, no, dept){
    var proto = Object.getPrototypeOf;
    proto (Student.prototype) .constructor.call (this, name, email, website);
    this.no = no;
    this.dept = dept;
}
// 继承 prototype
Student.prototype = Object.create (Person.prototype);
//重置构造函数
Student.prototype.constructor = Student;
//重载 sayHello ()
Student.prototype.sayHello = function(){
    var proto = Object.getPrototypeOf;
    var hello = proto (Student.prototype) .sayHello.call (this) + '<br>';
    hello += "my student no is: " + this. no + "， <br>" +
             "my departent is: " + this. dept;
    return hello;
};
var me = new Student (
    "Chen Hao",
    "haoel@hotmail.com",
    "http://coolshell.cn",
    "12345678",
    "Computer Science"
);
document.write (me.sayHello ());

兼容性

上面的这些代码并不一定能在所有的浏览器下都能运行，因为上面这些代码遵循 ECMAScript 5 的规范，关于 ECMAScript 5 的浏览器兼容列表，你可以看这里“ES5浏览器兼容表”。

本文中的所有代码都在 Chrome 最新版中测试过了。

下面是一些函数，可以用在不兼容 ES5 的浏览器中：

Object.create ()函数

function clone (proto) {
    function Dummy () { }
    Dummy.prototype             = proto;
    Dummy.prototype.constructor = Dummy;
    return new Dummy (); //等价于 Object.create (Person);
}
var me = clone (Person);

defineProperty ()函数

function defineProperty (target, key， descriptor) {
    if (descriptor.value){
        target[key] = descriptor.value;
    }else {
        descriptor.get && target.__defineGetter__(key， descriptor.get);
        descriptor.set && target.__defineSetter__(key， descriptor.set);
    }
    return target
}

keys ()函数

function keys (object) { var result, key
    result = [];
    for (key in object){
        if (object.hasOwnProperty (key))  result.push (key)
    }
    return result;
}

Object.getPrototypeOf () 函数

function proto (object) {
    return !object?                null
         : '__proto__' in object?  object.__proto__
         : /* not exposed? */      object.constructor.prototype
}

bind 函数

var slice = [].slice
function bind (fn, bound_this) { var bound_args
    bound_args = slice.call (arguments, 2)
    return function() { var args
        args = bound_args.concat (slice.call (arguments))
        return fn.apply (bound_this, args) }
}

参考

W3CSchool
MDN (Mozilla Developer Network)
MSDN (Microsoft Software Development Network)
Understanding Javascript OOP.

本文链接

学习反馈：对《开发笔记——通过反射验证对象属性值》的反馈

2010-04-19T13:43:00Z

本系列主旨是记录本人在项目开发和语言的学习中总结的小技巧，自知能力有限，不足登大雅之堂，但本着学习和交流的态度，希望各位同仁给与批评和指正。
在此不胜感激！！
转载请注明出处：http://suchenge.cnblogs.com

前文摘要：

我在2010年4月8日发表了一篇文章：《开发笔记——通过反射验证对象属性》

感谢大家对那片文章的关注和指导，在文章的回复中Artech和henry的指导使我受益匪浅，我根据这两位博友的指导意见重新编写了代码，同时也参考了《Smark.Data实体成员数据验证》这篇文章的代码思路，现在将设计思路和工程代码发布在此篇博文中，也算是回馈各位博友对我的支持和关注，同时也算是对Artech和henry的指导交的作业。

依据Artech和henry的指导和《Smark.Data实体成员数据验证》这篇文章的代码思路，我将验证修饰和验证过程设计为以下方式：

一、验证修饰对象的定义

    /// <summary>
    /// 验证属性抽象对象
    /// </summary>
    [AttributeUsage(AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
    public abstract class ValidatorAttribute : Attribute
    {
        /// <summary>
        /// 说明
        /// </summary>
        protected string m_Message;
        public void Validating<T>(object value, T sender) where T : BaseObject
        {
            if (!OnValidating(value))
            {
                ErrorMessage errorMessage = new ErrorMessage(m_Message,"");
                sender.Errors.Add(errorMessage);
            }
        }
        protected abstract bool OnValidating(object value);
        protected virtual bool RegexTest(object value, string regex)
        {
            bool result = false;
            string data = value.ToString();
            if (data!= null && !string.IsNullOrEmpty(data))
            {
                result = Regex.IsMatch(value.ToString(), regex);
            }
            return result;
        }
    }
    /// <summary>
    /// 不允许为空值的验证属性
    /// </summary>
    public class NotNULL : ValidatorAttribute
    {
        public NotNULL(string message)
        {
            m_Message = message;
        }
        protected override bool OnValidating(object value)
        {
            return value != null && !string.IsNullOrEmpty(value.ToString());
        }
    }
    /// <summary>
    /// String类型的长度验证
    /// </summary>
    public class StringLength : ValidatorAttribute
    {
        private int m_MaxLength;
        private int m_MinLength;
        public StringLength(string message,int minLength,int maxLength)
        {
            m_Message = message;
            m_MaxLength = maxLength;
            m_MinLength = minLength;
        }
        protected override bool OnValidating(object value)
        {
            bool result = false;
            string data = value.ToString();
            if(!string.IsNullOrEmpty(value.ToString()))
            {
                if (data.Length >= m_MinLength && data.Length <= m_MaxLength)
                {
                    result = true;
                }
            }
            return result;
        }
    }
    /// <summary>
    /// 数值类型的验证
    /// </summary>
    public class Number : ValidatorAttribute
    {
        private int m_MinValue;
        private int m_MaxValue;
        public Number(string message,int minValue,int maxValue)
        {
            m_Message = message;
            m_MaxValue = maxValue;
            m_MinValue = minValue;
        }
        protected override bool OnValidating(object value)
        {
            bool result = false;
            string data = value.ToString();
            if (!string.IsNullOrEmpty(data))
            {
                if(RegexTest(data,@"\d+"))
                {
                    int tmp = int.Parse(data);
                    if (m_MinValue != 0)
                    {
                        if (tmp >= m_MinValue)
                        {
                            result = true;
                        }
                    }
                    if(m_MaxValue != 0)
                    {
                        if(tmp <= m_MaxValue)
                        {
                            result = true;
                        }
                    }
                }
            }
            return result;
        }
    }
    /// <summary>
    /// 通过正则表达式方式验证
    /// </summary>
    public class Match: ValidatorAttribute
    {
        private string m_Regex = string.Empty;
        public  Match(string message,string regex)
        {
            m_Message = message;
            m_Regex = regex;
        }
        protected override bool OnValidating(object value)
        {
            bool result = false;
            string data = value.ToString();
            if(!string.IsNullOrEmpty(data))
            {
                return RegexTest(value, m_Regex);
            }
            return result;
        }
    }

验证修饰对象的定义，我简单的定义了对于String类型和Number类型值的验证修饰和通过正则表达式验证的验证修饰，根据《Smark.Data实体成员数据验证》，我们还可以定义通过数据库或其他方式验证数据有效性的修饰对象，比如验证一个对象的属性是否存在于数据库中等。

二、验证过程的定义

    public class Validator
    {
        public static void Scan<T>(T baseObject) where T : BaseObject
        {
            Type type = baseObject.GetType();
            foreach(PropertyInfo P in type.GetProperties())
            {
                object pv = P.GetValue(baseObject, null);
                foreach(ValidatorAttribute attr in P.GetCustomAttributes(true))
                {
                    attr.Validating(pv,baseObject);
                }
            }
        }
    }

验证过程函数中使用了泛型并约束月BaseObject对象的思路是，通过Scan验证的对象都继承与BaseObject对象，而BaseObject对象中含有错误消息集合ErrorMessageCollection，这样就可以将对属性验证的错误信息记录在对象的ErrorMessageCollection集合中，方便显示和处理。

三、错误消息的记录

我在这里设计了错误消息的记录方式，是通过Items<T>集合对象，ErrorMessage对象和ErrorMessageCollection对象来实现的，设计之初的思路是想给某一对象在实际使用中出现的错误找到一个放置的地方，并且这些错误消息是附属在对象上的，实现之后，反思觉得这样的设计有些耦合太紧了。

/// <summary>
    /// 系统自定义集合对象，实现了IEnumerable接口
    /// </summary>
    /// <typeparam name="T">用存于集合的对象的类型名称</typeparam>

    public class Items<T> : IEnumerable
    {

        /// <summary>
        /// 集合容器List<>类型
        /// </summary>
        protected List<T> arr = new List<T>();


        /// <summary>
        /// 必须实现的迭代器
        /// </summary>
        /// <returns></returns>
        public IEnumerator GetEnumerator()
        {
            foreach(T t in arr)
            {
                yield return t;
            }
        }

        /// <summary>
        /// 获取集合中的第一个对象，如果未找到返回对象默认
        /// </summary>
        public virtual T First
        {
            get
            {
                if(arr.Count > 0)
                    return arr[0];
                else
                    return default(T);
            }
        }


        /// <summary>
        /// 获取集合中的最后一个对象，如果未找到返回对象默认
        /// </summary>
        public virtual T Last
        {
            get
            {
                if(Count > 0)
                    return arr[arr.Count - 1];
                else
                    return default(T);
            }
        }

        /// <summary>
        /// 添加对象到集合
        /// </summary>
        public virtual void Add(T t)
        {
            arr.Add(t);
        }

        public virtual void AddList(Items<T> ts)
        {
            foreach(T t in ts)
            {
                arr.Add(t);
            }
        }

        /// <summary>
        /// 添加对象到集合，是否可重复添加
        /// </summary>
        /// <param name="t">要添加的对象</param>
        /// <param name="skipcontain">是否跳过包含；true：无论现有集合是否还有要添加的对象，都将要添加的对象添加到集合中；false：如果现有集合中含有要添加的对象，则不添加此对象</param>
        public virtual void Add(T t, bool skipcontain)
        {
            if(skipcontain)
                Add(t);
            else
            {
                if(!Contains(t))
                    Add(t);
            }
        }

        /// <summary>
        /// 返回集合中对象的数量
        /// </summary>
        public virtual int Count
        {
            get { return arr.Count; }
        }

        /// <summary>
        /// 返回指定参数Index为索引的对象
        /// </summary>
        public virtual T this[int Index]
        {
            get
            {
                if(Index < arr.Count)
                    return arr[Index];
                else
                    return default(T);
            }
        }

        /// <summary>
        /// 获取集合中是否存在对象的布尔值
        /// </summary>
        public virtual bool HasItem
        {
            get
            {
                bool b = false;
                if(arr.Count > 0)
                    b = true;
                return b;
            }
        }

        /// <summary>
        /// 清空集合
        /// </summary>
        public virtual void Clear()
        {
            arr.Clear();
            arr.RemoveRange(0, arr.Count);
        }

        /// <summary>
        /// 是否包含某项
        /// </summary>
        /// <param name="t">要检测的对象</param>
        /// <returns>是否包含</returns>
        public virtual bool Contains(T t)
        {
            return arr.Contains(t);
        }


        /// <summary>
        /// 删除指定索引的集合元素
        /// </summary>
        /// <param name="index"></param>
        public virtual void Remove(int index)
        {
            if(index > -1 && index < Count)
            {
                arr.RemoveAt(index);
            }
        }

        public virtual void Remove(T t)
        {
            arr.Remove(t);
        }

        public virtual void RemoveAll(T t)
        {
            foreach(T tmp in arr)
            {
                if(tmp.Equals(t))
                    arr.Remove(t);
            }
        }

    }

/// <summary>
    /// 错误消息处理委托
    /// </summary>
    /// <param name="message">自定义错误消息</param>
    /// <param name="systemmessage">系统错误消息</param>
    public delegate void ErrorHandle(string message, string systemmessage);

    /// <summary>
    /// 错误消息类
    /// </summary>
    public class ErrorMessage
    {
        /// <summary>
        /// 自定义错误消息
        /// </summary>
        private string _message = "";

        /// <summary>
        /// 系统错误消息
        /// </summary>
        private string _systemmessage = "";


        /// <summary>
        /// 获取或设置自定义错误消息
        /// </summary>
        public string Message
        {
            get { return _message; }
            set { _message = value; }
        }

        /// <summary>
        /// 获取或设置系统错误消息
        /// </summary>
        public string SystemMessage
        {
            get { return _systemmessage; }
            set { _systemmessage = value; }
        }

        public ErrorMessage()
        { }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="message">自定义错误消息</param>
        /// <param name="systemmessage">系统错误消息</param>
        public ErrorMessage(string message, string systemmessage)
        {
            _message = message;
            _systemmessage = systemmessage;
        }

        /// <summary>
        /// 返回自定义错误消息
        /// </summary>
        /// <returns>自定义错误消息</returns>
        public override string ToString()
        {
            return _message;
        }

        /// <summary>
        /// 通过参数t，返回错误消息
        /// </summary>
        /// <param name="t">返回错误类型，m：自定义错误；s：系统错误</param>
        /// <returns></returns>
        public string ToString(string t)
        {
            string tmp = "";
            if(t == "m")
                tmp = _message;
            if(t == "s")
                tmp = _systemmessage;
            return tmp;
        }

        /// <summary>
        /// 消息错误的类型枚举：Message，SystemMessage
        /// </summary>
        public enum Type
        {
            Message,
            SystemMessage
        }

        public bool Equals(ErrorMessage obj)
        {
            bool retult = false;
            if((_message == obj.Message) && _systemmessage == obj._systemmessage)
                retult = true;
            return retult;
        }
    }

    /// <summary>
    /// 自定义错误类型
    /// </summary>
    public enum ErrorMessageType
    {
        Message,
        SystemMessage
    }

public class ErrorMessageCollection:Items<ErrorMessage>
    {
        private const string _Separator = "-_-";

        /// <summary>
        /// 获取本类下定义的默认分隔符
        /// </summary>
        public string Separator
        {
            get { return _Separator; }
        }

        /// <summary>
        /// 实例化错误消息集合
        /// </summary>
        public ErrorMessageCollection()
        {}

        /// <summary>
        /// 实例化错误消息集合，将error参数以separator参数为分割后，添加到实例集合中
        /// </summary>
        /// <param name="error">错误消息字符串</param>
        /// <param name="separator">分隔符</param>
        public ErrorMessageCollection(string error, char[] separator)
        {
            string[] err = error.Split(separator, StringSplitOptions.RemoveEmptyEntries);
            foreach (string e in err) Add(e);
        }

        
        /// <summary>
        /// 添加只包含自定义错误消息的错误消息
        /// </summary>
        /// <param name="message">自定义错误消息</param>
        public void Add(string message)
        {
            ErrorMessage objEm = new ErrorMessage(message, "");
            Add(objEm);
        }


        /// <summary>
        /// 添加只包含自定义错误消息的错误消息
        /// </summary>
        /// <param name="message">自定义错误消息</param>
        /// <param name="eh">外部事件</param>
        public void Add(string message, ErrorHandle eh) {
            ErrorMessage objEm = new ErrorMessage(message, "");
            Add(objEm);
            eh(message, "");
        }

        /// <summary>
        /// 添加错误消息
        /// </summary>
        /// <param name="message">自定义错误消息</param>
        /// <param name="systemmessage">系统错误消息</param>
        public void Add(string message, string systemmessage)
        {
            ErrorMessage objEm = new ErrorMessage(message, systemmessage);
            Add(objEm);
        }

        /// <summary>
        /// 添加错误消息
        /// </summary>
        /// <param name="message">自定义错误消息</param>
        /// <param name="systemmessage">系统错误消息</param>
        /// <param name="eh">外部事件</param>
        public void Add(string message, string systemmessage, ErrorHandle eh)
        {
            ErrorMessage objEm = new ErrorMessage(message, systemmessage);
            Add(objEm);
            eh(message, systemmessage);
        }

        /// <summary>
        /// 是否存在错误消息
        /// </summary>
        public override bool HasItem {
            get {
                if (Count > 0) return true;
                else return false;
            }
        }

        /// <summary>
        /// 获取集合中第一个错误消息对象，如果未找到返回错误消息对象（ErrorMessage）默认值
        /// </summary>
        public override ErrorMessage First
        {
            get
            {
                if (HasItem)
                    return this[0];
                else
                    return default(ErrorMessage);
            }
        }

        /// <summary>
        /// 获取集合中最后一个错误消息对象，如果未找到返回错误消息对象（ErrorMessage）默认值
        /// </summary>
        public new ErrorMessage Last
        {
            get
            {
                if (HasItem)
                    return this[Count - 1];
                else
                    return default(ErrorMessage);
            }
        }

        /// <summary>
        /// 重写的索引器，根据参数index返回集合中的指定错误消息对象
        /// </summary>
        /// <param name="index">索引位置</param>
        /// <returns>ErrorMessage错误消息对象</returns>
        public override ErrorMessage this[int index]
        {
            get
            {
                if (Count > 0 && index <= (Count - 1))
                    return arr[index];
                else
                    return null;
            }
        }


        /// <summary>
        /// 重写的方法，返回集合中所有的错误消息对象中的自定义错误消息，并以系统默认分隔符组成字符串
        /// </summary>
        /// <returns>集合中所有的错误消息对象中的自定义错误消息，并以系统默认分隔符组成字符串</returns>
        public override string ToString()
        {
            return ToString(ErrorMessageType.Message);
        }

        /// <summary>
        /// 重写的方法，返回集合中所有的错误消息对象中的自定义错误消息，并以系统默认分隔符组成字符串
        /// </summary>
        /// <param name="errorMessageType">自定义错误消息的字段类型</param>
        /// <returns>集合中所有的错误消息对象中的自定义错误消息，并以系统默认分隔符组成字符串</returns>
        public string ToString(ErrorMessageType errorMessageType)
        {
            string result = string.Empty;
            if(Count > 0)
            {
                StringBuilder stringBuilder = new StringBuilder();
                foreach(ErrorMessage errorMessage in arr)
                {
                    stringBuilder.AppendFormat("{0}{1}",
                                               errorMessageType == ErrorMessageType.Message
                                                   ? errorMessage.Message
                                                   : errorMessage.SystemMessage,
                                               _Separator);
                }
                result = stringBuilder.ToString();
            }
            return result;
        }

        public string ToString(string replaceSeparator)
        {
            return ToString().Replace(_Separator, replaceSeparator);
        }

        public string ToString(ErrorMessageType errorMessageType,string replaceSeparator)
        {
            return ToString(errorMessageType).Replace(_Separator, replaceSeparator);
        }


        /// <summary>
        /// 添加系统错误消息
        /// </summary>
        /// <param name="err">系统消息集合</param>
        public void Add(ErrorMessageCollection err)
        {
            foreach (ErrorMessage em in err) Add(em);
        }


        public override void Remove(ErrorMessage t)
        {
            for(int i = 0; i < Count; i++)
            {
                if(this[i].Equals(t)) Remove(i);
                break;
            }
        }
    }

public class BaseObject
    {
        protected ErrorMessageCollection m_Errors;
        public ErrorMessageCollection Errors
        {
            get { return m_Errors; }
            set { m_Errors = value; }
        }

        public BaseObject()
        {
            m_Errors = new ErrorMessageCollection();
        }
    }

四、对象验证修饰的定义和验证过程

1、给对象属性加上验证修饰

    public class ObjectModel : BaseObject
    {
        private string m_Name;
        private string m_Age;
        private string m_Email;

        [NotNULL("用户名不能为空")]
        [StringLength("用户名长度在4-16位", 4, 16)]
        public string Name
        {
            get { return m_Name; }
            set { m_Name = value; }
        }
        [Number("用户年龄在18以及18岁以上", 18, 0)]
        public string Age
        {
            get { return m_Age; }
            set { m_Age = value; }
        }
        [Match("Email地址必须填写正确", @"^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$")]
        public string Email
        {
            get { return m_Email; }
            set { m_Email = value; }
        }
        public ObjectModel()
        { }
    }

2、验证过程

        private void button1_Click(object sender, EventArgs e)
        {
            ObjectModel objectModel = new ObjectModel();
            objectModel.Name = textBox1.Text;
            objectModel.Age = textBox2.Text;
            objectModel.Email = textBox3.Text;

            Validator.Scan(objectModel);//调用验证过程

            if (objectModel.Errors.HasItem)
            {
                MessageBox.Show(objectModel.Errors.ToString("\n"));
            }
            else
            {
                MessageBox.Show("验证成功！！");
            }
        }
    }

代码下载：ExampleProject.rar

本文链接

开发日志：通过反射验证对象属性值

2010-04-07T17:17:00Z

数据交互是WEB交互的核心功能，用户在Web页面的表单中提交数据，程序接受数据后进行相应的逻辑运算后将数据写入数据库中，在这样的应用中无论是考虑到应用系统的安全还是用户数据的完整，我们都将对用户提交的数据信息进行相应的验证。

比如一个用户注册的交互应用：

一般会在Model层建立一个注册类

public class Register
{
    public string Account { get; set; }
    public string Password { get; set; }
    public string Email { get; set; }
}

在UI层将页面提交来的数据对应赋予Register类实例化后的对象的属性，之后将对象传递给BLL层进行数据库的操作

Register register = new Register();
register.Account = HttpContext.Current.Request["txtAccount"].Trim();
register.Password = HttpContext.Current.Request["txtPassword"].Trim();
register.Email = HttpContext.Current.Request["txtEmail"].Trim();

在这里，我们暂不谈数据的安全性，只讨论数据的完整性，在这样的应用中Register类中的Account和Password属性，作为用户今后登录的重要依据，是必填的，通常情况下，我们会在将参数赋值给对象属性前先进行判断是否为空的操作

string account = string.Empty;
if (!string.IsNullOrEmpty(HttpContext.Current.Request["txtAccount"]))
{
    account = HttpContext.Current.Request["txtAccount"].Trim();
}
register.Account = account;

但是，当一个需要赋值的对象的属性非常多时，我们的判断工作将是灾难性的。

还好，.Net为我们提供了Attribute类（字面上解释应该叫做“属性”，但我叫它“修饰”，因为它和类的“Property”同名）

我们可以通过建立一个验证用的Attribute对象VerifyAttribute，并给Register类的属性加上VerifyAttribute型的修饰，记录下属性的规则，比如类型、是否可以为空，最大值以及最小值等，并建立一个通过对象属性修饰（Attribute）验证对象属性规则的类Verify，在Register对象个属性赋值好后，通过Verify的验证过程，返回验证信息。

/// <summary>
    /// 实体属性验证设置特性对象
    /// </summary>
    [AttributeUsage(AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
    public abstract class VerifyAttribute : Attribute
    {
        /// <summary>
        /// 说明
        /// </summary>
        protected string _Explain;

        /// <summary>
        /// 是否可以为空
        /// </summary>
        protected bool _NotNull;

        /// <summary>
        /// 正则表达式
        /// </summary>
        protected string _RegexExpressions;

        /// <summary>
        /// 获取说明
        /// </summary>
        public string Explain
        {
            get { return _Explain; }
        }

        /// <summary>
        /// 获取是否可以为空值
        /// </summary>
        public bool NotNULL
        {
            get { return _NotNull; }
        }

        /// <summary>
        /// 获取验证正则表达式
        /// </summary>
        public string RegexExpressions
        {
            get { return _RegexExpressions; }
        }

        /// <summary>
        /// 为内部字段赋值
        /// </summary>
        /// <param name="explain">属性说明</param>
        /// <param name="notnull">是否不可为空</param>
        /// <param name="regexexpressions">正则表达式，为空不验证</param>
        protected void GetParam(string explain, bool notnull, string regexexpressions)
        {
            _Explain = explain;
            _NotNull = notnull;
            _RegexExpressions = regexexpressions;
        }
    }

/// <summary>
    /// 实体字符类型属性验证设置特性对象
    /// </summary>
    public class VerifyString : VerifyAttribute
    {
        /// <summary>
        /// 最大长度
        /// </summary>
        protected int _MaxLength;

        /// <summary>
        /// 获取最大长度
        /// </summary>
        public int MaxLength
        {
            get { return _MaxLength; }
        }

        /// <summary>
        /// 为实体字符类型属性设置验证特性
        /// </summary>
        /// <param name="explain">属性说明</param>
        /// <param name="notnull">是否可以为空</param>
        /// <param name="maxlength">属性值最大长度</param>
        public VerifyString(string explain, bool notnull, int maxlength)
        {
            _MaxLength = maxlength;
            GetParam(explain, notnull, "");
        }

        /// <summary>
        /// 为实体字符类型属性设置验证特性
        /// </summary>
        /// <param name="explain">属性说明</param>
        /// <param name="notnull">是否可以为空</param>
        public VerifyString(string explain,bool notnull) {
            _MaxLength = 0;
            GetParam(explain, notnull, "");
        }

        /// <summary>
        /// 为实体字符类型属性设置验证特性
        /// </summary>
        /// <param name="explain">属性说明</param>
        /// <param name="notnull">是否可以为空</param>
        /// <param name="maxlength">属性值最大长度</param>
        /// <param name="regexexpressions">正则表达式，为空不验证</param>
        public VerifyString(string explain, bool notnull, int maxlength, string regexexpressions)
        {
            _MaxLength = maxlength;
            GetParam(explain, notnull, regexexpressions);
        }
    }

上面两个类VerifyString继承自VerifyAttribute类，主要是用作对String类型的属性的修饰，其中加入了可通过正则表达式进行验证的功能。

建立实现验证过程的对象

    /// <summary>
    /// 实例属性数据格式验证对象
    /// </summary>
    public class Verify {

        /// <summary>
        /// 验证属性数据格式，并返回验证结果
        /// </summary>
        /// <typeparam name="T">必须继承自BaseObject</typeparam>
        /// <param name="t">要验证的实例</param>
        /// <param name="separator">分割验证结果的自定义分隔符</param>
        /// <returns>验证结果</returns>
        public static string VerificationDataToString<T>(T t, string separator)
        {
            System.Type type = t.GetType();
            StringBuilder strTmp = new StringBuilder();
            foreach (PropertyInfo P in type.GetProperties())
            {
                foreach (Attribute attr in P.GetCustomAttributes(true))
                {
                    VerifyAttribute vattr = attr as VerifyAttribute;
                    string typename = vattr.GetType().ToString();
                    typename = typename.Substring(typename.LastIndexOf(".") + 1);
                    object pv = P.GetValue(t, null);
                    if (vattr.NotNULL)
                    {
                        if (pv == null || pv.ToString() == "")
                        {
                            strTmp.AppendFormat("{0}不得为空{1}", vattr.Explain, separator);
                        }
                    }

                    switch (typename)
                    {
                        case "VerifyString":
                            VerifyString vattrs = (VerifyString) vattr;
                            if (pv != null)
                            {
                                if (vattrs.MaxLength > 0)
                                {
                                    if (pv.ToString().Length > vattrs.MaxLength)
                                    {
                                        strTmp.AppendFormat("{0}长度不得超过{1}，现在是{2}{3}",
                                                            vattrs.Explain,
                                                            vattrs.MaxLength,
                                                            pv.ToString().Length,
                                                            separator);
                                    }
                                }
                            }
                            break;
                        case "VerifyDate":
                            
                            break;
                        case "VerifyNumber":
                            
                            break;
                    }
                    if(vattr.RegexExpressions != "")
                    {
                        if(pv != null)
                        {
                            if(!TestRegex(pv.ToString(), vattr.RegexExpressions))
                                strTmp.AppendFormat("{0}不符合格式要求{1}", vattr.Explain, separator);
                        }
                    }
                }
            }
            if (strTmp.ToString().Length <= 0) return "";
            else return strTmp.ToString().Substring(0, strTmp.ToString().LastIndexOf(separator));
        }

        /// <summary>
        /// 通过正则检查字符中是否存在指定字符
        /// </summary>
        /// <param name="value">要检查的字符串</param>
        /// <param name="regex">正则表达式</param>
        /// <returns>真or假</returns>
        private static bool TestRegex(string value, string regex)
        {
            return Regex.IsMatch(value, regex);
        }

    }

函数VerificationData()，接受一个泛型对象，并遍历对象的属性以及属性的修饰(Attribute)，取出属性的值后根据修饰描述的规则进行验证判断，最后返回验证结果。

这样，我们修改之前的Register类，为其属性加上VerifyAttribute验证规则修饰

public class Register
    {
        //必填，长度不得超过50字符，启用正则验证规则"^[\w|@|.|_]{2,20}$"
        [VerifyString("账户", true, 50, RegularExpression.Account)]
        public string Account { get; set; }

        //必填，长度不得超过50字符，启用正则验证规则"^[a-zA-Z0-9]{6,20}$"
        [VerifyString("密码", true, 50, RegularExpression.Password)]
        public string Password { get; set; }

        //必填，长度不得超过150字符，启用正则验证规则"^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$"
        [VerifyString("邮箱", true, 150, RegularExpression.Email)]
        public string Email { get; set; }
    }

在实际应用中我们通过Verify对象的VerificationData函数返回验证结果

string account = "";
string password = "$%123";
string email = "ffssfs@fdfds";

string err = string.Empty;

Register register = new Register();
register.Account = account;
register.Password = password;
register.Email = email;

err = Verify.VerificationData<Register>(register,"<br/>");

if(err == string.Empty)
{
    //验证通过
}
else
{
    HttpContext.Current.Response.Write(err);
    err应该返回：“账号不能为空<br/>请正确填写账号<br/>请正确填写密码<br/>请正确填写邮箱”
}

代码是从之前的项目中拷贝过来的，没有再次经过测试，如果有问题请与我联系，非常感谢！！

本文链接

开发日志：使用Asp.Net中的"Forms"验证方式，操作用户权限

2010-03-01T10:17:00Z

2010-03-01T10:17:00Z2010-03-01T10:17:00Z宿远http://www.cnblogs.com/suchenge/

一、web.config设置

<machineKey validationKey="DD305F238C8F26103323F10B1A655ED9FA7DBB7A" decryptionKey="70DE128000E565A7F8441A4C091C11EC8C5BB9B4D4EDA7A1" validation="SHA1"/>
<authentication mode="Forms">
    <forms name="SKAPP.ASPXAUTH" loginUrl="~/login.aspx" protection="All" timeout="10" path="/"/>
</authentication>

1、authentication 节

作用：配置 ASP.NET 身份验证支持（为Windows、Forms、PassPort、None四种）。该元素只能在计算机、站点或应用程序级别声明。＜authentication＞元素必需与＜authorization＞节配合使用。

示例：

以下示例为基于窗体（Forms）的身份验证配置站点，当没有登陆的用户访问需要身份验证的网页，网页自动跳转到登陆网页。

＜authentication mode="Forms" ＞
＜forms loginUrl="logon.aspx" name=".FormsAuthCookie"/＞

＜/authentication＞

其中元素loginUrl表示登陆网页的名称，name表示Cookie名称。

2、machineKey

作用：元素对密钥进行配置，以便将其用于对 Forms 身份验证 Cookie 数据和视图状态数据进行加密和解密，并将其用于对进程外会话状态标识进行验证

属性

属性说明

decryption

可选的 String 属性。

指定用于对数据进行解密的哈希算法的类型。

此属性可以为下列可能值之一。

值说明

Auto

指定 ASP.NET 基于配置的默认设置来确定使用哪个解密算法。这是默认值。

AES

指定 ASP.NET 使用 AES (Rijndael) 算法来对数据进行解密。AES 是用于对数据进行解密的默认算法。

3DES

指定 ASP.NET 使用 TripleDES 算法来对数据进行解密。TripleDES (3DES) 算法使用 DES 算法的三次连续迭代。

此属性是 .NET Framework 2.0 版中的新属性。

默认值为 "Auto"。

decryptionKey

必选的 String 属性。

指定用于对数据进行加密和解密的密钥或者生成该密钥的进程。当 validation 设置为 TripleDES 字段时，该属性用于 Forms 身份验证加密和解密以及视图状态加密。

如果向此属性添加 IsolateApps 修饰符，ASP.NET 将使用每个应用程序的应用程序 ID 为每个应用程序生成一个唯一的加密密钥。IsolateApps 也是默认值的一部分。

如果您需要在 Web 服务器网络（网络场）中支持配置，请手动设置此属性以确保配置保持一致。

此属性可以为下列可能值之一。

值说明

AutoGenerate

指定 ASP.NET 生成随机密钥并将其存储在 LSA 中。该值是默认值。如果向 decryptionKey 值添加 IsolateApps 修饰符，ASP.NET 将使用每个应用程序的应用程序 ID 为每个应用程序生成一个唯一的加密密钥。

value

指定一个手动分配的密钥。该值必须手动设置为十六进制字符串，以确保配置在整个网络场中保持一致。使用 DES 加密时，密钥长度应该为 16 个字符；而使用三重 DES (3 DES) 加密时，密钥长度应该为 48 个字符。如果要使用长度小于最大长度的密钥，则应通过真正的随机方式（例如，通过使用 RNGCryptoServiceProvider 类）来创建这些密钥。只有在计算机使用 128 位加密的情况下，ASP.NET 才能使用三重 DES。如果向 decryptionKey 值添加 IsolateApps 修饰符，ASP.NET 将使用每个应用程序的应用程序 ID 为每个应用程序生成一个唯一的加密密钥。

默认值为 "AutoGenerate,IsolateApps"。

validation

必选的 MachineKeyValidation 属性。

指定用来验证数据的加密类型。

此属性可以为下列可能值之一。

值说明

AES

指定 ASP.NET 使用 AES (Rijndael) 算法来对数据进行解密。AES 是用于对数据进行解密的默认算法。

MD5

指定 ASP.NET 使用 Message Digest 5 (MD5) 哈希算法。此算法的性能比 SHA1 好。

SHA1

指定 ASP.NET 使用 SHA1 哈希算法。使用此算法可增强安全性。

该值是默认值。

TripleDES

指定 ASP.NET 使用 TripleDES 算法来对数据进行解密。TripleDES 算法使用 DES 算法的三次连续迭代。

在 .NET Framework 1.0 和 1.1 版中，该值为 "3DES"。

默认值为 "SHA1"。

validationKey

必选的 String 属性。

指定用于验证加密数据的密钥。当 enableViewStateMAC 为 true 时，validationKey 用于创建消息身份验证代码 (MAC)，以确保视图状态未被篡改。validationKey 还可用于生成进程外、应用程序特定的会话 ID，以确保每个会话具有独立的会话状态变量。

如果向 ValidationKey 值添加 IsolateApps 修饰符，ASP.NET 将使用每个应用程序的应用程序 ID 为每个应用程序生成一个唯一的加密密钥。IsolateApps 也是默认值的一部分。

如果您需要在 Web 服务器网络（网络场）中支持配置，请手动设置 ValidationKey 属性以确保配置保持一致。

validationKey 属性可以为下列可能值之一。

值说明

AutoGenerate

指定 ASP.NET 生成随机密钥并将其存储在 LSA 中。此选项是默认值。如果向 validationKey 值添加 IsolateApps 修饰符，ASP.NET 将使用每个应用程序的应用程序 ID 为每个应用程序生成一个唯一的加密密钥。

value

指定一个手动分配的密钥。该值必须手动设置为十六进制字符串，以确保配置在整个网络场中保持一致。使用 DES 加密时，密钥长度应该为 16 个字符；而使用三重 DES 加密时，密钥长度应该为 48 个字符。如果要使用长度小于最大长度的密钥，则应通过真正的随机方式（例如，通过使用 CryptographyRNGCryptoServiceProvider 类）来创建这些密钥。只有在计算机使用 128 位加密的情况下，ASP.NET 才能使用三重 DES。如果向 validationKey 值添加 IsolateApps 修饰符，ASP.NET 将使用每个应用程序的应用程序 ID 为每个应用程序生成一个唯一的加密密钥。

默认值为 "AutoGenerate,IsolateApps"。

二、记录用户信息

FormsAuthenticationTicket ticket = new FormsAuthenticationTicket(
                        1, //票据版本号
                        MemberID + ";" + txtMemberNo.Text, //要记录的用户信息，在这里用多项信息用“；”号分隔
                        DateTime.Now, //用户信息记录时间
                        DateTime.Now.AddMinutes(30), //用户信息过期时间
                        true, //以Cookies的方式记录用户信息
                        dr["Roles"].ToString(), //同时写入记录信息的用户其他信息，这里记录了用户权限
                        FormsAuthentication.FormsCookiePath //写入Cookies的路径
                        );

string hash = FormsAuthentication.Encrypt(ticket);//加密要写入Cookies的用户信息

HttpCookie cookie = new HttpCookie(
                        FormsAuthentication.FormsCookieName, //要写入的Cookies的名称
                        hash //加密后的用户信息
                        ); 
 
if (ticket.IsPersistent) //如果用户信息保存是持久性的
       cookie.Expires = ticket.Expiration;//写入Cookies的过期日期

Response.Cookies.Add(cookie);//写入Cookies

三、读取用户信息

if(HttpContext.Current.User.Identity.IsAuthenticated)//用户是否通过验证
{
     string[] parts = HttpContext.Current.User.Identity.Name.Split(';');//返回记录的用户信息
     return Convert.ToInt32(parts[0]);
}
else
    return null;

本文链接

读书笔记：《亮剑 .Net》——实现异步调用Web Services

2009-07-27T02:19:00Z

普通在调用WebService的时候，程序会等待Web Service执行成功之后才执行接下来的逻辑，这样有可能会造成客户端UI线程的阻塞假死现象，这个时候可以使用异步调用Web Service的办法解决这个问题。第一种方法：通过利用Backgroundworker对象实现，Backgroundworker类允许你在单独的专用线程上运行操作。[代码]第二种方法：调用Web Service的WebM...

开发日志：基于IHttpHandler接口功能的防盗链应用

2009-07-24T09:19:00Z

读书笔记：《亮剑 .Net》——将类转化为XML并保存已经去读后反序列化为类对象

2009-07-24T07:05:00Z

简历一个可序列化的类[代码]序列化后保存[代码]读取后反序列化[代码]

读书笔记：《亮剑 .Net》——System.Transactions 事务处理

2009-07-24T06:49:00Z

使用System.Transactiions不需要考虑是简单事务还是分布式事务。在SQL Server 2005下.Net会创建一个Local Transaction，性能非常高。但是如果是SQL Server 2000，则会自动激发一个分布式事务，在性能上会受一些损失[代码]嵌套的事务处理[代码]事务范围如果想保留代码部分执行的操作，并在失败的情况下不希望终止环境事务使用TransactionS...

读书笔记：《亮剑 .Net》——企业级服务COM+事务

2009-07-24T06:32:00Z

要实现COM+事务处理的类必须继承System.EnterpriseServices.ServicedComponent，这些类需要是公共的，并且需要提供一个公共的默认的构造器。要找需要使用COM+事务处理的类定义以前加属性[Transaction(TransactionOption.Required)]，这样类中的每一个方法都会运行在一个事务中。项说明禁用指示 XML Web serv...

读书笔记：《亮剑 .Net》——Context.Handler以及Context.Items

2009-07-24T05:37:00Z

(1)Context.Handler获取控件发送页WebFormE1.aspx的HTML[代码]发送页：WebFormE1.aspx的CS代码[代码]接收页WebFormE2.aspx的HTML[代码]接收页WebFormE2.aspx的CS代码[代码](2)Context.Handler获取公共变量发送页：WebFormF1.aspx的CS代码[代码]接收页：[代码](3)Context.Ite...