private static MessageTraceEntityBase[] MapResultsTable <T>(DataTable table) where T : MessageTraceEntityBase, new()
{
List <MessageTraceEntityBase> list = new List <MessageTraceEntityBase>();
if (list != null && table != null && table.Rows.Count > 0)
{
MessageTraceDataSet.< > c__DisplayClass3 <T> CS$ < > 8__locals1 = new MessageTraceDataSet.< > c__DisplayClass3 <T>();
CS$ < > 8__locals1.columnSchema = table.Columns;
foreach (object obj in table.Rows)
{
DataRow dataRow = (DataRow)obj;
MessageTraceEntityBase entity = Activator.CreateInstance <T>();
IEnumerable <PropertyDefinition> propertyDefinitions = (IEnumerable <PropertyDefinition>)entity.GetAllProperties();
using (IEnumerator enumerator2 = CS$ < > 8__locals1.columnSchema.GetEnumerator())
{
while (enumerator2.MoveNext())
{
DataColumn column = (DataColumn)enumerator2.Current;
try
{
PropertyDefinition propertyDefinition2 = propertyDefinitions.First((PropertyDefinition propertyDefinition) => string.Compare(propertyDefinition.Name, column.ColumnName, StringComparison.OrdinalIgnoreCase) == 0);
if (propertyDefinition2 != null)
{
entity[propertyDefinition2] = DalHelper.ConvertFromStoreObject(dataRow[column], propertyDefinition2.Type);
}
}
catch (InvalidOperationException)
{
}
}
}
PropertyBase propertyBase = entity as PropertyBase;
if (propertyBase != null && propertyBase.PropertyName == MessageTraceCollapsedProperty.PropertyDefinition.Name)
{
byte[] data = Convert.FromBase64String(propertyBase.PropertyValueBlob.Value);
list.AddRange(MessageTraceCollapsedProperty.Expand <PropertyBase>(data, propertyBase.Namespace, delegate
{
PropertyBase propertyBase2 = Activator.CreateInstance <T>() as PropertyBase;
using (IEnumerator enumerator3 = CS$ < > 8__locals1.columnSchema.GetEnumerator())
{
while (enumerator3.MoveNext())
{
MessageTraceDataSet.< > c__DisplayClass3 <T> CS$ < > 8__locals4 = CS$ < > 8__locals1;
DataColumn column = (DataColumn)enumerator3.Current;
try
{
PropertyDefinition propertyDefinition3 = propertyDefinitions.First((PropertyDefinition propertyDefinition) => string.Compare(propertyDefinition.Name, column.ColumnName, StringComparison.OrdinalIgnoreCase) == 0);
if (propertyDefinition3 != null && propertyDefinition3 != PropertyBase.PropertyValueBlobProperty)
{
propertyBase2[propertyDefinition3] = entity[propertyDefinition3];
}
}
catch (InvalidOperationException)
{
}
}
}
propertyBase2.PropertyId = Guid.NewGuid();
return(propertyBase2);
}));
public T GetExtendedProperty(string nameSpace, string name)
{
if (nameSpace == null)
{
throw new ArgumentNullException("nameSpace");
}
if (name == null)
{
throw new ArgumentNullException("name");
}
T result = default(T);
Dictionary <string, T> dictionary = this.propertyStore[nameSpace];
if (MessageTraceCollapsedProperty.IsCollapsableProperty(nameSpace, name))
{
IEnumerable <PropertyBase> source;
if (!ExtendedPropertyStore <T> .TryGetCollapsedProperties(dictionary, nameSpace, name, out source))
{
throw new KeyNotFoundException(string.Format(CultureInfo.InvariantCulture, "The key '{0}' was not found in the property bag", new object[]
{
name
}));
}
result = (T)((object)source.LastOrDefault((PropertyBase p) => string.Equals(p.PropertyName, name, StringComparison.OrdinalIgnoreCase)));
}
else
{
result = dictionary[name];
}
return(result);
}
public bool TryGetExtendedProperty(string nameSpace, string name, out T extendedProperty)
{
if (nameSpace == null)
{
throw new ArgumentNullException("nameSpace");
}
if (name == null)
{
throw new ArgumentNullException("name");
}
Dictionary <string, T> dictionary = null;
if (this.propertyStore.TryGetValue(nameSpace, out dictionary) && dictionary.TryGetValue(name, out extendedProperty))
{
if (!MessageTraceCollapsedProperty.IsCollapsableProperty(nameSpace, name))
{
return(true);
}
IEnumerable <PropertyBase> source;
if (ExtendedPropertyStore <T> .TryGetCollapsedProperties(dictionary, nameSpace, name, out source))
{
extendedProperty = (source.LastOrDefault((PropertyBase p) => string.Equals(p.PropertyName, name, StringComparison.OrdinalIgnoreCase)) as T);
if (extendedProperty != null)
{
return(true);
}
}
}
extendedProperty = default(T);
return(false);
}
internal static IEnumerable <T> Expand <T>(byte[] data, string entityName, Func <T> objectBuilder) where T : PropertyBase
{
using (MemoryStream stream = new MemoryStream(data))
{
while (stream.Position < stream.Length)
{
long startPosition = stream.Position;
int propertyId = (int)MessageTraceCollapsedProperty.ReadPrimitiveValueFromStream(stream, typeof(int));
SqlPropertyDefinition propertyDefinition = MessageTraceCollapsedProperty.GetCollapsedPropertyById(entityName, propertyId);
T property = objectBuilder();
property.PropertyName = propertyDefinition.PropertyName;
switch (propertyDefinition.Type)
{
case SqlPropertyTypes.Int:
property.PropertyValueInteger = new int?((int)MessageTraceCollapsedProperty.ReadPrimitiveValueFromStream(stream, typeof(int)));
break;
case SqlPropertyTypes.String:
property.PropertyValueString = (string)MessageTraceCollapsedProperty.ReadPrimitiveValueFromStream(stream, typeof(string));
break;
case SqlPropertyTypes.DateTime:
property.PropertyValueDatetime = new DateTime?((DateTime)MessageTraceCollapsedProperty.ReadPrimitiveValueFromStream(stream, typeof(DateTime)));
break;
case SqlPropertyTypes.Decimal:
property.PropertyValueDecimal = new decimal?((decimal)MessageTraceCollapsedProperty.ReadPrimitiveValueFromStream(stream, typeof(decimal)));
break;
case SqlPropertyTypes.Blob:
property.PropertyValueBlob = new BlobType((string)MessageTraceCollapsedProperty.ReadPrimitiveValueFromStream(stream, typeof(string)));
break;
case SqlPropertyTypes.Boolean:
property.PropertyValueBit = new bool?((bool)MessageTraceCollapsedProperty.ReadPrimitiveValueFromStream(stream, typeof(bool)));
break;
case SqlPropertyTypes.Guid:
property.PropertyValueGuid = (Guid)MessageTraceCollapsedProperty.ReadPrimitiveValueFromStream(stream, typeof(Guid));
break;
case SqlPropertyTypes.Long:
property.PropertyValueLong = new long?((long)MessageTraceCollapsedProperty.ReadPrimitiveValueFromStream(stream, typeof(long)));
break;
default:
throw new InvalidOperationException(string.Format("Property type {0} is not supported for MessageTraceCollapsedProperty.", propertyDefinition.Type));
}
yield return(property);
if (stream.Position <= startPosition)
{
throw new InvalidOperationException("Unable to expand. Stream position is not moving forward.");
}
}
}
yield break;
}
private static void SaveLengthToStream(Stream stream, int length)
{
while (length >= 255)
{
MessageTraceCollapsedProperty.SaveSingleByteToStream(stream, byte.MaxValue);
length -= 255;
}
MessageTraceCollapsedProperty.SaveSingleByteToStream(stream, (byte)length);
}
private static byte[] ReadByteArrayFromStream(Stream stream)
{
int num = MessageTraceCollapsedProperty.ReadLengthFromStream(stream);
byte[] array = new byte[num];
if (stream.Read(array, 0, num) != num)
{
throw new InvalidOperationException(string.Format("Unable to read byte array of {0} length from stream. End of stream reached.", num));
}
return(array);
}
private static int ReadLengthFromStream(Stream stream)
{
int num = 0;
int num2;
do
{
num2 = (int)MessageTraceCollapsedProperty.ReadSingleByteFromStream(stream);
num += num2;
}while (num2 == 255);
return(num);
}
private static bool TryGetCollapsedProperties(IDictionary <string, T> nameToPropDict, string nameSpace, string name, out IEnumerable <PropertyBase> expandedProperties)
{
expandedProperties = null;
T t;
bool result;
if (result = nameToPropDict.TryGetValue(MessageTraceCollapsedProperty.PropertyDefinition.Name, out t))
{
byte[] data = Convert.FromBase64String(t.PropertyValueBlob.Value);
expandedProperties = MessageTraceCollapsedProperty.Expand <MessageEventProperty>(data, name, () => new MessageEventProperty(nameSpace, name, false));
}
return(result);
}
private static object ReadPrimitiveValueFromStream(Stream stream, Type typeOfvalue)
{
if (typeOfvalue == typeof(long))
{
return(BitConverter.ToInt64(MessageTraceCollapsedProperty.ReadByteArrayFromStream(stream), 0));
}
if (typeOfvalue == typeof(int))
{
return(BitConverter.ToInt32(MessageTraceCollapsedProperty.ReadByteArrayFromStream(stream), 0));
}
if (typeOfvalue == typeof(Guid))
{
return(new Guid(MessageTraceCollapsedProperty.ReadByteArrayFromStream(stream)));
}
if (typeOfvalue == typeof(string))
{
byte b = MessageTraceCollapsedProperty.ReadSingleByteFromStream(stream);
switch (b)
{
case 2:
return(Encoding.ASCII.GetString(MessageTraceCollapsedProperty.ReadByteArrayFromStream(stream)));
case 3:
return(Encoding.Unicode.GetString(MessageTraceCollapsedProperty.ReadByteArrayFromStream(stream)));
default:
throw new InvalidOperationException(string.Format("Unable to deserialize string from stream. Unknown string serialization algorithm {0}.", b));
}
}
else
{
if (typeOfvalue == typeof(DateTime))
{
return(DateTime.FromBinary((long)MessageTraceCollapsedProperty.ReadPrimitiveValueFromStream(stream, typeof(long))));
}
if (MessageTraceCollapsedProperty.PrimitiveValueFromByteArrayConvertor.ContainsKey(typeOfvalue))
{
return(MessageTraceCollapsedProperty.PrimitiveValueFromByteArrayConvertor[typeOfvalue](MessageTraceCollapsedProperty.ReadByteArrayFromStream(stream)));
}
if (typeOfvalue.IsEnum)
{
return(Enum.ToObject(typeOfvalue, (int)MessageTraceCollapsedProperty.ReadPrimitiveValueFromStream(stream, typeof(int))));
}
return(null);
}
}
private static bool SavePrimitiveValueToStream(Stream stream, Type typeOfvalue, object value)
{
if (typeOfvalue == typeof(long))
{
MessageTraceCollapsedProperty.SaveByteArrayToStream(stream, BitConverter.GetBytes((long)value));
return(true);
}
if (typeOfvalue == typeof(int))
{
MessageTraceCollapsedProperty.SaveByteArrayToStream(stream, BitConverter.GetBytes((int)value));
return(true);
}
if (typeOfvalue == typeof(Guid))
{
MessageTraceCollapsedProperty.SaveByteArrayToStream(stream, ((Guid)value).ToByteArray());
return(true);
}
if (typeOfvalue == typeof(string))
{
string text = value as string;
if (Encoding.ASCII.GetString(Encoding.ASCII.GetBytes(text)) == text)
{
MessageTraceCollapsedProperty.SaveSingleByteToStream(stream, 2);
MessageTraceCollapsedProperty.SaveByteArrayToStream(stream, Encoding.ASCII.GetBytes((string)value));
}
else
{
MessageTraceCollapsedProperty.SaveSingleByteToStream(stream, 3);
MessageTraceCollapsedProperty.SaveByteArrayToStream(stream, Encoding.Unicode.GetBytes((string)value));
}
return(true);
}
if (typeOfvalue == typeof(DateTime))
{
return(MessageTraceCollapsedProperty.SavePrimitiveValueToStream(stream, typeof(long), ((DateTime)value).ToBinary()));
}
if (MessageTraceCollapsedProperty.PrimitiveValueToByteArrayConvertor.ContainsKey(typeOfvalue))
{
MessageTraceCollapsedProperty.SaveByteArrayToStream(stream, MessageTraceCollapsedProperty.PrimitiveValueToByteArrayConvertor[typeOfvalue](value));
return(true);
}
return(typeOfvalue.IsEnum && MessageTraceCollapsedProperty.SavePrimitiveValueToStream(stream, typeof(int), Convert.ToInt32(value)));
}
public void AddExtendedProperty(T extendedProperty)
{
if (extendedProperty == null)
{
throw new ArgumentNullException("extendedProperty");
}
Dictionary <string, T> orAdd = this.propertyStore.GetOrAdd(extendedProperty.Namespace, () => new Dictionary <string, T>(StringComparer.OrdinalIgnoreCase));
if (MessageTraceCollapsedProperty.IsCollapsableProperty(extendedProperty.Namespace, extendedProperty.PropertyName))
{
byte[] array = null;
T t;
if (orAdd.TryGetValue(MessageTraceCollapsedProperty.PropertyDefinition.Name, out t))
{
array = Convert.FromBase64String(t.PropertyValueBlob.Value);
}
array = MessageTraceCollapsedProperty.Collapse(array, extendedProperty.Namespace, extendedProperty);
if (t == null)
{
t = extendedProperty;
t.PropertyName = MessageTraceCollapsedProperty.PropertyDefinition.Name;
t.PropertyValueGuid = Guid.Empty;
t.PropertyValueInteger = null;
t.PropertyValueString = null;
t.PropertyValueDatetime = null;
t.PropertyValueDecimal = null;
t.PropertyValueBit = null;
t.PropertyValueLong = null;
orAdd[extendedProperty.PropertyName] = t;
t.PropertyIndex = this.propertiesList.Count;
this.propertiesList.Add(extendedProperty);
}
t.PropertyValueBlob = new BlobType(Convert.ToBase64String(array));
return;
}
orAdd[extendedProperty.PropertyName] = extendedProperty;
extendedProperty.PropertyIndex = this.propertiesList.Count;
this.propertiesList.Add(extendedProperty);
}
internal static byte[] Collapse(byte[] existingData, string entityName, PropertyBase property)
{
byte[] result;
using (MemoryStream memoryStream = new MemoryStream())
{
if (existingData != null && existingData.Length > 0)
{
memoryStream.Write(existingData, 0, existingData.Length);
}
SqlPropertyDefinition collapsedPropertyByName = MessageTraceCollapsedProperty.GetCollapsedPropertyByName(entityName, property.PropertyName);
switch (collapsedPropertyByName.Type)
{
case SqlPropertyTypes.Int:
if (property.PropertyValueInteger != null)
{
MessageTraceCollapsedProperty.SavePrimitiveValueToStream(memoryStream, typeof(int), collapsedPropertyByName.PropertyId);
MessageTraceCollapsedProperty.SavePrimitiveValueToStream(memoryStream, typeof(int), property.PropertyValueInteger.Value);
}
break;
case SqlPropertyTypes.String:
if (!string.IsNullOrEmpty(property.PropertyValueString))
{
MessageTraceCollapsedProperty.SavePrimitiveValueToStream(memoryStream, typeof(int), collapsedPropertyByName.PropertyId);
MessageTraceCollapsedProperty.SavePrimitiveValueToStream(memoryStream, typeof(string), property.PropertyValueString);
}
break;
case SqlPropertyTypes.DateTime:
if (property.PropertyValueDatetime != null)
{
MessageTraceCollapsedProperty.SavePrimitiveValueToStream(memoryStream, typeof(int), collapsedPropertyByName.PropertyId);
MessageTraceCollapsedProperty.SavePrimitiveValueToStream(memoryStream, typeof(DateTime), property.PropertyValueDatetime.Value);
}
break;
case SqlPropertyTypes.Decimal:
if (property.PropertyValueDecimal != null)
{
MessageTraceCollapsedProperty.SavePrimitiveValueToStream(memoryStream, typeof(int), collapsedPropertyByName.PropertyId);
MessageTraceCollapsedProperty.SavePrimitiveValueToStream(memoryStream, typeof(decimal), property.PropertyValueDecimal.Value);
}
break;
case SqlPropertyTypes.Blob:
if (!string.IsNullOrEmpty(property.PropertyValueBlob.Value))
{
MessageTraceCollapsedProperty.SavePrimitiveValueToStream(memoryStream, typeof(int), collapsedPropertyByName.PropertyId);
MessageTraceCollapsedProperty.SavePrimitiveValueToStream(memoryStream, typeof(string), property.PropertyValueBlob.Value);
}
break;
case SqlPropertyTypes.Boolean:
if (property.PropertyValueBit != null)
{
MessageTraceCollapsedProperty.SavePrimitiveValueToStream(memoryStream, typeof(int), collapsedPropertyByName.PropertyId);
MessageTraceCollapsedProperty.SavePrimitiveValueToStream(memoryStream, typeof(bool), property.PropertyValueBit.Value);
}
break;
case SqlPropertyTypes.Guid:
if (property.PropertyValueGuid != Guid.Empty)
{
MessageTraceCollapsedProperty.SavePrimitiveValueToStream(memoryStream, typeof(int), collapsedPropertyByName.PropertyId);
MessageTraceCollapsedProperty.SavePrimitiveValueToStream(memoryStream, typeof(Guid), property.PropertyValueGuid);
}
break;
case SqlPropertyTypes.Long:
if (property.PropertyValueLong != null)
{
MessageTraceCollapsedProperty.SavePrimitiveValueToStream(memoryStream, typeof(int), collapsedPropertyByName.PropertyId);
MessageTraceCollapsedProperty.SavePrimitiveValueToStream(memoryStream, typeof(long), property.PropertyValueLong.Value);
}
break;
default:
throw new InvalidOperationException(string.Format("Property type {0} is not supported for MessageTraceCollapsedProperty.", collapsedPropertyByName.Type));
}
result = memoryStream.ToArray();
}
return(result);
}
internal static bool IsCollapsableProperty(string entityName, string propertyName)
{
return(MessageTraceCollapsedProperty.GetCollapsedPropertyByName(entityName, propertyName) != null);
}
private static void SaveByteArrayToStream(Stream stream, byte[] bytes)
{
MessageTraceCollapsedProperty.SaveLengthToStream(stream, bytes.Length);
stream.Write(bytes, 0, bytes.Length);
}
