导航是一个网站的路标，优秀的导航是网站设计成功地第一步。导航必须是用户友好的，而且要与网站设计风格保持一致，这样才能为用户提供简便的导航。

在这里您将看到120个非常优秀的CSS水平导航菜单。

在c#中一个类的静态成员有静态变量和静态方法,这里首先介绍静态变量.

首先说一下静态变量的特点:

1.静态变量属于类,而不属于类的任何实例.

(From MSDN:Use the static modifier to declare a static member, which belongs to the type itself rather than to a specific object.)

2.静态变量可以通过类名直接访问,而不能通过实例访问.

  如: class A
    {
       public static string  AName;
    }

我们想要访问AName可以通过A.AName 的方式.

3.在内存中static 变量只分配一块内存,各个实例如果修改静态变量则修改的是同一个内存地址上的值,也就是静态变量被各个实例共享.

  如下代码所示:

代码

 class Program
    {
        private static int sum = 0;
        static void Main(string[] args)
        {
            Program p1 = new Program();
            Program p2 = new Program();
            Program p3 = new Program();
            Console.WriteLine(p1.f(p2.f(p3.f(2))));
            Console.Read();
        }
        int f(int n)
        { 
            sum += n; 
            return sum + 1; 
        }
    }

各位同学,Console 最后输出的是多少呢 ?

 静态类

类可以声明为 static 的，以指示它仅包含静态成员。不能使用 new 关键字创建静态类的实例。静态类在加载包含该类的程序或命名空间时由 .NET Framework 公共语言运行库 (CLR) 自动加载。

使用静态类来包含不与特定对象关联的方法。例如，创建一组不操作实例数据并且不与代码中的特定对象关联的方法是很常见的要求。您应该使用静态类来包含那些方法。

静态类的主要功能如下：

• 它们仅包含静态成员。

• 它们不能被实例化。

• 它们是密封的。

• 它们不能包含实例构造函数。

因此创建静态类与创建仅包含静态成员和私有构造函数的类大致一样。私有构造函数阻止类被实例化。

使用静态类的优点在于，编译器能够执行检查以确保不致偶然地添加实例成员。编译器将保证不会创建此类的实利。

静态类是密封的，因此不可被继承。静态类不能包含构造函数，但仍可声明静态构造函数以分配初始值或设置某个静态状态。

1.Application对象

         Application用于保存所有用户的公共的数据信息,如果使用Application对象,一个需要考虑的问题是任何写操作都要在Application_OnStart事件(global.asax)中完成.尽管使用Application.Lock和Applicaiton.Unlock方法来避免写操作的同步,但是它串行化了对Application对象的请求,当网站访问量大的时候会产生严重的性能瓶颈.因此最好不要用此对象保存大的数据集合. 下面我们做个在线用户统计的例子来说明这个问题:
    (以文件的形式存放网站总访问量)

Global.asax类

  代码

2.Session对象
      Session用于保存每个用户的专用信息.每个客户端用户访问时，服务器都为每个用户分配一个唯一的会话ID（Session ID) . 她的生存期是用户持续请求时间再加上一段时间(一般是20分钟左右).Session中的信息保存在Web服务器内容中,保存的数据量可大可小.当Session超时或被关闭时将自动释放保存的数据信息.由于用户停止使用应用程序后它仍然在内存中保持一段时间,因此使用Session对象使保存用户数据的方法效率很低.对于小量的数据,使用Session对象保存还是一个不错的选择.使用Session对象保存信息的代码如下:

3.Cookie对象
    Cookie用于保存客户浏览器请求服务器页面的请求信息,程序员也可以用它存放非敏感性的用户信息，信息保存的时间可以根据需要设置.如果没有设置Cookie失效日期,它们仅保存到关闭浏览器程序为止.如果将Cookie对象的Expires属性设置为Minvalue,则表示Cookie永远不会过期.Cookie存储的数据量很受限制,大多数浏览器支持最大容量为4K,因此不要用来保存数据集及其他大量数据.由于并非所有的浏览器都支持Cookie,并且数据信息是以明文文本的形式保存在客户端的计算机中,因此最好不要保存敏感的,未加密的数据,否则会影响网站的安全性.使用Cookie对象保存的代码如下:

