Cadena contiene solo un conjunto dado de caracteres

Question

Necesito saber si una cadena dada es una cadena de formato de fecha y hora válida porque la cadena puede representar otras cosas. Intenté DateTime.ParseExact (somedate.ToString (formato), formato) pensando que sería un error en un formato no válido, pero no es así.

Así que estoy bien con simplemente probar si la cadena contiene solo caracteres "yYmMdDsShH". Algo como std :: string.find_first_not_of funcionaría, pero System.String no tiene esto.

Pensé que RegEx podría hacer el truco, pero estoy muy débil con expresiones regulares.

Tenga en cuenta que Linq no está disponible para esta (solo .NET 2.0).

Actualizado

Para aclarar, necesito saber si una determinada cadena representa un formato de fecha y no otra cosa como esta:

if (input == "some special value") 
... // it's a special case value 
else if (Environment.GetEnvironmentVariable(input)) 
... // it's an environment variable name 
else if (IsDateTimeFormatString(input)) 
... // it's a date time format string 
else if (input.IndexOfAny(Path.GetInvalidPathChars()) < 0) 
... // it's a file path 
else 
    throw new Exception(); // Not a valid input 

puedo restringir una cadena de formato DateTime a solamente "yYmMdDsShH", o puedo agregarle algunos caracteres separadores, depende de mí permitir o no permitir.

Answer 1

Con .NET2, necesita rodar su propio cheque para esto. Por ejemplo, el siguiente método utiliza un foreach para comprobar:

bool FormatValid(string format) 
{ 
    string allowableLetters = "yYmMdDsShH"; 

    foreach(char c in format) 
    { 
     // This is using String.Contains for .NET 2 compat., 
     // hence the requirement for ToString() 
     if (!allowableLetters.Contains(c.ToString())) 
       return false; 
    } 

    return true; 
} 

Si tuviera la opción de usar .NET 3.5 y LINQ, se podría utilizar Enumerable.Contains trabajar con caracteres directamente, y Enumerable.All. Esto simplificaría la anterior a:

bool valid = format.All(c => "yYmMdDsShH".Contains(c)); 

Answer 2

que acababa de hacer esto:

public static class DateTimeFormatHelper 
{ 
    // using a Dictionary<char, byte> instead of a HashSet<char> 
    // since you said you're using .NET 2.0 
    private static Dictionary<char, byte> _legalChars; 

    static DateTimeFormatHelper() 
    { 
     _legalChars = new Dictionary<char, byte>(); 
     foreach (char legalChar in "yYmMdDsShH") 
     { 
      _legalChars.Add(legalChar, 0); 
     } 
    } 

    public static bool IsPossibleDateTimeFormat(string format) 
    { 
     if (string.IsNullOrEmpty(format)) 
      return false; // or whatever makes sense to you 

     foreach (char c in format) 
     { 
      if (!_legalChars.ContainsKey(c)) 
       return false; 
     } 

     return true; 
    } 
} 

Por supuesto, esto podría ser una definición excesivamente estricta, ya que descarta lo que la mayoría de la gente consideraría formatos válidos como "aaaa-MM-dd" (ya que incluye los caracteres "-").

Determinar exactamente qué caracteres desea permitir es su decisión.

Answer 3

Algo así como

Regex regex = new Regex("^(y|Y|m|M|d|D|s|S|h|H)+$"); 
if (regex.IsMatch('DateTime String')) 
{ 
    // 'valid' 
} 

Si usted es, literalmente, la búsqueda de esos caracteres y no la representación numérica para una fecha determinada y el tiempo

Answer 4

De esta manera:

static readonly Regex Validator = new Regex(@"^[yYmMdDsShH]+$"); 

public static bool IsValid(string str) { 
    return Validator.IsMatch(str); 
} 

Las obras de expresiones regulares de esta manera:

• ^ coincide con el comienzo de la cadena
• [...] coincide con alguno de los personajes que aparecen en los soportes
• + coincide con uno o más caracteres que coinciden con el punto anterior
• $ coincide con el final de la cadena

Sin los anclajes ^ y $, la expresión regular coincidirá con cualquier cadena que contenga al menos un carácter válido, ya que una expresión regular puede coincidir con cualquier subcadena de la cadena. Utilícela. Los anclajes ^ y $ lo obligan a hacer coincidir toda la cadena.

Answer 5

ligeramente en cortocircuito la versión de Dan Tao ya cadena representa una implementación de IEnumerable & lt & carbón >

[TestClass] 
    public class UnitTest1 { 
     private HashSet<char> _legalChars = new HashSet<char>("yYmMdDsShH".ToCharArray()); 

     public bool IsPossibleDateTimeFormat(string format) { 
     if (string.IsNullOrEmpty(format)) 
      return false; // or whatever makes sense to you 
     return !format.Except(_legalChars).Any(); 
     } 

     [TestMethod] 
     public void TestMethod1() { 
     bool result = IsPossibleDateTimeFormat("yydD"); 
     result = IsPossibleDateTimeFormat("abc"); 
     } 
    } 

Answer 6

Gracias a todos. I 'aumenté' todos ustedes y conformé con una aplicación de fuerza bruta que no utiliza un diccionario/HashSet y no se convierte caracteres de cadenas:

private const string DateTimeFormatCharacters = "yYmMdDhHsS"; 
private static bool IsDateTimeFormatString(string input) 
{ 
    foreach (char c in input) 
     if (DateTimeFormatCharacters.IndexOf(c) < 0) 
      return false; 
    return true; 
} 

Answer 7

Hay un nuevo proyecto, NLib, lo que puede hacer esto mucho más rápido:

if (input.IndexOfNotAny(new char[] { 'y', 'm', 'd', 's', 'h' }, StringComparison.OrdinalIgnoreCase) < 0) 
{ 
    // Valid 
}