.net 学习积累1

最新推荐文章于 2025-12-26 18:11:27 发布

原创最新推荐文章于 2025-12-26 18:11:27 发布 · 270 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#.net #string #equals #c# #java #struct

2009.10.22

1. 学习了运算符的重载，这是 c# 语法独有的， java 里虽然没有，但是也可以轻松实现。

C# 支持 “ 运算符重载 ” ；使用此功能可结合自己的数据类型对运算符进行重新定义，使运算符更有意义。在下面的示例中，创建了一个结构，它将星期中的一天存储在由枚举定义的变量类型中。有关更多信息，请参见结构（ Visual C# 速成版）和枚举（ Visual C# 速成版）。对加法运算符进行了重载，这样使当前天可以加上一个整数天数，然后返回新的星期几。因此，星期日加上一天，则返回星期一。

using System;

// Define an DayOfWeek data type

enum DayOfWeek { Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday };

// Define a struct to store the methods and operators

struct Day

{

private DayOfWeek day;

// The constructor for the struct

public Day(DayOfWeek initialDay)

{

day = initialDay;

}

// The overloaded + operator

public static Day operator +(Day lhs, int rhs)

{

int intDay = (int )lhs.day;

return new Day((DayOfWeek)((intDay + rhs) % 7));

}

// An overloaded ToString method

public override string ToString()

{

return day.ToString();

}

public class Program

{

static void Main()

{

// Create a new Days object called "today"

Day today = new Day(DayOfWeek.Sunday);

Console.WriteLine(today.ToString());

today = today + 1;

Console.WriteLine(today.ToString());

today = today + 14;

Console.WriteLine(today.ToString());

}

main 方法有四种类型，参数可有可无，有的话为 string[] args, 返回值可有可无，有的话为 int

3. 字符串的学习：

C# 字符串是使用 string 关键字声明的、由一个或多个字符构成的一组字符，string 关键字是 C# 语言中对应于 System. . :: . String 类的快捷方式。C# 中的字符串比 C 或 C++ 中的字符数组更易于使用，而且也较不容易发生编程错误。

A ．字符串是使用引号声明的，

string

 greeting = "Hello, World!"

;

B ．在 c# 中 string 也是不可更改的，所以如果要对字符串进行比较多的操作的话，推荐使用 System.Text.StringBuilder

string

 question = "hOW DOES mICROSOFT wORD DEAL WITH THE cAPS lOCK KEY?"

;

System.Text.StringBuilder sb = new

 System.Text.StringBuilder(question);

上面是定义一个 StringBuilder 的方法

C ．转义字符是通过 / ，如果想不把 / 当做转义字符，那么就在字符串前面加上 @ 符号

如：string

 p1 = "////My Documents//My Files//"

;

string

