博客园_山天大畜

本书开篇以单独的一章介绍社会心理学的研究方法。这一章随后告诫学生如何才能使研究结果显而易见（一旦你了解了它们），以及社会心理学家如何将自己的价值观念渗透到学科领域当中。另外，本书新增加了一个部分“社会心理学中的一些重要思想”，它介绍了一些令人兴奋的话题：我们如何构筑社会现实、社会直觉、社会影响、个人态度和性格倾向，生理行为以及它们在日常生活中的应用。这样安排章节的目的是为了学生在学习后面的章节之前有一个充分的知识准备。

本书在随后的部分将围绕社会心理学的定义展开：社会心理学是对人们的思维方式（第一编）、社会影响（第二编）、人际关系（第三编）以及社会心理学原理在日常生活中应用（第四编）的科学研究。

第一编探讨社会思维——我们如何看待自己和他人。它可以评价我们的印象、直觉和解释的准确性。

第二编探讨社会影响。通过理解态度的文化因素和学习从众、说服以及群体影响的本质，我们能更好地认识到作用在我们身上的微妙的社会力量。

第三编分析消极和积极的社会关系的态度和行为表现：从偏见到攻击，从吸引到互助。这一部分还将同时探讨冲突与和解的动力学。

第四编分析如何将我们在前面章节中学习到的概念应用到社会生活中。社会心理学的应用贯穿于全书的各个章节，但主要集中在第14章（社会心理学在临床领域中的应用），第15章（这会心理学在司法领域中的应用），以及第16章（社会心理学与可持续发展的未来）。

我一直坚信梭罗那句名言：“一切存在的事物都可以用通俗的语言轻松而自然地加以表达”，所以我一直努力构思，以期出版一本尽可能有吸引力的并能给人留下深刻印象的著作。

前言

第1章社会心理学导论

第一编社会思维

第2章社会中的自我

第3章社会信念与判断

第4章行为和态度

第二编社会影响

第5章基因、文化和性别

第6章从众

第7章说服

第8章群体影响

第三编社会关系

第9章偏见：不喜欢他人

第10章攻击行为：伤害他人

第11章吸引和亲密：喜欢他人和爱他人

第12章利他：帮助他人

第13章冲突与和解

第四编应用社会心理学

第14章社会心理学在临床领域中的应用

第15章社会心理学在司法领域中的应用

第16章社会心理学与可持续发展的未来

本文链接

ASP.NET MVC2程序开发入门到精通

2010-10-04T09:39:00Z

ASP.NET MVC2 技术是微软又一个新的WEB开发技术，也是微软在ASP.NET 平台上有一个产品，这一技术旨在使用MVC架构呈现ASP.NET，给开发者提供更多更好的可定制内容。是广大WEB开发者继ASP.NET WebForm之外的另一好选择，本系列课程共12讲，介绍了这一技术的方方面面，为您了解和掌握ASP.NET MVC提供方便。

第1讲：MVC架构概述

第2讲：MVC范例分享

第3讲：MVC中的View层使用技巧(上讲)

第4讲：MVC中的View层使用技巧(下讲)

StringBuilder研究和探索

2010-09-12T11:05:00Z

由于String类型代表的是一个不可变的字符串，所以BCL提供了另一个名为System.Text.StringBuilder的类型，它允许我们有效的对字符串的字符执行动态操作，以创建一个String。

从逻辑上说，StringBuilder对象中包含一个字段，它引用由Char结构构成的一个数组。StringBuilder的成员允许我们操作这个字符，有效的缩减字符串的大小或者更改字符串中的字符。如果字符串变大，超过已经分配的字符的大小，StringBuilder就会自动的分配一个全新的、更大的数组，并开始使用新的数组，前一个数组会被垃圾回收器回收。用StringBuilder对象构建好字符串之后，为了将StringBuilder的字符“转换”成一个String，只需调用StringBuilder的ToString方法，在内部，该方法只是返回对StringBuilder内部维护的字符串的字段的一个引用，执行效率非常快，因为它不需要进行字符数组复制。

StringBuilder既是具体建造者（Builder）又是指导者（Director），最终生成一个复杂的String对象作为产品（Product）。在具体建造者只有一个的情况下，如果抽象建造者角色已经被省略掉，那么还可以省略掉指导者角色。让Builder角色自己扮演指导者与建造者双重角色。

    // Fields
    private const string CapacityField = "Capacity";
    internal const int DefaultCapacity = 0x10;
    internal IntPtr m_currentThread;
    internal int m_MaxCapacity;
    internal volatile string m_StringValue;
    private const string MaxCapacityField = "m_MaxCapacity";
    private const string StringValueField = "m_StringValue";
    private const string ThreadIDField = "m_currentThread";

