/// <summary> /// Получить свойство определенного типа /// </summary> /// <param name="obj">объект</param> /// <param name="propertyName">имя свойства определенного типа</param> /// <param name="nestedType">тип определенного типа</param> /// <returns>объект-свойство</returns> public static PropertyInfo GetProperty(this object obj, string propertyName, Type nestedType) { if (obj == null) { ExceptionGenerator.Run <NullReferenceException>("Аргумент \"obj\" равен null"); } if (String.IsNullOrEmpty(propertyName)) { ExceptionGenerator.Run <ArgumentNullException>("Аргумент \"propertyName\" равен null или пустой метода объекта типа {0}", obj.GetType()); } if (nestedType == null) { ExceptionGenerator.Run <ArgumentNullException>("Аргумент \"nestedType\" равен null (имя свойства вложенного типа \"{0}\")", propertyName); } Type type = obj.GetType(); try { PropertyInfo propertyInfo = type.GetProperty(propertyName, nestedType); return(propertyInfo); } catch (Exception ex) { throw ExceptionGenerator.Run(ex, "Ошибка при получении значения свойства \"{0}\" объекта типа \"{1}\"", propertyName, type); } }
/// <summary> /// Выполнить метод methodName у объекта /// </summary> /// <param name="obj">объект</param> /// <param name="methodName">имя метода</param> /// <param name="bindingFlags">условие поиска метода</param> /// <param name="args">аргументы выполняемого метода</param> /// <exception cref="ArgumentNullException"></exception> /// <exception cref="Exception"></exception> /// <returns></returns> public static object GetMethodValue(this object obj, string methodName, BindingFlags bindingFlags, params object[] args) { if (obj == null) { ExceptionGenerator.Run <ArgumentNullException>("Аргумент \"obj\" равен null"); } if (String.IsNullOrEmpty(methodName)) { ExceptionGenerator.Run <ArgumentNullException>("Аргумент \"methodName\" равен null или пустой"); } Type type = obj.GetType(); try { MethodInfo methodInfo = null; methodInfo = type.GetMethod(methodName, bindingFlags); if (methodInfo == null) { ExceptionGenerator.Run <ArgumentNullException>("Метод \"{0}\" в объекте типа \"{1}\" не найдено по условиям поиска \"{2}\"", methodName, type, bindingFlags.ToString()); } return(methodInfo.Invoke(obj, args)); } catch (Exception ex) { throw ExceptionGenerator.Run(ex, "Ошибка при выполнения метода \"{0}\" объекте типа \"{1}\"", methodName, type); } }
/// <summary> /// Преобразовывает числовое значение данного экземпляра в эквивалентное ему строковое представление с заданной точностью с отбрасыванием "пустых" нулей в конце числа /// </summary> /// <param name="value">значение</param> /// <param name="minNumberDecimalDigits">минимальное число цифр после запятой</param> /// <param name="numberDecimalDigits">число цифр после запятой</param> /// <returns></returns> public static string ToStr(this double value, int minNumberDecimalDigits, int numberDecimalDigits) { if (minNumberDecimalDigits < 0 || minNumberDecimalDigits > 99 || numberDecimalDigits < 0 || numberDecimalDigits > 99) { ExceptionGenerator.Run <ArgumentOutOfRangeException>("minNumberDecimalDigits \"{0}\", numberDecimalDigits = \"{1}\"", minNumberDecimalDigits, numberDecimalDigits); } if (minNumberDecimalDigits > numberDecimalDigits) { ExceptionGenerator.Run <ArgumentOutOfRangeException>("minNumberDecimalDigits \"{0}\" должно быть не больше, чем numberDecimalDigits = \"{1}\"", minNumberDecimalDigits, numberDecimalDigits); } if (value.IsEqual(Math.Floor(value))) { return(value.ToString(String.Format("F{0}", minNumberDecimalDigits))); } var temp_value = value; for (int i = minNumberDecimalDigits + 1; i < numberDecimalDigits; ++i) { temp_value = 10.0 * temp_value; if (temp_value.IsEqual(Math.Floor(temp_value))) { return(value.ToString(String.Format("F{0}", i))); } } return(value.ToString(String.Format("F{0}", numberDecimalDigits)));; }
/// <summary> /// Получить вложенный тип /// </summary> /// <param name="obj">объект, у которого получает вложенный тип</param> /// <param name="nestedTypeName">имя вложенного типа</param> /// <param name="bindingFlags">условие поиска вложенного типа</param> /// <returns>тип вложенного объекта</returns> public static Type GetNestedType(this object obj, string nestedTypeName, BindingFlags bindingFlags) { if (obj == null) { ExceptionGenerator.Run <NullReferenceException>("Аргумент \"obj\" равен null"); } if (String.IsNullOrEmpty(nestedTypeName)) { ExceptionGenerator.Run <ArgumentNullException>("Аргумент \"nestedTypeName\" равен null или пустой метода объекта типа {0}", obj.GetType()); } Type type = obj.GetType(); try { Type nestedType = type.GetNestedType(nestedTypeName, bindingFlags); return(nestedType); } catch (Exception ex) { throw ExceptionGenerator.Run(ex, "Ошибка при получении вложенного типа \"{0}\" объекта типа \"{1}\"", nestedTypeName, type); } }
/// <summary> /// проверяет наличия элемента в последовательности, у которого значение свойства /// , имя которого определено вторым аргументом метода /// , равно значение свойства объекта, определяемого первым аргументом /// </summary> /// <typeparam name="TItem">тип элемента</typeparam> /// <param name="originalItems">последовательность элементов</param> /// <param name="item">объект</param> /// <param name="propName">свойство по которому определяется наличие элемента в последовательности</param> /// <returns></returns> public static bool ContainsByFieldName <TItem>(this IEnumerable <TItem> originalItems, TItem item, string fieldName) { if (item == null) { ExceptionGenerator.Run <ArgumentNullException>("Объект не определен"); } if (String.IsNullOrEmpty(fieldName)) { ExceptionGenerator.Run <ArgumentNullException>("Имя поля не определено или пустое"); } var val = item.GetFlattenFieldValue(fieldName); if (val == null) { ExceptionGenerator.Run <NullReferenceException>("Поле \"{0}\" элемента не определено ", fieldName); } return(originalItems.Any(it => { var itVal = it.GetFlattenFieldValue(fieldName); return ObjectExtensions.IsEqual(val, itVal); })); }
/// <summary> /// Возвращает список свойства элементов типа TItemProp /// </summary> /// <typeparam name="FromType">тип элемента в последовательности</typeparam> /// <typeparam name="TItemProp">тип свойства</typeparam> /// <param name="originalItems">последовательность элементов</param> /// <param name="propName">имя свойства</param> /// <returns>список свойства элементов типа TItemField</returns> public static List <TItemProp> ToItemPropList <FromType, TItemProp>(this IEnumerable <FromType> originalItems, string propName) { var items = new List <TItemProp>(); if (!originalItems.Any()) { return(items); } var propValue = originalItems.ElementAt(0).GetFlattenPropertyValue(propName); if (!typeof(TItemProp).IsAssignableFrom(propValue.GetType())) { ExceptionGenerator.Run <InvalidCastException>("Свойство \"{0}\" должно реализовывать интерфейс (класс) \"{1}\"", propName, typeof(TItemProp)); } foreach (FromType item in originalItems) { var propVal = item.GetFlattenPropertyValue(propName); if (!(propVal is TItemProp)) { ExceptionGenerator.Run <InvalidCastException>("Свойство элемента типа \"{0}\" нельзя преобразовать в \"{1}\"", item.GetType(), typeof(TItemProp)); } items.Add((TItemProp)propVal); } return(items); }
/// <summary> /// Получить поле fieldName у объекта /// </summary> /// <param name="obj">объект</param> /// <param name="fieldName">имя поля</param> /// <param name="bindingFlags">условие поиска поля</param> /// <exception cref="ArgumentNullException"></exception> /// <exception cref="TargetException"></exception> /// <exception cref="Exception"></exception> /// <returns>значение поля</returns> public static FieldInfo GetField(this object obj, string fieldName, BindingFlags bindingFlags) { if (obj == null) { ExceptionGenerator.Run <NullReferenceException>("Аргумент \"obj\" равен null"); } if (String.IsNullOrEmpty(fieldName)) { ExceptionGenerator.Run <ArgumentNullException>("Аргумент \"fieldName\" равен null или пустой"); } Type type = obj.GetType(); try { FieldInfo fieldInfo = null; fieldInfo = type.GetField(fieldName, bindingFlags); return(fieldInfo); } catch (Exception ex) { throw ExceptionGenerator.Run(ex, "Ошибка при получении поля \"{0}\" объекта типа \"{1}\"", fieldName, type); } }
/// <summary> /// Получить значение свойства propertyInfo у объекта /// </summary> /// <param name="obj">объект</param> /// <param name="propertyInfo">свойство</param> /// <param name="accessAttr">доступ к селектору свойства</param> /// <exception cref="ArgumentNullException"></exception> /// <exception cref="Exception"></exception> /// <returns>значение свойства</returns> public static object GetPropertyValue(this object obj, PropertyInfo propertyInfo, AccessAttr accessAttr) { Type type = obj.GetType(); if (propertyInfo == null) { ExceptionGenerator.Run <ArgumentNullException>("Ошибка при получении значения свойства: свойство объекта типа \"{0}\" неопределено", type); } try { MethodInfo method = null; if (accessAttr == AccessAttr.All) { method = propertyInfo.GetGetMethod(); if (method == null) { method = propertyInfo.GetGetMethod(true); } return(method.Invoke(obj, null)); } method = propertyInfo.GetGetMethod(accessAttr == AccessAttr.NonPublic); return(method.Invoke(obj, null)); } catch (Exception ex) { throw ExceptionGenerator.Run(ex, "Ошибка при получении значения свойства \"{0}\" объекта типа \"{1}\"", propertyInfo.Name, type); } }
/// <summary> /// Возвращает список свойства элементов типа TItemField /// </summary> /// <typeparam name="FromType">тип элемента в последовательности</typeparam> /// <typeparam name="TItemField">тип свойства</typeparam> /// <param name="originalItems">последовательность элементов</param> /// <param name="propName">имя свойства</param> /// <returns>список свойства элементов типа TItemField</returns> public static List <TItemField> ToItemFieldList <FromType, TItemField>(this IEnumerable <FromType> originalItems, string fieldName) { var items = new List <TItemField>(); if (!originalItems.Any()) { return(items); } var fieldValue = originalItems.ElementAt(0).GetFlattenFieldValue(fieldName); if (!typeof(TItemField).IsAssignableFrom(fieldValue.GetType())) { ExceptionGenerator.Run <InvalidCastException>("Поле \"{0}\" должно реализовывать интерфейс (класс) \"{1}\"", fieldName, typeof(TItemField)); } foreach (FromType item in originalItems) { var fieldVal = item.GetFlattenFieldValue(fieldName); if (!(fieldVal is TItemField)) { ExceptionGenerator.Run <InvalidCastException>("Поле элемента типа \"{0}\" нельзя преобразовать в \"{1}\"", item.GetType(), typeof(TItemField)); } items.Add((TItemField)fieldVal); } return(items); }
/// <summary> /// Преобразовывает числовое значение данного экземпляра в эквивалентное ему строковое представление с заданной точностью с отбрасыванием "пустых" нулей в конце числа /// </summary> /// <param name="value">значение</param> /// <param name="numberDecimalDigits">число цифр после запятой</param> /// <returns></returns> public static string ToStr(this double value, int numberDecimalDigits) { if (numberDecimalDigits < 0 || numberDecimalDigits > 99) { ExceptionGenerator.Run <ArgumentOutOfRangeException>("numberDecimalDigits = \"{1}\"", numberDecimalDigits); } return(value.ToStr(0, numberDecimalDigits)); }
/// <summary> /// Возвращает элемент последовательности по индексу. Если индекс выходит за диапазон последовательности, то выдает исключение /// </summary> /// <typeparam name="TItem">тип элемента</typeparam> /// <param name="originalItems">последовательность</param> /// <param name="index">индекс</param> /// <returns>элемент</returns> public static TItem Get <TItem>(this IEnumerable <TItem> originalItems, int index) { if (index < 0 || index >= originalItems.Count()) { ExceptionGenerator.Run <ArgumentOutOfRangeException>("Индекс \"{0}\" должен быть не меньше \"0\" и меньше \"{1}\"", index, originalItems.Count()); } return(originalItems.ElementAt(index)); }
private static void Check <TIdType>() { Type type = typeof(TIdType); if (type != typeof(string) && (!type.IsPrimitive || !type.IsValueType)) { ExceptionGenerator.Run <InvalidCastException>("Тип идентификатора \"{0}\" должен быть примитивным типом или типом значений или строковым", type); } }
/// <summary> /// Возвращает первый элемент, если элемент в последовательности найден /// </summary> /// <param name="originalItems">последовательность элементов</param> /// <param name="predicate">условие поиска</param> /// <returns>возвращает первый элемент, если элемент в последовательности найден</returns> public static object First(this IEnumerable originalItems, Func <object, bool> predicate) { foreach (var it in originalItems) { if (predicate(it)) { return(it); } } ExceptionGenerator.Run <InvalidOperationException>("Элемент не найден в последовательности"); return(null); }
public static TIdType Get <TIdType>(IBaseIDObject <TIdType> obj) { Check <TIdType>(); Type type = typeof(TIdType); TIdType id = default(TIdType); if (!type.TryConvert <TIdType>(obj.GetHashCode(), ref id)) { ExceptionGenerator.Run <InvalidCastException>("Невозможно преобразовать код хеш-значения в значение тип идентификатора \"{0}\"", type); } return(id); }
/// <summary> /// Удалить единственный экземпляр класса. /// </summary> public static void Delete() { Debug.Assert(_instance != null, "_instance != null", "Ожидается, что _instance будет не null"); if (_instance == null) { ExceptionGenerator.Run <DuplicateNameException>("Ожидается, что _instance типа {0} будет null", typeof(T)); } InternalDelete(); }
/// <summary> /// Получить значение свойства propertyName у объекта /// </summary> /// <param name="obj">объект</param> /// <param name="propertyName">имя свойства</param> /// <param name="bindingFlags">условие поиска свойства</param> /// <exception cref="ArgumentNullException"></exception> /// <exception cref="Exception"></exception> /// <returns>значение свойства</returns> public static object GetPropertyValue(this object obj, string propertyName, BindingFlags bindingFlags) { Type type = obj.GetType(); PropertyInfo propertyInfo = obj.GetProperty(propertyName, bindingFlags); if (propertyInfo == null) { ExceptionGenerator.Run <NullReferenceException>("Ошибка при получении свойства с именем \"{0}\" объекта типа \"{1}\"", propertyName, type); } return(obj.GetPropertyValue(propertyInfo, AccessAttr.Public)); }
/// <summary> /// Установить значение поля fieldName у объекта /// </summary> /// <param name="obj">объект</param> /// <param name="fieldName">имя поля</param> /// <param name="bindingFlags">условие поиска поля</param> /// <exception cref="Exception"></exception> public static void SetFieldValue(this object obj, string fieldName, object value, BindingFlags bindingFlags) { Type type = obj.GetType(); try { FieldInfo fieldInfo = obj.GetField(fieldName, bindingFlags); fieldInfo.SetValue(obj, value); } catch (Exception ex) { throw ExceptionGenerator.Run(ex, "Ошибка при установке значения поля \"{0}\" объекта типа \"{1}\"", fieldName, type); } }
public static string ToStrOrDefault(this DateTime dateTime, string split, string dateSplit, string timeSplit) { try { return(dateTime.ToStr(split, dateSplit, timeSplit)); } catch (Exception ex) { if (ex is ArgumentException || ex is ArgumentNullException || ex is InvalidOperationException || ex is FormatException || ex is NotSupportedException) { return(String.Format("{0}{1}{2}", dateTime.ToShortDateString(), split, dateTime.ToLongTimeString())); } throw ExceptionGenerator.Run(ex); } }
/// <summary> /// проверяет наличия элемента в группе, у которого значение свойства /// , имя которого определено вторым аргументом метода /// , равно значению, определяемого третьим аргументом /// </summary> /// <param name="group">группа элементов</param> /// <param name="propName">имя свойства</param> /// <param name="value">значение</param> /// <param name="recursive"><c>true</c>, ресурсивный обход элементов, если элемент является также группой</param> /// <param name="comparer">функция сравнения значений</param> /// <param name="contains">дополнительная функция обхода элементов у негруппового объекта</param> /// <returns></returns> public static bool ContainsByPropName(IBaseGroup group, string propName, object value, bool recursive = false, ReturnAction <object, object, bool> comparer = null, ReturnAction <object, object, bool> contains = null) { if (group == null) { ExceptionGenerator.Run <NullReferenceException>("Группа не определена"); } if (group is IGroupObject) { var groupObject = group as IGroupObject; if (groupObject.Group != null) { foreach (var obj in groupObject.Group) { if (IsObjectHavingValue(obj, propName, value, recursive, comparer, contains)) { return(true); } } } } else if (group is IGroupOfOne) { var groupOfOne = group as IGroupOfOne; if (groupOfOne.Element != null) { if (IsObjectHavingValue(groupOfOne.Element, propName, value, recursive, comparer, contains)) { return(true); } } } else if (group is IGroup) { var group__ = group as IGroup; foreach (var obj in group__) { if (IsObjectHavingValue(obj, propName, value, recursive, comparer, contains)) { return(true); } } } return(false); }
/// <summary> /// Возвращает последний элемент, если элемент в последовательности найден /// </summary> /// <param name="originalItems">последовательность элементов</param> /// <param name="predicate">условие поиска</param> /// <returns>возвращает последний элемент, если элемент в последовательности найден</returns> public static object Last(this IEnumerable originalItems, Func <object, bool> predicate) { var items = new List <object>(); foreach (var it in originalItems) { if (predicate(it)) { items.Add(it); } } if (items.Count == 0) { ExceptionGenerator.Run <InvalidOperationException>("Элемент не найден в последовательности"); } return(items.Last()); }
/// <summary> /// Возвращает новый список элементов типа TItemType. Метод аналогичен методу Cast() /// </summary> /// <typeparam name="FromType">тип элемента в последовательности</typeparam> /// <typeparam name="TItemType">тип элемента</typeparam> /// <param name="originalItems">последовательность</param> /// <returns>список элементов типа TItemType</returns> public static List <TItemType> ToList <FromType, TItemType>(this IEnumerable <FromType> originalItems) { var items = new List <TItemType>(); foreach (FromType item in originalItems) { if (!(item is TItemType)) { ExceptionGenerator.Run <InvalidCastException>("Элемент типа \"{0}\" нельзя преобразовать в \"{1}\"", item.GetType(), typeof(TItemType));; } items.Add((TItemType)(object)item); } return(items); }
private static TIdType GetHashAlgorithm <TIdType>(byte[] hashValue) { Type type = typeof(TIdType); double value = 0; for (int i = 0; i < hashValue.Length; ++i) { value += hashValue[i] * Math.Pow(256, hashValue.Length - 1 - i); } TIdType id = default(TIdType); if (!type.TryConvert <TIdType>(value, ref id)) { ExceptionGenerator.Run <InvalidCastException>("Невозможно преобразовать крипт-значение в значение тип идентификатора \"{0}\"", type); } return(id); }
/// <summary> /// проверяет наличия элемента в группе, у которого значение свойства /// , имя которого определено вторым аргументом метода /// , равно значению, определяемого третьим аргументом /// </summary> /// <param name="group">группа элементов</param> /// <param name="propName">имя свойства</param> /// <param name="value">значение</param> /// <param name="recursive"><c>true</c>, ресурсивный обход элементов, если элемент является также группой</param> /// <param name="comparer">функция сравнения значений</param> /// <param name="contains">дополнительная функция обхода элементов у негруппового объекта</param> /// <returns></returns> public static bool ContainsByPropName(IEnumerable group, string propName, object value, bool recursive = false, ReturnAction <object, object, bool> comparer = null, ReturnAction <object, object, bool> contains = null) { if (group == null) { ExceptionGenerator.Run <NullReferenceException>("Последовательность не определена"); } foreach (var obj in group) { if (IsObjectHavingValue(obj, propName, value, recursive, comparer, contains)) { return(true); } } return(false); }
/// <summary> /// Изменяет значение свойства у элемента /// </summary> /// <typeparam name="TItem">тип элемента</typeparam> /// <param name="originalItems">последовательность элементов</param> /// <param name="index">индекс элемента</param> /// <param name="propertyName">имя свойства</param> /// <param name="propertyValue">новое значение свойства</param> /// <returns>возвращает true, если значение изменено</returns> public static bool ChangeItemPropValue <TItem>(this IEnumerable <TItem> originalItems, int index, string propertyName, object propertyValue) { if (String.IsNullOrEmpty(propertyName)) { ExceptionGenerator.Run <ArgumentNullException>("Имя свойства не определено или пустое"); } if (index < 0 || index >= originalItems.Count()) { ExceptionGenerator.Run <ArgumentOutOfRangeException>("Индекс должен быть не меньше 0 и не больше {0}", originalItems.Count()); } TItem item = originalItems.ElementAt(index); PropertyInfo propInfo = item.GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy); if (propInfo == null) { ExceptionGenerator.Run <MemberNotFoundException>("Свойство \"{0}\" не найдено", propertyName); } var propValue = item.GetPropertyValue(propInfo); object convertedValue = null; if (!propInfo.PropertyType.TryConvert(propertyValue, ref convertedValue)) { ExceptionGenerator.Run <InvalidCastException>( "Невозможно преобразовать из типа \"{0}\" в тип \"{1}\"", propValue.GetType(), propInfo.PropertyType); return(false); } if (ObjectExtensions.IsEqual(propValue, convertedValue)) { return(false); } item.SetPropertyValue(propInfo, convertedValue); return(true); }
/// <summary> /// Установить значение поля fieldInfo у объекта /// </summary> /// <param name="obj">объект</param> /// <param name="fieldName">поле</param> /// <exception cref="ArgumentNullException"></exception> /// <exception cref="Exception"></exception> public static void SetFieldValue(this object obj, FieldInfo fieldInfo, object value) { Type type = obj.GetType(); if (fieldInfo == null) { ExceptionGenerator.Run <ArgumentNullException>("Ошибка при установке значения поля: поле объекта типа \"{0}\" неопределено", type); } try { fieldInfo.SetValue(obj, value); } catch (Exception ex) { throw ExceptionGenerator.Run(ex, "Ошибка при установке значения поля \"{0}\" объекта типа \"{1}\"", fieldInfo.Name, type); } }
/// <summary> /// Получить поле у объекта по типу поля fieldType /// </summary> /// <param name="obj"></param> /// <param name="fieldType">тип поля</param> /// <param name="bindingFlags">условие поиска поля</param> /// <exception cref="NullReferenceException"></exception> /// <exception cref="System.Data.NoNullAllowedException"></exception> /// <returns>объект-свойство</returns> public static FieldInfo GetField(this object obj, Type fieldType, BindingFlags bindingFlags) { if (obj == null) { ExceptionGenerator.Run <NullReferenceException>("Аргумент \"obj\" равен null"); } Type type = obj.GetType(); FieldInfo[] fields = type.GetFields(bindingFlags); foreach (var fieldInfo in fields) { if (fieldInfo.FieldType == fieldType) { return(fieldInfo); } } ExceptionGenerator.Run <ApplicationException>("Ошибка при получении поля типа \"{0}\" объекта типа \"{1}\"", fieldType, type); return(null); }
/// <summary> /// Получить значение поля fieldName у объекта /// </summary> /// <param name="obj">объект</param> /// <param name="fieldName">имя поля</param> /// <param name="bindingFlags">условие поиска поля</param> /// <exception cref="ArgumentNullException"></exception> /// <exception cref="Exception"></exception> /// <returns>значение поля</returns> public static object GetFieldValue(this object obj, string fieldName, BindingFlags bindingFlags) { Type type = obj.GetType(); try { FieldInfo fieldInfo = obj.GetField(fieldName, bindingFlags); if (fieldInfo == null) { ExceptionGenerator.Run <NullReferenceException>("Ошибка при получении поля с именем \"{0}\" объекта типа \"{1}\"", fieldName, type); } return(fieldInfo.GetValue(obj)); } catch (Exception ex) { throw ExceptionGenerator.Run(ex, "Ошибка при получении значения поля \"{0}\" объекта типа \"{1}\"", fieldName, type); } }
/// <summary> /// Установить значение свойства propertyName у объекта /// </summary> /// <param name="obj">объект</param> /// <param name="propertyInfo">свойство</param> /// <param name="accessAttr">доступ к селектору свойства</param> /// <exception cref="ArgumentNullException"></exception> /// <exception cref="Exception"></exception> /// <returns></returns> public static void SetPropertyValue(this object obj, PropertyInfo propertyInfo, object value, AccessAttr accessAttr) { Type type = obj.GetType(); if (propertyInfo == null) { ExceptionGenerator.Run <ArgumentNullException>("Ошибка при установке значения свойства: свойство объекта типа \"{0}\" неопределено", type); } try { if (accessAttr == AccessAttr.All) { MethodInfo method = propertyInfo.GetSetMethod(); if (method == null) { method = propertyInfo.GetSetMethod(true); } object[] args = new object[1] { value }; method.Invoke(obj, args); } else { MethodInfo method = propertyInfo.GetSetMethod(accessAttr == AccessAttr.NonPublic); object[] args = new object[1] { value }; method.Invoke(obj, args); } } catch (Exception ex) { throw ExceptionGenerator.Run(ex, "Ошибка при установке значения свойства \"{0}\" объекта типа \"{1}\"", propertyInfo.Name, type); } }
/// <summary> /// Получить свойство у объекта по типу свойству propertyType /// </summary> /// <param name="obj"></param> /// <param name="propertyType">тип свойства</param> /// <param name="bindingFlags">условие поиска свойства</param> /// <exception cref="NullReferenceException"></exception> /// <exception cref="System.Data.NoNullAllowedException"></exception> /// <returns>объект-свойство</returns> public static PropertyInfo GetProperty(this object obj, Type propertyType, BindingFlags bindingFlags) { if (obj == null) { ExceptionGenerator.Run <NullReferenceException>("Аргумент \"obj\" равен null"); } Type type = obj.GetType(); PropertyInfo[] props = type.GetProperties(bindingFlags); foreach (var propInfo in props) { if (propInfo.PropertyType == propertyType) { return(propInfo); } } ExceptionGenerator.Run <ApplicationException>("Ошибка при получении свойства типа \"{0}\" объекта типа \"{1}\"", propertyType, type); return(null); }
/// <summary> /// Изменяет значение свойства у элементов перечисления /// </summary> /// <typeparam name="TItem">тип элемента</typeparam> /// <param name="originalItems">последовательность элементов</param> /// <param name="propertyName">имя свойства</param> /// <param name="propertyValue">новое значение свойства</param> /// <returns>возвращает true, если значения свойства всех элементов изменены</returns> public static bool ChangeItemsPropValue <TItem>(this IEnumerable <TItem> originalItems, string propertyName, object propertyValue) { if (String.IsNullOrEmpty(propertyName)) { ExceptionGenerator.Run <ArgumentNullException>("Имя свойства не определено или пустое"); } var bAllChanged = true; foreach (TItem item in originalItems) { PropertyInfo propInfo = item.GetFlattenProperty(propertyName); if (propInfo == null) { bAllChanged = false; continue; } var propValue = item.GetPropertyValue(propInfo); object convertedValue = null; if (!propInfo.PropertyType.TryConvert(propertyValue, ref convertedValue)) { bAllChanged = false; continue; } if (ObjectExtensions.IsEqual(propValue, convertedValue)) { continue; } item.SetPropertyValue(propInfo, convertedValue); } return(bAllChanged); }