Statements.cs source code in C# .NET

                        
Code:
                         / 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / cdf / src / WF / Activities / Rules / Statements.cs / 1305376 / Statements.cs
                        

                        
                            using System; 
using System.Collections.Generic;
using System.Text;
using System.CodeDom;
using System.Reflection; 
using System.Globalization;
using System.Workflow.ComponentModel; 
using System.Workflow.ComponentModel.Compiler; 
using System.Workflow.Activities.Common;
 
namespace System.Workflow.Activities.Rules
{
    internal abstract class RuleCodeDomStatement
    { 
        internal abstract bool Validate(RuleValidation validation);
        internal abstract void Execute(RuleExecution execution); 
        internal abstract void AnalyzeUsage(RuleAnalysis analysis); 
        internal abstract void Decompile(StringBuilder decompilation);
        internal abstract bool Match(CodeStatement expression); 
        internal abstract CodeStatement Clone();
    }

    internal class ExpressionStatement : RuleCodeDomStatement 
    {
        private CodeExpressionStatement exprStatement; 
 
        private ExpressionStatement(CodeExpressionStatement exprStatement)
        { 
            this.exprStatement = exprStatement;
        }

        internal static RuleCodeDomStatement Create(CodeStatement statement) 
        {
            return new ExpressionStatement((CodeExpressionStatement)statement); 
        } 

        internal override bool Validate(RuleValidation validation) 
        {
            bool success = false;

            if (exprStatement.Expression == null) 
            {
                ValidationError error = new ValidationError(Messages.NullInvokeStatementExpression, ErrorNumbers.Error_ParameterNotSet); 
                error.UserData[RuleUserDataKeys.ErrorObject] = exprStatement; 
                validation.Errors.Add(error);
            } 
            else if (exprStatement.Expression is CodeMethodInvokeExpression)
            {
                RuleExpressionInfo exprInfo = RuleExpressionWalker.Validate(validation, exprStatement.Expression, false);
                success = (exprInfo != null); 
            }
            else 
            { 
                ValidationError error = new ValidationError(Messages.InvokeNotHandled, ErrorNumbers.Error_CodeExpressionNotHandled);
                error.UserData[RuleUserDataKeys.ErrorObject] = exprStatement; 
                validation.Errors.Add(error);
            }

            return success; 
        }
 
        internal override void AnalyzeUsage(RuleAnalysis analysis) 
        {
            RuleExpressionWalker.AnalyzeUsage(analysis, exprStatement.Expression, false, false, null); 
        }

        internal override void Execute(RuleExecution execution)
        { 
            RuleExpressionWalker.Evaluate(execution, exprStatement.Expression);
        } 
 
        internal override void Decompile(StringBuilder decompilation)
        { 
            if (exprStatement.Expression == null)
            {
                RuleEvaluationException exception = new RuleEvaluationException(Messages.InvokeStatementNull);
                exception.Data[RuleUserDataKeys.ErrorObject] = exprStatement; 
                throw exception;
            } 
 
            RuleExpressionWalker.Decompile(decompilation, exprStatement.Expression, null);
        } 

        internal override bool Match(CodeStatement comperand)
        {
            CodeExpressionStatement comperandStatement = comperand as CodeExpressionStatement; 
            return ((comperandStatement != null)
                && RuleExpressionWalker.Match(exprStatement.Expression, comperandStatement.Expression)); 
        } 

        internal override CodeStatement Clone() 
        {
            CodeExpressionStatement newStatement = new CodeExpressionStatement();
            newStatement.Expression = RuleExpressionWalker.Clone(exprStatement.Expression);
            return newStatement; 
        }
    } 
 
    internal class AssignmentStatement : RuleCodeDomStatement
    { 
        private CodeAssignStatement assignStatement;

        private AssignmentStatement(CodeAssignStatement assignStatement)
        { 
            this.assignStatement = assignStatement;
        } 
 
        internal static RuleCodeDomStatement Create(CodeStatement statement)
        { 
            return new AssignmentStatement((CodeAssignStatement)statement);
        }

