如何自动生成每个方法都必须编写的代码？

Question

我正在开发一个项目，我编写的每个方法都以相同的方式开始：

public blah blah() // my method signature
{
    Tracing.StartOfMethod("Repositroy");

    // I'll declare variables as needed

    try
    {
        // the content here differs for every method
    }
    catch (Exception ex)
    {
        ErrorSignal.FromCurrentContext().Raise(ex);
        // sometimes I'll add something here
    }
    finally
    {
        // sometimes something here
        Tracing.EndOfMethod();
    }

    // return result
}

每个方法的最终结果都不同，具体取决于它的作用，但我总是从相同的结构开始。有人可以告诉我是否有一种方法可以自动编写这段代码，这样就不会那么重复了？也许“插入片段”？如果是这样，我如何定义片段？谢谢。

Answer 1

我同意 @Kent 和其他人的观点，即 AoP 在这里看起来不错，并且也同意 @sleske 的观点，即必须在每种方法上执行此操作表明您可能存在设计问题。

样板代码定义一个方法，并通过委托传递“有用”代码：

public T DoMethod<T>( Func<T> mainCode, Func<Exception, T> exceptionHandlerCode)
{
    Tracing.StartOfMethod("Repository");

    try
    {
        return mainCode.Invoke();
    }
    catch (Exception ex)
    {
         ErrorSignal.FromCurrentContext().Raise(ex);
         return exceptionHandlerCode.Invoke(ex);
    }
    finally
    {
        // sometimes something here
        Tracing.EndOfMethod();
    }
}

话虽如此，只是为了给您提供一种替代方案，我在类似情况下所做的一件事（尽管不是针对每种方法）是使用 例如，可以使用 lambda 来调用：

DoMethod(() => { return 5; }, ex => { return 0; })

Answer 2

有各种可用的代码片段编辑器，我都没有使用过，但我之前在 Codeplex 上看到过一个： 片段编辑器。

Answer 3

您可以在 MSDN 上查看此链接了解如何创建/使用片段。我同意@Kent，尽管 AOP 解决方案是最好的。

Answer 4

这是您可能想要的一个片段示例。
只需创建一个 .snippet 文件并将其放入 snippets 目录中。

