una - objetos inmutables c#

¿Cómo verificar todas las propiedades de un objeto, ya sea nulo o vacío?

Question

Tengo un objeto, llamémoslo ObjectA

y ese objeto tiene 10 propiedades y esas son todas las cadenas.

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

¿Hay alguna forma de verificar si todas estas propiedades son nulas o están vacías?

Entonces, ¿cualquier método incorporado que devuelva verdadero o falso?

Si alguno de ellos no es nulo o está vacío, la devolución sería falsa. Si todos ellos están vacíos, debe devolver verdadero.

La idea es que no quiero escribir 10 if declaración para controlar si esas propiedades están vacías o nulas.

Gracias

Answer 1

Aqui tienes

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)));

y aqui esta la clase

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

Answer 2

El siguiente código devuelve si alguna propiedad no es nula.

  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.

Answer 3

No, no creo que haya un método para hacer exactamente eso.

Lo mejor sería escribir un método simple que tome su objeto y devuelva verdadero o falso.

Alternativamente, si las propiedades son todas iguales, y solo desea analizarlas y encontrar un solo valor nulo o vacío, ¿quizás algún tipo de colección de cadenas funcionaría para usted?

Answer 4

Puedes hacerlo utilizando Reflexión.

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 sugirió una alternativa utilizando LINQ:

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

Answer 5

Puedes usar métodos de reflexión y extensión para hacer esto.

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;
    }
}

luego usarlo en cualquier objeto con propiedades de cadena

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

Answer 6

Supongo que quieres asegurarte de que todas las propiedades estén completas.

Probablemente, una mejor opción es colocar esta validación en el constructor de su clase y lanzar excepciones si la validación falla. De esa manera no puedes crear una clase que no es válida; Atrapa las excepciones y manéjalas en consecuencia.

La validación fluida es un marco agradable ( http://fluentvalidation.codeplex.com ) para realizar la validación. Ejemplo:

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;}
}

Uso:

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

PD: usar la reflexión para este tipo de cosas solo hace que tu código sea más difícil de leer. El uso de la validación como se muestra arriba hace que quede claro cuáles son sus reglas; y puedes extenderlos fácilmente con otras reglas.

Answer 7

Tenga en cuenta que si tiene una jerarquía estructural de datos y desea probar todo en esa jerarquía, entonces puede usar un método recursivo. Aquí hay un ejemplo rápido:

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

Answer 8

Una forma ligeramente diferente de expresar linq para ver si todas las propiedades de cadena de un objeto no son nulas y no están vacías:

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));
}