.net c#中static关键字是什么意思，还有，动态方法是哪个关键字，是什么意思了

Answer 1

static 表示这个变量或者方法是静态的。静态的变量或者方法是不需要实例化类，就可以访问的。而动态方法，可能就是没加static的，默认就是动态的，呵呵，这样的方法或者成员变量，需要实例化了类之后才可以访问。

至于为什么有静态，那要从程序的内存组织方式上来解释，一个变量或者方法，加不加static关键字，在内存中分配的区域是不一样的。你可以理解为，内存中有2个地方，一个地方存放的是类的模板，静态成员都在这里分配内存。而你要使用类的时候，要new的时候，运行环境会把这个类从静态区拷贝一份出来放到动态区去，没加static关键字的成员，就要到动态的内存区去访问。

Answer 2

使用 static 修饰符声明属于类型本身而不是属于特定对象的静态成员。static 修饰符可用于类、字段、方法、属性、运算符、事件和构造函数，但不能用于索引器、析构函数或类以外的类型。

使用 DynamicMethod 类（.NET Framework 2.0 版中的新类）创建的动态方法为在运行时发出静态方法提供了增强的功能。动态方法通过多种方式扩展 Reflection.Emit 命名空间中的类型的功能：

1.因为不需要生成动态程序集、模块和类型以包含方法，所以它们的系统开销较小。

2.在长时间运行的应用程序中，它们可提供更好的资源占用状况，因为方法体使用的内存在无需再使用该方法时可以回收。

3.如果具有足够的安全权限，它们就能够使代码与现有程序集或类型关联，而该代码能够具有与内部类型和私有成员相同的可见性。

4.如果具有足够的安全权限，它们允许代码跳过实时 (JIT) 可见性检查并访问对象的私有的和受保护的数据。

动态方法可以使用 ILGenerator 对象发出 Microsoft 中间语言 (MSIL)。此外，动态方法还可以使用 DynamicILInfo 对象处理元数据标记和允许复杂客户端执行自己的 MSIL 生成的范围。

动态方法对需要生成运行时代码以保证性能的情形十分有用。
using System;
using System.Reflection;
using System.Reflection.Emit;

public class Example
{
// The following constructor and private field are used to
// demonstrate a method bound to an object.
private int test;
public Example(int test) { this.test = test; }

// Declare delegates that can be used to execute the completed
// SquareIt dynamic method. The OneParameter delegate can be
// used to execute any method with one parameter and a return
// value, or a method with two parameters and a return value
// if the delegate is bound to an object.
//
private delegate long SquareItInvoker(int input);

private delegate TReturn OneParameter<TReturn, TParameter0>
(TParameter0 p0);

public static void Main()
{
// Example 1: A simple dynamic method.
//
// Create an array that specifies the parameter types for the
// dynamic method. In this example the only parameter is an
// int, so the array has only one element.
//
Type[] methodArgs = { typeof(int) };

// Create a DynamicMethod. In this example the method is
// named SquareIt. It is not necessary to give dynamic
// methods names. They cannot be invoked by name, and two
// dynamic methods can have the same name. However, the
// name appears in calls stacks and can be useful for
// debugging.
//
// In this example the return type of the dynamic method
// is long. The method is associated with the module that
// contains the Example class. Any loaded module could be
// specified. The dynamic method is like a module-level
// static method.
//
DynamicMethod squareIt = new DynamicMethod(
"SquareIt",
typeof(long),
methodArgs,
typeof(Example).Module);

// Emit the method body. In this example ILGenerator is used
// to emit the MSIL. DynamicMethod has an associated type
// DynamicILInfo that can be used in conjunction with
// unmanaged code generators.
//
// The MSIL loads the argument, which is an int, onto the
// stack, converts the int to a long, duplicates the top
// item on the stack, and multiplies the top two items on the
// stack. This leaves the squared number on the stack, and
// all the method has to do is return.
//
ILGenerator il = squareIt.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Conv_I8);
il.Emit(OpCodes.Dup);
il.Emit(OpCodes.Mul);
il.Emit(OpCodes.Ret);

// Create a delegate that represents the dynamic method.
// Creating the delegate completes the method, and any further
// attempts to change the method (for example, by adding more
// MSIL) are ignored. The following code uses a generic
// delegate that can produce delegate types matching any
// single-parameter method that has a return type.
//
OneParameter<long, int> invokeSquareIt =
(OneParameter<long, int>)
squareIt.CreateDelegate(typeof(OneParameter<long, int>));

Console.WriteLine("123456789 squared = {0}",
invokeSquareIt(123456789));

// Example 2: A dynamic method bound to an instance.
//
// Create an array that specifies the parameter types for a
// dynamic method. If the delegate representing the method
// is to be bound to an object, the first parameter must
// match the type the delegate is bound to. In the following
// code the bound instance is of the Example class.
//
Type[] methodArgs2 = { typeof(Example), typeof(int) };

// Create a DynamicMethod. In this example the method has no
// name. The return type of the method is int. The method
// has access to the protected and private data of the
// Example class.
//
DynamicMethod multiplyHidden = new DynamicMethod(
"",
typeof(int),
methodArgs2,
typeof(Example));

// Emit the method body. In this example ILGenerator is used
// to emit the MSIL. DynamicMethod has an associated type
// DynamicILInfo that can be used in conjunction with
// unmanaged code generators.
//
// The MSIL loads the first argument, which is an instance of
// the Example class, and uses it to load the value of a
// private instance field of type int. The second argument is
// loaded, and the two numbers are multiplied. If the result
// is larger than int, the value is truncated and the most
// significant bits are discarded. The method returns, with
// the return value on the stack.
//
ILGenerator ilMH = multiplyHidden.GetILGenerator();
ilMH.Emit(OpCodes.Ldarg_0);

FieldInfo testInfo = typeof(Example).GetField("test",
BindingFlags.NonPublic | BindingFlags.Instance);

ilMH.Emit(OpCodes.Ldfld, testInfo);
ilMH.Emit(OpCodes.Ldarg_1);
ilMH.Emit(OpCodes.Mul);
ilMH.Emit(OpCodes.Ret);

// Create a delegate that represents the dynamic method.
// Creating the delegate completes the method, and any further
// attempts to change the method for example, by adding more
// MSIL are ignored.
//
// The following code binds the method to a new instance
// of the Example class whose private test field is set to 42.
// That is, each time the delegate is invoked the instance of
// Example is passed to the first parameter of the method.
//
// The delegate OneParameter is used, because the first
// parameter of the method receives the instance of Example.
// When the delegate is invoked, only the second parameter is
// required.
//
OneParameter<int, int> invoke = (OneParameter<int, int>)
multiplyHidden.CreateDelegate(
typeof(OneParameter<int, int>),
new Example(42)
);

Console.WriteLine("3 * test = {0}", invoke(3));
}
}
/* This code example produces the following output:

123456789 squared = 15241578750190521
3 * test = 126
*/

参考资料：vs2005

Answer 3

声明 类或者变量为静态

类的话,在引用的时候不需要实例化,里面的属性方法等可以直接.出来

附值后.值会一直存在于程序的运行周期,除非主动去更新这些值,否则值不变

Answer 4

说简单点就是：如果你定义的类存在static，那么在调用你自己定义的类的时候就不需要实例化的！