1. 协议
a. TCP/IP整体构架概述
TCP/IP协议并不完全符合OSI的七层参考模型。传统的开放式系统互连参考模型,是一种通信协议的7层抽象的参考模型,其中每一层执行某一特定任务。该模型的目的是使各种硬件在相同的层次上相互通信。这7层是:物理层、数据链路层、网路层、传输层、话路层、表示层和应用层。而TCP/IP通讯协议采用了4层的层级结构,每一层都呼叫它的下一层所提供的网络来完成自己的需求。这4层分别为:
i. 应用层:应用程序间沟通的层,如超文本传送协议(HTTP)、简单电子邮件传输(SMTP)、文件传输协议(FTP)、网络远程访问协议(Telnet)等。
ii. 传输层:在此层中,它提供了节点间的数据传送服务,如传输控制协议(TCP)、用户数据报协议(UDP)等,TCP和UDP给数据包加入传输数据并把它传输到下一层中,这一层负责传送数据,并且确定数据已被送达并接收。
iii. 互连网络层:负责提供基本的数据封包传送功能,让每一块数据包都能够到达目的主机(但不检查是否被正确接收),如网际协议(IP)。
iv. 网络接口层:对实际的网络媒体的管理,定义如何使用实际网络(如Ethernet、Serial Line等)来传送数据。
b. HTTP协议介绍:
i. HTTP是一种超文本传送协议(HyperText Transfer Protocol),是一套计算机在网络中通信的一种规则。在TCP/IP体系结构中,HTTP属于应用层协议,位于TCP/IP协议的顶层
ii. HTTP是一种无状态的的协议,意思是指 在Web 浏览器(客户端)和 Web 服务器之间不需要建立持久的连接。整个过程就是当一个客户端向服务器端发送一个请求(request),然后Web服务器返回一个响应 (response),之后连接就关闭了,在服务端此时是没有保留连接的信息。
iii. HTTP 遵循 请求/响应(request/response) 模型的,所有的通信交互都被构造在一套请求和响应模型中。
iv. 浏览WEB时,浏览器通过HTTP协议与WEB服务器交换信息,Web服务器向Web浏览器返回的文件都有与之相关的类型,这些信息类型的格式由MIME定义。
c. 协议的java实现方式
不论是TCP/IP协议也好,还是HTTP协议也好,java都是通过套接字(java.net.Socket)来实现的,可以参考我的另一篇技术博客:一个项目看java TCP/IP Socket编程(1.3版)
2. HTTP报文接口及客户端和服务器端交互原理
a. HTTP定义的事务处理由以下四步组成:
i. 建立连接:
例如我在浏览器里输入 http://cuishen.iteye.com,客户端请求这个地址时即打开了web服务器HTTP端口的一个套接字。因为在网络中间作为传递数据的实体介质就是网线,数据实质上是通过IO流进行输出和输入,这就不难理解我们为什么在写一个Servlet的时候要引用 import java.io.*; 的原因 ,包括我们在向客户端回发结果的时候要用到PrintWriter对象的println()方法。其实请求的这个地址还要加上端口号80,80可以不写,是因为浏览器默认的端口号是80。
在Java底层代码中是这样实现的,只不过它们已经帮我们做了。
1.Socket socket = new Socket("cuishen.iteye.com",80); 2.InputStream in = socket.getInputStream(); 3.OutputStream out = socket.getOutputStream();
ii. 客户端发送HTTP请求报文(request)
一旦建立了TCP连接,Web浏览器就会向Web服务器发送请求命令,是一个ASCII文本请求行,后跟0个或多个HTTP头标,一个空行和实现请求的任意数据。
即报文分四个部分:请求行,请求头标,空行和请求数据
1)请求行
请求行由三个标记组成:请求方法、请求URL和HTTP版本,中间用空格分开
例如: GET cuishen.iteye.com/blog/242842 HTTP/1.1
HTTP规范定义了8种可能的请求方法:(最常见的就是 GET 和 POST 两种方法)
GET -- 检索URI中标识资源的一个简单请求
HEAD -- 与GET方法相同,服务器只返回状态行和头标,并不返回请求文档
POST -- 服务器接受被写入客户端输出流中的数据的请求
PUT -- 服务器保存请求数据作为指定URI新内容的请求
DELETE -- 服务器删除URI中命名的资源的请求
OPTIONS -- 关于服务器支持的请求方法信息的请求
TRACE -- Web服务器反馈Http请求和其头标的请求
CONNECT -- 已文档化但当前未实现的一个方法,预留做隧道处理
2)请求头标
请求头标:由key :value 健值组成,每行一对。请求头标用来通知服务器有关客户端的功能和标识。
HOST -- 请求的哪一个服务器端地址,主地址,比如:我的技术blog:cuishen.iteye.com
User-Agent -- 用户即客户端可以使用的浏览器 ,如: Mozilla/4.0
Accept -- 即客户端可以接受的MIME 类型列表,如image/gif、text/html、application/msword
Content-Length -- 只适用于POST请求,以字节给出POST数据的尺寸
3)空行
发送回车符和退行,通知服务器以下不再有头标。
4)请求数据
使用POST传送数据,最常使用的是Content-Type和Content-Length头标。
请求报文总结:
我们可以这样写出一个标准的 HTTP请求:
POST /blog/242842 HTTP1.1
HOST: cuishen.iteye.com/
User-Agent: Mozilla/4.0
Accpt: image/gif,text/html,application/pdf,image/png...
key=value&key=value&key=value...... (POST()请求的数据)
这上面的一个例子意思是:
我要去访问的服务器端的地址是cuishen.iteye.com/ 它下面的资源 /blog/242842
连起来就是: cuishen.iteye.com/blog/242842
这个页面用的是 HTTP1.1 规范,我的浏览器版本是Mozilla/4.0
可以支持的MIME格式为 image/gif,text/html,application/pdf,image/png...等等
这个MIME格式我们在servlet中写法是:response.setContentType("text/html;charset=gb2312");
或者在jsp中写法是:<%@ page contentType="text/html;charset=gb2312"%>
或者在html中写法是:<meta http-equiv="content-Type" content="text/html; charset=gb2312">
GET 和 POST 最直观的区别就是:GET方法将数据的请求跟在了所请求的URL后面,也就是在请求行里面我们是这么样来做的:
GET /blog/242842?key=value&key=value&key=value......HTTP1.1
实际上用 GET 是这样传递数据的:
http://cuishen.iteye.com/?page=2......
iii.服务器端响应请求生成结果并回发(response)
Web 服务器解析请求,定位指定的资源 http://cuishen.iteye.com/blog/242842
1)根据请求时的 GET/POST 对应的用servlet里的 doGet() / doPost()方法来处理(有可能是一些业务逻辑,也有可能是一些验证等等,也有可能是一些数据查询,提交等等)其有效的数据就来源于key=value&key=value&key=value......,以及其它的一些封装在 request 对象中的数据资源。
2)处理请求之后,由 response 对象得到 java.io.PrintWriter 输出流对象out,通过 out.println(); 将数据以指定的格式,如按照response.setcontentType("text/html;charset=gb2312");的格式输出到输出流。
它的响应报文与请求报文非常类似,其区别就在于:我们在请求阶段的请求行被状态行给替换了,再来看响应报文:
3)一个响应报文由四个部分组成:状态行、响应头标、空行、响应数据:
(a).状态行:
状态行由三个标记组成:HTTP版本、响应代码和响应描述。
HTTP1.1 --- 100 --- continue //继续追加后继内容
HTTP1.1 --- 200 --- OK //一切正常
HTTP1.1 --- 301 --- Moved Permanently //请求的文档在其它地方,会自动连接
HTTP1.1 --- 403 --- Forbidden //绝对拒绝你访问这个资源,不管授权没有
HTTP1.1 --- 400 --- Bad Request //客户端请求中的不良语法
HTTP1.1 --- 404 --- Not Found //最常见,绝对是大名鼎鼎的找不到
HTTP响应码:
1xx:提示性信息,告诉客户端应该对某些其它的动作作出响应
2xx:这些就代表了请求成功
3xx:重定向,为了完成请求,必须进一步执行的动作
4xx:客户端错误
500-599: 服务器端的错误
(b).响应头标:像请求头标一样,它们指出服务器的功能,标识出响应数据的细节。
Date: Sat, 31 Dec 2005 23:59:59 GMT --响应生成的日期和时间
ContentType: 'text/html;charset=gb2312'
Content-Length: 122 --响应中的字节数,只在浏览器使用永久(Keep-alive)HTTP连接时需要。
(c).空行:最后一个响应头标之后是一个空行,发送回车符和退行,表明服务器以下不再有头标。
(d).响应数据:HTML文档和图像等,也就是HTML本身。out.println("<html>......");写到客户端。
1.<html> 2.<head> 3.<title>Welcome to cuishen's IT blog</title> 4.</head> 5.<body> 6.<!-- 这里是具体的内容,看到了这里 7.相信大家对 HTTP 工作原理及客户端与服务器交互过程已经很清楚了吧 8.--> 9.</body> 10.</html>
iv. 服务器端关闭连接,客户端解析回发响应报文,恢复页面
1)浏览器先解析状态行,查看请求是否成功的状态代码--HTTP响应码:404 400 200 ....
2)解析每一个响应头标,如:
ContentType: text/html;charset=gb2312
Content-Length: 122 --- 响应中的字节数,只在浏览器使用永久(Keep-alive)HTTP连接时需要。
3)读取响应数据HTML,根据标签<html></html>中的内容恢复标准的HTML格式页面或者其它。
4)一个HTML 文档可能包含其它的需要被载入的资源,浏览器会识别,并对这些资源再进行额外的请求,这个过程可以是循环的方式一直到所有的数据都按照响应头标中规定的格式恢复到页面中。
5)数据传送完毕,服务器端关闭连接,即无状态协议。
3. 总结
不要被高深的名词和理论吓到,其实HTTP客户端和服务器端的交互原理很简单:即先是浏览器和服务器端建立Socket无状态连接,也就是短连接,然后通过IO流进行报文信息(这个报文是严格遵循HTTP报文接口的)的交互,最后会话结束后就关闭连接。对于这些底层的协议和报文的打包解包交互的实现,其实java和浏览器早都已经封装好了,程序员只要专注于业务逻辑的实现就行啦,这些都不必关心!!
1,什么是Servlet
2,Servlet有什么作用
3,Servlet的生命周期
4,Servlet怎么处理一个请求
5,Servlet与JSP有什么区别
6,Servlet里的cookie技术
7,Servlet里的过滤器
8,Servlet里的监听器
一,什么是Servlet?
Servlet是一个Java编写的程序,此程序是基于Http协议的,在服务器端运行的(如tomcat),
是按照Servlet规范编写的一个Java类。
二,Servlet有什么作用?
主要是处理客户端的请求并将其结果发送到客户端。
三,Servlet的生命周期?
Servlet的生命周期是由Servlet的容器来控制的,它可以分为3个阶段;初始化,运行,销毁。
初始化阶段:
1,Servlet容器加载servlet类,把servlet类的.class文件中的数据读到内存中。
2,然后Servlet容器创建一个ServletConfig对象。ServletConfig对象包含了Servlet的初始化配置信息。
3,Servlet容器创建一个servlet对象。
4,Servlet容器调用servlet对象的init方法进行初始化。
运行阶段:
当servlet容器接收到一个请求时,servlet容器会针对这个请求创建servletRequest和servletResponse对象。
然后调用service方法。并把这两个参数传递给service方法。Service方法通过servletRequest对象获得请求的
信息。并处理该请求。再通过servletResponse对象生成这个请求的响应结果。然后销毁servletRequest和
servletResponse对象。我们不管这个请求是post提交的还是get提交的,最终这个请求都会由service方法来处理。
销毁阶段:
当Web应用被终止时,servlet容器会先调用servlet对象的destrory方法,然后再销毁servlet对象,
同时也会销毁与servlet对象相关联的servletConfig对象。我们可以在destroy方法的实现中,释放
servlet所占用的资源,如关闭数据库连接,关闭文件输入输出流等。
在这里该注意的地方:
在servlet生命周期中,servlet的初始化和和销毁阶段只会发生一次,而service方法执行的次数则取决于servlet被客户
端访问的次数
四,Servlet怎么处理一个请求?
当用户发送一个请求到某个Servlet的时候,Servlet容器会创建一个ServletRequst和ServletResponse对象。
在ServletRequst对象中封装了用户的请求信息,然后Servlet容器把ServletRequst和ServletResponse对象
传给用户所请求的Servlet,Servlet把处理好的结果写在ServletResponse中,然后Servlet容器把响应结果传
给用户。
五,Servlet与JSP有什么区别?
1,jsp经编译后就是servlet,也可以说jsp等于servlet。
2,jsp更擅长页面(表现)。servlet更擅长逻辑编辑。 (最核心的区别)。
3,在实际应用中采用Servlet来控制业务流程,而采用JSP来生成动态网页.在struts框架中,
JSP位于MVC设计模式的视图层,而Servlet位于控制层。
六,Servlet里的cookie技术?
cookies是一种WEB服务器通过浏览器在访问者的硬盘上存储信息的手段,是由Netscape公司开发出来的。
cookie技术的好处:
1,Cookie有效期限未到时,Cookie能使用户在不键入密码和用户名的情况下进入曾经浏览过的一些站点。
2,Cookie能使站点跟踪特定访问者的访问次数、最后访问时间和访问者进入站点的路径。 创建一个cookie
1 //里面的两个参数分别是cookie的名和cookie的值 2 3 response.addCookie(new Cookie("abc","10000000"));
使用cookie
1.Cookie[] cook =request.getCookies();//用一个Cookie数组来接收 2. 3.for(int j=0;j<cook.length;j++){//通过循环来打印Cookie 4. 5. cook[j].getName()://取cookie的名 6. cook[j].getValue()://去cookie的值 7. 8.}
七,Servlet里的过滤器?
过滤器的主要作用
1,任何系统或网站都要判断用户是否登录。
2,网络聊天系统或论坛,功能是过滤非法文字
3,统一解决编码
(2)怎么创建一个过滤器:
1,生成一个普通的class类,实现Filter接口(javax.servlet.Filter;)。
2,重写接口里面的三个方法:init,doFilter,destroy。
3,然后在web.xml配置过滤器。
八,Servlet里的监听器?
监听器的作用:自动执行一些操作。
三种servlet监听器:
对request的监听。对session的监听。对application的监听。
怎么创建一个session监听器:
1,生成一个普通的class类,如果是对session的监听,则实现HttpSessionListener。
2,然后重写里面的五个方法:
1.public void sessionCreated(HttpSessionEvent arg0) {} // 创建 2. 3.public void sessionDestroyed(HttpSessionEvent arg0) {} // 销毁 4. 5.public void attributeAdded(HttpSessionEvent arg0) {} // 增加 6. 7.public void attributeRemoved(HttpSessionEvent arg0) {} // 删除 8. 9.public void attributeReplaced(HttpSessionEvent arg0) {} // 替换
|
VB.NET |
C# |
||||||||||
|
Comments |
|||||||||||
|
' Single line only |
// Single line |
||||||||||
|
Data Types |
|||||||||||
|
Value Types Reference Types Dim x As Integer ' Type conversion |
Value Types Reference Types int x;
|
||||||||||
|
Constants |
|||||||||||
|
Const MAX_STUDENTS As Integer = 25 |
const int MAX_STUDENTS = 25; |
||||||||||
|
Enumerations |
|||||||||||
|
Enum Action |
enum Action {Start, Stop, Rewind, Forward}; |
||||||||||
|
Operators |
|||||||||||
|
Comparison Arithmetic Assignment Bitwise Logical Note: AndAlso and OrElse are for short-circuiting logical evaluations String Concatenation |
Comparison Arithmetic Assignment Bitwise Logical Note: && and || perform short-circuit logical evaluations String Concatenation |
||||||||||
|
Choices |
|||||||||||
|
greeting = IIf(age < 20, "What's up?", "Hello") ' One line doesn't require "End If", no "Else" ' Use : to put two commands on same line ' or to break up any long single command use _ 'If x > 5 Then Select Case color ' Must be a primitive data type |
greeting = age < 20 ? "What's up?" : "Hello"; if (x != 100) { // Multiple statements must be enclosed in {} No need for _ or : since ; is used to terminate each statement.
|
||||||||||
|
Loops |
|||||||||||
' Array or collection looping |
Pre-test Loops: // no "until" keyword
|
||||||||||
|
Arrays |
|||||||||||
|
Dim nums() As Integer = {1, 2, 3}
|
int[] nums = {1, 2, 3}; float[,] twoD = new float[rows, cols]; int[][] jagged = new int[3][] { |
||||||||||
|
Functions |
|||||||||||
|
' Pass by value (in, default), reference (in/out), and reference (out) Dim a = 1, b = 1, c As Integer ' c set to zero by default ' Accept variable number of arguments ' Optional parameters must be listed last and must have a default value |
// Pass by value (in, default), reference (in/out), and reference (out) int a = 1, b = 1, c; // c doesn't need initializing // Accept variable number of arguments int total = Sum(4, 3, 2, 1); // returns 10 /* C# doesn't support optional arguments/parameters. Just create two different versions of the same function. */ |
||||||||||
|
Exception Handling |
|||||||||||
|
' Deprecated unstructured error handling Try |
try { |
||||||||||
|
Namespaces |
|||||||||||
|
Namespace Harding.Compsci.Graphics ' or Namespace Harding Import Harding.Compsci.Graphics |
namespace Harding.Compsci.Graphics { // or namespace Harding { using Harding.Compsci.Graphics; |
||||||||||
|
Classes / Interfaces |
|||||||||||
|
Accessibility keywords ' Inheritance ' Interface definition // Extending an interface // Interface implementation |
Accessibility keywords // Inheritance
// Extending an interface
|
||||||||||
|
Constructors / Destructors |
|||||||||||
|
Class SuperHero |
class SuperHero { |
||||||||||
|
Objects |
|||||||||||
|
Dim hero As SuperHero = New SuperHero Dim hero2 As SuperHero = hero ' Both refer to same object hero = Nothing ' Free the object If hero Is Nothing Then _ Dim obj As Object = New SuperHero |
SuperHero hero = new SuperHero(); hero.Defend("Laura Jones");
hero = null ; // Free the object if (hero == null)
|
||||||||||
|
Structs |
|||||||||||
|
Structure StudentRecord Dim stu As StudentRecord = New StudentRecord("Bob", 3.5) |
struct StudentRecord { StudentRecord stu = new StudentRecord("Bob", 3.5f); |
||||||||||
|
Properties |
|||||||||||
|
Private _size As Integer foo.Size += 1 |
private int _size;
|
||||||||||
|
Delegates / Events |
|||||||||||
|
Delegate Sub MsgArrivedEventHandler(ByVal message As String) Event MsgArrivedEvent As MsgArrivedEventHandler ' or to define an event which declares a delegate implicitly AddHandler MsgArrivedEvent, AddressOf My_MsgArrivedCallback Imports System.Windows.Forms Dim WithEvents MyButton As Button ' WithEvents can't be used on local variable Private Sub MyButton_Click(ByVal sender As System.Object, _ |
delegate void MsgArrivedEventHandler(string message); event MsgArrivedEventHandler MsgArrivedEvent; // Delegates must be used with events in C#
Button MyButton = new Button(); private void MyButton_Click(object sender, System.EventArgs e) { |
||||||||||
|
Console I/O |
|||||||||||
|
Special character constants Console.Write("What's your name? ") |
Escape sequences Convert.ToChar(65) // Returns 'A' - equivalent to Chr(num) in VB Console.Write("What's your name? ");
|
||||||||||
|
File I/O |
|||||||||||
|
Imports System.IO Dim writer As StreamWriter = File.CreateText("c:\myfile.txt") Dim reader As StreamReader = File.OpenText("c:\myfile.txt") Dim str As String = "Text data" Dim binReader As New BinaryReader (File.OpenRead("c:\myfile.dat")) |
using System.IO; StreamWriter writer = File.CreateText("c:\\myfile.txt"); StreamReader reader = File.OpenText("c:\\myfile.txt"); string str = "Text data"; BinaryReader binReader = new BinaryReader(File.OpenRead("c:\\myfile.dat")); |
||||||||||
转载自:http://www.harding.edu/fmccown/vbnet_csharp_comparison.html#linq
既然是面向对象,那最重要的概念无非是对象。我们面对的一切事物其实都是对象。对象有它的固有属性和固有方法,其实对象也就是由一个属性集合和一个方法集合组成的。这可以结合 C# 理解,在 C# 中对象是类的实例,而每个类都定义了一系列的属性和方法。然后说到类,这也是一个重要的概念。类,很简单,是一类对象的集合,它不是一个具体的集合,而是一种抽象描述,而描述方式就是此类对象的共有属性和方法。换句话说就是共性,很简单。类和对象的概念是面向对象的基础,有了这两者,我们已经可以描述整个宇宙,从抽象到具体,从时间到空间的任何事物。面向对象的还有一个概念于是出现了:抽象。如果你觉得前面的概念很简单的话,接下来可能就难以理解了。可惜理解抽象同样很重要,因为我们有这么多类,无穷多个,如果没有一个统一的称呼,没有一个办法对其进行进一步的分类,会难以找到其中的关系,从而难以利用这些类和对象来解决实际问题。那么幸好我们有抽象。抽象是把具体的事物合并,舍弃一些次要的属性而保留共有属性。在这个意义上来讲,它是设计类时的参照。记住,再说一次,这是你设计类时候的依据!经常有初学者迷茫于如何能设计出结构良好的程序,其实他们纠结的是如何能设计出良好的类结构。
那么关于它和面向过程有什么区别呢?
面向过程就是分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步实现,使用的时候一个一个依次调用就可以了。 面向对象是把构成问题事务分解成各个对象,建立对象的目的不是为了完成一个步骤,而是为了描叙某个事物在整个解决问题的步骤中的行为。例如五子棋,面向过程的设计思路就是首先分析问题的步骤:1、开始游戏,2、黑子先走,3、绘制画面,4、判断输赢,5、轮到白子,6、绘制画面,7、判断输赢,8、返回步骤2,9、输出最后结果。把上面每个步骤用分别的函数来实现,问题就解决了。而面向对象的设计则是从另外的思路来解决问题。整个五子棋可以分为 1、黑白双方,这两方的行为是一模一样的,2、棋盘系统,负责绘制画面,3、规则系统,负责判定诸如犯规、输赢等。第一类对象(玩家对象)负责接受用户输入,并告知第二类对象(棋盘对象)棋子布局的变化,棋盘对象接收到了棋子的i变化就要负责在屏幕上面显示出这种变化,同时利用第三类对象(规则系统)来对棋局进行判定。可以明显地看出,面向对象是以功能来划分问题,而不是步骤。同样是绘制棋局,这样的行为在面向过程的设计中分散在了总多步骤中,很可能出现不同的绘制版本,因为通常设计人员会考虑到实际情况进行各种各样的简化。而面向对象的设计中,绘图只可能在棋盘对象中出现,从而保证了绘图的统一。功能上的统一保证了面向对象设计的可扩展性。比如我要加入悔棋的功能,如果要改动面向过程的设计,那么从输入到判断到显示这一连串的步骤都要改动,甚至步骤之间的循序都要进行大规模调整。如果是面向对象的话,只用改动棋盘对象就行了,棋盘系统保存了黑白双方的棋谱,简单回溯就可以了,而显示和规则判断则不用顾及,同时整个对对象功能的调用顺序都没有变化,改动只是局部的。再比如我要把这个五子棋游戏改为围棋游戏,如果你是面向过程设计,那么五子棋的规则就分布在了你的程序的每一个角落,要改动还不如重写。但是如果你当初就是面向对象的设计,那么你只用改动规则对象就可以了,五子棋和围棋的区别不就是规则吗?(当然棋盘大小好像也不一样,但是你会觉得这是一个难题吗?直接在棋盘对象中进行一番小改动就可以了。)而下棋的大致步骤从面向对象的角度来看没有任何变化。当然,要达到改动只是局部的需要设计的人有足够的经验,使用对象不能保证你的程序就是面向对象,初学者或者很蹩脚的程序员很可能以面向对象之虚而行面向过程之实,这样设计出来的所谓面向对象的程序很难有良好的可移植性和可扩展性。
为啥会有LINQ,主要还是因为现在的数据格式越来越多,数据库、XML、数组、哈希表……每一种都有自己操作数据的方式,学起来费事费力。于是,就有了LINQ 诞生的理由——以一种统一的方式操作各种数据源,减少数据访问的复杂性。LINQ 目前可以对XML, Object, SQL 做数据访问,今后还会有LINQ to Entity的功能。说来惭愧,我也是刚刚才接触LINQ,先从最简单的开始吧,先来看以下代码。
1 MethodInfo[] methods = typeof(StringBuilder).GetMethods();
2 var result = from m in methods where m.IsStatic == false select m.Name;
3 var res = (from m in methods where m.IsStatic != true select m.Name).Distinct();
4 var result2 = from m in methods where m.IsStatic != true
5 group m by m.Name into g select new { MethodName = g.Key, Overload = g.Count() }; //匿名类
6 MyClass mc = new MyClass { Methods = "myMethod", Overload = 1 };
7 foreach (var r in result2)
8 {
9 Console.WriteLine(r);
10 }
11 Console.ReadKey();
看起来,有点像javascript 里面的弱类型的变量声明。但是,C#是强类型的,尽管你用var 来声明,编译器还是可以根据上下文推倒出它当前的类型。比如这个例子里面,result 就是IEnumerable 类型的。在这里面,写IEnumerable 和写var 是一样效果的,显然,var 会简单得多。你不用考虑数据操作的返回值是什么类型,还能享受强类型声明带来的方便实惠。还有from m in methods 这句,m 是什么东西,m 是隐式声明的一个变量,尽管没有声明,但编译器根据上下文,推断出它的类型是MethodInfo 型的!.NETFramework 3.5 的编译器的确是聪明了很多。纯粹给懒人用的var 关键字,告诉编译器(对于CLR 来说,它是不会知道你是否使用了var,苦力是编译器出的),你自己推断它的类型吧,我不管了。但是既然让编译器推断类型就必须声明的时候赋值,而且不能是null 值。注意,这只能用于局部变量,用于字段是不可以的。
Lambda 表达式:
var list = new [] { "aa", "bb", "ac" };
var result = Array.FindAll(list, s => (s.IndexOf("a") > -1));
foreach (var v in result)
Console.WriteLine(v);
其实和2.0 中的匿名方法差不多,都是用于产生内联方法,只不过Lambda
表达式的语法更为简洁。语法如下:
(参数列表) => 表达式或者语句块
其中:
参数个数:可以有多个参数,一个参数,或者无参数。
参数个数:可以有多个参数,一个参数,或者无参数。
表达式或者语句块:这部分就是我们平常写函数的实现部分(函数体)。
前面的示例分别是1 个参数的例子,下面结合扩展方法来一个复杂的例子:
public delegate int mydg(int a, int b);
public static class LambdaTest
{
public static int oper(this int a, int b, mydg dg)
{
return dg(a, b);
}
}
Console.WriteLine(1.oper(2, (a, b) => a + b));
Console.WriteLine(2.oper(1, (a, b) => a - b));
再来看如下查询例子:
var persons = new List<Person> { new Person { username = "a", age = 19 },
new Person { username = "b", age = 20 },
new Person { username = "a", age = 21 } };
var selectperson = from p in persons where p.age >= 20 select p.username.ToUpper();
foreach (var p in selectperson)
Console.WriteLine(p);
public class Person
{
public string username { get; set; }
public int age { get; set; }
}
查询句法是使用标准的LINQ 查询运算符来表达查询时一个方便的声明式简化写法。该句法能在代码里表达查询时增进可读性和简洁性,读起来容易,也容易让人写对。Visual Studio 对查询句法提供了完整的智能感应和编译时检查支持。
初步入门到此。。。