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