const和readonly区别

我们都知道，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较灵活。在应用上以static readonly代替const，以平衡const在灵活性上的不足，

同时克服编译器优化cosnt性能，所带来的程序集引用不一致问题；

文章2：

readonly和const比较

前天犯了个低级错误，是关于readonly的，总结了一下：

C#的readonly关键字只能在字段上面使用

public readonly TcpClient client;

不能在类，方法，属性上面使用readonly!!

顺便看了一下readonly和const的区别：

readonly和const都是用来标识常量的。

const可用于修饰class的field或者一个局部变量（local variable）；而readonly仅仅用于修饰class的field。

const常量的值必定在编译时就已明确并且恒定的；而readonly常量却有一点不同，那就是其值可以在运行时编译，当然，它也必须遵守作为常量的约束，那就是值必须恒定不变。const常量必须在声明的同时对其进行赋值，并且确保该值在编译时可确定并恒定；而readonly常量则可以根据情况选择在声明的同时对其赋予一个编译时确定并恒定的值，或者将其值的初始化工作交给实例构造函数（instant constructor）完成。如：public readonly string m_Now = DateTime.Now.ToString();，m_Now会随着运行时实际情况变化而变化。

const常量属于类级别（class level）而不是实例对象级别（instant object level），并且它不能跟static结合一起使用，该常量的值将由整个类的所有实例对象共同分享（详细论述参见后面的Remark区域）。

readonly常量既可以是类级别也可以是实例对象级别的，这取决于它的声明以及初始化工作怎么实施。readonly可以与static结合使用，用于指定该常量属于类级别，并且把初始化工作交由静态构造函数（static constructor）完成（有关如何把readonly常量声明为类级别或实例对象级别的论述清参见后面的Remark区域）。

能被const修饰声明为常量的类型必须是以下的基元类型（primitive type）：sbyte, byte, short, ushort, int, uint, long, ulong, char, float, double, float, bool, decimal, string。

object, 数组（Array）和结构（struct）不能被声明为const常量。

一般情况下，引用类型是不能被声明为const常量的，不过有一个例外：string。该引用类型const常量的值可以有两种情况，string或null。其实，string虽然是引用类型，但是.NET却对它特别处理，这种处理叫做字符串恒定性（immutable），使得string的值具有只读特性。有关字符串恒定性的内容，可以参考《Microsoft .NET框架程序设计（修订版）》。

Examples：

using System;

public class Order

{

public Order()

{

Guid guid = Guid.NewGuid();

ID = guid.ToString("D");

}

// 对于每一份订单，其订单序号都是实时确定的常量。

public readonly string ID;

public override string ToString()

{

return "Order ID: " + ID;

}

}

Explaintion：

如果结合数据库使用，ID field通常都会都会与某个表的主健（primary key）关联起来，如Orders表的OrderID。

数据库的主健通常采用以下三种方式：

自动递增值。你可以通过把DataColumn.AutoIncrement设定为true值来激活自动递增特性。唯一名称。这个是使用自己定义的算法来生成一个唯一序列号。

GUID（全局唯一标识符）。你可以通过System.Guid结构来生成GUID，如上例。

using System;

class Customer

{

public Customer(string name, int kind)

{

m_Name = name;

m_Kind = kind;

}

public const int NORMAL = 0;

public const int VIP = 1;

public const int SUPER_VIP = 2;

private string m_Name;

public string Name

{

get { return m_Name; }

}

private readonly int m_Kind;

public int Kind

{

get { return m_Kind; }

}

public override string ToString()

{

if(m_Kind == SUPER_VIP)

return "Name: " + m_Name + "[SuperVip]";

else if(m_Kind == VIP)

return "Name: " + m_Name + "[Vip]";

else

return "Name: " + m_Name + "[Normal]";

}

}

Remarks:

一般情况下，如果你需要声明的常量是普遍公认的并作为单个使用，例如圆周率，黄金分割比例等。你可以考虑使用const常量，如：public const double PI = 3.1415926;。如果你需要声明常量，不过这个常量会随着实际的运行情况而决定，那么，readonly常量将会是一个不错的选择，例如上面第一个例子的订单号Order.ID。

另外，如果要表示对象内部的默认值的话，而这类值通常是常量性质的，那么也可以考虑const。更多时候我们对源代码进行重构时（使用Replace Magic Number with Symbolic Constant），要去除魔数（Magic Number）的影响都会借助于const的这种特性。

对于readonly和const所修饰的变量究竟是属于类级别的还是实例对象级别的问题，我们先看看如下代码：

Using directives#region Using directives

using System;

using System.Collections.Generic;

using System.Text;

#endregion

namespace ConstantLab

{

class Program

{

static void Main(string[] args)

{

Constant c = new Constant(3);

Console.WriteLine("ConstInt = " + Constant.ConstInt.ToString());

Console.WriteLine("ReadonlyInt = " + c.ReadonlyInt.ToString());

Console.WriteLine("InstantReadonlyInt = " + c.InstantReadonlyInt.ToString());

Console.WriteLine("StaticReadonlyInt = " + Constant.StaticReadonlyInt.ToString());

Console.WriteLine("Press any key to continue");

Console.ReadLine();

}

}

class Constant

{

public Constant(int instantReadonlyInt)

{

InstantReadonlyInt = instantReadonlyInt;

}

public const int ConstInt = 0;

public readonly int ReadonlyInt = 1;

public readonly int InstantReadonlyInt;

public static readonly int StaticReadonlyInt = 4;

}

}

