C# (CSharp) CodeUnitProxy Examples

Example #1

 /// <summary>
 /// Initializes a new instance of the GreaterThanExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="leftHandSide">The left hand side of the expression.</param>
 /// <param name="rightHandSide">The right hand side of the expression.</param>
 internal GreaterThanExpression(CodeUnitProxy proxy, Expression leftHandSide, Expression rightHandSide)
     : base(proxy, RelationalExpressionType.GreaterThan, leftHandSide, rightHandSide)
 {
     Param.Ignore(proxy, leftHandSide, rightHandSide);
 }

Example #2

 /// <summary>
 /// Initializes a new instance of the EqualsExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="leftHandSide">The left hand side of the expression.</param>
 /// <param name="rightHandSide">The right hand side of the expression.</param>
 internal EqualsExpression(CodeUnitProxy proxy, Expression leftHandSide, Expression rightHandSide)
     : base(proxy, AssignmentExpressionType.Equals, leftHandSide, rightHandSide)
 {
     Param.Ignore(proxy, leftHandSide, rightHandSide);
 }

Example #3

File: LeftShiftExpression.cs Project: sarvex/StyleCop

 /// <summary>
 /// Initializes a new instance of the LeftShiftExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="leftHandSide">The left hand side of the expression.</param>
 /// <param name="rightHandSide">The right hand side of the expression.</param>
 internal LeftShiftExpression(CodeUnitProxy proxy, Expression leftHandSide, Expression rightHandSide)
     : base(proxy, ArithmeticExpressionType.LeftShift, leftHandSide, rightHandSide)
 {
     Param.Ignore(proxy, leftHandSide, rightHandSide);
 }

Example #4

File: DereferenceExpression.cs Project: jonthegiant/StyleCop

 /// <summary>
 /// Initializes a new instance of the DereferenceExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="value">The value the operator is being applied to.</param>
 internal DereferenceExpression(CodeUnitProxy proxy, Expression value)
     : base(proxy, UnsafeAccessExpressionType.Dereference, value)
 {
     Param.Ignore(proxy, value);
 }

Example #5

File: PrefixIncrementExpression.cs Project: sarvex/StyleCop

 /// <summary>
 /// Initializes a new instance of the PrefixIncrementExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="value">The value being incremented.</param>
 internal PrefixIncrementExpression(CodeUnitProxy proxy, Expression value)
     : base(proxy, value, IncrementExpressionType.Prefix)
 {
     Param.Ignore(proxy, value);
 }

Example #6

 /// <summary>
 /// Initializes a new instance of the BitwiseComplementExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="value">The value the operator is being applied to.</param>
 internal BitwiseComplementExpression(CodeUnitProxy proxy, Expression value)
     : base(proxy, UnaryExpressionType.BitwiseComplement, value)
 {
     Param.Ignore(proxy, value);
 }

Example #7

File: BitwiseComplementExpression.cs Project: jonthegiant/StyleCop

 /// <summary>
 /// Initializes a new instance of the BitwiseComplementExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="value">The value the operator is being applied to.</param>
 internal BitwiseComplementExpression(CodeUnitProxy proxy, Expression value)
     : base(proxy, UnaryExpressionType.BitwiseComplement, value)
 {
     Param.Ignore(proxy, value);
 }

Example #8

File: ConditionalAndExpression.cs Project: sarvex/StyleCop

 /// <summary>
 /// Initializes a new instance of the ConditionalAndExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="leftHandSide">The left hand side of the expression.</param>
 /// <param name="rightHandSide">The right hand side of the expression.</param>
 internal ConditionalAndExpression(CodeUnitProxy proxy, Expression leftHandSide, Expression rightHandSide)
     : base(proxy, ConditionalLogicalExpressionType.ConditionalAnd, leftHandSide, rightHandSide)
 {
     Param.Ignore(proxy, leftHandSide, rightHandSide);
 }

Example #9

File: RightShiftExpression.cs Project: jonthegiant/StyleCop

 /// <summary>
 /// Initializes a new instance of the RightShiftExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="leftHandSide">The left hand side of the expression.</param>
 /// <param name="rightHandSide">The right hand side of the expression.</param>
 internal RightShiftExpression(CodeUnitProxy proxy, Expression leftHandSide, Expression rightHandSide)
     : base(proxy, ArithmeticExpressionType.RightShift, leftHandSide, rightHandSide)
 {
     Param.Ignore(proxy, leftHandSide, rightHandSide);
 }

Example #10

 /// <summary>
 /// Initializes a new instance of the DereferenceExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="value">The value the operator is being applied to.</param>
 internal DereferenceExpression(CodeUnitProxy proxy, Expression value)
     : base(proxy, UnsafeAccessExpressionType.Dereference, value)
 {
     Param.Ignore(proxy, value);
 }

Example #11

 /// <summary>
 /// Initializes a new instance of the NotEqualToExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="leftHandSide">The left hand side of the expression.</param>
 /// <param name="rightHandSide">The right hand side of the expression.</param>
 internal NotEqualToExpression(CodeUnitProxy proxy, Expression leftHandSide, Expression rightHandSide)
     : base(proxy, RelationalExpressionType.NotEqualTo, leftHandSide, rightHandSide)
 {
     Param.Ignore(proxy, leftHandSide, rightHandSide);
 }

