C#高级编程阅读笔记-1

好久不更新博客了，现在终于又稳定下来了。发现自己C#的基础好薄弱，于是买了一本C#高级编程，学习一下。以下是我的学习笔记。

通过学习C#高级编程真的明白了很多，当然也有一些不明白的，等弄明白以后继续更新。

对于值类型，变量直接存储器数据；对于引用类型，变量仅存储地址，对应的数据可以在改地址找到。
让应用程序代码负责释放内存是低级高性能使用的技术。
维护引用技术是COM对象采用的一种技术，其方法是每个COM组件都保留一个计数，记录客户端目前对于它的引用，当这个计数下降到0时，组件就会删除自己，并释放相关的内存和资源，但是需要客户端通知组件完成了引用。
垃圾回收器，搜有动态请求的内存都分配到堆上，每隔一段时间，当.NET检测到给定进程的托管堆已满，需要清理时，就调用垃圾回收器。
代码访问安全性建立在代码实际执行的任务和代码的可信程度上。
应用程序域用于减少运行应用程序的系统开销。
孤立代码的唯一方式是通过进程来实现的。
任何进程都只能通过指定虚拟内存中的一个地址来访问内存，即进程不能直接访问物理内存，因此一个进程不可能访问分配给另一个进程的内存。
使用基于DLL的组件，让所有组件在同一个地址内存中运行-其风险是执行出错的组件会影响其他组件。
可执行代码和库代码使用相同的程序集。唯一的区别是可执行代码的程序集包含一个主程序入口点，而库程序集不包含。
修饰符（modifiers）用于指定用户所定义的方法的某些特性。
pulic 任何代码可以访问该项；
protected：只有派生的类型能够访问；
internal：只能在包含他的程序集中访问；
private：只能在他所属的类型中访问；
protected internal：只能在包含他的程序集和派生的类型中访问；

