Wie überprüfe ich alle Eigenschaften eines Objekts, ob null oder leer?

Ich habe ein Objekt, nennen wir es ObjectA

und dieses Objekt hat 10 Eigenschaften und das sind alles Zeichenfolgen.

 var myObject = new {Property1="",Property2="",Property3="",Property4="",...}

Gibt es überhaupt eine Möglichkeit zu überprüfen, ob alle diese Eigenschaften null oder leer sind?

Also eine eingebaute Methode, die wahr oder falsch zurückgeben würde?

Wenn einer von ihnen nicht null oder leer ist, wäre die Rückgabe falsch. Wenn alle leer sind, sollte true zurückgegeben werden.

Die Idee ist, dass ich keine 10 if-Anweisung schreiben möchte, um zu steuern, ob diese Eigenschaften leer oder null sind.

Vielen Dank

Sie können dies mit Reflection tun

bool IsAnyNullOrEmpty(object myObject)
{
    foreach(PropertyInfo pi in myObject.GetType().GetProperties())
    {
        if(pi.PropertyType == typeof(string))
        {
            string value = (string)pi.GetValue(myObject);
            if(string.IsNullOrEmpty(value))
            {
                return true;
            }
        }
    }
    return false;
}

Matthew Watson schlug eine Alternative mit LINQ vor:

return myObject.GetType().GetProperties()
    .Where(pi => pi.PropertyType == typeof(string))
    .Select(pi => (string)pi.GetValue(myObject))
    .Any(value => string.IsNullOrEmpty(value));

Ich nehme an, Sie möchten sicherstellen, dass alle Eigenschaften ausgefüllt sind.

Eine bessere Option besteht wahrscheinlich darin, diese Validierung in den Konstruktor Ihrer Klasse einzufügen und Ausnahmen auszulösen, wenn die Validierung fehlschlägt. Auf diese Weise können Sie keine ungültige Klasse erstellen. Ausnahmen abfangen und entsprechend behandeln.

Die fließende Validierung ist ein nützliches Framework ( http://fluentvalidation.codeplex.com ) für die Validierung. Beispiel:

public class CustomerValidator: AbstractValidator<Customer> 
{
    public CustomerValidator()
    {
        RuleFor(customer => customer.Property1).NotNull();
        RuleFor(customer => customer.Property2).NotNull();
        RuleFor(customer => customer.Property3).NotNull();
    }
}

public class Customer
{
    public Customer(string property1, string property2, string property3)
    {
         Property1  = property1;
         Property2  = property2;
         Property3  = property3;
         new CustomerValidator().ValidateAndThrow();
    }

    public string Property1 {get; set;}
    public string Property2 {get; set;}
    public string Property3 {get; set;}
}

Verwendung:

 try
 {
     var customer = new Customer("string1", "string", null);
     // logic here
 } catch (ValidationException ex)
 {
     // A validation error occured
 }

PS: Die Verwendung von Reflektion für solche Dinge macht das Lesen Ihres Codes nur schwieriger. Wenn Sie die oben gezeigte Validierung verwenden, wird deutlich, wie Ihre Regeln lauten. und Sie können sie leicht mit anderen Regeln erweitern.

Bitte schön

var instOfA = new ObjectA();
bool isAnyPropEmpty = instOfA.GetType().GetProperties()
     .Where(p => p.GetValue(instOfA) is string) // selecting only string props
     .Any(p => string.IsNullOrWhiteSpace((p.GetValue(instOfA) as string)));

und hier ist die Klasse

class ObjectA
{
    public string A { get; set; }
    public string B { get; set; }
}

Der folgende Code wird zurückgegeben, wenn eine Eigenschaft nicht null ist.

  return myObject.GetType()
                 .GetProperties() //get all properties on object
                 .Select(pi => pi.GetValue(myObject)) //get value for the propery
                 .Any(value => value != null); // Check if one of the values is not null, if so it returns true.

Eine etwas andere Art, die Linq auszudrücken, um festzustellen, ob alle Zeichenfolgeeigenschaften eines Objekts nicht null und nicht leer sind:

public static bool AllStringPropertyValuesAreNonEmpty(object myObject)
{
    var allStringPropertyValues = 
        from   property in myObject.GetType().GetProperties()
        where  property.PropertyType == typeof(string) && property.CanRead
        select (string) property.GetValue(myObject);

    return allStringPropertyValues.All(value => !string.IsNullOrEmpty(value));
}

Hinweis: Wenn Sie eine Datenstrukturhierarchie haben und alles in dieser Hierarchie testen möchten, können Sie eine rekursive Methode verwenden. Hier ist ein kurzes Beispiel:

static bool AnyNullOrEmpty(object obj) {
  return obj == null
      || obj.ToString() == ""
      || obj.GetType().GetProperties().Any(prop => AnyNullOrEmpty(prop.GetValue(obj)));
}

Sie können dazu Reflektions- und Erweiterungsmethoden verwenden.

using System.Reflection;
public static class ExtensionMethods
{
    public static bool StringPropertiesEmpty(this object value)
    {
        foreach (PropertyInfo objProp in value.GetType().GetProperties())
        {
            if (objProp.CanRead)
            {
                object val = objProp.GetValue(value, null);
                if (val.GetType() == typeof(string))
                {
                    if (val == "" || val == null)
                    {
                        return true;
                    }
                }
            }
        }
        return false;
    }
}

Verwenden Sie es dann für jedes Objekt mit Zeichenfolgeeigenschaften

test obj = new test();
if (obj.StringPropertiesEmpty() == true)
{
    // some of these string properties are empty or null
}

So überprüfen Sie nur, ob alle Eigenschaften null sind:

bool allPropertiesNull = !myObject.GetType().GetProperties().Any(prop => prop == null);

Nein, ich glaube nicht, dass es eine Methode gibt, um genau das zu tun.

Am besten schreiben Sie eine einfache Methode, die Ihr Objekt nimmt und true oder false zurückgibt.

Wenn die Eigenschaften alle gleich sind und Sie sie nur analysieren und eine einzelne Null oder eine leere finden möchten, funktioniert möglicherweise eine Art Sammlung von Zeichenfolgen für Sie?