.Net培训个人总结笔记19

学习交流，欢迎转载。转载请注明文章来源：http://www.cnblogs.com/lgjspace/archive/2011/10/12/2218253.html

 

面试题！！！！：
代码如下：

namespace 面试题
{
    public class A
    {
        public static int i = 0;    //静态属性，不能用类的对象来调用。
        public A()    //非静态构造函数，外界每创建一个“该类的对象”或者“继承自该类的子类的对象”，该方法就被调用一次。
        {
            Console.WriteLine(@"A");
        }
        
        public virtual void fun()
        {
            i++;    //非静态成员可以直接调用静态成员，由于两者在同一个类里面，所以不用以“类名.成员名”的方式来调用，可以直接以“成员名”的方式来使用。
        }
    }
    public class B : A      //继承自类 A
    {
        public new int i = 0;
        public B()      //非静态构造函数，由于该类 B 继承自类 A，因此外界每创建一个该类的对象，该构造函数的基类 A 中的构造函数和该构造函数 B() 本身都会“依次、分别被调用一次”，即先调用 A()，然后再调用 B()。
        {
            Console.WriteLine(@"B");
            i++;
        }
        public override void fun()  //覆盖（override）父类方法。
        {
            i--;
            base.fun();     //调用基类的 fun() 函数。
        }
    }
    public class Main1
    {
        static void Main(string[] args)
        {
            A a = new A();      //调用了类 A 的构造函数 A() ，打印出“A”。
            B b = new B();      //先是调用了类 A 的构造函数 A() ，打印出“A”，然后再调用了类 B 的构造函数 B() ，并打印出“B”。
            b.fun();            //调用了类 B 的对象 b 的 fun() 方法：首先是对 b 的被标记为 new 的成员变量 i 作自减操作，由于在 b 被构造时 b 中的 i 被作了一次自增操作，所以自减之前 i = 1，自减后 i 为 0，然后执行“base.fun()”，调用父类 A 的 fun() 方法，但在父类 A 的 fun() 方法中的“i++”所自增的是父类 A 中的静态变量 i，而非子类 B 中的成员变量 i，此时父类 A 中的静态变量 i 的值为 1。
            Console.WriteLine(A.i);     //此时 A.i 的值为1。注意！在外部调用静态成员时要用类名来调用而非对象名。
            Console.WriteLine(b.i);     //此时 b.i 的值为 0。
            Console.ReadKey();
        }
    }
}

 

细节：
1. 如果想隐藏父类的实现，写 new 和不写 new 的运行结果是一样的，只是写了 new 的话就相当于告诉编译器“我是刻意隐藏父类的方法的，别警告我了”。
2. 只有（广义的）方法（包括 属性、索引器、方法等）才有 virtual 和 override，对于字段是没有 virtual、override 的说法的，但字段仍然可以使用“new”。
3. 创建对象的时候先执行父类的构造函数，再执行自己类的构造函数。

 

细节：
1. C# 中，结构体非常类似于类，“看起来”和类几乎是一摸一样的，但结构体是值类型（拷贝传递），不能被继承（常考），也不能继承其他结构体和类，只能继承 接口。
2. C# 中的结构体可以声明字段，属性，方法等。

 

见识：
1. 其实平时用到的很多基本类型（值类型）都是结构体（struct），例如：bool，int，DateTime，long 等。
2. int 和 Int32，bool 和 Boolean，byte 和 Byte 等这些的两者之间其实都有略微差别，内部涉及到了 boxing 和 unboxing 的问题，具体可以查阅相关资料。

 

细节：
1. XML 的标签、属性名、属性值等都是区分大小写的。
2. XML 的标签（Tag）是闭合的：有开始就要有结束，如：<Person>"Tom"</Person>。但有一种例外：“开始即结束”，如：<Person/>。
3. XML 的属性（Attribute）是“开始即结束”的标签类型，如：<add key = "ip地址" value = "127.0.0.1"/>，其中 key 就是属性（Attribute）名，在这里是“ip地址”，value 就是属性值，在这里是“127.0.0.1”。
4. XML 的结构是树状结构，有分父节点，子节点，兄弟节点等。

 

