静态成员：

非静态类可以包含静态方法、字段、属性或事件。 即使未创建类的任何实例，也可对类调用静态成员。 静态成员始终按类名（而不是实例名称）进行访问。 静态成员只有一个副本存在（与创建的类的实例数无关）。 静态方法和属性无法在其包含类型中访问非静态字段和事件，它们无法访问任何对象的实例变量，除非在方法参数中显式传递它。

更典型的做法是声明具有一些静态成员的非静态类（而不是将整个类都声明为静态）。 静态字段的两个常见用途是保留已实例化的对象数的计数，或是存储必须在所有实例间共享的值。

静态方法可以进行重载，但不能进行替代，因为它们属于类，而不属于类的任何实例。

虽然字段不能声明为 static const ，不过 const 字段在其行为方面本质上是静态的。 它属于类型，而不属于类型的实例。 因此，可以使用用于静态字段的相同 ClassName.MemberName 表示法来访问 const 字段。 无需进行对象实例化。

C# 不支持静态局部变量（即在方法范围中声明的变量）。

可在成员的返回类型之前使用 static 关键字声明静态类成员，如下面的示例所示：

public class Automobile
    public static int NumberOfWheels = 4;
    public static int SizeOfGasTank
            return 15;
    public static void Drive() { }
    public static event EventType RunOutOfGas;
    // Other non-static fields and properties...
在首次访问静态成员之前以及在调用构造函数（如果有）之前，会初始化静态成员。 若要访问静态类成员，请使用类的名称（而不是变量名称）指定成员的位置，如下面的示例所示：
 
 
Automobile.Drive();
int i = Automobile.NumberOfWheels;
 
如果类包含静态字段，则提供在类加载时初始化它们的静态构造函数。
 
对静态方法的调用会采用 Microsoft 中间语言 (MSIL) 生成调用指令，而对实例方法的调用会生成 callvirt 指令，该指令还会检查是否存在 null 对象引用。 但是在大多数时候，两者之间的性能差异并不显著。
 
简言之：用static修饰的成员称为静态成员。
 
 
class Beauty
//静态字段
public static string feature = "美女";
//静态方法
public static void SpendMoney()
Console.WriteLine("买:衣服、包包、化妆品、鞋子。。。。");
静态成员只能由类来调用
 
 
public static void Main(string[] args)
Beauty.SpendMoney();
string name = Beauty.feature;
区分静态成员：
 
静态类基本上与非静态类相同，但存在一个差异：静态类无法实例化。 换句话说，无法使用 new 运算符创建类类型的变量。 由于不存在任何实例变量，因此可以使用类名本身访问静态类的成员。
 
静态类可以用作只对输入参数进行操作并且不必获取或设置任何内部实例字段的方法集的方便容器。
 
因此，创建静态类基本上与创建只包含静态成员和私有构造函数的类相同。 私有构造函数可防止类进行实例化。 使用静态类的优点是编译器可以进行检查，以确保不会意外地添加任何实例成员。 编译器可保证无法创建此类的实例。
 
静态类会进行密封，因此不能继承。 它们不能继承自任何类（除了 Object）。 静态类不能包含实例构造函数。 但是，它们可以包含静态构造函数。 如果非静态类包含了需要进行有意义的初始化的静态成员，则它也应该定义一个静态构造器。
 
下面是静态类的示例，该类包含将温度从摄氏度从华氏度以及从华氏度转换为摄氏度的两个方法：
 
public static class TemperatureConverter
    public static double CelsiusToFahrenheit(string temperatureCelsius)
        // Convert argument to double for calculations.
        double celsius = Double.Parse(temperatureCelsius);
        // Convert Celsius to Fahrenheit.
        double fahrenheit = (celsius * 9 / 5) + 32;
        return fahrenheit;
    public static double FahrenheitToCelsius(string temperatureFahrenheit)
        // Convert argument to double for calculations.
        double fahrenheit = Double.Parse(temperatureFahrenheit);
        // Convert Fahrenheit to Celsius.
        double celsius = (fahrenheit - 32) * 5 / 9;
        return celsius;