使用Visual C#在Main()里面使用IntelliSence插入Constant的相关field的时候，发现ReadonlyInt和InstantReadonlyInt需要指定Constant的实例对象；而ConstInt和StaticReadonlyInt却要指定Constant class（参见上面代码）。可见，用const或者static readonly 修饰的常量是属于类级别的；而readonly修饰的，无论是直接通过赋值来初始化或者在实例构造函数里初始化，都属于实例对象级别。

一般情况下，如果你需要表达一组相关的编译时确定常量，你可以考虑使用枚举类型（enum），而不是把多个const常量直接嵌入到class中作为field，不过这两种方式没有绝对的孰优孰劣之分。

using System;

enum CustomerKind

{

SuperVip,

Vip,

Normal

}

class Customer

{

public Customer(string name, CustomerKind kind)

{

m_Name = name;

m_Kind = kind;

}

private string m_Name;

public string Name

{

get { return m_Name; }

}

private CustomerKind m_Kind;

public CustomerKind Kind

{

get { return m_Kind; }

}

public override string ToString()

{

return "Name: " + m_Name + "[" + m_Kind.ToString() + "]";

}

}

然而，当这种结合使用枚举和条件判断的代码阻碍了你进行更灵活的扩展，并有可能导致日后的维护成本增加，你可以代之以多态，使用Replace Conditional with Polymorphism来对代码进行重构。（有关多态的详细介绍，请参见《今天你多态了吗？》一文。）Comments：

readonly field准确来说应该翻译成为“只读域”，这里是为了统一翻译用语才将它和const 两者所修饰的量都说成“常量”，希望没有引起误会。

===============================================================================

有时你不想在在程序运行时改变域，如运行时程序依靠的数据文件，一个math类的pi值，或者任何在程序运行时你不想改变的值。为了处理这种情况，c#中定义了两个近似的、相关的成员类型：contants和read-only域。

Constants域

从字面可以看出，常数（用关键字const表示）在应用程序运行期间保持不变。当定义某个事物为const时记住两个规则：第一，定义成常数的成员的值是在编译时设置的——或者是由编程者指定，或者是由编译器设置缺省值；第二，一个常数成员的值必须被写为一个字面常数。

为了定义一个常数域，在要定义的成员前使用一个const关键字，如下所示：

using System;

class MagicNumbers

{

public const double pi = 3.1415;

public const int answerToAllLifesQuestions = 42;

}

class ConstApp

{

public static void Main()

{

Console.WriteLine("pi = {0}, everything else = {1}",

MagicNumbers.pi, MagicNumbers.answerToAllLifesQuestions);

}

}

请注意这个代码的一个关键点——不必在客户端实例化MagicNumbers类，因为const成员缺省是静态的。为了更清楚的展示它，我们列出这两个域在MSIL中生成时的情况：

answerToAllLifesQuestions : public static literal int32 = int32(0x0000002A)

pi : public static literal float64 = float64(3.1415000000000002)

Read-only 域

使用const域是非常有用的，因为他清楚的表明了编程者的意图。然而，这只能用于在编译时已经知道值的情况下。所以，当一个域只有在运行时才能知道值而且一旦初始化以后值便不能改变的情况下，编程者该怎么办呢？C#语言的设计者用Read-only域的办法解决了这个问题（在其他语言中一般不会处理）。

当你用readonly关键字定义了一个域时，你只能在一个地方设置这个域的值——构造函数。以后，域的值便不能被自身类或者使用这个类的客户改变。让我们看一个图形应用程序记录屏幕分辨率的例子。你不能用const处理这个问题，因为应用程序直到运行时才能确定终端用户的屏幕分辨率，所以你必须使用这样的代码：

using System;

class GraphicsPackage

{

public readonly int ScreenWidth;

public readonly int ScreenHeight;

public GraphicsPackage()

{

this.ScreenWidth = 1024;

this.ScreenHeight = 768;

}

}

class ReadOnlyApp

{

public static void Main()

{

GraphicsPackage graphics = new GraphicsPackage();

Console.WriteLine("Width = {0}, Height = {1}",

graphics.ScreenWidth,

graphics.ScreenHeight);

}

}

猛一看，这个代码正是我们需要的。然而，还有一点小问题：我们定义的readonly域是一个实例域，这意味着是用户在使用域之前必须先实例化类。这可能也不是什么问题，甚至这正是你想做的——在实例化类的时候正可以初始化readonly域的值。但如果你想要一个被定义成静态的、能在运行时被初始化的常数时该怎么办呢？这时，我们可以定义一个带static和readonly修饰符的域。然后，创建一个构造函数的特殊类型——static constructor。静态函数可以用来初始化static域、readonly域或其他的域。现在我们改变先前的例子，给屏幕分辨率域加上static和readonly，并且增加一个静态构造函数。

using System;

class GraphicsPackage

{

public static readonly int ScreenWidth;

public static readonly int ScreenHeight;

static GraphicsPackage()

{

// Code would be here to

// calculate resolution.

ScreenWidth = 1024;

ScreenHeight = 768;

}

}