上面是StringBuilder的一些Fields，其中主要的字段是MaxCapacity和StringValue。注意StringValue的定义有个Volatile。

C#中volatile 关键字指示一个字段可以由多个同时执行的线程修改。声明为 volatile 的字段不受编译器优化（假定由单个线程访问）的限制。这样可以确保该字段在任何时间呈现的都是最新的值。可变关键字仅可应用于类或结构字段。不能将局部变量声明为 volatile。

volatile关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素更改。
用volatile关键字声明的变量i每一次被访问时，执行部件都会从i相应的内存单元中取出i的值。

没有用volatile关键字声明的变量i在被访问的时候可能直接从cpu的寄存器中取值（因为之前i被访问过，也就是说之前就从内存中取出i的值保存到某个寄存器中），之所以直接从寄存器中取值，而不去内存中取值，是因为编译器优化代码的结果（访问cpu寄存器比访问ram快的多）。

以上两种情况的区别在于被编译成汇编代码之后，两者是不一样的。之所以这样做是因为变量i可能会经常变化，保证对特殊地址的稳定访问。

volatile关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素更改，比如：操作系统、硬件或者其它线程等。遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问。

我们在使用StringBuilder的时候，先new一个实例，看看构造函数

public StringBuilder() : this(0x10)
{
}

public StringBuilder(int capacity) : this(string.Empty, capacity)
{
}

public StringBuilder(string value) : this(value, 0x10)
{
}

public StringBuilder(int capacity, int maxCapacity)
{
    this.m_currentThread = Thread.InternalGetCurrentThread(); //获取线程ID
    if (capacity > maxCapacity)
    {
        throw new ArgumentOutOfRangeException("capacity", Environment.GetResourceString("ArgumentOutOfRange_Capacity"));
    }
    if (maxCapacity < 1)
    {
        throw new ArgumentOutOfRangeException("maxCapacity", Environment.GetResourceString("ArgumentOutOfRange_SmallMaxCapacity"));
    }
    if (capacity < 0)
    {
        throw new ArgumentOutOfRangeException("capacity", string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("ArgumentOutOfRange_MustBePositive"), new object[] { "capacity" }));
    }
    if (capacity == 0)
    {
        capacity = Math.Min(0x10, maxCapacity);
    }
    this.m_StringValue = string.GetStringForStringBuilder(string.Empty, capacity);
    this.m_MaxCapacity = maxCapacity;
}

public StringBuilder(string value, int capacity) : this(value, 0, (value != null) ? value.Length : 0, capacity)
{
}

public StringBuilder(string value, int startIndex, int length, int capacity)
{
    this.m_currentThread = Thread.InternalGetCurrentThread();
    if (capacity < 0)
    {
        throw new ArgumentOutOfRangeException("capacity", string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("ArgumentOutOfRange_MustBePositive"), new object[] { "capacity" }));
    }
    if (length < 0)
    {
        throw new ArgumentOutOfRangeException("length", string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("ArgumentOutOfRange_MustBeNonNegNum"), new object[] { "length" }));
    }
    if (startIndex < 0)
    {
        throw new ArgumentOutOfRangeException("startIndex", Environment.GetResourceString("ArgumentOutOfRange_StartIndex"));
    }
    if (value == null)
    {
        value = string.Empty;
    }
    if (startIndex > (value.Length - length))
    {
        throw new ArgumentOutOfRangeException("length", Environment.GetResourceString("ArgumentOutOfRange_IndexLength"));
    }
    this.m_MaxCapacity = 0x7fffffff;
    if (capacity == 0)
    {
        capacity = 0x10;
    }
    while (capacity < length) //如果长度大于了容量，则扩容2倍
    {
        capacity *= 2;
        if (capacity < 0)
        {
            capacity = length;
            break;
        }
    }
    this.m_StringValue = string.GetStringForStringBuilder(value, startIndex, length, capacity);
}

还有经常用到的Append方法：

public StringBuilder Append(string value)
{
    if (value != null)
    {
        string stringValue = this.m_StringValue;
        IntPtr currentThread = Thread.InternalGetCurrentThread();//获取线程ID
        if (this.m_currentThread != currentThread)
        {
            stringValue = string.GetStringForStringBuilder(stringValue, stringValue.Capacity);//如果是不同线程，则值重新设置
        }
        int length = stringValue.Length;
        int requiredLength = length + value.Length;
        if (this.NeedsAllocation(stringValue, requiredLength))//看是否需要扩容
        {
            string newString = this.GetNewString(stringValue, requiredLength);
            newString.AppendInPlace(value, length);//追加新值
            this.ReplaceString(currentThread, newString);//把线程ID的字符串值更新
        }
        else
        {
            stringValue.AppendInPlace(value, length);
            this.ReplaceString(currentThread, stringValue);
        }
    }
    return this;
}