Example #12

File: LogicalXorExpression.cs Project: jonthegiant/StyleCop

 /// <summary>
 /// Initializes a new instance of the LogicalXorExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="leftHandSide">The left hand side of the expression.</param>
 /// <param name="rightHandSide">The right hand side of the expression.</param>
 internal LogicalXorExpression(CodeUnitProxy proxy, Expression leftHandSide, Expression rightHandSide)
     : base(proxy, LogicalExpressionType.LogicalXor, leftHandSide, rightHandSide)
 {
     Param.Ignore(proxy, leftHandSide, rightHandSide);
 }

Example #13

 /// <summary>
 /// Initializes a new instance of the MemberAccessExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="leftHandSide">The left side of the operation.</param>
 /// <param name="rightHandSide">The member being accessed.</param>
 internal MemberAccessExpression(CodeUnitProxy proxy, Expression leftHandSide, LiteralExpression rightHandSide)
     : base(proxy, ExpressionType.MemberAccess, leftHandSide, rightHandSide)
 {
     Param.Ignore(proxy, leftHandSide, rightHandSide);
 }

Example #14

File: QualifiedAliasExpression.cs Project: sarvex/StyleCop

 /// <summary>
 /// Initializes a new instance of the QualifiedAliasExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="leftHandSide">The left side of the operation.</param>
 /// <param name="rightHandSide">The member being accessed.</param>
 internal QualifiedAliasExpression(CodeUnitProxy proxy, Expression leftHandSide, LiteralExpression rightHandSide)
     : base(proxy, ExpressionType.QualifiedAlias, leftHandSide, rightHandSide)
 {
     Param.Ignore(proxy, leftHandSide, rightHandSide);
 }

Example #15

File: NotEqualToExpression.cs Project: jonthegiant/StyleCop

 /// <summary>
 /// Initializes a new instance of the NotEqualToExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="leftHandSide">The left hand side of the expression.</param>
 /// <param name="rightHandSide">The right hand side of the expression.</param>
 internal NotEqualToExpression(CodeUnitProxy proxy, Expression leftHandSide, Expression rightHandSide)
     : base(proxy, RelationalExpressionType.NotEqualTo, leftHandSide, rightHandSide)
 {
     Param.Ignore(proxy, leftHandSide, rightHandSide);
 }

Example #16

File: PositiveExpression.cs Project: sarvex/StyleCop

 /// <summary>
 /// Initializes a new instance of the PositiveExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="value">The value the operator is being applied to.</param>
 internal PositiveExpression(CodeUnitProxy proxy, Expression value)
     : base(proxy, UnaryExpressionType.Positive, value)
 {
     Param.Ignore(proxy, value);
 }

Example #17

 /// <summary>
 /// Initializes a new instance of the PostfixDecrementExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="value">The value being decremented.</param>
 internal PostfixDecrementExpression(CodeUnitProxy proxy, Expression value)
     : base(proxy, value, DecrementExpressionType.Postfix)
 {
     Param.Ignore(proxy, value);
 }

Example #18

File: AddressOfExpression.cs Project: sarvex/StyleCop

 /// <summary>
 /// Initializes a new instance of the AddressOfExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="value">The value the operator is being applied to.</param>
 internal AddressOfExpression(CodeUnitProxy proxy, Expression value)
     : base(proxy, UnsafeAccessExpressionType.AddressOf, value)
 {
     Param.Ignore(proxy, value);
 }

Example #19

File: LambdaExpression.cs Project: jonthegiant/StyleCop

 /// <summary>
 /// Initializes a new instance of the LambdaExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 internal LambdaExpression(CodeUnitProxy proxy) 
     : base(proxy, ExpressionType.Lambda)
 {
     Param.Ignore(proxy);
 }

Example #20

File: MultiplicationExpression.cs Project: jonthegiant/StyleCop

 /// <summary>
 /// Initializes a new instance of the MultiplicationExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="leftHandSide">The left hand side of the expression.</param>
 /// <param name="rightHandSide">The right hand side of the expression.</param>
 internal MultiplicationExpression(CodeUnitProxy proxy, Expression leftHandSide, Expression rightHandSide)
     : base(proxy, ArithmeticExpressionType.Multiplication, leftHandSide, rightHandSide)
 {
     Param.Ignore(proxy, leftHandSide, rightHandSide);
 }

Example #21

File: NegativeExpression.cs Project: jonthegiant/StyleCop

 /// <summary>
 /// Initializes a new instance of the NegativeExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="value">The value the operator is being applied to.</param>
 internal NegativeExpression(CodeUnitProxy proxy, Expression value)
     : base(proxy, UnaryExpressionType.Negative, value)
 {
     Param.Ignore(proxy, value);
 }

Example #22