class ReadOnlyApp

{

public static void Main()

{

Console.WriteLine("Width = {0}, Height = {1}", GraphicsPackage.ScreenWidth,

GraphicsPackage.ScreenHeight);

}

}

常见标点符号的用法归纳

常见标点符号的用法归纳 一、常见的标点符号 标点符号是辅助文字记录语言的符号，是书面语的有机组成部分，用来表示停顿、语气以及词语的性质和作用。常见的标点符号有16种，分为点号和标号两大类。 1、点号 点号的作用在于点断，主要表示说话时的停顿和语气。点号又分为句内点号和句外点号。句内点号用在句内，表示句内各种不同性质的停顿，有顿号(、)、逗号（，）、分号（；）、冒号（：）4种；句末点号用在句末，表示句末的停顿，有句号（。）、问号（？）、叹号（！）3种。 各种点号的停顿时间的长短排列如下：、﹤，﹤：；﹤。？！ 2、标号 标号的作用在于标明，主要标明语句的性质和作用。常见的标号有9种，即：引号（“”）、括号（（））、破折号（——）、省略号（……）、着重号（.）、连接号（—）、间隔号（.）、书名号（《》）和专名号（____） 二、常见标点符号的用法归纳 1、顿号（句子内部并列词语或短语的停顿） 1) 数字并列表省略时用顿号，表概数时不用顿号。 如：三年级二、三班的同学今天下午劳动两三节课。 （表省略）（表概数） 2）停顿较短的并列成分（如：锅碗瓢盆交响曲）或集合词语（如：工农兵中小学生公安干警）之间不用顿号。 3）并列词语之间带有“啊”“哇”“啦”“呀”等语气助词时不用顿号，改用逗号。 如：妈妈经常给我讲她纺线啊，织布啊，做军鞋啊。 4）并列的分句做句子的成分时，使用顿号；各自独立成句时则使用逗号。 如：难道说工期紧、任务重、难度大，就可以不顾工程的质量而随意改变设计方案吗？（作句子的成分） 今年春季，这个省……改道工程，任务重，工程难，规模大。 （各自独立成句） 5）如果大的并列成分里包含着小的并列成分时，那么大并列用逗号，小并列用顿号。 如：克隆羊、克隆牛的诞生，“神舟的五号的发射、回收，标示着我国科学发展的新水平。 小并列大并列小并列 2、逗号（略） 3、分号（复句内部并列分句的停顿） 1）复句内并列分句的停顿使用分号。 如：如实地反映客观事物，反映正确就是客观的；反之，就是不科学的。（前后正反对照，构成并列，当使用分号）

const int

const int* a = &b 和const* int a = &b的区别收藏 如果const关键字不涉及到指针，我们很好理解，下面是涉及到指针的情况： int b = 500; const int* a = &b; [1] int const *a = &b; [2] int* const a = &b; [3] const int* const a = &b; [4] 如果你能区分出上述四种情况，那么，恭喜你，你已经迈出了可喜的一步。不知道，也没关系，我们可以参考《Effective c++》Item21上的做法，如果const位于星号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于星号的右侧，const就是修饰指针本身，即指针本身是常量。因此，[1]和[2]的情况相同，都是指针所指向的内容为常量（const放在变量声明符的位置无关），这种情况下不允许对内容进行更改操作，如不能*a = 3 ；[3]为指针本身是常量，而指针所指向的内容不是常量，这种情况下不能对指针本身进行更改操作，如a++是错误的；[4]为指针本身和指向的内容均为常量。另外const 的一些强大的功能在于它在函数声明中的应用。在一个函数声明中，const 可以修饰函数的返回值，或某个参数；对于成员函数，还可以修饰是整个函数。有如下几种情况，以下会逐渐的说明用法： A& operator=(const A& a); void fun0(const A* a ); void fun1( ) const; // fun1( ) 为类成员函数 const A fun2( ); --------------------------------------------------------------------------------------------------------------------------------------------- const int * pi 、int const * pi与int * const pi及其操作 （本贴已经做了重大修改） 1 从const int i 说起

倒装用法归纳(部分-全部)