 p2 = @"//My Documents/My Files/"

;

上面 2 个字符串是相同的

D ．字符串的链接可以用 + ，也可以用 String.Format 这个静态方法。

E. string 可以当做一个数组，里面的字符可以通过索引来访问

总结：字符串的比较

A ： Object 的静态方法： ReferenceEquals, Equals 比较的是引用是否相等，

所以： Person p1 = new Person("jia"); Person p2 = new Person("jia");

Object.ReferenceEquals(p1, p2) 返回的是 false 。

特别注意： ReferenceEquals 对于值类型的比较，它的返回永远都是 false ，因为值类型在系统自动封箱后的引用地址肯定是不一样的。

B ： == ， Object.Equals 作用是相同的，比较的都是引用，但是 .net 内置的很多类都重载了这个运算符，但是特别注意 ：比如 String 类，重载后 == 跟 Equals 的作用也都是一样的，但两者比较的都是对象，而不是再是对象引用。

备注：

a.== 能自动转换类型，值类型存储在栈中，只要值相当，那就相等了。

int a = 100;
Double b =100;

If(a == b)
Console.WriteLine(“equal supports compare between different types!”);

上面这段程序将会输出：
equal supports compare between different types!

b. 用户定义的值类型（ struct ），如果没有重载 == ，是不能使用 == 的。

C ． Object 有两个 equals 方法，一个是静态的，一个是动态的。静态的好处就是不用考虑空指针的错误发生。

D.Object 的非静态的 equals 方法，如果是自己定义的 struct ，那么只要里面各属性值都相同就相同，如果是自定义的引用类型的类来使用，那比较的就是对象了，而不是对象引用。

E: 特别注意下面这个例子：

StringBuilder a = new StringBuilder();
a.Append("the test a");
String s1 = a.ToString();
String s2 = "the test a";

if (s2 == s1) //== 已经被 string 重写，比较的是值
Console.WriteLine("== returns true");

if (Object.Equals(s2, s1)) // 这是多态，调用的是 string 的 equals ，所以比较的也是值
{
Console.WriteLine("equals returns true");
}

if (Object.ReferenceEquals(s2, s1)) // 这里比较的就是纯粹的引用了。而他们的是不一样的。

// 如果 String s1 = "the test a"; 那 Object.ReferenceEquals(s2, s1) 就会返回 true
{
Console.WriteLine("ReferenceEquals returns true");
}

这个实例将输出：
== returns true
equals returns true

C ：用户自己定义的类，如果想要 equals 比较的是对象，而不是对象引用，那么就需要重写 equals 方法了。

2009.10.23

1.c# 中的访问器

Class AB{

private String a="bazhaohua" ；

public string A{// 属性名称首字母大写，这样就表明了到底是谁的访问器

get{ return a; }

set{ a=value; }

}

static void Main(){

AA aa=new AA();

string b=aa.A ； // 通过 A 方法获取到 aa 类中 a 的值

Console.WriteLine(b);

aa.A="zhanghongshan"; // 直接把参数 “zhanghongshan” 传递给 value

Console.WriteLine(b);

}

总结：访问的时候不用加括号。 Java 更加规范一点，这里更加简洁一点

a 叫字段变量 A 叫属性

2. C# 中 ref 和 out 的区别

首先：两者都是按地址传递的，使用后都将改变原来的数值 。很多人在论坛上解释说 out 是按数值传递，是错误的。简单的测试后可以知道 out 使用也能改变数值的，所以肯定是按照地址传递的。

**** 不是值传递，是地址传递的证明程序：下面的程序中的 out 换成 ref ，也同样改变原来的 a 值 ***

public static int a = 3;

public static void Method(out int b){

b = 2;

//int c = 2;

//b = c+b;

// 当参数b 是out 的话，上面2 行程序是会报错的，说b 未被赋值，因为out 参数使用前必须赋值。

// 当参数b 是ref 的话，上面2 行程序是不会报错的。结果是 3 5. 说明ref 使用前不必赋值

}

static void Main(string [] args)

{

Console .WriteLine(a);

Method(out a);// 注意使用的时候也要加 out ，否则会报错

Console .WriteLine(a);

}// 结果是 3 2
其次： rel 可以把参数的数值传递进函数，但是 out 是要把参数清空，就是说你无法把一个数值从 out 传递进去的， out 进去后，参数的数值为空，所以你必须初始化一次。这个就是两个的区别，或者说就像有的网友说的， rel 是有进有出， out 是只出不进 。经典！！！

使用区别： ref 外面必须

又一个关于 ref 和 out 比较好的总结：

ref 和 out 都对函数参数采用引用传递形式 —— 不管是值类型参数还是引用类型参数，并且定义函数和调用函数时都必须显示生命该参数为 ref/out 形式。两者都可以使函数传回多个结果。

两者区别：

两种参数类型的设计思想不同， ref 的目的在于将值类型参数当作引用型参数传递到函数，是函数的输入参数，并且在函数内部的任何改变也都将影响函数外部该参数的值；而 out 的目的在于获取函数的返回值，是输出参数，由函数内部计算得到的值再回传到函数外部，因此必须在函数内部对该参数赋值，这将冲掉函数外部的任何赋值，使得函数外部赋值毫无意义。

表现为：

1 、 out 必须在函数体内初始化，这使得在外面初始化变得没意义。也就是说， out 型的参数在函数体内不能得到外面传进来的初始值。
2 、 ref 必须在函数体外初始化。
3 、两者在函数体内的任何修改都将影响到函数体外面。

例：

using System;

namespace ConsoleApplication1
{
class C
{
public static void reffun(ref string str)
{
str += " fun";
}

public static void outfun(out string str)
{
str = "test"; // 必须在函数体内初始 , 如无此句 , 则下句无法执行 , 报错
str += " fun";
}
}

class Class1
{
[STAThread]
static void Main(string[] args)
{
string test1 = "test";
string test2; // 没有初始
C.reffun( ref test1 ); // 正确
C.reffun( ref test2 ); // 错误，没有赋值使用了 test2
C.outfun( out test1 ); // 正确，但值 test 无法传进去
C.outfun( out test2 ); // 正确

Console.Read();
}
}
}

3. 放在 hashTable 中的键必须同时实现 GetHashCode 和 Equals 方法。这样才行

作用跟 java 中是一样的。 GetHashCode 是保证冲突， equals 方法是去重。

因为 GetHashCode 是保证同样的对象返回一个唯一的哈希码，而 object 本来的 GetHashCode 函数是不保证同样的对象返回的哈希码是唯一的。

2009-11-2

1. 修饰符的作用范围：

Private 仅限于本类内部

Protected 仅限于本类以及其子类（即使子类跟基类不在同一个程序集也是可以的）

Internal 仅限于同一个程序集。也就是同一个解决方案里

Public 公开访问权限。

Protected internal 可在子类中或同一个程序集内被访问。更公开了。

如果只允许同一个程序集中的子类访问，那就父类就该被设置为 internal 的，成员设置为 protected.

2. 自动实现的属性：

String Password{get;set;}

3.sealed 类似于 java 中的 final 修饰类则该类无法被继承，修饰方法则该方法无法被重写。

不会像 java 中一样去修饰字段，因为 c# 中有 const 。

3. 静态类成员：属于类的，而不是某个具体的对象

静态类：当该类的所有才所有成员都是静态的时候，可以将该类声明为静态类。

2009-11-4

关于在 c# 中排序：

集合对象中的对象元素排序也是类似于 java ，元素对象要实现 Icomparer 方法。

1. 一个 c# 中的现象：当一个类中有一个对象数组，如果要对该对象中的数组使用 foreach 进行循环，使用的方法是该类要实现一个方法：

Public Ienumerator GetEnumerator(){

Foreach(Student s in stu){

Yield return s;

}

然后迭代的时候就是对该类进行迭代，实际实现的是对该类中的数组进行的迭代。

2. 对集合对象中的元素进行排序是统一使用 Array.Sort() 方法进行排序，如果是内置类型，那就可以直接排序了，如果是对象类型，那么对象就要继承 System.Icomparable 接口，然后实现它的 CompareTo 方法。然后再 Array.Sort( 元素数组 );

3. 如果是对象类型，且是要依据对象中的多个字段进行比较的话，那么就要定义辅助类了，在 java 中这叫做比较器。这个类要继承 System.Collections.Icomparer 方法，然后实现它的 Compare 方法。最后再 Array.Sort( 元素数组，辅助类对象 ). 这是对 Array.Sort() 方法的重载。

另一篇：

1..asax文件是干什么用的 c#？？？
答：Global.asax全局配置文件.当一个应用程序启动时,首先就先执行这个
类型文件,没有的话那就算,,
在这里主要是配置一些http事件啊,或者user
等等,,反正是全局的,这个里面的东西一加载,那就会用到所有的页面上
而不是象在其他的程序里写的只有一个范围内

当这个应用程序关了后,或者停了话,他会自动关闭了

2.Session.Timeout 的单位是分钟，而不是秒
默认是20分钟
＜sessionState＞
　　作用：为当前应用程序配置会话状态设置（如设置是否启用会话状态，会话状态保存位置）。
　　示例：
　　＜sessionState mode="InProc" cookieless="true" timeout="20"/＞
　　＜/sessionState＞
　　注：
　　mode="InProc"表示：在本地储存会话状态（你也可以选择储存在远程服务器或SAL服务器中或不启用会话状态）
　　cookieless="true"表示：如果用户浏览器不支持Cookie时启用会话状态(默认为False）
　　timeout="20"表示：会话可以处于空闲状态的分钟数

3.protected virtual HttpHandler[] GetHttpHandlers(HttpContext context)
         {
              return HandlerConfiguration.Instance().HttpHandlers;//这是个收集
         }

virtual是什么意思？
默认情况下方法是非虚拟的，是不能重写的。
有了virtual的话就可以既有自己的实现，又可以被重写了。
如果是abstract的话，那不能有自己的实现，只能被重写了。

总结：重写的方法必须是vitural，override，abstract类型的。不能重写非虚犯法和静态方法。
属性是不可以被重写的，字段可以。因为字段也相当于方法

protected的意思是本类和子类才可以使用的方法
virtual的意思是：该方法有实现，同时也可以被子类覆盖，如果子类覆盖了该方法，那么就是多态了，如果子类没有覆盖，那使用的就是本方法。子类覆盖需要使用关键字override

4. public partial calss Form1:Form
partial 是部分的的意思。这是.net framework2.0引入的新特性---分布类。

分布类的意思就是把一个类分布写在两个文件中。只有两个文件在一起，这个类才完成，才可以运行。
在VS2008中，利用VS创建的窗体都是分布类。如创建一个Form.aspx,那么就Form类就分布在Form.cs 和Form.Designer.cs中。

5..net程序如何编译？
答：首先来看java程序时如何编译的：
首先.java文件会被编译器javac.exe编译成.class文件也就是机器码； jvm是与平台有关系的。
然后 JVM解释执行，.class文件， JVM把字节码转换成机器码

.net程序可以由各种语言编写，各种语言都由各自的编译编译成托管代码(也叫中间语言IL,MSIL。类似于java中的.class文件)，然后在.net framework的核心CLR，托管代码在CLR中运行并转换为机器码。

托管代码的优点：
1.与平台无关
2.JIT性能优化。为了减少中间的代码编译为机器码的性能损失，中间语言采用即时编译。也称为JIT编译。这种编译方法只编译调用的代码，而不是所有的代码，编译过的部分将被存储在内存中，再次执行时候不需要重复编译。当退出程序时，已编译的代码才会被清除。n

6. 自定义的异常类需要一般以Exception结尾，然后继承自System.ApplicationException。
在.net中，基础类库所定义的异常都是在CLR中创建并抛出，这种异常称为系统级异常，继承自System.SystemException.