        internal override bool Validate(RuleValidation validation) 
        {
            bool success = false; 
            string message; 
            RuleExpressionInfo lhsExprInfo = null;
 
            if (assignStatement.Left == null)
            {
                ValidationError error = new ValidationError(Messages.NullAssignLeft, ErrorNumbers.Error_LeftOperandMissing);
                error.UserData[RuleUserDataKeys.ErrorObject] = assignStatement; 
                validation.Errors.Add(error);
            } 
            else 
            {
                lhsExprInfo = validation.ExpressionInfo(assignStatement.Left); 
                if (lhsExprInfo == null)
                    lhsExprInfo = RuleExpressionWalker.Validate(validation, assignStatement.Left, true);
            }
 
            RuleExpressionInfo rhsExprInfo = null;
            if (assignStatement.Right == null) 
            { 
                ValidationError error = new ValidationError(Messages.NullAssignRight, ErrorNumbers.Error_RightOperandMissing);
                error.UserData[RuleUserDataKeys.ErrorObject] = assignStatement; 
                validation.Errors.Add(error);
            }
            else
            { 
                rhsExprInfo = RuleExpressionWalker.Validate(validation, assignStatement.Right, false);
            } 
 
            if (lhsExprInfo != null && rhsExprInfo != null)
            { 
                Type expressionType = rhsExprInfo.ExpressionType;
                Type assignmentType = lhsExprInfo.ExpressionType;

                if (assignmentType == typeof(NullLiteral)) 
                {
                    // Can't assign to a null literal. 
                    ValidationError error = new ValidationError(Messages.NullAssignLeft, ErrorNumbers.Error_LeftOperandInvalidType); 
                    error.UserData[RuleUserDataKeys.ErrorObject] = assignStatement;
                    validation.Errors.Add(error); 
                    success = false;
                }
                else if (assignmentType == expressionType)
                { 
                    // Easy case, they're both the same type.
                    success = true; 
                } 
                else
                { 
                    // The types aren't the same, but it still might be a legal assignment.
                    ValidationError error = null;
                    if (!RuleValidation.TypesAreAssignable(expressionType, assignmentType, assignStatement.Right, out error))
                    { 
                        if (error == null)
                        { 
                            message = string.Format(CultureInfo.CurrentCulture, Messages.AssignNotAllowed, RuleDecompiler.DecompileType(expressionType), RuleDecompiler.DecompileType(assignmentType)); 
                            error = new ValidationError(message, ErrorNumbers.Error_OperandTypesIncompatible);
                        } 
                        error.UserData[RuleUserDataKeys.ErrorObject] = assignStatement;
                        validation.Errors.Add(error);
                    }
                    else 
                    {
                        success = true; 
                    } 
                }
            } 

            return success;
        }
 
        internal override void AnalyzeUsage(RuleAnalysis analysis)
        { 
            // The left side of the assignment is modified. 
            RuleExpressionWalker.AnalyzeUsage(analysis, assignStatement.Left, false, true, null);
            // The right side of the assignment is read. 
            RuleExpressionWalker.AnalyzeUsage(analysis, assignStatement.Right, true, false, null);
        }

        internal override void Execute(RuleExecution execution) 
        {
            Type leftType = execution.Validation.ExpressionInfo(assignStatement.Left).ExpressionType; 
            Type rightType = execution.Validation.ExpressionInfo(assignStatement.Right).ExpressionType; 

            RuleExpressionResult leftResult = RuleExpressionWalker.Evaluate(execution, assignStatement.Left); 
            RuleExpressionResult rightResult = RuleExpressionWalker.Evaluate(execution, assignStatement.Right);
            leftResult.Value = Executor.AdjustType(rightType, rightResult.Value, leftType);
        }
 
        internal override void Decompile(StringBuilder decompilation)
        { 
            if (assignStatement.Right == null) 
            {
                RuleEvaluationException exception = new RuleEvaluationException(Messages.AssignRightNull); 
                exception.Data[RuleUserDataKeys.ErrorObject] = assignStatement;
                throw exception;
            }
            if (assignStatement.Left == null) 
            {
                RuleEvaluationException exception = new RuleEvaluationException(Messages.AssignLeftNull); 
                exception.Data[RuleUserDataKeys.ErrorObject] = assignStatement; 
                throw exception;
            } 

            RuleExpressionWalker.Decompile(decompilation, assignStatement.Left, null);
            decompilation.Append(" = ");
            RuleExpressionWalker.Decompile(decompilation, assignStatement.Right, null); 
        }
 
        internal override bool Match(CodeStatement comperand) 
        {
            CodeAssignStatement comperandStatement = comperand as CodeAssignStatement; 
            return ((comperandStatement != null)
                && RuleExpressionWalker.Match(assignStatement.Left, comperandStatement.Left)
                && RuleExpressionWalker.Match(assignStatement.Right, comperandStatement.Right));
        } 