4.ViewState对象
    ViewState 常用于保存单个用户的状态信息，有效期等于页面的生存期。跟隐藏控件相似。viewstate是在本页面之内各函数间进行传值的 , 至于为什么要使用这种方法是因为在一个事件发生之后 , 页面可能会刷新 , 如果定义全局变量会被清零 , 所以要使用 viewstate. ViewState容器可以保持大量的数据，但是必须谨慎使用，因为过多使用会影响应用程序的性能。所有Web服务器控件都使用ViewState在页面回发期音保存自己的状态信息。如果某个控件不需要在回发期间保存状态信息,最好关闭该对象的ViewState，避免不必要的资源浪费。通过给@Page指令添加“EnableViewState=false”属性可以禁止整个页面的ViewState。使用ViewState对象保存信息的代码如下。

5.Cache对象
   Cache对象用于在HTTP请求间保存页面或数据。该对象的使用可以极大地提高整个应用程序的效率。常用于将频繁访问的大量服务器资源存储在内存中，当用户发出相同的请求后服务器不再次处理而是将Cache中保存的信息返回给用户，节省了服务器处理请求的时间。其生存期依赖于该应用程序的生存期。当重新启动应用程序时，将重新创建其Cache对象的实例。使用Cache对象保存信息的代码如下。

   6.隐藏域
  Hidden控件是属于HTML类型的服务器控件，使用此控件可以实现隐藏域的功能。其实此控件和其它服务器控件的使用没有太大区别，只是它不会在用户端的浏览器中显示，始终处于隐藏状态。但是每次页面提交的时候，此控件和其它服务器控件一同提交到服务器端，因此在服务器端可以使用Value属性获取或保存一些数据信息。使用Hidden控件保存信息的代码如下。

  7.查询字符串
 查询字符串的方式是将要传递的值连接在URL后面，然后通过Response.Redirect方法实现客户端的重定向。这种方式可以实现在两个页面之间传递信息。由于URL的长度有一定的限制，因此不能传递太大的信息，加外安全性也不是很好。
  传递信息如下。问号后面格式 key1=value1&key2=value2

代码

Response.Redirect("List.aspx?nameID=0001&gradeID=002");
  //执行上面的语句后在IE地址栏显示的URL的代码如下。
  http://localhost/List.aspx?nameID=0001&grade=002
  //当跳转到List.aspx后，可以通过以下代码获得所传递的信息。
  string NameID.GradeID;
  NameID=Request.Params["nameID"];
  GradeID=Request.Params["gradeID"]; 

     一、数组类型 (Array)

     数组类型，在语义上表示一组相同类型的集合。这个跟列表(List)相似，两者的区别在于列表类型数据元素不可变，而数组类型可以。虽然数组类型随机访问，在查询访问上性能优先列表，但列表在变更集合(增加、删除集合元素)上有更好的性能。这个跟大多数语言是相似的。

     定义数组类型的语法，跟列表也很相似，区别在于数组多了两个"|"符合。

     arr为一维数组，类型为int array。jaggedArr数组为int array array

     F#数组与c#很相似，有两种类别的数组，一种叫矩形(rectangle)数组，另一种叫锯齿(jagged)数组

     矩形数组，在数字意义上，就是矩阵(matrix)，一维数组也叫矢量或向量(vector)。注意锯齿数组内嵌的数组长度不相等。

     在F#中共定义了三个模块来处理数组类型。Array,Array2,Array3，分别用来处理一维、二维、三维数组。

     a类型为int [,]，是一个二维数组。

     从上面的代码可以看出，F#除支持与c#类似的访问方法外，还对一维数组支持范围区间访问语法。     

     二、可变数组类型(ResizeArray)

     ResizeArray类型，只是.net 类型 System.Collections.Generic.List泛型类型的别名。ResizeArray长度可变，数据元素可变，很显然这个类型难以保证线程安全，应优先使用F#的List类型。

     三、键值对类型Map。

     Map类型，不同于.net的System.Collections.Generic.Dictionary类型，Map类型是不可变类型。

     上面的代码可以看出Map.add函数创建Map类型比较麻烦，通过of_list，of_array,of_seq等函数创建字典比较方便。

     四、Set类型

     Set类型，不同于List之处，在于集合中数据是唯一的，不存在两条相等的数据成员。

     Set类型，还支持两个Set类型的相交、合并，取子集合等操作     

     集合在日常编程中占据了重要了位置，本文对F#集合类型的技术细节没有进行讨论。

     到本篇博客为止，已经讨论了基本类型、集合类型、元组类型、函数类型。 记录类型，不准备专门讲解，可以阅读从c#3.0到F#，序列seq类型，我不打算在本系列中讨论，因为不讨论计算表达式，序列无法说清。 下一篇博客将讨论模式匹配，这样，基本上F#函数编程范式基本知识讨论完了。

     接下来，我就集中研究函数式编程中一些高级特性，例如组合子，CPS,Monad。希望条件成熟，我另开一个系列来讨论。

     1、名称空间必须使用完全限定名打开，名称空间不可以取别名。

     2、在fs,fsi文件中，除注释外，第一行必须使用#light或#light "off"

     3、元组类型互操作上发生了变动。

     新增了两个类型来提供互操作上的支持。TupleEnd,TupleNested，彻底解决了互操作上的不一致性。

     对应的c#签名:  

     C#语言如果使用以下的规则，F#语言就可以正确的识别出元组。

      如果元组元素个数小于7，使用Tuple泛型，下面的代码，F#可以正确的转换为(1,2,3);     

     等于七个元素，第七个元素使用TupleEnd包装,下面的代码，F#可以正确的转换为(1,2,3,4,5,6,7)   

      大于七个元素的元组，七个元素以上的使用TupleNested包装，下面的代码，F#可以正确的转换为(1,2,3,4,5,6,7,8)。 

     为了给大家一个直观的映象，我给出完整的调用例子。    

     首先请建立一个c#类库工程，引用FSharp.Core.dll 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.FSharp.Core;

