Laden...

InputValidator - Eingaben auf Typ prüfen

Erstellt von inflames2k vor 12 Jahren Letzter Beitrag vor 12 Jahren 8.324 Views
inflames2k Themenstarter:in
2.298 Beiträge seit 2010
vor 12 Jahren
InputValidator - Eingaben auf Typ prüfen

Beschreibung:

Im laufe der Zeit hat sich bei mir die statische Klasse InputValidator mit Methoden zur Prüfung von Eingaben angesammelt, die mir schon oft geholfen hat. Mit der Zeit kommen ab und an mal neue Methoden hinzu, und sie ist auch nicht gerade riesig.

Bis zum Zeitpunkt als ich begonnen habe mit der Klasse zu arbeiten, habe ich die Prüfungen immer wieder neu geschrieben, für jede Anwendung. Auch wenn der nutzen nur in Hinsicht der wiederverwendbarkeit liegt, möchte ich euch die Klasse nicht vorenthalten. Die Validierung eigener Typen habe ich entfernt. Somit bleibt eine überschaubare Menge an Typen übrig.

Update (18.11.2011): Die Klasse wurde von mir so geändert, dass die Validierungsmethode generisch ist, und eine Verwendung als Erweiterungsmethode möglich ist.


    public static class InputValidator
    {
       /// <summary>
       /// Method to check if a string can be converted to a given type
       /// </summary>
       /// <typeparam name="T">the type</typeparam>
       /// <param name="input">the input</param>
       /// <returns>true if the string can be converted to the given type</returns>
       public static bool CanConvertTo<T>(this string input)
       {
           Object converted;
            try
            {
                 converted = Convert.ChangeType(input, typeof(T));
            }
            catch
            {
                 converted = null;
             }
          return converted != null;
       }
    }

Schlagwörter: Eingabevalidigierung, Typprüfung, Datentypen, input validation, InputValidator

Wissen ist nicht alles. Man muss es auch anwenden können.

PS Fritz!Box API - TR-064 Schnittstelle | PS EventLogManager |

Gelöschter Account
vor 12 Jahren

Die zuweisung des Defaultwertes solltest du weglassen, da bei einem "out" Parameter diese nicht notwendig ist, bzw. sowieso überschrieben wird.

6.911 Beiträge seit 2009
vor 12 Jahren

Hallo inflames2k,

cool wäre das ganze noch als Erweiterungsmethoden - also überall ein this vor das String-Argument.

mfG Gü

Stellt fachliche Fragen bitte im Forum, damit von den Antworten alle profitieren. Daher beantworte ich solche Fragen nicht per PM.

"Alle sagten, das geht nicht! Dann kam einer, der wusste das nicht - und hat's gemacht!"

D
38 Beiträge seit 2009
vor 12 Jahren

// Codeoptimierung an

  
    /// <summary>  
    /// Method to check if the input is Int32  
    /// </summary>  
    /// <param name="input">the input</param>  
    /// <returns>true if the input is Int32</returns>  
    public static bool IsInt32(string input)  
    {  
        Int32 value;  
        return Int32.TryParse(input, out value);  
    }  
  

// Codeoptimierung aus

cool wäre das ganze noch als Erweiterungsmethoden - also überall ein this vor das String-Argument.

Oder man macht das ganze generisch und hat nur noch eine Methode.


InputValidator.IsTypeOf<int>("123");

Grüße,

dispose

Gelöschter Account
vor 12 Jahren

Oder man macht das ganze generisch und hat nur noch eine Funktion.

...Methode.

Noch besser:


"123".CanParseTo<int>();

771 Beiträge seit 2009
vor 12 Jahren

Hi zusammen,

leider gibt es für TryParse kein Interface, um das ganze generisch zu machen (außer intern dann per Reflection auf die Methode zuzugreifen).

Gelöschter Account
vor 12 Jahren