        internal override CodeStatement Clone() 
        { 
            CodeAssignStatement newStatement = new CodeAssignStatement();
            newStatement.Left = RuleExpressionWalker.Clone(assignStatement.Left); 
            newStatement.Right = RuleExpressionWalker.Clone(assignStatement.Right);
            return newStatement;
        }
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
using System; 
using System.Collections.Generic;
using System.Text;
using System.CodeDom;
using System.Reflection; 
using System.Globalization;
using System.Workflow.ComponentModel; 
using System.Workflow.ComponentModel.Compiler; 
using System.Workflow.Activities.Common;
 
namespace System.Workflow.Activities.Rules
{
    internal abstract class RuleCodeDomStatement
    { 
        internal abstract bool Validate(RuleValidation validation);
        internal abstract void Execute(RuleExecution execution); 
        internal abstract void AnalyzeUsage(RuleAnalysis analysis); 
        internal abstract void Decompile(StringBuilder decompilation);
        internal abstract bool Match(CodeStatement expression); 
        internal abstract CodeStatement Clone();
    }

    internal class ExpressionStatement : RuleCodeDomStatement 
    {
        private CodeExpressionStatement exprStatement; 
 
        private ExpressionStatement(CodeExpressionStatement exprStatement)
        { 
            this.exprStatement = exprStatement;
        }

        internal static RuleCodeDomStatement Create(CodeStatement statement) 
        {
            return new ExpressionStatement((CodeExpressionStatement)statement); 
        } 

        internal override bool Validate(RuleValidation validation) 
        {
            bool success = false;

            if (exprStatement.Expression == null) 
            {
                ValidationError error = new ValidationError(Messages.NullInvokeStatementExpression, ErrorNumbers.Error_ParameterNotSet); 
                error.UserData[RuleUserDataKeys.ErrorObject] = exprStatement; 
                validation.Errors.Add(error);
            } 
            else if (exprStatement.Expression is CodeMethodInvokeExpression)
            {
                RuleExpressionInfo exprInfo = RuleExpressionWalker.Validate(validation, exprStatement.Expression, false);
                success = (exprInfo != null); 
            }
            else 
            { 
                ValidationError error = new ValidationError(Messages.InvokeNotHandled, ErrorNumbers.Error_CodeExpressionNotHandled);
                error.UserData[RuleUserDataKeys.ErrorObject] = exprStatement; 
                validation.Errors.Add(error);
            }

            return success; 
        }
 
        internal override void AnalyzeUsage(RuleAnalysis analysis) 
        {
            RuleExpressionWalker.AnalyzeUsage(analysis, exprStatement.Expression, false, false, null); 
        }

        internal override void Execute(RuleExecution execution)
        { 
            RuleExpressionWalker.Evaluate(execution, exprStatement.Expression);
        } 
 
        internal override void Decompile(StringBuilder decompilation)
        { 
            if (exprStatement.Expression == null)
            {
                RuleEvaluationException exception = new RuleEvaluationException(Messages.InvokeStatementNull);
                exception.Data[RuleUserDataKeys.ErrorObject] = exprStatement; 
                throw exception;
            } 
 
            RuleExpressionWalker.Decompile(decompilation, exprStatement.Expression, null);
        } 

        internal override bool Match(CodeStatement comperand)
        {
            CodeExpressionStatement comperandStatement = comperand as CodeExpressionStatement; 
            return ((comperandStatement != null)
                && RuleExpressionWalker.Match(exprStatement.Expression, comperandStatement.Expression)); 
        } 

        internal override CodeStatement Clone() 
        {
            CodeExpressionStatement newStatement = new CodeExpressionStatement();
            newStatement.Expression = RuleExpressionWalker.Clone(exprStatement.Expression);
            return newStatement; 
        }
    } 
 
    internal class AssignmentStatement : RuleCodeDomStatement
    { 
        private CodeAssignStatement assignStatement;

        private AssignmentStatement(CodeAssignStatement assignStatement)
        { 
            this.assignStatement = assignStatement;
        } 
 
        internal static RuleCodeDomStatement Create(CodeStatement statement)
        { 
            return new AssignmentStatement((CodeAssignStatement)statement);
        }

