Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / CompMod / System / Diagnostics / Debug.cs / 1305376 / Debug.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
/*
*/
#define DEBUG
namespace System.Diagnostics {
using System;
using System.Text;
using System.Reflection;
using System.Collections;
using System.Security.Permissions;
using System.Globalization;
///
/// Provides a set of properties and
/// methods
/// for debugging code.
///
public static class Debug {
#if !SILVERLIGHT
///
/// Gets
/// the collection of listeners that is monitoring the debug
/// output.
///
public static TraceListenerCollection Listeners {
[SecurityPermission(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)]
[HostProtection(SharedState=true)]
get {
return TraceInternal.Listeners;
}
}
///
/// Gets or sets a value indicating whether
///
public static bool AutoFlush {
[SecurityPermission(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)]
get {
return TraceInternal.AutoFlush;
}
[SecurityPermission(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)]
set {
TraceInternal.AutoFlush = value;
}
}
///
/// Gets or sets
/// the indent level.
///
public static int IndentLevel {
get { return TraceInternal.IndentLevel; }
set { TraceInternal.IndentLevel = value; }
}
///
/// Gets or sets the number of spaces in an indent.
///
public static int IndentSize {
get { return TraceInternal.IndentSize; }
set { TraceInternal.IndentSize = value; }
}
///
/// Clears the output buffer, and causes buffered data to
/// be written to the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void Flush() {
TraceInternal.Flush();
}
///
/// Clears the output buffer, and then closes the
///
[System.Diagnostics.Conditional("DEBUG")]
[SecurityPermission(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)]
public static void Close() {
TraceInternal.Close();
}
///
/// Checks for a condition, and outputs the callstack if the condition is
///
[System.Diagnostics.Conditional("DEBUG")]
public static void Assert(bool condition) {
TraceInternal.Assert(condition);
}
///
/// Checks for a condition, and displays a message if the condition is
///
///
[System.Diagnostics.Conditional("DEBUG")]
public static void Assert(bool condition, string message) {
TraceInternal.Assert(condition, message);
}
///
/// Checks for a condition, and displays both the specified messages if the condition
/// is
///
[System.Diagnostics.Conditional("DEBUG")]
public static void Assert(bool condition, string message, string detailMessage) {
TraceInternal.Assert(condition, message, detailMessage);
}
///
/// Checks for a condition, and displays both the specified messages if the condition
/// is
///
[System.Diagnostics.Conditional("DEBUG")]
public static void Assert(bool condition, string message, string detailMessageFormat, params Object[] args) {
TraceInternal.Assert(condition, message, String.Format(CultureInfo.InvariantCulture, detailMessageFormat, args));
}
///
/// Emits or displays a message for an assertion that always fails.
///
[System.Diagnostics.Conditional("DEBUG")]
public static void Fail(string message) {
TraceInternal.Fail(message);
}
///
/// Emits or displays both messages for an assertion that always fails.
///
[System.Diagnostics.Conditional("DEBUG")]
public static void Fail(string message, string detailMessage) {
TraceInternal.Fail(message, detailMessage);
}
[System.Diagnostics.Conditional("DEBUG")]
public static void Print(string message) {
TraceInternal.WriteLine(message);
}
[System.Diagnostics.Conditional("DEBUG")]
public static void Print(string format, params object[] args) {
TraceInternal.WriteLine(String.Format(CultureInfo.InvariantCulture, format, args));
}
///
/// Writes a message to the trace listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void Write(string message) {
TraceInternal.Write(message);
}
///
/// Writes the name of the value
/// parameter to the trace listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void Write(object value) {
TraceInternal.Write(value);
}
///
/// Writes a category name and message
/// to the trace listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void Write(string message, string category) {
TraceInternal.Write(message, category);
}
///
/// Writes a category name and the name of the value parameter to the trace
/// listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void Write(object value, string category) {
TraceInternal.Write(value, category);
}
///
/// Writes a message followed by a line terminator to the trace listeners in the
///
///
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteLine(string message) {
TraceInternal.WriteLine(message);
}
///
/// Writes the name of the value
/// parameter followed by a line terminator to the
/// trace listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteLine(object value) {
TraceInternal.WriteLine(value);
}
///
/// Writes a category name and message followed by a line terminator to the trace
/// listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteLine(string message, string category) {
TraceInternal.WriteLine(message, category);
}
///
/// Writes a category name and the name of the value
/// parameter followed by a line
/// terminator to the trace listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteLine(object value, string category) {
TraceInternal.WriteLine(value, category);
}
///
/// Writes a category name and the name of the value
/// parameter followed by a line
/// terminator to the trace listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteLine(string format, params object[] args) {
TraceInternal.WriteLine(String.Format(CultureInfo.InvariantCulture, format, args));
}
///
/// Writes a message to the trace listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteIf(bool condition, string message) {
TraceInternal.WriteIf(condition, message);
}
///
/// Writes the name of the value
/// parameter to the trace listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteIf(bool condition, object value) {
TraceInternal.WriteIf(condition, value);
}
///
/// Writes a category name and message
/// to the trace listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteIf(bool condition, string message, string category) {
TraceInternal.WriteIf(condition, message, category);
}
///
/// Writes a category name and the name of the value
/// parameter to the trace
/// listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteIf(bool condition, object value, string category) {
TraceInternal.WriteIf(condition, value, category);
}
///
/// Writes a message followed by a line terminator to the trace listeners in the
///
///
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteLineIf(bool condition, string message) {
TraceInternal.WriteLineIf(condition, message);
}
///
/// Writes the name of the value
/// parameter followed by a line terminator to the
/// trace listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteLineIf(bool condition, object value) {
TraceInternal.WriteLineIf(condition, value);
}
///
/// Writes a category name and message
/// followed by a line terminator to the trace
/// listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteLineIf(bool condition, string message, string category) {
TraceInternal.WriteLineIf(condition, message, category);
}
///
/// Writes a category name and the name of the value parameter followed by a line
/// terminator to the trace listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteLineIf(bool condition, object value, string category) {
TraceInternal.WriteLineIf(condition, value, category);
}
///
/// [To be supplied.]
///
[System.Diagnostics.Conditional("DEBUG")]
public static void Indent() {
TraceInternal.Indent();
}
///
/// [To be supplied.]
///
[System.Diagnostics.Conditional("DEBUG")]
public static void Unindent() {
TraceInternal.Unindent();
}
#else
static object s_ForLock = new Object();
// This is the number of characters that OutputDebugString chunks at.
const int internalWriteSize = 4091;
[System.Diagnostics.Conditional("DEBUG")]
public static void Assert(bool condition) {
Assert(condition, String.Empty, String.Empty);
}
[System.Diagnostics.Conditional("DEBUG")]
public static void Assert(bool condition, string message) {
Assert(condition, message, String.Empty);
}
[System.Diagnostics.Conditional("DEBUG")]
[System.Security.SecuritySafeCritical]
public static void Assert(bool condition, string message, string detailMessage) {
if (!condition) {
StackTrace stack = new StackTrace(true);
int userStackFrameIndex = 0;
string stackTrace;
try {
stackTrace = StackTraceToString(stack, userStackFrameIndex, stack.FrameCount - 1);
} catch {
stackTrace = "";
}
WriteAssert(stackTrace, message, detailMessage);
AssertWrapper.ShowAssert(stackTrace, stack.GetFrame(userStackFrameIndex), message, detailMessage);
}
}
// Given a stack trace and start and end frame indexes, construct a
// callstack that contains method, file and line number information.
[System.Security.SecuritySafeCritical]
private static string StackTraceToString(StackTrace trace, int startFrameIndex, int endFrameIndex) {
StringBuilder sb = new StringBuilder(512);
for (int i = startFrameIndex; i <= endFrameIndex; i++) {
StackFrame frame = trace.GetFrame(i);
MethodBase method = frame.GetMethod();
sb.Append(Environment.NewLine);
sb.Append(" at ");
if (method.ReflectedType != null) {
sb.Append(method.ReflectedType.Name);
} else {
// This is for global methods and this is what shows up in windbg.
sb.Append("");
}
sb.Append(".");
sb.Append(method.Name);
sb.Append("(");
ParameterInfo[] parameters = method.GetParameters();
for (int j = 0; j < parameters.Length; j++) {
ParameterInfo parameter = parameters[j];
if (j > 0)
sb.Append(", ");
sb.Append(parameter.ParameterType.Name);
sb.Append(" ");
sb.Append(parameter.Name);
}
sb.Append(") ");
sb.Append(frame.GetFileName());
int line = frame.GetFileLineNumber();
if (line > 0) {
sb.Append("(");
sb.Append(line.ToString(CultureInfo.InvariantCulture));
sb.Append(")");
}
}
sb.Append(Environment.NewLine);
return sb.ToString();
}
private static void WriteAssert(string stackTrace, string message, string detailMessage) {
string assertMessage = SR.GetString(SR.DebugAssertBanner) + Environment.NewLine
+ SR.GetString(SR.DebugAssertShortMessage) + Environment.NewLine
+ message + Environment.NewLine
+ SR.GetString(SR.DebugAssertLongMessage) + Environment.NewLine +
detailMessage + Environment.NewLine
+ stackTrace;
WriteLine(assertMessage);
}
[System.Diagnostics.Conditional("DEBUG")]
public static void Assert(bool condition, string message, string detailMessageFormat, params object[] args) {
Assert(condition, message, String.Format(detailMessageFormat, args));
}
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteLine(string message) {
// We don't want output from multiple threads to be interleaved.
lock (s_ForLock) {
message = message + "\r\n"; // Use Windows end line on *all* Platforms
// really huge messages mess up both VS and dbmon, so we chop it up into
// reasonable chunks if it's too big
if (message == null || message.Length <= internalWriteSize) {
internalWrite(message);
} else {
int offset;
for (offset = 0; offset < message.Length - internalWriteSize; offset += internalWriteSize) {
internalWrite(message.Substring(offset, internalWriteSize));
}
internalWrite(message.Substring(offset));
}
}
}
[System.Security.SecuritySafeCritical]
private static void internalWrite(string message) {
if (Debugger.IsLogging()) {
Debugger.Log(0, null, message);
#if !FEATURE_PAL
} else {
if (message == null)
Microsoft.Win32.SafeNativeMethods.OutputDebugString(String.Empty);
else
Microsoft.Win32.SafeNativeMethods.OutputDebugString(message);
#endif //!FEATURE_PAL
}
}
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteLine(object value) {
WriteLine((value == null) ? String.Empty : value.ToString());
}
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteLine(string format, params object[] args) {
WriteLine(String.Format(null, format, args));
}
#endif // SILVERLIGHT
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
/*
*/
#define DEBUG
namespace System.Diagnostics {
using System;
using System.Text;
using System.Reflection;
using System.Collections;
using System.Security.Permissions;
using System.Globalization;
///
/// Provides a set of properties and
/// methods
/// for debugging code.
///
public static class Debug {
#if !SILVERLIGHT
///
/// Gets
/// the collection of listeners that is monitoring the debug
/// output.
///
public static TraceListenerCollection Listeners {
[SecurityPermission(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)]
[HostProtection(SharedState=true)]
get {
return TraceInternal.Listeners;
}
}
///
/// Gets or sets a value indicating whether
///
public static bool AutoFlush {
[SecurityPermission(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)]
get {
return TraceInternal.AutoFlush;
}
[SecurityPermission(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)]
set {
TraceInternal.AutoFlush = value;
}
}
///
/// Gets or sets
/// the indent level.
///
public static int IndentLevel {
get { return TraceInternal.IndentLevel; }
set { TraceInternal.IndentLevel = value; }
}
///
/// Gets or sets the number of spaces in an indent.
///
public static int IndentSize {
get { return TraceInternal.IndentSize; }
set { TraceInternal.IndentSize = value; }
}
///
/// Clears the output buffer, and causes buffered data to
/// be written to the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void Flush() {
TraceInternal.Flush();
}
///
/// Clears the output buffer, and then closes the
///
[System.Diagnostics.Conditional("DEBUG")]
[SecurityPermission(SecurityAction.LinkDemand, Flags=SecurityPermissionFlag.UnmanagedCode)]
public static void Close() {
TraceInternal.Close();
}
///
/// Checks for a condition, and outputs the callstack if the condition is
///
[System.Diagnostics.Conditional("DEBUG")]
public static void Assert(bool condition) {
TraceInternal.Assert(condition);
}
///
/// Checks for a condition, and displays a message if the condition is
///
///
[System.Diagnostics.Conditional("DEBUG")]
public static void Assert(bool condition, string message) {
TraceInternal.Assert(condition, message);
}
///
/// Checks for a condition, and displays both the specified messages if the condition
/// is
///
[System.Diagnostics.Conditional("DEBUG")]
public static void Assert(bool condition, string message, string detailMessage) {
TraceInternal.Assert(condition, message, detailMessage);
}
///
/// Checks for a condition, and displays both the specified messages if the condition
/// is
///
[System.Diagnostics.Conditional("DEBUG")]
public static void Assert(bool condition, string message, string detailMessageFormat, params Object[] args) {
TraceInternal.Assert(condition, message, String.Format(CultureInfo.InvariantCulture, detailMessageFormat, args));
}
///
/// Emits or displays a message for an assertion that always fails.
///
[System.Diagnostics.Conditional("DEBUG")]
public static void Fail(string message) {
TraceInternal.Fail(message);
}
///
/// Emits or displays both messages for an assertion that always fails.
///
[System.Diagnostics.Conditional("DEBUG")]
public static void Fail(string message, string detailMessage) {
TraceInternal.Fail(message, detailMessage);
}
[System.Diagnostics.Conditional("DEBUG")]
public static void Print(string message) {
TraceInternal.WriteLine(message);
}
[System.Diagnostics.Conditional("DEBUG")]
public static void Print(string format, params object[] args) {
TraceInternal.WriteLine(String.Format(CultureInfo.InvariantCulture, format, args));
}
///
/// Writes a message to the trace listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void Write(string message) {
TraceInternal.Write(message);
}
///
/// Writes the name of the value
/// parameter to the trace listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void Write(object value) {
TraceInternal.Write(value);
}
///
/// Writes a category name and message
/// to the trace listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void Write(string message, string category) {
TraceInternal.Write(message, category);
}
///
/// Writes a category name and the name of the value parameter to the trace
/// listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void Write(object value, string category) {
TraceInternal.Write(value, category);
}
///
/// Writes a message followed by a line terminator to the trace listeners in the
///
///
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteLine(string message) {
TraceInternal.WriteLine(message);
}
///
/// Writes the name of the value
/// parameter followed by a line terminator to the
/// trace listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteLine(object value) {
TraceInternal.WriteLine(value);
}
///
/// Writes a category name and message followed by a line terminator to the trace
/// listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteLine(string message, string category) {
TraceInternal.WriteLine(message, category);
}
///
/// Writes a category name and the name of the value
/// parameter followed by a line
/// terminator to the trace listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteLine(object value, string category) {
TraceInternal.WriteLine(value, category);
}
///
/// Writes a category name and the name of the value
/// parameter followed by a line
/// terminator to the trace listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteLine(string format, params object[] args) {
TraceInternal.WriteLine(String.Format(CultureInfo.InvariantCulture, format, args));
}
///
/// Writes a message to the trace listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteIf(bool condition, string message) {
TraceInternal.WriteIf(condition, message);
}
///
/// Writes the name of the value
/// parameter to the trace listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteIf(bool condition, object value) {
TraceInternal.WriteIf(condition, value);
}
///
/// Writes a category name and message
/// to the trace listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteIf(bool condition, string message, string category) {
TraceInternal.WriteIf(condition, message, category);
}
///
/// Writes a category name and the name of the value
/// parameter to the trace
/// listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteIf(bool condition, object value, string category) {
TraceInternal.WriteIf(condition, value, category);
}
///
/// Writes a message followed by a line terminator to the trace listeners in the
///
///
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteLineIf(bool condition, string message) {
TraceInternal.WriteLineIf(condition, message);
}
///
/// Writes the name of the value
/// parameter followed by a line terminator to the
/// trace listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteLineIf(bool condition, object value) {
TraceInternal.WriteLineIf(condition, value);
}
///
/// Writes a category name and message
/// followed by a line terminator to the trace
/// listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteLineIf(bool condition, string message, string category) {
TraceInternal.WriteLineIf(condition, message, category);
}
///
/// Writes a category name and the name of the value parameter followed by a line
/// terminator to the trace listeners in the
///
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteLineIf(bool condition, object value, string category) {
TraceInternal.WriteLineIf(condition, value, category);
}
///
/// [To be supplied.]
///
[System.Diagnostics.Conditional("DEBUG")]
public static void Indent() {
TraceInternal.Indent();
}
///
/// [To be supplied.]
///
[System.Diagnostics.Conditional("DEBUG")]
public static void Unindent() {
TraceInternal.Unindent();
}
#else
static object s_ForLock = new Object();
// This is the number of characters that OutputDebugString chunks at.
const int internalWriteSize = 4091;
[System.Diagnostics.Conditional("DEBUG")]
public static void Assert(bool condition) {
Assert(condition, String.Empty, String.Empty);
}
[System.Diagnostics.Conditional("DEBUG")]
public static void Assert(bool condition, string message) {
Assert(condition, message, String.Empty);
}
[System.Diagnostics.Conditional("DEBUG")]
[System.Security.SecuritySafeCritical]
public static void Assert(bool condition, string message, string detailMessage) {
if (!condition) {
StackTrace stack = new StackTrace(true);
int userStackFrameIndex = 0;
string stackTrace;
try {
stackTrace = StackTraceToString(stack, userStackFrameIndex, stack.FrameCount - 1);
} catch {
stackTrace = "";
}
WriteAssert(stackTrace, message, detailMessage);
AssertWrapper.ShowAssert(stackTrace, stack.GetFrame(userStackFrameIndex), message, detailMessage);
}
}
// Given a stack trace and start and end frame indexes, construct a
// callstack that contains method, file and line number information.
[System.Security.SecuritySafeCritical]
private static string StackTraceToString(StackTrace trace, int startFrameIndex, int endFrameIndex) {
StringBuilder sb = new StringBuilder(512);
for (int i = startFrameIndex; i <= endFrameIndex; i++) {
StackFrame frame = trace.GetFrame(i);
MethodBase method = frame.GetMethod();
sb.Append(Environment.NewLine);
sb.Append(" at ");
if (method.ReflectedType != null) {
sb.Append(method.ReflectedType.Name);
} else {
// This is for global methods and this is what shows up in windbg.
sb.Append("");
}
sb.Append(".");
sb.Append(method.Name);
sb.Append("(");
ParameterInfo[] parameters = method.GetParameters();
for (int j = 0; j < parameters.Length; j++) {
ParameterInfo parameter = parameters[j];
if (j > 0)
sb.Append(", ");
sb.Append(parameter.ParameterType.Name);
sb.Append(" ");
sb.Append(parameter.Name);
}
sb.Append(") ");
sb.Append(frame.GetFileName());
int line = frame.GetFileLineNumber();
if (line > 0) {
sb.Append("(");
sb.Append(line.ToString(CultureInfo.InvariantCulture));
sb.Append(")");
}
}
sb.Append(Environment.NewLine);
return sb.ToString();
}
private static void WriteAssert(string stackTrace, string message, string detailMessage) {
string assertMessage = SR.GetString(SR.DebugAssertBanner) + Environment.NewLine
+ SR.GetString(SR.DebugAssertShortMessage) + Environment.NewLine
+ message + Environment.NewLine
+ SR.GetString(SR.DebugAssertLongMessage) + Environment.NewLine +
detailMessage + Environment.NewLine
+ stackTrace;
WriteLine(assertMessage);
}
[System.Diagnostics.Conditional("DEBUG")]
public static void Assert(bool condition, string message, string detailMessageFormat, params object[] args) {
Assert(condition, message, String.Format(detailMessageFormat, args));
}
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteLine(string message) {
// We don't want output from multiple threads to be interleaved.
lock (s_ForLock) {
message = message + "\r\n"; // Use Windows end line on *all* Platforms
// really huge messages mess up both VS and dbmon, so we chop it up into
// reasonable chunks if it's too big
if (message == null || message.Length <= internalWriteSize) {
internalWrite(message);
} else {
int offset;
for (offset = 0; offset < message.Length - internalWriteSize; offset += internalWriteSize) {
internalWrite(message.Substring(offset, internalWriteSize));
}
internalWrite(message.Substring(offset));
}
}
}
[System.Security.SecuritySafeCritical]
private static void internalWrite(string message) {
if (Debugger.IsLogging()) {
Debugger.Log(0, null, message);
#if !FEATURE_PAL
} else {
if (message == null)
Microsoft.Win32.SafeNativeMethods.OutputDebugString(String.Empty);
else
Microsoft.Win32.SafeNativeMethods.OutputDebugString(message);
#endif //!FEATURE_PAL
}
}
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteLine(object value) {
WriteLine((value == null) ? String.Empty : value.ToString());
}
[System.Diagnostics.Conditional("DEBUG")]
public static void WriteLine(string format, params object[] args) {
WriteLine(String.Format(null, format, args));
}
#endif // SILVERLIGHT
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- FileUtil.cs
- NativeRecognizer.cs
- WorkflowDispatchContext.cs
- CompiledQuery.cs
- ObjectAnimationUsingKeyFrames.cs
- KeyManager.cs
- TouchEventArgs.cs
- EraserBehavior.cs
- DesignTimeParseData.cs
- ValidatorUtils.cs
- SiteMapSection.cs
- WebPartTransformerCollection.cs
- SimpleRecyclingCache.cs
- StrongNameUtility.cs
- WorkflowHostingEndpoint.cs
- CatalogPartChrome.cs
- Int32RectValueSerializer.cs
- BrowserDefinition.cs
- SizeConverter.cs
- GridErrorDlg.cs
- ToolStripContentPanelRenderEventArgs.cs
- CachedPathData.cs
- EdmScalarPropertyAttribute.cs
- Compensation.cs
- SettingsProviderCollection.cs
- ChannelFactoryRefCache.cs
- ColumnResult.cs
- FrugalList.cs
- ToolStripRendererSwitcher.cs
- ExtensionSimplifierMarkupObject.cs
- Clipboard.cs
- UseAttributeSetsAction.cs
- XsltOutput.cs
- RequestQueryProcessor.cs
- DBParameter.cs
- XmlSerializerFactory.cs
- XmlDataSource.cs
- ObjectSecurity.cs
- GacUtil.cs
- SystemInformation.cs
- PolyQuadraticBezierSegment.cs
- InvalidDataContractException.cs
- SqlFunctionAttribute.cs
- AssemblyResourceLoader.cs
- StoreItemCollection.cs
- CustomErrorsSection.cs
- Mapping.cs
- codemethodreferenceexpression.cs
- DataProviderNameConverter.cs
- InstanceKeyCollisionException.cs
- NotificationContext.cs
- InternalMappingException.cs
- DllHostInitializer.cs
- CalendarSelectionChangedEventArgs.cs
- SafeNativeMethodsMilCoreApi.cs
- DataGridRow.cs
- SqlGenericUtil.cs
- HyperLinkField.cs
- OracleBinary.cs
- HexParser.cs
- ClientScriptManagerWrapper.cs
- InlineObject.cs
- COSERVERINFO.cs
- HtmlTableRowCollection.cs
- Int16Converter.cs
- SmuggledIUnknown.cs
- X509PeerCertificateAuthenticationElement.cs
- DragEvent.cs
- securestring.cs
- BooleanExpr.cs
- ApplicationFileCodeDomTreeGenerator.cs
- SqlClientPermission.cs
- EntityDataSourceViewSchema.cs
- SessionPageStatePersister.cs
- TextStore.cs
- EmptyImpersonationContext.cs
- CultureInfoConverter.cs
- XmlDigitalSignatureProcessor.cs
- Viewport2DVisual3D.cs
- NativeMethods.cs
- SplitterPanel.cs
- ListDictionaryInternal.cs
- DataTable.cs
- UnitySerializationHolder.cs
- TextTrailingCharacterEllipsis.cs
- DurableInstanceProvider.cs
- ComboBox.cs
- DefaultTraceListener.cs
- DynamicResourceExtension.cs
- RegexMatch.cs
- GetResponse.cs
- WebPageTraceListener.cs
- XmlWellformedWriter.cs
- InteropDesigner.xaml.cs
- PropertyChangedEventArgs.cs
- UmAlQuraCalendar.cs
- GridViewCellAutomationPeer.cs
- TrackingMemoryStreamFactory.cs
- SqlDataSourceEnumerator.cs
- SrgsElementFactoryCompiler.cs