namespace TestFSharpTuple
{
    public class Class1
    {

        public static Tuple<int, int, int, int, int> T1
        {
            get { return new Tuple<int, int, int, int, int>(1, 2, 3, 4, 5); }
        }

        public static Tuple<int, int, int, int, int, int, int> T2
        {
            get { return new Tuple<int, int, int, int, int, int, int>(1, 2, 3, 4, 5, 6, 7); }
        }

        public static Tuple<int, int, int, int, int, int, TupleEnd<int>> T3
        {
            get { return new Tuple<int, int, int, int, int, int, TupleEnd<int>>(1, 2, 3, 4, 5, 6, new TupleEnd<int>(7)); }
        }

        public static Tuple<int, int, int, int, int, int, TupleNested<int>> T4
        {
            get
            {
                return new Tuple<int, int, int, int, int, int, TupleNested<int>>
                    (1, 2, 3, 4, 5, 6, new TupleNested<int>(7));
            }
        }

        public static Tuple<int, int, int, int, int, int, TupleNested<Tuple<int, int>>> T5
        {
            get
            {
                return new Tuple<int, int, int, int, int, int, TupleNested<Tuple<int, int>>>
                    (1, 2, 3, 4, 5, 6, new TupleNested<Tuple<int, int>>(new Tuple<int, int>(7, 8)));
            }
        }

        public static Tuple<int, int, int, int, int, TupleNested<Tuple<int, int, int>>> T6
        {
            get
            {
                return new Tuple<int, int, int, int, int,  TupleNested<Tuple<int,int, int>>>
                   (1, 2, 3, 4, 5,  new TupleNested<Tuple<int,int, int>>(new Tuple<int,int, int>(6,7, 8)));
            }
        }
    }
}

      在F#中分别调用 

    你会发现调用T2,T4均出错。T6不会出错，但可能不是你想要的结果,T6的结果为(1,2,3,4,5,(6,7,8))

     调用T2时的错误截图:

     调用T4的错误截图:

      一、如何定义列表

     在F#中定义一个列表，有几个方法。

     1、使用字量值

     使用中括号'[',']'，元素之间用分号分隔。不同于元组类型，元组使用'(',')'，元素之间使用逗号分隔。

     F#中的列表是链表，列表元素必须是相同类型，列表是不可变的，因此定义后将不能改变。

     F#中定义一个空列表，有三种方法。它们在使用上有一些细微的差别。

     列表上定义了一个 @ 操作符，用于将一个列表追加到另一个列表的尾部，生成一个新的列表。而 :: 操作符，则将一个元素添加到一个列表的首部，形成一个新的列表。注意所有操作的列表本身不会改变。这种行为类似.net的string类型。

     2、使用范围表达式

     3、使用序列表达式

     关于序列将在以后的博客中讨论，序列是一种计算表达式的实现。

     二、列表比较。

      列表类型可以很方便的进行值比较，要使用引用比较请使用obj.ReferenceEquals

     三、访问列表元素

     列表索引从0开始。

     四、使用列表类型属性     

     五、访问List模块操作列表 

