générique de façon à vérifier la valeur null ou vide pour n'importe quel type int, string, double

Je suis en train de t obtenir ce travail mais de toute façon sa va de ma main... je veux être en mesure de vérifier la valeur null ou vide quel que soit le type je lui ai donné.

EX:

int i =0;
string mystring = "";

var reult  = CheckNullOrEmpty(10) //passing int
var result 1  = CheckNullOrEmpty(mystring) //passing string 

 public bool CheckNullOrEmpty<T>(T value)
 {
    //check for null or empty for strings
    //check for null i.e. 0 for int 

 }

quelqu'un peut m'aider.. je suis en train d'essayer de comprendre comment les génériques des œuvres pour cette méthode simple.

je pense que u besoin de créer de la méthode et l'a nommé tous les CheckNullOrEmpty. chaque méthode vérifie les différents types de données
Je pense que vous ne pouvez pas vérifier génériquement pour une telle chose comme vide, car il n'y a pas de définition générale: Pour un string c'est une chaîne vide, pour une int il peut être 0, mais pour tout type T, il peut être n'importe quoi ou n'existe même pas...
Si vous souhaitez une valeur par défaut de comparaison, comparer default(T). C'est le meilleur que vous pouvez faire ici.
Je ne pense pas que ce serait la bonne façon, comme j'ai vu quelque part sur internet à ce sujet.. je ne peux pas semble trouver cela maintenant, et j'ai donc posé la question...
pourriez-vous me donner un exemple pour utiliser la valeur par défaut(T)..

OriginalL'auteur patel.milanb | 2013-05-15

  1. 25
    public static bool CheckNullOrEmpty<T>(T value)
{
     if (typeof(T) == typeof(string))
        return string.IsNullOrEmpty(value as string);

     return value == null || value.Equals(default(T));
}

    Comment utiliser:

    class Stub { }

bool f1 = CheckNullOrEmpty(""); //true
bool f2 = CheckNullOrEmpty<string>(null); //true
bool f3 = CheckNullOrEmpty(0); //true
bool f4 = CheckNullOrEmpty<Stub>(null);  //true
    Que faire si T est un type de référence <> string de la valeur et de null?
    cela fonctionne parfaitement .....
    Aucune raison de faire if (typeof(T) == typeof(string)) au lieu de if (value est une chaîne) ?
    si value est null, le value is string ne fonctionne pas

    OriginalL'auteur

  2. 2

    Vous pouvez vérifier contre default(T);

     public bool CheckNullOrEmpty<T>(T value)
 {
      return value == default(T);
 }

    Pour plus d'informations: http://msdn.microsoft.com/en-us/library/xwth0h0d.aspx

    ce que je cherchais...
    Malheureusement, cela ne permet pas de couvrir la chaîne.Vide.
    il est dit de l'Opérateur '==' ne peut pas être appliquée à des opérandes de type 'T' et 'T'
    Vous pouvez le vérifier if typeof(T) == typeof(string) et puis testez pour la chaîne.vide.

    OriginalL'auteur

  3. 1

    Vous pouvez utiliser la valeur par défaut() -

    par exemple:

    if(value != default(T))

    à partir de MSDN:

    Donné une variable t de type paramétré T, la déclaration de t = null
    n'est valable que si T est un type de référence et t = 0 ne fonctionne que pour les
    valeur numérique des types, mais pas pour les structures. La solution est d'utiliser la
    mots clés par défaut, qui permet de renvoyer la valeur null pour les types référence et zéro
    pour les types de valeur. Pour les structures, il sera de retour à chaque membre de
    la structure initialisée à zéro ou la valeur null, selon qu'ils sont
    valeur ou des types de référence.

    http://msdn.microsoft.com/en-us/library/xwth0h0d(v=vs. 80).aspx

    Cela ne couvre pas la chaîne.Des valeurs vides

    OriginalL'auteur

  4. 1

    Parce que votre CheckNullOrEmpty mise en œuvre diffère selon le type, vous ne pouvez pas avoir que de vérifier qu'une fonction générique.

    Si vous utilisez Nullable types de valeur cependant, vous pouvez utiliser GetValueOrDefault():

    int? i = 0;

var result = i.GetValueOrDefault(10);

    Alors pour string, juste une méthode d'extension:

    public static string GetValueOrDefault(this string item, string defaultValue = "")
{
    return !string.IsNullOrWhiteSpace(item) ? item : defaultValue;
}

    Alors vous pouvez faire:

    string i = null;
string mystring = "";

var result  = i.GetValueOrDefault(mystring);

    OriginalL'auteur

  5. 0
    J'ai ajouté un couple de re-factorings: 

1. DBNull n'est pas considéré comme isnullorempty ajoutée (value as string) 
2. Le passage d'un datatable ligne[colonne] qui a été créé dynamiquement à l'exécution (comme: row["PropertyName"]) ne sera pas le voir comme une chaîne de caractères avec typeof(T) en raison du fait que le type de la colonne de la base de l'objet. Donc ajouté un supplément de vérifier pour typeof(objet) et si non null test que le ToString() est vide. Je n'ai pas testé ce bien peut ne pas fonctionner pour tous les types de données des colonnes. 

      public static bool CheckNullOrEmpty<T>(T value)
  {
        //note: this does not see DBNull as isnullorempty.  
        if (typeof(T) == typeof(string))
        {
            if (!string.IsNullOrEmpty(value as string))
            {
                return string.IsNullOrEmpty(value.ToString().Trim());
            }
            else
            {
                return true;
            }
        }
        else if (typeof(T) == typeof(object))
        {
            //note: datatable columns are always seen as object at runtime with generic T regardless of how they are dynamically typed?
            if (value != null) {
                return string.IsNullOrEmpty(value.ToString().Trim());
            }
        }


      return value == null || value.Equals(default(T));
  }
    Alors que ce bout de code peut être la solution, y compris une explication aide vraiment à améliorer la qualité de votre post. Rappelez-vous que vous répondez à la question pour les lecteurs dans l'avenir, et ces personnes pourraient ne pas connaître les raisons de votre code suggestion.

    OriginalL'auteur