变量：顾名思义是一种会变化量，常量：声明赋值之后就不会再次改变的量

变量

变量可以表示一个数值 、布尔值、字符串值或者一个类的对象。变量的值可以发生变。

1
2
3
4
5
6
7
8
9
10
11

/*
 * 变量代码演示
*/
int num1 = 2;
Console.WriteLine(num1);//此时输出2
num1 = 12;
Console.WriteLine(num1);//此时输出12
string author = "Yahue";
Console.WriteLine(author);//此时输出Yahue
author = "Yahui.Wang";
Console.WriteLine(author);//此时输出Yahui.Wang

常量

既是在使用过程中不会发生变化的常量，通常在前面加上一个 关键字 const， 需要注意的是：

1.常量总是静态的，所以不需要在常量前面加上静态标示符 static

2.声明时就要赋值 而且赋值之后就不可以修改了

3.初始化不能从变量提取，只可以在变量前面加上readonly 一旦加上readonly之后变量就不可修改视为常量

1
2
3
4
5
6
7

 /**
 * 常量代码演示
 * */
const int num2 = 2;
Console.WriteLine(num2);//此时输出2
//num2 = 12;//无法编译通过 错误：赋值号左边必须是变量、属性或索引器
Console.WriteLine(num2);//此时输出2

c#的数据类型分为值类型和引用类型，他们的区别在于存储和取值的方式不一样。

值类型

直接储存值，直接储存在堆栈中 下面看段代码来说明int类型是值类型的

1
2
3
4
5

/*
 * 值类型
 * */
int i = 10;//开辟一个地方 存储i为10
int j = i;//在开辟一个地方存储j为10

引用类型

储存的是值的引用，储存在托管堆上 下面看段代码来更直观的看下引用类型   先定义一个对象 Person 对象是引用类型

1
2
3
4
5
6
7
8
9
10

/// <summary>
/// 抽象出来对象 人
/// </summary>
public class Person
{
    /// <summary>
    /// 这个人的年龄 int
    /// </summary>
    public int age { get; set; }
}

在Main方法里调用

1
2
3
4
5
6
7
8
9
10
11

/*
 * 引用类型
 * **/
Person yahui = new Person();
yahui.age = 20;
//下面不是不是真正的创建对象wang
//而是 yahui 和wang 使用同一个引用
// yahui的值变了 相应的 wang的值也变了
Person wang = yahui;
yahui.age = 30;
Console.WriteLine(wang.age);//输出的是30

本文代码地址：https://github.com/yahue/JustDoIt-CSharp/tree/master/0002_Source/0002_Source

国际惯例，我们以一个Hello World程序来运行第一个C#程序

创建HelloWorld项目

打开VS(VisualStudio2013 以下简称为VS)新建一个控制台项目 命名为HelloWorld

可以看到vs自动创建了Program.cs 代码文件 代码文本如下所示

1
2
3
4
5
6
7
8
9
10
11

using System;
namespace HelloWorld
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World");
        }
    }
}

VS运行项目

vs窗口使用按F5快捷键或者点击工具栏的启动按钮 弹出一个控制台窗口打印出刚刚我们输入的 Hello World

纳尼。。刚刚发生了什么！？

或许您还没缓过神来，纳尼。。刚刚发生了什么！？

这样一个后缀是cs的文本文件怎么就可以运行了呢，还在控制台里打印出了我们需要显示的东西 下面我们手动来编译一下 Program.cs 文件

1. 我们在 开始-程序-Visual Studio 2013-Visual Studio Tools

2.双击 VS2013 开发人员命令提示 快捷方式 进入命令行模式

3.进入我们 Program.cs 所在的文件夹 image 运行命令 csc Program.cs

4.发现在目录下生成了 Program.exe 可执行程序

如果现在您双击此文件，由于运行的太快了，你的眼睛只会捕捉到一个黑窗口一闪而过 我们还是使用命令执行它吧
新编译出的可执行程序执行也打印出了Hello World

刚刚我们自己编译的方式编译出了一个简单的控制台程序。和按下F5快捷键（或者鼠标点击下菜单栏的运行按钮）相比，我们输入了大量的指令。知道了vs的编译功能在做什么。IDE帮我们节省下来了大量的时间，接下来的时间里我们直接使用VS开发和学习C#就可以了。因为当我们知道原理之后像这样重复而又没意义的工作应该交给机器（程序）来完成，我们的时间要用到去做创新而又很酷的事情。

分析 Program.cs

先简单说下注释：

注释不会执行 在代码中起到了对代码说明作用
单行注释 在// 后面写入您的注释 换行无效
多行注释 /开头/结尾 注释在中间 中间可以多行也可以一行 注：多行注释 里面不能有多行注释
下面就用注释的方式来说明Program.cs中的代码。也许会有一些您现在还不理解的名词，不用担心，通过学习的慢慢深入之后就会豁然开朗了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

