C# notes

C# 基本用法和程序

程序结构(demo1)

using System;
namespace HelloWorldApplication
{
   class HelloWorld
   {
      static void Main(string[] args)
      {
         /* 我的第一个 C# 程序*/
         Console.WriteLine("Hello World");
         Console.ReadKey();
      }
   }
}

让我们看一下上面程序的各个部分：

• 程序的第一行 using System; - using 关键字用于在程序中包含 System 命名空间。 一个程序一般有多个 using 语句。

• 下一行是 namespace 声明。一个 namespace 里包含了一系列的类。HelloWorldApplication 命名空间包含了类 HelloWorld。

• 下一行是 class 声明。类 HelloWorld 包含了程序使用的数据和方法声明。类一般包含多个方法。方法定义了类的行为。在这里，HelloWorld 类只有一个 Main 方法。

• 下一行定义了 Main 方法，是所有 C# 程序的 入口点。Main 方法说明当执行时 类将做什么动作。

• 下一行 /…/ 将会被编译器忽略，且它会在程序中添加额外的 注释。

• Main 方法通过语句

  Console.WriteLine("Hello World"); 指定了它的行为。

  WriteLine 是一个定义在 System 命名空间中的 Console 类的一个方法。该语句会在屏幕上显示消息 “Hello World”。

• 最后一行 Console.ReadKey(); 是针对 VS.NET 用户的。这使得程序会等待一个按键的动作，防止程序从 Visual Studio .NET 启动时屏幕会快速运行并关闭。

Namespace

Namespace: 提供一种让一组名称与其他的分割开来的方式，在一个命名空间中生命的类的

namespace namespace_name
{
   // 代码声明
}

e.g.

using System;
namespace first_space
{
   class namespace_cl
   {
      public void func()
      {
         Console.WriteLine("Inside first_space");
      }
   }
}
namespace second_space
{
   class namespace_cl
   {
      public void func()
      {
         Console.WriteLine("Inside second_space");
      }
   }
}  
class TestClass
{
   static void Main(string[] args)
   {
      first_space.namespace_cl fc = new first_space.namespace_cl();
      second_space.namespace_cl sc = new second_space.namespace_cl();
      fc.func();
      sc.func();
      Console.ReadKey();
   }
}

// ============

Inside first_space 
Inside second_space
 

Using:

表明程序使用的是给定命名空间中的名称

Using System;
Console.Writeline("Hello there");
// === 等价于
  
System.Console.Writeline("Hello there");

.Net Framework

.Net Framework 框架是.Net平台不可缺少的一部分，它提供了一个稳定的运行环境以来保证我们基于.net平台开发的各种应用能够正常的运转（一种平台一种技术）

• CLR （公共语言运行时）
• .Net 类库

C# 中 // 注释和 /// 注释的区别

/// 会被编译， // 不会

所以使用 /// 会减慢编译的速度（但不会影响执行速度）

/// 会在其它的人调用你的代码时提供智能感知

/// 也是一种注释，但是这种注释主要有两种作用：

• 1.这些注释能够生成一个XML文件。这样呢,看起来会对程序的内容一目了然。
• 2.以这种方式对你的类，属性，方法等等加上注释之后，当你在其他地方使用以这种方式加上的类，属性，方法等等地时候，黄色的提示框里面会把你写的注释显示出来，是你更加明白你要使用的功能的作用。

/// <summary>
///定义用户姓名属性，该属性为可读可写属性
/// </summary>

C# 编码的时候，常常涉及代码注释，常见的注释包括两类：

• 1）单行注释。格式：// Comments
• 2）多行注释。格式：/* Comments… */

C# 引入了新的 XML 注释，即我们在某个函数前新起一行，输入 ///，VS.Net 会自动增加XML格式的注释，这里整理一下可用的XML注释。 XML 注释分为一级注释（Primary Tags）和二级注释（Secondary Tags），前者可以单独存在，后者必须包含在一级注释内部。