StringBuilder在需要多次修改字符串值的时候是个比较好的工具，他的性能比直接修改string要快很多，下面将通过IL代码来看看，实际运用中如果多次修改string产生的代价：

namespace abc
{
    public class a
    {
        static void Main()
        {
            string s = "1 " + "2 " + "3 ";
            Console.WriteLine(s);
        }
    }
}
//IL如下
.method   private   hidebysig   static   void     Main()   cil   managed
{
    .entrypoint
    //   Code   size               13   (0xd)
    .maxstack     1
    .locals   init   (string   V_0)
    IL_0000:     ldstr             "123 "
    IL_0005:     stloc.0
    IL_0006:     ldloc.0
    IL_0007:     call               void   [mscorlib]System.Console::WriteLine(string)
    IL_000c:     ret
}   //   end   of   method   a::Main

在这里我们看到这么一句： ldstr "123 "，String 是引用类型，可它却没有newobj指令，这说明CLR构造String与其他的对象不一样。还有，不用我说你们都看到了：为什么是“123”，原因是编译器在编译时将它们合并成一个字符串放到了程序集的元数据中（仅限于文字字符）。这样，运行时CLR直接将它们取出来用就OK了，不用再“分别取出来，重新分配内存，复制数据“。

关于下面这个问题，结果却是不一样的：

namespace abc
{
    public class a
    {
        static void Main()
        {
            string s1 = "1 ";
            string s2 = "2 ";
            string s3 = "3 ";
            string s = s1 + s2 + s3;
            Console.WriteLine(s);
        }
    }
}
//IL如下
.method   private   hidebysig   static   void     Main()   cil   managed
{
    .entrypoint
    //   Code   size               34   (0x22)
    .maxstack     3
    .locals   init   (string   V_0,
                      string   V_1,
                      string   V_2,
                      string   V_3)
    IL_0000:     ldstr             "1 "
    IL_0005:     stloc.0
    IL_0006:     ldstr             "2 "
    IL_000b:     stloc.1
    IL_000c:     ldstr             "3 "
    IL_0011:     stloc.2
    IL_0012:     ldloc.0
    IL_0013:     ldloc.1
    IL_0014:     ldloc.2
    IL_0015:     call               string   [mscorlib]System.String::Concat(string,
                                                                                                                            string,
                                                                                                                            string)
    IL_001a:     stloc.3
    IL_001b:     ldloc.3
    IL_001c:     call               void   [mscorlib]System.Console::WriteLine(string)
    IL_0021:     ret
}   //   end   of   method   a::Main

这里我们关心的是这一句：System.String::Concat(string, string,string) 。这一句的源代码上面给出来了，它实现分配一块内存，然后将s1,s2,s3的内容复制过去。
再请看：

.method   private   hidebysig   static   void     Main()   cil   managed
{
    .entrypoint
    //   Code   size               55   (0x37)
    .maxstack     2
    .locals   init   (string   V_0,
                      string   V_1,
                      string   V_2,
                      string   V_3)
    IL_0000:     ldstr             "1 "
    IL_0005:     stloc.0
    IL_0006:     ldstr             "2 "
    IL_000b:     stloc.1
    IL_000c:     ldstr             "3 "
    IL_0011:     stloc.2
    IL_0012:     ldstr             " "
    IL_0017:     stloc.3
    IL_0018:     ldloc.3
    IL_0019:     ldloc.0
    IL_001a:     call               string   [mscorlib]System.String::Concat(string,
                                                                                                                            string)
    IL_001f:     stloc.3
    IL_0020:     ldloc.3
    IL_0021:     ldloc.1
    IL_0022:     call               string   [mscorlib]System.String::Concat(string,
                                                                                                                            string)
    IL_0027:     stloc.3
    IL_0028:     ldloc.3
    IL_0029:     ldloc.2
    IL_002a:     call               string   [mscorlib]System.String::Concat(string,
                                                                                                                            string)
    IL_002f:     stloc.3
    IL_0030:     ldloc.3
    IL_0031:     call               void   [mscorlib]System.Console::WriteLine(string)
    IL_0036:     ret
}   //   end   of   method   a::Main

string a=str1+str2+str3+str4只分配一次内存，而后者的代码需要分配三次内存。（来自CSDN上的讨论）

下面是对String的一些网上的分析：摘自.NET框架未公开的特性[String]

