NET 经验的总结

===========================NET==================================
NET框架的组成
--类库
--公共语言运行时

类型的分类
--值：存放实际的值，堆栈中(大多数类型/枚举/结构体)
--引用：存放地址，堆中(类/接口/数组/字符串)

装箱：值-->引用
拆箱：引用-->值(强转)

NET原理
NET语言----------->MSIL------------------------>机器代码
C#              微软中间代码   JIT即时编译
VB.NET              exe,dll
C++

面向对象的三大特性
--继承
--封装
--多态

多态：不同对象相同方法的不同实现

命名空间：
--作用：1.解决命名冲突 2.条理和结构清晰
--定义：namespace 名称{}
--导入：
  --using 命名空间;
  --using 别名=命名空间.命名空间;

属性：1.自定义访问权限 2.验证数据的有效性
属性的公式：
public 类型 属性名
{
  get { return ...; }   // 取值
  set { ... = value; }  // 赋值
}
value关键字获得等号右边的值

索引器：能够用对象来方便访问数组或集合
注意：
--1.名称只能为this
--2.支持重载
公式：
public 类型 this[类型 标识符]
{
  get { return ...; }   // 取值
  set { ... = value; }  // 赋值
}
举例：假定类A中有数组strs，则访问方式如下：
正常：A a = new A(); a.strs[0] = "ABC";
索引器：A a = new A();a[0] = "ABC";

枚举 (enum)：一组已命名的常量 
注意点：
--1.初始值从0开始  (也可以帮它赋值)
--2.后一个在前一个基础上加1
公式：
public enum 枚举名称 : 数字的基础类型  （不能为char类型）
{
  名称=初始值,
  名称=初始值
}
转换：
枚举->String：枚举.ToString()
枚举->数字：(数字)枚举;
数字->枚举：(枚举)数字;
String->枚举：(枚举)Enum.Parse(typeof(枚举),字符串);

方法的重载：不同的数据实现相同的功能
--方法名称相同
--参数不同
  --参数的个数
  --参数的类型

方法的重写(override)：子类从写父类的方法
只能重写abstract、virtual和override声明的方法

new关键字用来隐藏基类的成员

抽象类：
1.不能实例化的类
2.组成
  --非抽象方法
  --抽象方法：只有方法的定义，没有方法的实现
3.实现一种规范、约束
4.子类必须重写(override)抽象方法
  (除非子类也是抽象类)

虚方法：
1.用virtual声明
2.virtual方法必须在基类中实现
3.子类可以重写(override)

构造函数：
1.与类名相同，无返回值
2.无显示的构造函数时，编译器会自动的创建无参的构造函数
3.在实例化时，自动调用
4.支持重载

继承：用现有类创建新类的过程，少写和重用代码
公式：
public class 子类: 父类,接口1，接口2...
{}
构造函数的顺序：父类->子类
base访问基类成员
sealed密封类不允许被继承

集合：管理一组对象
集合：System.Collections;
--ArrayList:以索引维护
--Hashtable:以Key-Value对维护
泛型集合：System.Collections.Generic;
--List<>:以索引维护
--Dictionary<,>:以Key-Value对维护

泛型的优点：
--1.类型安全性(编译时就会检查类型)
--2.性能高(没有装箱和拆箱)
--3.重用性

进程：程序在内存中的实例
线程：程序中单独的执行路径
进行包含一个或多个线程

线程
--导入命名空间：System.Threading;
--停顿：Thread.Sleep(毫秒);

文件的操作：System.IO;
--File:对文件操作
--Directory:对文件夹操作

文本文件的操作
--写：
// 定义文件流
FileStream fs = new FileStream(文件名,FileMode.Create);
// 定义写入器
StreamWriter sw = new StreamWriter(fs,Encondig.Default);
// 写入内容
sw.Write(内容);
// 关闭流
sw.Close();
fs.Close();

--读：
// 定义文件流
FileStream fs = new FileStream(文件名,FileMode.Open);
// 定义读取器
StreamReader sr = new StreamReader(fs,Encondig.Default);
// 读取内容
txtContent.Text = sr.ReadToEnd();
// 关闭流
sr.Close();
fs.Close();

设置MDI窗体
--父：IsMdiContainer = true;
--子：窗体 obj = new 窗体();
      obj.MdiParent = this;
      obj.Show();