I 一级注释

\1. <remarks>对类型进行描述，功能类似<summary>，据说建议使用<remarks>;
\2. <summary>对共有类型的类、方法、属性或字段进行注释；
\3. <value>主要用于属性的注释，表示属性的制的含义，可以配合<summary>使用；
\4. <param>用于对方法的参数进行说明，格式：<param name=”param_name”>value</param>；
\5. <returns>用于定义方法的返回值，对于一个方法，输入///后，会自动添加<summary>、<param>列表和<returns>；
\6. <exception>定义可能抛出的异常，格式：<exception cref=”IDNotFoundException”>；
\7. <example>用于给出如何使用某个方法、属性或者字段的使用方法；
\8. <permission>涉及方法的访问许可；
\9. <seealso>用于参考某个其它的东东:)，也可以通过cref设置属性；
\10. <include>用于指示外部的XML注释；

II 二级注释

\1. <c> or <code>主要用于加入代码段；
\2. <para>的作用类似HTML中的<p>标记符，就是分段；
\3.<pararef>用于引用某个参数；
\4. <see>的作用类似<seealso>，可以指示其它的方法；
\5. <list>用于生成一个列表；
另外，还可以自定义XML标签

让C#智能注释时显示为换行

在C#智能注释时，常常希望它能在开发时显示为换行，使得提示更加友好！原来一直想怎么实现，今天偶然发现原来如此简单，只需将<para> 标记用于诸如 <summary>、<remarks> 或 <returns> 等标记内即可。

注释在开发时换行显示的办法

<para> 标记用于诸如 <summary>、<remarks> 或 <returns> 等标记内，使您得以将结构添加到文本中。

/// <summary> 
/// 基类（第1行） 
///<para>说明：（第2行）</para> 
///<para>　　封装一些常用的成员（第3行）</para> 
///<para>　　前面要用全角空格才能显示出空格来（第4行）</para> 
/// </summary> 
public class MyBase 
{ 
      /// <summary> 
      /// 构造函数（第1行） 
      ///<para>说明：（第2行）</para> 
      ///<para>　　初始化一些数据（第3行）</para> 
      /// </summary> 
      public MyBase() 
      { 
            // 
            //TODO: 在此处添加构造函数逻辑 
            // 
       } 
} 

#region（C# 参考）

#region 使您可以在使用Visual Studio 代码编辑器的大纲显示功能时指定可展开或折叠的代码块。 在较长的代码文件中，能够折叠或隐藏一个或多个区域会十分便利，这样，您可将精力集中于当前处理的文件部分。

OOP编程

对象和类

• 对象是OOP应用程序的组成部件。

• 类是用于实例化对象的类型定义。

对象可以包含数据，提供其他代码可以使用的操作。数据可以通过属性供外部代码使用，操作可以通过方法供外部代码使用。

属性和方法都称为类的成员。属性可以进行读取访问、写入访问或读写访问。类成员可以是公共的（可用于所有代码）或私有的（只有类定义中的代码可以使用）。在.NET中，所有的东西都是对象

对象的生命周期

• 构造阶段： 第一次实例化一个对象时，需要初始化该对象。这个初始化过程称为构造阶段，由构造函数完成。
• 析构阶段： 在删除一个对象时，常常需要执行一些清理工作，例如释放内存，这由析构函数完成。

CupOfCoffee myCup = new CupOfCoffee();
CupOfCoffee myCup = new CupOfCoffee("Blue Mountain");

静态成员和实例类成员

• 静态构造函数
  • 使用类中的静态成员时，需要预先初始化这些成员。在声明时，可以给静态成员提供一个初始值，但有时需要执行更复杂的初始化操作，或者在赋值、执行静态方法之前执行某些操作。

实例成员只能在类的对象实例上使用，静态成员只能直接通过类定义使用，它不与实例关联