//这里使用using应用命名空间
//作用相当于c语言的include
using System;
//这里声明我们自己定义的命名空间
namespace HelloWorld
{
    //我们声明一个类 名字定义为Program
    class Program
    {
        /*
         * 这里是Main方法可以看成是程序的开始运行的地方，也是程序的入口点
        通过调用main来运行程序
         * */
        static void Main(string[] args)
        {
            //调用Console的WriteLine方法 参数为Hello World
            Console.WriteLine("Hello World");
        }
    }
}

本文代码地址

CSharp 简写为**c#**，是一门非常年轻而又有活力的语言。

CSharp的诞生

在2000年6月微软发布了c#这门新的语言。作为微软公司.NET 平台的主角，c#吸收了在他之前诞生的语言(c/c++、Visual Basic、Delphi、Java)的优点。也就是说在.NET平台下 c#可以轻易的使用面向对象的设计和实现出安全高效的程序。

发现到现在

经过十几年的发展，.NET 平台发展到了 4.5版本。提供了各种新的语言特征（3.0：lambda，linq等 4.0 ：动态语言、可选参数和命名参数等）和开发框架（asp.net mvc、wcf、wpf、WWF），在其他语言中非常流行的开发框架(spring.framework、nhibernate、ibatis等)都得到了完美移植。
跨平台方面，借助mono.NET，可以开发在android、ios手机上运行的应用和手游，可以开发并部署在linux服务器上运行的网站以及其他后台应用程序。
曾经的微软帝国现在逐渐以一种开放的态度向的开发者示以好意，在github上，创建了asp.net、msopentech、donet、Microsoft 等开源地址，值得一提的是在2015年2月.NET Core的执行引擎 coreclr 也开源了。这标志了微软在开源和跨平台又向前迈出了一步。

CSharp如何运行的

c#的源代码已cs为后缀的文本文件，从文本文件的源代码到可以执行的c#经历了两个非常重要的编译阶段。

1. 把源代码编译为Microsoft中间语言（IL）
   2.公共语言动态库（CLR）把IL编译为平台专用的代码
   由此可以看出 Microsoft(中间语言)IL发挥了非常大的作用。IL是一种低级语言，总是及时编译的，也称为JIT编译（JIT编译器只编译那一部份调用的代码，并且编译一次之后把本地可执行程序储存起来，在下次运行的时候直接运行本地程序 不用重新编译。）
   不只是c#可以变成中间语言，vb、c++也可以编译成中间语言，也就是说c#可以轻松和这些可以编译成中间语言的高级语言互调用。
   并且由编译过程中被编译成了中间语言可以看出c#的运行和平台无关。实现了中间语言运行环境即可让其运行。mono 项目就是一个很好的例子。 基于他的还有 xamarin、unity3d等
   所以无论将c#作为入门语言还是作为程序员长期发展的语言来学习都是一个很好的选择。

扩展jquery的时候。最核心的方法是以下两种：

• $.extend(object) 可以理解为jquery添加一个静态方法

• $.fn.extend(object) 可以理解为jquery实例添加一个方法

$.extend(object)

1
2
3
4
5
6
7
8
9

     例子：

