C#入门经典（第6版）阅读笔记（第一篇）（1-10）

最新推荐文章于 2019-09-23 10:52:17 发布

「已注销」

最新推荐文章于 2019-09-23 10:52:17 发布

阅读量180

点赞数

本文链接：https://blog.csdn.net/zhonghua_csdn/article/details/89878253

版权

<h5>第一章 C#简介</h5>
1.1 .NET Framework的含义
1.1.1 .NET Framework是Microsoft为开发应用程序而创建的一个具有革命意义的平台。
1.1.2中间语言：在编译使用.net framework 库的代码时，不是立即创建专用操作系统的本机代码，而是把代码编译为通用中间语言（Common Intermediate Language，CIL）代码，这些代码并非专门用于任何一种操作系统，也非专门用于C#。
1.1.3编译器：Just-In-Time(JIT)编译器的任务，他把CIL编译为专用于OS和目标机器结构的本级代码。
1.1.4程序集：在编译应用程序时，所创建的CIL代码存储在一个程序集中。程序集包括可执行的应用程序文件（.exe）和其他应用程序使用的库（.dll）。
1.1.5托管代码：在将代码编译成为CIL，再用JIT编译器将它编译为本级代码后，CLR的任务尚未完成，还需要管理正在执行的用.net framework编写的代码。托管代码最重要的一个功能是垃圾回收（garbage collection）。
1.1.6总结图：

执行过程

<h5>第二章编写C#程序</h5>
2.1.1 第一个小程序---控制台程序HelloWorld

HelloWorld

2.1.2 第二个小程序---桌面应用---WPF application

桌面应用---点击按钮弹窗

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace Test02_WPF
{
    /// <summary>
    /// MainWindow.xaml 的交互逻辑
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, RoutedEventArgs e)
        {
            MessageBox.Show("你竟然敢点我！");
        }
    }
}

<h5>第三章变量和表达式（由于之前学过c语言和java，部分相通的章节不会记录过多）</h5>
3.1.1注释

注释

3.3.2注意：组成string打的字符串数量没有上限，以为他可以使用可变大小的内存。
3.3.3注意：根据约定，名称空间通常采用PascalCase命名方式。

<h5>第五章变量的更多内容</h5>

5.1.1使用Convert命令进行显示转换。
5.1.2 变量类型：结构---》就是由几个数据组成的数据结构，这些数据可能具有不同的类型----》个人感觉像是c语言中的结构体。
小例子：

枚举与结构体的使用

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 枚举与结构的应用
{
    //定义枚举类型
    enum orientation : byte
    { 
        north = 1,
        soutth = 2,
        east = 3,
        west = 4
    }
    //定义结构体类型
    struct route
    {
        public orientation direction;
        public double distance;
    }
    class Program
    {
        static void Main(string[] args)
        {
            route myRoute;
            int myDirection = -1;
            double myDistance;
            Console.WriteLine("1)North \n 2)South \n 3) East \n 4)West \n");
            do
            {
                Console.WriteLine("Select a direction:");
                myDirection = Convert.ToInt32(Console.ReadLine());
            }
            while((myDirection < 1) || (myDirection > 4));
            Console.WriteLine("Input a distance:");
            myDistance = Convert.ToInt32(Console.ReadLine());
            myRoute.direction = (orientation)myDirection;
            myRoute.distance = myDistance;
            Console.WriteLine("myRoute specifiex a direction of {0} and a  distance of {1}",myRoute.direction,myRoute.distance);
            Console.ReadLine();
        }
    }
}

5.1.3定义数组时注意

定义数组注意

5.2.1锯齿数组---》数组的数组
5.3.1string类型变量可以看成是char变量的只读数组。为了获得一个可写的char数组，可以使用下面代码

string myString = "a string";
char[] myChar = myString.ToCharArray();

<h5>第六章函数</h5>
6.1.1函数的定义与使用
一般采用PascaCase形式编写函数名。
函数Main（）是控制台应用程序的入口点函数。
void这个关键字表明函数没有返回值。
样例：
主函数：

static void Main(string[] args)
        {
            Console.WriteLine("请输入一个整数");
            int x = Convert.ToInt32(Console.ReadLine());
            Console.WriteLine(GetVal(x));
            Console.ReadLine();
        }

被调函数：

 static double GetVal(int n) 
        {
            if (n > 5)
            {
                return 5;
            }
            else
            {
                return 0;
            }
        }

结果显示：

函数的定义与使用

6.1.2查看函数的参数值是否会改变
被调用函数：

被调用的函数

主函数：

主函数

结果：

结果

可见，从主函数，将变量通过调用函数加工后，其本身并不会做出改变。若想让其发生本质的改变，需要使用ref。如下所示：

被调用的函数

主函数调用方式

执行结果

代码：