C# 中的static的用法

静态全局变量

定义：在全局变量前，加上关键字 static 该变量就被定义成为了一个静态全局变量。

特点：
　　A、该变量在全局数据区==分配内存==。
　　B、初始化：如果不显式初始化，那么将被==隐式初始化为0==。

静态局部变量

定义：在局部变量前加上static关键字时，就定义了静态局部变量。

特点：
　　A、该变量在全局数据区分配内存。
　　B、初始化：如果不显式初始化，那么将被隐式初始化为0。
　　C、它始终驻留在全局数据区，直到程序运行结束。但其作用域为局部作用域，当定义它的函数或语句块结束时，其作用域随之结束。

静态数据成员

特点：
　　A、内存分配：在程序的全局数据区分配。
　　B、初始化和定义：
　　　 a、静态数据成员定义时要分配空间，所以不能在类声明中定义。
　　　 b、为了避免在多个使用该类的源文件中，对其重复定义，所以，不能在类的头文件中定义。
　　　 c、静态数据成员因为程序一开始运行就必需存在，所以其初始化的最佳位置在类的内部实现。
　　C、特点
　　　 a、对相于 public,protected,private 关键字的影响它和普通数据成员一样，
　　　 b、因为其空间在全局数据区分配，属于所有本类的对象共享，所以，它不属于特定的类对象，在没产生类对象时其作用域就可见，即在没有产生类的实例时，我们就可以操作它。
　　D、访问形式
　　　 a、 类对象名.静态数据成员名
　　E、静态数据成员，主要用在类的所有实例都拥有的属性上。比如，对于一个存款类，帐号相对于每个实例都是不同的，但每个实例的利息是相同的。所以，应该把利息设为存款类的静态数据成员。这有两个好处，第一，不管定义多少个存款类对象，利息数据成员都共享分配在全局区的内存，所以节省存贮空间。第二，一旦利息需要改变时，只要改变一次，则所有存款类对象的利息全改变过来了，因为它们实际上是共用一个东西。

静态成员函数

特点：
　　A、静态成员函数与类相联系，不与类的对象相联系。
　　B、静态成员函数不能访问非静态数据成员。原因很简单，非静态数据成员属于特定的类实例。
作用：
　　主要用于对静态数据成员的操作。

调用形式：
　　类对象名.静态成员函数名（）

static静态变量的实例与分析

class class1
   {
       static int i = getNum();
       int j = getNum();

       static int num = 1;

       static int getNum()
       {
           return num;
       }

       static void Main(string[] args)
       {
           Console.WriteLine("i={0}",i);
           Console.WriteLine("j={0}", new class1().j);
           Console.Read();
       }
   }1

分析：Console.WriteLine("i={0}",i);这里i是static变量，而且类class1是第一次被引 用，要先为class1里面所有的static变量分配内存。尽管现在有超线程技术，但是指令在逻辑还是一条一条的按顺序执行的，所以先为static int i分配内存，并且在该内存中保持int的缺省值0，接着再为static int num 变量分配内存，值当然也为0。

然后执行第二步，为变量赋值：先为static int i变量赋值，i＝getNum（），看getNum里面的代码，就是return num，这个时候num的值是0，于是i就为0了。然后对变量num赋值，num＝1；这行代码执行后，num就为1了。

所以最后的结果为：

i＝0 j＝11

当以一次引用类的时候，会对类中的静态变量先按顺序进行分配内存空间，当全部分配完内存空间之后，在对静态变量按顺序赋值。

static的优点是什么？为什么要使用static 变量或函数？？

有一些频繁使用的东西，如果你每次使用都重新new一下，那么这个开销可能会很高，如果使用static，一直放在内存中，那么想用就直接用，而不需要重新new一块空间初始化数据。那么static就是为了实现一个系统的缓存作用的，其生命周期直到应用程序退出结束。

