I ended up caching and reapplying the values after calls to ReInsert().
if (!document.ParameterBindings.Insert(parameterDefinition, binding))
{
var parameterCache = new StringParameterValueCache(document, parameterDefinition, categories);
parameterCache.CacheValues();
document.ParameterBindings.ReInsert(parameterDefinition, binding);
parameterCache.ReInsertValues();
}
I wanted to go back and make this a generic class template, but never had the need. Perhaps you can use this as a starting point.
public class StringParameterValueCache
{
private readonly Document _document;
private readonly Definition _parameterDefinition;
private readonly CategorySet _categories;
private Dictionary<ElementId, string> _cachedValues;
public StringParameterValueCache(Document document, Definition parameterDefinition, CategorySet categories)
{
_document = document;
_parameterDefinition = parameterDefinition;
_categories = categories;
}
public void CacheValues()
{
//Potential point of future update
//parameters can hold: ElementId, int, double, string
//this will need to be updated to support the types other than string
if (_parameterDefinition.ParameterType != ParameterType.Text)
{
_cachedValues = new Dictionary<ElementId, string>();
return;
}
var filter = GetElementsContainingParameterFilter();
var values = _document.Collector()
.WherePasses(filter)
//this value getter must be updated to support types other than string
.Select(e => new { Id = e.Id, Value = e.GetParameterValueAsString(_parameterDefinition.Name) })
.Where(e => !string.IsNullOrWhiteSpace(e.Value))
.ToDictionary(e => e.Id, e => e.Value);
_cachedValues = values;
}
public void ReInsertValues()
{
foreach (var cachedValue in _cachedValues)
{
var element = _document.GetElement(cachedValue.Key);
element.SetParameter(_parameterDefinition.Name, cachedValue.Value);
}
_cachedValues.Clear();
}
private ElementFilter GetElementsContainingParameterFilter()
{
//Category filter is a quick filter
var categoryFilterRule = new FilterCategoryRule(_categories.Cast<Category>().Select(c => c.Id).ToList());
var categoryFilter = new ElementParameterFilter(categoryFilterRule);
//Parameter filter is a slow filter
var parameterAppliesRule = new SharedParameterApplicableRule(_parameterDefinition.Name);
var parameterAppliesFilter = new ElementParameterFilter(parameterAppliesRule);
var combinedFilter = new LogicalAndFilter(categoryFilter, parameterAppliesFilter);
return combinedFilter;
}
}
--
Bobby C. Jones