/* $.extend 定义与调用

* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

$.extend({ fun1: function () { alert("执行方法一"); } });//定义

$.fun1();//调用

$.fn.extentd(object)

1
2
3
4
5
6
7
8
9
10
11
12
13

/*  $.fn.extend 定义与调用

* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

$.fn.extend({ fun2: function () { alert("执行方法2"); } });

$(this).fun2();

//等同于

$.fn.fun3 = function () { alert("执行方法三"); }

$(this).fun3();

定义jquery插件的基本结构

1． 定义作用域：

为插件定义一个私有作用域。外界代码不能直接访问插件内部。插件内部代码不受外界干扰，也不会污染到全局变量。

1
2
3

//step01 定义JQuery的作用域
(function ($) {
})(jQuery);

2. 为插件添加扩展方法：

1
2
3
4
5
6
7

//step01 定义JQuery的作用域
(function ($) {
    //step02 插件的扩展方法名称
    $.fn.easySlider = function (options) {

    }
})(jQuery);

3. 设置默认值：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

//step01 定义JQuery的作用域
(function ($) {
    //step03-a 插件的默认值属性
    var defaults = {
        prevId: 'prevBtn',
        prevText: 'Previous',
        nextId: 'nextBtn',
        nextText: 'Next'
        //……
    };
    //step02 插件的扩展方法名称
    $.fn.easySlider = function (options) {
        //step03-b 合并用户自定义属性，默认属性
        var options = $.extend(defaults, options);
    }
})(jQuery);

其中：var options = $.extend(defaults, options)的含义了。表示 options 去覆盖了defaults的值，并把值赋给了options。
在插件环境中，就表示用户设置的值，覆盖了插件的默认值；如果用户没有设置默认值的属性，还是保留插件的默认值。

4. 支持jquery选择器：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

//step01 定义JQuery的作用域
(function ($) {
    //step03-a 插件的默认值属性
    var defaults = {
        prevId: 'prevBtn',
        prevText: 'Previous',
        nextId: 'nextBtn',
        nextText: 'Next'
        //……
    };
    //step02 插件的扩展方法名称
    $.fn.easySlider = function (options) {
        //step03-b 合并用户自定义属性，默认属性
        var options = $.extend(defaults, options);
        //step4 支持JQuery选择器
        this.each(function () {

        });
    }
})(jQuery);

5 ．支持JQuery的链接调用：

为了能达到链接调用的效果必须要把循环的每个元素return

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

//step01 定义JQuery的作用域
(function ($) {
    //step03-a 插件的默认值属性
    var defaults = {
        prevId: 'prevBtn',
        prevText: 'Previous',
        nextId: 'nextBtn',
        nextText: 'Next'
        //……
    };
    //step02 插件的扩展方法名称
    $.fn.easySlider = function (options) {
        //step03-b 合并用户自定义属性，默认属性
        var options = $.extend(defaults, options);
        //step4 支持JQuery选择器
        //step5 支持链式调用
        return this.each(function () {

        });
    }
})(jQuery);

6. 插件里的方法：

在插件里定义的方法，外界不能直接调用，我在插件里定义的方法也没有污染外界环境。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

//step01 定义JQuery的作用域
(function ($) {
    //step03-a 插件的默认值属性
    var defaults = {
        prevId: 'prevBtn',
        prevText: 'Previous',
        nextId: 'nextBtn',
        nextText: 'Next'
        //……
    };
    //step06-a 在插件里定义方法
    var showLink = function (obj) {
        $(obj).append(function () { return "(" + $(obj).attr("href") + ")" });
    }
    //step02 插件的扩展方法名称
    $.fn.easySlider = function (options) {
        //step03-b 合并用户自定义属性，默认属性
        var options = $.extend(defaults, options);
        //step4 支持JQuery选择器
        //step5 支持链式调用
        return this.each(function () {
            //step06-b 在插件里定义方法
            showLink(this);
        });
    }
})(jQuery);

如 我定义了一个事件信息的模型
[Serializable]
public class EventM
{
public string eventid { get; set; }
public string ownertype { get; set; }
public string owner { get; set; }
public string time { get; set; }
public string desp { get; set; }
public string handled { get; set; }
public string handleduser { get; set; }
public string handedtime { get; set; }
} 　　

顺便有实例化了一个事件对象
EventM em = new EventM();
em.eventid = “1312”;
em.time = DateTime.Now.ToString();
em.owner = “某某人”;
em.ownertype = “太帅了”;
em.desp = “罚款100元”; 　　

无聊 又感觉一个太少了 于是乎
List emList1 = new List();
for (int i = 0; i < 10; i++)
{
EventM em = new EventM();
em.eventid = “1312”;
em.time = DateTime.Now.ToString();
em.owner = “某某人”;
em.ownertype = “太帅了”;
em.desp = “罚款100元”;
emList1.Add(em);
} 　　

下面进行序列化

XmlSerializer serializer = new XmlSerializer(emList1.GetType());
StringWriter writer = new StringWriter();
serializer.Serialize(writer, emList1);
writer.Close();
　　

首先顶一个一个序列化对象serializer 然后是一个写入对象writer
开始对emList1序列化serializer.Serialize(writer, emList1); 并写入到writer里 最后要记得 writer.Close();的好习惯

结果

如果吧上段代码中的StringWriter 换成XmlWriter就可以得到一个xml文件 里面的代码为



1312
太帅了
某某人
2012/8/27 9:18:33
罚款100元


1312
太帅了
某某人
2012/8/27 9:18:33
罚款100元


1312
太帅了
某某人
2012/8/27 9:18:33
罚款100元


1312
太帅了
某某人
2012/8/27 9:18:33
罚款100元


1312
太帅了
某某人
2012/8/27 9:18:33
罚款100元


1312
太帅了
某某人
2012/8/27 9:18:33
罚款100元


1312
太帅了
某某人
2012/8/27 9:18:33
罚款100元


1312
太帅了
某某人
2012/8/27 9:18:33
罚款100元


1312
太帅了
某某人
2012/8/27 9:18:33
罚款100元


1312
太帅了
某某人
2012/8/27 9:18:33
罚款100元

　　

下面是反序列化 我已经生成了一个xml文件xmltest.xml

反序列化代码如下

XmlSerializer serialize = new XmlSerializer(typeof(List<EventM>));
            FileStream stream = new FileStream("xmltest.xml", FileMode.Open);
            List<EventM> emList2 = new List<EventM>();
            emList2 = (List<EventM>)serialize.Deserialize(stream);
            stream.Close();

即可得到反序行列话之后的内容

由于我使用的要求不多 随意用的比较简单基础
还有一篇详细些的博客：
C#对象和XMl文件之间的转换

注：XmlSerializer 需要引用命名空间
using System.Xml.Serialization