细节：
Linq To Xml 的现状：
1. Linq To Xml 不需要单独创建类来调用，而且（相对于XmlSerializer）更底层一些，灵活性更高，推荐 Linq To Xml。
2. System.Xml 下的类是 2.0 及之前操作 Xml 推荐的，现在很多人也仍然在用这个 namespace 下的类，这个 namespace 下的类和 Linq To Xml非常相似，因此不用再单独学。

 

细节：
1. 用 XElement 类的对象的 Save() 方法可以把对象保存为文件、流等。
2. 在 Xml 中，属性的值一定要用双引号包着。
3. Xml 的保存格式一般都是 UTF-8。

 

细节：
XDocument 类的对象（暂命名为 doc）的 Root（根节点）属性下的 Element("节点名") 方法可以找到“根节点下的名为"节点名"的节点”。

 

细节：
Xml 的读取操作：

using (FileStream fs = File.OpenRead("c:/1.xml"))
{
    using (StreamReader reader = new StreamReader(fs))
    {
        //读取节点格式的属性值
        /*
        XDocument doc = XDocument.Load(reader);
        //IEnumerable<XElement> elements = doc.Root.Descendants("Person");
        foreach (XElement xePerson in doc.Root.Descendants("Person"))
        {
            Console.WriteLine("姓名{0}，年龄：{1}", xePerson.Element("Name").Value,xePerson.Element("Age").Value);
        }*/

        //读取属性格式的属性值。
        XDocument doc = XDocument.Load(reader);
        foreach (XElement xePerson in doc.Root.Descendants("Person"))
        {
            Console.WriteLine("姓名{0}，年龄：{1}", xePerson.Attribute("Name").Value, xePerson.Attribute("Age").Value);
        }
    }
}

细节：
相对于 Linq To Object 来说，Linq To Xml 并不是什么新东西，Linq 的语法几乎都一样，唯一不同的只是操作的对象由原来的变量序列变成了现在的 Xml 序列。

 

细节：
WebService 技术是和语言以及平台无关的，因此可以说 WebService 可以实现跨语言的方法调用。

 

概念：
WSDL：描述了 WebService 提供了哪些方法。
SOAP：描述了向服务器发送什么格式的调用数据，以及服务器会返回什么格式的数据。

 

细节：
1. 用 ASP.Net 开发的 WebService 页面后缀都为“.asmx”。
2. 在“.asmx”的 WebService 页面中一般都能找到“服务说明”，点击该“服务说明”一般就能看到该 WebService 的 WSDL 了。

 

细节：
在 ASP.Net 中，在所有对外开放的 WebService 方法上都要标记为[WebMethod]，每个作为 WebService 的方法前面都要分别被标记一次。同时，该方法必须是 public 的，这样才能被外界调用。

 

细节：
在程序中添加服务引用时，添加的是“服务说明”页（即 WSDL 页，如：“http://www.webxml.com.cn/WebServices/WeatherWebService.asmx?WSDL”），而不是 WebService 所在的“.asmx”后缀的页面。但如果 WebService 所在的页面后缀为“.asmx”的话（即该 WebService 页面是用 ASP.Net 做的话），则它的 WSDL 页面地址一般就是在原 WebService 页面的地址后面加上“?WSDL”，如：“http://www.webxml.com.cn/WebServices/WeatherWebService.asmx?WSDL”。

 

细节：
1.添加 WebService 项目步骤：新建项目 → 项目类型中选中“Web”→ 模板中选中“ASP.NET Web 服务应用程序”即可。
2.注意：在 VS2010 中没有“ASP.NET Web 服务应用程序”的模板，但没关系，可以先创建一个“ASP.Net 空 Web 应用程序”项目，然后再在该空项目下新建一个“Web 服务”项（即 .asmx文件）也同样可以。
3.一个 WebService 项目中可以添加多个 WebService 页面（即 .asmx 页面）。
4.每当修改或增删了方法之后都要“更新服务”。

 

细节：
在 WSDL 文档中诸如“s:string”“s:int”等标识中的“s:”指代的是“这是标准类型”的意思。

 