class TestTemperatureConverter
    static void Main()
        Console.WriteLine("Please select the convertor direction");
        Console.WriteLine("1. From Celsius to Fahrenheit.");
        Console.WriteLine("2. From Fahrenheit to Celsius.");
        Console.Write(":");
        string selection = Console.ReadLine();
        double F, C = 0;
        switch (selection)
            case "1":
                Console.Write("Please enter the Celsius temperature: ");
                F = TemperatureConverter.CelsiusToFahrenheit(Console.ReadLine());
                Console.WriteLine("Temperature in Fahrenheit: {0:F2}", F);
                break;
            case "2":
                Console.Write("Please enter the Fahrenheit temperature: ");
                C = TemperatureConverter.FahrenheitToCelsius(Console.ReadLine());
                Console.WriteLine("Temperature in Celsius: {0:F2}", C);
                break;
            default:
                Console.WriteLine("Please select a convertor.");
                break;
        // Keep the console window open in debug mode.
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
/* Example Output:
    Please select the convertor direction
    1. From Celsius to Fahrenheit.
    2. From Fahrenheit to Celsius.
    Please enter the Fahrenheit temperature: 20
    Temperature in Celsius: -6.67
    Press any key to exit.
 简言之：用static修饰的类称为静态类。
 
静态类不能实例化，所以内部只允许有静态成员或const修饰的常量。
 
static class MyMath
//int length; // 不能包含非静态成员
static int length;
const int id = 10;
//void fun(){} // 不能包含非静态成员
static int Abs()
return a > 0 ? a : -a;
静态类特点：
 1.仅包含静态成员和const修饰的常量。
 2.不能被实例化。
 3.是密封的。（默认已经是sealed，不能再用sealed修饰）
 4.有静态构造方法（函数），但静态构造方法必须是无参数的。
 
静态构造方法
 
静态构造方法用于初始化任何静态数据，或用于执行仅需执行一次的特定操作。在创建第一个实例或引用任何静态成员之前，将自动调用静态构造函数。
 
public sealed class Time
public static float dealTime;
static Time() //不能带访问修饰符，不能带参数 ，不能重载
dealTime = 0.04f; //如果不写这句话，系统会为静态变量赋一个默认值
Console.WriteLine ("static Time().");
class MainClass
public static void Main (string[] args)
Console.WriteLine ( Time.dealTime);
//output:static Time().
//output:0.04
深入理解C# 静态类与非静态类、静态成员的区别
 
静态类与非静态类的重要区别在于静态类不能实例化，也就是说，不能使用 new 关键字创建静态类类型的变量。在声明一个类时使用static关键字，具有两个方面的意义：首先，它防止程序员写代码来实例化该静态类；其次，它防止在类的内部声明任何实例字段或方法。
 
静态类是自C# 2.0才引入的，C# 1.0不支持静态类声明。程序员必须声明一个私有构造器。私有构造器禁止开发者在类的范围之外实例化类的实例。使用私有构造器的效果与使用静态类的效果非常相似。
 
两者的区别：
 私有构造器方式仍然可以从类的内部对类进行实例化，而静态类禁止从任何地方实例化类，其中包括从类自身内部。静态类和使用私有构造器的另一个区别在于，在 使用私有构造器的类中，是允许有实例成员的，而C# 2.0和更高版本的编译器不允许静态类有任何实例成员。使用静态类的优点在于，编译器能够执行检查以确保不致偶然地添加实例成员，编译器将保证不会创建此 类的实例。静态类的另一个特征在于，C#编译器会自动把它标记为sealed。这个关键字将类指定为不可扩展；换言之，不能从它派生出其他类。
 
 
静态类的主要特性：
 1：仅包含静态成员。
 2：无法实例化。
 3：是密封的。
 4：不能包含实例构造函数。
 
 
1：非静态类可以包含静态的方法、字段、属性或事件；
 2：无论对一个类创建多少个实例，它的静态成员都只有一个副本；
 3：静态方法和属性不能访问其包含类型中的非静态字段和事件，并且不能访问任何对象的实例变量；
 4：静态方法只能被重载，而不能被重写，因为静态方法不属于类的实例成员；
 5：虽然字段不能声明为 static const，但 const 字段的行为在本质上是静态的。这样的字段属于类，不属于类的实例。因此，可以同对待静态字段一样使用 ClassName.MemberName 表示法来访问 const 字段；
 6：C# 不支持静态局部变量(在方法内部定义静态变量)。
 
 静态构造函数
 
 
1：静态类可以有静态构造函数，静态构造函数不可继承；
 2：静态构造函数可以用于静态类，也可用于非静态类；
 3：静态构造函数无访问修饰符、无参数，只有一个 static 标志；
 4：静态构造函数不可被直接调用，当创建类实例或引用任何静态成员之前，静态构造函数被自动执行，并且只执行一次。
 
 
1：静态类在内存中是一直有位置的；
 2：非静态类在实例化后是在内存中是独立的，它的变量不会重复，在使用后会及时销毁，所以不会出现未知的错误。在C#中静态成员是比较敏感的东西，在不是十分确认的情况下不要使用；
 3：建议更多地使用一般类(非静态类)。
 
使用选择： 
 
当定义的类不需要进行实例化时，我们使用静态类；如果需要实例化对象，需要继承等特性时，应该使用非静态类，并且将统一使用的变量和方法设为静态的，那么所有实例对象都能访问。
 
C# 静态成员和方法的学习小结
 
数据成员：
 
数据成员可以分静态变量、实例变量两种.
静态成员：
 
静态成员变量是和类相关联的,可以作为类中"共"有的变量(是一个共性的表现),他不依赖特定对象的存在,访问的时候通过类名加点操作符加变量名来访问.
 
实例成员：
 
实例成员变量是和对象相关联的,访问实例成员变量依赖于实例的存在.当多个实例对象存在时，每个对象的每个数据成员都有自己独立的一套存储空间。
 
函数成员：
 方法可以主要分为静态方法,实例方法
 
静态方法：
 
静态方法是不属于特定对象的方法，静态方法可以访问静态成员变量，静态方法不可以直接访问实例变量，可以在实例函数调用的情况下，实例变 量做为参数传给静态方法。静态方法也不能直接调用实例方法，可以间接调用，首先要创建一个类的实例，然后通过这一特定对象来调用静态方法。
 
实例方法：
 
一个实例方法的执行与特定对象关联，他的执行需要一个对象存在。实例方法可以直接访问静态变量和实例变量，实例方法可以直接访问实例方 法、和静态方法，静态方法的访问方式为类名加点操作符加变量名。当多个实例对象存在时，内存中并不是存在每个特定的实例方法的拷贝，而是，相同类的所有对象都共享每个实例方法的一个拷贝（实例方法只占用“一套”空间）。
  
 如果将类中的某个成员声明为static，则称该成员为静态成员。一般来说，静态成员是属于类所有的，而非静态成员则属于类的实例的。每创建一个类的实 例，都在内存中为非静态成员开辟一片区域。而类的静态成员为类所有，为这个类的所有实例共享。无论这个类创建了多少副本，一个静态成员在内存中只占有一块 区域。
 
C#类中静态成员变量的生命周期问题，就是什么时候创建，什么时候销毁已声明元素的“生存期”是元素可供使用的时间周期。变量是唯一具有生存期的元素；为此，编译器将过程参数和函数返回值视为变量的特殊情况。变量的生存期表示它可以保留值的时间周期。在生存期内变量的值可以更改，但变量总是保留某些值。
 
                    静态成员：非静态类可以包含静态方法、字段、属性或事件。 即使未创建类的任何实例，也可对类调用静态成员。 静态成员始终按类名（而不是实例名称）进行访问。 静态成员只有一个副本存在（与创建的类的实例数无关）。 静态方法和属性无法在其包含类型中访问非静态字段和事件，它们无法访问任何对象的实例变量，除非在方法参数中显式传递它。更典型的做法是声明具有一些静态成员的非静态类（而不是将整个类都声明为静态）。 静态字段的两个常见用途是保留已实例化的对象数的计数，或是存储必须在所有实例间共享的值。静态方法可以进行
				
① 静态成员属于类所有，非静态成员属于类的实例所有。 ② 每创建一个类的实例，都市在内存中为非静（动）态成员新分派一块存储； 静态成员属于类所有，为各个类的实例所公用，无论类创建了几多实例，类的静态成员在内存中只占同一块区域。 静态数据成员区别于动态数据成员，静态变量并不是稳定的，只是静态变量在声明的时候不管有没有赋值，都市凭据它的类型分派对应的内存空间，他的可访问性和作用区间与动态变量是一样的 ========================================================================== 关于C#中静态数据成员和静态要领的总结。 1.静态
				
如果类只包含静态的方法和属性,该类就是静态的.静态类在功能上与使用私有静态构造函数创建的类相同.不能创建静态类的实例.使用关键字static关键字,编译器可以检查用户是否不经意间给类添加了实例成员.如果是,就生成一个编译错误.这可以确保不创建静态类的实例.
static class StatucTest
public static void SayHello()
				
C#的类中可以包含两种方法：C#静态方法与非静态方法。那么他们的定义有什么不同呢？他们在使用上会有什么不同呢？
让我们来看看最直观的差别：使用了static 修饰符的方法为静态方法，反之则是非静态方法。
下面我们分四个方面来看看C#静态方法与非静态方法的差异：
C#静态方法与非静态方法比较一、C#静态成员：①静态成员属于类所有，非静态成员属于类的实例所有。②每创建一个类的实例，...
静态内部类中的非静态变量和方法需要实例化静态内部后，才能调用。（且访问权限够）
静态内部类中的静态变量和方法可以直接访问使用。（且访问权限够）
静态内部类可以访问外部类的变量和方法
如果是静态变量和方法可以直接访问。（且访问权限够）
如果是非静态变量和方法，需要实例化外部类然后才能访问。（且访问权限够）
当外部类被加载的时候，静态内部类不会被加载，只有当第一次调用到该静态内部类时，才会被加载。
静态内部类类虽然写在了外部类的内部，但就像一个其他的不在外部类内部的普通的类一