C# ReturnStatement类代码示例

		protected override string GenerateCode(ITypeDefinition currentClass)
		{
//			string[] fields = listBox.SelectedItems.OfType<PropertyOrFieldWrapper>().Select(f2 => f2.MemberName).ToArray();
			string[] fields = parameterList.Where(f => f.IsIncluded).Select(f2 => f2.MemberName).ToArray();
			
			PrimitiveExpression formatString = new PrimitiveExpression(GenerateFormatString(currentClass, editor.Language.CodeGenerator, fields));
			List<Expression> param = new List<Expression>() { formatString };
			ReturnStatement ret = new ReturnStatement(new InvocationExpression(
				new MemberReferenceExpression(new TypeReferenceExpression(ConvertType(KnownTypeCode.String)), "Format"),
				param.Concat(fields.Select(f => new IdentifierExpression(f))).ToList()
			));
			
			if (baseCallNode != null) {
				MethodDeclaration insertedOverrideMethod = refactoringContext.GetNode().PrevSibling as MethodDeclaration;
				if (insertedOverrideMethod == null) {
					// We are not inside of a method declaration
					return null;
				}
				
				using (Script script = refactoringContext.StartScript()) {
					NewLineNode nextNewLineNode = insertedOverrideMethod.NextSibling as NewLineNode;
					
					// Find base method call and replace it by return statement
					script.AddTo(insertedOverrideMethod.Body, ret);
					AppendNewLine(script, insertedOverrideMethod, nextNewLineNode);
				}
			}
			
			return null;
		}

        public void InsertAfterStatementIndentsLikeStatement()
        {
            var input [email protected]"
public class Test
{
		void DoublyIndented()
		{
			System.Console.WriteLine(""hello"");
		}
}";
            var expected = @"
public class Test
{
		void DoublyIndented()
		{
			System.Console.WriteLine(""hello"");
			return;
		}
}";

            DoInsertAfterTest(input, expected, (syntaxTree, script) =>
            {
                var nodeToInsert = new ReturnStatement();
                var nodeToInsertAfter = syntaxTree.DescendantsAndSelf.OfType<ExpressionStatement>().Single();
                script.InsertAfter(nodeToInsertAfter,nodeToInsert);
            });
        }

        public void ReturnStatementProducesReturnWithValue()
        {
            var statement = new ReturnStatement(3);

            Assert.AreEqual(3, statement.Value);
            Assert.AreEqual("return 3;", statement.ToString());

            statement.Value = "Yes!";

            Assert.AreEqual("return \"Yes!\";", statement.ToString());
        }

 protected internal virtual void PostWalk(ReturnStatement node) { }

 // ReturnStatement
 protected internal virtual bool Walk(ReturnStatement node) { return true; }

			public override object Visit (Return returnStatement)
			{
				var result = new ReturnStatement ();
				
				result.AddChild (new CSharpTokenNode (Convert (returnStatement.loc), "return".Length), ReturnStatement.Roles.Keyword);
				if (returnStatement.Expr != null)
					result.AddChild ((INode)returnStatement.Expr.Accept (this), ReturnStatement.Roles.Expression);
				
				var location = LocationsBag.GetLocations (returnStatement);
				if (location != null)
					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ReturnStatement.Roles.Semicolon);
				
				return result;
			}

		public void VisitReturnStatement(ReturnStatement returnStatement)
		{
			StartNode(returnStatement);
			WriteKeyword(ReturnStatement.ReturnKeywordRole);
			if (!returnStatement.Expression.IsNull) {
				Space();
				returnStatement.Expression.AcceptVisitor(this);
			}
			Semicolon();
			EndNode(returnStatement);
		}

 public virtual void Visit(ReturnStatement expression)
 {
     if (expression.Expression != null)
     {
         outStream.Write("return ");
         expression.Expression.Accept(this);
     }
     else
         outStream.Write("return");
 }

		public virtual void VisitReturnStatement (ReturnStatement returnStatement)
		{
			VisitChildren (returnStatement);
		}

 public virtual void Exit(ReturnStatement node)
 {
 }

 // ReturnStatement
 public virtual bool Walk(ReturnStatement node) { return true; }

 public void VisitReturn(ReturnStatement r)
 {
     if (r.Expression != null)
         gen.Return(r.Expression.Accept(xlat));
     else
         gen.Return();
 }

 public virtual bool Enter(ReturnStatement node)
 {
     return true;
 }

			public override void VisitReturnStatement(ReturnStatement returnStatement)
			{
				if (!returnStatement.Expression.IsNull) {
					AddIssue(
						returnStatement, 
						string.Format (ctx.TranslateString("`{0}': A return keyword must not be followed by any expression when method returns void"), currentMethodName),
						new CodeAction (
							ctx.TranslateString("Remove returned expression"),
							script => {
								script.Remove(returnStatement.Expression); 
							}
						)
					);
				}
			}

        /// <summary>
        ///     Generates the code for a ReturnStatement node.
        /// </summary>
        /// <param name="rs">The ReturnStatement node.</param>
        /// <returns>String containing C# code for ReturnStatement rs.</returns>
        private string GenerateReturnStatement(ReturnStatement rs)
        {
            StringBuilder retVal = new StringBuilder();

            bool dump = FuncCallsMarc();

            if (IsParentEnumerable)
            {
                retVal.Append(GenerateLine("{ "));
                if (rs.kids.Count == 0)
                    retVal.Append(GenerateLine("yield break;", rs));
                else
                {
                    retVal.Append(Generate(string.Format("yield return ({0})(", _currentGlobalFunctionDeclaration.ReturnType), rs));
                    foreach (SYMBOL kid in rs.kids)
                        retVal.Append(GenerateNode(kid));
                    retVal.Append(GenerateLine(");", null));
                    retVal.Append(GenerateLine("yield break;", null));
                }
                retVal.Append(GenerateLine("}"));
            }
            else
            {
                retVal.Append(Generate(string.Format("return ({0})", _currentGlobalFunctionDeclaration.ReturnType), rs));

                foreach (SYMBOL kid in rs.kids)
                    retVal.Append(GenerateNode(kid));
            }
            if (dump)
                return DumpFunc(dump) + retVal.ToString() + DumpAfterFunc(dump);
            return retVal.ToString();
        }