        internal override bool Validate(RuleValidation validation) 
        {
            bool success = false; 
            string message; 
            RuleExpressionInfo lhsExprInfo = null;
 
            if (assignStatement.Left == null)
            {
                ValidationError error = new ValidationError(Messages.NullAssignLeft, ErrorNumbers.Error_LeftOperandMissing);
                error.UserData[RuleUserDataKeys.ErrorObject] = assignStatement; 
                validation.Errors.Add(error);
            } 
            else 
            {
                lhsExprInfo = validation.ExpressionInfo(assignStatement.Left); 
                if (lhsExprInfo == null)
                    lhsExprInfo = RuleExpressionWalker.Validate(validation, assignStatement.Left, true);
            }
 
            RuleExpressionInfo rhsExprInfo = null;
            if (assignStatement.Right == null) 
            { 
                ValidationError error = new ValidationError(Messages.NullAssignRight, ErrorNumbers.Error_RightOperandMissing);
                error.UserData[RuleUserDataKeys.ErrorObject] = assignStatement; 
                validation.Errors.Add(error);
            }
            else
            { 
                rhsExprInfo = RuleExpressionWalker.Validate(validation, assignStatement.Right, false);
            } 
 
            if (lhsExprInfo != null && rhsExprInfo != null)
            { 
                Type expressionType = rhsExprInfo.ExpressionType;
                Type assignmentType = lhsExprInfo.ExpressionType;

                if (assignmentType == typeof(NullLiteral)) 
                {
                    // Can't assign to a null literal. 
                    ValidationError error = new ValidationError(Messages.NullAssignLeft, ErrorNumbers.Error_LeftOperandInvalidType); 
                    error.UserData[RuleUserDataKeys.ErrorObject] = assignStatement;
                    validation.Errors.Add(error); 
                    success = false;
                }
                else if (assignmentType == expressionType)
                { 
                    // Easy case, they're both the same type.
                    success = true; 
                } 
                else
                { 
                    // The types aren't the same, but it still might be a legal assignment.
                    ValidationError error = null;
                    if (!RuleValidation.TypesAreAssignable(expressionType, assignmentType, assignStatement.Right, out error))
                    { 
                        if (error == null)
                        { 
                            message = string.Format(CultureInfo.CurrentCulture, Messages.AssignNotAllowed, RuleDecompiler.DecompileType(expressionType), RuleDecompiler.DecompileType(assignmentType)); 
                            error = new ValidationError(message, ErrorNumbers.Error_OperandTypesIncompatible);
                        } 
                        error.UserData[RuleUserDataKeys.ErrorObject] = assignStatement;
                        validation.Errors.Add(error);
                    }
                    else 
                    {
                        success = true; 
                    } 
                }
            } 

            return success;
        }
 
        internal override void AnalyzeUsage(RuleAnalysis analysis)
        { 
            // The left side of the assignment is modified. 
            RuleExpressionWalker.AnalyzeUsage(analysis, assignStatement.Left, false, true, null);
            // The right side of the assignment is read. 
            RuleExpressionWalker.AnalyzeUsage(analysis, assignStatement.Right, true, false, null);
        }

        internal override void Execute(RuleExecution execution) 
        {
            Type leftType = execution.Validation.ExpressionInfo(assignStatement.Left).ExpressionType; 
            Type rightType = execution.Validation.ExpressionInfo(assignStatement.Right).ExpressionType; 

            RuleExpressionResult leftResult = RuleExpressionWalker.Evaluate(execution, assignStatement.Left); 
            RuleExpressionResult rightResult = RuleExpressionWalker.Evaluate(execution, assignStatement.Right);
            leftResult.Value = Executor.AdjustType(rightType, rightResult.Value, leftType);
        }
 
        internal override void Decompile(StringBuilder decompilation)
        { 
            if (assignStatement.Right == null) 
            {
                RuleEvaluationException exception = new RuleEvaluationException(Messages.AssignRightNull); 
                exception.Data[RuleUserDataKeys.ErrorObject] = assignStatement;
                throw exception;
            }
            if (assignStatement.Left == null) 
            {
                RuleEvaluationException exception = new RuleEvaluationException(Messages.AssignLeftNull); 
                exception.Data[RuleUserDataKeys.ErrorObject] = assignStatement; 
                throw exception;
            } 

            RuleExpressionWalker.Decompile(decompilation, assignStatement.Left, null);
            decompilation.Append(" = ");
            RuleExpressionWalker.Decompile(decompilation, assignStatement.Right, null); 
        }
 
