C# CodeActivityContext.GetValue方法代码示例

        /// <summary>
        /// Execute Activity
        /// </summary>
        /// <param name="context">code activity context </param>
        protected override void Execute(CodeActivityContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            var directoryInfo = context.GetValue(this.BaseDirectory);
            if (!directoryInfo.Exists)
            {
                return;
            }

            var searchDescription = context.GetValue(this.SearchDescription);
            var fileExtensions = context.GetValue(this.FileExtensions);

            var searchStrings = context.GetValue(this.SearchStrings);
            if (searchStrings == null || searchStrings.Length == 0)
            {
                return;
            }

            var matches = directoryInfo.Search(fileExtensions, searchStrings);

            // Write to build outputs log
            context.TrackBuildMessage(string.Format("{0}: {1} items found.", searchDescription, matches.Count), BuildMessageImportance.High);
            foreach (var match in matches)
            {
                var fileAndLine = string.Format("{0} ({1})", match.File.Name, match.LineNumber);
                context.TrackBuildMessage(string.Format("{0,-50} {1}", fileAndLine, match.LineText.Trim()), BuildMessageImportance.High);
            }

            // Set output
            this.MatchCount.Set(context, matches.Count);
        }

        /// <summary>
        /// Processes the conversion of the version number
        /// </summary>
        /// <param name="context"></param>
        protected override void Execute(CodeActivityContext context)
        {
            // Get the values passed in
            var versionPattern = context.GetValue(VersionPattern);
            var buildNumber = context.GetValue(BuildNumber);
            var buildNumberPrefix = context.GetValue(BuildNumberPrefix);

            var version = new StringBuilder();
            var addDot = false;

            // Validate the version pattern
            if (string.IsNullOrEmpty(versionPattern))
            {
                throw new ArgumentException("VersionPattern must contain the versioning pattern.");
            }

            var versionPatternArray = versionPattern.Split(new[] {'.'}, StringSplitOptions.RemoveEmptyEntries);

            // Go through each pattern and convert it
            foreach (var conversionItem in versionPatternArray)
            {
                if (addDot) { version.Append("."); }

                version.Append(VersioningHelper.ReplacePatternWithValue(conversionItem, buildNumber, buildNumberPrefix, DateTime.Now));

                addDot = true;
            }

            // Return the value back to the workflow
            context.SetValue(ConvertedVersionNumber, version.ToString());
        }

        /// <summary>
        /// Processes the conversion of the version number
        /// </summary>
        /// <param name="context"></param>
        protected override void Execute(CodeActivityContext context)
        {
            // Get the values passed in
            string propertyPattern = context.GetValue(PropertyPattern);
            IBuildDetail buildDetail = context.GetValue(BuildDetail);
            DateTime buildDate = context.GetValue(BuildDate);
            int buildNumberPrefix = context.GetValue(BuildNumberPrefix);

            // Validate the version pattern
            if (string.IsNullOrEmpty(propertyPattern))
            {
                throw new ArgumentException("PropertyPattern must contain a valid property replacement pattern.");
            }

            // Validate the version pattern
            if (buildDetail == null)
            {
                throw new ArgumentNullException("BuildDetail", "BuildDetail must contain a valid IBuildDetail value.");
            }

            string convertedValue = VersioningHelper.ReplacePatternWithValue(propertyPattern, buildDetail, buildDetail.BuildNumber, buildNumberPrefix, buildDate);

            // Return the value back to the workflow
            context.SetValue(ConvertedVersionNumber, convertedValue);
        }

        protected override void Execute(CodeActivityContext context)
        {
            TrackMessage(context, "Starting SVN action");

            string destinationPath = context.GetValue(this.DestinationPath);
            string svnPath = context.GetValue(this.SvnPath);
            string svnToolPath = context.GetValue(this.SvnToolPath);
            string svnCommandArgs = context.GetValue(this.SvnCommandArgs);
            SvnCredentials svnCredentials = context.GetValue(this.SvnCredentials);

            string svnCommand = Regex.Replace(svnCommandArgs, "{uri}", svnPath);
            svnCommand = Regex.Replace(svnCommand, "{destination}", destinationPath);
            svnCommand = Regex.Replace(svnCommand, "{username}", svnCredentials.Username);
            TrackMessage(context, "svn command: " + svnCommand);

            // Never reveal the password!
            svnCommand = Regex.Replace(svnCommand, "{password}", svnCredentials.Password);

            if (File.Exists(svnToolPath))
            {
                var process = Process.Start(svnToolPath, svnCommand);
                if (process != null)
                {
                    process.WaitForExit();
                    process.Close();
                }
            }

            TrackMessage(context, "End SVN action");
        }

        /// <summary>
        /// You need to put this activity in a different agent that write the diagnostics log that you want to change.
        /// </summary>
        /// <param name="context"></param>
        protected override void Execute(CodeActivityContext context)
        {
            Thread.Sleep(30000);

            var findAndReplace = context.GetValue(FindAndReplaceStrings);
            _teamProjectUri = context.GetValue(TeamProjectUri);
            _buildUri = context.GetValue(BuildUri);

            var vssCredential = new VssCredentials(true);
            _fcClient = new FileContainerHttpClient(_teamProjectUri, vssCredential);
            var containers = _fcClient.QueryContainersAsync(new List<Uri>() { _buildUri }).Result;

            if (!containers.Any())
                return;

            var agentLogs = GetAgentLogs(containers);

            if (agentLogs == null)
                return;

            using (var handler = new HttpClientHandler() { UseDefaultCredentials = true })
            {
                var reader = DownloadAgentLog(agentLogs, handler);

                using (var ms = new MemoryStream())
                {
                    ReplaceStrings(findAndReplace, reader, ms);
                    var response = UploadDocument(containers, agentLogs, ms);
                }
            }
        }

        protected override string ExecuteOperation(CodeActivityContext context)
        {
            var status = context.GetValue(Status);
            var hostedServiceName = context.GetValue<string>(HostedServiceName);
            var slot = context.GetValue(Slot).Description();

            var updateDeploymentStatus = new UpdateDeploymentStatusInput()
            {
                Status = status
            };

            using (new OperationContextScope((IContextChannel)channel))
            {
                try
                {
                    this.RetryCall(s => this.channel.UpdateDeploymentStatusBySlot(
                        s,
                        hostedServiceName,
                        slot,
                        updateDeploymentStatus));
                }
                catch (CommunicationException ex)
                {
                    throw new CommunicationExceptionEx(ex);
                }

                return RetrieveOperationId();
            }
        }

        protected override void Execute(CodeActivityContext context)
        {
            DynamicValue taskdata = context.GetValue(this.Data);

            DynamicValue MessageId = new DynamicValue();
            taskdata.TryGetValue("MessageId", out MessageId);

            IMessageStore messageStore = strICT.InFlow.Db.StoreHandler.getMessageStore(context.GetValue(cfgSQLConnectionString));
            M_Message message = messageStore.getMessageBymsgId(Convert.ToInt32(MessageId.ToString()));

            //store message-type in GlobalTransition
            context.SetValue(GlobalTransition, message.Sender_SubjectName + "|" + message.Message_Type);


            DynamicValue data = DynamicValue.Parse(message.Data);
            DynamicValue variables = context.GetValue(GlobalVariables);

            //write message data to GlobalVariables
            foreach (string i in data.Keys)
            {
                DynamicValue value = new DynamicValue();
                data.TryGetValue(i, out value);
                if (variables.ContainsKey(i))
                {
                    variables.Remove(i);
                }
                variables.Add(i, value);
            }
            context.SetValue(GlobalVariables, variables);

            //mark message in message-store as received
            messageStore.markMessageAsReceived(message.Id);      
        }

 // If your activity returns a value, derive from CodeActivity<TResult>
 // and return the value from the Execute method.
 protected override void Execute(CodeActivityContext context) {
     // Obtain the runtime value of the Text input argument
     StringBuilder salesMessage = new StringBuilder();
     salesMessage.AppendLine("*** Message To Sales ***");
     salesMessage.AppendLine("Please order the following ASAP!");
     salesMessage.AppendFormat("1 {0} {1}\n", context.GetValue(Color), context.GetValue(Make));
     System.IO.File.WriteAllText("SalesMemo.txt", salesMessage.ToString());
 }

        protected override void Execute(CodeActivityContext context)
        {
            string ticketId = context.GetValue(this.TicketId);
            var comment = context.GetValue(this.Comment);
            var approve = context.GetValue(this.Approve);

            Console.WriteLine(string.Format("\n[Review]> ticketid: {0}, {1} by leader, comment: {2}", ticketId, approve ? "approved" : "rejected", comment));
        }

        protected override void Execute(CodeActivityContext context)
        {
            var ticketId = context.GetValue(this.TicketId);
            var userId = context.GetValue(this.UserId);
            var start = context.GetValue(this.Start);
            var end = context.GetValue(this.End);

            Console.WriteLine(string.Format("\n> ticket {0} expired, userId: {1}, start: {2}, end: {3}.", ticketId, userId, start.ToShortDateString(), end.ToShortDateString()));
        }

        protected override void Execute(CodeActivityContext context)
        {
            transform = new XslCompiledTransform();

            String input = context.GetValue(this.InputXmlName);
            String output = context.GetValue(this.OutputXmlName);
            analyze(input, output);
            Console.Out.WriteLine(output);
        }

        protected override void Execute(CodeActivityContext context)
        {
            var a = context.GetValue(A);
            var b = context.GetValue(B);

            var result = Calculator.Add(a, b);

            Result.Set(context, result);
        }

        protected override void Execute(CodeActivityContext context)
        {
            #region Workflow Arguments

            // The TFS source location of the file to get
            var fileToGet = context.GetValue(FileToGet);

            // The current workspace - used to create a new workspace for the get
            var workspace = context.GetValue(Workspace);

            // The local build directory
            var buildDirectory = context.GetValue(BuildDirectory);

            var destinationSubfolderName = context.GetValue(DestinationSubfolderName);

            #endregion

            // File and path
            var versionFileDirectory = string.Format("{0}\\{1}", buildDirectory, destinationSubfolderName);
            var filename = Path.GetFileName(fileToGet);

            if (filename == null)
            {
                throw new ArgumentException("Filename must not be null");
            }

            var fullPathToFile = Path.Combine(versionFileDirectory, filename);

            // Write to the log
            context.WriteBuildMessage(string.Format("Getting file from Source: {0}", fileToGet), BuildMessageImportance.High);

            // Create workspace and working folder
            var tempWorkspace = workspace.VersionControlServer.CreateWorkspace("NuGetterTemp");
            var workingFolder = new WorkingFolder(fileToGet, fullPathToFile);

            // Map the workspace
            tempWorkspace.CreateMapping(workingFolder);

            // Get the file
            var request = new GetRequest(new ItemSpec(fileToGet, RecursionType.None), VersionSpec.Latest);
            var status = tempWorkspace.Get(request, GetOptions.GetAll | GetOptions.Overwrite);

            if (!status.NoActionNeeded)
            {
                foreach (var failure in status.GetFailures())
                {
                    context.WriteBuildMessage(string.Format("Failed to get file from source: {0} - {1}", fileToGet, failure.GetFormattedMessage()), BuildMessageImportance.High);
                }
            }

            // Return the value back to the workflow
            context.SetValue(FullPathToFile, fullPathToFile);

            // Get rid of the workspace
            tempWorkspace.Delete();
        }

        // If your activity returns a value, derive from CodeActivity<TResult>
        // and return the value from the Execute method.
        protected override void Execute(CodeActivityContext context)
        {
            // Obtain the runtime value of the Text input argument

            bool doFlush = context.GetValue(this.DoFlush);
            List<string> text = context.GetValue(this.Text);
            if (doFlush)
                context.GetExtension<List<string>>().Clear();
            context.GetExtension<List<string>>().AddRange(text);
        }

        protected override void Execute(CodeActivityContext context)
        {
            // Obtain the runtime value of the Text input argument
            Expense expense = context.GetValue(this.Expense);
            ExpenseReview review = context.GetValue(this.ExpenseReview);

            //expense.WorkflowID = this.WorkflowInstanceId;
            ExpenseComponent bc = new ExpenseComponent();
            context.SetValue(this.Expense, bc.Reject(expense, review));
        }