const和readonly区别

C＃面试题（设计模式在后面）2。

const和readonly有什么区别？答：const可以用于类的成员常量和局部常量，必须在声明时赋值，之后不可以对常量进行赋值。

而readonly只能用于类的成员变量不能用于局部变量，在声明时可以不赋值，除了在构造函数中可以再次赋值外，其它的地方和const一样也不能赋值.5。

接口和抽象类有什么区别？你选择使用接口和抽象类的依据是什么？答答：区别如下（1) 抽象类可以有抽象成员（无具体实现)，也可以有非抽象成员(有具体实现）;接口只有抽象成员。

（2）一个类不能同时继承多个抽象类，一个类可以同时实现多个接口.如果多个子类中有很多代码是重复的,这时采用抽象类，因为可以将这些代码放到抽象类的非抽象方法中，这样可以达到代码复用.当实现多个接口时因为抽象类不支持,只能使用接口.6. struct和class有什么区别答:两者都可以有成员变量、属性、索引器、事件、函数、构造函数,主要区别如下：区别点结构类类型值类型引用类型成员变量在声明时不能赋值可以赋值也可以不赋值构造函数可以不写，系统提供默认构造函数，默认构造函数中会将所有成员值设为0，如果写了构造函数则构造函数必须有参数，且在构造函数中必须为每一个成员赋值。

可以不写，系统提供默认构造函数，写了也没有结构中的限制.析构函数不能有析构函数可以有析构函数继承性自定义的结构不能从类继承，但可以实现接口,结构都是密封（sealed），不能从结构继承类没有限制7。

try后面一个finally，try中有一个return，那么finally中的代码会不会运行？如果运行，是在return后还是return前。

答：会运行,并且在return 后运行。

8。

产生一个int数组，长度为100，并向其中随机插入1-100，并且不能重复。

答：该题解题思路有很多，主要是看运行效率如何，下面提供一种方法。

int［] array = new int[100］；int temp［] = new int［100];for （int i = 0；i < 100；i++)｛temp[i]=i+1；｝Random rand = new Random(）;for （int i = 0；i < 100; i++){int index = rand。

我们都知道，const和static readonly的确很像：通过类名而不是对象名进行访问，在程序中只读等等。

在多数情况下可以混用。

二者本质的区别在于，const的值是在编译期间确定的，因此只能在声明时通过常量表达式指定其值。

而static readonly是在运行时计算出其值的，所以还可以通过静态构造函数来赋值。

明白了这个本质区别，我们就不难看出下面的语句中static readonly和const能否互换了：1. static readonly MyClass myins = new MyClass();2. static readonly MyClass myins = null;3. static readonly B = 10; static readonly A = B * 20;4. static readonly int [] constIntArray = new int[] {1, 2, 3};5. void SomeFunction(){const int a = 10;...}6.private static string astr="abcd";private const string str = astr+"efg";1：不可以换成const。

new操作符是需要执行构造函数的，所以无法在编译期间确定2：可以换成const。

我们也看到，Reference类型的常量（除了String）只能是Null。

3：可以换成const。

我们可以在编译期间很明确的说，A等于200。

4：不可以换成const。

道理和1是一样的，虽然看起来1,2,3的数组的确就是一个常量。

5：不可以换成readonly，readonly只能用来修饰类的field，不能修饰局部变量，也不能修饰property等其他类成员。

6.错误：如果在astr前加上const或者const改为readonly即可；总结：1.const、readonly和static readonly定义的常量，指定初始值后(包括在构造函数内指定的初始值) 将不可更改，可读不可写；2.const定义时必须指定初始值，而readonly定义时可以不进行初始化(MS建议在定义时初始值),同时也可以在构造函数内指定初始值，并以构造函数内指定的值为准；3.const和static readonly定义的常量是静态的，只能由类直接访问；而readonly定义的常量是非静态的，只能由实例对象访问；4.static readonly常量，如果在构造函数内指定初始值，则必须是静态无参构造函数；5.const是编译时常量，readonly是运行时常量；cosnt较高效，readonly较灵活。

net软件工程师面试题根本题：1. 简述string[]、ArrayList、List的区别。

数组：利益：o数组在内存中是接连存储的，索引速度十分快；o赋值和修改元素也很简单；不足：o两个数据之间插入数据对照贫穷困难；o声明数组的时辰，必须指明数组的长度，数组长渡过长会造成内存挥霍，数组的长渡过短，会造成数据溢犯错误。

ArrayList：利益：o. net framework 提供的用于数据存储和检索的专用类o大小依据存储的数据来动态扩展和收缩o继承IList，可以方便的进行数据的添加、插入和删除瑕玷：o许可插入差别类型的数据，都当做object类型处理o数据处理时大概出现类型不匹配的错误o存在装箱（值=》引用）拆箱的操纵，会带来很大的性能损耗List：利益：o声明List集合时，需要声明集合内数据的对象类型o避免了类型安然问题和装箱拆箱的性能问题2. 简述装箱和拆箱操纵中的性能损耗是若何产生的。

3. 简述对ASP. NET中的事务机制的懂得。

4. 在一个ASP. NET的三层结构系统中，以登录操纵为例，简述在各层中若何组织代码。

5. 简述相比DATASET，实体类在WEB项目中的利益与瑕玷。

6. 简述GC是若何工作的。

Java采纳VM（Virtual Machine）机制，由VM来经管程序的运行当然也包罗对GC 经管。

90年代末期. NET出现了， . NET采纳了和Java类似的方式由CLR(Common Language Runtime) 来经管。

Garbage Collector（垃圾收集器，在不至于混淆的情况下也成为GC）以应用程序的root为根本，遍历应用程序在Heap上动态分配的所有对象[2]，通过识别它们是否被引用来确定哪些对象是已经死亡的、哪些仍需要被使用。

已经不再被应用程序的root 大概别的对象所引用的对象就是已经死亡的对象，即所谓的垃圾，需要被回收。

这就是GC工作的原理。

C#定义常量的两种⽅法在C#中定义常量的⽅式有两种，⼀种叫做静态常量（Compile-time constant），另⼀种叫做动态常量（Runtime constant）。

前者⽤“const”来定义，后者⽤“readonly”来定义。

对于静态常量（Compile-time constant），它的书写⽅式如下：public const int MAX_VALUE = 10;为什么称它为静态常量呢，因为如上声明可以按照如下理解（注意：如下书写是错误的，会出编译错误，这⾥只是为了⽅便说明）。

public static const int MAX_VALUE = 10;⽤const定义的常量，对于所有类对象⽽⾔都是⼀样的，因此需要像访问静态成员那样去访问const定义的常量，⽽⽤对象的成员⽅式去访问会出变异错误。

此外，对于静态常量的访问在编译的时候，是⽤常量的值去替换常量，例如：int nValue = MAX_VALUE;这句在编译之后，和如下这句所产⽣的中间语⾔代码是⼀样的。

int nValue = 10;不过，在⽤const来定义常量的时候，在类型上有很多限制。

⾸先，此类型必须属于值类型，同时此类型的初始化不能通过new来完成，因此⼀些⽤struct定义的值类型常量也不能⽤const来定义。

相对于const⽽⾔，⽤readonly来定义常量要灵活的多，它的书写⽅式如下：public readonly int MAX_VALUE = 10;为什么称为动态变量，因为系统要为readonly所定义的常量分配空间，即和类的其他成员⼀样拥有独⽴的空间。

此外，readonly所定义的常量除了在定义的时候可以设定常量值外，还可以在类的构造函数中进⾏设定。

由于readonly所定义的常量相当于类的成员，因此使⽤const来定义常量所受到的类型限制，在使⽤readonly去定义的时候全部消失，即可以⽤readonly去定义任何类型的常量。

C#知识点总结1、 Console.WriteLine()：打印到控制台并换行2、 C#类型：值类型、引用类型3、 namespace：不同文件夹下的类可以属于同一个namespace4、字符串相加：使用“ + ”操作符，任何其他对象与字符串相加都会自动调用ToString()5、字符串存储：str1 = “111”; str2 = “111”，str1和str2指向同一地址6、字符串比较：只要str1和str2内容相同，str1 == str2表达式都会返回true。

==操作符被String重载7、整型：byte、short、int、long，都有相应的有/无符号版本，其中byte 是无符号的，其他是有符号的8、浮点型：float、double、decimal，只有有符号版本9、值类型中的数值型：都包含MinValue、MaxValue属性，可以直接由类型通过（.）操作符访问10、强制类型转换：“()”操作符，如int i = (int)c;11、 char：字符型，Unicode编码（16位）。

可看作无符号整型，可以使用ushort 以上的类型强制类型转换。

12、 char/Unicode码段常量：数字0-9（48-57），大写字母A-Z（65-90），小写字母a-z（97-122）13、特殊字符：’\t’-制表位；’\n’-换行符eg： Console.WriteLine("ying shi\t yang") 效果为： ying shi yang （中间空四个格）14、赋值语句/表达式：赋值语句在表达式中只计算左值，计算前已经将右值计算结果赋予左值15、 bool：逻辑型，只有两个值，true/false16、出现在字符串中的双引号：写法为（\"）17、数值、char、bool的Parse()方法：基础值类型都包含该方法，将字符串转为本类型变量18、数值型.Parse()：参数如果不是数值，或者越界，将返回异常19、编译器捕获数值计算越界：在编译期判断是否越界，如果判断越界，则根本不可能编译成功20、未捕获的数值计算越界（如方法调用）：则回到数值型范围开始处。

const与readonly 很像，都是将变量声明为只读，且在变量初始化后就不可改写。

那么，const与readonly 这两个修饰符到底区别在什么地方呢？其实，这个牵扯出C#语言中两种不同的常量类型：静态常量（compile-time constants）和动态常量（runtime constants）。

这两者具有不同的特性，错误的使用不仅会损失效率，而且还会造成错误。

首先先解释下什么是静态常量以及什么是动态常量。

静态常量是指编译器在编译时候会对常量进行解析，并将常量的值替换成初始化的那个值。

而动态常量的值则是在运行的那一刻才获得的，编译器编译期间将其标示为只读常量，而不用常量的值代替，这样动态常量不必在声明的时候就初始化，而可以延迟到构造函数中初始化。

当你大致了解上面的两个概念的时候，那么就可以来说明const与readonly了。

const修饰的常量是上述中的第一种，即静态常量;而readonly则是第二种，即动态常量。

那么区别可以通过静态常量与动态常量的特性来说明：1）const修饰的常量在声明的时候必须初始化;readonly修饰的常量则可以延迟到构造函数初始化2）const修饰的常量在编译期间就被解析，即常量值被替换成初始化的值;readonly修饰的常量则延迟到运行的时候此外const常量既可以声明在类中也可以在函数体内，但是static readonly常量只能声明在类中。

const 的概念就是一个包含不能修改的值的变量。

常数表达式是在编译时可被完全计算的表达式。

因此不能从一个变量中提取的值来初始化常量。

如果const int a = b+1;b是一个变量，显然不能再编译时就计算出结果，所以常量是不可以用变量来初始化的。

readonly 允许把一个字段设置成常量，但可以执行一些运算，可以确定它的初始值。

因为readonly 是在计算时执行的，当然它可以用某些变量初始化。

readonly 是实例成员，所以不同的实例可以有不同的常量值，这使readonly更灵活。

10个面试高压问题及回答“如果我录用你，你将怎样开展工作”这是一道陷阱题，如果应聘者对于应聘的职位缺乏足够的了解，最好不要直接说出自己开展工作的具体办法，以免引起不良的效果。

面试者可以尝试采用迂回战术来回答，如“首先听取领导的指示和要求，然后就有关情况进行了解和熟悉，接下来制定一份近期的工作计划并报领导批准，最后根据计划开展工作。

1、告诉我，你最大的弱点是什么？回答这种问题的秘诀在于不接受这种否定暗示。

不要否认你有缺点，没人会相信世界上有完人；相反，你应该承认一个微不足道的弱点或一个小小的缺点，然后再说那都已经成为过去了，表明自己是怎样克服这个缺点的。

2、你认为自己的哪项技能需要加强？麻烦又来了，你不可能宣称自己无所不能，但如果你简单地承认自己在哪方面需要改进，高压面试主考就会像嗜血的鲨鱼一样一口咬住你。

你该重新定义一下这个问题以便躲开这一点：“既然谈到这儿，我想说我已具备了这份工作所需的所有技能。

这也是我所以对这个职位感兴趣的原因。

”你可以借机再把自己简历中的闪光之处再炫耀一番。

我叫&times;&times;&times;，今年19岁，xxx(where)人。

我在高一阶段曾有幸参加了xx杯网页设计比赛，尽管成绩平平，仅获了第4名，但由此激起了我对网络的浓厚兴趣!我知道进入21世纪后，信息将成为第一生产要素，同时将构成信息化社会的重要技术物质基础。

当今社会网络人才辈出，造就了淘宝的马云，腾讯的马化腾等。

我愿以他们为坐标，作为我一生追求的终点。

我认为贵校可以为我提供平台，帮我的实现愿望，所以我填报了贵校的计算机网络专业。

我知道名额有限，但是有挑战才会有成功!恭请贵校可以给我一个机会!我的业余爱好是上网，打球。

偶尔与朋友结伴出游。

3、你认为什么样的决定犹为难做？如果你用他问题中的这些词来回答，就只能对自己不利了。

主考会立刻猛扑上来。

那回答的秘诀是什么呢？要摒弃那些否定性的词汇：“我没发现有什么决定特别‘难’做，但确实有时做一些决定要比做其他的决定要多费一些脑筋，多做些分析。

net下面调用access中存储过程的方法在Sql Server中使用存储过程是大家都比较熟悉的了，前不久自己作了一个小东东，数据库使用的是MS Access数据库，也想着试试用存储过程是否可行。

毕竟，存储过程与代码的关系不是非常大，数据库和存储过程的修改有些是不用更改编码的。

下面贴出我的代码，大家会发现，其实跟调用Sql Server的存储过程是完全一样的，不同的仅仅在于存储过程的名称。

以删除人员信息为例：1. 这里是数据访问层的一段代码，直接调用存储过程。

public class Person{///定义存储过程，注意，这里的存储过程用 [ ] 括起来了。

private const string ASP_PERSON_INSERT = “[asp_Person_Insert]“; private const string ASP_PERSON_UPDATE = “[asp_Person_Update]“; private const string ASP_PERSON_DELETE = “[asp_Person_Delete]“;……………………………..private const string PARM_PERSON_PERSONID=”@PersonID”;…………………………….private OleDbParameter[] GetDeleteParam(int PersonID){OleDbParameter[] param = new OleDbParameter[]{new OleDbParameter(PARM_PERSON_PERSONID,OleDbType.Integer)};param[0].Value=PersonID;return param;}/// <summary>/// 删除人员信息/// </summary>/// <param name=”personID”>人员ID</param>/// <returns>成功返回True；失败返回False</returns>public bool Delete(int personID){//ASP_PERSON_DELETE 存储过程的名称。

const在c语言中的用法在C语言中，const是一个用于限定定义变量或函数表达式类型的修饰符，其意义是变量或表达式一旦被const修饰，就意味着该变量的值或表达式的值不可被改变。

1. const的定义const修饰符的本意是"read-only"，也就是常量，它使用最主要的作用是引用非变量可被改变的值，用来显示为可被信任或只读的值。

可用于修饰全局变量以及局部变量，以及函数参数、函数返回值以及指针类型。

2. const的作用（1）保护定义的变量不允许被改变，确保程序的稳定性和安全性。

（2）const修饰可以有效的防止程序出现意外的错误。

（3）使用const可以有效地减少编程过程中的无用的编译和修改操作。

（4）使用const等修饰符可以易于理解和调试程序。

3. const的用法（1）变量修饰：使用const关键字修饰变量，这个变量及其值就无法被改变了。

例如，int const a = 10;a = 20; //运行出错（2）函数修饰：将定义函数的参数、指针以及返回值用const进行修饰，使得这些修饰的参数、指针以及返回值甚至在函数内部也处于只读状态。

例如，int const * checkData(int const *data);4. const的特点（1）const的作用域：const只在声明时存在，而不像#define那样会一直存在到程序结束，并且一个定义的实体，和在其他地方使用#define 定义常量不同，它只在声明和定义的一段语句有效，到了这段代码结束就失效。

（2）使用const可以避免定义无用的变量。

（3）const有利于代码的可维护性，使得代码更容易维护和调试，也有助于降低重大的程序错误的发生。

TS--（2）接⼝、数组的类型、函数的类型2019-10-28:学习内容：接⼝、数组的类型、函数的类型（展开涉及多个内容）参考：⼀、接⼝（（Interfaces）：⼀、接⼝（1） LabelledValue接⼝就好⽐⼀个名字，⽤来描述上⾯例⼦⾥的要求。

它代表了有⼀个label属性且类型为string的对象。

需要注意的是，我们在这⾥并不能像在其它语⾔⾥⼀样，说传给printLabel的对象实现了这个接⼝。

我们只会去关注值的外形。

只要传⼊的对象满⾜上⾯提到的必要条件，那么它就是被允许的。

还有⼀点值得提的是，类型检查器不会去检查属性的顺序，只要相应的属性存在并且类型也是对的就可以。

interface LabelledValue {label: string;color?: string}function printLabel(labelledObj: LabelledValue) {console.log(bel);}let myObj = {size: 10, label: "Size 10 Object"};printLabel(myObj);// 可选属性：接⼝⾥的属性不全都是必需的。

有些是只在某些条件下存在，或者根本不存在。

在可选属性名字定义的后⾯加⼀个?符号。

可选属性的好处之⼀是可以对可能存在的属性进⾏预定义，好处之⼆是可以捕获引⽤了不存在的属性时的错误（2）只读属性：readonly ⼀些对象属性只能在对象刚刚创建的时候修改其值。

你可以在属性名前⽤readonly来指定只读属性interface Point {readonly x: number;readonly y: number;}let p1: Point = { x: 10, y: 20 };p1.x = 5;// error! 只读数组类型：let a: number[] = [1, 2, 3, 4];let ro: ReadonlyArray<number> = a;ro[0] = 12; // error!ro.push(5); // error!ro.length = 100; // error!a = ro; // error!// 最后⼀⾏可以看到就算把整个ReadonlyArray赋值到⼀个普通数组也是不可以的。

C#笔记2 —常量基本上和c语言中的常量类似，但有区别在const关键字的基础上，添加了readonly，readonly关键字在笔记中说明。

常量是固定值，程序执行期间不会改变。

常量可以是任何基本数据类型，比如整数常量、浮点常量、字符常量或者字符串常量，还有枚举常量。

常量可以被当作常规的变量，只是它们的值在定义后不能被修改。

整数常量、浮点常量、字符常量和c语言基本类似，这里就不详细展开字符串常量稍有不同：字符串常量是括在双引号"" 里，或者是括在@"" 里。

字符串常量包含的字符与字符常量相似，可以是：普通字符、转义序列和通用字符使用字符串常量时，可以把一个很长的行拆成多个行，可以使用空格分隔各个部分。

这里是一些字符串常量的实例。

下面所列的各种形式表示相同的字符串。

string a = "hello, world"; // hello, worldstring b = @"hello, world"; // hello, worldstring c = "hello \t world"; // hello worldstring d = @"hello \t world"; // hello \t worldstring e = "Joe said \"Hello\" to me"; // Joe said "Hello" to me string f = @"Joe said ""Hello"" to me"; // Joe said "Hello" to me string g = "\\\\server\\share\\file.txt"; // \\server\share\file.txtstring h = @"\\server\share\file.txt"; // \\server\share\file.txtstring i = "one\r\ntwo\r\nthree";string j = @"one //说明可以换行twothree";然后c#中还有string类型，和c++类似的。

js中readonly用法JS中的readonly用法JavaScript（简称JS）是一种广泛使用的脚本语言，用于在网页上实现交互效果。

JS具有很多特性和关键字，其中之一就是readonly。

在本文中，我们将详细探讨JS中readonly的用法以及如何正确使用它。

1. readonly的定义和作用readonly是JS中用于定义只读属性或只读变量的关键字。

它用于限制对变量或对象属性的赋值操作，从而保护数据的完整性。

只读属性或变量意味着它们的值无法被修改，只能读取。

2. 只读属性和只读变量的定义和声明方式在JS中，有两种方式来声明和定义只读属性和变量：使用const关键字和使用Object.defineProperty()方法。

a. 使用const关键字const关键字用于声明只读变量。

一旦变量被声明为只读，就无法修改其值。

例如：const PI = 3.14; 声明一个只读变量PI，其值为3.14PI = 3.14159; 报错，无法修改只读变量的值b. 使用Object.defineProperty()方法Object.defineProperty()方法可以用来定义只读属性。

该方法接受三个参数：要定义属性的对象、属性的名称和属性描述符。

其中，属性描述符是一个包含属性特性的对象，其中之一是writable，将其设置为false可以使属性变为只读。

例如：var person = {};Object.defineProperty(person, 'name', {value: 'John', 属性值writable: false, 设置属性为只读enumerable: true, 可枚举configurable: true 可配置}); = 'Mike'; 报错，无法修改只读属性的值3. 只读属性和只读变量的应用场景只读属性和变量通常用于存储不希望被修改的常量或一次性赋值的值。

c#面试问题及答案c#面试问题及答案(一)以下哪些可以作为接口成员?(多选) ( abde )a.方法b.属性c.字段d.事件e.索引器f.构造函数g.析构函数.以下关于ref和out的描述哪些项是正确的?(多选) (acd)a.使用ref参数，传递到ref参数的参数必须最先初始化。

b.使用out参数，传递到out参数的参数必须最先初始化。

c.使用ref参数，必须将参数作为ref参数显式传递到方法。

d.使用out参数，必须将参数作为out参数显式传递到方法。

.访问范围限定于此程序或那些由它所属的类派生的类型是对以下哪个成员可访问性含义的正确描述?(b)a.publicb.protectedc.internald.protected internal16.class class1{private static int count = 0;static class1(){count++;}public class1(){count++;}}class1 o1 = new class1();class1 o2 = new class1();请问，o1.count的值是多少?( c ) a.1 b.2 c.3 d.4.abstract class baseclass{public virtual void methoda() {}public virtual void methodb() {}}class class1: baseclass{public void methoda(string arg) {}public override void methodb(){}}class class2: class1{new public void methodb(){}}class mainclass{public static void main(string[] args) {class2 o = new class2();console.writeline(o.methoda());}}请问，o.methoda调用的是: ( a )a.baseclass.methodab.class2.methodac.class1.methodad.都不是.请叙述属性与索引器的区别。

readonly方法【原创版3篇】目录（篇1）I.引言A.readonly方法的定义B.readonly方法在编程中的重要性II.readonly方法的原理A.readonly方法的实现方式B.readonly方法的限制和缺点III.readonly方法的应用场景A.数据库操作中的readonly方法B.业务逻辑中的readonly方法C.性能优化中的readonly方法IV.readonly方法的优缺点A.readonly方法的优点B.readonly方法的缺点V.总结A.readonly方法的重要性和局限性B.readonly方法在编程中的实际应用案例正文（篇1）一、引言readonly方法是一种只读方法，不允许在方法内部修改数据。

在编程中，使用readonly方法可以提高代码的可读性和安全性，防止代码意外修改数据。

本文将介绍readonly方法的原理和应用场景。

二、readonly方法的原理readonly方法通过在方法内部对数据使用const或readonly关键字进行声明，从而限制方法的修改行为。

例如，在C#中，可以使用readonly 修饰符来声明只读属性。

readonly方法的实现方式取决于编程语言和具体应用场景。

三、readonly方法的应用场景1.数据库操作中的readonly方法：在数据库操作中，可以使用readonly方法来确保查询结果不会被修改。

例如，可以使用readonly方法来查询数据表中的数据，并将其作为参数传递给其他方法。

2.业务逻辑中的readonly方法：在业务逻辑中，可以使用readonly 方法来确保代码不会意外修改数据。

例如，可以使用readonly方法来获取用户信息，并将其用于验证用户权限。

3.性能优化中的readonly方法：在某些情况下，可以使用readonly 方法来提高代码的性能。

例如，可以使用readonly方法来获取全局变量或常量值，从而避免频繁的内存分配和数据复制。

readonly关键字的⽤法readonly 关键字是可以在字段上使⽤的修饰符。

当字段声明包括 readonly 修饰符时，该声明引⼊的字段赋值只能作为声明的⼀部分出现，或者出现在同⼀类的构造函数中。

在此⽰例中，字段year的值⽆法在ChangeYear⽅法中更改，即使在类构造函数中给它赋了值。

1. class Age2. {3. readonly int _year;4. Age(int year)5. {6. _year = year;7. }8. void ChangeYear()9. {10. //_year = 1967; // Compile error if uncommented.11. }12. }13.14.只能在下列上下⽂中对 readonly 字段进⾏赋值：当在声明中初始化变量时，例如：public readonly int y = 5;对于实例字段，在包含字段声明的类的实例构造函数中；或者，对于静态字段，在包含字段声明的类的静态构造函数中。

也只有在这些上下⽂中，将readonly字段作为或参数传递才有效。

说明readonly 关键字与关键字不同。

const 字段只能在该字段的声明中初始化。

readonly 字段可以在声明或构造函数中初始化。

因此，根据所使⽤的构造函数，readonly 字段可能具有不同的值。

另外，const 字段为编译时常数，⽽ readonly 字段可⽤于运⾏时常数，如下例所⽰：public static readonly uint timeStamp = (uint)DateTime.Now.Ticks;1. public class ReadOnlyTest2. {3. class SampleClass4. {5. public int x;6. // Initialize a readonly field7. public readonly int y = 25;8. public readonly int z;9.10. public SampleClass()11. {12. // Initialize a readonly instance field13. z = 24;14. }15.16. public SampleClass(int p1, int p2, int p3)17. {18. x = p1;19. y = p2;20. z = p3;21. }22. }23.24. static void Main()25. {26. SampleClass p1 = new SampleClass(11, 21, 32); // OK27. Console.WriteLine("p1: x={0}, y={1}, z={2}", p1.x, p1.y, p1.z);28. SampleClass p2 = new SampleClass();29. p2.x = 55; // OK30. Console.WriteLine("p2: x={0}, y={1}, z={2}", p2.x, p2.y, p2.z);31. }32. }33. /*34. Output:35. p1: x=11, y=21, z=3236. p2: x=55, y=25, z=2437. */38.39.在前⾯的⽰例中，如果使⽤这样的语句：p2.y = 66; // Error将收到编译器错误信息：The left-hand side of an assignment must be an l-value 这与尝试将值赋给常数时收到的错误相同。

C#中只读（readonly）字段的使⽤ 望⽂⽣义，只读字段，就是说在程序运转过程中，程序中能够读取这个字段的值，⽽不能修改它的值。

在C#中能够运⽤readonly关键词来界说⼀个只读字段。

在C#中运⽤只读字段主要有以下⼏个要点： （1）只读字段能够在界说的同时赋值或许在类的结构办法中给其赋值； （2）除了结构办法外，其他地⽅不能够修改只读字段的值； （3）只读字段的特点只能有get访问器，不能有set，这是显⽽易见的； 只读字段与常量的区别 常量（运⽤const关键字界说）只能在声明的同时初始化（赋值）。

readonly字段能够在声明或结构函数中初始化。

因此，根据所运⽤的结构函数，readonly字段或许具有不同的值。

readonly字段 只读字段运⽤举例： classStudent { readonlystringstudentId; stringstudentName; publicStudent(stringsId)//在结构函数中初始化只读字段 { this.studentId=sId; } publicStudent(stringsId,stringsName)//另外⼀个结构函数 { studentId=sId;studentName=sName; } publicvoidPrintInfo()//⼀般办法 { Console.WriteLine("学号：{0}",sId); Console.WriteLine("名字：{0}",sName); } publicstringStudentId//特点 { get{returnthis.sId;} set{sId=value;}//错误，只读字段不能有set } } 从上⾯的⽐如中能够看出，在不同的实例中只读字段的值能够不同。

也能够在多个结构函数中设置只读字段的值。