静态成员包括静态字段和静态属性，静态成员和类相关联，不依赖于对象而存在，只能由类访问，而不能由对象访问；

静态成员属于类所有，无认创建多少实例对象，静态成员在内存中只有一份；实例成员属于类的实例所有，每创建一个实例对象，实例成员都会在内存中分配一块内存区域。
所以静态成员一般用于存放共享的数据段，如数据库连接字符串等。

一个类如果只包含静态成员和静态方法，则该类可以定义为静态类，给类加上static修饰符；

静态方法和非静态方法：

一、性能上：静态方法和实例方法差别不大。所有方法，不管是静态方法还是实例方法，都是在JIT加载类时分配内存，不同的是静态方法以类名引用，而实例方法对对象实例引用。创建实例时，不会再为类的方法分配内存，所有的实例对象共用一个类的方法代码。因此静态方法和实例方法的调用，在性能上的差别微乎其微。

二、静态方法只能由类访问；实例方法只能由对象访问。

优点：
1，静态变量在类载入时，就装入内存
2，使用时不用 New 就意味的不必 创建类中 所有对象，就可以调用 某个方法

缺点：
1，垃圾回收机制 不能 回收 静态变量，静态类变量 会常驻内存

---

c#中静态类的优缺点

缺点：

1、整个类型在程序运行期间只加载一次。 这样是对于那些经常使用的类型来说的，那就不用每次使用前都先加载。效率高些。但是对那些不常用的类型来说。
2、如果是静态类型，那就要一直占用相当的内存；一直到程序停止。或者应用程序域被卸载。所以应该只对那些常用的类型定义成静态类型。

优点：

1、它们仅包含静态成员。
2、它们不能被实例化。
3、它们是密封的。
4、它们不能包含实例构造函数（C# 编程指南）。

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

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

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

C# 类定义

Visual Studio 中的OOP工具

定义类成员

• public——成员可以由任何代码访问。
• private——成员只能由类中的代码访问（如果没有使用任何关键字，就默认使用这个关键字）。
• internal——成员只能由定义它的程序集（项目）内部的代码访问。
• protected——成员只能由类或派生类中的代码访问。

C#网页web开发(ASP.NET)

• C/S（Client/Server）结构：

  即大家熟知的客户机和服务器结构，在特定的应用中无论是Client端还是Server端都需要特定的软件支持。一般就是那种需要下载不同版本的安装包，在PC机安装，比如：QQ，360安全卫士等。

• B/S（Browser/Server）结构：

  即浏览器和服务器结构，在这种结构下，用户工作界面是通过www浏览器来实现，极少部分事物逻辑在前端实现，主要事物逻辑在服务器端实现，比如我们的网站，网络办公等。

预备知识：

ASP.NET并不是一门编程语言，而是一个统一的Web开发模型，她支持可视化的方式创建企业级网站，ASP.NET是.NET Framework的一部分，在ASP.NET中可以利用.NET Framework中的类进行编程，在ASP.NET 中可以用VB.NET、C#、JScript.NET等编程语言来开发web应用程序。

WebApplication: (Web应用程序)是新的网站类型，但是在WebSite（网站)下代码不分命名空间，不利于工程化开发，CS代码修改后不需要重启，代码出错不易察觉，但是可以把WebSite程序转化为WebApplication,在WebSite上点击右键可以有转化为WebApplication的功能，记住，要想调试必须是在Debug的模式下才会有断点生效，并且F12转到定义，然后可以跟进和步过，调试是开发的关键,Session是针对不同的浏览器进程相关，Application是针对所有的应用程序相关，<% 中间包含C#代码在HTML里面 %> <%=中间放动态的表达式%>

静态网页：就是服务器向浏览器发送单纯的Html语言（只包含具有在客户端执行的代码），速度很快，但是维护不方便

动态网页：包含有在Web服务器端执行的代码，然后就是把这一堆都发送给浏览器，又因为浏览器只认识html（还有js脚本等）,所以只能解析html，是在服务器动态组成html

