|
//------------------------------------------------------------------------------
// <copyright file="DateTimeOffsetConverter.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
/*
DevDiv Bugs 181818: DateTimeOffset should have a type converter just like DateTime.
This converter should behave just like DateTimeConverter only it should convert DateTimeOffsets.
The code was copied from DateTimeConverter and adapted for DateTimeOffset.
*/
namespace System.ComponentModel {
using Microsoft.Win32;
using System.ComponentModel.Design.Serialization;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Runtime.Remoting;
using System.Runtime.Serialization.Formatters;
using System.Security.Permissions;
/// <devdoc>
/// <para>Provides a type converter to convert <see cref='System.DateTimeOffset'/>
/// objects to and from various other representations.</para>
/// </devdoc>
[HostProtection(SharedState = true)]
public class DateTimeOffsetConverter : TypeConverter {
/// <devdoc>
/// <para>Gets a value indicating whether this converter can
/// convert an object in the given source type to a <see cref='System.DateTimeOffset'/>
/// object using the
/// specified context.</para>
/// </devdoc>
public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) {
if (sourceType == typeof(string)) {
return true;
}
return base.CanConvertFrom(context, sourceType);
}
/// <devdoc>
/// <para>Gets a value indicating whether this converter can
/// convert an object to the given destination type using the context.</para>
/// </devdoc>
public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType) {
if (destinationType == typeof(InstanceDescriptor)) {
return true;
}
return base.CanConvertTo(context, destinationType);
}
/// <devdoc>
/// <para>Converts the given value object to a <see cref='System.DateTime'/>
/// object.</para>
/// </devdoc>
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) {
if (value is string) {
string text = ((string)value).Trim();
if (text.Length == 0) {
return DateTimeOffset.MinValue;
}
try {
// See if we have a culture info to parse with. If so, then use it.
//
DateTimeFormatInfo formatInfo = null;
if (culture != null ) {
formatInfo = (DateTimeFormatInfo)culture.GetFormat(typeof(DateTimeFormatInfo));
}
if (formatInfo != null) {
return DateTimeOffset.Parse(text, formatInfo);
}
else {
return DateTimeOffset.Parse(text, culture);
}
}
catch (FormatException e) {
throw new FormatException(SR.GetString(SR.ConvertInvalidPrimitive, (string)value, "DateTimeOffset"), e);
}
}
return base.ConvertFrom(context, culture, value);
}
/// <devdoc>
/// <para>Converts the given value object to a <see cref='System.DateTimeOffset'/>
/// object
/// using the arguments.</para>
/// </devdoc>
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType) {
// logic is exactly as in DateTimeConverter, only the offset pattern ' zzz' is added to the default
// ConvertToString pattern.
if (destinationType == typeof(string) && value is DateTimeOffset) {
DateTimeOffset dto = (DateTimeOffset) value;
if (dto == DateTimeOffset.MinValue) {
return string.Empty;
}
if (culture == null) {
culture = CultureInfo.CurrentCulture;
}
DateTimeFormatInfo formatInfo = null;
formatInfo = (DateTimeFormatInfo)culture.GetFormat(typeof(DateTimeFormatInfo));
string format;
if (culture == CultureInfo.InvariantCulture) {
// note: the y/m/d format used when there is or isn't a time component is not consistent
// when the culture is invariant, because for some reason InvariantCulture's date format is
// MM/dd/yyyy. However, this matches the behavior of DateTimeConverter so it is preserved here.
if (dto.TimeOfDay.TotalSeconds == 0) {
// pattern just like DateTimeConverter when DateTime.TimeOfDay.TotalSeconds==0
// but with ' zzz' offset pattern added.
return dto.ToString("yyyy-MM-dd zzz", culture);
}
else {
return dto.ToString(culture);
}
}
if (dto.TimeOfDay.TotalSeconds == 0) {
// pattern just like DateTimeConverter when DateTime.TimeOfDay.TotalSeconds==0
// but with ' zzz' offset pattern added.
format = formatInfo.ShortDatePattern + " zzz";
}
else {
// pattern just like DateTimeConverter when DateTime.TimeOfDay.TotalSeconds!=0
// but with ' zzz' offset pattern added.
format = formatInfo.ShortDatePattern + " " + formatInfo.ShortTimePattern + " zzz";
}
return dto.ToString(format, CultureInfo.CurrentCulture);
}
if (destinationType == typeof(InstanceDescriptor) && value is DateTimeOffset) {
DateTimeOffset dto = (DateTimeOffset)value;
if (dto.Ticks == 0) {
// Make a special case for the empty DateTimeOffset
//
ConstructorInfo ctr = typeof(DateTimeOffset).GetConstructor(new Type[] {typeof(Int64)});
if (ctr != null) {
return new InstanceDescriptor(ctr, new object[] {
dto.Ticks });
}
}
ConstructorInfo ctor = typeof(DateTimeOffset).GetConstructor(new Type[] {
typeof(int), typeof(int), typeof(int), typeof(int),
typeof(int), typeof(int), typeof(int), typeof(TimeSpan) });
if (ctor != null) {
return new InstanceDescriptor(ctor, new object[] {
dto.Year, dto.Month, dto.Day, dto.Hour, dto.Minute, dto.Second, dto.Millisecond, dto.Offset });
}
}
return base.ConvertTo(context, culture, value, destinationType);
}
}
}
|