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

589 lines
18 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Channels
{
using System;
using System.Globalization;
using System.Text;
using System.Threading;
using System.Runtime.InteropServices;
using System.Security;
using System.Runtime.Serialization;
using System.ServiceModel.Diagnostics;
using Microsoft.Win32.SafeHandles;
abstract class NativeMsmqMessage : IDisposable
{
UnsafeNativeMethods.MQPROPVARIANT[] variants;
UnsafeNativeMethods.MQMSGPROPS nativeProperties;
int[] ids;
GCHandle nativePropertiesHandle;
GCHandle variantsHandle;
GCHandle idsHandle;
MsmqProperty[] properties;
bool disposed;
object[] buffersForAsync;
protected NativeMsmqMessage(int propertyCount)
{
this.properties = new MsmqProperty[propertyCount];
this.nativeProperties = new UnsafeNativeMethods.MQMSGPROPS();
this.ids = new int[propertyCount];
this.variants = new UnsafeNativeMethods.MQPROPVARIANT[propertyCount];
this.nativePropertiesHandle = GCHandle.Alloc(null, GCHandleType.Pinned);
this.idsHandle = GCHandle.Alloc(null, GCHandleType.Pinned);
this.variantsHandle = GCHandle.Alloc(null, GCHandleType.Pinned);
}
~NativeMsmqMessage()
{
Dispose(false);
}
public virtual void GrowBuffers()
{
}
public object[] GetBuffersForAsync()
{
if (null == this.buffersForAsync)
{
int propertyBuffersToPin = 0;
for (int i = 0; i < this.nativeProperties.count; ++i)
{
if (this.properties[i].MaintainsBuffer)
++propertyBuffersToPin;
}
this.buffersForAsync = new object[propertyBuffersToPin + 3];
}
int bufferCount = 0;
for (int i = 0; i < this.nativeProperties.count; ++i)
{
if (this.properties[i].MaintainsBuffer)
{
this.buffersForAsync[bufferCount++] = this.properties[i].MaintainedBuffer;
}
}
this.buffersForAsync[bufferCount++] = this.ids;
this.buffersForAsync[bufferCount++] = this.variants;
this.buffersForAsync[bufferCount] = this.nativeProperties;
return this.buffersForAsync;
}
public IntPtr Pin()
{
for (int i = 0; i < this.nativeProperties.count; i++)
properties[i].Pin();
this.idsHandle.Target = this.ids;
this.variantsHandle.Target = this.variants;
this.nativeProperties.status = IntPtr.Zero;
this.nativeProperties.variants = this.variantsHandle.AddrOfPinnedObject();
this.nativeProperties.ids = this.idsHandle.AddrOfPinnedObject();
this.nativePropertiesHandle.Target = this.nativeProperties;
return nativePropertiesHandle.AddrOfPinnedObject();
}
public void Unpin()
{
this.nativePropertiesHandle.Target = null;
this.idsHandle.Target = null;
this.variantsHandle.Target = null;
for (int i = 0; i < this.nativeProperties.count; i++)
properties[i].Unpin();
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
void Dispose(bool disposing)
{
if (!this.disposed && disposing)
{
for (int i = 0; i < this.nativeProperties.count; i++)
{
this.properties[i].Dispose();
}
this.disposed = true;
}
if (this.nativePropertiesHandle.IsAllocated)
this.nativePropertiesHandle.Free();
if (this.idsHandle.IsAllocated)
this.idsHandle.Free();
if (this.variantsHandle.IsAllocated)
this.variantsHandle.Free();
}
public abstract class MsmqProperty : IDisposable
{
UnsafeNativeMethods.MQPROPVARIANT[] variants;
int index;
protected MsmqProperty(NativeMsmqMessage message, int id, ushort vt)
{
this.variants = message.variants;
this.index = message.nativeProperties.count++;
message.variants[this.index].vt = vt;
message.ids[this.index] = id;
message.properties[this.index] = this;
}
protected int Index
{
get { return this.index; }
}
public virtual bool MaintainsBuffer
{
get { return false; }
}
public virtual object MaintainedBuffer
{
get { return null; }
}
public virtual void Pin()
{
}
public virtual void Unpin()
{
}
public virtual void Dispose()
{
}
protected UnsafeNativeMethods.MQPROPVARIANT[] Variants
{
get { return this.variants; }
}
}
public class ByteProperty : MsmqProperty
{
public ByteProperty(NativeMsmqMessage message, int id)
: base(message, id, UnsafeNativeMethods.VT_UI1)
{
}
public ByteProperty(NativeMsmqMessage message, int id, byte value)
: this(message, id)
{
this.Value = value;
}
public byte Value
{
get
{
return this.Variants[this.Index].byteValue;
}
set
{
this.Variants[this.Index].byteValue = value;
}
}
}
public class ShortProperty : MsmqProperty
{
public ShortProperty(NativeMsmqMessage message, int id)
: base(message, id, UnsafeNativeMethods.VT_UI2)
{
}
public ShortProperty(NativeMsmqMessage message, int id, short value)
: this(message, id)
{
this.Value = value;
}
public short Value
{
get
{
return this.Variants[this.Index].shortValue;
}
set
{
this.Variants[this.Index].shortValue = value;
}
}
}
public class BooleanProperty : MsmqProperty
{
public BooleanProperty(NativeMsmqMessage message, int id)
: base(message, id, UnsafeNativeMethods.VT_BOOL)
{
}
public BooleanProperty(NativeMsmqMessage message, int id, bool value)
: this(message, id)
{
this.Value = value;
}
public bool Value
{
get
{
return this.Variants[this.Index].shortValue != 0;
}
set
{
this.Variants[this.Index].shortValue = value ? (short)-1 : (short)0;
}
}
}
public class IntProperty : MsmqProperty
{
public IntProperty(NativeMsmqMessage message, int id)
: base(message, id, UnsafeNativeMethods.VT_UI4)
{
}
public IntProperty(NativeMsmqMessage message, int id, int value)
: this(message, id)
{
this.Value = value;
}
public int Value
{
get
{
return this.Variants[this.Index].intValue;
}
set
{
this.Variants[this.Index].intValue = value;
}
}
}
public class LongProperty : MsmqProperty
{
public LongProperty(NativeMsmqMessage message, int id)
: base(message, id, UnsafeNativeMethods.VT_UI8)
{
}
public LongProperty(NativeMsmqMessage message, int id, long value)
: this(message, id)
{
this.Value = value;
}
public long Value
{
get
{
return this.Variants[this.Index].longValue;
}
set
{
this.Variants[this.Index].longValue = value;
}
}
}
public class BufferProperty : MsmqProperty
{
byte[] buffer;
GCHandle bufferHandle;
public BufferProperty(NativeMsmqMessage message, int id)
: base(message, id, UnsafeNativeMethods.VT_UI1 | UnsafeNativeMethods.VT_VECTOR)
{
bufferHandle = GCHandle.Alloc(null, GCHandleType.Pinned);
}
public BufferProperty(NativeMsmqMessage message, int id, byte[] buffer)
: this(message, id, buffer.Length)
{
System.Buffer.BlockCopy(buffer, 0, this.Buffer, 0, buffer.Length);
}
public BufferProperty(NativeMsmqMessage message, int id, int length)
: this(message, id)
{
SetBufferReference(DiagnosticUtility.Utility.AllocateByteArray(length));
}
~BufferProperty()
{
Dispose(false);
}
public override void Dispose()
{
base.Dispose();
this.Dispose(true);
GC.SuppressFinalize(this);
}
void Dispose(bool disposing)
{
if (bufferHandle.IsAllocated)
bufferHandle.Free();
}
public void SetBufferReference(byte[] buffer)
{
SetBufferReference(buffer, buffer.Length);
}
public void SetBufferReference(byte[] buffer, int length)
{
this.buffer = buffer;
this.BufferLength = length;
}
public override bool MaintainsBuffer
{
get { return true; }
}
public override object MaintainedBuffer
{
get { return this.buffer; }
}
public override void Pin()
{
bufferHandle.Target = buffer;
this.Variants[this.Index].byteArrayValue.intPtr = bufferHandle.AddrOfPinnedObject();
}
public override void Unpin()
{
this.Variants[this.Index].byteArrayValue.intPtr = IntPtr.Zero;
bufferHandle.Target = null;
}
public byte[] GetBufferCopy(int length)
{
byte[] buffer = DiagnosticUtility.Utility.AllocateByteArray(length);
System.Buffer.BlockCopy(this.buffer, 0, buffer, 0, length);
return buffer;
}
public void EnsureBufferLength(int length)
{
if (this.buffer.Length < length)
{
SetBufferReference(DiagnosticUtility.Utility.AllocateByteArray(length));
}
}
public int BufferLength
{
get
{
return this.Variants[this.Index].byteArrayValue.size;
}
set
{
if (value > this.buffer.Length)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("value"));
this.Variants[this.Index].byteArrayValue.size = value;
}
}
public byte[] Buffer
{
get
{
return this.buffer;
}
}
}
public class StringProperty : MsmqProperty
{
char[] buffer;
GCHandle bufferHandle;
internal StringProperty(NativeMsmqMessage message, int id, string value)
: this(message, id, value.Length + 1)
{
CopyValueToBuffer(value);
}
internal StringProperty(NativeMsmqMessage message, int id, int length)
: base(message, id, UnsafeNativeMethods.VT_LPWSTR)
{
this.buffer = DiagnosticUtility.Utility.AllocateCharArray(length);
this.bufferHandle = GCHandle.Alloc(null, GCHandleType.Pinned);
}
~StringProperty()
{
Dispose(false);
}
public override bool MaintainsBuffer
{
get { return true; }
}
public override object MaintainedBuffer
{
get { return this.buffer; }
}
public override void Pin()
{
this.bufferHandle.Target = buffer;
this.Variants[this.Index].intPtr = bufferHandle.AddrOfPinnedObject();
}
public override void Unpin()
{
this.Variants[this.Index].intPtr = IntPtr.Zero;
this.bufferHandle.Target = null;
}
public override void Dispose()
{
base.Dispose();
Dispose(true);
GC.SuppressFinalize(this);
}
void Dispose(bool disposing)
{
if (bufferHandle.IsAllocated)
bufferHandle.Free();
}
public void EnsureValueLength(int length)
{
if (length > this.buffer.Length)
{
this.buffer = DiagnosticUtility.Utility.AllocateCharArray(length);
}
}
public void SetValue(string value)
{
if (null == value)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("value");
EnsureValueLength(value.Length + 1);
CopyValueToBuffer(value);
}
void CopyValueToBuffer(string value)
{
value.CopyTo(0, this.buffer, 0, value.Length);
this.buffer[value.Length] = '\0';
}
public string GetValue(int length)
{
if (length == 0)
{
return null;
}
else
{
return new string(this.buffer, 0, length - 1);
}
}
}
}
static class MsmqMessageId
{
const int guidSize = 16;
public static string ToString(byte[] messageId)
{
StringBuilder result = new StringBuilder();
byte[] guid = new byte[guidSize];
Array.Copy(messageId, guid, guidSize);
int id = BitConverter.ToInt32(messageId, guidSize);
result.Append((new Guid(guid)).ToString());
result.Append("\\");
result.Append(id);
return result.ToString();
}
public static byte[] FromString(string messageId)
{
string[] pieces = messageId.Split(new char[] { '\\' });
if (pieces.Length != 2)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.MsmqInvalidMessageId, messageId), "messageId"));
Guid guid;
if (!DiagnosticUtility.Utility.TryCreateGuid(pieces[0], out guid))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.MsmqInvalidMessageId, messageId), "messageId"));
}
int integerId;
try
{
integerId = Convert.ToInt32(pieces[1], CultureInfo.InvariantCulture);
}
catch (FormatException)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.MsmqInvalidMessageId, messageId), "messageId"));
}
byte[] bytes = new byte[UnsafeNativeMethods.PROPID_M_MSGID_SIZE];
Array.Copy(guid.ToByteArray(), bytes, guidSize);
Array.Copy(BitConverter.GetBytes(integerId), 0, bytes, guidSize, 4);
return bytes;
}
}
class MsmqEmptyMessage : NativeMsmqMessage
{
public MsmqEmptyMessage()
: base(0)
{ }
}
static class MsmqDuration
{
public static int FromTimeSpan(TimeSpan timeSpan)
{
long totalSeconds = (long)timeSpan.TotalSeconds;
if (totalSeconds > int.MaxValue)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(
SR.GetString(SR.MsmqTimeSpanTooLarge)));
return (int)totalSeconds;
}
public static TimeSpan ToTimeSpan(int seconds)
{
return TimeSpan.FromSeconds(seconds);
}
}
static class MsmqDateTime
{
public static DateTime ToDateTime(int seconds)
{
return new DateTime(1970, 1, 1).AddSeconds(seconds);
}
}
}