File: PostfixDecrementExpression.cs Project: jonthegiant/StyleCop

 /// <summary>
 /// Initializes a new instance of the PostfixDecrementExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="value">The value being decremented.</param>
 internal PostfixDecrementExpression(CodeUnitProxy proxy, Expression value)
     : base(proxy, value, DecrementExpressionType.Postfix)
 {
     Param.Ignore(proxy, value);
 }

Example #23

File: DivisionExpression.cs Project: sarvex/StyleCop

 /// <summary>
 /// Initializes a new instance of the DivisionExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="leftHandSide">The left hand side of the expression.</param>
 /// <param name="rightHandSide">The right hand side of the expression.</param>
 internal DivisionExpression(CodeUnitProxy proxy, Expression leftHandSide, Expression rightHandSide)
     : base(proxy, ArithmeticExpressionType.Division, leftHandSide, rightHandSide)
 {
     Param.Ignore(proxy, leftHandSide, rightHandSide);
 }

Example #24

 /// <summary>
 /// Initializes a new instance of the NotExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="value">The value the operator is being applied to.</param>
 internal NotExpression(CodeUnitProxy proxy, Expression value)
     : base(proxy, UnaryExpressionType.Not, value)
 {
     Param.Ignore(proxy, value);
 }

Example #25

File: PointerAccessExpression.cs Project: jonthegiant/StyleCop

 /// <summary>
 /// Initializes a new instance of the PointerAccessExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="leftHandSide">The left side of the operation.</param>
 /// <param name="rightHandSide">The member being accessed.</param>
 internal PointerAccessExpression(CodeUnitProxy proxy, Expression leftHandSide, LiteralExpression rightHandSide)
     : base(proxy, ExpressionType.PointerAccess, leftHandSide, rightHandSide)
 {
     Param.Ignore(proxy, leftHandSide, rightHandSide);
 }

Example #26

File: QualifiedAliasExpression.cs Project: jonthegiant/StyleCop

 /// <summary>
 /// Initializes a new instance of the QualifiedAliasExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="leftHandSide">The left side of the operation.</param>
 /// <param name="rightHandSide">The member being accessed.</param>
 internal QualifiedAliasExpression(CodeUnitProxy proxy, Expression leftHandSide, LiteralExpression rightHandSide)
     : base(proxy, ExpressionType.QualifiedAlias, leftHandSide, rightHandSide)
 {
     Param.Ignore(proxy, leftHandSide, rightHandSide);
 }

Example #27

File: GreaterThanExpression.cs Project: jonthegiant/StyleCop

 /// <summary>
 /// Initializes a new instance of the GreaterThanExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="leftHandSide">The left hand side of the expression.</param>
 /// <param name="rightHandSide">The right hand side of the expression.</param>
 internal GreaterThanExpression(CodeUnitProxy proxy, Expression leftHandSide, Expression rightHandSide)
     : base(proxy, RelationalExpressionType.GreaterThan, leftHandSide, rightHandSide)
 {
     Param.Ignore(proxy, leftHandSide, rightHandSide);
 }

Example #28

File: LogicalOrExpression.cs Project: sarvex/StyleCop

 /// <summary>
 /// Initializes a new instance of the LogicalOrExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="leftHandSide">The left hand side of the expression.</param>
 /// <param name="rightHandSide">The right hand side of the expression.</param>
 internal LogicalOrExpression(CodeUnitProxy proxy, Expression leftHandSide, Expression rightHandSide)
     : base(proxy, LogicalExpressionType.LogicalOr, leftHandSide, rightHandSide)
 {
     Param.Ignore(proxy, leftHandSide, rightHandSide);
 }

Example #29

File: ConditionalOrExpression.cs Project: jonthegiant/StyleCop

 /// <summary>
 /// Initializes a new instance of the ConditionalOrExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="leftHandSide">The left hand side of the expression.</param>
 /// <param name="rightHandSide">The right hand side of the expression.</param>
 internal ConditionalOrExpression(CodeUnitProxy proxy, Expression leftHandSide, Expression rightHandSide)
     : base(proxy, ConditionalLogicalExpressionType.ConditionalOr, leftHandSide, rightHandSide)
 {
     Param.Ignore(proxy, leftHandSide, rightHandSide);
 }

Example #30

File: DivisionEqualsExpression.cs Project: jonthegiant/StyleCop

 /// <summary>
 /// Initializes a new instance of the DivisionEqualsExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 /// <param name="leftHandSide">The left hand side of the expression.</param>
 /// <param name="rightHandSide">The right hand side of the expression.</param>
 internal DivisionEqualsExpression(CodeUnitProxy proxy, Expression leftHandSide, Expression rightHandSide)
     : base(proxy, AssignmentExpressionType.DivisionEquals, leftHandSide, rightHandSide)
 {
     Param.Ignore(proxy, leftHandSide, rightHandSide);
 }

Example #31

 /// <summary>
 /// Initializes a new instance of the LambdaExpression class.
 /// </summary>
 /// <param name="proxy">Proxy object for the expression.</param>
 internal LambdaExpression(CodeUnitProxy proxy)
     : base(proxy, ExpressionType.Lambda)
 {
     Param.Ignore(proxy);
 }