C# CodeDom.CodeSnippetExpression类代码示例

		public void CodeAssignStatementTest ()
		{
			CodeSnippetExpression cse1 = new CodeSnippetExpression("A");
			CodeSnippetExpression cse2 = new CodeSnippetExpression("B");

			CodeAssignStatement assignStatement = new CodeAssignStatement (cse1, cse2);
			statement = assignStatement;

			Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
				"A = B;{0}", NewLine), Generate (), "#1");

			assignStatement.Left = null;
			try {
				Generate ();
				Assert.Fail ("#2");
			} catch (ArgumentNullException) {
			}

			assignStatement.Left = cse1;
			Generate ();

			assignStatement.Right = null;
			try {
				Generate ();
				Assert.Fail ("#3");
			} catch (ArgumentNullException) {
			}

			assignStatement.Right = cse2;
			Generate ();
		}

		public void Constructor1 ()
		{
			string value = "mono";

			CodeSnippetExpression cse = new CodeSnippetExpression (value);
			Assert.IsNotNull (cse.Value, "#1");
			Assert.AreSame (value, cse.Value, "#2");
		}

 public TypescriptSnippetExpression(
     CodeSnippetExpression codeExpression, 
     CodeGeneratorOptions options)
 {
     _codeExpression = codeExpression;
     _options = options;
     System.Diagnostics.Debug.WriteLine("TypescriptSnippetExpression Created");
 }

		public void Constructor0 ()
		{
			CodeSnippetExpression cse = new CodeSnippetExpression ();
			Assert.IsNotNull (cse.Value, "#1");
			Assert.AreEqual (string.Empty, cse.Value, "#2");

			string value = "mono";
			cse.Value = value;
			Assert.IsNotNull (cse.Value, "#3");
			Assert.AreSame (value, cse.Value, "#4");

			cse.Value = null;
			Assert.IsNotNull (cse.Value, "#5");
			Assert.AreEqual (string.Empty, cse.Value, "#6");
		}

 private static void LoadEnumElement(XmlElement element, CodeTypeDeclaration codeType,
     out CodeMemberProperty codeProperty)
 {
     codeProperty = new CodeMemberProperty();
     string name = element.GetAttribute("name");
     CodeTypeDeclaration codeEnum = new CodeTypeDeclaration(ToPublicName(name) + "Enum");
     codeEnum.IsEnum = true;
     codeEnum.Members.Add(new CodeSnippetTypeMember(element.InnerText));
     codeType.Members.Add(codeEnum);
     CodeExpression defaultValue = null;
     if(element.HasAttribute("default"))
         defaultValue = new CodeSnippetExpression(
         JoinNames(codeEnum.Name, element.GetAttribute("default")));
     GenerateProperty(codeType, codeEnum.Name, name, out codeProperty, defaultValue);
 }

        /// <summary>
        /// Creates a reference to a collection based member field and initializes it with a new instance of the
        /// specified parameter type and adds a collection item to it.
        /// Sample values are used as the initializing expression.
        /// </summary>
        /// <param name="memberCollectionField">Name of the referenced collection field.</param>
        /// <param name="collectionInitializers">Defines the types of the new object list.</param>
        /// <returns>
        /// An assignment statement for the specified collection member field.
        /// </returns>
        /// <remarks>
        /// With a custom Type, this method produces a statement with a initializer like:
        /// <code>this.paths = new[] { pathsItem };</code>.
        /// where the item is defined like:
        /// <code>this.pathsItem = new PathItemType();</code>.
        /// myType of type System.Type:
        /// <code>this.pathsItem = "An Item";</code>.
        /// </remarks>
        public static CodeAssignStatement CreateAndInitializeCollectionField(
            //Type type,
            string memberCollectionField,
            params string[] collectionInitializers)
        {
            /*if (type == typeof(object))
            {

            }*/
            var fieldRef1 = new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), memberCollectionField);
            //CodeExpression assignExpr = CreateExpressionByType(type, memberCollectionField);
            var para = collectionInitializers.Aggregate((x, y) => x += "," + y);
            CodeExpression assignExpr = new CodeSnippetExpression("new[] { " + para + " }");

            return new CodeAssignStatement(fieldRef1, assignExpr);
        }

        public static void AddArgument(this CodeAttributeDeclaration attribute, string name, string value)
        {
            if (value == null)
                throw new ArgumentNullException("value");

            CodeExpression expression;
            // Use convention that if string starts with $ its a const
            if (value.StartsWith(SnippetIndicator.ToString()))
            {
                expression = new CodeSnippetExpression(value.TrimStart(SnippetIndicator));
            }
            else
            {
                expression = new CodePrimitiveExpression(value);
            }
            attribute.AddArgument(name, expression);
        }

        public static CodeStatement[] CreateMappingStatements(ClassMappingDescriptor descriptor, CodeGeneratorContext context)
        {
            Dictionary<string, List<MemberMappingDescriptor>> aggregateGroups = new Dictionary<string, List<MemberMappingDescriptor>>();
            List<CodeStatement> statements = new List<CodeStatement>(20);
            foreach (MemberMappingDescriptor member in descriptor.MemberDescriptors)
            {
                if (member.IsAggregateExpression)
                {
                    // group all agregates by expression to avoid multiple traversals over same path
                    //string path = GetPath(member.Expression);
                    string path = GetPath(descriptor, member);
                    if(!aggregateGroups.ContainsKey(path))
                        aggregateGroups[path] = new List<MemberMappingDescriptor>(1);
                    aggregateGroups[path].Add(member);
                }
                else
                {
                    CodeStatement[] st = CreateNonAggregateMappingStatements(descriptor, member, context);
                    if(member.HasNullValue)
                    {
                        CodeStatement[] falseStatements = st;
                        CodeStatement[] trueStatements = new CodeStatement[1];
                        trueStatements[0] = new CodeAssignStatement(
                            new CodeVariableReferenceExpression("target." + member.Member),
                            new CodeSnippetExpression(member.NullValue.ToString()));

                        string checkExpression = GetNullablePartsCheckExpression(member);
                        CodeExpression ifExpression = new CodeSnippetExpression(checkExpression);

                        st = new CodeStatement[1];
                        st[0] = new CodeConditionStatement(ifExpression, trueStatements, falseStatements);
                    }
                    statements.AddRange(st);
                }
            }

            foreach (List<MemberMappingDescriptor> group in aggregateGroups.Values)
            {
                    CodeStatement[] st = CreateAggregateMappingStatements(descriptor, group, context);
                    statements.AddRange(st);
            }

            return statements.ToArray();
        }

        //Create main method
        private void CreateEntryPoint(List<string> statements)
        {
            //Create an object and assign the name as "Main"
            CodeEntryPointMethod mymain = new CodeEntryPointMethod();
            mymain.Name = "Main";
            //Mark the access modifier for the main method as Public and //static
            mymain.Attributes = MemberAttributes.Public | MemberAttributes.Static;
            //Change string to statements
            if(statements != null){

                foreach (string item in statements) {
                    if (item != null) {
                        CodeSnippetExpression exp1 = new CodeSnippetExpression(@item);
                        CodeExpressionStatement ces1 = new CodeExpressionStatement(exp1);
                        mymain.Statements.Add(ces1);
                    }
                }
            }
            myclass.Members.Add(mymain);
        }

        /// <summary>
        /// if (string.IsNullOrEmpty(APIKey) == false)
        ///    request = request.WithAPIKey(APIKey)
        /// </summary>
        /// <returns></returns>
        internal CodeConditionStatement CreateWithApiKey()
        {
            // !string.IsNullOrEmpty(Key)
            var condition =
                new CodeSnippetExpression("!string.IsNullOrEmpty(" + ApiKeyServiceDecorator.PropertyName + ")");

            // if (...) {
            var block = new CodeConditionStatement(condition);

            // request = request.WithKey(APIKey)
            var getProperty = new CodePropertyReferenceExpression(
                new CodeThisReferenceExpression(), ApiKeyServiceDecorator.PropertyName);
            var request = new CodeMethodInvokeExpression(
                new CodeVariableReferenceExpression("request"), "WithKey", getProperty);

            var trueCase = new CodeAssignStatement(new CodeVariableReferenceExpression("request"), request);

            // }
            block.TrueStatements.Add(trueCase);

            return block;
        }

		public void Constructor1 ()
		{
			CodeSnippetExpression expression = new CodeSnippetExpression("exp");

			CodeEventReferenceExpression cere = new CodeEventReferenceExpression (
				expression, "mono");
			Assert.AreEqual ("mono", cere.EventName, "#1");
			Assert.IsNotNull (cere.TargetObject, "#2");
			Assert.AreSame (expression, cere.TargetObject, "#3");

			cere.EventName = null;
			Assert.IsNotNull (cere.EventName, "#4");
			Assert.AreEqual (string.Empty, cere.EventName, "#5");

			cere.TargetObject = null;
			Assert.IsNull (cere.TargetObject, "#6");

			cere = new CodeEventReferenceExpression ((CodeExpression) null,
				(string) null);
			Assert.IsNotNull (cere.EventName, "#7");
			Assert.AreEqual (string.Empty, cere.EventName, "#8");
			Assert.IsNull (cere.TargetObject, "#9");
		}

        public void CreateEntryPoint(ref CodeTypeDeclaration customClass)
        {
            //Create an object and assign the name as “Main”
            CodeEntryPointMethod main = new CodeEntryPointMethod();
            main.Name = "Main";

            //Mark the access modifier for the main method as Public and //static
            main.Attributes = MemberAttributes.Public | MemberAttributes.Static;

            //Provide defenition to the main method.
            //Create an object of the “Cmyclass” and invoke the method
            //by passing the required parameters.
            CodeSnippetExpression exp = new CodeSnippetExpression(CallingMethod(customClass));

            //Create expression statements for the snippets
            CodeExpressionStatement ces = new CodeExpressionStatement(exp);

            //Add the expression statements to the main method.
            main.Statements.Add(ces);

            //Add the main method to the class
            customClass.Members.Add(main);
        }

 private void GenerateConstructor(CodeTypeDeclaration taskClass)
 {
     CodeConstructor constructor = new CodeConstructor {
         Attributes = MemberAttributes.Public
     };
     CodeTypeReference createType = new CodeTypeReference("System.Resources.ResourceManager");
     CodeSnippetExpression expression = new CodeSnippetExpression(this.SurroundWithQuotes(this.taskParser.ResourceNamespace));
     CodeTypeReferenceExpression targetObject = new CodeTypeReferenceExpression("System.Reflection.Assembly");
     CodeMethodReferenceExpression method = new CodeMethodReferenceExpression(targetObject, "GetExecutingAssembly");
     CodeMethodInvokeExpression expression4 = new CodeMethodInvokeExpression(method, new CodeExpression[0]);
     CodeObjectCreateExpression expression5 = new CodeObjectCreateExpression(createType, new CodeExpression[] { expression, expression4 });
     CodeTypeReference reference2 = new CodeTypeReference(new CodeTypeReference("System.String"), 1);
     List<CodeExpression> list = new List<CodeExpression>();
     foreach (string str in this.taskParser.SwitchOrderList)
     {
         list.Add(new CodeSnippetExpression(this.SurroundWithQuotes(str)));
     }
     CodeArrayCreateExpression expression6 = new CodeArrayCreateExpression(reference2, list.ToArray());
     constructor.BaseConstructorArgs.Add(expression6);
     constructor.BaseConstructorArgs.Add(expression5);
     taskClass.Members.Add(constructor);
     if (this.GenerateComments)
     {
         constructor.Comments.Add(new CodeCommentStatement(Microsoft.Build.Shared.ResourceUtilities.FormatResourceString("StartSummary", new object[0]), true));
         string text = Microsoft.Build.Shared.ResourceUtilities.FormatResourceString("ConstructorDescription", new object[0]);
         constructor.Comments.Add(new CodeCommentStatement(text, true));
         constructor.Comments.Add(new CodeCommentStatement(Microsoft.Build.Shared.ResourceUtilities.FormatResourceString("EndSummary", new object[0]), true));
     }
 }

		protected override void GenerateSnippetExpression (CodeSnippetExpression e)
		{
		}

		protected override void GenerateSnippetExpression (CodeSnippetExpression expression)
		{
			Output.Write (expression.Value);
		}