名词解释：
IIS：Internet information server

CGI: common Getway interface,通用网关接口

CGI（Computer Graphics Interface) 计算机图形接口标准

解释一种错误的认识

其实在空间里拉过来的控件是完全一样的，就是在自己写的html的内容，因为服务器端的语言是asp的语言，要经过服务器解析为html,所以这里的使用方式和html是完全一样的，这里面的Botton和你托的控件是完全一样的，而浏览器只认html,和脚本，这里只是要翻译而已，这里明确的就是可以完全按照html的语法进行写，在一般的控件后的属性只要加个<input id = “abc” type =”button” runat = “server”> 这样就是说明为服务器语言，

asp语言的是解释性的语言（脚本），不利于工程化开发,只有运行到该页的时候才报错，使用webApplication和webSite修改的aspx都不需要重启、大规模的网站一般使用webApplication，并且在VS里还有个在网站上点击右键，有使website转换为webApplication的功能

简单的服务器-浏览器交互模式:

1.提交到服务器的表单元素一定要有name属性，如：

<input id="Text1" type="text" name="UserName" />
<input id="Submit1" type="submit" value="提交" />

2.提交页面的制作过程为：在网站下添加新项->添加一般应用程序->.ashx页面的出现->ProcessRequest事件里写代码 ProcessRequest事件是对所有的Http请求做的处理，

服务器和浏览器的交互要有三个阶段，请求->处理->响应

3.首先再建立一个html页面，在你想要提交的表单里添加 name属性啊，在form的action=”aaa.aspx”;就是要提交请求的页面，也可以的任意.aspx页面，在不是使用type = “submit”属性提交的情况下
可以使用 在form里添加 runat = “server” 并且 form 的 id = "form1" οnclick="document.getElementById(‘form1’).submit()" type = “button” 使button的样子也可以提交表单，呵呵

4.在ProcessRequst事件中具体的方法是，先判断是否是由表单提交过来的，简单的方法就是在form里建立一个<input type = “hidden” value =”true” name = “ispostback”> 就是一个隐藏的控件，在浏览器端不可见，呵呵，为的就是看看是否是由本页提交过来的；

5.先获取该字段用 string ispostback = context.Request["ispostback"];
再用if判断就行了，几个常用的方法有：

string 模版全路径 = context.Server.MapPath("moban.html");

string content = System.IO.File.ReadAllText(模版全路径); //因为这里本来就是字符串了，所以就
//不用再加双引号了哈

content.Replace(“@num”,number);//表示将本地模版的num的值变为number，现在还没有写回去，在这里的content是获得本地一个相同模版的全路径下的所有文本内容，则会使下面的替换成为可能，步骤是先将读取的本地模版字符串信息里的@变量替换为需要的字符串，然后再用context.Response.Write(content);将修改后的信息的完整页面写回请求页面

string fullpath = context.Server.MapPath("aaa.htm"); //获得文件全路径

string content = System.IO.File.ReadAllText(fullpath); //读取文件路径下的文件内容

context.Response.Write(content);//向页面写东西，也可以理解为响应

content = content.Replace("@value",number); //用number的值替换@value
注意是在html 中有 < input type = “text” value = “@value”>的前提下

具体代码如下：
在.ashx的页面：

<%@ WebHandler Language="C#" Class="IncValue1" %>
using System;
using System.Web;

public class IncValue1 : IHttpHandler {

  public void ProcessRequest (HttpContext context) {
    context.Response.ContentType = "text/html";

    string ispostback = context.Request["ispostback"];

    string number = context.Request["number"];
    if (ispostback == "true")
    {
      int i = Convert.ToInt32(number);

      i++;
      number = i.ToString();
    }
    else
    {
      number = "0";

    }

    string fullpath = context.Server.MapPath("IncValue1.htm");

    string content = System.IO.File.ReadAllText(fullpath);

    content = content.Replace("@value",number);

    context.Response.Write(content);
  }