<?xml version="1.0" encoding="utf-8"?> <CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet"> <CodeSnippet Format="1.0.0">
    <Header>
      <SnippetTypes>
        <SnippetType>Expansion</SnippetType>
      </SnippetTypes>
      <Title>commonmethodsnippet</Title>
      <Shortcut>commonmethodsnippet</Shortcut>
      <Description>Common method snippet.</Description>
      <Author>Me</Author>
    </Header>
    <Snippet>
      <Declarations>
        <Literal Editable="true">
          <ID>returnValue</ID>
          <ToolTip>Return Value</ToolTip>
          <Default>returnValue</Default>
          <Function>
          </Function>
        </Literal>
        <Literal Editable="true">
          <ID>methodName</ID>
          <ToolTip>Method Name</ToolTip>
          <Default>methodName</Default>
          <Function>
          </Function>
        </Literal>
        <Literal Editable="true">
          <ID>methodDescription</ID>
          <ToolTip>Method Description</ToolTip>
          <Default>methodDescription</Default>
          <Function>
          </Function>
        </Literal>
        <Literal Editable="true">
          <ID>variableDeclarations</ID>
          <ToolTip>Variable Declarations</ToolTip>
          <Default>variableDeclarations</Default>
          <Function>
          </Function>
        </Literal>
      </Declarations>
      <Code Language="csharp"><![CDATA[public $returnValue$ $methodName$() // $methodDescription$  { 
    Tracing.StartOfMethod("Repository"); 

    // Variable Declarations
    $variableDeclarations$

    try 
    { 
        // the content here differs for every method 
    } 
    catch (Exception ex) 
    { 
        ErrorSignal.FromCurrentContext().Raise(ex);

        // sometimes I'll add something here 
    } 
    finally 
    { 
        // sometimes something here 
        Tracing.EndOfMethod(); 
    } 

    // return result  }]]></Code>
    </Snippet>   </CodeSnippet> </CodeSnippets>

Answer 5

我不同意这里提出的关于日志记录的有用性以及为每个功能使用固定模板的问题的观点。

基于 Jerry Dennany 的文章 TraceListeners 和 Reflection，我扩展了 < a href="http://www.theobjectguy.com/" rel="nofollow">Object Guy 的日志框架 来生成我的代码的缩进跟踪。这可以通过日志工具进一步处理，但我不介意 - 有时只是扫描结果就非常有建设性。

当然，使用方面编程是正确的做法，但我从未学习过它。所以我在每个方法中使用以下代码片段来记录，验证每个方法的参数，并捕获异常（默认情况下，会重新抛出）

<CodeSnippet Format="1.0.0">
<Header>
  <Title>Canonic</Title>
  <SnippetTypes>
    <SnippetType>Expansion</SnippetType>
  </SnippetTypes>
</Header>
<Snippet>
  <Declarations>
    <Literal>
      <ID>ClassName</ID>
      <ToolTip>Replace with the name of the class.</ToolTip>
      <Default>ClassName</Default>
    </Literal>
    <Literal>
      <ID>MethodName</ID>
      <ToolTip>Replace with the name of the method.</ToolTip>
      <Default>MethodName</Default>
    </Literal>
    <Literal>
      <ID>FirstArgName</ID>
      <ToolTip>Replace with the name of the first argument.</ToolTip>
      <Default>FirstArgName</Default>
    </Literal>
    <Literal>
      <ID>SecondArgName</ID>
      <ToolTip>Replace with the name of the second argument.</ToolTip>
      <Default>SecondArgName</Default>
    </Literal>
    <Literal>
      <ID>ResultName</ID>
      <ToolTip>Replace with the name of the result.</ToolTip>
      <Default>ResultName</Default>
    </Literal>
  </Declarations>
  <Code Language="CSharp">
    <![CDATA[            Logger.LogMethod("$FirstArgName$", $FirstArgName$,"$SecondArgName$", $SecondArgName$);
        try
        {
            Validator.Verify($FirstArgName$, $SecondArgName$);
            //VerifyFields();

            Logger.LogReturn($ResultName$);
            return $ResultName$;

        }
        #region Exception
        catch (Exception exp)
        {
            Logger.LogException("$ClassName$.$MethodName$", exp);
            throw;
        }
        #endregion Exception
   ]]>
  </Code>
</Snippet>

Answer 6

您可以查看 AoP 解决方案，例如 PostSharp。

Answer 7

您可以使用“插入片段”，但我认为最好使用 PostSharp 之类的东西将其实现为横切，而不是到处都有重复的代码。

你会做这样的事情，这将有效地生成上面的代码：

public class TraceAttribute : OnMethodBoundaryAspect
{
    public override void OnEntry(MethodExecutionEventArgs eventArgs)
    { 
        Tracing.StartOfMethod("Repository");
    }

    public override void OnExit(MethodExecutionEventArgs eventArgs)
    { 
        Tracing.EndOfMethod();
    }
}

Answer 8

正如 Kent Boogaart 指出的那样，这正是面向方面编程的发明目的。因此，您可以使用它，或者仅使用一些代码片段机制将代码作为模板插入到 IDE 中。

然而，我想说的是，在我看来，这是一种非常糟糕的编程风格。像这样的样板代码对于未来的维护和代码的可读性来说是一个沉重的负担。

我敦促您考虑其他选择。至少，您可以将样板代码放入“启动器”方法中，并让所有方法调用通过启动器方法传递，该方法会处理此问题。

在这种情况下，您的样板本身已经让我觉得非常有问题：

• 跟踪每个方法调用似乎有点矫枉过正。如果您确实需要这个，只需附加一个调试器，这就是它们的用途。如果您想跟踪生产中的内容，那么拥有有意义的日志消息会更有帮助（“开始 frob 处理...”、“已处理 x glurg 对象”）。这些也将对系统管理员等有所帮助，而您的消息只有在您知道源代码时才有用。
• 在我看来，在每种方法中捕获所有异常是完全不可原谅的。例外的一点是你可以让它们传播。仅在本地捕获您可以单独处理的异常；其余的应该转到调用堆栈上的通用处理程序。

也许您可以解释一下您编写此代码的动机？