异常Exception
--SystemException：系统异常
--ApplicationException：自定义异常

ADO.NET组件(NET程序访问数据的组件)
--DataSet数据集
  --DataSet:数据集(内存中的数据库)
  --DataTable:数据表
    --NewRow():已表结构产生新行
    --Rows:行集合
    --Columns:列集合
  --DataColumn:数据列
    --ColumnName:列名
    --DataType:数据类型
    --MaxLength:最大长度
    --AllowDBNull:是否允许为空
    --DefaultValue:默认值
    --Unique:是否唯一
  --DataRow:数据行
  --DataView:数据视图
    --RowFilter:行筛选
    --Sort:排序

--NET数据提供程序
  --Connection:连接(程序和数据库之间的桥梁)
  --Command:命令(能够执行数据的操作)
    --CommandText:命令文本(SQL语句或存储过程名称)
    --CommandType:命令类型(Text或StoredProcedure)
    --ExecuteNonQuery:执行操作(添加/修改/删除)，返回受影响的行数
    --ExecuteReader:执行查询，返回DataReader
    --ExecuteScalar:执行查询，返回第一行第一列
  --DataReader:读取器(一条条读取，只读只进)
  --DataAdapter:适配器(数据集和数据源之间的桥梁)
    --Fill:填充(把数据源的数据填充到数据集)
    --Update:更新(把数据集中的数据更新到数据源中)

从网格DataGridView获得内容：
--dataGridView1[列索引,行索引].Value
从数据集获得内容
--ds.Tables[索引|表名].Rows[行索引][列索引]

连接字符串
--服务器：server/data source
--登录名：uid/user id
--密码：pwd/password
--数据库：database/initial catalog 初始目录
--Windows集成验证：Integrated Security=SSPI

OleDb嵌入式连接方式
--SQLServer:Provider=sqlOledb;uid=sa;pwd=sa;database=pubs
--Access:Provider=Microsoft.jet.oledb.4.0;data Source=AAA.mdb

方法的输出：
--ref:引用，侧重于值的修改
--out:输出，侧重于值的输出(退出方法时，out参数必须赋值)

类中成员的访问：
--静态成员：类.成员;
--实例成员：类 obj = new 类(); obj.成员;

常量：不能修改的值
公式：const 类型 常量名=初始值;

Xml:可扩展标记语言(文本格式)
用途：
--1.标准的通信格式
--2.小型的DB
组成：
--声明：<?xml version="1.0" encoding="GB2312"?>
--元素：<名称 属性="值">文本</名称>
注意点：
--1.有且只有一个根元素
--2.区分大小写

程序对XML的操作：
--XmlDocument:xml文档
  --Load:加载Xml文件
  --DocumentElement:获得XML文件的根元素
--XmlNode:xml节点
  --Name:名称
  --InnerText:内部文本
  --ChildNodes:子节点集合
  --Attributes:属性集合

泛型接口:
1.自定义对象的比较(默认Sort方法就是对元素进行比较)
  --1)实现IComparable<>接口
  --2)实现CompareTo方法
  具体如下：
  public class 类:IComparable<类型>
  {
      public int CompareTo(类型 other)
      {
          // 实现比较
      }
  }
2.自定义的比较器
  --1)创建类，实现IComparer<>
  --2)实现Compare方法
  --3)调用：Sort(new 比较器());
  具体如下：
  public class 类:IComparer<类型>
  {
      public int Compare(类型 obj1,类型 obj2)
      {
          // 实现比较
      }
  }
  调用：集合.Sort(new 类());

接口：
--1.实现一种规范、约束
--2.接口是一种特殊的抽象类(接口里面全部是抽象方法)
--3.接口是对抽象类的扩展(可以多实现接口)

抽象类和接口选择的原则
--抽象类：is a
--接口：can do

序列化的公式：
// 产生文件流
FileStream fs = new FileStream("文件名",FileMode.Create);
// 产生二进制格式化器
BinaryFormatter bf = new BinaryFormatter();
// 将对象已二进制格式写入文件
bf.Serialize(fs,对象);
// 关闭流
fs.Close();

注意点：序列化的自定义对象，一定要加[Serializable]特性
如：
[Serializable]
public class 类{}