static void ChangeParameterMethod1(int value)
        {
            value = value * 2;
            Console.WriteLine("由定义函数输出：" + value);
        }
        static void ChangeParameterMethod2( ref int value)
        {
            value = value * 2;
            Console.WriteLine("由定义函数输出：" + value);
        }
        static void Main(string[] args)
        {
            int myValue1 = 3;
            ChangeParameterMethod1(myValue1);
            Console.WriteLine("由主函数输出，查看myValue是否改变：" + myValue1);

            int myValue2 = 3;
            ChangeParameterMethod2(ref myValue2);
            Console.WriteLine("由主函数输出，查看myValue是否改变：" + myValue2);
            Console.ReadLine();
        }

6.1.3输出参数（用法与ref相同）
把未赋值的变量用作ref参数是违法的，但可以把未赋值的变量用作out参数。
另外，在函数使用out参数时，必须把它看成是尚未赋值。
6.2.1结构函数
即把函数放到结构中，可以集中处理常见任务，从而简化过程。
6.3.1重载：函数名相同，参数不同。
6.4.1委托：
委托（delegate）是一种存储函数引用的类型。主要用于事件和事件处理。委托的声明非常类似函数，但不带函数体，且要使用delegate关键字，定义了委托后就可以声明该委托类型的变量。下面我们来看一段代码，使用委托访问两个函数中的一个。个人觉得，委托就像一个已经定义好的选择器，然后根据选择去挑选所需要的函数，然后再通过委托传参。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 委托用法的练习
{
    class Program
    {
        delegate double ProcessDelegate(double param1,double param2);//委托声明(类似函数)
        static double Multiply(double param1, double param2)
        {
            return param1 * param2;
        }
        static double Divide(double param1, double param2)
        {
            return param1 / param2;
        }
        static void Main(string[] args)
        {
            ProcessDelegate process;
            Console.WriteLine("Enter 2 numbers separated with a comma:");
            string input = Console.ReadLine();
            int commaPos = input.IndexOf(',');
            double param1 = Convert.ToDouble(input.Substring(0,commaPos));
            double param2 = Convert.ToDouble(input.Substring(commaPos + 1,input.Length -1-commaPos));
            Console.WriteLine("Enter M to Multiply or D to Divide:");
            input = Console.ReadLine();
            //如果选M则调用函数Multiply否则使用函数Divide
            if (input == "M")
            {
                process = new ProcessDelegate(Multiply);
            }
            else
            {
                process = new ProcessDelegate(Divide);
            }
            Console.WriteLine("Result:{0}",process(param1,param2));
            Console.ReadLine();
        }
    }
}

执行结果：

委托的使用

<h5>第八章面向对象编程简介</h5>
8.1.1类与对象的区别
若拿汽车比喻，类是指汽车的模板，或者用于构建汽车的规划，汽车本身是这这些规划的实例，所以可以看做对象。
8.1.2对象的生命周期
构造阶段：第一次实例化一个对象时，需要初始化该对象。这个初始化过程称为构造阶段，由构造函数完成。
正在使用阶段：正常状态
析构阶段：在删除一个对象时，常常需要执行一些清理工作，例如，释放内存，这由析构函数完成。
8.2.1封装，继承，多态之类的就不多说了，扩展两个名词：继承--》派生；父类---》基类。

<h5>第九章定义类</h5>
9.1定义
9.1.1抽象（abstract）类：不能实例化，只能继承。密封（sealed）类：不能继承。
9.1.2编译器不允许派生类的可访问性高于基类。也就是说，内部类可以继承于一个公共基类，但公共基类不能继承于一个内部类。
9.1.3如果没有基类，则被定义的类就只继承于基类System.Object（它在C#中的别名是object）。
9.1.4必须使用逗号来分隔基类名和接口名。此处与java不同。java使用的是两个关键字，extends 和implements，C#这两个都采用的方式是“：”。
9.1.5 类的修饰符

类的修饰符

类定义中可以使用的访问修饰符组合
none or internal 类只能在当前工程中访问
public 类可以在任何地方访问
abstract or internal abstract 类只能在当前工程中访问，不能实例化，只能继承
public abstract 类可以在任何地方访问，不能实例化，只能继承
sealed or internal sealed 类只能在当前工程中访问，不能派生，只能实例化
public sealed 类可以在任何地方访问，不能派生，只能实例化
9.2 System.object
9.2.1 在利用多态性时，GetType()是一个有用的方法，允许根据对象的类型来执行不同的操作，而不是像通常那样，对所有对象都执行相同的操作。
9.2.2抽象类和接口的相同与不同点
相同点：

<li>都包含可以由派生类继承的成员</li>
<li>都不能直接实例化</li>

不同点：

<li>派生类只能继承一个基类，相反，类可以使用任意多个接口</li>
<li>抽象类可以拥有抽象成员和非抽象成员</li>

<li>接口成员必须都在使用接口的类上实现-----他们没有代码体</li>
<li>接口成员是公有的，抽象类的成员是私有的</li>
<li>接口不能包含字段、构造函数、析构函数、静态成员或常量</li>

