如何将DateTime结构转换为其等效的RFC 822日期时间格式化字符串表示形式，并在.NET中解析此字符串表示形式以返回DateTime结构？ RFC-822日期时间格式在许多规范（如RSS合成格式）中使用。
6个回答
50
尝试这个：
DateTime today = DateTime.Now;
String rfc822 = today.ToString("r");
Console.WriteLine("RFC-822 date: {0}", rfc822);
DateTime parsedRFC822 = DateTime.Parse(rfc822);
Console.WriteLine("Date: {0}", parsedRFC822);
在DateTime的ToString()方法中传入的"r"格式说明符实际上生成了一个RFC-1123格式的日期时间字符串，但也可以基于读取http://www.w3.org/Protocols/rfc822/#z28规范作为RFC-822日期。我在创建RSS订阅时使用了此方法，并且它们通过http://validator.w3.org/feed/check.cgi提供的验证程序进行了验证。
缺点是在转换过程中会将日期时间转换为GMT时间。要转换回本地时间，您需要应用本地时区偏移量。为此，您可以使用TimeZone类获取当前时区偏移量，并将"GMT"替换为时区偏移字符串：
TimeZone tz = TimeZone.CurrentTimeZone;
String offset = tz.GetUtcOffset().ToString();
// My locale is Mountain time; offset is set to "-07:00:00"
// if local time is behind utc time, offset should start with "-".
// otherwise, add a plus sign to the beginning of the string.
if (!offset.StartsWith("-"))
offset = "+" + offset; // Add a (+) if it's a UTC+ timezone
offset = offset.Substring(0,6); // only want the first 6 chars.
offset = offset.Replace(":", ""); // remove colons.
// offset now looks something like "-0700".
rfc822 = rfc822.Replace("GMT", offset);
// The rfc822 string can now be parsed back to a DateTime object,
// with the local time accounted for.
DateTime new = DateTime.Parse(rfc822);
- Jeff Woodman
31
这是一个使用C#实现的解析和转换DateTime到RFC-822格式的示例。唯一的限制是DateTime必须是协调世界时（UTC）。我同意这并不是非常优美的代码，但它可以完成工作。
/// <summary>
/// Provides methods for converting <see cref="DateTime"/> structures
/// to and from the equivalent <a href="http://www.w3.org/Protocols/rfc822/#z28">RFC 822</a>
/// string representation.
/// </summary>
public class Rfc822DateTime
{
//============================================================
// Private members
//============================================================
#region Private Members
/// <summary>
/// Private member to hold array of formats that RFC 822 date-time representations conform to.
/// </summary>
private static string[] formats = new string[0];
/// <summary>
/// Private member to hold the DateTime format string for representing a DateTime in the RFC 822 format.
/// </summary>
private const string format = "ddd, dd MMM yyyy HH:mm:ss K";
#endregion
//============================================================
// Public Properties
//============================================================
#region Rfc822DateTimeFormat
/// <summary>
/// Gets the custom format specifier that may be used to represent a <see cref="DateTime"/> in the RFC 822 format.
/// </summary>
/// <value>A <i>DateTime format string</i> that may be used to represent a <see cref="DateTime"/> in the RFC 822 format.</value>
/// <remarks>
/// <para>
/// This method returns a string representation of a <see cref="DateTime"/> that utilizes the time zone
/// offset (local differential) to represent the offset from Greenwich mean time in hours and minutes.
/// The <see cref="Rfc822DateTimeFormat"/> is a valid date-time format string for use
/// in the <see cref="DateTime.ToString(String, IFormatProvider)"/> method.
/// </para>
/// <para>
/// The <a href="http://www.w3.org/Protocols/rfc822/#z28">RFC 822</a> Date and Time specification
/// specifies that the year will be represented as a two-digit value, but the
/// <a href="http://www.rssboard.org/rss-profile#data-types-datetime">RSS Profile</a> recommends that
/// all date-time values should use a four-digit year. The <see cref="Rfc822DateTime"/> class
/// follows the RSS Profile recommendation when converting a <see cref="DateTime"/> to the equivalent
/// RFC 822 string representation.
/// </para>
/// </remarks>
public static string Rfc822DateTimeFormat
{
get
{
return format;
}
}
#endregion
#region Rfc822DateTimePatterns
/// <summary>
/// Gets an array of the expected formats for RFC 822 date-time string representations.
/// </summary>
/// <value>
/// An array of the expected formats for RFC 822 date-time string representations
/// that may used in the <see cref="DateTime.TryParseExact(String, string[], IFormatProvider, DateTimeStyles, out DateTime)"/> method.
/// </value>
/// <remarks>
/// The array of the expected formats that is returned assumes that the RFC 822 time zone
/// is represented as or converted to a local differential representation.
/// </remarks>
/// <seealso cref="ConvertZoneToLocalDifferential(String)"/>
public static string[] Rfc822DateTimePatterns
{
get
{
if (formats.Length > 0)
{
return formats;
}
else
{
formats = new string[35];
// two-digit day, four-digit year patterns
formats[0] = "ddd',' dd MMM yyyy HH':'mm':'ss'.'fffffff zzzz";
formats[1] = "ddd',' dd MMM yyyy HH':'mm':'ss'.'ffffff zzzz";
formats[2] = "ddd',' dd MMM yyyy HH':'mm':'ss'.'fffff zzzz";
formats[3] = "ddd',' dd MMM yyyy HH':'mm':'ss'.'ffff zzzz";
formats[4] = "ddd',' dd MMM yyyy HH':'mm':'ss'.'fff zzzz";
formats[5] = "ddd',' dd MMM yyyy HH':'mm':'ss'.'ff zzzz";
formats[6] = "ddd',' dd MMM yyyy HH':'mm':'ss'.'f zzzz";
formats[7] = "ddd',' dd MMM yyyy HH':'mm':'ss zzzz";
// two-digit day, two-digit year patterns
formats[8] = "ddd',' dd MMM yy HH':'mm':'ss'.'fffffff zzzz";
formats[9] = "ddd',' dd MMM yy HH':'mm':'ss'.'ffffff zzzz";
formats[10] = "ddd',' dd MMM yy HH':'mm':'ss'.'fffff zzzz";
formats[11] = "ddd',' dd MMM yy HH':'mm':'ss'.'ffff zzzz";
formats[12] = "ddd',' dd MMM yy HH':'mm':'ss'.'fff zzzz";
formats[13] = "ddd',' dd MMM yy HH':'mm':'ss'.'ff zzzz";
formats[14] = "ddd',' dd MMM yy HH':'mm':'ss'.'f zzzz";
formats[15] = "ddd',' dd MMM yy HH':'mm':'ss zzzz";
// one-digit day, four-digit year patterns
formats[16] = "ddd',' d MMM yyyy HH':'mm':'ss'.'fffffff zzzz";
formats[17] = "ddd',' d MMM yyyy HH':'mm':'ss'.'ffffff zzzz";
formats[18] = "ddd',' d MMM yyyy HH':'mm':'ss'.'fffff zzzz";
formats[19] = "ddd',' d MMM yyyy HH':'mm':'ss'.'ffff zzzz";
formats[20] = "ddd',' d MMM yyyy HH':'mm':'ss'.'fff zzzz";
formats[21] = "ddd',' d MMM yyyy HH':'mm':'ss'.'ff zzzz";
formats[22] = "ddd',' d MMM yyyy HH':'mm':'ss'.'f zzzz";
formats[23] = "ddd',' d MMM yyyy HH':'mm':'ss zzzz";
// two-digit day, two-digit year patterns
formats[24] = "ddd',' d MMM yy HH':'mm':'ss'.'fffffff zzzz";
formats[25] = "ddd',' d MMM yy HH':'mm':'ss'.'ffffff zzzz";
formats[26] = "ddd',' d MMM yy HH':'mm':'ss'.'fffff zzzz";
formats[27] = "ddd',' d MMM yy HH':'mm':'ss'.'ffff zzzz";
formats[28] = "ddd',' d MMM yy HH':'mm':'ss'.'fff zzzz";
formats[29] = "ddd',' d MMM yy HH':'mm':'ss'.'ff zzzz";
formats[30] = "ddd',' d MMM yy HH':'mm':'ss'.'f zzzz";
formats[31] = "ddd',' d MMM yy HH':'mm':'ss zzzz";
// Fall back patterns
formats[32] = "yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'fffffffK"; // RoundtripDateTimePattern
formats[33] = DateTimeFormatInfo.InvariantInfo.UniversalSortableDateTimePattern;
formats[34] = DateTimeFormatInfo.InvariantInfo.SortableDateTimePattern;
return formats;
}
}
}
#endregion
//============================================================
// Public Methods
//============================================================
#region Parse(string s)
/// <summary>
/// Converts the specified string representation of a date and time to its <see cref="DateTime"/> equivalent.
/// </summary>
/// <param name="s">A string containing a date and time to convert.</param>
/// <returns>
/// A <see cref="DateTime"/> equivalent to the date and time contained in <paramref name="s"/>,
/// expressed as <i>Coordinated Universal Time (UTC)</i>.
/// </returns>
/// <remarks>
/// The string <paramref name="s"/> is parsed using formatting information in the <see cref="DateTimeFormatInfo.InvariantInfo"/> object.
/// </remarks>
/// <exception cref="ArgumentNullException"><paramref name="s"/> is a <b>null</b> reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException"><paramref name="s"/> is an empty string.</exception>
/// <exception cref="FormatException"><paramref name="s"/> does not contain a valid RFC 822 string representation of a date and time.</exception>
public static DateTime Parse(string s)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
if (String.IsNullOrEmpty(s))
{
throw new ArgumentNullException("s");
}
DateTime result;
if (Rfc822DateTime.TryParse(s, out result))
{
return result;
}
else
{
throw new FormatException(String.Format(null, "{0} is not a valid RFC 822 string representation of a date and time.", s));
}
}
#endregion
#region ConvertZoneToLocalDifferential(string s)
/// <summary>
/// Converts the time zone component of an RFC 822 date and time string representation to its local differential (time zone offset).
/// </summary>
/// <param name="s">A string containing an RFC 822 date and time to convert.</param>
/// <returns>A date and time string that uses local differential to describe the time zone equivalent to the date and time contained in <paramref name="s"/>.</returns>
/// <exception cref="ArgumentNullException"><paramref name="s"/> is a <b>null</b> reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException"><paramref name="s"/> is an empty string.</exception>
public static string ConvertZoneToLocalDifferential(string s)
{
string zoneRepresentedAsLocalDifferential = String.Empty;
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
if (String.IsNullOrEmpty(s))
{
throw new ArgumentNullException("s");
}
if(s.EndsWith(" UT", StringComparison.OrdinalIgnoreCase))
{
zoneRepresentedAsLocalDifferential = String.Concat(s.Substring(0, (s.LastIndexOf(" UT") + 1) ), "+00:00");
}
else if (s.EndsWith(" GMT", StringComparison.OrdinalIgnoreCase))
{
zoneRepresentedAsLocalDifferential = String.Concat(s.Substring(0, (s.LastIndexOf(" GMT") + 1 ) ), "+00:00");
}
else if (s.EndsWith(" EST", StringComparison.OrdinalIgnoreCase))
{
zoneRepresentedAsLocalDifferential = String.Concat(s.Substring(0, (s.LastIndexOf(" EST") + 1)), "-05:00");
}
else if (s.EndsWith(" EDT", StringComparison.OrdinalIgnoreCase))
{
zoneRepresentedAsLocalDifferential = String.Concat(s.Substring(0, (s.LastIndexOf(" EDT") + 1)), "-04:00");
}
else if (s.EndsWith(" CST", StringComparison.OrdinalIgnoreCase))
{
zoneRepresentedAsLocalDifferential = String.Concat(s.Substring(0, (s.LastIndexOf(" CST") + 1)), "-06:00");
}
else if (s.EndsWith(" CDT", StringComparison.OrdinalIgnoreCase))
{
zoneRepresentedAsLocalDifferential = String.Concat(s.Substring(0, (s.LastIndexOf(" CDT") + 1)), "-05:00");
}
else if (s.EndsWith(" MST", StringComparison.OrdinalIgnoreCase))
{
zoneRepresentedAsLocalDifferential = String.Concat(s.Substring(0, (s.LastIndexOf(" MST") + 1)), "-07:00");
}
else if (s.EndsWith(" MDT", StringComparison.OrdinalIgnoreCase))
{
zoneRepresentedAsLocalDifferential = String.Concat(s.Substring(0, (s.LastIndexOf(" MDT") + 1)), "-06:00");
}
else if (s.EndsWith(" PST", StringComparison.OrdinalIgnoreCase))
{
zoneRepresentedAsLocalDifferential = String.Concat(s.Substring(0, (s.LastIndexOf(" PST") + 1)), "-08:00");
}
else if (s.EndsWith(" PDT", StringComparison.OrdinalIgnoreCase))
{
zoneRepresentedAsLocalDifferential = String.Concat(s.Substring(0, (s.LastIndexOf(" PDT") + 1)), "-07:00");
}
else if (s.EndsWith(" Z", StringComparison.OrdinalIgnoreCase))
{
zoneRepresentedAsLocalDifferential = String.Concat(s.Substring(0, (s.LastIndexOf(" Z") + 1)), "+00:00");
}
else if (s.EndsWith(" A", StringComparison.OrdinalIgnoreCase))
{
zoneRepresentedAsLocalDifferential = String.Concat(s.Substring(0, (s.LastIndexOf(" A") + 1)), "-01:00");
}
else if (s.EndsWith(" M", StringComparison.OrdinalIgnoreCase))
{
zoneRepresentedAsLocalDifferential = String.Concat(s.Substring(0, (s.LastIndexOf(" M") + 1)), "-12:00");
}
else if (s.EndsWith(" N", StringComparison.OrdinalIgnoreCase))
{
zoneRepresentedAsLocalDifferential = String.Concat(s.Substring(0, (s.LastIndexOf(" N") + 1)), "+01:00");
}
else if (s.EndsWith(" Y", StringComparison.OrdinalIgnoreCase))
{
zoneRepresentedAsLocalDifferential = String.Concat(s.Substring(0, (s.LastIndexOf(" Y") + 1)), "+12:00");
}
else
{
zoneRepresentedAsLocalDifferential = s;
}
return zoneRepresentedAsLocalDifferential;
}
#endregion
#region ToString(DateTime utcDateTime)
/// <summary>
/// Converts the value of the specified <see cref="DateTime"/> object to its equivalent string representation.
/// </summary>
/// <param name="utcDateTime">The Coordinated Universal Time (UTC) <see cref="DateTime"/> to convert.</param>
/// <returns>A RFC 822 string representation of the value of the <paramref name="utcDateTime"/>.</returns>
/// <exception cref="ArgumentException">The specified <paramref name="utcDateTime"/> object does not represent a <see cref="DateTimeKind.Utc">Coordinated Universal Time (UTC)</see> value.</exception>
public static string ToString(DateTime utcDateTime)
{
if (utcDateTime.Kind != DateTimeKind.Utc)
{
throw new ArgumentException("utcDateTime");
}
return utcDateTime.ToString(Rfc822DateTime.Rfc822DateTimeFormat, DateTimeFormatInfo.InvariantInfo);
}
#endregion
#region TryParse(string s, out DateTime result)
/// <summary>
/// Converts the specified string representation of a date and time to its <see cref="DateTime"/> equivalent.
/// </summary>
/// <param name="s">A string containing a date and time to convert.</param>
/// <param name="result">
/// When this method returns, contains the <see cref="DateTime"/> value equivalent to the date and time
/// contained in <paramref name="s"/>, expressed as <i>Coordinated Universal Time (UTC)</i>,
/// if the conversion succeeded, or <see cref="DateTime.MinValue">MinValue</see> if the conversion failed.
/// The conversion fails if the s parameter is a <b>null</b> reference (Nothing in Visual Basic),
/// or does not contain a valid string representation of a date and time.
/// This parameter is passed uninitialized.
/// </param>
/// <returns><b>true</b> if the <paramref name="s"/> parameter was converted successfully; otherwise, <b>false</b>.</returns>
/// <remarks>
/// The string <paramref name="s"/> is parsed using formatting information in the <see cref="DateTimeFormatInfo.InvariantInfo"/> object.
/// </remarks>
public static bool TryParse(string s, out DateTime result)
{
//------------------------------------------------------------
// Attempt to convert string representation
//------------------------------------------------------------
bool wasConverted = false;
result = DateTime.MinValue;
if (!String.IsNullOrEmpty(s))
{
DateTime parseResult;
if (DateTime.TryParseExact(Rfc822DateTime.ConvertZoneToLocalDifferential(s), Rfc822DateTime.Rfc822DateTimePatterns, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AdjustToUniversal, out parseResult))
{
result = DateTime.SpecifyKind(parseResult, DateTimeKind.Utc);
wasConverted = true;
}
}
return wasConverted;
}
#endregion
}
- Oppositional
5
在这段代码中使用
Guard 类型让我想起了 Argotic Syndication Framework 中的解决方案。这是来自 Argotic 的 beta 代码吗？他们在最新版本的 Argotic 中对这个问题的解决方案是我见过的最好的。 - rasx这不是Argotic的beta代码，我相信最新的Argotic可能比这里概述的实现更好。 - Oppositional
1错误4：当前不存在名称“Guard”。
-1 未提交可工作的代码。 - aron
看起来你只处理了单个字母后缀 A、M、N、Y 和 Z。规范说明除 J 外，所有字母都是允许的，A-M（不包括 J）表示范围为 -1 到 -12 小时，而 N 到 Y 表示 +1 到 +12 小时的范围。 - Richard Fawcett
3
按照Kirk的想法，我反编译了System.ServiceModel.Syndication.Rss20FeedFormatter类（System.ServiceModel.dll），这里是Microsoft内部解析RFC 822日期格式的解析器（我稍微简化了他们的异常处理逻辑以减少依赖）：
public static class DateTimeParser
{
public static DateTimeOffset ParseDateTimeRFC822(string dateTimeString)
{
StringBuilder dateTimeStringBuilder = new StringBuilder(dateTimeString.Trim());
if (dateTimeStringBuilder.Length < 18)
{
throw new FormatException("Invalid date format. Expected date in RFC 822 format");
}
if (dateTimeStringBuilder[3] == ',')
{
// There is a leading (e.g.) "Tue, ", strip it off
dateTimeStringBuilder.Remove(0, 4);
// There's supposed to be a space here but some implementations dont have one
RemoveExtraWhiteSpaceAtStart(dateTimeStringBuilder);
}
ReplaceMultipleWhiteSpaceWithSingleWhiteSpace(dateTimeStringBuilder);
if (char.IsDigit(dateTimeStringBuilder[1]))
{
// two-digit day, we are good
}
else
{
dateTimeStringBuilder.Insert(0, '0');
}
if (dateTimeStringBuilder.Length < 19)
{
throw new FormatException("Invalid date format. Expected date in RFC 822 format");
}
bool thereAreSeconds = (dateTimeStringBuilder[17] == ':');
int timeZoneStartIndex;
if (thereAreSeconds)
{
timeZoneStartIndex = 21;
}
else
{
timeZoneStartIndex = 18;
}
string timeZoneSuffix = dateTimeStringBuilder.ToString().Substring(timeZoneStartIndex);
dateTimeStringBuilder.Remove(timeZoneStartIndex, dateTimeStringBuilder.Length - timeZoneStartIndex);
bool isUtc;
dateTimeStringBuilder.Append(NormalizeTimeZone(timeZoneSuffix, out isUtc));
string wellFormattedString = dateTimeStringBuilder.ToString();
DateTimeOffset theTime;
string parseFormat;
if (thereAreSeconds)
{
parseFormat = "dd MMM yyyy HH:mm:ss zzz";
}
else
{
parseFormat = "dd MMM yyyy HH:mm zzz";
}
if (DateTimeOffset.TryParseExact(wellFormattedString, parseFormat,
CultureInfo.InvariantCulture.DateTimeFormat,
(isUtc ? DateTimeStyles.AdjustToUniversal : DateTimeStyles.None), out theTime))
{
return theTime;
}
throw new FormatException("Invalid date format. Expected date in RFC 822 format");
}
static string NormalizeTimeZone(string rfc822TimeZone, out bool isUtc)
{
isUtc = false;
// return a string in "-08:00" format
if (rfc822TimeZone[0] == '+' || rfc822TimeZone[0] == '-')
{
// the time zone is supposed to be 4 digits but some feeds omit the initial 0
StringBuilder result = new StringBuilder(rfc822TimeZone);
if (result.Length == 4)
{
// the timezone is +/-HMM. Convert to +/-HHMM
result.Insert(1, '0');
}
result.Insert(3, ':');
return result.ToString();
}
switch (rfc822TimeZone)
{
case "UT":
case "Z":
isUtc = true;
return "-00:00";
case "GMT":
return "-00:00";
case "A":
return "-01:00";
case "B":
return "-02:00";
case "C":
return "-03:00";
case "D":
case "EDT":
return "-04:00";
case "E":
case "EST":
case "CDT":
return "-05:00";
case "F":
case "CST":
case "MDT":
return "-06:00";
case "G":
case "MST":
case "PDT":
return "-07:00";
case "H":
case "PST":
return "-08:00";
case "I":
return "-09:00";
case "K":
return "-10:00";
case "L":
return "-11:00";
case "M":
return "-12:00";
case "N":
return "+01:00";
case "O":
return "+02:00";
case "P":
return "+03:00";
case "Q":
return "+04:00";
case "R":
return "+05:00";
case "S":
return "+06:00";
case "T":
return "+07:00";
case "U":
return "+08:00";
case "V":
return "+09:00";
case "W":
return "+10:00";
case "X":
return "+11:00";
case "Y":
return "+12:00";
default:
return "";
}
}
static void RemoveExtraWhiteSpaceAtStart(StringBuilder stringBuilder)
{
int i = 0;
while (i < stringBuilder.Length)
{
if (!char.IsWhiteSpace(stringBuilder[i]))
{
break;
}
++i;
}
if (i > 0)
{
stringBuilder.Remove(0, i);
}
}
static void ReplaceMultipleWhiteSpaceWithSingleWhiteSpace(StringBuilder builder)
{
int index = 0;
int whiteSpaceStart = -1;
while (index < builder.Length)
{
if (char.IsWhiteSpace(builder[index]))
{
if (whiteSpaceStart < 0)
{
whiteSpaceStart = index;
// normalize all white spaces to be ' ' so that the date time parsing works
builder[index] = ' ';
}
}
else if (whiteSpaceStart >= 0)
{
if (index > whiteSpaceStart + 1)
{
// there are at least 2 spaces... replace by 1
builder.Remove(whiteSpaceStart, index - whiteSpaceStart - 1);
index = whiteSpaceStart + 1;
}
whiteSpaceStart = -1;
}
++index;
}
// we have already trimmed the start and end so there cannot be a trail of white spaces in the end
Debug.Assert(builder.Length == 0 || builder[builder.Length - 1] != ' ', "The string builder doesnt end in a white space");
}
}
第一件看起来不寻常的事情是它们返回
[DateTimeOffset][1]类而不是DateTime。但是当我们更多地了解它时，它似乎完全合乎逻辑 - DateTimeOffset存储日期、时间和时区信息（正如RFC 822格式中的字符串）。如果您只返回DateTime对象，那么它将在哪个时区：UTC、本地还是在解析字符串中指定的时区 - 任何答案都有些情况是错误的。因此，DateTimeOffset解决了一个重要的不确定性问题。您可以使用方法DateTimeOffset.ToUniversalTime()、DateTimeOffset.ToLocalTime()将其转换为所需的时区。
我在几个案例中进行了测试，它似乎完美地完成了工作。
虽然我不确定为什么微软决定使此实现私有 - 它似乎不需要太多支持。
- Sasha
2
这是Microsoft在Rss20FeedFormatter中的实现方式。Oppositional的代码没有去掉GMT偏移量部分的“:”符号。Jeff Woodman的代码似乎可以做到这一点。下面的代码也可以做到这一点（如果不使用Atom10FeedFormatter.zeroOffset）。
private string AsString(DateTimeOffset dateTime)
{
if (dateTime.Offset == Atom10FeedFormatter.zeroOffset)
{
return dateTime.ToUniversalTime().ToString("ddd, dd MMM yyyy HH:mm:ss Z", CultureInfo.InvariantCulture);
}
StringBuilder builder = new StringBuilder(dateTime.T)oString("ddd, dd MMM yyyy HH:mm:ss zzz", CultureInfo.InvariantCulture));
builder.Remove(builder.Length - 3, 1);
return builder.ToString();
}
- Kirk Liemohn
2
无法解析
Atom10FeedFormatter。在 VS2015 下该如何修复？ - Adrian已经过去了7年，因此如果您还没有尝试，请尝试以下方法。将System.ServiceModel.dll作为程序集引用，并添加一个关于System.ServiceModel.Syndication的Using语句。请参见:https://msdn.microsoft.com/zh-cn/library/system.servicemodel.syndication.atom10feedformatter(v=vs.110).aspx - Kirk Liemohn
1
根据Kirk Liemohn的答案，我成功地使用了这种方法：
private DateTimeOffset? ParseDate(string date)
{
const string FORMAT = "ddd, d MMM yyyy HH:mm:ss zzz";
const string FORMAT2 = "ddd, dd MMM yyyy HH:mm:ss zzz";
const string FORMAT3 = "dd MMM yyyy HH:mm:ss zzz";
const string FORMAT4 = "d MMM yyyy HH:mm:ss zzz";
DateTimeOffset d;
if (DateTimeOffset.TryParseExact(date, new string[] { FORMAT, FORMAT2, FORMAT3, FORMAT4 }, CultureInfo.InvariantCulture, DateTimeStyles.AllowLeadingWhite | DateTimeStyles.AllowTrailingWhite, out d))
return d;
return null;
}
例子：
DateTimeOffset? date = ParseDate("Thu, 5 Apr 2012 23:47:37 +0200");
Console.WriteLine(date.ToString());
// => 05/04/2012 23:47:37 +02:00
它并不完全符合RFC的规范，但对于我的用例来说是有效的。
具体而言，它无法处理像"GMT"、"CST"等时区表示方式（请参见RFC822第5.1节中的"zone"）。请参阅Oleksandr Pshenychnyy的更好答案。
- Eric Boumendil
1
这是我的实现，使用了扩展方法：
namespace MyNamespace
{
public static partial class ExtensionMethods
{
public static string ToRFC822String(this DateTime timestamp)
{
return timestamp.ToString("ddd',' d MMM yyyy HH':'mm':'ss")
+ " "
+ timestamp.ToString("zzzz").Replace(":", "");
}
}
}
使用方法：
using MyNamespace;
....
string MyRFC822String = DateTime.Now.ToRFC822String();
- Raymond Powell
网页内容由stack overflow 提供, 点击上面的可以查看英文原文，
原文链接
原文链接
- 相关问题
- 56 将日期格式yyyyMMdd转换为系统datetime格式
- 5 萨克森 XSLT 2.0 和 RFC 822 日期格式
- 25 将YYYYMMDD/HHMMSS格式的日期/时间转换为Python datetime
- 36 将Python日期时间转换为RFC 2822
- 4 将RFC 822日期转换为TDateTime
- 10 电子邮件地址的RFC 822格式是什么？
- 31 如何将RFC 2822日期/时间解析为Python datetime？
- 38 如何使用Java解析RFC 3339格式的日期时间？
- 3 将RFC 3339纳秒时间转换为Python datetime
- 56 如何解析和转换DateTime为RFC 3339日期时间格式？