反序列化的公式：
// 产生文件流
FileStream fs = new FileStream("文件名",FileMode.Open);
// 产生二进制格式化器
BinaryFormatter bf = new BinaryFormatter();
// 将文件中的二进制数据重新构建为对象
类 对象 = (类)bf.Deserialize(对象);
// 关闭流
fs.Close();

修饰符：
--public:公共，所有地方都可以访问
--protected:保护，只有自己和派生类可以访问
--private:私有，只有自己可以访问
--internal:内部，只有本程序集可以访问

三层的优势：
1）开发时便于人员分工
2）方便维护和扩展

三层的结构：
表示层--------------------业务逻辑层-----------数据访问层------------- 模型层
与用户交互的界面        数据处理和传递          数据库操作                           类库
WinForm                        类库                           类库                                  类库  
                                       **BLL                        **DAL                               **Model
                                       **Manager                 **Service                         **

                     

============================SQLServer============================
E-R图：实体关系图
--矩形：实体
--椭圆：属性
--菱形：关系

三大范式：
--1NF:有主键，列不可再分
--2NF:满足1NF，没有部分依赖(一个表只描述一件事情)
--3NF:满足2NF，没有传递依赖(非主键字段不能被非主键字段推出)

数据库的三类文件
--主数据文件：mdf(1个)
--次要数据文件：ndf(0-N个)
--日志文件:ldf(1-N个)

创建数据库
if exists(select * from sysdatabases where name='数据库名')
 drop database 数据库名
go

create database 数据库名
on 
(
 name=逻辑名,
 filename=物理名称,
 size=初始化大小,
 maxsize=最大大小,
 filegrowth=文件增长大小/文件增长率
),
(
  ...  -- 次要数据文件
)
log on
(
  ...  -- 日志文件
)

创建表
if exists(select * from sysobjects where name='表名')
 drop table 表名
go

create table 表名
(
 字段1 类型 约束,
 字段2 类型 约束,
 ...
)
go

添加约束
alter table 表名 add
  constraint pk_列名 primary key(主键列),  -- 主键
  constraint uq_列名 unique(列),  -- 唯一
  constraint df_列名 default(默认值) for 列,  -- 默认
  constraint ck_列名 check(检查条件),   -- 检查
  constraint fk_列名 foreign key(外键) references 主表(主键) -- 外键
go

变量
--局部变量
  --定义：declare @变量名 类型
  --赋值：
    --set @变量名 = 值，直接赋值
    --select @变量名 = 值,从查询结果中赋值
--全局变量
  --@@error:获得最后一句SQL的错误号
    >0:错误
    =0:正确
  --@@rowcount:获得最后一句SQL受影响的行数
  --@@identity:获得最新的自动编号

显示
--Print:文本显示
--Select:网格显示

别名
--Select 别名=值
--Select 值 as 别名

类型转换
--Cast(值 as 类型)
--Convert(类型,值)

查询公式:
select 字段
from 表
where 条件
group by 分组
having 分组后的条件
order by 排序

select 字段 into 新表
from 旧表

insert into 旧表1
select 字段 from 旧表2

事务的公式：
begin transation -- 开始事务
declare @errSum int
set @errSum = 0
操作1
set @errSum = @errSum + @@error
操作2
set @errSum = @errSum + @@error
...
if (@errSum <> 0)
 rollback transaction -- 回滚事务
else
 commit transaction -- 提交事务
go

索引的分类：
--聚集索引：数据的顺序和键的顺序一致（1个）
--非聚集索引：和数据的顺序无关（249个）

创建索引
if exists(select * from sysindexes where name='索引名')
 drop index 表名.索引名
go

create nonclustered|clustered index 索引名
on 表(字段)
with fillfactor = 填充因子的数字
go

select * from 表(index=索引名)

创建视图
if exists(select * from sysobjects where name='视图名')
 drop view 视图名
go

create view 视图名
as
  查询语句
go

创建存储过程
if exists(select * from sysobjects where name='存储过程名')
 drop procedure 存储过程名
go

create procedure 存储过程名
  @参数 类型 [=默认值] [output],
  @参数 类型 [=默认值] [output]
  ..
as
  SQL语句
go

调用：
--默认:exec 存储过程名
--带返回参数
  declare @变量 类型
  exec 存储过程名 @变量 output
--带返回值
  declare @变量 类型
  exec @变量=存储过程名 参数1,参数2