public static object Extract(PropValue value, MapiPropertyDefinition propertyDefinition)
{
bool isReadOnly = propertyDefinition.IsReadOnly;
Type type = propertyDefinition.Type;
Type underlyingType = Nullable.GetUnderlyingType(type);
if (null != underlyingType)
{
type = underlyingType;
}
if (propertyDefinition.PropertyTag.Id() != value.PropTag.Id())
{
throw MapiPropValueConvertor.ConstructExtractingException(value, propertyDefinition, Strings.ExceptionUnmatchedPropTag(propertyDefinition.PropertyTag.ToString(), value.PropTag.ToString()));
}
if (PropType.Binary == value.PropType)
{
if (typeof(Guid) == type)
{
return(new Guid(value.GetBytes()));
}
if (typeof(Schedule) == type)
{
return(Schedule.FromByteArray(value.GetBytes()));
}
if (typeof(MapiEntryId) == type)
{
return(new MapiEntryId(value.GetBytes()));
}
}
if (typeof(short) == type)
{
if (propertyDefinition.IsMultivalued)
{
return(new MultiValuedProperty <short>(isReadOnly, propertyDefinition, value.GetShortArray()));
}
return(value.GetShort());
}
else if (typeof(int) == type)
{
if (propertyDefinition.IsMultivalued)
{
return(new MultiValuedProperty <int>(isReadOnly, propertyDefinition, value.GetIntArray()));
}
return(value.GetInt());
}
else if (typeof(long) == type)
{
if (propertyDefinition.IsMultivalued)
{
return(new MultiValuedProperty <long>(isReadOnly, propertyDefinition, value.GetLongArray()));
}
return(value.GetLong());
}
else if (typeof(float) == type)
{
if (propertyDefinition.IsMultivalued)
{
return(new MultiValuedProperty <float>(isReadOnly, propertyDefinition, value.GetFloatArray()));
}
return(value.GetFloat());
}
else if (typeof(double) == type)
{
if (propertyDefinition.IsMultivalued)
{
return(new MultiValuedProperty <double>(isReadOnly, propertyDefinition, value.GetDoubleArray()));
}
return(value.GetDouble());
}
else if (typeof(DateTime) == type)
{
if (propertyDefinition.IsMultivalued)
{
DateTime[] dateTimeArray = value.GetDateTimeArray();
List <DateTime> list = new List <DateTime>(dateTimeArray.Length);
foreach (DateTime dateTime in dateTimeArray)
{
list.Add(dateTime.ToLocalTime());
}
return(new MultiValuedProperty <DateTime>(isReadOnly, propertyDefinition, list.ToArray()));
}
return(value.GetDateTime().ToLocalTime());
}
else if (typeof(bool) == type)
{
if (propertyDefinition.IsMultivalued)
{
return(new MultiValuedProperty <bool>(isReadOnly, propertyDefinition, value.GetBoolArray()));
}
return(value.GetBoolean());
}
else if (typeof(string) == type)
{
if (propertyDefinition.IsMultivalued)
{
return(new MultiValuedProperty <string>(isReadOnly, propertyDefinition, value.GetStringArray()));
}
return(value.GetString());
}
else if (typeof(Guid) == type)
{
if (propertyDefinition.IsMultivalued)
{
return(new MultiValuedProperty <Guid>(isReadOnly, propertyDefinition, value.GetGuidArray()));
}
return(value.GetGuid());
}
else if (typeof(byte[]) == type)
{
if (propertyDefinition.IsMultivalued)
{
return(new MultiValuedProperty <byte[]>(isReadOnly, propertyDefinition, value.GetBytesArray()));
}
return(value.GetBytes());
}
else
{
if (typeof(short[]) == type)
{
return(value.GetShortArray());
}
if (typeof(int[]) == type)
{
return(value.GetIntArray());
}
if (typeof(long[]) == type)
{
return(value.GetLongArray());
}
if (typeof(float[]) == type)
{
return(value.GetFloatArray());
}
if (typeof(double[]) == type)
{
return(value.GetDoubleArray());
}
if (typeof(DateTime[]) == type)
{
DateTime[] dateTimeArray2 = value.GetDateTimeArray();
List <DateTime> list2 = new List <DateTime>(dateTimeArray2.Length);
foreach (DateTime dateTime2 in dateTimeArray2)
{
list2.Add(dateTime2.ToLocalTime());
}
return(list2.ToArray());
}
if (typeof(bool[]) == type)
{
return(value.GetBoolArray());
}
if (typeof(string[]) == type)
{
return(value.GetStringArray());
}
if (typeof(Guid[]) == type)
{
return(value.GetGuidArray());
}
if (typeof(byte[][]) == type)
{
return(value.GetBytesArray());
}
if (type.IsAssignableFrom(MapiPropValueConvertor.TypeFromPropType(value.PropType, false)))
{
return(value.RawValue);
}
object result = null;
if (MapiPropValueConvertor.TryCastValueToExtract(value, type, out result))
{
return(result);
}
throw MapiPropValueConvertor.ConstructExtractingException(value, propertyDefinition, Strings.ConstantNa);
}
}
// Token: 0x0600135F RID: 4959 RVA: 0x00070F58 File Offset: 0x0006F158
protected object SortValues(PropValue propValue)
{
object value;
try
{
PropType propType = propValue.PropType;
if (propType <= PropType.LongArray)
{
switch (propType)
{
case PropType.ShortArray:
{
short[] shortArray = propValue.GetShortArray();
if (shortArray != null)
{
Array.Sort <short>(shortArray);
return(shortArray);
}
return(propValue.Value);
}
case PropType.IntArray:
{
int[] intArray = propValue.GetIntArray();
if (intArray != null)
{
Array.Sort <int>(intArray);
return(intArray);
}
return(propValue.Value);
}
case PropType.FloatArray:
{
float[] floatArray = propValue.GetFloatArray();
if (floatArray != null)
{
Array.Sort <float>(floatArray);
return(floatArray);
}
return(propValue.Value);
}
case PropType.DoubleArray:
{
double[] doubleArray = propValue.GetDoubleArray();
if (doubleArray != null)
{
Array.Sort <double>(doubleArray);
return(doubleArray);
}
return(propValue.Value);
}
default:
if (propType == PropType.LongArray)
{
long[] longArray = propValue.GetLongArray();
if (longArray != null)
{
Array.Sort <long>(longArray);
return(longArray);
}
return(propValue.Value);
}
break;
}
}
else
{
switch (propType)
{
case PropType.AnsiStringArray:
case PropType.StringArray:
{
string[] stringArray = propValue.GetStringArray();
if (stringArray != null)
{
Array.Sort <string>(stringArray);
return(stringArray);
}
return(propValue.Value);
}
default:
if (propType != PropType.GuidArray)
{
if (propType == PropType.BinaryArray)
{
byte[][] bytesArray = propValue.GetBytesArray();
if (bytesArray != null)
{
Array.Sort <byte[]>(bytesArray, ArrayComparer <byte> .Comparer);
return(bytesArray);
}
return(propValue.Value);
}
}
else
{
Guid[] guidArray = propValue.GetGuidArray();
if (guidArray != null)
{
Array.Sort <Guid>(guidArray);
return(guidArray);
}
return(propValue.Value);
}
break;
}
}
OABLogger.LogRecord(TraceType.ErrorTrace, "MultivaluedProperty.SortValues: don't know how to deal with type {0}", new object[]
{
propValue.PropType
});
value = propValue.Value;
}
catch (InvalidCastException)
{
OABLogger.LogRecord(TraceType.ErrorTrace, "MultivaluedProperty.SortValues: InvalidCastException while handling property {0} of stated type {1}", new object[]
{
this.propertyDefinition.Name,
propValue.PropType
});
value = propValue.Value;
}
return(value);
}