背景知识：
       String 是.NET的一种基元类型。CLR和JIT为一些特殊的类作了特殊的处理和优化，String就是其中的一种。其他的包括：其他基元类型， StringBuilder，Array，Type，Enum，Delegate和一些Reflection类，比如MethodInfo。
       在.NET 1.0中，所有分配到堆的对象都包含了两个东东：一个对象头（4字节）和一个指向方法表的指针（4字节）。对象头提供有5个位标志，其中一个位标志是为 GC保留的，它标识对象是否是“可到达对象“（“可到达对象“是垃圾回收算法里的一个名词，简单的说就是指正在被应用程序使用的对象）。剩余的27个位作为一个索引，被称作syncindex，它指向一个表。这个索引有多种用途：首先，在使用"lock" 关键字时，它用于线程同步；另外，在调用Object.GetHashCode()方法时，它被用作缺省的哈希代码（继承类没有重写 Object.GetHashCode()时）。尽管这个索引不能为哈希代码提供最好的分布特性，但是，对于哈希代码的另外一个要求---具有相同值的对象返回相同的哈希代码，它是可以满足的。在对象的整个生存周期，syncindex保持不变。
       所有的对象都可以根据对象头计算得到它实际的内存占用，计算的公式如下（摘自Rotor包sscli20020326\sscli\clr\src\vm\object.h）：
MT->GetBaseSize() + ((OBJECTTYPEREF->GetSizeField() * MT->GetComponentSize())
       对于大多数对象，它们的大小是固定不变的。String类和Array类（包括Array的继承类）是仅有的两个可变长对象，也就是说它们创建后，对象的长度可以发生变化。
       String有点类似OLE BSTRs---以长度数据开头，空字符结尾的Unicode字符数组。下面列出的是String在内部维护的三个字段：
[NonSerialized]private int m_arrayLength;
[NonSerialized]private int m_stringLength;
[NonSerialized]private char m_firstChar;
       它们的具体含义如下表所示：

m_arrayLength
这是分配给字符串的实际长度（以字符为单位）。通常创建一个字符串时，m_arrayLength与字符串的逻辑长度(m_stringLength)是相同的。但是，如果使用StringBuilder返回一个字符串，实际长度可能比逻辑长度大。

m_stringLength
这是字符串的逻辑长度，你可以通过String.Length属性获得。出于优化性能的需要，m_stringLength的一些高位被用作标识符，所以String的最大长度要比UInt32.Max小得多（32位操作系统）。这些标识符的其中一些用来指示String是否是简单字符（比如 plain ASCII），这样在排序和比较的时候，就不采用复杂的UNICODE算法。

m_firstChar
这是字符串的第一个字符。如果是空字符串的话，这是空字符。

       String总是以一个空字符结尾，这一点加强了它与非托管代码和传统的Win32API的互操作性。
       String总共占用的内存为：16字节+2字节*字符数+2字节（最后的空字符）。表1中已经讲述，如果使用StringBuilder来创建字符串，那么实际分配的内存将可能比String.Length大。
非常有效率的StringBuilder
        与String密切关联的是StringBuilder。虽然StringBuilder被放在System.Text命名空间，但它不是一个平常的类。运行时和JIT编译器对StringBuilder进行了特殊的处理，你想写一个跟它一样有效率的类是不容易的。
       StringBuilder在内部维护一个字符串变量---m_StringValue，并且允许直接对它进行修改。默认情况下，m_StringValue的m_arrayLength字段为16。下面是StringBuilder维护的2个内部字段：
internal int m_MaxCapacity = 0;
internal String m_StringValue = null;
它们的具体含义如下所示：

m_MaxCapacity
StringBuilder的最大容量，它规定了最多可以放置到m_StringValue的字符个数，默认值为Int32.MaxValue。你可以自己规定一个小一点的容量，m_MaxCapacity一旦被指定就不能再更改。

m_StringValue
StringBuilder维护的一个字符串（Jeffrey Richter在《Applied Microsoft .NET Framework Programming》中讲述StringBuilder维护的是一个字符数组，译者认为作为字符数组比较容易理解，但从Rotor包的源代码看，实际维护的应该是一个字符串

使用StringBuilder.ToString()返回一个字符串时，实际的字符串被返回（也就是说该方法返回的是StringBuilder内部维护的字符串字段（m_StringValue）的引用，而不是创建新字符串）。如果StringBuilder的容量（ArrayLength）超过实际字符数的两倍以上，StringBuilder.ToString()将返回一个字符串的简洁版本。在调用了StringBuilder. ToString()方法之后，再次修改StringBuilder将会产生一个复制动作，它将创建一个新的字符串；这时被修改的是新的字符串，如此，原来已经返回的字符串才不会发生改变。
除了字符串使用的内存外，StringBuilder额外开销了16个字节，但是，同样的StringBuilder对象可以被使用多次来生成多个字符串，这样StringBuilder仅仅带来一次额外开销。
我们可以看到，使用StringBuilder是非常有效率的。

本文链接

向XML插入节点

2010-03-16T02:03:00Z

假如现在有一个Xml文件，内容如下：Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->3.75cm0.2381cm