MonoDevelop开发笔记，c#中类的默认访问修饰符,是private还是internal
Mono C#语法说明：
1)不允许使用默认修饰符。例如： public void ShowLoading(bool IsCanCancel=false)
2)Mono和VS 的解决方案不完全兼容。
给个例子：
C++：
typedef struct tagPlayFile // 播放文件
{
int fid; // 文件序号（序号小于 0则取全路径）
char fname[100]; // 文件名或全路径名
} PlayFile, *LPPlayFile;
C#：
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
public struct tagPlayFile // 播放文件
{
int fid; // 文件序号（序号小于 0则取全路径）
[MarshalAs(UnmanagedType.ByValTStr, SizeConst = 100)]
string fname; // 文件名或全路径名
}
默认是internal ：
扩展：
类(class)或结构(struct)如果不是在其它类或结构中的话，它的访问类型要不就是internal, 要不就是public；
换句话说，如果它在其它类或结构中的话，则可以为private 或protected等。下面我说的类和结构，如无特殊说明，均指非"类中类"
类中所有的成员，默认均为private。
C#用多种修饰符来表达类的不同性质。根据其保护级C#的类有五种不同的限制修饰符： public可以被任意存取； protected只可以被本类和其继承子类存取； internal只可以被本组合体（Assembly）内所有的类存取，组合体是C#语言中类被组合后的逻辑单位和物理单位，其编译后的文件扩展名往往是“.DLL”或“.EXE”。 protected internal唯一的一种组合限制修饰符，它只可以被本组合体内所有的类和这些类的继承子类所存取。 private只可以被本类所存取。 如果不是嵌套的类，命名空间或编译单元内的类只有public和internal两种修饰。 new修饰符只能用于嵌套的类，表示对继承父类同名类型的隐藏。 override 只能用于嵌套的类，表示对继承父类同名类型的覆盖。
abstract用来修饰抽象类，表示该类只能作为父类被用于继承，而不能进行对象实例化。抽象类可以包含抽象的成员，但这并非必须。abstract不能和new同时用。下面是抽象类用法的伪码： abstract class A { public abstract void F(); } abstract class B: A { public void G() {} } class C: B { public override void F() { //方法F的实现 } } 抽象类A内含一个抽象方法F()，它不能被实例化。类B继承自类A，其内包含了一个实例方法G(),但并没有实现抽象方法F()，所以仍然必须声明为抽象类。类C继承自类B，实现类抽象方法F()，于是可以进行对象实例化。 sealed用来修饰类为密封类，阻止该类被继承。同时对一个类作abstract和sealed的修饰是没有意义的，也是被禁止的。
enum 的默认访问修饰符：public，且此类型不允许其它访问修饰符
interface的默认访问修饰符：interal，且此类型不允许其它访问修饰符；接口的成员默认访问修饰符是public，也不可能是其他访问修饰符
委托，默认internal
命名空间上不允许使用访问修饰符。命名空间没有访问限制。（命名空间，枚举类型成员默认public，也不可能是其他访问修饰符 //?????? 待验证）
c# 的访问修饰符是private 还是 internal？
准确的说，不能一概而论。
[MSDN]
Classes and structs that are not nested within other classes or structs can be either public or internal. A type declared as public is accessible by any other type. A type declared as internal is only accessible by types within the same assembly. Classes and structs are declared as internal by default unless the keyword public is added to the class definition, as in the previous example. Class or struct definitions can add the internal keyword to make their access level explicit. Access modifiers do not affect the class or struct itself — it always has access to itself and all of its own members.
类(class)或结构(struct)如果不是在其它类或结构中的话，它的访问类型要不就是internal, 要不就是public；
换句话说，如果它在其它类或结构中的话，则可以为private 或protected等。下面我说的类和结构，如无特殊说明，均指非"类中类"
类或结构的默认访问类型是internal.
类中所有的成员，默认均为private。
[MSDN]
Interfaces, like classes, can be declared as public or internal types. Unlike classes, interfaces default to internal access. Interface members are always public, and no access modifiers can be applied.
Namespaces and enumeration members are always public, and no access modifiers can be applied.
Delegates have internal access by default.
Any types declared within a namespace or at the top level of a compilation unit (for example, not within a namespace, class, or struct) are internal by default, but can be made public.
接口默认访问符是internal
接口的成员默认访问修饰符是public，也不可能是其他访问修饰符
命名空间，枚举类型成员默认public，也不可能是其他访问修饰符
委托，默认internal
在命名空间内部或编译单元顶部的所有类型，默认是internal，可以人为改为public。
访问权限控制(图解)
C#类的访问性 类成员的访问修饰符今天想不起C#中类的默认访问修饰符是internal了还以为是public呢，单元测试时候一直是黄色敬告。所以把csdn的东西翻出了（在百度上搜不到的）。当用internal修饰类（c#默认不加修饰符就是internal）可能会出现问题：当你在继承或者是实例化一个internal类的时候你的访问权限不能打破原来internal类的访问限制。 例：internal class A{} public class B:A{}是不允许的； public class C{ public A a=new A();}是不允许的. msdn参考： 访问修饰符（C# 编程指南）所有类型和类型成员都具有可访问性级别，用来控制是否可以在您程序集的其他代码中或其他程序集中使用它们。您在声明类型或成员时使用以下访问修饰符之一来指定其可访问性：
- public （可以修饰类）
同一程序集中的任何其他代码或引用该程序集的其他程序集都可以访问该类型或成员。
- private (成员的默认访问修饰符) (成员方法和成员字段的默认访问符）
只有同一类或结构中的代码可以访问该类型或成员。
- protected
只有同一类或结构或者派生类中的代码可以访问该类型或成员。
- internal （可以修饰类，类的默认修饰符）
同一程序集中的任何代码都可以访问该类型或成员，但其他程序集中的代码不可以。（internal指的是同一个程序集,内部成员和类型才是可以访问的.内部访问通常用于基于组件的开发，因为它使一组组件能够以私有方式进行合作，而不必向应用程序代码的其余部分公开）
- protected internal
同一程序集中的任何代码或其他程序集中的任何派生类都可以访问该类型或成员。
下面的示例演示如何为类型和成员指定访问修饰符：
不是所有访问修饰符都可以在所有上下文中由所有类型或成员使用，在某些情况下类型成员的可访问性受到其包含类型的可访问性的限制。以下各节提供了有关可访问性的更多详细信息。
类和结构的可访问性
直接在命名空间中声明的类和结构（即，没有嵌套在其他类或结构中的类和结构）可以是公共类和结构，也可以是内部类和结构。如果不指定访问修饰符，则默认为 internal。嵌套的类和结构还可以声明为私有类和结构。不可以从包含类型访问私有嵌套类型。
派生类的可访问性不能高于其基类型。换句话说，不能有从内部类 A 派生的公共类 B。如果允许这种情况，将会使 A 成为公共类，因为 A 的所有受保护的成员或内部成员都可以从派生类访问。
可以使用 InternalsVisibleToAttribute 使其他某些程序集能够访问您的内部类型。有关更多信息，请参见友元程序集（C# 编程指南）。
可以使用五种访问类型中的任何一种来声明类成员（包括嵌套的类和结构）。结构成员无法声明为受保护成员，因为结构不支持继承。
成员的可访问性决不能高于其包含类型的可访问性。例如，在内部类型中声明的公共方法只具有内部可访问性。
如果类或结构的成员为属性、字段、方法、事件或委托，并且该成员是某个类型或具有参数或返回值类型，则该成员的可访问性不能超过该类型。例如，如果 C 不是公共类，则不能返回类 C 的公共方法 M。同样，如果 A 声明为私有，则类型 A 不能有受保护的属性。
用户定义的运算符必须始终声明为公共运算符。有关更多信息，请参见 operator（C# 参考）。
析构函数不能具有可访问性修饰符。
若要设置类成员或结构成员的访问级别，请向该成员声明添加适当的关键字。下面是一些示例：
说明：
protected internal 可访问性的意思是受保护“或”内部，而不是受保护“和”内部。换句话说，可以从同一程序集内的任何类（包括派生类）中访问 protectedinternal 成员。若要限制为只有同一程序集内的派生类可以访问，请将类本身声明为内部，并将其成员声明为受保护。
直接用命名空间声明时，可以将接口声明为公共接口或内部接口，并且与类和结构一样，接口默认具有内部可访问性。接口成员始终是公共成员，因为接口的用途是让其他类型能够访问某个类或结构。访问修饰符不能应用于接口成员。
枚举成员始终是公共的，不能应用任何访问修饰符。
默认情况下，委托默认具有内部访问级别。
嵌套类型是其他类型的成员，它们可以具有下表所示的声明的可访问性。
属于 默认的成员可访问性 该成员允许的声明的可访问性 enum
public
无
class
private
public
protected
internal
private
protected internal
interface
public
无
struct
private
public
internal
private
msdn中interal的运用： http://msdn.microsoft.com/zh-cn/library/6fawty39(v=vs.80).aspx
private void LockUnlockBitsExample(PaintEventArgs e)
{
// Create a new bitmap.
Bitmap bmp = new Bitmap("c:\\fakePhoto.jpg");
// Lock the bitmap's bits.
Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
System.Drawing.Imaging.BitmapData bmpData =
bmp.LockBits(rect, System.Drawing.Imaging.ImageLockMode.ReadWrite,
bmp.PixelFormat);
// Get the address of the first line.
IntPtr ptr = bmpData.Scan0;
// Declare an array to hold the bytes of the bitmap.
int bytes = Math.Abs(bmpData.Stride) * bmp.Height;
��� byte[] rgbValues = new byte[bytes];
// Copy the RGB values into the array.
System.Runtime.InteropServices.Marshal.Copy(ptr, rgbValues, 0, bytes);
// Set every third value to 255. A 24bpp bitmap will look red.
for (int counter = 2; counter < rgbValues.Length; counter += 3)
rgbValues[counter] = 255;
// Copy the RGB values back to the bitmap
System.Runtime.InteropServices.Marshal.Copy(rgbValues, 0, ptr, bytes);
// Unlock the bits.
bmp.UnlockBits(bmpData);
// Draw the modified image.
e.Graphics.DrawImage(bmp, 0, 150);
}
C#_空值判断
(2)""、String.Empty、String.Length == 0
这两个都是表示空字符串。只不过""理论上重新开辟内存空间，而String.Empty指向一处。不过优化器会优化的！
string.Empty不分配存储空间, ""分配一个长度为空的存储空间,所以一般用string.Empty,为了以后跨平台，还是用string.empty。在 C# 中，大多数情况下 "" 和string.Empty 可以互换使用。比如：
string s1 = "";
string s2 = string.Empty;
if (s1 == string.Empty)
{
//
}
if语句成立
判定为空字符串的几种写法，按照性能从高到低的顺序是：
s.Length == 0 优于 s == string.Empty 优于 s == ""
注意：
1.string str1="" 和 string str2=null 的区别。str1是一个空字符串，空字符串是一个特殊的字符串，只不过这个字符串的值为空，在内存中是有准确的指向的，string str2=null,这样定义后，只是定义了一个string 类的引用，str2并没有指向任何地方，在使用前如果不实例化的话，都将报错。
2.在net 2.0中可用String.IsNullOrEmpty(param)检测是否为null或为空值。当Request.QueryString的标识不存在时返回的是NULL，可以在空串上调用string类的所有方法，但null不可以，不可以在null上调用方法。
(3)DBNULL
DBNull在DotNet是单独的一个类型, 该类用于指示不存在某个已知值（通常在数据库应用程序中）。该类只能存在唯一的实例,DBNULL.Value, DBNull唯一作用是可以表示数据库中的字符串，数字，或日期，为什么可以表示原因是DotNet储存这些数据的类（DataRow等）都是以 object 的形式来储存数据的。对于 DataRow , 它的 row[column] 返回的值永远不为 null ， 要么就是具体的为column 的类型的值 。 要么就是 DBNull 。 所以 row[column].ToString() 这个写法永远不会在ToString那里发生NullReferenceException。DBNull 实现了 IConvertible 。 但是，除了 ToString 是正常的外，其他的ToXXX都会抛出不能转换的错误。您可以通过将从数据库字段检索到的值传递给 DBNull.Value.Equals 方法，确定该字段值是否为 DBNull 值
(4)Convert.IsDBNull()
Convert.IsDBNull()返回有关指定对象是否为 DBNull 类型的指示,即是用来判断对象是否为DBNULL的。其返回值是True或Flase。
首先C#只有Hashtable,Hashtable表示键/值对的集合，这些键/值对根据键的哈希代码进行组织。C#中没有HashMap,而HashMap是Java1.2引进的Map interface的一个实现.... 1.Hashtable是Dictionary的子类，HashMap是Map接口的一个实现类； 2.Hashtable中的方法是同步的，而HashMap中的方法在缺省情况下是非同步的。即是说，在多线程应用程序中，不用专门的操作就安全地可以使用Hashtable了；而对于HashMap，则需要额外的同步机制。但HashMap的同步问题可通过Collections的一个静态方法得到解决： Map Collections.synchronizedMap(Map m) 这个方法返回一个同步的Map，这个Map封装了底层的HashMap的所有方法，使得底层的HashMap即使是在多线程的环境中也是安全的。 3.在HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。当get()方法返回null值时，即可以表示HashMap中没有该键，也可以表示该键所对应的值为null。因此，在HashMap中不能由get()方法来判断HashMap中是否存在某个键，而应该用containsKey()方法来判断
C#Hashtable与Dictionary性能
由于 Hashtable 和 Dictionary 同时存在, 在使用场景上必然存在选择性, 并不任何时刻都能相互替代.
[1] 单线程程序中推荐使用 Dictionary, 有泛型优势, 且读取速度较快, 容量利用更充分.
[2] 多线程程序中推荐使用 Hashtable, 默认的 Hashtable 允许单线程写入, 多线程读取, 对 Hashtable 进一步调用 Synchronized() 方法可以获得完全线程安全的类型. 而 Dictionary 非线程安全, 必须人为使用 lock 语句进行保护, 效率大减.
[3] Dictionary 有按插入顺序排列数据的特性 (注: 但当调用 Remove() 删除过节点后顺序被打乱), 因此在需要体现顺序的情境中使用 Dictionary 能获得一定方便.
几种C#框架提供的数据结构对单值查找的效率比较->http://www.cnblogs.com/eaglet/archive/2008/10/23/1317893.html
我个人是觉得，无论什么时候，都应该使用Dictionary<K,V>，理由如下：
1、Dic是类型安全的，这有助于我们写出更健壮更具可读性的代码，而且省却我们强制转化的麻烦。这个相信大家都明白。
2、Dic是泛行的，当K或V是值类型时，其速度远远超过Hashtable。这个大家对值类型与引用类型有所了解的话也会明白。
3、如果K和V都是引用类型，如eaglet所测，Hashtable比Dic更快，这里我要指出，eaglet所做的测试是有问题的。原因在于Hashtable与Dic采用的是不同的数据结构。eaglet的“Dictionary 由于在Hashtable基础上封装了一层”这个说法是不对的。
Dictionary 调用 Add 方法之前使用 ContainsKey 方法测试某个键是否存在，否则得到一个KeyNotFoundException。
当程序频繁尝试字典中不存在的键时，使用 TryGetValue 方法来检索值，这种方法是一种更有效的检索值的方法。
具体我也不讲了，因为有人（Angel Lucifer）已经讲得很清楚了，引用如下：
http://www.cnblogs.com/lucifer1982/archive/2008/06/18/1224319.html
http://www.cnblogs.com/lucifer1982/archive/2008/07/03/1234431.html
Hashtable在指定capacity参数时，它并不只开出capacity个槽的内存空间，而是开出比 capacity / 0.72（默认装填因子） 大的最小素数个槽的空间；而Dic在指定capacity时，是开出 比capacity 大的最小素数个槽的空间。因此可以看到，楼主虽然都指定capacity为10万，而实际上Hashtable的槽的总数远远大于Dic的槽的总数，也就是占用的内存远远大于Dic，因此，如此测试是不公平不公正的，如要公平公正的测试，则应该把Dic的capacity指定为 10万/0.72，请大家再测试其性能。