public MemberAccessorElement(
MemberAccessor <T> accessor,
IPropertyObserver propertyObserver)
{
ArgumentNullException.ThrowIfNull(accessor);
ArgumentNullException.ThrowIfNull(propertyObserver);
this.Accessor = accessor;
this.propertyObserver = propertyObserver;
if (accessor.Type == MemberAccessorType.Member &&
accessor.MemberExpressions is not null)
{
var targetAccessors = new List <Delegate>();
var memberNames = new List <string>();
foreach (var member in accessor.MemberExpressions)
{
var targetAccessor = Expression.Lambda(member.Expression !).Compile();
targetAccessors.Add(targetAccessor);
memberNames.Add(member.Member.Name);
}
this.targetAccessors = targetAccessors.ToImmutableArray();
this.memberNames = memberNames.ToImmutableArray();
this.targets = new(this.targetAccessors.Length);
}
else
{
this.targetAccessors = ImmutableArray <Delegate> .Empty;
this.memberNames = ImmutableArray <string> .Empty;
}
}
public IndexPropertyObserver(Type propertyContainingType, IndexPropertyPathElement propertyPathElement, XamlNamespaces namespaces)
{
baseObserver = CreateBaseObserver(propertyContainingType, propertyPathElement.PropertyName);
PropertyInfo indexPropertyInfo = baseObserver != null?baseObserver.ValueType.GetDefaultIndexProperty() :
propertyPathElement.PropertyName.IsEmpty ? propertyContainingType.GetDefaultIndexProperty() : propertyContainingType.GetInstanceProperty(propertyPathElement.PropertyName.MemberName);
if (indexPropertyInfo == null)
{
throw new Granular.Exception("Property \"{0}.{1}\" does not have an indexer", propertyContainingType.Name, propertyPathElement.PropertyName.MemberName);
}
if (indexPropertyInfo.GetIndexParameters().Count() != propertyPathElement.IndexRawValues.Count())
{
throw new Granular.Exception("Invalid number of index parameters for \"{0}.{1}\"", indexPropertyInfo.DeclaringType.Name, indexPropertyInfo.Name);
}
indexerObserver = new ClrPropertyObserver(indexPropertyInfo, propertyPathElement.ParseIndexValues(indexPropertyInfo));
indexerObserver.ValueChanged += (sender, e) => ValueChanged.Raise(this, e);
if (baseObserver != null)
{
baseObserver.ValueChanged += (sender, e) => indexerObserver.SetBaseValue(baseObserver.Value);
indexerObserver.SetBaseValue(baseObserver.Value);
}
}
/// <summary>
/// 对属性进行绑定【私有】
/// </summary>
/// <param name="propName"></param>
/// <param name="handler"></param>
/// <param name="observer"></param>
private void Bind(string propName, Action <string, object, object> handler, IPropertyObserver observer)
{
this.Unregist();
this.propertyObserver = observer;
this.propName = propName;
this.valueChangedHandler = handler;
this.Regist();
CheckBinderIsValidObject();
}
public void Init(IPropertyObserver <TModel> observer)
{
if (observer == null)
{
throw new ArgumentNullException("observer");
}
this.observer = observer;
observer.DidChange += new EventHandler(observer_DidChange);
}
/// <summary>
/// 对属性进行绑定
/// </summary>
/// <param name="propOwner"></param>
/// <param name="propName"></param>
/// <param name="handler"></param>
public void Bind(object propOwner, string propName, Action <string, object, object> handler)
{
IPropertyObserver propertyObserver = PropertyObserverFactory.CreatePropertyObserver(propOwner);
if (propertyObserver == null)
{
return;
}
this.Bind(propName, handler, propertyObserver);
}
public ControlPropertyObserver(object target, IPropertyObserver <T> observer, string name)
{
if (target == null)
{
throw new ArgumentNullException("target");
}
if (observer == null)
{
throw new ArgumentNullException("observer");
}
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("name");
}
Type t = target.GetType();
this.observer = observer;
PropertyInfo info = t.GetProperty(name, BindingFlags.Public | BindingFlags.Instance);
var getterMi = info.GetGetMethod();
var setterMi = info.GetSetMethod();
getter = target.GetDelegate <Getter <T> >(getterMi.Name);
setter = target.GetDelegate <Setter <T> >(setterMi.Name);
setter(observer.Value);
EventInfo ei = t.GetEvent(name + "Changed", BindingFlags.Instance | BindingFlags.Public);
if (ei != null)
{
ei.AddEventHandler(target, new EventHandler(ControlPropertyChanged));
}
observer.DidChange += new EventHandler(observer_DidChange);
}
private void SetDelegateObserverBaseValue()
{
object baseValue = baseObserver.Value;
if (ObservableValue.IsNullOrUnset(baseValue) || baseObserverValueType == baseValue.GetType())
{
if (delegateObserver != null)
{
delegateObserver.SetBaseValue(baseValue);
}
return;
}
baseObserverValueType = baseValue.GetType();
if (delegateObserver is IDisposable)
{
((IDisposable)delegateObserver).Dispose();
}
delegateObserver = propertyPathElement.CreatePropertyObserver(baseObserverValueType);
if (delegateObserver != null)
{
ValueType = delegateObserver.ValueType;
delegateObserver.SetBaseValue(baseValue);
delegateObserver.ValueChanged += (sender, e) => observableValue.Value = delegateObserver.Value;
observableValue.Value = delegateObserver.Value;
}
else
{
ValueType = null;
observableValue.Value = ObservableValue.UnsetValue;
}
}
public TransformPropertyObserver(IPropertyObserver <TModel> observer)
{
Init(observer);
}
private void SetDelegateObserverBaseValue()
{
object baseValue = baseObserver.Value;
if (ObservableValue.IsNullOrUnset(baseValue) || baseObserverValueType == baseValue.GetType())
{
if (delegateObserver != null)
{
delegateObserver.SetBaseValue(baseValue);
}
return;
}
baseObserverValueType = baseValue.GetType();
if (delegateObserver is IDisposable)
{
((IDisposable)delegateObserver).Dispose();
}
delegateObserver = propertyPathElement.CreatePropertyObserver(baseObserverValueType);
if (delegateObserver != null)
{
ValueType = delegateObserver.ValueType;
delegateObserver.SetBaseValue(baseValue);
delegateObserver.ValueChanged += (sender, e) => observableValue.Value = delegateObserver.Value;
observableValue.Value = delegateObserver.Value;
}
else
{
ValueType = null;
observableValue.Value = ObservableValue.UnsetValue;
}
}
/// <summary>
/// 取消属性绑定
/// </summary>
public void Unbind()
{
this.Unregist();
this.propertyObserver = null;
this.propName = null;
}
public StringPropertyObserver(IPropertyObserver <TModel> observer)
: base(observer)
{
}
