C# ActivityContext.GetExtension方法代码示例

        public VersionControlScope(VersionControlServer server, ActivityContext context)
        {
            this.Server = server;
            if (context != null)
            {
                this.ActionInvoker = context.GetExtension<ScheduleActionExtension>();
                if (this.ActionInvoker == null)
                {
                    throw new ServiceMissingException(typeof(ScheduleActionExtension));
                }
            }

            this.GettingHandlers = new List<Tuple<string, GettingEventHandler>>();
            this.NonFatalErrorHandlers = new List<Tuple<string, ExceptionEventHandler>>();
            this.NewPendingChangeHandlers = new List<Tuple<string, PendingChangeEventHandler>>();
        }

 private TimerExtension GetTimerExtension(ActivityContext context)
 {
     return context.GetExtension<TimerExtension>();
 }

        internal void InitializeChannelCacheEnabledSetting(ActivityContext context)
        {
            if (!this.channelCacheEnabled.HasValue)
            {
                SendMessageChannelCache channelCacheExtension = context.GetExtension<SendMessageChannelCache>();
                Fx.Assert(channelCacheExtension != null, "channelCacheExtension must exist!");

                InitializeChannelCacheEnabledSetting(channelCacheExtension);
            }
        }

		protected bool GetRunInProc(ActivityContext context)
		{
			bool flag = false;
			bool flag1;
			HostParameterDefaults extension = context.GetExtension<HostParameterDefaults>();
			if (this as PSGeneratedCIMActivity == null)
			{
				IEnumerator enumerator = context.DataContext.GetProperties().GetEnumerator();
				try
				{
					while (enumerator.MoveNext())
					{
						PropertyDescriptor current = (PropertyDescriptor)enumerator.Current;
						if (!string.Equals(current.DisplayName, "PSRunInProcessPreference", StringComparison.OrdinalIgnoreCase))
						{
							continue;
						}
						object value = current.GetValue(context.DataContext);
						if (value == null || !LanguagePrimitives.TryConvertTo<bool>(value, CultureInfo.InvariantCulture, out flag))
						{
							continue;
						}
						flag1 = flag;
						return flag1;
					}
					this.psActivityContextImplementationVariable.Get(context);
					PSWorkflowHost workflowHost = PSActivity.GetWorkflowHost(extension);
					return workflowHost.PSActivityHostController.RunInActivityController(this);
				}
				finally
				{
					IDisposable disposable = enumerator as IDisposable;
					if (disposable != null)
					{
						disposable.Dispose();
					}
				}
				return flag1;
			}
			else
			{
				return true;
			}
		}

            /// <summary>
            /// Make sure we have a log file in place.
            /// <para></para>
            /// If the user hasn't specified one we will create one for him on
            /// the logs drops folder path.
            /// <para></para>
            /// The file will have the same name as the solution/project being built, plus the
            /// context for configuration and platform with the .log file extension
            /// </summary>
            /// <param name="context">Activity Context</param>
            /// <returns>The location of the log file</returns>
            private string GenerateLogFile(ActivityContext context)
            {
                string finalLogFile = null;

                var buildDetail = context.GetExtension<IBuildDetail>();
                var filePath = this.FilePath.Get(this.ActivityContext);
                var configuration = this.Configuration.Get(this.ActivityContext);
                var platform = this.Platform.Get(this.ActivityContext);

                var fileName = Path.GetFileName(filePath);

                if (fileName != null)
                {
                    string logDirectory = string.IsNullOrEmpty(buildDetail.DropLocation)
                        ? Path.GetDirectoryName(filePath)
                        : Path.Combine(buildDetail.DropLocation, @"logs");

                    if (!Directory.Exists(logDirectory))
                    {
                        Directory.CreateDirectory(logDirectory);
                    }

                    finalLogFile = Path.GetFileNameWithoutExtension(fileName);

                    if (string.IsNullOrWhiteSpace(configuration) == false)
                    {
                        finalLogFile += configuration;
                    }

                    if (string.IsNullOrWhiteSpace(platform) == false)
                    {
                        finalLogFile += platform;
                    }

                    finalLogFile += ".log";

                    finalLogFile = Path.Combine(logDirectory, SanitizeFileName(finalLogFile));
                }

                this.LogBuildMessage(string.Format("Log file {0} will be used.", finalLogFile));

                return finalLogFile;
            }

 internal void InitializeChannelCacheEnabledSetting(ActivityContext context)
 {
     if (!this.channelCacheEnabled.HasValue)
     {
         SendMessageChannelCache extension = context.GetExtension<SendMessageChannelCache>();
         this.InitializeChannelCacheEnabledSetting(extension);
     }
 }

 TimerExtension GetTimerExtension(ActivityContext context)
 {
     TimerExtension timerExtension = context.GetExtension<TimerExtension>();
     Fx.Assert(timerExtension != null, "TimerExtension must exist.");
     return timerExtension;
 }

            /// <summary>
            /// Make sure we have a log file in place.
            /// <para></para>
            /// If the user hasn't specified one we will create one for him on
            /// the logs drops folder path.
            /// <para></para>
            /// The file will have the same name of the solution/project being built, plus the
            /// context for configuration and platform with the .log file extension
            /// </summary>
            /// <param name="context">Activity Context</param>
            /// <returns>The location of the log file</returns>
            private string GenerateLogFile(ActivityContext context)
            {
                string finalLogFile = null;
                string logDirectory;

                var buildDetail = context.GetExtension<IBuildDetail>();

                var fileName = this.LogFilename.Get(context);

                if (fileName == null)
                {
                    return null;
                }

                if (string.IsNullOrEmpty(buildDetail.LogLocation) == false)
                {
                    logDirectory = buildDetail.LogLocation;
                }
                else if (string.IsNullOrEmpty(buildDetail.DropLocation) == false)
                {
                    logDirectory = Path.Combine(buildDetail.DropLocation, @"logs");
                }
                else
                {
                    this.LogBuildWarning("drop location not defined. Will not write to log file");
                    return null;
                }

                if (!Directory.Exists(logDirectory))
                {
                    Directory.CreateDirectory(logDirectory);
                }

                finalLogFile = Path.Combine(logDirectory, SanitizeFileName(fileName));

                this.LogBuildMessage(string.Format("Log file {0} will be used.", finalLogFile));

                return finalLogFile;
            }