类和结构中的字段，如果没有显示初始化，创建这些变量时，其默认值就是0.
类型级别声明的变量称作字段，方法中声明的变量称作局部变量。
值类型存储在堆栈上，引用类型存储在托管堆上。二者会在内存的两个地方存储。（ int i ,j;i = 1;j = i; j = 6;结果i=1;j=6,互不影响）。
两个引用类型引用同一个对象，二者的修改会相互影响。（ User usera, userb;usera=new User();usera.Age = 2;userb = usera; userb.Age = 3;结果都是3）。
C#有15个预定义类型，其中13个是值类型，2个引用类型。值类型包括（sbyte,short,int,long,byte,ushort,uint,ulong,float,double,decimal,bool,char，枚举，结构(struct)属于值类型），引用类型（string,object,类（class）、接口（interface）、委托（delegate）和数组（array）属于引用类型）。
字符串是不可改变的，修改一个字符串，就会创建一个新的对象，而另一个字符串不会改变。（运算符重载的结果）
String 中使用双斜杠表示和使用@符(  string a = "sdfsdf\nsdffsdf";== a = @"sdfsdf
                  dfsdf";).
控制程序流语句：1、条件语句（if/switch。switch中goto跳转到另外一个case，或者将case罗列出来就可以公用一个处理方法。case1：case2: 方法）2、循环（for，foreach,while,do while）3、跳转语句(goto,return,break,continue.break：跳出循环,continue：执行下一次迭代。)
using语句(1、引用名称空间；2、给类和名称空间加别名+"::"；3、表示一个进程，处理完释放内存 using(){}).
main方法必须是类或结构的静态方法，其返回类型必须是int或void。
类与结构的区别在于他们在内存中的存储方式、访问方式。类存储在堆上的引用类型，结构是存储在栈上的值类型。结构不支持实现继承，但支持接口继承。
类的数据成员：字段、常量、事件。函数成员：方法、属性、构造函数等。
ref参数：传递给方法的参数面前带有ref关键字，则该方法对变量所做的任何改变都会印象影响原始对象的值。
out参数：输入参数前面加上out前缀，传递给该方法的变量可以不用初始化,该变量通过引用传递，所以从被调用的方法中传回时，方法对于变量进行的任何改变都会保留下来。
readonly:可以在构造函数中给只读字段赋值，不能在其他地方赋值。如果把只读字段设置为静态，需要显示的声明。
弱引用：使用WeakReference类创建。针对于对象大但是不经常访问。垃圾回收器运行时，会回收对于弱引用创建的对象，并释放内存。访问前需要确认存在，若不存在调用垃圾回收器。
partial:允许把类，结构，接口和方法放在不同的文件夹中。
动态类型：注意对于对象的属性的使用。 如果传递给包含动态类型的方法中，使用不属于该传递的对象的属性，会报错。
虚方法：把一个基类的函数声明为virtual,就可以在任何派生类中重写该方法。
隐藏方法：C#中要隐藏一个方法，应该使用new关键字声明。
抽象类和抽象函数：抽象类不能实例化，而抽象函数不能直接实现，必须在非抽象类的派生类中重写。
密封类和密封方法：C#允许把类和方法声明为Sealed。对于类，表示不能继承该类，对于方法，表示不能重写该方法。
构造函数：构造函数的调用顺序是先调用System.Object,在按照层次结构由上向下进行，直到达到编译器要实例化的类为止。每个构造函数都初始化自己的类中的字段。base和this是调用另一个构造函数时允许使用的唯一关键字。
接口：接口只包含方法，属性，索引器和事件的声明。

下面是自己写的一些测试：

    public class Students
    {
        public static readonly Color BackColor;
        public readonly DateTime CreationDate;
        static Students()
        {
            DateTime now = DateTime.Now;
            if (now.DayOfWeek == DayOfWeek.Saturday)
            {
                BackColor = Color.Green;
            }
            else
            {
                BackColor = Color.Red;
            }


        }


        public Students()
        {
            CreationDate =DateTime.Now;
        }


        public virtual int Count { get; set; }
        public double Length;
        public double Width;
        public Students(double length, double width)
        {
            Length = length;
            Width = width;
        }
        public double Diagonal
        {
            get
            {
                return Math.Sqrt(Length * Length + Width * Width);
            }
        }
  }

 public abstract class L
    {
        public  DateTime Time { get; set; }
        public abstract void ShowTime();
    }
   public class User:L
    {
       public override void ShowTime()
       {
           Console.WriteLine(Time);
       }
       private const string MyName = "lilin";
       public string Name { get; set; }
       public int Age { get; set; }
       public static readonly int tt;
       public readonly int ts;
    }

    class Core
    {
        private static void Main(string[] args)
        {
            Console.WriteLine("值类型存储在堆栈上，引用类型存储在托管堆上。二者会在内存的两个地方存储。");
            int i ,j;
            i = 1;
            j = i;
            Console.WriteLine(j);
            j = 6;
            Console.WriteLine(i);
            Console.WriteLine(j);
            Console.WriteLine("两个引用类型引用同一个对象，二者的修改会相互影响。");
            User usera, userb;
            usera=new User();
            usera.Age = 2;
            userb = usera;
            Console.WriteLine(usera.Age);
            Console.WriteLine(userb.Age);
            userb.Age = 3;
            Console.WriteLine(usera.Age);
            Console.WriteLine(userb.Age);
            Console.WriteLine("String 中使用双斜杠表示和使用@符");
            string a = "sdfsdf\nsdffsdf";
            Console.WriteLine(a);
            a = @"sdfsdf
                  dfsdf";
            Console.WriteLine(a);


            Console.WriteLine("ref关键字");
            int r = 2;
            string r2 = "we";
            Change(r);
            Change(r2);
            Console.WriteLine(r);
            Console.WriteLine(r2);
            Change(ref r);
            Change(ref r2);
            Console.WriteLine(r);
            Console.WriteLine(r2);
            Console.WriteLine("out参数");
            int r3;
            Initialization(out r3);
            Console.WriteLine(r3);
            Console.WriteLine("只读字段");
            var stu2 = new Students();
            Console.WriteLine(User.tt);
            Console.WriteLine(stu2.CreationDate);
            Console.WriteLine(Students.BackColor);
            Console.WriteLine("弱引用");
            //弱引用
            WeakReference mathReference = new WeakReference(new Students());
            Students math;
            if (mathReference.IsAlive)
            {
                math = mathReference.Target as Students;
                math.Length = 30;
                Console.WriteLine("Value field of math variable contains " + math.Length);
            }
            else
            {
                Console.WriteLine("Reference is not available.");
            }
            GC.Collect();
            if (mathReference.IsAlive)
            {
                math = mathReference.Target as Students;
            }
            else
            {
                Console.WriteLine("Reference is not available.");
            }
            Console.WriteLine("动态类型");
            var stu1 =GetObject(new Students(3,4));
            //Console.WriteLine(stu1.X);//出错
            Console.WriteLine(stu1.Diagonal);
            Console.WriteLine("抽象类");
            var user = new User();
            user.Time = DateTime.Now;
            user.ShowTime();
            Console.ReadLine();
        }
        public static dynamic GetObject(dynamic sourceObj)
        {
            return sourceObj;
        }


        public static  dynamic ChangeObject(ref dynamic sourceObj)
        {
            sourceObj.X = 1;
            return sourceObj;
        }
        private static void Change(int i)
        {
            i = 100;
        }
        private static void Change(string  a)
        {
            a ="100";
        }
        private static void Change(ref int i)
        {
            i = 100;
        }
        private static void Change(ref string a)
        {
            a = "100";
        }
        private static void Initialization(out int i)
        {
            i = 100;
        }
}