Cody说得对，但我想提供一个内联函数是什么的例子。

假设你有这样的代码:

private void OutputItem(string x)
{
    Console.WriteLine(x);

    //maybe encapsulate additional logic to decide 
    // whether to also write the message to Trace or a log file
}

public IList<string> BuildListAndOutput(IEnumerable<string> x)
{  // let's pretend IEnumerable<T>.ToList() doesn't exist for the moment
    IList<string> result = new List<string>();

    foreach(string y in x)
    {
        result.Add(y);
        OutputItem(y);
    }
    return result;
}

编译器即时优化器可以选择修改代码，以避免在堆栈上重复调用OutputItem()，这样就好像你写的代码是这样的:

public IList<string> BuildListAndOutput(IEnumerable<string> x)
{
    IList<string> result = new List<string>();

    foreach(string y in x)
    {
        result.Add(y);

        // full OutputItem() implementation is placed here
        Console.WriteLine(y);   
    }

    return result;
}

在本例中，我们可以说OutputItem()函数是内联的。注意，即使从其他地方也调用OutputItem()，它也可能这样做。

经过编辑以显示更可能内联的场景。

在某些情况下，我确实希望强制代码内联。

For example if I have a complex routine where there are a large number of decisions made within a highly iterative block and those decisions result in similar but slightly differing actions to be carried out. Consider for example, a complex (non DB driven) sort comparer where the sorting algorythm sorts the elements according to a number of different unrelated criteria such as one might do if they were sorting words according to gramatical as well as semantic criteria for a fast language recognition system. I would tend to write helper functions to handle those actions in order to maintain the readability and modularity of the source code.

我知道那些辅助函数应该是内联的，因为这是编写代码的方式，如果它永远不需要被人类理解的话。在这种情况下，我当然希望确保没有函数调用开销。

不，c#中没有这样的构造，但是. net JIT编译器可以决定在JIT时间执行内联函数调用。但我实际上不知道它是否真的在做这样的优化。 (我认为它应该:))

最后，在。net 4.5中，CLR允许使用MethodImplOptions提示/suggest1方法内联。AggressiveInlining价值。它也可以在Mono的主干中使用(今天提交)。

// The full attribute usage is in mscorlib.dll,
// so should not need to include extra references
using System.Runtime.CompilerServices; 

...

[MethodImpl(MethodImplOptions.AggressiveInlining)]
void MyMethod(...)

1. 以前这里用的是“force”。我会试着解释一下这个术语。正如注释和文档中所述，如果可能的话，方法应该内联。特别是考虑到Mono(它是开放的)，在考虑内联或更一般的技术(如虚函数)时，有一些特定于Mono的技术限制。总的来说，是的，这是对编译器的一个提示，但我猜这是要求的。

Cody说得对，但我想提供一个内联函数是什么的例子。

假设你有这样的代码:

private void OutputItem(string x)
{
    Console.WriteLine(x);

    //maybe encapsulate additional logic to decide 
    // whether to also write the message to Trace or a log file
}

public IList<string> BuildListAndOutput(IEnumerable<string> x)
{  // let's pretend IEnumerable<T>.ToList() doesn't exist for the moment
    IList<string> result = new List<string>();

    foreach(string y in x)
    {
        result.Add(y);
        OutputItem(y);
    }
    return result;
}

编译器即时优化器可以选择修改代码，以避免在堆栈上重复调用OutputItem()，这样就好像你写的代码是这样的:

public IList<string> BuildListAndOutput(IEnumerable<string> x)
{
    IList<string> result = new List<string>();

    foreach(string y in x)
    {
        result.Add(y);

        // full OutputItem() implementation is placed here
        Console.WriteLine(y);   
    }

    return result;
}

在本例中，我们可以说OutputItem()函数是内联的。注意，即使从其他地方也调用OutputItem()，它也可能这样做。

经过编辑以显示更可能内联的场景。

没错，唯一的区别是它返回一个值。

简化(不使用表达式):

列表> < T。ForEach执行一个操作，它不期望返回结果。

所以Action<T>委托就足够了。说:

List<T>.ForEach(param => Console.WriteLine(param));

就等于说:

List<T>.ForEach(delegate(T param) { Console.WriteLine(param); });

不同之处在于参数类型和委托声明是根据用法推断的，在简单的内联方法上不需要花括号。

而

列表> < T。接受一个函数，期待一个结果。

因此，一个Function<T, bool>将被期望:

List<T>.Where(param => param.Value == SomeExpectedComparison);

也就是:

List<T>.Where(delegate(T param) { return param.Value == SomeExpectedComparison; });

你也可以内联声明这些方法，并将它们赋值给变量IE:

Action myAction = () => Console.WriteLine("I'm doing something Nifty!");

myAction();

or

Function<object, string> myFunction = theObject => theObject.ToString();

string myString = myFunction(someObject);

我希望这能有所帮助。