Unit5 Grammar Inversion（倒装） 英语部分倒装用法归纳（Partial Inversion） 1. 否定副词位于句首时的倒装 在正式文体中，never, seldom, rarely, little, hardly, scarcely, no sooner, no longer, nowhere 等含有否定意义的副词若位于句首，则其后要用部分倒装： I shall never forgive him. / Never shall I forgive him. 我永远不会宽恕他。 He seldom goes out for dinner. / Seldom does he go out for dinner. 他很少出去吃饭。 She hardly has time to listen to music. / Hardly does she have time to listen to music. 她几乎没时间听音乐。 He little realizes how important this meeting is. / Little does he realize how important this meeting is. 他不甚明白这个会议的重要性。 We had no sooner reached the airport than the plane took off. / No sooner had we reached the airport than the plane took off. 我们刚到机场,飞机就起飞了。 【注意】 (1)对于not…until句型，当not until…位于句首时，其后的主句要用倒装语序： He didn’t leave the r oom until the rain stopped. / Not until the rain stopped did he leave the room. 雨停了之后他才离开这房间。 (2)某些起副词作用的介词短语，由于含有否定词，若位于句首，其后要用部分倒装： On no accounts must this switch be touched. 这个开关是绝不能触摸的。 In [Under] no circumstances will I lend money to him.无论如何我也不会再借钱给他了。 但是，in no time(立即，马上)位于句首时，其后无需用倒装语序： In no time he worked out the problem. 他马上就算出了那道题。 2.“only+状语”位于句首时的倒装 当一个状语受副词only的修饰且置于句首时，其后用部分倒装语序： Only then did he realize that he was wrong. 到那时他才意识到他错了。 Only in this way are you able to do it well. 你只有用这种方法才能把它做好。 Only when he returned home did he realize what had happened. 当他回到家里时，才知道出了什么事。 3. “so+adj. / adv.”位于句首时的倒装 副词so后接形容词或副词位于句首时，其后用部分倒装： So cold was the weather that we had to stay at home. 天气太冷，我们只好呆在家里。 So fast does light travel that we can hardly imagine its speed. 光速很快，我们几乎没法想像它的速度。 So sudden was the attack that we had no time to escape. 袭击来得非常突然，我们来不及逃跑。 4.“so+助动词+主语”倒装 当要表示前面提出的某一肯定的情况也同样适合于后者，通常就要用“So+助动词+主语”这种倒装结构： You are young and so am I. 你年轻，我也年轻。 She likes music and so do I. 她喜欢音乐，我也喜欢。

const,static,extern用法总结

--------------------------CONST--------------------------------------- const应用: 一、对于基本声明 const int r=100;//标准const变量声明加初始化，编译器经过类型检查后直接用100在编译时替换。 二、对于指针 1. int x=10; const int *r=&x; //指针指向的内容是常量,r指向的内容不能够通过r改变,但如果是非const,内容可以通过自己改变,而且r指针可以改变,可以指向其它的整形. //*r=*r+1;NO //x++;YES //r=&y;YES 2. int const *r=&x; 与1完全相同 3. int * const r=&x; //指针指向是常量,不能修改去指向其它内容,但指向的内容可以修改 //r=&y;NO //*r=*r+1;YES //x++;YES 4.const int * const r=&x; //综合1、3用法，r是一个指向常量的常量型指针,指针指向不能改变,指针内容不能改变,内容可以自身改变 //r=&y;NO //*r=*r+1;NO //x++;YES 三、对于类型检查 可以把非const对象赋予const指针,这样就不能改变.但是不能把const赋给非const,除非先强制转换 const int x=100; int *p=(int*)&x; *p++; 四、对于函数 1.void Fuction1(const int r); //此处为参数传递const值，意义是变量初值不能被函数改变 2.const int Fuction1 (int); //此处返回const值，意思指返回的原函数里的变量的初值不能被修改，但是函数按值返回的这个变量被制成副本，能不能被修改就没有了意义，它可以被赋给任何的const或非const类型变量，完全不需要加上这个const关键字。 3.Class CX; //内部有构造函数，声明如CX(int r =0) CX Fuction1 () { return CX(); } const CX Fuction2 () { return CX(); } Fuction1() = CX(1); //没有问题，可以作为左值调用 Fuction2() = CX(1); //编译错误，const返回值禁止作为左值调用。 4.函数中指针的const传递和返回： int F1 (const char *pstr); //作为传递的时候使用const修饰可以保证不会通过这个指针来修改传递参数的初值 const char *F2();//意义是函数返回的指针指向的对象是一个const对象，它必须赋给一个同样是指向const对象的指针 const char * const F3(); //比上面多了一个const，这个const的意义只是在他被用作左值时有效，它表明了这个指针除了指向const对象外，它本身也不能被修改，所以就不能当作左值来处理。 五、对于类 1.首先，对于const的成员变量，只能在构造函数里使用初始化成员列表来初始化，试图在构造函数体内进行初始化const成员变量会引起编译错误。初始化成员列表形如：X:: X ( int ir ): r(ir) {} //假设r是类X的const成员变量 注意：类的构造和析构函数都不能是const函数。 2.建立了一个const成员函数，但仍然想用这个函数改变对象内部的数据。(函数不能修改类的数据成员)

IF的用法