Interface wäre cool... aber ist hier ohnehin nicht notwendig.

        public static bool CanParseTo<T>(this string input) where T:struct
        {
            string typeIdentifier = typeof (T).Name;
            switch(typeIdentifier)
            {
                case "Int32":
                    Int32 value;
                    return Int32.TryParse(input, out value);
                    // usw...
                default:
                    throw new NotSupportedException("The Type '" + typeIdentifier + "' is not supported.");
            }
        }
771 Beiträge seit 2009
vor 12 Jahren

Aber irgendwie nicht meine Vorstellung von generisch 🤔
Dann doch lieber per Reflection, so daß man auch für eigene Datentypen einfach nur eine "TryParse"-Methode anbieten müßte.

B
142 Beiträge seit 2007
vor 12 Jahren

Ich habe bei mir noch folgenden Code-Schnippsel entdeckt, welcher hier passen würde:

		public static T ConvertTo<T>(this object value)
		{
			if (value != null)
			{
				Type targetType = typeof(T);				
				TypeConverter converter = TypeDescriptor.GetConverter(value);
				if (converter != null)
				{
					if (converter.CanConvertTo(targetType))
					{
						return (T)converter.ConvertTo(null, CultureInfo.InvariantCulture, value, targetType);
					}
				}
			}
			return null;
		}

Gruß
Björn

Hinweis von Abt vor 12 Jahren

Ich möchte in den Code von Björn nicht eingreifen, aber ein return null ist hier aufgrund von T nicht möglich. Stattdessen müsste default(T) verwendet werden.

P
64 Beiträge seit 2011
vor 12 Jahren

@Björn,

das funktioniert leider nicht so gut, da eine Lexikalische Konvertierung mit Typeconverter nicht geht.

Ich hätte das so:


public static bool isType<T>(string value)
{
            // is everytime a string
            if (typeof(T) == typeof(string)) return true;

            // else try to find a TryParse of the output type            
            MethodInfo x = default(T).GetType().GetMethod("TryParse", new Type[]{typeof(string),typeof(T).MakeByRefType()});
            
            // if a TryParse found, return the result. Othwerwise return false
            if (x != null)
                return (bool)x.Invoke(new object(), new object[] { value, default(T) });
            else return false;            
}

gelöst

Grüße,

PS: Verbesserungen sind gerne gesehen

inflames2k Themenstarter:in
2.298 Beiträge seit 2010
vor 12 Jahren

@panicJonny

Ist zwar schön kurz gehalten. Aber aus meiner Sicht ist Reflection hier ein Fall von mit Kanonen auf Spatzen geschossen.

Bis auf den Try-Catch gefällt mir eigentlich folgende Variante:


/// <summary>
    /// Method to validate an input
    /// </summary>
    public static class InputValidator
    {
        /// <summary>
        /// Method to check if a string can be converted to a given type
        /// </summary>
        /// <typeparam name="T">the type</typeparam>
        /// <param name="input">the input</param>
        /// <returns>true if the string can be converted to the given type</returns>
        public static bool CanConvertTo<T>(this string input)
        {
            Object converted;
            try
            {
                converted = Convert.ChangeType(input, typeof(T));
            }
            catch
            {
                converted = null;
            }
            return converted != null;
        }
    }

Wissen ist nicht alles. Man muss es auch anwenden können.

PS Fritz!Box API - TR-064 Schnittstelle | PS EventLogManager |

P
64 Beiträge seit 2011
vor 12 Jahren

Immerhin hab ich damit viele Spatzen getroffen 😄

Ich geb an der Stelle auch einfach mal zu, dass das oben mein erster echter Versuch in Sachen Reflection war. Hat mir viel Spaß gemacht, das zu basteln und als ich gesehen habe, dass der Beitrag schon älter ist, wollte ich das eigentlich nicht posten.

Aber mal interessant zu sehen, wie du dich von deinem ersten Post weiterentwickelt hast ^^.

Grüße,