C#: Cómo obtener todas las propiedades de cadena públicas (tanto obtener y establecer) de un tipo

Question

Estoy tratando de hacer un método que vaya a través de una lista de objetos genéricos y reemplazar todas sus propiedades del tipo string que es o vacío con un reemplazo.

¿Cómo es una buena manera de hacer esto?

tengo este tipo de concha ... ... hasta ahora:

public static void ReplaceEmptyStrings<T>(List<T> list, string replacement) 
{ 
    var properties = typeof(T).GetProperties(-- What BindingFlags? --); 

    foreach(var p in properties) 
    { 
     foreach(var item in list) 
     { 
      if(string.IsNullOrEmpty((string) p.GetValue(item, null))) 
       p.SetValue(item, replacement, null); 
     } 
    } 
} 

Así que, ¿cómo puedo encontrar todas las propiedades de un tipo que son:

• De tipo string
• Ha pública get

• Ha pública set

  ?

---

Hice esta clase de prueba:

class TestSubject 
{ 
    public string Public; 
    private string Private; 

    public string PublicPublic { get; set; } 
    public string PublicPrivate { get; private set; } 
    public string PrivatePublic { private get; set; } 
    private string PrivatePrivate { get; set; } 
} 

La siguiente no funciona:

var properties = typeof(TestSubject) 
     .GetProperties(BindingFlags.Instance|BindingFlags.Public) 
     .Where(ø => ø.CanRead && ø.CanWrite) 
     .Where(ø => ø.PropertyType == typeof(string)); 

Si imprimo el nombre de aquellas propiedades que consigo allí, consiga:

PublicPublic público- PrivatePublic

En otras palabras, me sale dos propiedades demasiado.

---

Nota: Esto probablemente se podría hacer de una manera mejor ... usando foreach y reflexión anidada y todos aquí ... pero si tiene alguna grandes ideas alternativas, por favor hágamelo saber porque yo ¡querer aprender!

Answer 1

Su código se reescribió. No usa LINQ ni var.

public static void ReplaceEmptyStrings<T>(List<T> list, string replacement) 
{ 
    PropertyInfo[] properties = typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance); 

    foreach (PropertyInfo p in properties) 
    { 
     // Only work with strings 
     if (p.PropertyType != typeof(string)) { continue; } 

     // If not writable then cannot null it; if not readable then cannot check it's value 
     if (!p.CanWrite || !p.CanRead) { continue; } 

     MethodInfo mget = p.GetGetMethod(false); 
     MethodInfo mset = p.GetSetMethod(false); 

     // Get and set methods have to be public 
     if (mget == null) { continue; } 
     if (mset == null) { continue; } 

     foreach (T item in list) 
     { 
      if (string.IsNullOrEmpty((string)p.GetValue(item, null))) 
      { 
       p.SetValue(item, replacement, null); 
      } 
     } 
    } 
} 

Answer 2

BindingFlags.Public | BindingFlags.Instance debe hacerlo

GetSetMethod()

Answer 3

Encontrará las propiedades tales como la BindingFlags.Public | BindingFlags.Instance. A continuación, deberá examinar cada instancia de PropertyInfo marcando las propiedades CanWrite y CanRead para ver si son legibles o escribibles.

Actualización: código de ejemplo

PropertyInfo[] props = yourClassInstance.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance); 
for (int i = 0; i < props.Length; i++) 
{ 
    if (props[i].PropertyType == typeof(string) && props[i].CanWrite) 
    { 
     // do your update 
    } 
} 

---

Miré en ella con más detalle después de su actualización.Si también examina los objetos MethodInfo devueltos por GetGetMethod y GetSetMethod, llegará al objetivo, creo;

var properties = typeof(TestSubject).GetProperties(BindingFlags.Instance | BindingFlags.Public) 
     .Where(ø => ø.CanRead && ø.CanWrite) 
     .Where(ø => ø.PropertyType == typeof(string)) 
     .Where(ø => ø.GetGetMethod(true).IsPublic) 
     .Where(ø => ø.GetSetMethod(true).IsPublic); 

Por defecto estos dos métodos de vuelta Solamente captadores y definidores públicas (que arriesgan una NullReferenceException en un caso como éste), pero al pasar por encima de true como los hace también vuelven las privadas. Luego puede examinar las propiedades IsPublic (o IsPrivate).

Answer 4

Sugiero un enfoque diferente: AOP.
Puede interceptar el colocador y establecer el valor deseado en uno válido. Con PostSharp es bastante fácil.

Answer 5

Si no especifica ninguna marca de encuadernación, obtendrá las propiedades de instancia públicas, que es lo que desea. Pero luego deberá verificar si PropertyType en el objeto PropertyInfo es de tipo String. A menos que sepa con anticipación, también deberá verificar si la propiedad es legible/escribible como lo indica @Fredrik.

using System.Linq; 

public static void ReplaceEmptyStrings<T>(List<T> list, string replacement) 
{ 
    var properties = typeof(T).GetProperties() 
           .Where(p => p.PropertyType == typeof(string)); 
    foreach(var p in properties) 
    { 
     foreach(var item in list) 
     { 
      if(string.IsNullOrEmpty((string) p.GetValue(item, null))) 
       p.SetValue(item, replacement, null); 
     } 
    } 
} 

Answer 6

Estoy de acuerdo con otras respuestas, pero yo prefiero que refactorizar la búsqueda en sí misma a ser easly consulta con LINQ, por lo que la consulta podría ser el siguiente:

 var asm = Assembly.GetExecutingAssembly(); 
     var properties = (from prop 
           in asm.GetType() 
           .GetProperties(BindingFlags.Public | BindingFlags.Instance) 
          where 
          prop.PropertyType == typeof (string) && 
          prop.CanWrite && 
          prop.CanRead 
          select prop).ToList(); 
     properties.ForEach(p => Debug.WriteLine(p.Name)); 

Tomé de mi ejemplo la Asamblea tipo, que no ha de lectura/escritura propiedades de cadena, pero si la misma búsqueda de código para simplemente leer las propiedades, el resultado será:

• CodeBase
• Esc apedCodeBase
• NombreCompleto
• Ubicación
• ImageRuntimeVersion

¿Cuáles son la cadena de sólo lectura propiedades de tipo de montaje

Answer 7

http://jefferytay.wordpress.com/2010/05/03/simple-and-useful-tostring/

para un método de reemplazo toString que le permite para obtener todas las propiedades de th e class