Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

531 lines
18 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Diagnostics
{
using System;
using System.Diagnostics;
using System.Runtime.Remoting.Messaging;
using System.Threading;
using System.Globalization;
using System.Collections.Generic;
using System.ServiceModel.Diagnostics.Application;
using System.Runtime.Diagnostics;
class ServiceModelActivity : IDisposable
{
[ThreadStatic]
static ServiceModelActivity currentActivity;
static string[] ActivityTypeNames = new string[(int)ActivityType.NumItems];
ServiceModelActivity previousActivity = null;
static string activityBoundaryDescription = null;
ActivityState lastState = ActivityState.Unknown;
string name = null;
bool autoStop = false;
bool autoResume = false;
Guid activityId;
bool disposed = false;
bool isAsync = false;
int stopCount = 0;
const int AsyncStopCount = 2;
TransferActivity activity = null;
ActivityType activityType = ActivityType.Unknown;
static ServiceModelActivity()
{
ActivityTypeNames[(int)ActivityType.Unknown] = "Unknown";
ActivityTypeNames[(int)ActivityType.Close] = "Close";
ActivityTypeNames[(int)ActivityType.Construct] = "Construct";
ActivityTypeNames[(int)ActivityType.ExecuteUserCode] = "ExecuteUserCode";
ActivityTypeNames[(int)ActivityType.ListenAt] = "ListenAt";
ActivityTypeNames[(int)ActivityType.Open] = "Open";
ActivityTypeNames[(int)ActivityType.OpenClient] = "Open";
ActivityTypeNames[(int)ActivityType.ProcessMessage] = "ProcessMessage";
ActivityTypeNames[(int)ActivityType.ProcessAction] = "ProcessAction";
ActivityTypeNames[(int)ActivityType.ReceiveBytes] = "ReceiveBytes";
ActivityTypeNames[(int)ActivityType.SecuritySetup] = "SecuritySetup";
ActivityTypeNames[(int)ActivityType.TransferToComPlus] = "TransferToComPlus";
ActivityTypeNames[(int)ActivityType.WmiGetObject] = "WmiGetObject";
ActivityTypeNames[(int)ActivityType.WmiPutInstance] = "WmiPutInstance";
}
ServiceModelActivity(Guid activityId)
{
this.activityId = activityId;
this.previousActivity = ServiceModelActivity.Current;
}
static string ActivityBoundaryDescription
{
get
{
if (ServiceModelActivity.activityBoundaryDescription == null)
{
ServiceModelActivity.activityBoundaryDescription = TraceSR.GetString(TraceSR.ActivityBoundary);
}
return ServiceModelActivity.activityBoundaryDescription;
}
}
internal ActivityType ActivityType
{
get { return this.activityType; }
}
internal ServiceModelActivity PreviousActivity
{
get { return this.previousActivity; }
}
static internal Activity BoundOperation(ServiceModelActivity activity)
{
if (!DiagnosticUtility.ShouldUseActivity)
{
return null;
}
return ServiceModelActivity.BoundOperation(activity, false);
}
static internal Activity BoundOperation(ServiceModelActivity activity, bool addTransfer)
{
return activity == null ? null : ServiceModelActivity.BoundOperationCore(activity, addTransfer);
}
static Activity BoundOperationCore(ServiceModelActivity activity, bool addTransfer)
{
if (!DiagnosticUtility.ShouldUseActivity)
{
return null;
}
TransferActivity retval = null;
if (activity != null)
{
retval = TransferActivity.CreateActivity(activity.activityId, addTransfer);
if (retval != null)
{
retval.SetPreviousServiceModelActivity(ServiceModelActivity.Current);
}
ServiceModelActivity.Current = activity;
}
return retval;
}
internal static ServiceModelActivity CreateActivity()
{
if (!DiagnosticUtility.ShouldUseActivity)
{
return null;
}
return ServiceModelActivity.CreateActivity(Guid.NewGuid(), true);
}
internal static ServiceModelActivity CreateActivity(bool autoStop)
{
if (!DiagnosticUtility.ShouldUseActivity)
{
return null;
}
ServiceModelActivity activity = ServiceModelActivity.CreateActivity(Guid.NewGuid(), true);
if (activity != null)
{
activity.autoStop = autoStop;
}
return activity;
}
internal static ServiceModelActivity CreateActivity(bool autoStop, string activityName, ActivityType activityType)
{
if (!DiagnosticUtility.ShouldUseActivity)
{
return null;
}
ServiceModelActivity activity = ServiceModelActivity.CreateActivity(autoStop);
ServiceModelActivity.Start(activity, activityName, activityType);
return activity;
}
internal static ServiceModelActivity CreateAsyncActivity()
{
if (!DiagnosticUtility.ShouldUseActivity)
{
return null;
}
ServiceModelActivity activity = ServiceModelActivity.CreateActivity(true);
if (activity != null)
{
activity.isAsync = true;
}
return activity;
}
internal static ServiceModelActivity CreateBoundedActivity()
{
return ServiceModelActivity.CreateBoundedActivity(false);
}
internal static ServiceModelActivity CreateBoundedActivity(bool suspendCurrent)
{
if (!DiagnosticUtility.ShouldUseActivity)
{
return null;
}
ServiceModelActivity activityToSuspend = ServiceModelActivity.Current;
ServiceModelActivity retval = ServiceModelActivity.CreateActivity(true);
if (retval != null)
{
retval.activity = (TransferActivity)ServiceModelActivity.BoundOperation(retval, true);
retval.activity.SetPreviousServiceModelActivity(activityToSuspend);
if (suspendCurrent)
{
retval.autoResume = true;
}
}
if (suspendCurrent && activityToSuspend != null)
{
activityToSuspend.Suspend();
}
return retval;
}
internal static ServiceModelActivity CreateBoundedActivity(Guid activityId)
{
if (!DiagnosticUtility.ShouldUseActivity)
{
return null;
}
ServiceModelActivity retval = ServiceModelActivity.CreateActivity(activityId, true);
if (retval != null)
{
retval.activity = (TransferActivity)ServiceModelActivity.BoundOperation(retval, true);
}
return retval;
}
internal static ServiceModelActivity CreateBoundedActivityWithTransferInOnly(Guid activityId)
{
if (!DiagnosticUtility.ShouldUseActivity)
{
return null;
}
ServiceModelActivity retval = ServiceModelActivity.CreateActivity(activityId, true);
if (retval != null)
{
if (null != FxTrace.Trace)
{
FxTrace.Trace.TraceTransfer(activityId);
}
retval.activity = (TransferActivity)ServiceModelActivity.BoundOperation(retval);
}
return retval;
}
internal static ServiceModelActivity CreateLightWeightAsyncActivity(Guid activityId)
{
return new ServiceModelActivity(activityId);
}
internal static ServiceModelActivity CreateActivity(Guid activityId)
{
if (!DiagnosticUtility.ShouldUseActivity)
{
return null;
}
ServiceModelActivity retval = null;
if (activityId != Guid.Empty)
{
retval = new ServiceModelActivity(activityId);
}
if (retval != null)
{
ServiceModelActivity.Current = retval;
}
return retval;
}
internal static ServiceModelActivity CreateActivity(Guid activityId, bool autoStop)
{
if (!DiagnosticUtility.ShouldUseActivity)
{
return null;
}
ServiceModelActivity retval = ServiceModelActivity.CreateActivity(activityId);
if (retval != null)
{
retval.autoStop = autoStop;
}
return retval;
}
internal static ServiceModelActivity Current
{
get { return ServiceModelActivity.currentActivity; }
private set { ServiceModelActivity.currentActivity = value; }
}
public void Dispose()
{
if (!this.disposed)
{
this.disposed = true;
try
{
if (this.activity != null)
{
this.activity.Dispose();
}
if (this.autoStop)
{
this.Stop();
}
if (this.autoResume &&
ServiceModelActivity.Current != null)
{
ServiceModelActivity.Current.Resume();
}
}
finally
{
ServiceModelActivity.Current = this.previousActivity;
GC.SuppressFinalize(this);
}
}
}
internal Guid Id
{
get { return this.activityId; }
}
ActivityState LastState
{
get { return this.lastState; }
set { this.lastState = value; }
}
internal string Name
{
get { return this.name; }
set { this.name = value; }
}
internal void Resume()
{
if (this.LastState == ActivityState.Suspend)
{
this.LastState = ActivityState.Resume;
this.TraceMilestone(TraceEventType.Resume);
}
}
internal void Resume(string activityName)
{
if (string.IsNullOrEmpty(this.Name))
{
this.name = activityName;
}
this.Resume();
}
static internal void Start(ServiceModelActivity activity, string activityName, ActivityType activityType)
{
if (activity != null && activity.LastState == ActivityState.Unknown)
{
activity.LastState = ActivityState.Start;
activity.name = activityName;
activity.activityType = activityType;
activity.TraceMilestone(TraceEventType.Start);
}
}
internal void Stop()
{
int newStopCount = 0;
if (this.isAsync)
{
newStopCount = Interlocked.Increment(ref this.stopCount);
}
if (this.LastState != ActivityState.Stop &&
(!this.isAsync || (this.isAsync && newStopCount >= ServiceModelActivity.AsyncStopCount)))
{
this.LastState = ActivityState.Stop;
this.TraceMilestone(TraceEventType.Stop);
}
}
static internal void Stop(ServiceModelActivity activity)
{
if (activity != null)
{
activity.Stop();
}
}
internal void Suspend()
{
if (this.LastState != ActivityState.Stop)
{
this.LastState = ActivityState.Suspend;
this.TraceMilestone(TraceEventType.Suspend);
}
}
public override string ToString()
{
return this.Id.ToString();
}
void TraceMilestone(TraceEventType type)
{
if (string.IsNullOrEmpty(this.Name))
{
if (null != FxTrace.Trace)
{
CallEtwMileStoneEvent(type, null);
}
if (null != DiagnosticUtility.DiagnosticTrace)
{
TraceUtility.TraceEventNoCheck(type, TraceCode.ActivityBoundary, ServiceModelActivity.ActivityBoundaryDescription, null, ServiceModelActivity.ActivityBoundaryDescription, (Exception)null);
}
}
else
{
if (null != FxTrace.Trace)
{
Dictionary<string, string> values = new Dictionary<string, string>(2);
values["ActivityName"] = this.Name;
values["ActivityType"] = ServiceModelActivity.ActivityTypeNames[(int)this.activityType];
using (DiagnosticUtility.ShouldUseActivity && Guid.Empty == activityId ? null : Activity.CreateActivity(this.Id))
{
CallEtwMileStoneEvent(type, new DictionaryTraceRecord(values));
}
}
if (null != DiagnosticUtility.DiagnosticTrace)
{
Dictionary<string, string> values = new Dictionary<string, string>(2);
values["ActivityName"] = this.Name;
values["ActivityType"] = ServiceModelActivity.ActivityTypeNames[(int)this.activityType];
TraceUtility.TraceEventNoCheck(type, TraceCode.ActivityBoundary, ServiceModelActivity.ActivityBoundaryDescription, new DictionaryTraceRecord(values), null, null, this.Id);
}
}
}
void CallEtwMileStoneEvent(TraceEventType type, DictionaryTraceRecord record)
{
switch (type)
{
case TraceEventType.Start:
if (TD.StartSignpostEventIsEnabled())
{
TD.StartSignpostEvent(record);
}
break;
case TraceEventType.Stop:
if (TD.StopSignpostEventIsEnabled())
{
TD.StopSignpostEvent(record);
}
break;
case TraceEventType.Suspend:
if (TD.SuspendSignpostEventIsEnabled())
{
TD.SuspendSignpostEvent(record);
}
break;
case TraceEventType.Resume:
if (TD.ResumeSignpostEventIsEnabled())
{
TD.ResumeSignpostEvent(record);
}
break;
}
}
enum ActivityState
{
Unknown,
Start,
Suspend,
Resume,
Stop,
}
class TransferActivity : Activity
{
bool addTransfer = false;
bool changeCurrentServiceModelActivity = false;
ServiceModelActivity previousActivity = null;
TransferActivity(Guid activityId, Guid parentId)
: base(activityId, parentId)
{
}
internal static TransferActivity CreateActivity(Guid activityId, bool addTransfer)
{
if (!DiagnosticUtility.ShouldUseActivity)
{
return null;
}
TransferActivity retval = null;
if (DiagnosticUtility.TracingEnabled && activityId != Guid.Empty)
{
Guid currentActivityId = DiagnosticTraceBase.ActivityId;
if (activityId != currentActivityId)
{
if (addTransfer)
{
if (null != FxTrace.Trace)
{
FxTrace.Trace.TraceTransfer(activityId);
}
}
TransferActivity activity = new TransferActivity(activityId, currentActivityId);
activity.addTransfer = addTransfer;
retval = activity;
}
}
return retval;
}
internal void SetPreviousServiceModelActivity(ServiceModelActivity previous)
{
this.previousActivity = previous;
this.changeCurrentServiceModelActivity = true;
}
public override void Dispose()
{
try
{
if (addTransfer)
{
// Make sure that we are transferring from our AID to the
// parent. It is possible for someone else to change the ambient
// in user code (MB 49318).
using (Activity.CreateActivity(this.Id))
{
if (null != FxTrace.Trace)
{
FxTrace.Trace.TraceTransfer(this.parentId);
}
}
}
}
finally
{
if (this.changeCurrentServiceModelActivity)
{
ServiceModelActivity.Current = this.previousActivity;
}
base.Dispose();
}
}
}
}
}