C# 仅解析字符串列表中的日期_C#_.net_C# 4.0

C# 仅解析字符串列表中的日期

c# .net c#-4.0

C# 仅解析字符串列表中的日期,c#,.net,c#-4.0,C#,.net,C# 4.0,是否可以仅检查和分析此列表中的日期： List<string> everything = new List<string> {"1", "A", "11/05/2013 22:43", "2.3", "21/11","null", "2012"}; 列出所有内容=新建列表 {“1”、“A”、“11/05/2013 22:43”、“2.3”、“21/11”、“空”、“2012”}；这应该只返回解析值11/05/2013 22:43

是否可以仅检查和分析此列表中的日期：

List<string> everything = new List<string>
                   {"1", "A", "11/05/2013 22:43", "2.3", "21/11","null", "2012"};

列出所有内容=新建列表
{“1”、“A”、“11/05/2013 22:43”、“2.3”、“21/11”、“空”、“2012”}；

这应该只返回解析值

11/05/2013 22:43

不应返回值

2.3

和

21/11

。

使用

dateimke.TryParse

。您可以使用以下LINQ查询：

IEnumerable<DateTime> dates = everything
    .Select(str => str.TryGetDate(CultureInfo.InvariantCulture))
    .Where(d => d.HasValue)
    .Select(d => d.Value);

结果:

Console.WriteLine(string.Join(", ", dates)); // 11/05/2013, 02/03/2013

编辑：因为您要解析确切的用法

DateTime.TryParseExact

。下面是另一个返回所需结果的方法：

public static DateTime? TryGetDateExact(this string item, String[] allowedFormats = null, params IFormatProvider[] formatProvider)
{
    if (formatProvider.Length == 0)
        formatProvider = new[] { CultureInfo.CurrentCulture };
    if (allowedFormats == null || allowedFormats.Length == 0)
    {
        allowedFormats = formatProvider
        .Select(fp => { 
            DateTimeFormatInfo dti = DateTimeFormatInfo.GetInstance(fp); 
            return String.Format("{0} {1}", dti.ShortDatePattern, dti.ShortTimePattern);
        })
        .ToArray();
    }
    bool success = false;
    DateTime d = DateTime.MinValue;
    foreach (var provider in formatProvider)
    {
        success = DateTime.TryParseExact(item, allowedFormats, provider, DateTimeStyles.None, out d);
        if (success) break;
    }
    return success ? (DateTime?)d : (DateTime?)null;
}

您可以这样使用它：

IEnumerable<DateTime> dates = everything
    .Select(str => str.TryGetDateExact(null, CultureInfo.InvariantCulture))
    .Where(d => d.HasValue)
    .Select(d => d.Value);

IEnumerable dates=一切
.Select（str=>str.TryGetDateExact（null，CultureInfo.InvariantCulture））
.其中（d=>d.HasValue）
.选择（d=>d.Value）；

注意，我使用了

CultureInfo.InvariantCulture

强制

作为分隔符。如果只想将

CultureInfo.CurrentCulture

与格式字符串一起使用，则可以省略所有参数。

使用

DateTimke.TryParse

。您可以使用以下LINQ查询：

IEnumerable<DateTime> dates = everything
    .Select(str => str.TryGetDate(CultureInfo.InvariantCulture))
    .Where(d => d.HasValue)
    .Select(d => d.Value);

结果:

Console.WriteLine(string.Join(", ", dates)); // 11/05/2013, 02/03/2013

编辑：因为您要解析确切的用法

DateTime.TryParseExact

。下面是另一个返回所需结果的方法：

public static DateTime? TryGetDateExact(this string item, String[] allowedFormats = null, params IFormatProvider[] formatProvider)
{
    if (formatProvider.Length == 0)
        formatProvider = new[] { CultureInfo.CurrentCulture };
    if (allowedFormats == null || allowedFormats.Length == 0)
    {
        allowedFormats = formatProvider
        .Select(fp => { 
            DateTimeFormatInfo dti = DateTimeFormatInfo.GetInstance(fp); 
            return String.Format("{0} {1}", dti.ShortDatePattern, dti.ShortTimePattern);
        })
        .ToArray();
    }
    bool success = false;
    DateTime d = DateTime.MinValue;
    foreach (var provider in formatProvider)
    {
        success = DateTime.TryParseExact(item, allowedFormats, provider, DateTimeStyles.None, out d);
        if (success) break;
    }
    return success ? (DateTime?)d : (DateTime?)null;
}

