private void BuildParameterAccessors <TProperty>(string paramName, MethodInfo getter)
{
MeasurementEventMetadata <TEvent> .PropertyAccessor <TProperty> propertyAccessor = (MeasurementEventMetadata <TEvent> .PropertyAccessor <TProperty>)Delegate.CreateDelegate(typeof(MeasurementEventMetadata <> .PropertyAccessor <TEvent, TProperty>), getter);
MeasurementEvent <TEvent> .StringParameterAccessor stringParameterAccessor = (TEvent ev) => {
string str;
try
{
TProperty tProperty = propertyAccessor(ev);
str = (tProperty == null ? "" : tProperty.ToString());
}
catch (Exception exception1)
{
Exception exception = exception1;
throw new MeasurementEventException(string.Concat(new string[] { "Exception getting property ", propertyAccessor.Method.Name, " of measurement event class ", typeof(TEvent).FullName, " as a string: ", exception.Message }), exception);
}
return(str);
};
DoubleConverter.Conversion <TProperty> conversion = DoubleConverter.GetConversion <TProperty>();
MeasurementEvent <TEvent> .NumericParameterAccessor numericParameterAccessor = (TEvent ev) => {
double num;
try
{
num = conversion(propertyAccessor(ev));
}
catch (Exception exception1)
{
Exception exception = exception1;
throw new MeasurementEventException(string.Concat(new string[] { "Exception getting property ", propertyAccessor.Method.Name, " of measurement event class ", typeof(TEvent).FullName, " as a double: ", exception.Message }), exception);
}
return(num);
};
try
{
this.stringParams.Add(paramName, stringParameterAccessor);
this.numericParams.Add(paramName, numericParameterAccessor);
}
catch (ArgumentException argumentException1)
{
ArgumentException argumentException = argumentException1;
throw new MeasurementEventException(string.Concat("Measurement event class ", getter.DeclaringType.FullName, " declares more than one parameter named ", paramName), argumentException);
}
}
public static DoubleConverter.Conversion <TInput> GetConversion <TInput>()
{
Delegate fromBoolean;
Type type = typeof(TInput);
if (type.IsEnum)
{
return(DoubleConverter.GetEnumConversion <TInput>());
}
switch (Type.GetTypeCode(type))
{
case TypeCode.Boolean:
{
fromBoolean = DoubleConverter.FromBoolean;
break;
}
case TypeCode.Char:
{
fromBoolean = DoubleConverter.FromChar;
break;
}
case TypeCode.SByte:
{
fromBoolean = DoubleConverter.FromSByte;
break;
}
case TypeCode.Byte:
{
fromBoolean = DoubleConverter.FromByte;
break;
}
case TypeCode.Int16:
{
fromBoolean = DoubleConverter.FromInt16;
break;
}
case TypeCode.UInt16:
{
fromBoolean = DoubleConverter.FromUInt16;
break;
}
case TypeCode.Int32:
{
fromBoolean = DoubleConverter.FromInt32;
break;
}
case TypeCode.UInt32:
{
fromBoolean = DoubleConverter.FromUInt32;
break;
}
case TypeCode.Int64:
{
fromBoolean = DoubleConverter.FromInt64;
break;
}
case TypeCode.UInt64:
{
fromBoolean = DoubleConverter.FromUInt64;
break;
}
case TypeCode.Single:
{
fromBoolean = DoubleConverter.FromSingle;
break;
}
case TypeCode.Double:
{
fromBoolean = DoubleConverter.FromDouble;
break;
}
case TypeCode.Decimal:
{
fromBoolean = DoubleConverter.FromDecimal;
break;
}
case TypeCode.DateTime:
{
fromBoolean = DoubleConverter.FromDateTime;
break;
}
default:
{
if (typeof(TimeSpan) != type)
{
fromBoolean = new DoubleConverter.Conversion <TInput>((TInput val) => DoubleConverter.FromObject(val));
break;
}
else
{
fromBoolean = DoubleConverter.FromTimeSpan;
break;
}
}
}
return(fromBoolean as DoubleConverter.Conversion <TInput>);
}
public static DoubleConverter.Conversion <TInput> GetEnumConversion <TInput>()
{
DoubleConverter.Conversion <TInput> fromSByte;
switch (Type.GetTypeCode(typeof(TInput)))
{
case TypeCode.SByte:
{
fromSByte = (TInput val) => DoubleConverter.FromSByte(Convert.ToSByte(val));
break;
}
case TypeCode.Byte:
{
fromSByte = (TInput val) => DoubleConverter.FromByte(Convert.ToByte(val));
break;
}
case TypeCode.Int16:
{
fromSByte = (TInput val) => DoubleConverter.FromInt16(Convert.ToInt16(val));
break;
}
case TypeCode.UInt16:
{
fromSByte = (TInput val) => DoubleConverter.FromUInt16(Convert.ToUInt16(val));
break;
}
case TypeCode.Int32:
{
fromSByte = (TInput val) => DoubleConverter.FromInt32(Convert.ToInt32(val));
break;
}
case TypeCode.UInt32:
{
fromSByte = (TInput val) => DoubleConverter.FromUInt32(Convert.ToUInt32(val));
break;
}
case TypeCode.Int64:
{
fromSByte = (TInput val) => DoubleConverter.FromInt64(Convert.ToInt64(val));
break;
}
case TypeCode.UInt64:
{
fromSByte = (TInput val) => DoubleConverter.FromUInt64(Convert.ToUInt64(val));
break;
}
default:
{
fromSByte = null;
break;
}
}
return(fromSByte);
}