  public bool IsReusable {
    get {
      return false;
    }
  }

}

在html中的页面：

<!--要记住的是，在表单里面只有key和value能提交到服务器，这里的Key就是name,这里的value就是Value,就是说在页面上的数据必须设置name和value属性，才能交给服务器，呵呵-->
<form action ="IncValue1.ashx" id = "form1">
<p>
<input type = "hidden" value ="true" name ="ispostback" />
    姓名：<input id="Text1" type="text" name="number" value = "@value" /><input id="Submit1" type="button" value="自增" onclick ="document.getElementById('form1').submit()" /></p>
 
        <!-- 如果是type = "button" ,则不会自动提交表单，需要自己写代码-->
</form>

ashx文件和HttpHandler

什么是HttpHandler

HttpHandler是一个HTTP请求的真正处理中心，也正是在这个HttpHandler容器中，ASP.NET Framework才真正地对客户端请求的服务器页面做出编译和执行，并将处理过后的信息附加在HTTP请求信息流中再次返回到HttpModule中。

IHttpHandler是什么

IHttpHandler定义了如果要实现一个HTTP请求的处理所必需实现的一些系统约定。HttpHandler与HttpModule不同，一旦定义了自己的HttpHandler类，那么它对系统的HttpHandler的关系将是“覆盖”关系。

IHttpHandler如何处理HTTP请求

当一个HTTP请求经同HttpModule容器传递到HttpHandler容器中时，ASP.NET Framework会调用HttpHandler的ProcessRequest成员方法来对这个HTTP请求进行真正的处理。以一个ASPX页面为例，正是在这里一个ASPX页面才被系统处理解析，并将处理完成的结果继续经由HttpModule传递下去，直至到达客户端。

对于ASPX页面，ASP.NET Framework在默认情况下是交给System.Web.UI.PageHandlerFactory这个HttpHandlerFactory来处理的。所谓一个HttpHandlerFactory，所谓一个HttpHandlerFactory，是指当一个HTTP请求到达这个HttpHandler Factory时，HttpHandlerFactory会提供出一个HttpHandler容器，交由这个HttpHandler容器来处理这个HTTP请求。

一个HTTP请求都是最终交给一个HttpHandler容器中的ProcessRequest方法来处理的。

HttpModule：Http模块，可以在页面处理前后、应用程序初始化、出错等时候加入自己的事件处理程序
HttpHandler：Http处理程序，处理页面请求
HttpHandlerFactory：用来创建Http处理程序，创建的同时可以附加自己的事件处理程序

https://www.cnblogs.com/DSC1991/p/8674960.html

ashx：.ashx 文件用于写web handler的。.ashx文件与.aspx文件类似，可以通过它来调用HttpHandler类，它免去了普通.aspx页面的控件解析以及页面处理的过程。其实就是带HTML和C#的混合文件。

.ashx文件适合产生供浏览器处理的、不需要回发处理的数据格式，例如用于生成动态图片、动态文本等内容。

Ajax回调函数

如果要处理 $.ajax() 得到的数据，则需要使用回调函数：beforeSend、error、dataFilter、success、complete。

beforeSend

在发送请求之前调用，并且传入一个 XMLHttpRequest 作为参数。

error

在请求出错时调用。传入 XMLHttpRequest 对象，描述错误类型的字符串以及一个异常对象（如果有的话）

dataFilter

在请求成功之后调用。传入返回的数据以及 “dataType” 参数的值。并且必须返回新的数据（可能是处理过的）传递给 success 回调函数。

success

当请求之后调用。传入返回后的数据，以及包含成功代码的字符串。

complete

当请求完成之后调用这个函数，无论成功或失败。传入 XMLHttpRequest 对象，以及一个包含成功或错误代码的字符串。

C# 图谱