9.3 结构类型
9.3.1 结构和类非常相似，但结构是值类型，而类是引用类型。代码解释：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 区分类和结构
{
    //定义一个类
    class MyClass
    {
        public int val; 
    }
    //定义一个结构，注意命名规则
    struct myStruct
    {
        public int val;
    }
    class Program
    {
        static void Main(string[] args)
        {
            //对定义的类实例化
            MyClass objectA = new MyClass();
            //此处实际上是复制了这个地址
            MyClass objectB = objectA;
            objectA.val = 20;
            objectB.val = 30;
            //对结构进行实例化
            myStruct structA = new myStruct();
            //此处赋值的是结构体的所有信息
            myStruct structB = structA;
            structA.val = 20;
            structB.val = 30;
            //输出上面的四个值
            Console.WriteLine("objectA.val = {0}",objectA.val);
            Console.WriteLine("objectB.val = {0}", objectB.val);
            Console.WriteLine("structA.val = {0}", structA.val);
            Console.WriteLine("structB.val = {0}", objectB.val);


            Console.ReadKey();
        }
    }
}

执行结果：

类与结构

9.4 浅度复制和深度复制
浅度复制：简单的按照成员复制对象，通过拍摄呢过于System.Object的MemberwiseClone()方法；
深度复制：如果要创建成员的新实例（复制值，而不复制引用），可以实现一个ICloneable接口，以标准方式进行深度复制。如果使用这个接口，就必须实现它包含的Clone()方法。这种方式跟java中的创建多线程，实现Runnable接口创建多线程的方式挺像的。

第十章定义类成员

10.1 成员定义

10.1.1在类定义中，也提供了该类中所有成员的定义包括字段、方法和属性。所有成员都有自己访问级别，用下面的关键字之一来定义：

public——成员可以由任何代码访问
private——成员只能由类中的代码访问（如果没有使用任何关键字，就默认使用这个关键字）
internal——成员只能由定义它的程序集（项目）内部的代码访问
protected——成员只能由类或派生类中的代码访问
后两个关键字可以结合起来使用，protected internal，它们只能由项目中派生类的代码访问。
10.1.2公共字段以PascalCasing形式命名，公共方法也采用PascalCasing形式命名，私有字段通常使用camelCasing来命名。
10.1.3 如果使用了static关键字，这个方法就只能通过类来访问，不能通过对象实例来访问。也可以在方法定义中使用下述关键字：
virtual——方法可以重写
abstract——方法必须在非抽象的派生类中重写（只用于抽象类中）。
override——方法重写了一个基类方法（如果方法被重写，就必须使用该关键字）。&_&
exten——方法定义放在其他地方
下面是一个方法重写的实例：

public class MyBaseClass
    {
        //virtual——方法可以重写
        public virtual void DoSomething()
        { 
            //Base implementation
        }
    }
    //Extends a class(MyBaseClass) and overwrite it's method
    //override——方法重写了一个基类方法（如果方法被重写，就必须使用该关键字）
    public class MyDerivedClass : MyBaseClass
    { 
        //To overwrite the method
        public override void DoSomething()
        { 
            //Drived class implementation,overrides base inplementation.
        }
    }

这个地方，如果第一个类中的方法没有加Virtual，这个方法就不可以被重写：

方法的重写

如果使用的override,也可以使用sealed来指定在派生类中不能对这个方法做进一步的修改。
测试代码：

 public class MyDerivedClass : MyBaseClass
    { 
        //To overwrite the method
        public override sealed void DoSomething()
        { 
            //Drived class implementation,overrides base inplementation.
        }
    }

    public class MyTestClass : MyDerivedClass
    {
        public override void DoSomething()
        { 
            //this is test to see whether the method is rewritten
        }
    }

报错显示：

报错显示

当然，此处去除sealed，程序时可以正常运行的。
10.1.4 定义属性
get块必须有一个属性类型的返回值，简单属性一般与私有字段相关联，以控制对这个字段的访问，此时get块可以直接返回该字段的值。
代码：

public class MyTestClass
    { 
        //Field used by prtperty
        private int myInt;
        //Property
        public int MyIntProp
        {
            get
            {
                return myInt;
            }
            set
            {
                myInt = value;
            }
        }
    }

value 等于类型与属性相同的一个值，所以如果属性和字段使用相同的类型，就不必考虑数据类型转换了。
10.1.5 this 与 base
base关键字指定.NET实例化过程使用基类中具有指定参数的构造函数。
this这个关键字指定调用指定的构造函数前，.net实例化过程对当前类使用非默认的构造函数。
如果没有给构造函数指定构造函数初始化器，编译器就会自动添加base()。
this关键字与base一样，this也可以用在类成员内部，且该关键字也引用对象实例。只是this应用的是当前的对象实例（即不能在静态成员中使用this关键字，因为静态成员不是对象实例的一部分）。

微信公众号：

公众号.png

「已注销」

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
C#入门经典（第6版）阅读笔记（第一篇）（1-10）

目录<h5>第一章 C#简介</h5><h5>第二章编写C#程序</h5><h5>第三章变量和表达式（注释方式）</h5><h5>第五章变量的更多内容</h5><h5>第六章函数 *</h5><h5>第八章 ...
复制链接

扫一扫