您可以这样使用它：

IEnumerable<DateTime> dates = everything
    .Select(str => str.TryGetDateExact(null, CultureInfo.InvariantCulture))
    .Where(d => d.HasValue)
    .Select(d => d.Value);

IEnumerable dates=一切
.Select（str=>str.TryGetDateExact（null，CultureInfo.InvariantCulture））
.其中（d=>d.HasValue）
.选择（d=>d.Value）；

注意，我使用了

CultureInfo.InvariantCulture

强制

作为分隔符。如果只想将

CultureInfo.CurrentCulture

与格式字符串一起使用，则可以省略所有参数。

使用

DateTimke.TryParse

。您可以使用以下LINQ查询：

IEnumerable<DateTime> dates = everything
    .Select(str => str.TryGetDate(CultureInfo.InvariantCulture))
    .Where(d => d.HasValue)
    .Select(d => d.Value);

结果:

Console.WriteLine(string.Join(", ", dates)); // 11/05/2013, 02/03/2013

编辑：因为您要解析确切的用法

DateTime.TryParseExact

。下面是另一个返回所需结果的方法：

public static DateTime? TryGetDateExact(this string item, String[] allowedFormats = null, params IFormatProvider[] formatProvider)
{
    if (formatProvider.Length == 0)
        formatProvider = new[] { CultureInfo.CurrentCulture };
    if (allowedFormats == null || allowedFormats.Length == 0)
    {
        allowedFormats = formatProvider
        .Select(fp => { 
            DateTimeFormatInfo dti = DateTimeFormatInfo.GetInstance(fp); 
            return String.Format("{0} {1}", dti.ShortDatePattern, dti.ShortTimePattern);
        })
        .ToArray();
    }
    bool success = false;
    DateTime d = DateTime.MinValue;
    foreach (var provider in formatProvider)
    {
        success = DateTime.TryParseExact(item, allowedFormats, provider, DateTimeStyles.None, out d);
        if (success) break;
    }
    return success ? (DateTime?)d : (DateTime?)null;
}

您可以这样使用它：

IEnumerable<DateTime> dates = everything
    .Select(str => str.TryGetDateExact(null, CultureInfo.InvariantCulture))
    .Where(d => d.HasValue)
    .Select(d => d.Value);

IEnumerable dates=一切
.Select（str=>str.TryGetDateExact（null，CultureInfo.InvariantCulture））
.其中（d=>d.HasValue）
.选择（d=>d.Value）；

注意，我使用了

CultureInfo.InvariantCulture

强制

作为分隔符。如果只想将

CultureInfo.CurrentCulture

与格式字符串一起使用，则可以省略所有参数。

使用

DateTimke.TryParse

。您可以使用以下LINQ查询：

IEnumerable<DateTime> dates = everything
    .Select(str => str.TryGetDate(CultureInfo.InvariantCulture))
    .Where(d => d.HasValue)
    .Select(d => d.Value);

结果:

Console.WriteLine(string.Join(", ", dates)); // 11/05/2013, 02/03/2013

编辑：因为您要解析确切的用法

DateTime.TryParseExact

。下面是另一个返回所需结果的方法：

public static DateTime? TryGetDateExact(this string item, String[] allowedFormats = null, params IFormatProvider[] formatProvider)
{
    if (formatProvider.Length == 0)
        formatProvider = new[] { CultureInfo.CurrentCulture };
    if (allowedFormats == null || allowedFormats.Length == 0)
    {
        allowedFormats = formatProvider
        .Select(fp => { 
            DateTimeFormatInfo dti = DateTimeFormatInfo.GetInstance(fp); 
            return String.Format("{0} {1}", dti.ShortDatePattern, dti.ShortTimePattern);
        })
        .ToArray();
    }
    bool success = false;
    DateTime d = DateTime.MinValue;
    foreach (var provider in formatProvider)
    {
        success = DateTime.TryParseExact(item, allowedFormats, provider, DateTimeStyles.None, out d);
        if (success) break;
    }
    return success ? (DateTime?)d : (DateTime?)null;
}

您可以这样使用它：

IEnumerable<DateTime> dates = everything
    .Select(str => str.TryGetDateExact(null, CultureInfo.InvariantCulture))
    .Where(d => d.HasValue)
    .Select(d => d.Value);

IEnumerable dates=一切
.Select（str=>str.TryGetDateExact（null，CultureInfo.InvariantCulture））
.其中（d=>d.HasValue）
.选择（d=>d.Value）；

