/// <summary>
/// <see cref="ConvertAll{TEntity}(IDataReader,INameMap)"/>와는 반대로,
/// Persistent Object의 속성정보를 DbCommand Parameter Value로 설정한다.
/// </summary>
/// <param name="db">instance of <see cref="Database"/> defined in DAAB</param>
/// <param name="cmd">instance of DbCommand</param>
/// <param name="entity">Command로 실행할 Persistent object</param>
/// <param name="nameMaps">DbCommand 인자명 : Persistent Object 속성명의 매핑 정보</param>
/// <param name="ignoreCase">컬럼명과 속성명의 대소문자 구분없이 매칭합니다.</param>
public static void SetParameterValues <T>(this Database db, DbCommand cmd, T entity, INameMap nameMaps, bool ignoreCase = true)
{
cmd.ShouldNotBeNull("cmd");
entity.ShouldNotBeNull("entity");
nameMaps.ShouldNotBeNull("nameMaps");
var accessor = DynamicAccessorFactory.CreateDynamicAccessor <T>(true);
var propertyNames = accessor.GetPropertyNames();
if (IsDebugEnabled)
{
log.Debug("대상 Entity의 속성명 정보=[{0}]", propertyNames.CollectionToString());
}
var parameters = new List <IAdoParameter>();
foreach (string paramName in nameMaps.Keys)
{
// remove parameter prefix
var pName = paramName.RemoveParameterPrefix();
var propertyName = propertyNames.FirstOrDefault(pn => pn.EqualTo(nameMaps[pName], ignoreCase));
if (propertyName.IsNotWhiteSpace())
{
parameters.Add(new AdoParameter(pName, accessor.GetPropertyValue(entity, propertyName)));
}
}
SetParameterValues(db, cmd, parameters.ToArray());
}
/// <summary>
/// Castle.Windsor 환경설정 정보에 있는 속성정보를 Instance의 속성 값으로 매핑한다.
/// </summary>
/// <param name="configuration">Castle configuration object</param>
/// <param name="targetType">target type</param>
/// <returns></returns>
public override object PerformConversion(IConfiguration configuration, Type targetType)
{
configuration.ShouldNotBeNull("configuration");
targetType.ShouldNotBeNull("targetType");
if (IsDebugEnabled)
{
log.Debug("Perform conversion configuration value to property. configuration={0}, targetType={1}",
configuration, targetType);
}
var instance = ActivatorTool.CreateInstance(targetType);
var accessor = DynamicAccessorFactory.CreateDynamicAccessor(targetType, false);
const BindingFlags flags = BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
foreach (var itemConfig in configuration.Children)
{
var propInfo = targetType.GetProperty(itemConfig.Name, flags);
// convert from string to object
var value = Context.Composition.PerformConversion(itemConfig.Value, propInfo.PropertyType);
accessor.SetPropertyValue(instance, itemConfig.Name, value);
}
return(instance);
}
/// <summary>
/// 지정된 엔티티와 속성들을 <see cref="NHibernateUtil.Initialize"/>를 이용하여 초기화 합니다. ( proxy 값을 실제 값으로 대체한다는 소리!!!)
/// </summary>
/// <typeparam name="T">초기화할 엔티티의 수형</typeparam>
/// <param name="entity">초기화할 엔티티</param>
/// <param name="forceInitialize">강제 초기화</param>
/// <returns>초기화된 엔티티</returns>
public static T InitializeEntity <T>(this T entity, bool forceInitialize) where T : IDataObject
{
// NOTE : IsInitialized, IsPropertyInitialized 가 제대로 수행되지 않는다. 그래서 무조건 항상 Initialize를 수행하도록 했다.
if (forceInitialize == false && NHibernateUtil.IsInitialized(entity))
{
return(entity);
}
if (IsDebugEnabled)
{
log.Debug("NHibernate 엔티티를 Initialize하여 Proxy에서 실제 Data를 로딩하도록 합니다... entity=[{0}]", entity);
}
var dynamicAccessor = DynamicAccessorFactory.CreateDynamicAccessor <T>(true);
var propertyNames = dynamicAccessor.GetPropertyNames();
NHibernateUtil.Initialize(entity);
foreach (var propertyName in propertyNames)
{
if (forceInitialize || NHibernateUtil.IsPropertyInitialized(entity, propertyName) == false)
{
NHibernateUtil.Initialize(dynamicAccessor.GetPropertyValue(entity, propertyName));
}
}
return(entity);
}
public void GetAllFields_By_Generic()
{
var widget = new Widget(1, "Widget No1");
var accessor = DynamicAccessorFactory.CreateDynamicAccessor <Widget>();
var fields = accessor.GetFieldNameValueCollection(widget).ToDictionary(pair => pair.Key, pair => pair.Value);
VerifyFieldCollection(fields);
}
public void GetAllProperties_By_Generic()
{
var widget = new Widget(1, "Widget No1");
var accessor = DynamicAccessorFactory.CreateDynamicAccessor <Widget>();
var properties = accessor.GetPropertyNameValueCollection(widget).ToDictionary(pair => pair.Key, pair => pair.Value);
VerifyPropertyCollection(properties);
}
protected virtual void DoSetupCommand(DbCommand cmd)
{
// NOTE: Oracle 인 경우 다음과 같은 코드가 추가되어야 한다.
var accessor = DynamicAccessorFactory.CreateDynamicAccessor <DbCommand>(MapPropertyOptions.Safety);
accessor.SetPropertyValue(cmd, "BindByName", true);
}
public void SetFieldByDynamicMethodWithIgnoreCase()
{
using (new OperationTimer("Set Field value by dynamic method with IgnoreCase")) {
var accessor = DynamicAccessorFactory.CreateDynamicAccessor <Widget>(false, true);
foreach (var widget in _widgets)
{
accessor.SetFieldValue(widget, "_ID", widget.Id);
accessor.SetFieldValue(widget, "_NAME", widget.Name);
accessor.SetFieldValue(widget, "_GUID", widget.Guid);
}
}
}
public void SetFieldByDynamicMethod()
{
using (new OperationTimer("Set Field value by dynamic method")) {
var accessor = DynamicAccessorFactory.CreateDynamicAccessor <Widget>();
foreach (var widget in _widgets)
{
accessor.SetFieldValue(widget, "_id", widget.Id);
accessor.SetFieldValue(widget, "_name", widget.Name);
accessor.SetFieldValue(widget, "_guid", widget.Guid);
}
}
}
public void GetFieldNames()
{
var accessor = DynamicAccessorFactory.CreateDynamicAccessor <Widget>();
var fieldNames = accessor.GetFieldNames();
Assert.IsTrue(fieldNames.Count > 0);
Assert.IsTrue(fieldNames.Contains("_id"));
Assert.IsTrue(fieldNames.Contains("_name"));
var customFieldNames = accessor.GetFieldNames(BindingFlags.Public | BindingFlags.Instance);
Assert.AreEqual(0, customFieldNames.Count);
}
/// <summary>
/// 지정된 컬렉션의 엔티티와 속성들을 <see cref="NHibernateUtil.Initialize"/>를 이용하여 초기화 합니다. ( proxy 값을 실제 값으로 대체한다는 소리!!!)
/// </summary>
/// <typeparam name="T">엔티티 수형</typeparam>
/// <param name="entities">엔티티 시퀀스</param>
/// <param name="forceInitialize">Initialize가 되었던 안되었던 강제로 초기화를 합니다.</param>
/// <returns>초기화된 엔티티 컬렉션</returns>
public static IList <T> InitializeEntities <T>(this IList <T> entities, bool forceInitialize)
{
if (NHibernateUtil.IsInitialized(entities) && forceInitialize == false)
{
return(entities);
}
if (IsDebugEnabled)
{
log.Debug("NHibernate 엔티티 컬렉션을 Initialize하여 Proxy에서 실제 Data를 로딩하도록 합니다... forceInitialized=[{0}]", forceInitialize);
}
var dynamicAccessor = DynamicAccessorFactory.CreateDynamicAccessor <T>(true);
var propertyNames = dynamicAccessor.GetPropertyNames();
NHibernateUtil.Initialize(entities);
var ignorePropertyNames = new List <string>();
foreach (T item in entities)
{
if (forceInitialize || NHibernateUtil.IsInitialized(item) == false)
{
NHibernateUtil.Initialize(item);
foreach (var propertyName in propertyNames)
{
if (ignorePropertyNames.Contains(propertyName))
{
continue;
}
var propertyType = dynamicAccessor.PropertyMap[propertyName].PropertyType;
if (propertyType.IsSimpleType())
{
ignorePropertyNames.Add(propertyName);
continue;
}
if (forceInitialize || NHibernateUtil.IsPropertyInitialized(item, propertyName) == false)
{
NHibernateUtil.Initialize(dynamicAccessor.GetPropertyValue(item, propertyName));
}
}
}
}
return(entities);
}
private static void GenerateXmlAttributes <T>(XmlWriter writer, IDynamicAccessor accessor, T instance) where T : IChartObject
{
foreach (var propertyName in accessor.GetPropertyNames())
{
var propertyValue = accessor.GetPropertyValue(instance, propertyName);
if (propertyValue != null)
{
Type propertyType = accessor.GetPropertyType(propertyName);
if (propertyType.IsSimpleType() || propertyType.IsValueType)
{
if (IsDebugEnabled)
{
log.Debug("Property name={0}, type={1}, value={2}", propertyName, propertyType, propertyValue);
}
// NOTE : Color인 경우는 HexString으로, Enum 값은 HashCode 값으로...
if (propertyType == typeof(Color?))
{
var color = (Color?)propertyValue;
writer.WriteAttributeString(propertyName, color.Value.ToHexString());
}
else if (propertyType.IsEnum)
{
writer.WriteAttributeString(propertyName, propertyValue.GetHashCode().ToString());
}
else
{
writer.WriteAttributeString(propertyName, propertyValue.ToString());
}
}
else if (propertyType.IsSameOrSubclassOf(typeof(ChartAttributeBase)))
{
var accessor2 = DynamicAccessorFactory.CreateDynamicAccessor(propertyType, false);
GenerateXmlAttributes(writer, accessor2, propertyValue as ChartAttributeBase);
}
else if (TypeTool.IsSameOrSubclassOrImplementedOf(propertyType, typeof(IEnumerable)))
{
// Nothing to do.
}
else
{
throw new NotSupportedException(string.Format("지원하지 않는 속성입니다. property name={0}, type={1}", propertyName,
propertyType.FullName));
}
}
}
}
public void GetPropertyByDynamicMethodWithIgnoreCase()
{
using (new OperationTimer("Get Property by Dynamic Method with IgnoreCase")) {
var accessor = DynamicAccessorFactory.CreateDynamicAccessor <Widget>(false, true);
foreach (var widget in _widgets)
{
var id = (int)accessor.GetPropertyValue(widget, "ID");
var name = (string)accessor.GetPropertyValue(widget, "NAME");
var guid = (Guid)accessor.GetPropertyValue(widget, "GUID");
Assert.AreEqual(widget.Id, id);
Assert.AreEqual(widget.Name, name);
Assert.AreEqual(widget.Guid, guid);
}
}
}
public void GetPropertyByDynamicMethodAndParallel()
{
using (new OperationTimer("Get Property by Dynamic Method and Parallel Programming")) {
var accessor = DynamicAccessorFactory.CreateDynamicAccessor <Widget>();
foreach (var widget in _widgets.AsParallel())
{
var id = (int)accessor.GetPropertyValue(widget, "Id");
var name = (string)accessor.GetPropertyValue(widget, "Name");
var guid = (Guid)accessor.GetPropertyValue(widget, "Guid");
Assert.AreEqual(widget.Id, id);
Assert.AreEqual(widget.Name, name);
Assert.AreEqual(widget.Guid, guid);
}
}
}
public void GetPropertyNames()
{
var accessor = DynamicAccessorFactory.CreateDynamicAccessor <Widget>();
var propertyNames = accessor.GetPropertyNames();
Assert.IsTrue(propertyNames.Count > 0);
Assert.IsTrue(propertyNames.Contains("Id"));
Assert.IsTrue(propertyNames.Contains("Name"));
var customPropertyNames =
accessor.GetPropertyNames(BindingFlags.Public | BindingFlags.Instance | BindingFlags.GetProperty);
Assert.IsTrue(customPropertyNames.Count > 0);
Assert.IsTrue(propertyNames.Contains("Id"));
Assert.IsTrue(propertyNames.Contains("Name"));
}
/// <summary>
/// 제공하는 PerformanceCounter를 등록합니다.
/// </summary>
/// <param name="provider">PerformanceCounter 제공자</param>
private static void RegistPerformanceCounter(IPerformanceCounterProvider provider)
{
provider.ShouldNotBeNull("provider");
if (IsDebugEnabled)
{
log.Debug("해당 Provider의 PerformanceCounter 들을 생성합니다... CategoryName=[{0}]", provider.CategoryName);
}
var accessor = DynamicAccessorFactory.CreateDynamicAccessor(provider.GetType(), true);
foreach (var propName in accessor.GetPropertyNames())
{
if (accessor.GetPropertyType(propName) == typeof(PerformanceCounter))
{
provider.PerformanceCounters.Add((PerformanceCounter)accessor.GetPropertyValue(provider, propName));
}
}
}
public void GetFieldByDynamicMethodWithIgnoreCase()
{
int id;
string name;
Guid guid;
using (new OperationTimer("Get Field by Dynamic Method with IgnoreCase")) {
var accessor = DynamicAccessorFactory.CreateDynamicAccessor <Widget>(false, true);
foreach (var widget in _widgets)
{
id = (int)accessor.GetFieldValue(widget, "_ID");
name = (string)accessor.GetFieldValue(widget, "_NAME");
guid = (Guid)accessor.GetFieldValue(widget, "_GUID");
Assert.AreEqual(id, widget.Id);
Assert.AreEqual(name, widget.Name);
Assert.AreEqual(guid, widget.Guid);
}
}
}
public void GetFieldByDynamicMethod()
{
int id;
string name;
Guid guid;
using (new OperationTimer("Get Field by Dynamic Method")) {
var accessor = DynamicAccessorFactory.CreateDynamicAccessor <Widget>();
foreach (var widget in _widgets)
{
id = (int)accessor.GetFieldValue(widget, "_id");
name = (string)accessor.GetFieldValue(widget, "_name");
guid = (Guid)accessor.GetFieldValue(widget, "_guid");
Assert.AreEqual(id, widget.Id);
Assert.AreEqual(name, widget.Name);
Assert.AreEqual(guid, widget.Guid);
}
}
}
/// <summary>
/// 인스턴스의 특정 속성들로부터 HashCode를 생성합니다.
/// </summary>
/// <typeparam name="T">대상 객체의 수형</typeparam>
/// <param name="target">해시코드를 얻고자하는 대상 객체</param>
/// <param name="propertyExprs">해시코드 조합용 속성들</param>
/// <returns></returns>
public static int CalcHash <T>(this T target, params Expression <Func <T, object> >[] propertyExprs)
{
if (Equals(target, default(T)))
{
return(0);
}
#if !SILVERLIGHT
if (propertyExprs == null || propertyExprs.Length == 0)
{
return(target.GetHashCode());
}
var propertyNames = propertyExprs.Select(expr => expr.Body.FindMemberName()).ToArray();
var accessor = DynamicAccessorFactory.CreateDynamicAccessor <T>(MapPropertyOptions.Safety);
return(Compute(propertyNames.Select(name => accessor.GetPropertyValue(target, name)).ToArray()));
#else
return(target.GetHashCode());
#endif
}
public void SetPropertyByDynamicMethodAndParellel()
{
using (new OperationTimer("Set Property value by Dynamic method and Parallel")) {
var accessor = DynamicAccessorFactory.CreateDynamicAccessor <Widget>();
_widgets
.AsParallel()
.RunEach(widget => {
var id = widget.Id;
var name = widget.Name + " by SetPropertyValue";
var guid = Guid.NewGuid();
accessor.SetPropertyValue(widget, "Id", id);
accessor.SetPropertyValue(widget, "Name", name);
accessor.SetPropertyValue(widget, "Guid", guid);
Assert.AreEqual(id, widget.Id);
Assert.AreEqual(name, widget.Name);
Assert.AreEqual(guid, widget.Guid);
});
}
}
public void TryGetFieldByDynamicMethod()
{
object id, name, guid;
using (new OperationTimer("TryGetFieldValue by Dynamic Method")) {
var accessor = DynamicAccessorFactory.CreateDynamicAccessor <Widget>(true, true);
foreach (var widget in _widgets)
{
Assert.IsTrue(accessor.TryGetFieldValue(widget, "_id", out id));
Assert.IsTrue(accessor.TryGetFieldValue(widget, "_name", out name));
Assert.IsTrue(accessor.TryGetFieldValue(widget, "_guid", out guid));
object notExists;
Assert.IsFalse(accessor.TryGetFieldValue(widget, "_notExistField", out notExists));
Assert.AreEqual(id, widget.Id);
Assert.AreEqual(name, widget.Name);
Assert.AreEqual(guid, widget.Guid);
}
}
}
public void SetPropertyByDynamicMethodWithIgnoreCase()
{
using (new OperationTimer("Set Property value by Dynamic method with IgnoreCase")) {
var accessor = DynamicAccessorFactory.CreateDynamicAccessor <Widget>(() => new DynamicAccessor <Widget>(false, true));
foreach (var widget in _widgets)
{
var id = widget.Id;
var name = widget.Name + " by SetPropertyValue";
var guid = Guid.NewGuid();
accessor.SetPropertyValue(widget, "ID", id);
accessor.SetPropertyValue(widget, "NAME", name);
accessor.SetPropertyValue(widget, "GUID", guid);
Assert.AreEqual(id, widget.Id);
Assert.AreEqual(name, widget.Name);
Assert.AreEqual(guid, widget.Guid);
}
}
using (new OperationTimer("Set Property value by Dynamic method with IgnoreCare")) {
var accessor = DynamicAccessorFactory.CreateDynamicAccessor <Widget>(false, true);
foreach (var widget in _widgets)
{
var id = widget.Id;
var name = widget.Name + " by SetPropertyValue";
var guid = Guid.NewGuid();
accessor.SetPropertyValue(widget, "ID", id);
accessor.SetPropertyValue(widget, "NAME", name);
accessor.SetPropertyValue(widget, "GUID", guid);
Assert.AreEqual(id, widget.Id);
Assert.AreEqual(name, widget.Name);
Assert.AreEqual(guid, widget.Guid);
}
}
}
public void GenerateXmlByDynamicAccessor()
{
var accessor2 = DynamicAccessorFactory.CreateDynamicAccessor(typeof(CosmeticAttribute), false);
var cosmetic = new CosmeticAttribute
{
BgSWF = "~/FusionCharts/BgChart.swf"
};
var sb = new StringBuilder();
using (var writer = new XmlTextWriter(new StringWriter(sb))) {
writer.WriteStartDocument(true);
writer.WriteStartElement("chart");
GenerateXmlAttributes(writer, accessor2, cosmetic);
writer.WriteEndElement();
writer.WriteEndDocument();
}
Console.WriteLine(sb.ToString());
}
public static ResultRow ToResultRow(ResultEntity resultEntity)
{
var accessor = DynamicAccessorFactory.CreateDynamicAccessor <ResultEntity>();
return(new ResultRow(accessor.GetPropertyNameValueCollection(resultEntity).ToDictionary(p => p.Key, p => p.Value)));
}
/// <summary>
/// 지정된 수형의 속성, 필드를 동적으로 접근할 수 있도록 해주는 <see cref="IDynamicAccessor"/>를 생성합니다.
/// </summary>
/// <param name="type">대상 수형</param>
/// <param name="mapOptions">매핑 옵션</param>
internal static IDynamicAccessor GetDynamicAccessor(Type type, MapPropertyOptions mapOptions = null)
{
return(DynamicAccessorFactory.CreateDynamicAccessor(type, mapOptions ?? MapPropertyOptions.Safety));
}
static IndexableCollection()
{
Accessor = DynamicAccessorFactory.CreateDynamicAccessor <T>(MapPropertyOptions.Safety);
PropertyInfos = Accessor.PropertyMap.Values.ToArray();
PropertyNames = Accessor.GetPropertyNames();
}
/// <summary>
/// 수형 {T} 의 인스턴스의 속성 및 필드에 동적으로 접근할 수 있도록 해주는 <see cref="IDynamicAccessor{T}"/>를 생성합니다.
/// </summary>
/// <typeparam name="T">대상 수형</typeparam>
/// <param name="mapOptions">매핑 옵션</param>
/// <seealso cref="TypeConvertableDynamicAccessor{T}"/>
internal static IDynamicAccessor <T> GetDynamicAccessor <T>(MapPropertyOptions mapOptions = null)
{
return(DynamicAccessorFactory.CreateDynamicAccessor <T>(mapOptions ?? MapPropertyOptions.Safety));
}
