本文整理汇总了C#中SyntaxGenerator.DefaultExpression方法的典型用法代码示例。如果您正苦于以下问题：C# SyntaxGenerator.DefaultExpression方法的具体用法？C# SyntaxGenerator.DefaultExpression怎么用？C# SyntaxGenerator.DefaultExpression使用的例子？那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类SyntaxGenerator的用法示例。
在下文中一共展示了SyntaxGenerator.DefaultExpression方法的2个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C#代码示例。
示例1: CreateEmptyRule
internal static FieldDeclarationSyntax CreateEmptyRule(SyntaxGenerator generator, string idName="Change me to the name of the above constant", string titleDefault="Enter a title for this diagnostic", string messageDefault="Enter a message to be displayed with this diagnostic",
string categoryDefault="Enter a category for this diagnostic (e.g. Formatting)", ExpressionSyntax severityDefault=null, ExpressionSyntax enabledDefault=null)
{
if (severityDefault == null)
{
severityDefault = generator.DefaultExpression(SyntaxFactory.ParseTypeName("DiagnosticSeverity")) as ExpressionSyntax;
}
if (enabledDefault == null)
{
enabledDefault = generator.DefaultExpression(generator.TypeExpression(SpecialType.System_Boolean)) as ExpressionSyntax;
}
var type = SyntaxFactory.ParseTypeName("DiagnosticDescriptor");
var arguments = new ArgumentSyntax[6];
var whitespace = " ";
var id = generator.LiteralExpression(idName);
var idArg = generator.Argument("id", RefKind.None, id).WithLeadingTrivia(SyntaxFactory.CarriageReturnLineFeed, SyntaxFactory.Whitespace(whitespace)) as ArgumentSyntax;
arguments[0] = idArg;
var title = generator.LiteralExpression(titleDefault);
var titleArg = generator.Argument("title", RefKind.None, title).WithLeadingTrivia(SyntaxFactory.Whitespace(whitespace)) as ArgumentSyntax;
arguments[1] = titleArg;
var message = generator.LiteralExpression(messageDefault);
var messageArg = generator.Argument("messageFormat", RefKind.None, message).WithLeadingTrivia(SyntaxFactory.Whitespace(whitespace)) as ArgumentSyntax;
arguments[2] = messageArg;
var category = generator.LiteralExpression(categoryDefault);
var categoryArg = generator.Argument("category", RefKind.None, category).WithLeadingTrivia(SyntaxFactory.Whitespace(whitespace)) as ArgumentSyntax;
arguments[3] = categoryArg;
var defaultSeverityArg = generator.Argument("defaultSeverity", RefKind.None, severityDefault).WithLeadingTrivia(SyntaxFactory.Whitespace(whitespace)) as ArgumentSyntax;
arguments[4] = defaultSeverityArg;
var enabledArg = generator.Argument("isEnabledByDefault", RefKind.None, enabledDefault).WithLeadingTrivia(SyntaxFactory.Whitespace(whitespace)) as ArgumentSyntax;
arguments[5] = enabledArg;
var identifier = SyntaxFactory.ParseToken("spacingRule");
var separators = new List<SyntaxToken>();
var separator = SyntaxFactory.ParseToken(",").WithTrailingTrivia(SyntaxFactory.CarriageReturnLineFeed);
separators.Add(separator);
separators.Add(separator);
separators.Add(separator);
separators.Add(separator);
separators.Add(separator);
var argumentsNewLines = SyntaxFactory.SeparatedList(arguments, separators);
var argumentList = SyntaxFactory.ArgumentList(argumentsNewLines);
var value = SyntaxFactory.ObjectCreationExpression(type, argumentList, null);
var initializer = SyntaxFactory.EqualsValueClause(value);
var variables = new SeparatedSyntaxList<VariableDeclaratorSyntax>();
var variable = SyntaxFactory.VariableDeclarator(identifier, null, initializer);
variables = variables.Add(variable);
var declaration = SyntaxFactory.VariableDeclaration(type.WithTrailingTrivia(SyntaxFactory.Whitespace(" ")), variables);
var modifiers = SyntaxFactory.TokenList(SyntaxFactory.ParseToken("internal").WithTrailingTrivia(SyntaxFactory.Whitespace(" ")), SyntaxFactory.ParseToken("static").WithTrailingTrivia(SyntaxFactory.Whitespace(" ")));
var rule = SyntaxFactory.FieldDeclaration(new SyntaxList<AttributeListSyntax>(), modifiers, declaration);
return rule;
}示例2: GetMethodStatementsSyntax
private static IEnumerable<SyntaxNode> GetMethodStatementsSyntax(
SyntaxGenerator syntaxGenerator,
SemanticModel semanticModel,
IMethodSymbol methodSymbol)
{
// GENERATED CODE (for every ref or out parameter):
//
// string someOutParameter;
// var someRefParameter = default(int);
for (var i = 0; i < methodSymbol.Parameters.Length; ++i)
{
var parameter = methodSymbol.Parameters[i];
if (parameter.RefKind == RefKind.Out)
{
yield return syntaxGenerator
.LocalDeclarationStatement(
syntaxGenerator.TypeExpression(parameter.Type),
GetNameForParameter(methodSymbol, parameter));
}
else if (parameter.RefKind == RefKind.Ref)
{
yield return syntaxGenerator
.LocalDeclarationStatement(
GetNameForParameter(methodSymbol, parameter),
initializer: syntaxGenerator.DefaultExpression(syntaxGenerator.TypeExpression(parameter.Type)));
}
}
var arguments = methodSymbol
.Parameters
.Select(x =>
syntaxGenerator
.Argument(
x.RefKind,
syntaxGenerator.IdentifierName(GetNameForParameter(methodSymbol, x))))
.ToList();
var typeArguments = methodSymbol
.TypeArguments
.Select(x => syntaxGenerator.TypeExpression(x))
.ToList();
var lambdaParameterName = GetUniqueName(methodSymbol);
var lambdaInvocation = syntaxGenerator
.MemberAccessExpression(
syntaxGenerator.IdentifierName(lambdaParameterName),
methodSymbol.Name);
if (typeArguments.Count > 0)
{
lambdaInvocation = syntaxGenerator
.WithTypeArguments(
lambdaInvocation,
typeArguments);
}
// GENERATED CODE (for every ref or out parameter):
//
// someOutParameter = this.GetOutParameterValue<string>(x => x.TheMethod(out someOutParameter), parameterIndex: 0);
// someRefParameter = this.GetRefParameterValue<int>(x => x.TheMethod(ref someRefParameter), parameterIndex: 0);
for (var i = 0; i < methodSymbol.Parameters.Length; ++i)
{
var parameter = methodSymbol.Parameters[i];
if (parameter.RefKind == RefKind.Out || parameter.RefKind == RefKind.Ref)
{
var nameOfMethodToCall = parameter.RefKind == RefKind.Out ? "GetOutParameterValue" : "GetRefParameterValue";
yield return syntaxGenerator
.AssignmentStatement(
syntaxGenerator.IdentifierName(parameter.Name),
syntaxGenerator
.InvocationExpression(
syntaxGenerator.MemberAccessExpression(
syntaxGenerator.ThisExpression(),
syntaxGenerator.GenericName(
nameOfMethodToCall,
typeArguments: syntaxGenerator.TypeExpression(parameter.Type))),
arguments: new[]
{
syntaxGenerator.ValueReturningLambdaExpression(
lambdaParameterName,
syntaxGenerator.InvocationExpression(
lambdaInvocation,
arguments: arguments)),
syntaxGenerator.LiteralExpression(i)
}));
}
}
// GENERATED CODE:
//
// [return] this.Apply(x => x.SomeMethod(param1, param2));
var applyInvocation = syntaxGenerator
.InvocationExpression(
syntaxGenerator.MemberAccessExpression(
syntaxGenerator.ThisExpression(),
"Apply"),
//.........这里部分代码省略.........