Lidarr/Marr.Data/DataHelper.cs

166 lines
5.4 KiB
C#

/* Copyright (C) 2008 - 2011 Jordan Marr
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 3 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library. If not, see <http://www.gnu.org/licenses/>. */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Reflection;
using Marr.Data.Mapping;
using System.Linq.Expressions;
namespace Marr.Data
{
/// <summary>
/// This class contains misc. extension methods that are used throughout the project.
/// </summary>
internal static class DataHelper
{
public static bool HasColumn(this IDataReader dr, string columnName)
{
for (int i=0; i < dr.FieldCount; i++)
{
if (dr.GetName(i).Equals(columnName, StringComparison.InvariantCultureIgnoreCase))
return true;
}
return false;
}
public static string ParameterPrefix(this IDbCommand command)
{
string commandType = command.GetType().Name.ToLower();
return commandType.Contains("oracle") ? ":" : "@";
}
/// <summary>
/// Returns the mapped name, or the member name.
/// </summary>
/// <param name="member"></param>
/// <returns></returns>
public static string GetTableName(this MemberInfo member)
{
string tableName = MapRepository.Instance.GetTableName(member.DeclaringType);
return tableName ?? member.DeclaringType.Name;
}
public static string GetTableName(this Type memberType)
{
return MapRepository.Instance.GetTableName(memberType);
}
public static string GetColumName(this IColumnInfo col, bool useAltName)
{
if (useAltName)
{
return col.TryGetAltName();
}
else
{
return col.Name;
}
}
/// <summary>
/// Returns the mapped column name, or the member name.
/// </summary>
/// <param name="member"></param>
/// <returns></returns>
public static string GetColumnName(Type declaringType, string propertyName, bool useAltName)
{
// Initialize column name as member name
string columnName = propertyName;
var columnMap = MapRepository.Instance.GetColumns(declaringType).GetByFieldName(propertyName);
if (useAltName)
{
columnName = columnMap.ColumnInfo.TryGetAltName();
}
else
{
columnName = columnMap.ColumnInfo.Name;
}
return columnName;
}
/// <summary>
/// Determines a property name from a passed in expression.
/// Ex: p => p.FirstName -> "FirstName
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="member"></param>
/// <returns></returns>
public static string GetMemberName<T>(this Expression<Func<T, object>> member)
{
var memberExpression = (member.Body as MemberExpression);
if (memberExpression == null)
{
memberExpression = (member.Body as UnaryExpression).Operand as MemberExpression;
}
return memberExpression.Member.Name;
}
public static string GetMemberName(this LambdaExpression exp)
{
var memberExpression = (exp.Body as MemberExpression);
if (memberExpression == null)
{
memberExpression = (exp.Body as UnaryExpression).Operand as MemberExpression;
}
return memberExpression.Member.Name;
}
public static bool ContainsMember(this List<MemberInfo> list, MemberInfo member)
{
foreach (var m in list)
{
if (m.EqualsMember(member))
return true;
}
return false;
}
public static bool EqualsMember(this MemberInfo member, MemberInfo otherMember)
{
return member.Name == otherMember.Name && member.DeclaringType == otherMember.DeclaringType;
}
/// <summary>
/// Determines if a type is not a complex object.
/// </summary>
public static bool IsSimpleType(Type type)
{
Type underlyingType = !IsNullableType(type) ? type : type.GetGenericArguments()[0];
return
underlyingType.IsPrimitive ||
underlyingType.Equals(typeof(string)) ||
underlyingType.Equals(typeof(DateTime)) ||
underlyingType.Equals(typeof(decimal)) ||
underlyingType.IsEnum;
}
public static bool IsNullableType(Type theType)
{
return (theType.IsGenericType && theType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)));
}
}
}