注意，我使用了

CultureInfo.InvariantCulture

强制

作为分隔符。如果只想对格式字符串使用

CultureInfo.CurrentCulture

，则可以省略所有参数。

可以使用

DateTime.TryParse

：只需尝试解析列表中的每个字符串，如果解析成功，则为DateTime

列表数据=新列表（）；
foreach（所有内容中的字符串st）{
日期时间日期时间；
如果（DateTime.TryParse（st，out DateTime））/您可以使用DateTime.TryParse
：只需尝试解析列表中的每个字符串，如果解析成功，则为DateTime

列表数据=新列表（）；
foreach（所有内容中的字符串st）{
日期时间日期时间；
如果（DateTime.TryParse（st，out DateTime））/您可以使用DateTime.TryParse
：只需尝试解析列表中的每个字符串，如果解析成功，则为DateTime

列表数据=新列表（）；
foreach（所有内容中的字符串st）{
日期时间日期时间；
如果（DateTime.TryParse（st，out DateTime））/您可以使用DateTime.TryParse
：只需尝试解析列表中的每个字符串，如果解析成功，则为DateTime

列表数据=新列表（）；
foreach（所有内容中的字符串st）{
日期时间日期时间；
如果（DateTime.TryParse（st，out DateTime））/这将忽略作为有效日期值的“2.3”
        List<string> everything = new List<string> { "20131105", "1", "A", "11/05/2013 22:43", "2.3", "21/11", "null", "2012" };
        List<string> allDates = new List<string>();
        DateTime d;
        foreach (string s in everything)
        {
            if (s.Length < 8) continue;
            if (DateTime.TryParse(s, out d))
            {
                allDates.Add(s);
            }
        }

List everything=新列表{“20131105”、“1”、“A”、“11/05/2013 22:43”、“2.3”、“21/11”、“null”、“2012”}；
List allDates=新列表（）；
日期时间；
foreach（所有内容中的字符串s）
{
如果（s.长度<8）继续；
if（DateTime.TryParse（s，out d））
{
所有日期。添加（s）；
}
}
这将忽略作为有效日期值的“2.3”
        List<string> everything = new List<string> { "20131105", "1", "A", "11/05/2013 22:43", "2.3", "21/11", "null", "2012" };
        List<string> allDates = new List<string>();
        DateTime d;
        foreach (string s in everything)
        {
            if (s.Length < 8) continue;
            if (DateTime.TryParse(s, out d))
            {
                allDates.Add(s);
            }
        }

List everything=新列表{“20131105”、“1”、“A”、“11/05/2013 22:43”、“2.3”、“21/11”、“null”、“2012”}；
List allDates=新列表（）；
日期时间；
foreach（所有内容中的字符串s）
{
如果（s.长度<8）继续；
if（DateTime.TryParse（s，out d））
{
所有日期。添加（s）；
}
}
这将忽略作为有效日期值的“2.3”
        List<string> everything = new List<string> { "20131105", "1", "A", "11/05/2013 22:43", "2.3", "21/11", "null", "2012" };
        List<string> allDates = new List<string>();
        DateTime d;
        foreach (string s in everything)
        {
            if (s.Length < 8) continue;
            if (DateTime.TryParse(s, out d))
            {
                allDates.Add(s);
            }
        }

List everything=新列表{“20131105”、“1”、“A”、“11/05/2013 22:43”、“2.3”、“21/11”、“null”、“2012”}；
List allDates=新列表（）；
日期时间；
foreach（所有内容中的字符串s）
{
如果（s.长度<8）继续；
if（DateTime.TryParse（s，out d））
{
所有日期。添加（s）；
}
}
这将忽略作为有效日期值的“2.3”
        List<string> everything = new List<string> { "20131105", "1", "A", "11/05/2013 22:43", "2.3", "21/11", "null", "2012" };
        List<string> allDates = new List<string>();
        DateTime d;
        foreach (string s in everything)
        {
            if (s.Length < 8) continue;
            if (DateTime.TryParse(s, out d))
            {
                allDates.Add(s);
            }
        }

List everything=新列表{“20131105”、“1”、“A”、“11/05/2013 22:43”、“2.3”、“21/11”、“null”、“2012”}；
List allDates=新列表（）；
日期时间；
foreach（所有内容中的字符串s）
{
如果（s.长度<8）继续；
if（DateTime.TryParse（s，out d））