private ChildPropertyChangedProcessor(
PropertyFieldBindingsMap propertyToFieldBindings, FieldValueComparer fieldValueComparer, ExplicitDependencyMap explicitDependencyMap )
{
this.fieldValueComparer = fieldValueComparer;
this.explicitDependencyMap = explicitDependencyMap;
this.propertyToFieldBindings = propertyToFieldBindings;
}
public override void CompileTimeInitialize( Type type, AspectInfo aspectInfo )
{
this.explicitDependencyMap = analyzer.Value.AnalyzeType( type );
this.fieldValueComparer = new FieldValueComparer( type );
this.childPropertyChangedProcessor = ChildPropertyChangedProcessor.CompileTimeCreate(
type, analyzer.Value.MethodFieldDependencies, this.fieldValueComparer, this.explicitDependencyMap );
}
private ChildPropertyChangedProcessor( ChildPropertyChangedProcessor prototype, object instance )
{
this.instance = instance;
this.fieldValueComparer = prototype.fieldValueComparer;
this.explicitDependencyMap = prototype.explicitDependencyMap;
this.propertyToFieldBindings = PropertyFieldBindingsMap.CreateFromPrototype( prototype.propertyToFieldBindings );
this.notifyChildPropertyChangedHandlers = new Dictionary<string, NotifyChildPropertyChangedEventHandlerDescriptor>();
}
public static ChildPropertyChangedProcessor CompileTimeCreate(
Type type,
Dictionary<MethodBase, IList<FieldInfo>> methodFieldDependencies,
FieldValueComparer fieldValueComparer,
ExplicitDependencyMap explicitDependencyMap )
{
PropertyFieldBindingsMap propertyToFieldBindings = PropertyToFieldBindingGenerator.GenerateBindings(
type, methodFieldDependencies, fieldValueComparer );
return new ChildPropertyChangedProcessor( propertyToFieldBindings, fieldValueComparer, explicitDependencyMap );
}
public ExplicitDependencyMap AnalyzeType(Type type)
{
//We need to grab all the properties and build a map of their dependencies
IEnumerable <PropertyInfo> allProperties =
type.GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly)
.Where(p => !p.IsInpcIgnoredMethod()).ToList();
IEnumerable <PropertyInfo> propertiesForImplicitAnalasis =
allProperties;
//var propertiesForExplicitAnalasis =
// allProperties.Select( p => new { Property = p, DependsOnAttributes = p.GetCustomAttributes( typeof(DependsOnAttribute), false ) } ).Where(
// p => p.DependsOnAttributes.Any() );
// build ExplicitDependencyMap. We need it here to add invocation chains.
ExplicitDependencyMap currentTypeExplicitDependencyMap = new ExplicitDependencyMap();
//propertiesForExplicitAnalasis.Select(
// p => new ExplicitDependency( p.Property.Name, p.DependsOnAttributes.SelectMany( d => ((DependsOnAttribute)d).Dependencies ) ) ) );
foreach (PropertyInfo propertyInfo in propertiesForImplicitAnalasis)
{
if (!propertyInfo.CanRead)
{
continue;
}
this.methodAnalyzer.AnalyzeProperty(type, propertyInfo, currentTypeExplicitDependencyMap);
IList <FieldInfo> fieldList;
//Time to build the reversed graph, i.e. field->property dependencies
if (this.methodAnalyzer.MethodFieldDependencies.TryGetValue(propertyInfo.GetGetMethod(), out fieldList))
{
foreach (FieldInfo field in fieldList)
{
IList <string> propertyList = this.fieldDependentProperties.GetOrCreate(field.FullName(), () => new List <string>());
propertyList.AddIfNew(propertyInfo.Name);
}
}
}
return(currentTypeExplicitDependencyMap);
}
public ExplicitDependencyMap AnalyzeType( Type type )
{
//We need to grab all the properties and build a map of their dependencies
IEnumerable<PropertyInfo> allProperties =
type.GetProperties( BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly )
.Where( p => !p.IsInpcIgnoredMethod() ).ToList();
IEnumerable<PropertyInfo> propertiesForImplicitAnalasis =
allProperties;
//var propertiesForExplicitAnalasis =
// allProperties.Select( p => new { Property = p, DependsOnAttributes = p.GetCustomAttributes( typeof(DependsOnAttribute), false ) } ).Where(
// p => p.DependsOnAttributes.Any() );
// build ExplicitDependencyMap. We need it here to add invocation chains.
ExplicitDependencyMap currentTypeExplicitDependencyMap = new ExplicitDependencyMap();
//propertiesForExplicitAnalasis.Select(
// p => new ExplicitDependency( p.Property.Name, p.DependsOnAttributes.SelectMany( d => ((DependsOnAttribute)d).Dependencies ) ) ) );
foreach ( PropertyInfo propertyInfo in propertiesForImplicitAnalasis )
{
if ( !propertyInfo.CanRead )
{
continue;
}
this.methodAnalyzer.AnalyzeProperty( type, propertyInfo, currentTypeExplicitDependencyMap );
IList<FieldInfo> fieldList;
//Time to build the reversed graph, i.e. field->property dependencies
if ( this.methodAnalyzer.MethodFieldDependencies.TryGetValue( propertyInfo.GetGetMethod(), out fieldList ) )
{
foreach ( FieldInfo field in fieldList )
{
IList<string> propertyList = this.fieldDependentProperties.GetOrCreate( field.FullName(), () => new List<string>() );
propertyList.AddIfNew( propertyInfo.Name );
}
}
}
return currentTypeExplicitDependencyMap;
}
public void AnalyzeProperty(Type type, PropertyInfo propertyInfo, ExplicitDependencyMap currentTypeExplicitDependencyMap)
{
if (this.context.Current != null)
{
throw new NotSupportedException("MethodAnalyzer is currently single-threaded!");
}
MethodInfo propertyGetter = propertyInfo.GetGetMethod(false);
if (propertyGetter == null)
{
return;
}
using (this.context.InContext(() => new AnalysisContext(type, propertyGetter, propertyInfo, currentTypeExplicitDependencyMap)))
{
this.AnalyzeMethodRecursive(propertyGetter);
}
}
public AnalysisContext(Type currentType, MethodBase currentMethod, PropertyInfo currentProperty, ExplicitDependencyMap explicitDependencyMap)
{
this.CurrentType = currentType;
this.CurrentMethod = currentMethod;
this.CurrentProperty = currentProperty;
this.ExplicitDependencyMap = explicitDependencyMap;
}
public AnalysisContext( Type currentType, MethodBase currentMethod, PropertyInfo currentProperty, ExplicitDependencyMap explicitDependencyMap )
{
this.CurrentType = currentType;
this.CurrentMethod = currentMethod;
this.CurrentProperty = currentProperty;
this.ExplicitDependencyMap = explicitDependencyMap;
}
public void AnalyzeProperty( Type type, PropertyInfo propertyInfo, ExplicitDependencyMap currentTypeExplicitDependencyMap )
{
if ( this.context.Current != null )
{
throw new NotSupportedException( "MethodAnalyzer is currently single-threaded!" );
}
MethodInfo propertyGetter = propertyInfo.GetGetMethod( false );
if ( propertyGetter == null )
{
return;
}
using ( this.context.InContext( () => new AnalysisContext( type, propertyGetter, propertyInfo, currentTypeExplicitDependencyMap ) ) )
{
this.AnalyzeMethodRecursive( propertyGetter );
}
}