见识：
网上对于“WebService 是否支持返回 DataSet 类型的数据”是有很大争议的，因为 WebService 是跨语言的，而 DataSet 只是 .Net 框架里面才有的东西，其他语言调用 DataSet 类型数据需要进行数据解析后才能使用 DataSet 类型的数据，很麻烦。

 

细节：
1. 类的默认访问级别是 internal。
2. 密封类(sealed)：密封类不能被继承，只能被实例化；（String 类也是密封类）。注意：String 的“密封”和 int 的“密封”，从本质上来讲是不一样的，String 是密封类，而 int 是结构体，只是结构体也不能被继承或继承其他的类或结构体(但能继承接口)，从而有“密封”效果而已。
3. 抽象类(abstract)：抽象类不能被实例化，只能被继承；
4. 静态类(static)：静态类既不能被继承，也不能被实例化，只能“静态调用”（即只能以“类名.方法名”的方式调用）。
5. 部分类(partial)：可以把一个类的代码分别定义到两个（或以上）的 *.cs 文件中，主要是为了方便“设计器”的工作模式（“设计器模式”类似于窗体项目中的“Form1.cs”和“Form1.Designer.cs”文件的关系）。
  （注意：部分类中的每一个子部分类的访问级别要一致，如果一个标识为 public ，则另一个就算没有标识为 public 也是 public 级别，但不可以一个显式地标识为 public 而另一个却显式地标识为非 public 级别。）
  （注意：面试时可能会问到 ASP.Net 的 CodeBehind 的原理，这也是用部分类来实现的。）

 

区别：
int/Int32，string/String，bool/Boolean 等的关系：
1. Int32、String、Boolean 都是 .Net 中的类型，int、string、bool 都是 C# 中的类型，是 .Net 的类型映射到 C# 中的类型，.Net支持多语言，.Net的类型映射到每个具体语言里的基本类型的关键字会因语言种类而不同，但无论什么语言的基本类型，最终还是要先转换成 .Net 下的基本类型，然后才能对数据作进一步操作。
2. 两者之间的转换需要经过“装箱（Boxing）”和“拆箱（UnBoxing）”。

 

问题：
写代码的时候是不是直接用.Net的类型会提高代码性能？
不是，因为“类型转换”的工作不是在程序运行时进行的，而是在程序编译时进行的。

 

细节：
extern、PInvoke 能调用 Win32API 或调用其他语言编写的一般的dll（而不是.Net框架中编译的 Assembly 中的 DLL ）中的方法。

 

细节：
假设有如下调用：
[DllImport("kernel32.dll")]
static extern uint GetCurrentProcessId();
1. 这种方式调用的 dll 是非 .Net 框架下的语言写的一般的 dll，如 C/C++ 下写好的 dll。
2. 系统会首先到 C:\Windows\System32 下寻找该 dll，如果没有就在代码所在的当前目录下找。
3. 如果 dll 文件是放在其它的非默认路径下的话，可以在上面第一行代码中的双引号里写明 dll 的全路径，来让程序定位调用。

 

细节：
1. C# 中是可以使用指针的，把使用指针的代码、方法标记为 unsafe ，然后打开项目的 → 属性 → 生成 → 勾选“允许不安全代码”即可。
2. unsafe 不仅仅只能在方法级别上标记，还可以为某个语句（或语句段）标记，方式如下：

unsafe
{
　　//代码。。。
　　//代码。。。
　　//代码。。。
}

 

细节：
对象初始化器的使用：
如下面代码所示：

Person p = new Person() { Age = 3, Name = "Jim"}; //直接在构造函数后面添加一对大括号{}，并在大括号里面初始化成员。

 

细节：
.Net 4.0 的新特性：
1. 可选参数。（在 4.0 之前可以通过方法的重载来实现该功能）
   基本语法：static void SayHello(string name = "tom");
2. 动态对象。最重要的特性，适合于逻辑算法不好确定，要经常变化的场合，但效率比较低，性能要求较高的场合不推荐使用，而且动态对象，是运行时的动态，如果错了，编译时不会报错，运行时才报错。动态对象还可以简化反射调用。

//基本语法：
dynamic p = new ExpandoObject();

 

拓展：
IronPython 是一种动态语言，是 .Net 下的 Python 语言。