C# CodeDom.CodeLinePragma类代码示例

        internal static void BuildExpressionSetup(ControlBuilder controlBuilder, CodeStatementCollection methodStatements, CodeStatementCollection statements, CodeLinePragma linePragma, bool isTwoWayBound, bool designerMode) {
            // {{controlType}} target;
            CodeVariableDeclarationStatement targetDecl = new CodeVariableDeclarationStatement(controlBuilder.ControlType, "dataBindingExpressionBuilderTarget");
            methodStatements.Add(targetDecl);

            CodeVariableReferenceExpression targetExp = new CodeVariableReferenceExpression(targetDecl.Name);

            // target = ({{controlType}}) sender;
            CodeAssignStatement setTarget = new CodeAssignStatement(targetExp,
                                                                    new CodeCastExpression(controlBuilder.ControlType,
                                                                                           new CodeArgumentReferenceExpression("sender")));
            setTarget.LinePragma = linePragma;
            statements.Add(setTarget);

            Type bindingContainerType = controlBuilder.BindingContainerType;
            CodeVariableDeclarationStatement containerDecl = new CodeVariableDeclarationStatement(bindingContainerType, "Container");
            methodStatements.Add(containerDecl);

            // {{containerType}} Container = ({{containerType}}) target.BindingContainer;
            CodeAssignStatement setContainer = new CodeAssignStatement(new CodeVariableReferenceExpression(containerDecl.Name),
                                                                       new CodeCastExpression(bindingContainerType,
                                                                                              new CodePropertyReferenceExpression(targetExp,
                                                                                                                                  "BindingContainer")));
            setContainer.LinePragma = linePragma;
            statements.Add(setContainer);
            string variableName = isTwoWayBound ? "BindItem" : "Item";
            GenerateItemTypeExpressions(controlBuilder, methodStatements, statements, linePragma, variableName);
            //Generate code for other variable as well at design time in addition to runtime variable for intellisense to work.
            if (designerMode) {
                GenerateItemTypeExpressions(controlBuilder, methodStatements, statements, linePragma, isTwoWayBound ?  "Item" : "BindItem");
            }
        }

		public void Constructor0 ()
		{
			CodeSnippetStatement css = new CodeSnippetStatement ();
			Assert.IsNull (css.LinePragma, "#1");

			Assert.IsNotNull (css.Value, "#2");
			Assert.AreEqual (string.Empty, css.Value, "#3");

			Assert.IsNotNull (css.StartDirectives, "#4");
			Assert.AreEqual (0, css.StartDirectives.Count, "#5");

			Assert.IsNotNull (css.EndDirectives, "#6");
			Assert.AreEqual (0, css.EndDirectives.Count, "#7");

			Assert.IsNotNull (css.UserData, "#8");
			Assert.AreEqual (typeof(ListDictionary), css.UserData.GetType (), "#9");
			Assert.AreEqual (0, css.UserData.Count, "#10");
			
			css.Value = null;
			Assert.IsNotNull (css.Value, "#11");
			Assert.AreEqual (string.Empty, css.Value, "#12");

			CodeLinePragma clp = new CodeLinePragma ("mono", 10);
			css.LinePragma = clp;
			Assert.IsNotNull (css.LinePragma, "#13");
			Assert.AreSame (clp, css.LinePragma, "#14");

			css.LinePragma = null;
			Assert.IsNull (css.LinePragma, "#15");
		}

	    public FieldInfo (int idx, UserType type, string name, CodeLinePragma line)
	    {
		Idx = idx;
		Type = type;
		Name = name;
		Line = line;
	    }

		public void Constructor0 ()
		{
			CodeGotoStatement cgs = new CodeGotoStatement ();
			Assert.IsNull (cgs.Label, "#1");

			Assert.IsNotNull (cgs.StartDirectives, "#2");
			Assert.AreEqual (0, cgs.StartDirectives.Count, "#3");

			Assert.IsNotNull (cgs.EndDirectives, "#4");
			Assert.AreEqual (0, cgs.EndDirectives.Count, "#5");

			Assert.IsNotNull (cgs.UserData, "#6");
			Assert.AreEqual (typeof(ListDictionary), cgs.UserData.GetType (), "#7");
			Assert.AreEqual (0, cgs.UserData.Count, "#8");

			Assert.IsNull (cgs.LinePragma, "#9");

			CodeLinePragma clp = new CodeLinePragma ("mono", 10);
			cgs.LinePragma = clp;
			Assert.IsNotNull (cgs.LinePragma, "#10");
			Assert.AreSame (clp, cgs.LinePragma, "#11");

			cgs.LinePragma = null;
			Assert.IsNull (cgs.LinePragma, "#12");

			string label = "mono";
			cgs.Label = label;
			Assert.AreSame (label, cgs.Label, "#13");
		}

	public StructureBuilder (NamespaceBuilder ns, CodeLinePragma loc, TypeAttributes attr) 
	    : base (BundleManagerBase.DefaultStructureClass, ns, loc, attr)
	{
	    BaseClass = new UserType (typeof (StructureTemplate));

	    ns.SetUserParams (this);
	}

        internal static void BuildEvalExpression(string field, string formatString, string propertyName,
            Type propertyType, ControlBuilder controlBuilder, CodeStatementCollection methodStatements, CodeStatementCollection statements, CodeLinePragma linePragma, bool isEncoded, ref bool hasTempObject) {

            // Altogether, this function will create a statement that looks like this:
            // if (this.Page.GetDataItem() != null) {
            //     target.{{propName}} = ({{propType}}) this.Eval(fieldName, formatString);
            // }

            //     this.Eval(fieldName, formatString)
            CodeMethodInvokeExpression evalExpr = new CodeMethodInvokeExpression();
            evalExpr.Method.TargetObject = new CodeThisReferenceExpression();
            evalExpr.Method.MethodName = EvalMethodName;
            evalExpr.Parameters.Add(new CodePrimitiveExpression(field));
            if (!String.IsNullOrEmpty(formatString)) {
                evalExpr.Parameters.Add(new CodePrimitiveExpression(formatString));
            }

            CodeStatementCollection evalStatements = new CodeStatementCollection();
            BuildPropertySetExpression(evalExpr, propertyName, propertyType, controlBuilder, methodStatements, evalStatements, linePragma, isEncoded, ref hasTempObject);

            // if (this.Page.GetDataItem() != null)
            CodeMethodInvokeExpression getDataItemExpr = new CodeMethodInvokeExpression();
            getDataItemExpr.Method.TargetObject = new CodePropertyReferenceExpression(new CodeThisReferenceExpression(), "Page");
            getDataItemExpr.Method.MethodName = GetDataItemMethodName;

            CodeConditionStatement ifStmt = new CodeConditionStatement();
            ifStmt.Condition = new CodeBinaryOperatorExpression(getDataItemExpr, 
                                                                CodeBinaryOperatorType.IdentityInequality, 
                                                                new CodePrimitiveExpression(null));
            ifStmt.TrueStatements.AddRange(evalStatements);
            statements.Add(ifStmt);
        }

	public EnumResultBuilder (string name, NamespaceBuilder ns, CodeLinePragma loc, TypeAttributes attr)
	{
	    if (name == null)
		throw new ArgumentNullException ();
	    
	    enumer = new TheEnum (name, ns, loc, attr);
	    result = new TheResult (name + "Result", ns, name, loc, attr);
	}

		public void Constructor0_Deny_Unrestricted ()
		{
			CodeLinePragma clp = new CodeLinePragma ();
			Assert.AreEqual (String.Empty, clp.FileName, "FileName");
			clp.FileName = "filename";
			Assert.AreEqual (0, clp.LineNumber, "LineNumber");
			clp.LineNumber = Int32.MinValue;
		}

		public void Constructor1_Deny_Unrestricted ()
		{
			CodeLinePragma clp = new CodeLinePragma ("filename", Int32.MaxValue);
			Assert.AreEqual ("filename", clp.FileName, "FileName");
			clp.FileName = String.Empty;
			Assert.AreEqual (Int32.MaxValue, clp.LineNumber, "LineNumber");
			clp.LineNumber = 0;
		}

	public MetaRuleBuilder (string name, NamespaceBuilder ns, CodeLinePragma loc, TypeAttributes attr)
	{
	    rb = new RuleBuilder (name, ns, loc, attr);
	    tmpl = new RuleTemplateBuilder (name + "RTemplate", rb, ns, loc, attr);

	    ns.AddMetaRule (this);
	    BaseClass = RuleType;
	}

	    public TheResult (string name, NamespaceBuilder ns, string ename, CodeLinePragma loc, TypeAttributes attr)
		: base (name, ns, loc, attr)
	    {
		etype = new UserType (ename);

		BaseClass = new UserType (typeof (EnumResult<>));
		BaseClass.AddTypeArgument (etype);
	    }

 private void AddOutputWriteStatement(CodeStatementCollection methodStatements, CodeExpression expr, CodeLinePragma linePragma)
 {
     CodeStatement outputWriteStatement = this.GetOutputWriteStatement(expr, false);
     if (linePragma != null)
     {
         outputWriteStatement.LinePragma = linePragma;
     }
     methodStatements.Add(outputWriteStatement);
 }

 public virtual void WriteLinePragma(CodeLinePragma pragma)
 {
     if (pragma == null)
     {
         WriteLinePragma(null, null);
     }
     else
     {
         WriteLinePragma(pragma.LineNumber, pragma.FileName);
     }
 }

        internal virtual void BuildExpression(BoundPropertyEntry bpe, ControlBuilder controlBuilder,
            CodeExpression controlReference, CodeStatementCollection methodStatements, CodeStatementCollection statements, CodeLinePragma linePragma, ref bool hasTempObject) {

            CodeExpression codeExpression = GetCodeExpression(bpe,
                bpe.ParsedExpressionData, new ExpressionBuilderContext(controlBuilder.VirtualPath));

            CodeDomUtility.CreatePropertySetStatements(methodStatements, statements,
                controlReference, bpe.Name, bpe.Type,
                codeExpression,
                linePragma);
        }

	protected TypeExpressedItem (string namebase, NamespaceBuilder ns, CodeLinePragma loc, TypeAttributes attrs)
	{
	    if (namebase == null)
		throw new ArgumentNullException ();

	    this.namebase = namebase;
	    location = loc;
	    this.attrs = attrs;

	    this.ns = ns;
	    ns.AddItem (this);
	}