IF的用法 if是英语中出现频率很高的连词，并且它的用法也很多。学生感到很难掌握，为了让同学们更多更好地了解其用法及其语法功能。现结合教学中遇到的情况，予以归纳，以供参考。 一、if作为连词，引导条件状语从句，它表示的意思是“假如”“如果”等。在复合句中如果主句用将 来时，则if引导的状语从句用一般现在时。例如： 1. If itdoesn’train, we will go to the park next Sunday. 如果天不下雨，下周星期天我们将去公园。 2. If you ask him，he will help you．如果你求他，他将会帮助你。 二、if还可以引导让步状语从句。这时if当作“即使是”，“虽说”解。例如： 1. If she’s poor，at least she’s honest．虽说她很穷，但至少她还是诚实的。 2. If I am wrong，you are wrong，too．即使说我错了，那么你也不对。 3. I’ll do it, even if it takes me all the afternoon．虽然会花费我一下午的时间，我还是要做这事。 三、if作为连词还可以引导宾语从句。引导宾语从句时和whether意思相同。例如： 1. Lily asked if ／whether she liked it. 莉莉问她是否喜欢它。 2. She asked if ／whether they had a cotton one．她问是否他们有一件棉织的。 四、if引导时间状语从句，当if做“当”或“无论何时”解而不含有条件之义时，if从句中的时态与主句中的时态相同。例如： 1. If youmix yellow and blue，you get green．你将黄色与蓝色混合，便会得到绿色。 2. If she wants the servant，she rings the bell．每当她需要仆人时，她便按铃。 五、if后接否定动词，用于感叹句中，表示沮丧、惊奇等。例如： I. Well，if I haven’t left my false teeth at home!真倒霉，我把假牙丢在家里了! 2. And if he didn’t try to kn ock me down!(What do you think he did!He tried knock me down!)你猜他想做什么?他想把我撞倒! 六、用于虚拟语气中，if从句中用过去式，表示不可能实现，大概不会实现或提出作为考虑的假定条件。例如： 1. If you were a bird, you could fly.假使你是只鸟，你便会飞了。 2. If I asked him(if I were to ask him) for a loan，would he agree?如果我向他借贷，他会答应吗? 另外，if从句中用过去完成式，表示过去未实现的条件(例如由于不可能实现或某人之未能实行)。例如： 1. If they had startedearlier，they would have arrivedin time．要是他们早些动身，他们便可及时到达了。 2. If they had not started when they did，they would not be here now．如果他们那时不动身，现在他们就不会在此地了。 第三，在文学体栽中，if有时可省略，然后将主语与所用的限定动词(尤其是were，had，should)倒置。例如： 1. Should it (=if it should)be necessary，I will go. 倘若有必要，我会去的。 2. Were I(=if I were) in your place，I would do the same ．如果我处于你的位置，我也会这样干的。 3. Had I(=if I had)known earlier，I would come．如果我早一点知道，我就会来。 七、if与其它一些介词的连用。

.net高级工程师面试题

.net软件工程师面试题 基础题： 1.简述string[]、ArrayList、List的区别。 数组： 优点： o数组在内存中是连续存储的，索引速度非常快； o赋值和修改元素也很简单； 不足： o两个数据之间插入数据比较麻烦； o声明数组的时候，必须指明数组的长度，数组长度过长会造成内存浪费，数组的长度过短，会造成数据溢出错误。 ArrayList： 优点： https://www.sodocs.net/doc/2f3718297.html, framework 提供的用于数据存储和检索的专用类 o大小依据存储的数据来动态扩展和收缩 o继承IList，可以方便的进行数据的添加、插入和删除 缺点： o允许插入不同类型的数据，都当做object类型处理 o数据处理时可能出现类型不匹配的错误

o存在装箱（值=》引用）拆箱的操作，会带来很大的性能损耗 List： 优点： o声明List集合时，需要声明集合内数据的对象类型 o避免了类型安全问题和装箱拆箱的性能问题 2.简述装箱和拆箱操作中的性能损耗是如何产生的。 3.简述对https://www.sodocs.net/doc/2f3718297.html,中的事件机制的理解。 4.在一个https://www.sodocs.net/doc/2f3718297.html,的三层结构系统中，以登录操作为例，简述在各层中如何组织代码。 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工作的原理。为了实现这个原理，GC有多种算法。比较常见的算法有Reference Counting，Mark Sweep，Copy Collection等等。目前主流的虚拟系统.NET CLR，Java VM和Rotor都是采用的Mark Sweep算法。

标点符号要点归纳及用法

标点符号 知识要点： 标点符号是书面语言的有机组成部分，是书面语言不可缺少的辅助工具。标点符号的主要作用有三点：1．表示停顿；2．表示语气；3．表示词语的性质和作用。现在通行的标点符号有l6种，分为点号和标号两大类。点号包括：顿号(、)、逗号(，)、分号(；)、句号（。）、问号(?)、叹号(!)和冒号(：)。而标号则包括：破折号(——)、括号(( ))、省略号（……)、书名号(《》)、引号(“”)等。 答题注意： 1、标点符号是书面语里用来表示停顿、语调以及词语性质和作用的符号。虽然它只是一个小符号，作用却非常大，一定要认真读题，什么样的语气就相应地用什么样的标点符号。 2、给一段话加标点，难度较大，首先要认真地读这一段话看一看一共有几句话．每句话是什么意思，使用的是怎样的语气，然后再动手加标点符号，最后再读一读，检查标点符号使用得是否恰当、正确。 方法指津： 小学5～6年级与初中阶段要求掌握的常用标点符号大体一致，只是题型有变化，难度有所提高。在解题时要注意以下几个方面： 1．建立标点符号用法表，熟悉掌握常用标点符号的用法。无论是主观题，还是客观题，熟悉并掌握常用标点符号的用法，是准确解答标点符号题的基础。 2．熟记各种标点符号的位置，规范使用标点符号。如：标点符号由点号与标号组成，点号分为句中点号和句末点号。其中句中点号由顿号、分号、逗号组成，这三种点号均表示一个句子内部的停顿。顿号表示词语之问的停顿，一般应是两个或以上的词语之间，停顿时间最短；逗号表示一个句子内的一般性停顿，可以是词语、短语或句子内部的分句，停顿时问稍长；分号则用于复句内部并列的分句之间或排比句中并列的分句之间，停顿的时间比逗号更长。运用时，应先用停顿短的逗号，再用停顿长的分号，不能乱了秩序，只有在分行列举的各项之间，才能直接用分号。又如：七种点号都占一个字的位置，通常点在紧靠文字右边偏下，不能用在一行之首，引号、括号、书名号都标在文字前后，各占一个字位置。破折号和省略号占两个字的位置，都标在正中。连接号占一个字的位置，着重号标在字的下面，间隔号写在格子正中。知晓了这些内容，才能规范使用标点符号，为识破标点使用的正误打下基础。 3．总结、积累标点符号使用的特点、规律，以简驭繁。事物总是有规律的，标点符号也不例外。如冒号的使用就有以下规律：一是冒号不能连用，在同一句子中，冒号一般只用一个，否则便会面目不清，必须将其中一个改为逗号；二是冒号后面揭示范围不清楚。特别是冒号与引号连用时，一定要分清冒号提示的范围，如果提示的是全部，句末的句号应在引号之外；如果提示的仅引号内的部分，那么或将冒号改为逗号，或将逗号改为引号内句号。 4．对易错标点要反复训练，定期复习巩固。有些标点在使用中常常被误用，如顿号、分号、逗号的误用，冒号的误用，句号、叹号、问号的误用等。还有不同标点间的连用、套用容易出错，比如引号的使用．因为引语与“某某说”之间位置不同，标点符号也就不同。“说”在前，“引语”在后，“说”后用冒号；“说”在“引语”中间，“说”后用逗号；“说”在“引语”之后，“说”后用句号。如果区分不明，则易导致标号误用。因此，我们在平时的学习实践中一定要反复训练，不断强化巩固。