        internal override bool Match(CodeStatement comperand) 
        {
            CodeAssignStatement comperandStatement = comperand as CodeAssignStatement; 
            return ((comperandStatement != null)
                && RuleExpressionWalker.Match(assignStatement.Left, comperandStatement.Left)
                && RuleExpressionWalker.Match(assignStatement.Right, comperandStatement.Right));
        } 

        internal override CodeStatement Clone() 
        { 
            CodeAssignStatement newStatement = new CodeAssignStatement();
            newStatement.Left = RuleExpressionWalker.Clone(assignStatement.Left); 
            newStatement.Right = RuleExpressionWalker.Clone(assignStatement.Right);
            return newStatement;
        }
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.

                        

                        

                        
                        

Link Menu

This book is available now!
Buy at Amazon US or
Buy at Amazon UK

• BrowserCapabilitiesCodeGenerator.cs
• ByteConverter.cs
• CharEnumerator.cs
• XmlObjectSerializerReadContextComplex.cs
• QilXmlReader.cs
• DataSourceHelper.cs
• CalendarDay.cs
• BuildManagerHost.cs
• FreezableDefaultValueFactory.cs
• DataGridViewCellPaintingEventArgs.cs
• HttpDictionary.cs
• DeviceContext2.cs
• UnmanagedMarshal.cs
• HttpListenerRequestUriBuilder.cs
• ReferencedAssembly.cs
• SerializerWriterEventHandlers.cs
• PageContentAsyncResult.cs
• StringFormat.cs
• PartialArray.cs
• RichTextBox.cs
• DesignerDeviceConfig.cs
• DocumentReference.cs
• ResizeBehavior.cs
• WeakRefEnumerator.cs
• XmlWriter.cs
• ZipIORawDataFileBlock.cs
• IISMapPath.cs
• DllNotFoundException.cs
• StrongTypingException.cs
• BinHexDecoder.cs
• Math.cs
• BitmapEffectDrawingContextState.cs
• ComponentResourceKeyConverter.cs
• ToolStripSeparator.cs
• ScrollItemPattern.cs
• Object.cs
• DragSelectionMessageFilter.cs
• VBIdentifierTrimConverter.cs
• DeclaredTypeValidatorAttribute.cs
• ButtonChrome.cs
• DrawingContextDrawingContextWalker.cs
• followingsibling.cs
• WindowCollection.cs
• XmlEnumAttribute.cs
• Normalization.cs
• BamlTreeUpdater.cs
• DBCSCodePageEncoding.cs
• _StreamFramer.cs
• HttpModuleActionCollection.cs
• SelectingProviderEventArgs.cs
• ClientBuildManager.cs
• DataControlReferenceCollection.cs
• ToolStripComboBox.cs
• BadImageFormatException.cs
• StylusDownEventArgs.cs
• GridViewColumnCollectionChangedEventArgs.cs
• CopyCodeAction.cs
• httpstaticobjectscollection.cs
• DataTableNewRowEvent.cs
• ResXResourceWriter.cs
• CompareInfo.cs
• NativeMethods.cs
• ResourceAttributes.cs
• ImageList.cs
• ObjectResult.cs
• _SslStream.cs
• RegexCompiler.cs
• SmiEventSink.cs
• HtmlTable.cs
• GridViewDeleteEventArgs.cs
• NextPreviousPagerField.cs
• EditorPartChrome.cs
• EventToken.cs
• ResizeBehavior.cs
• HideDisabledControlAdapter.cs
• InvalidContentTypeException.cs
• listitem.cs
• ContentElementAutomationPeer.cs
• BoundField.cs
• DaylightTime.cs
• DtrList.cs
• WsdlImporter.cs
• LinkedList.cs
• EventWaitHandleSecurity.cs
• OleDbReferenceCollection.cs
• FontDriver.cs
• TextTrailingCharacterEllipsis.cs
• XmlNamespaceDeclarationsAttribute.cs
• XmlBinaryReader.cs
• XmlDataLoader.cs
• FactoryRecord.cs
• CngKeyCreationParameters.cs
• PromptEventArgs.cs
• WorkflowServiceHost.cs
• SizeIndependentAnimationStorage.cs
• UxThemeWrapper.cs
• MD5.cs
• StartUpEventArgs.cs
• XmlSchemaObject.cs
• CapabilitiesSection.cs