/// <summary>
        /// The to formatted string.
        /// </summary>
        /// <param name="query">
        /// The query. 
        /// </param>
        /// <param name="tabs"> the tabs
        /// The tab indent level.
        /// </param>
        /// <returns>
        /// The System.String. 
        /// </returns>
        public static string ToFormattedString(this BookmarkResumptionQuery query, int tabs = 0)
        {
            var tsb = new TraceStringBuilder(tabs);

            tsb.AppendLine(query.GetType().Name);
            using (tsb.IndentBlock())
            {
                tsb.AppendLine("Name: {0}", query.Name);
                tsb.AppendDictionary("QueryAnnotations", query.QueryAnnotations);
            }

            return tsb.ToString();
        }
        /// <summary>
        /// The to formatted string.
        /// </summary>
        /// <param name="query">
        /// The query. 
        /// </param>
        /// <param name="tabs"> the tabsThe tabs count</param>
        /// <returns>
        /// The System.String. 
        /// </returns>
        public static string ToFormattedString(this ActivityScheduledQuery query, int tabs = 0)
        {
            var tsb = new TraceStringBuilder(tabs);

            tsb.AppendLine(query.GetType().Name);
            using (tsb.IndentBlock())
            {
                tsb.AppendLine("ActivityName: {0}", query.ActivityName);
                tsb.AppendLine("ChildActivityName: {0}", query.ChildActivityName);
                tsb.AppendDictionary("QueryAnnotations", query.QueryAnnotations);
            }

            return tsb.ToString();
        }
        /// <summary>
        /// The to formatted string.
        /// </summary>
        /// <param name="query">
        /// The query. 
        /// </param>
        /// <param name="tabs"> the tabs
        /// The tabs indent level.
        /// </param>
        /// <returns>
        /// The System.String. 
        /// </returns>
        public static string ToFormattedString(this FaultPropagationQuery query, int tabs = 0)
        {
            var tsb = new TraceStringBuilder(tabs);

            tsb.AppendLine(query.GetType().Name);
            using (tsb.IndentBlock())
            {
                tsb.AppendLine("FaultHandlerActivityName: {0}", query.FaultHandlerActivityName);
                tsb.AppendLine("FaultSourceActivityName: {0}", query.FaultSourceActivityName);
                tsb.AppendDictionary("QueryAnnotations", query.QueryAnnotations);
            }

            return tsb.ToString();
        }
        /// <summary>
        /// The to formatted string.
        /// </summary>
        /// <param name="query">
        /// The query. 
        /// </param>
        /// <param name="tabs"> the tabs
        /// The tabs.
        /// </param>
        /// <returns>
        /// The System.String. 
        /// </returns>
        public static string ToFormattedString(this ActivityStateQuery query, int tabs = 0)
        {
            var tsb = new TraceStringBuilder(tabs);

            tsb.AppendLine(query.GetType().Name);
            using (tsb.IndentBlock())
            {
                tsb.AppendLine("ActivityName: {0}", query.ActivityName);
                tsb.AppendCollection("Arguments", query.Arguments);
                tsb.AppendDictionary("QueryAnnotations", query.QueryAnnotations);
                tsb.AppendCollection("States", query.States);
                tsb.AppendCollection("Variables", query.Variables);
            }

            return tsb.ToString();
        }
        /// <summary>
        /// The to formatted string.
        /// </summary>
        /// <param name="trackingQuery">
        /// The tracking query. 
        /// </param>
        /// <param name="tabs"> the tabs
        /// The number of tabs 
        /// </param>
        /// <returns>
        /// The System.String. 
        /// </returns>
        public static string ToFormattedString(this TrackingQuery trackingQuery, int tabs = 0)
        {
            var activityScheduledQuery = trackingQuery as ActivityScheduledQuery;
            if (activityScheduledQuery != null)
            {
                return activityScheduledQuery.ToFormattedString(tabs);
            }

            var activityStateQuery = trackingQuery as ActivityStateQuery;
            if (activityStateQuery != null)
            {
                return activityStateQuery.ToFormattedString(tabs);
            }

            var bookmarkResumptionQuery = trackingQuery as BookmarkResumptionQuery;
            if (bookmarkResumptionQuery != null)
            {
                return bookmarkResumptionQuery.ToFormattedString(tabs);
            }

            var cancelRequestedQuery = trackingQuery as CancelRequestedQuery;
            if (cancelRequestedQuery != null)
            {
                return cancelRequestedQuery.ToFormattedString(tabs);
            }

            var customTrackingQuery = trackingQuery as CustomTrackingQuery;
            if (customTrackingQuery != null)
            {
                return customTrackingQuery.ToFormattedString(tabs);
            }

            var faultPropagationQuery = trackingQuery as FaultPropagationQuery;
            if (faultPropagationQuery != null)
            {
                return faultPropagationQuery.ToFormattedString(tabs);
            }

            var workflowInstanceQuery = trackingQuery as WorkflowInstanceQuery;
            if (workflowInstanceQuery != null)
            {
                return workflowInstanceQuery.ToFormattedString(tabs);
            }

            var tsb = new TraceStringBuilder(tabs);

            tsb.AppendLine(trackingQuery.GetType().Name);
            using (tsb.IndentBlock())
            {
                tsb.AppendDictionary("QueryAnnotations", trackingQuery.QueryAnnotations);
            }

            return tsb.ToString();
        }
        /// <summary>
        /// The to formatted string.
        /// </summary>
        /// <param name="trackingProfile">
        /// The tracking profile.
        /// </param>
        /// <param name="tabs"> the tabs
        /// The tabs.
        /// </param>
        /// <returns>
        /// The System.String.
        /// </returns>
        /// <exception cref="ArgumentNullException">
        /// An argument was null
        /// </exception>
        public static string ToFormattedString(this TrackingProfile trackingProfile, int tabs = 0)
        {
            Contract.Requires(trackingProfile != null);
            if (trackingProfile == null)
            {
                throw new ArgumentNullException("trackingProfile");
            }

            var tsb = new TraceStringBuilder(tabs);

            tsb.AppendTitle("Tracking profile: {0}", trackingProfile.Name);
            using (tsb.IndentBlock())
            {
                tsb.AppendLine("ActivityDefinitionId : {0}", trackingProfile.ActivityDefinitionId);
                tsb.AppendLine("ImplementationVisibility : {0}", trackingProfile.ImplementationVisibility);
                tsb.AppendCollection("Queries", trackingProfile.Queries, (trackingQuery, t) => trackingQuery.ToFormattedString(t));
            }

            var formattedString = tsb.ToString();
            return formattedString;
        }
        /// <summary>
        /// The to formatted string.
        /// </summary>
        /// <param name="query">
        /// The query. 
        /// </param>
        /// <param name="tabs"> the tabs
        /// The tabs. 
        /// </param>
        /// <returns>
        /// The System.String. 
        /// </returns>
        public static string ToFormattedString(this WorkflowInstanceQuery query, int tabs = 0)
        {
            var tsb = new TraceStringBuilder(tabs);

            tsb.AppendLine(query.GetType().Name);
            using (tsb.IndentBlock())
            {
                tsb.AppendCollection("States", query.States);
                tsb.AppendDictionary("QueryAnnotations", query.QueryAnnotations);
            }

            return tsb.ToString();
        }
        /// <summary>
        /// The to formatted string.
        /// </summary>
        /// <param name="tabs">
        /// the tabs The tabs. 
        /// </param>
        /// <returns>
        /// The System.String. 
        /// </returns>
        public string ToFormattedString(int tabs = 0)
        {
            var tsb = new TraceStringBuilder(tabs);
            tsb.AppendLine(this.GetType().Name);
            using (tsb.IndentBlock())
            {
                tsb.AppendProperty("Message", this.Message);
                tsb.AppendProperty("BookmarkName", this.BookmarkName);
                tsb.AppendProperty("Result", this.Result);
                tsb.AppendProperty("Value", this.Value);
            }

            return tsb.ToString();
        }
 /// <summary>
 /// The to formatted string.
 /// </summary>
 /// <param name="tabs">
 /// the tabs The tabs. 
 /// </param>
 /// <returns>
 /// The System.String. 
 /// </returns>
 public string ToFormattedString(int tabs = 0)
 {
     var tsb = new TraceStringBuilder(tabs);
     tsb.AppendLine(this.GetType().Name);
     tsb.AppendCollection("Children", this.Children);
     return tsb.ToString();
 }
        public void AppendPropertyIndentsNewLines()
        {
            // Arrange
            const string Expected = @"	Test
            MultiLine: Line 1
            Line 2
            Line 3
            ";
            const string MultiLine = @"Line 1
            Line 2
            Line 3";

            var tsb = new TraceStringBuilder(1);

            // Act
            tsb.AppendLine("Test");
            tsb.AppendProperty("MultiLine", MultiLine);
            var actual = tsb.ToString();
            Trace.WriteLine(actual);

            // Assert
            Assert.AreEqual(Expected, actual, this.StringsDifferAt(Expected, actual));
        }
        public void AppendPropertyAppendsTraceable()
        {
            // Arrange
            const string Expected = @"	Test
            Prop: TestTracable
            Children
            {
            ChildTraceable
            {
            }

            ChildTraceable
            {
            Strings
            {
                0
            }
            }

            ChildTraceable
            {
            Strings
            {
                0
                1
            }
            }

            ChildTraceable
            {
            Strings
            {
                0
                1
                2
            }
            }

            }
            ";

            var tsb = new TraceStringBuilder(1);
            var prop = new TestTracable();

            // Act
            tsb.AppendLine("Test");
            tsb.AppendProperty("Prop", prop);
            var actual = tsb.ToString();
            Trace.WriteLine(actual);

            // Assert
            Assert.AreEqual(Expected, actual, this.StringsDifferAt(Expected, actual));
        }
        public void AppendLineWithoutArgsAppendsText()
        {
            // Arrange
            const string Expected = "test";

            var tsb = new TraceStringBuilder();

            // Act
            tsb.AppendLine(Expected);
            var actual = tsb.ToString();

            // Assert
            Assert.AreEqual(Expected + Environment.NewLine, actual);
        }
        /// <summary>
        /// Creates a formatted string for tracing
        /// </summary>
        /// <param name="tabs"> the tabs
        /// The tab count 
        /// </param>
        /// <returns>
        /// A string 
        /// </returns>
        public string ToFormattedString(int tabs = 0)
        {
            var tsb = new TraceStringBuilder(tabs) { Options = WorkflowTraceOptions.ShowCollectionCount };
            tsb.AppendLine("State Machine: {0}", this.Name);
            using (tsb.IndentBlock())
            {
                tsb.AppendLine("InstanceId: {0}", this.InstanceId);
                tsb.AppendLine("Instance State: {0}", this.InstanceState);
                tsb.AppendLine("Current State: {0}", this.CurrentState);
                tsb.AppendLine("Previous State: {0}", this.PreviousState);
                tsb.AppendCollection("Possible Transitions", this.PossibleTransitions);
                tsb.AppendCollection("State History", this.StateHistory);
            }

            return tsb.ToString();
        }
        /// <summary>
        /// The to formatted string.
        /// </summary>
        /// <param name="tabs">
        /// the tabs The tabs. 
        /// </param>
        /// <returns>
        /// The System.String. 
        /// </returns>
        public string ToFormattedString(int tabs = 0)
        {
            var tsb = new TraceStringBuilder(tabs);
            tsb.AppendTitle(this.GetType().Name);
            using (tsb.IndentBlock())
            {
                var trackingProfile = this.TrackingProfile;
                if (trackingProfile != null)
                {
                    tsb.AppendLine(trackingProfile.ToFormattedString(tabs));
                }

                var trackingRecords = this.Records;
                if (trackingRecords != null)
                {
                    lock (this.syncLock)
                    {
                        foreach (var trackingRecord in trackingRecords)
                        {
                            tsb.AppendLine(trackingRecord.ToFormattedString(this.Option, tsb.Tabs).TrimStart());
                        }
                    }
                }
                else
                {
                    tsb.AppendLine(SR.No_tracking_records_to_trace);
                }
            }

            return tsb.ToString();
        }