C++中const用法详解

const是一个C语言的关键字，它限定一个变量不允许被改变。使用const在一定程度上可以提高程序的安全性和可靠性。类型声明中const用来修饰一个常量，有如下两种写法，那么，请问，下面分别用const限定不可变的内容是什么? 1)、const在前面 const int nValue；//nValue是const const char *pContent; //*pContent是const, pContent可变 const (char *) pContent;//pContent是const,*pContent可变 char* const pContent; //pContent是const,*pContent可变 const char* const pContent; //pContent和*pContent都是const 2)、const在后面，与上面的声明对等 int const nValue；// nValue是const char const * pContent;// *pContent是const, pContent可变 (char *) const pContent;//pContent是const,*pContent可变 char* const pContent;// pContent是const,*pContent可变 char const* const pContent;// pContent和*pContent都是const 答案与分析： const和指针一起使用是C语言中一个很常见的困惑之处，在实际开发中，特别是在看别人代码的时候，常常会因为这样而不好判断作者的意图，下面讲一下我的判断原则：当const所在代码段中不包含括号时，沿着*号划一条线，如果const 位于*的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于*的右侧，const就是修饰指针本身，即指针本身是常量。你可以根据这个规则来看上面声明的实际意义，相信定会一目了然。

英语中if的用法

精心整理1.(表示条件)如果,主句用将来时，if从句用现在时表示将来Hewillcomeifyouinvitehim. 如果你请他,他会来的。 2.(表示虚拟)假如,要是 1 a. b. 句型：条件从句主句 过去完成时should(would)have+过去分词 Ifshehadworkedharder,shewouldhavesucceeded. Thericewouldnothavebeenburntifyouhadbeenmorecareful.

IfmylawyerhadbeenherelastSaturday,hewouldhavepreventedmefromgoing. Ifhehadcomeyesterday,Ishould/wouldhavetoldhimaboutit. 含义：Hedidnotcomeyesterday,soIdidnottellhimaboutit. c. were+ Ifyousucceeded,everythingwouldbeallright. Ifyoushouldsucceed,everythingwouldbeallright. Ifyouweretosucceed,everythingwouldbeallright.