Code
namespace FSharpLearning       

type LineNo=int

type Order= 

    {ID:string;No:string;TotalPrice:float;Status:OrderStatus;OrderItems:List<LineNo*Product>}
and Product =
    {ID:string;Name:string;Price:float}
and OrderStatus=
    New
    | Readed
    | Confirmed
    | Canceled
    | Finished

[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
module Order =
    let change_order_status status order=
        {order with Status=status}
    let sum_order_totalprice order=
        {order with TotalPrice=order.OrderItems |>List.sum_by (fun (i,product)->product.Price)}
    let add_order_items productList order=
        {order with OrderItems=productList |> List.mapi (fun i product ->(i,product))}
    let reorder order =
        {order with OrderItems=
                    order.OrderItems |> List.sort (fun (_,i) (_,j) ->compare i.Price j.Price) 
                    |>List.mapi (fun i (_,product) ->(i,product))  }
            

module ListTest=
     
      let main ()=
          let productList=List.map3 (fun id name price->{ID=id;Name=name;Price=price}) 
                            ["0001";"0002";"0003"] ["彩电";"冰箱";"PDA"] [4000.;3050.;3000.]
          
          let order={ID="0001";No="20080904"; Status=New;TotalPrice=0.;OrderItems=[]}
          let order=order |> Order.add_order_items productList 
          let order=Order.sum_order_totalprice order
          let order=order |>Order.reorder
          let order=Order.change_order_status Readed order
            
          printfn "%A" order
                                          
          do System.Console.ReadKey(true)|>ignore


      do main()                         

     上面的代码，使用namespace定义了一个FSharpLearning名称空间,使用type给int类型取了一个更有意义的名称LineNO。

     并且使用type定义了一个Order记录类型和Product记录类型，以及OrderStatus联合类型。

     之后使用module定义了一个子模块Order，并且这里使用[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]标注了Order模块。并告诉编译器在Order模块名后面加上Module作为模块名。前面说过顶层作用域不允许重名。

     Order模块中定义了几个函数，用来操作Order记录类型。之后，我们在ListTest模块中分别调用了这些定义的函数。

     List模块中函数较多，主要介绍三个,其它函数使用方法类似。

           List.iteri函数类型为(int->'a->unit)->'a list->unit

      |>前向管道操作符。上面的字法等价于List.iteri (fun i num ->printfn "index %d:%d" i num) numbers

      List.iteri带有索引，还有一个List.iter不带索引，通常这两个函数用来遍历列表。

     List.map的函数类型为('a->'b)->'a list->'b list

     map函数通常用来操作列表中每个元素，生成新的列表。 

     List.reduce_left函数类型为('a->'a->'a)->'a list ->'a

     reduce_left函数从左到右依次取出列表中两个元素操作。通常称为归约。

     六、列表与模式匹配

          总结：

     1、列表用于表示相同类型的一组数据的集合，在F#中大数据量集合类型应优先使用seq序列，因为序列是惰性的。

     2、列表是一个combinator,列表的类型定义为:

          type 'a list=

          |([])

          |( :: ) of 'a *'a list

     一个[1;2;3]的列表本质上是1::2::3::[]，最具体的说是op_Cons(1,op_Cons(2,op_Cons(3,op_Nil)))

     op_Nil是[]的操作符名，op_Cons是::的操作符名。

     一个列表可以看作第一个元素（称为首部Head)与后面所有元素(称为尾部Tail)的组合。

     这样两个操作构成了列表的灵魂，深入研究组合子非常必要。