Beispiel #15
0
 /// <summary>
 ///   The trace.
 /// </summary>
 public void Trace()
 {
     var tsb = new TraceStringBuilder();
     tsb.AppendLine(this.GetType().Name);
     tsb.AppendCollection("StateMachines", this.StateMachines);
     WorkflowTrace.Information(tsb.ToString());
 }
        public void AppendLineWithNullFormatThrowsArgumentNull()
        {
            const string Expected = @"Value cannot be null.
            Parameter name: format";

            // Arrange
            var tsb = new TraceStringBuilder();

            // Act / Assert
            AssertHelper.Throws<ArgumentNullException>(() => tsb.AppendLine(null), Expected);
        }
        /// <summary>
        /// Traces additional data about a tracking record
        /// </summary>
        /// <param name="tsb">
        /// The stringBuilder. 
        /// </param>
        /// <param name="option">
        /// A TrackingOptions value which specifies data to include in the trace 
        /// </param>
        /// <param name="instanceId">
        /// The instance ID of the tracking record 
        /// </param>
        /// <param name="annotations">
        /// The annotations dictionary 
        /// </param>
        /// <param name="arguments">
        /// The arguments dictionary 
        /// </param>
        /// <param name="variables">
        /// The variables dictionary 
        /// </param>
        /// <param name="data">
        /// The data dictionary 
        /// </param>
        /// <param name="eventTime">
        /// The event time 
        /// </param>
        internal static void AppendInstance(
            TraceStringBuilder tsb, 
            TrackingOption option, 
            Guid instanceId, 
            IDictionary<string, string> annotations, 
            IDictionary<string, object> arguments, 
            IDictionary<string, object> variables, 
            IDictionary<string, object> data, 
            DateTime eventTime)
        {
            if (!AnythingToTrace(option, tsb.Options, annotations, arguments, variables, data))
            {
                return;
            }

            tsb.AppendLine();

            using (tsb.IndentBlock())
            {
                if (option.HasFlag(TrackingOption.InstanceId))
                {
                    tsb.AppendProperty("InstanceId", instanceId);
                }

                if (option.HasFlag(TrackingOption.Time))
                {
                    tsb.AppendProperty("Event Time", eventTime.ToString(EventTimeFormat));
                }

                if (option.HasFlag(TrackingOption.Annotations))
                {
                    tsb.AppendDictionary("Annotations", annotations);
                }

                if (option.HasFlag(TrackingOption.Arguments))
                {
                    tsb.AppendDictionary("Arguments", arguments);
                }

                if (option.HasFlag(TrackingOption.Variables))
                {
                    tsb.AppendDictionary("Variables", variables);
                }

                if (option.HasFlag(TrackingOption.Data))
                {
                    tsb.AppendDictionary("Data", data);
                }
            }
        }