3.是否=whether连接宾语从句 Iwonderifsheisill. 不知她是否病了。 连接词conj. 1.( 2.( 3.( 4.是否 不知她是否病了。 5.(表示因果关系)每一次...的时候(总是会) IfIfeelanydoubt,Iinquire. 我一感到有疑问就随时询问。 if作为连词的时候，一般用于条件状语从句或者是宾语从句或让步状语从句

const和readonly区别

我们都知道，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较灵活。在应用上以static readonly代替const，以平衡const在灵活性上的不足， 同时克服编译器优化cosnt性能，所带来的程序集引用不一致问题； 文章2：

what用法总结

what用法总结 温馨提示:what用法很多，对专升本有用的我已经用红色字体显示，由于部分同学考研可能要用到，把几乎所有用法都附上了。 what的用法是各种类型英语科测试的热点，what的用法灵活多变，出题花样翻新，只有对其有一个全面的掌握，才能灵活运用。本文以2006年的两道高考题为例，总结what的用法，希望能让同学们对它有一个全面的了解。 The shopkeeper did not want to sell for _____ he thought was not enough.（2006山东卷第26题） A. where B. how C. what D. which 答案：C Great changes have taken place in that school. It is no longer _____ it was 20 years ago, _____ it was so poorly equipped.（2006安徽卷第32题） A. what; when B. that; which C. what; which D. which; that 答案：A. 上述两题中的what都是关系代词，一般含义是“the thing that”。第一题中what 的意思是“the price that”，引导宾语从句；第二题中what的意思是“the school that”，引导的是表语从句。what的其他结构还有：

一、what + little 在此结构中，little是名词，强调某种东西“虽少但已是全部”，至于被强调的是什么，只能凭借上下文来判断。 例如：（1）What little he said on the subject was full of wisdom. （2）She saved what little of the money she could out of her slim salary to help her brother go to school 二、what little + 名词 此结构为上一结构的延伸，所不同的是，little在这里不是名词，而是形容词了。 例如：（1）He gave me what little money he had about him. （2）My father spent what little spare time he had in writing. 三、what + few + 名词 当被修饰的名词为可数名词时，little应换成few，含义为“仅有的几个”。 例如：（1）What few friends I have are very kind to me. （2）I will lend you what few books I can spare.

C基础知识25个常见问题

C# 基础知识 25个常见问题（1） 2007-04-12 16:53 当初学 C# 时是找个人大概问了一下数据类型和分支语句就开始做项目了。这两天又全面的看了一下相关的基础知识（学而时习之嘛），总结了25个问题： 1.静态变量和非静态变量的区别？ 2.const 和 static readonly 区别？ 3.extern 是什么意思？ 4.abstract 是什么意思？ 5.internal 修饰符起什么作用？ 6.sealed 修饰符是干什么的？ 7.override 和 overload 的区别？ 8.什么是索引指示器？ 9.new 修饰符是起什么作用？ 10.this 关键字的含义？ 11.可以使用抽象函数重写基类中的虚函数吗？ 12.密封类可以有虚函数吗？ 13.如果基类中的虚属性只有一个属性访问器，那么继承类重写该属性后可以有几个属性访问器？如果基类中有 get 和 set 两个呢？ 14.abstract 可以和 virtual 一起使用吗？可以和 override 一起使用吗？ 15.接口可以包含哪些成员？ 16.类和结构的区别？ 17.接口的多继承会带来哪些问题？ 18.抽象类和接口的区别？ 19.别名指示符是什么？ 20.如何释放非托管资源？ 21.P/Invoke是什么？ 22.StringBuilder 和 String 的区别？ 23.explicit 和 implicit 的含义？ 24.params 有什么用？ 25.什么是反射？ 以下是我做的一份参考答案（C# 语言范畴之内），如果有不准确、不全面的，欢迎各位朋友指正！ 1.静态变量和非静态变量的区别？ 答：静态变量： 静态变量使用 static 修饰符进行声明 在所属类被装载时创建 通过类进行访问

partly的用法总结大全

partly的用法总结大全 partly的意思是什么呢?partly的用法是怎样的呢，今天给大家带来了parcel的用法,希望能够帮助到大家，一起来学习吧。 partly的意思 adv. 在一定程度上,部分地,不完全地,半 partly用法 partly可以用作副词 partly用作副词指“部分地,不完全地”,修饰形容词常置于其前。常用于partly...partly...结构。 partly无比较级和最高级形式。 partly用作副词的用法例句 You have introduced a partly random component.你介绍了一个在一定程度上属于偶然的成分。 The transformation is partly due to demographics.这一变化一定程度上是源于人口的变化。 Their energy is partly dissipated.它们的能量被部分地消耗掉。

partly双语例句 1.This is partly a political and partly a legal question.这个问题部分是政治问题, 部分是法律问题。 2.Farming is partly subsidised by the government.农业得到政府的部分资助。 3.Their company sell partly to foreign markets.他们公司部分向国外市场销售。 4.Leaves scale-like, distichous, equitant, sometimes linear or partly linear.叶鳞片状，2列，套折，有时线形的或部分线形。 5.The delay is partly explicable by the road works.延误的部份原因是道路施工。 6.I believe what he has said is partly true.我相信他刚才说的话一部分是真实的。 7.The sale of ice cream is partly determined by the weather.冰淇淋的销量部分取决于天气。 8.Maturate partly in French oak barrique and partly in Slovenian oak casks for about 12-15 months.之后，一部分在法国橡木桶里醇化，一部分在斯洛文尼亚橡木桶里醇化，大致需要12-15个月。

const变量使用总结

或许还有不少人对于const修饰符理解的并不深刻，都只是停留在一个比较浅的层面上，仅仅是在读别人代码的时候看到了const修饰符的使用，自己的写代码的过中从未使用过，所以自然对于const修饰符比较陌生。那么到底什么是const 修饰符，我们在自己编写C语言代码的过程中又该如何有效的使用const修饰符呢，现在让我们来学习下const修饰符的使用。 const在C语言中算是一个比较新的描述符，我们称之为常量修饰符，即就是说其所修饰的对象为常量。当你代码中想要设法阻止一个变量被改变，那么这个时候可以选择使用const关键字。在你给一个变量加上const修饰符的同时，通常需要对它进行初始化，在之后的程序中就不能再去改变它。 可能有的人会有一个疑问，我们不是有在C中有预处理指令#define VariableNameVariableValue可以很方便地进行值替代，干嘛还要引入const修饰符呢?!这是因为预处理语句虽然可以很方便的进行值得替代，但它有个比较致命的缺点，即预处理语句仅仅只是简单值替代，缺乏类型的检测机制。这样预处理语句就不能享受C编译器严格类型检查的好处，正是由于这样，使得它的使用存在着一系列的隐患和局限性。 在讲解const修饰符之前，我们在此首先给出const修饰符的几个典型作用： 1. const类型定义：指明变量或对象的值是不能被更新,引入目的是为了取代预编译指令 2. 可以保护被修饰的东西，防止意外的修改，增强程序的健壮性; 3. 编译器通常不为普通const常量分配存储空间，而是将它们保存在符号表中，这使得它成为一个编译期间的常量，没有了存储与读内存的操作，使得它的效率也很高。 4. 可以节省空间，避免不必要的内存分配。 接下来看看具体的使用。 一、const修饰符在函数体内修饰局部变量。 constint n=5; 和 intconst n=5;

C++ const 精髓

1.const的用法： 看到const 关键字，C++程序员首先想到的可能是const 常量。这可不是良好的条件反射。如果只知道用const 定义常量，那么相当于把火药仅用于制作鞭炮。const 更大的魅力是它可以修饰函数的参数、返回值，甚至函数的定义体。 const 是constant 的缩写，“恒定不变”的意思。被const 修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。所以很多C++程序设计书籍建议：“Use const whenever you need”。 1.用const 修饰函数的参数 如果参数作输出用，不论它是什么数据类型，也不论它采用“指针传递”还是“引用传递”，都不能加const 修饰，否则该参数将失去输出功能。const 只能修饰输入参数： 如果输入参数采用“指针传递”，那么加const 修饰可以防止意外地改动该指针，起到保护作用。 例如StringCopy 函数： void StringCopy(char *strDestination, const char *strSource); 其中strSource 是输入参数，strDestination 是输出参数。给strSource 加上const修饰后，如果函数体内的语句试图改动strSource 的内容，编译器将指出错误。 如果输入参数采用“值传递”，由于函数将自动产生临时变量用于复制该参数，该输入参数本来就无需保护，所以不要加const 修饰。 例如不要将函数void Func1(int x) 写成void Func1(const int x)。 同理不要将函数void Func2(A a) 写成void Func2(const A a)。其中A 为用户自定义的数据类型。 对于非内部数据类型的参数而言，象void Func(A a) 这样声明的函数注定效率比较底。因为函数体内将产生A 类型的临时对象用于复制参数a，而临时对象的构造、复制、析构过程都将消耗时间。 为了提高效率，可以将函数声明改为void Func(A &a)，因为“引用传递”仅借用一下参数的别名而已，不需要产生临时对象。但是函数void Func(A & a) 存在一个缺点： “引用传递”有可能改变参数a，这是我们不期望的。解决这个问题很容易，加const修饰即可，因此函数最终成为void Func(const A &a)。 以此类推，是否应将void Func(int x) 改写为void Func(const int &x)，以便提高效率？完全没有必要，因为内部数据类型的参数不存在构造、析构的过程，而复制也非常快，“值传递”和“引用传递”的效率几乎相当。 问题是如此的缠绵，我只好将“const &”修饰输入参数的用法总结一下。 对于非内部数据类型的输入参数，应该将“值传递”的方式改为“const 引用传递”，目的是提高效率。例如将void Func(A a) 改为void Func(const A &a)。 对于内部数据类型的输入参数，不要将“值传递”的方式改为“const 引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。例如void Func(int x) 不应该改为void Func(const int &x)。

部分倒装用法归纳教学内容

部分倒装用法归纳

英语部分倒装用法归纳 1. 否定副词位于句首时的倒装 在正式文体中，never, seldom, rarely, little, hardly, scarcely, no sooner, no longer, nowhere 等含有否定意义的副词若位于句首，则其后要用部分倒装： I shall never forgive him. / Never shall I forgive him. 我永远不会宽恕他。 He seldom goes out for dinner. / Seldom does he go out for dinner. 他很少出去吃饭。 She hardly has time to listen to music. / Hardly does she have time to listen to music. 她几乎没时间听音乐。 He little realizes how important this meeting is. / Little does he realize how important this meeting is. 他不甚明白这个会议的重要性。 We had no sooner reached the airport than the plane took off. / No sooner had we reached the airport than the plane took off. 我们刚到机场,飞机就起飞了。 【注意】 (1) 对于not…until句型，当not until…位于句首时，其后的主句要用倒装语序： He didn’t leave the room until the rain stopp ed. / Not until the rain stopped did he leave the room. 雨停了之后他才离开这房间。 (2) 某些起副词作用的介词短语，由于含有否定词，若位于句首，其后要用部分倒装： On no accounts must this switch be touched. 这个开关是绝不能触摸的。 In [Under] no circumstances will I lend money to him.无论如何我也不会再借钱给他了。 但是，in no time(立即，马上)位于句首时，其后无需用倒装语序： In no time he worked out the problem. 他马上就算出了那道题。 2.“only+状语”位于句首时的倒装 当一个状语受副词only的修饰且置于句首时，其后用部分倒装语序： Only then did he realize that he was wrong. 到那时他才意识到他错了。 Only in this way are you able to do it well. 你只有用这种方法才能把它做好。 Only when he returned home did he realize what had happened. 当他回到家里时，才知道出了什么事。 3. “so+adj. / adv.”位于句首时的倒装 副词so后接形容词或副词位于句首时，其后用部分倒装： So cold was the weather that we had to stay at home. 天气太冷，我们只好呆在家里。