/// <summary>
/// Updates settings for a store.
/// </summary>
/// <param name="settings">Settings class instance.</param>
/// <param name="form">Form value collection.</param>
/// <param name="storeId">Store identifier.</param>
/// <param name="settingService">Setting service.</param>
/// <param name="propertyNameMapper">Function to map property names. Return <c>null</c> to skip a property.</param>
public async Task UpdateSettingsAsync(
object settings,
IFormCollection form,
int storeId,
Func <string, string> propertyNameMapper = null)
{
var settingType = settings.GetType();
var settingName = settingType.Name;
var settingProperties = FastProperty.GetProperties(settingType).Values;
foreach (var prop in settingProperties)
{
var name = propertyNameMapper?.Invoke(prop.Name) ?? prop.Name;
if (!name.HasValue())
{
continue;
}
var key = string.Concat(settingName, ".", name);
if (storeId == 0 || IsOverrideChecked(key, form))
{
dynamic value = prop.GetValue(settings);
await _settingService.ApplySettingAsync(key, value ?? string.Empty, storeId);
}
else if (storeId > 0)
{
await _settingService.RemoveSettingAsync(key, storeId);
}
}
await _db.SaveChangesAsync();
}
/// <summary>
/// Get localized property value of a plugin
/// </summary>
/// <param name="descriptor">Plugin descriptor</param>
/// <param name="localizationService">Localization service</param>
/// <param name="propertyName">Name of the property</param>
/// <param name="languageId">Language identifier</param>
/// <param name="returnDefaultValue">A value indicating whether to return default value (if localized is not found)</param>
/// <returns>Localized value</returns>
public static string GetLocalizedValue(this PluginDescriptor descriptor, ILocalizationService localizationService, string propertyName, int languageId = 0, bool returnDefaultValue = true)
{
if (localizationService == null)
{
throw new ArgumentNullException(nameof(localizationService));
}
if (descriptor == null)
{
throw new ArgumentNullException(nameof(descriptor));
}
if (propertyName == null)
{
throw new ArgumentNullException(nameof(propertyName));
}
string systemName = descriptor.SystemName;
string resourceName = string.Format("Plugins.{0}.{1}", propertyName, systemName);
string result = localizationService.GetResource(resourceName, languageId, false, "", true);
if (String.IsNullOrEmpty(result) && returnDefaultValue)
{
var fastProp = FastProperty.GetProperty(descriptor.GetType(), propertyName);
if (fastProp != null)
{
result = fastProp.GetValue(descriptor) as string;
}
}
return(result);
}
public async Task UpdateSettingAsync(
string formKey,
string settingName,
object settings,
IFormCollection form,
int storeId)
{
var settingType = settings.GetType();
if (storeId == 0 || IsOverrideChecked(formKey, form))
{
var prop = FastProperty.GetProperty(settingType, settingName);
if (prop != null)
{
dynamic value = prop.GetValue(settings);
var key = string.Concat(settingType.Name, ".", settingName);
await _settingService.ApplySettingAsync(key, value ?? string.Empty, storeId);
}
}
else if (storeId > 0)
{
var key = string.Concat(settingType.Name, ".", settingName);
await _settingService.RemoveSettingAsync(key, storeId);
}
await _db.SaveChangesAsync();
}
private static void PassItems(Selector selector, IList list, bool selected)
{
FastProperty accessor = null;
if (list != null)
{
foreach (object obj in list)
{
if (accessor == null)
{
if (!compiledAccessors.ContainsKey(obj.GetType()))
{
string path = GetSyncIsSelectedWhenSelected(selector);
accessor = new FastProperty(obj, path);
compiledAccessors[obj.GetType()] = accessor;
}
else
{
accessor = compiledAccessors[obj.GetType()];
}
}
accessor.Set(obj, selected);
}
}
}
static Getters()
{
testUri = new TestUri("SomeHost");
@class = testUri.GetType();
property = @class.GetProperty(propertyName, bindingFlags);
fastProperty = new FastProperty(property, bindingFlags);
getgetMethod = property.GetGetMethod(nonPublic: allowNonPublicFieldAccess);
// Using FastMember - https://github.com/mgravell/fast-member
fastMember = TypeAccessor.Create(@class, allowNonPublicAccessors: allowNonPublicFieldAccess);
Type funcType = Type.GetType("System.Func`2[Benchmark.TestUri, System.String]");
getDelegate = (Func <TestUri, string>)Delegate.CreateDelegate(funcType, getgetMethod);
getDelegateDynamic = Delegate.CreateDelegate(funcType, getgetMethod);
Emit <Func <TestUri, string> > getterEmiter = Emit <Func <TestUri, string> >
.NewDynamicMethod("GetTestUriProperty")
.LoadArgument(0)
.Call(getgetMethod)
.Return();
funcTstring = getterEmiter.CreateDelegate();
ffgetter = Reflect.PropertyGetter(property);
Emit <Func <object, object> > objGetterEmiterFunc = Emit <Func <object, object> >
.NewDynamicMethod("GetMSTestUriProperty")
.LoadArgument(0)
.CastClass(typeof(TestUri))
.Call(getgetMethod)
.Return();
funcObjObj = objGetterEmiterFunc.CreateDelegate();
}
/// Save settings object
/// </summary>
/// <typeparam name="T">Entity type</typeparam>
/// <typeparam name="TPropType">Property type</typeparam>
/// <param name="settings">Settings</param>
/// <param name="keySelector">Key selector</param>
/// <param name="storeId">Store ID</param>
/// <param name="clearCache">A value indicating whether to clear cache after setting update</param>
public virtual void SaveSetting <T, TPropType>(T settings,
Expression <Func <T, TPropType> > keySelector,
int storeId = 0, bool clearCache = true) where T : ISettings, new()
{
var member = keySelector.Body as MemberExpression;
if (member == null)
{
throw new ArgumentException(string.Format(
"Expression '{0}' refers to a method, not a property.",
keySelector));
}
var propInfo = member.Member as PropertyInfo;
if (propInfo == null)
{
throw new ArgumentException(string.Format(
"Expression '{0}' refers to a field, not a property.",
keySelector));
}
string key = typeof(T).Name + "." + propInfo.Name;
// Duck typing is not supported in C#. That's why we're using dynamic type
var fastProp = FastProperty.GetProperty(propInfo, PropertyCachingStrategy.EagerCached);
dynamic value = fastProp.GetValue(settings);
SetSetting(key, value ?? "", storeId, false);
}
static bool DecimalValidation(FastProperty propertie, DecimalRuleAttribute attr, StringBuilder strBuilder)
{
string Name = propertie.PropertyName;
object Value = propertie.Get();
if (attr.Greater.NotNull(false) && Value.NotNull(false) && Convert.ToDecimal(Value) > Convert.ToDecimal(attr.Greater))
{
strBuilder.AppendLine(string.Format(attr.Message, Name, attr.Name, Value ?? "NULL", $"不能大于{attr.Greater}"));
return(false);
}
if (attr.Less.NotNull(false) && Value.NotNull(false) && Convert.ToDecimal(Value) < Convert.ToDecimal(attr.Less))
{
strBuilder.AppendLine(string.Format(attr.Message, Name, attr.Name, Value ?? "NULL", $"不能小于{attr.Less}"));
return(false);
}
if (attr.Equal.NotNull(false) && Value.NotNull(false) && Convert.ToDecimal(Value) == Convert.ToDecimal(attr.Equal))
{
strBuilder.AppendLine(string.Format(attr.Message, Name, attr.Name, Value ?? "NULL", $"不能等于{attr.Equal}"));
return(false);
}
if (attr.NoEqual.NotNull(false) && Value.NotNull(false) && Convert.ToDecimal(Value) != Convert.ToDecimal(attr.NoEqual))
{
strBuilder.AppendLine(string.Format(attr.Message, Name, attr.Name, Value ?? "NULL", $"必须等于{attr.NoEqual}"));
return(false);
}
if (attr.Precision.NotNull(false) && Value.NotNull(false) && Convert.ToDecimal(Value).GetPrecision() > (int?)attr.Precision)
{
strBuilder.AppendLine(string.Format(attr.Message, Name, attr.Name, Value ?? "NULL", $"精度不能超过{attr.Precision}"));
return(false);
}
return(true);
}
/// <summary>
/// Gets the reflection value from item.
/// </summary>
/// <param name="path">The path.</param>
/// <param name="item">The item.</param>
/// <returns></returns>
/// <exception cref="System.NotSupportedException"></exception>
public double GetReflectionValueFromItem(string path, Object item)
{
#if !WINRT
PropertyInfo propertInfo = item.GetType().GetProperty(path);
#else
PropertyInfo propertInfo = item.GetType().GetRuntimeProperty(path);
#endif
FastProperty fastPropertInfo = new FastProperty(propertInfo);
if (propertInfo != null)
{
object value = fastPropertInfo.Get(item);
if (value is Double || value is int)
{
return(Double.Parse(value.ToString()));
}
else if (value is DateTime)
{
return(((DateTime)value).ToOADate());
}
else if (value is String)
{
if (!Chart.ActualCategoryValues.Contains(value.ToString()))
{
Chart.ActualCategoryValues.Add(value.ToString());
}
return(Chart.ActualCategoryValues.IndexOf(value.ToString()));
}
else
{
throw new NotSupportedException(String.Format("The {0} type is Not Supported by Chart", path));
}
}
return(0d);
}
internal static T DoRead <T>(IDataReader reader, TableMapping mapping)
{
object instance = Activator.CreateInstance(typeof(T));
foreach (Column column in mapping.Table.Columns)
{
FastProperty prop = column.Property;
if (null != prop)
{
//TODO : 更好的处理可能出现列名不存在的情况
bool exists = false;
object value = null;
try
{
value = reader[column.Name];
exists = true;
}
catch (IndexOutOfRangeException e)
{
//找不到列名抛出此错误，忽略掉
}
if (exists)
{
prop.SetValue(instance, value.ConvertToType(prop.Type));
}
}
}
return((T)instance);
}
protected virtual void SaveSettingCore(ISettings settings, int storeId = 0)
{
Guard.NotNull(settings, nameof(settings));
using (BeginScope())
{
var settingType = settings.GetType();
var prefix = settingType.Name;
/* We do not clear cache after each setting update.
* This behavior can increase performance because cached settings will not be cleared
* and loaded from database after each update */
foreach (var prop in FastProperty.GetProperties(settingType).Values)
{
// get properties we can read and write to
if (!prop.IsPublicSettable)
{
continue;
}
var converter = TypeConverterFactory.GetConverter(prop.Property.PropertyType);
if (converter == null || !converter.CanConvertFrom(typeof(string)))
{
continue;
}
string key = prefix + "." + prop.Name;
// Duck typing is not supported in C#. That's why we're using dynamic type
dynamic value = prop.GetValue(settings);
SetSetting(key, value ?? "", storeId, false);
}
}
}
private static void MapObject(IDataReader reader, object instance, params string[] fieldsToSkip)
{
var fastProperties = FastProperty.GetProperties(instance);
if (fastProperties.Count == 0)
{
return;
}
for (int i = 0; i < reader.FieldCount; i++)
{
string name = reader.GetName(i);
if (fastProperties.ContainsKey(name))
{
var fastProp = fastProperties[name];
if (fieldsToSkip.Contains(name))
{
continue;
}
if ((fastProp != null) && fastProp.Property.CanWrite)
{
var dbValue = reader.GetValue(i);
fastProp.SetValue(instance, (dbValue == DBNull.Value) ? null : dbValue);
}
}
}
}
public void UpdateSetting(
string formKey,
string settingName,
object settings,
FormCollection form,
int storeId,
ISettingService settingService,
ILocalizedModelLocal localized = null)
{
if (storeId == 0 || IsOverrideChecked(formKey, form))
{
var prop = FastProperty.GetProperty(localized == null ? settings.GetType() : localized.GetType(), settingName);
if (prop != null)
{
dynamic value = prop.GetValue(localized == null ? settings : localized);
var key = string.Concat(settings.GetType().Name, ".", settingName);
settingService.SetSetting(key, value == null ? "" : value, storeId, false);
}
}
else if (storeId > 0)
{
var key = string.Concat(settings.GetType().Name, ".", settingName);
settingService.DeleteSetting(key, storeId);
}
}
public TCounterCategory GetCounter <TCounterCategory>(string instance) where TCounterCategory : class, CounterCategory, new()
{
Type t = typeof(TCounterCategory);
CounterCategory value;
if (_counterCache.TryGetValue(t, out value))
{
return((TCounterCategory)value);
}
//cache miss
var cat = new TCounterCategory();
var categoryName = t.Name;
var props = t.GetProperties();
foreach (var propertyInfo in props)
{
var fp = new FastProperty <TCounterCategory>(propertyInfo);
fp.Set(cat, CreateCounter(categoryName, propertyInfo.Name, instance));
}
_counterCache.Add(t, cat);
return(cat);
}
public void SetIdentityForOutput <T>(IList <T> entities, TableInfo tableInfo, object lastRowIdScalar)
{
long counter = (long)lastRowIdScalar;
string identityPropertyName = tableInfo.PropertyColumnNamesDict.SingleOrDefault(a => a.Value == tableInfo.IdentityColumnName).Key;
FastProperty identityFastProperty = tableInfo.FastPropertyDict[identityPropertyName];
string idTypeName = identityFastProperty.Property.PropertyType.Name;
object idValue = null;
for (int i = entities.Count - 1; i >= 0; i--)
{
idValue = idTypeName switch
{
"Int64" => counter, // long is default
"UInt64" => (ulong)counter,
"Int32" => (int)counter,
"UInt32" => (uint)counter,
"Int16" => (short)counter,
"UInt16" => (ushort)counter,
"Byte" => (byte)counter,
"SByte" => (sbyte)counter,
_ => counter,
};
identityFastProperty.Set(entities[i], idValue);
counter--;
}
}
/// <summary>
/// Save settings object
/// </summary>
/// <typeparam name="T">Type</typeparam>
/// <param name="settings">Setting instance</param>
/// <param name="storeId">Store identifier</param>
public virtual void SaveSetting <T>(T settings, int storeId = 0) where T : ISettings, new()
{
if (typeof(T).HasAttribute <JsonPersistAttribute>(true))
{
SaveSettingsJson <T>(settings);
return;
}
/* We do not clear cache after each setting update.
* This behavior can increase performance because cached settings will not be cleared
* and loaded from database after each update */
foreach (var prop in FastProperty.GetProperties(typeof(T)).Values)
{
// get properties we can read and write to
if (!prop.IsPublicSettable)
{
continue;
}
var converter = TypeConverterFactory.GetConverter(prop.Property.PropertyType);
if (converter == null || !converter.CanConvertFrom(typeof(string)))
{
continue;
}
string key = typeof(T).Name + "." + prop.Name;
// Duck typing is not supported in C#. That's why we're using dynamic type
dynamic value = prop.GetValue(settings);
SetSetting(key, value ?? "", storeId, false);
}
//and now clear cache
ClearCache();
}
public void UpdateSetting(
string formKey,
string settingName,
object settings,
FormCollection form,
int storeId,
ISettingService settingService)
{
var settingType = settings.GetType();
if (storeId == 0 || IsOverrideChecked(formKey, form))
{
var prop = FastProperty.GetProperty(settingType, settingName);
if (prop != null)
{
dynamic value = prop.GetValue(settings);
var key = string.Concat(settingType.Name, ".", settingName);
settingService.SetSetting(key, value ?? string.Empty, storeId, false);
}
}
else if (storeId > 0)
{
var key = string.Concat(settingType.Name, ".", settingName);
settingService.DeleteSetting(key, storeId);
}
}
/// <summary>
/// Updates settings for a store.
/// </summary>
/// <param name="settings">Settings class instance.</param>
/// <param name="form">Form value collection.</param>
/// <param name="storeId">Store identifier.</param>
/// <param name="settingService">Setting service.</param>
/// <param name="propertyNameMapper">Function to map property names. Return <c>null</c> to skip a property.</param>
public void UpdateSettings(
object settings,
FormCollection form,
int storeId,
ISettingService settingService,
Func <string, string> propertyNameMapper = null)
{
var settingType = settings.GetType();
var settingName = settingType.Name;
var settingProperties = FastProperty.GetProperties(settingType).Values;
foreach (var prop in settingProperties)
{
var name = propertyNameMapper?.Invoke(prop.Name) ?? prop.Name;
if (string.IsNullOrWhiteSpace(name))
{
continue;
}
var key = string.Concat(settingName, ".", name);
if (storeId == 0 || IsOverrideChecked(key, form))
{
dynamic value = prop.GetValue(settings);
settingService.SetSetting(key, value ?? string.Empty, storeId, false);
}
else if (storeId > 0)
{
settingService.DeleteSetting(key, storeId);
}
}
}
public static T Read <T>(IDictionary <string, object> data, Type instanceType)
{
if (null != data)
{
FastType reflection = FastType.Get(instanceType);
object instance = Activator.CreateInstance(instanceType);
foreach (String key in data.Keys)
{
FastProperty prop =
reflection.Setters.SingleOrDefault(p => MatchColumnName(p.Name, key));
if (null != prop)
{
prop.SetValue(instance, data[key].ConvertToType(prop.Type));
}
}
return((T)instance);
}
else
{
return(default(T));
}
}
private IEnumerable<TreeNode<ModelTreeMember>> BuildModelTreePartForClass(object instance)
{
var type = instance?.GetType();
if (type == null)
{
yield break;
}
foreach (var prop in FastProperty.GetProperties(type).Values)
{
var pi = prop.Property;
if (pi.PropertyType.IsPredefinedType())
{
yield return new TreeNode<ModelTreeMember>(new ModelTreeMember { Name = prop.Name, Kind = ModelTreeMemberKind.Primitive });
}
else if (typeof(IDictionary<string, object>).IsAssignableFrom(pi.PropertyType))
{
yield return BuildModelTreePart(prop.Name, prop.GetValue(instance));
}
else if (pi.PropertyType.IsSequenceType())
{
yield return new TreeNode<ModelTreeMember>(new ModelTreeMember { Name = prop.Name, Kind = ModelTreeMemberKind.Collection });
}
else
{
var node = new TreeNode<ModelTreeMember>(new ModelTreeMember { Name = prop.Name, Kind = ModelTreeMemberKind.Complex });
node.AppendRange(BuildModelTreePartForClass(prop.GetValue(instance)));
yield return node;
}
}
}
protected virtual ISettings LoadSettingCore(Type settingType)
{
var settings = (ISettings)Activator.CreateInstance(settingType);
var prefix = settingType.Name;
foreach (var fastProp in FastProperty.GetProperties(settingType).Values)
{
var prop = fastProp.Property;
// get properties we can read and write to
if (!prop.CanWrite)
{
continue;
}
var key = prefix + "." + prop.Name;
// load by store
string setting = GetSetting <string>(key, loadSharedValueIfNotFound: true);
if (setting == null)
{
if (fastProp.IsSequenceType)
{
if ((fastProp.GetValue(settings) as IEnumerable) != null)
{
// Instance of IEnumerable<> was already created, most likely in the constructor of the settings concrete class.
// In this case we shouldn't let the EnumerableConverter create a new instance but keep this one.
continue;
}
}
else
{
continue;
}
}
var converter = TypeConverterFactory.GetConverter(prop.PropertyType);
if (converter == null || !converter.CanConvertFrom(typeof(string)))
{
continue;
}
try
{
object value = converter.ConvertFrom(setting);
// Set property
fastProp.SetValue(settings, value);
}
catch (Exception)
{
"Could not convert setting '{0}' to type '{1}'".FormatInvariant(key, prop.PropertyType.Name);
}
}
return(settings);
}
public static IDictionary <string, object> ObjectToDictionary(object obj)
{
Guard.NotNull(obj, nameof(obj));
return(FastProperty.ObjectToDictionary(
obj,
key => key.Replace("_", "-")));
}
public static IDictionary <string, object> ObjectToDictionary(object obj)
{
Guard.ArgumentNotNull(() => obj);
return(FastProperty.ObjectToDictionary(
obj,
key => key.Replace("_", "-")));
}
protected override void AttachToComponentRegistration(IComponentRegistryBuilder componentRegistry, IComponentRegistration registration)
{
//// Ignore components that provide loggers (and thus avoid a circular dependency below)
//if (registration.Services.OfType<TypedService>().Any(ts => ts.ServiceType == typeof(ILogger)))
// return;
bool hasCtorLogger = false;
bool hasPropertyLogger = false;
FastProperty[] loggerProperties = null;
var ra = registration.Activator as ReflectionActivator;
if (ra != null)
{
// // Look for ctor parameters of type "ILogger"
var ctors = GetConstructorsSafe(ra);
var loggerParameters = ctors.SelectMany(ctor => ctor.GetParameters()).Where(pi => pi.ParameterType == typeof(ILogger));
hasCtorLogger = loggerParameters.Any();
// Autowire properties
// Look for settable properties of type "ILogger"
loggerProperties = ra.LimitType
.GetProperties(BindingFlags.SetProperty | BindingFlags.Public | BindingFlags.Instance)
.Select(p => new
{
PropertyInfo = p,
p.PropertyType,
IndexParameters = p.GetIndexParameters(),
Accessors = p.GetAccessors(false)
})
.Where(x => x.PropertyType == typeof(ILogger)) // must be a logger
.Where(x => x.IndexParameters.Count() == 0) // must not be an indexer
.Where(x => x.Accessors.Length != 1 || x.Accessors[0].ReturnType == typeof(void)) //must have get/set, or only set
.Select(x => FastProperty.Create(x.PropertyInfo))
.ToArray();
hasPropertyLogger = loggerProperties.Length > 0;
// Ignore components known to be without logger dependencies
if (!hasCtorLogger && !hasPropertyLogger)
{
return;
}
if (hasPropertyLogger)
{
registration.Metadata.Add("LoggerProperties", loggerProperties);
}
}
registration.PipelineBuilding += (sender, pipeline) =>
{
// Add our middleware to the pipeline.
pipeline.Use(new AutofacSerilogMiddleware(registration.Activator.LimitType, hasCtorLogger, hasPropertyLogger));
};
}
public virtual void AddModelPart(object part, MessageContext messageContext, string name = null)
{
var model = messageContext.Model;
name = name.NullEmpty() ?? ResolveModelName(part);
object modelPart = null;
switch (part)
{
case INamedModelPart x:
modelPart = x;
break;
case IModelPart x:
MergeModelBag(x, model, messageContext);
break;
case Order x:
modelPart = CreateModelPart(x, messageContext);
break;
case Domain.Entities.Data.Post x:
modelPart = CreateModelPart(x, messageContext);
break;
}
if (modelPart != null)
{
if (name.IsEmpty())
{
throw new Exception($"Could not resolve a model key for part '{modelPart.GetType().Name}'. Use an instance of 'NamedModelPart' class to pass model with name.");
}
if (model.TryGetValue(name, out var existing))
{
// A model part with the same name exists in model already...
if (existing is IDictionary <string, object> x)
{
// but it's a dictionary which we can easily merge with
x.Merge(FastProperty.ObjectToDictionary(modelPart));
}
else
{
// Wrap in HybridExpando and merge
var he = new HybridExpando(existing, true);
he.Merge(FastProperty.ObjectToDictionary(modelPart));
model[name] = he;
}
}
else
{
// Put part to model as new property
model[name] = modelPart;
}
}
}
private CGLibPropertyGetter MakeCGIGetter(Type clazz, String propertyName)
{
FastClass fastClass = FastClass.Create(clazz);
PropertyInfo propertyInfo = clazz.GetProperty(propertyName);
FastProperty fastProp = fastClass.GetProperty(propertyInfo);
CGLibPropertyGetter getter = new CGLibPropertyGetter(propertyInfo, fastProp, SupportEventAdapterService.Service);
return(getter);
}
public CachedMember(MemberInfo mi)
: base(GetMemberType(mi))
{
Member = mi;
if (Member is PropertyInfo)
{
fastproperty = FastProperty.Create((PropertyInfo)Member);
}
}
public static IDictionary <string, object> ObjectToDictionary(object obj)
{
if (obj == null)
{
throw new ArgumentNullException(nameof(obj));
}
return(FastProperty.ObjectToDictionary(
obj,
key => key.Replace("_", "-").Replace("@", "")));
}
public static IDictionary <string, object> ObjectToDictionary(object obj)
{
if (obj == null)
{
return(new Dictionary <string, object>());
}
return(FastProperty.ObjectToDictionary(
obj,
key => key.Replace("_", "-").Replace("@", "")));
}
private void HookObject(BaseEntity entity, IHookedEntity entry, bool beforeSave)
{
if (Silent)
{
return;
}
var type = entry.EntityType;
if (!_mediaTracker.Value.TryGetTrackedPropertiesFor(type, out var properties))
{
throw new NotSupportedException();
}
var state = entry.InitialState;
foreach (var prop in properties)
{
if (beforeSave)
{
if (entry.Entry.TryGetModifiedProperty(_dbContext, prop.Name, out object prevValue))
{
var actions = new HashSet <MediaTrack>();
// Untrack the previous file relation (if not null)
TryAddTrack(prop.Album, entry.Entity, prop.Name, prevValue, MediaTrackOperation.Untrack, actions);
// Track the new file relation (if not null)
TryAddTrack(prop.Album, entry.Entity, prop.Name, entry.Entry.CurrentValues[prop.Name], MediaTrackOperation.Track, actions);
_actionsTemp[entry.Entity] = actions;
}
}
else
{
switch (state)
{
case EntityState.Added:
case EntityState.Deleted:
var value = FastProperty.GetProperty(type, prop.Name).GetValue(entry.Entity);
TryAddTrack(prop.Album, entry.Entity, prop.Name, value, state == EntityState.Added ? MediaTrackOperation.Track : MediaTrackOperation.Untrack);
break;
case EntityState.Modified:
if (_actionsTemp.TryGetValue(entry.Entity, out var actions))
{
_actionsUnit.AddRange(actions);
}
break;
}
}
}
}
public void CanCreateFastPropertyByLambda()
{
var fastProp = FastProperty.GetProperty <Product>(x => x.Name, PropertyCachingStrategy.Cached);
fastProp.ShouldNotBeNull();
Assert.AreEqual(fastProp.Property.Name, "Name");
// from cache
var fastProp2 = FastProperty.GetProperty <Product>(x => x.Name);
Assert.AreSame(fastProp, fastProp2);
}
public ArgumentParsingInstructions(Type argumentType)
{
_argumentType = argumentType;
_positionalArguments = new List<FastProperty>();
_shortFormArguments = new Dictionary<string, FastProperty>(StringComparer.InvariantCultureIgnoreCase);
_longFormArguments = new Dictionary<string, FastProperty>(StringComparer.InvariantCultureIgnoreCase);
foreach (var info in _argumentType.GetProperties())
{
var fp = new FastProperty(info);
_positionalArguments.Add(fp);
_shortFormConvention.Append(info, _shortFormArguments, fp);
_longFormConvention.Append(info, _longFormArguments, fp);
_numberOfAguments++;
}
}
public void Append(PropertyInfo prop, IDictionary<string, FastProperty> args, FastProperty fp)
{
var key = GenerateKey(prop.Name.ToLower(), args);
args.Add(key, fp);
}
public void Append(PropertyInfo prop, IDictionary<string, FastProperty> args, FastProperty fp)
{
args.Add(prop.Name.ToLower(), fp);
}
