public override void Initialize(IInstanceBuilderContext context, ViewNode viewNode, bool isNewInstance)
{
if (context.IsSerializationScope || viewNode.Instance == null || viewNode.InstanceState != InstanceState.Uninitialized)
{
base.Initialize(context, viewNode, isNewInstance);
return;
}
DocumentCompositeNode documentNode = viewNode.DocumentNode as DocumentCompositeNode;
DocumentCompositeNode documentCompositeNode = documentNode;
if (documentNode != null)
{
this.InstantiateProperties(context, viewNode, documentCompositeNode);
if (documentCompositeNode.SupportsChildren)
{
for (int i = 0; i < documentCompositeNode.Children.Count; i++)
{
DocumentNode item = documentCompositeNode.Children[i];
IInstanceBuilder builder = context.InstanceBuilderFactory.GetBuilder(item.TargetType);
ViewNode viewNode1 = builder.GetViewNode(context, item);
viewNode.Children.Add(viewNode1);
this.InstantiateChild(context, viewNode, viewNode1);
}
}
}
viewNode.InstanceState = InstanceState.Valid;
this.OnInitialized(context, viewNode, viewNode.Instance);
}
private static object CreateXmlDataContext(DataSourceInfo dataSource, SceneViewModel viewModel)
{
DocumentNode sourceNode = dataSource.SourceNode;
object obj = (object)null;
using (StandaloneInstanceBuilderContext instanceBuilderContext = new StandaloneInstanceBuilderContext(viewModel.Document.DocumentContext, viewModel.DesignerContext))
{
try
{
IInstanceBuilder builder = instanceBuilderContext.InstanceBuilderFactory.GetBuilder(sourceNode.TargetType);
ViewNode viewNode = builder.GetViewNode((IInstanceBuilderContext)instanceBuilderContext, sourceNode);
obj = (object)(bool)(builder.Instantiate((IInstanceBuilderContext)instanceBuilderContext, viewNode) ? true : false);
}
catch
{
}
}
ReferenceStep referenceStep = (ReferenceStep)viewModel.ProjectContext.ResolveProperty(XmlDataProviderSceneNode.XPathProperty);
string inheritedXPath = referenceStep.GetValue(obj) as string;
if (string.IsNullOrEmpty(inheritedXPath))
{
inheritedXPath = dataSource.Path;
}
else if (!string.IsNullOrEmpty(dataSource.Path))
{
inheritedXPath = XmlSchema.CombineXPaths(inheritedXPath, dataSource.Path);
}
if (!string.IsNullOrEmpty(inheritedXPath))
{
referenceStep.SetValue(obj, (object)inheritedXPath);
}
return(obj);
}
/// <summary>
/// Injects multiple instances of <typeparamref name="T"/> for this instance builder, one per item in the source sequence, via the factory function passed to this method.
/// </summary>
/// <typeparam name="TSource">The type of items in the source sequence.</typeparam>
/// <typeparam name="T">The type of instance to create.</typeparam>
/// <param name="builder">The instance builder.</param>
/// <param name="source">The source sequence.</param>
/// <param name="function">The factory function that transforms a source sequence item to an instance of <typeparamref name="T"/>.</param>
public static InstanceBuilder WithMany <TSource, T>(this IInstanceBuilder builder, IEnumerable <TSource> source, Func <InstanceBuilder, TSource, T> function)
{
_ = builder ?? throw new ArgumentNullException(nameof(builder));
_ = source ?? throw new ArgumentNullException(nameof(source));
_ = function ?? throw new ArgumentNullException(nameof(function));
return(builder.With(source.Select(x => function(builder.Copy(), x)).ToList()));
}
public object Build(Type pluginType, BuildSession session, IInstanceBuilder builder)
{
if (builder == null)
{
throw new StructureMapException(
201, _plugin.PluggedType.FullName, Name, pluginType);
}
try
{
var args = new Arguments(this, session);
return(builder.BuildInstance(args));
}
catch (StructureMapException)
{
throw;
}
catch (InvalidCastException ex)
{
throw new StructureMapException(206, ex, Name);
}
catch (Exception ex)
{
throw new StructureMapException(207, ex, Name, pluginType.FullName);
}
}
public static ViewNode UpdateChildWithoutApply(IInstanceBuilderContext context, ViewNode viewNode, int childIndex, DocumentNodeChangeAction action, DocumentNode childNode)
{
ViewNode viewNode1 = null;
if (action == DocumentNodeChangeAction.Remove)
{
ViewNode item = viewNode.Children[childIndex];
viewNode.Children.Remove(item);
}
if (action == DocumentNodeChangeAction.Add || action == DocumentNodeChangeAction.Replace)
{
IInstanceBuilder builder = context.InstanceBuilderFactory.GetBuilder(childNode.TargetType);
viewNode1 = builder.GetViewNode(context, childNode);
if (action != DocumentNodeChangeAction.Replace)
{
viewNode.Children.Insert(childIndex, viewNode1);
}
else
{
viewNode.Children[childIndex] = viewNode1;
}
context.ViewNodeManager.Instantiate(viewNode1);
}
return(viewNode1);
}
public GroupByValuesQueryResultAction(IInternalValuesQuery query, IInstanceBuilder instanceBuilder)
{
_query = query;
_queryHasOrderBy = query.HasOrderBy();
_instanceBuilder = instanceBuilder;
_returnArraySize = query.ObjectActionsCount;
_groupByFieldList = query.GetGroupByFieldList();
_groupByResult = new OdbHashMap <IOdbComparable, ValuesQueryResultAction>();
}
public QueryResultAction(IQuery query, bool inMemory, IStorageEngine storageEngine, bool returnObjects,
IInstanceBuilder instanceBuilder)
{
_query = (IInternalQuery)query;
_inMemory = inMemory;
_storageEngine = storageEngine;
_returnObjects = returnObjects;
_queryHasOrderBy = _query.HasOrderBy();
_instanceBuilder = instanceBuilder;
}
private bool TryGetPipeline(IContext context, out IInstanceBuilder instanceBuilder)
{
foreach (var conditionalPipelineEngine in _conditionalPipelineEngines.Where(x => x.Condition(context)))
{
instanceBuilder = conditionalPipelineEngine.InstanceBuilder;
return true;
}
instanceBuilder = _defaultInstanceBuilder;
return instanceBuilder != null;
}
public void BuildUp(object target)
{
Type pluggedType = target.GetType();
IConfiguredInstance instance = _pipelineGraph.GetDefault(pluggedType) as IConfiguredInstance
?? new ConfiguredInstance(pluggedType);
IInstanceBuilder builder = PluginCache.FindBuilder(pluggedType);
var arguments = new Arguments(instance, this);
builder.BuildUp(arguments, target);
}
/// <summary>
/// The "BuildUp" method takes in an already constructed object
/// and uses Setter Injection to push in configured dependencies
/// of that object
/// </summary>
/// <param name="target"></param>
public void BuildUp(object target)
{
Type pluggedType = target.GetType();
IConfiguredInstance instance = _pipelineGraph.GetDefault(pluggedType) as IConfiguredInstance
?? new ConfiguredInstance(pluggedType);
IInstanceBuilder builder = _pipelineGraph.Outer.BuilderFor(pluggedType);
var arguments = new Arguments(instance, new BuildSession(_pipelineGraph));
builder.BuildUp(arguments, target);
}
public LazySimpleListOfAoi(IInstanceBuilder builder, bool returnInstance) : base(10)
{
if (builder == null)
{
throw new OdbRuntimeException(
NDatabaseError.InternalError.AddParameter("instance builder cannot be null"));
}
_instanceBuilder = builder;
_returnInstance = returnInstance;
}
public static object InstantiateTargetType(IAssembly projectAssembly, IInstanceBuilderContext context, Type type)
{
bool flag = (projectAssembly == null ? false : projectAssembly.CompareTo(type.Assembly));
IInstanceBuilder builder = context.InstanceBuilderFactory.GetBuilder(type);
if (builder.ReplacementType == null)
{
return(InstanceBuilderOperations.InstantiateType(type, flag));
}
return(InstanceBuilderOperations.InstantiateType(builder.ReplacementType, true));
}
private IDeploymentTask BuildInstance(IInstanceBuilder builder, Sentence sentence)
{
try
{
var type = typeUniverse.Single(x => x.Name == sentence.Command.Name);
var parameters = sentence.Command.Arguments.Select(x => x.Value);
return((IDeploymentTask)builder.Create(type, parameters.ToArray()));
}
catch (InvalidOperationException)
{
throw new ScriptException($"Task '{sentence.Command.Name}' not found");
}
}
public void SetUp()
{
TheDefaultGateway = new DefaultGateway();
var args = new ExplicitArguments();
args.Set<IGateway>(TheDefaultGateway);
builder = new Plugin(typeof (ClassWithMixOfSetters)).CreateBuilder();
instance = new SmartInstance<ClassWithMixOfSetters>().Ctor<int>("Age").Is(34);
_session = BuildSession.Empty(args);
_target = null;
}
protected override object build(Type pluginType, BuildSession session)
{
if (_builder == null)
{
lock (_locker)
{
if (_builder == null)
{
_builder = session.CreateBuilder(Plugin);
}
}
}
return(Build(pluginType, session, _builder));
}
public static ViewNode UpdatePropertyWithoutApply(IInstanceBuilderContext context, ViewNode viewNode, IProperty propertyKey, DocumentNode valueNode)
{
ViewNode item = viewNode.Properties[propertyKey];
ViewNode viewNode1 = null;
if (item != null)
{
viewNode.Properties[propertyKey] = null;
}
if (valueNode != null)
{
IInstanceBuilder builder = context.InstanceBuilderFactory.GetBuilder(valueNode.TargetType);
viewNode1 = builder.GetViewNode(context, valueNode);
viewNode.Properties[propertyKey] = viewNode1;
context.ViewNodeManager.Instantiate(viewNode1);
}
return(viewNode1);
}
public ValuesQueryResultAction(IInternalValuesQuery query, IStorageEngine storageEngine,
IInstanceBuilder instanceBuilder)
{
_engine = storageEngine;
_query = query;
_queryHasOrderBy = query.HasOrderBy();
_returnArraySize = query.ObjectActionsCount;
_queryFieldActions = new IQueryFieldAction[_returnArraySize];
var i = 0;
foreach (var action in _query.GetObjectActions())
{
_queryFieldActions[i] = action.Copy();
_queryFieldActions[i].SetReturnInstance(query.ReturnInstance());
((AbstractQueryFieldAction)_queryFieldActions[i]).SetInstanceBuilder(instanceBuilder);
i++;
}
}
private object GetDefaultStyleKey(SceneElement targetElement, ITypeId styleTargetType, IPropertyId targetProperty)
{
IInstanceBuilder builder = this.SceneView.InstanceBuilderContext.InstanceBuilderFactory.GetBuilder(this.Type.RuntimeType);
if (BaseFrameworkElement.StyleProperty.Equals((object)targetProperty) && builder.ReplacementType == (Type)null)
{
IViewObject viewObject = targetElement.ViewObject;
if (viewObject == null)
{
return((object)null);
}
return(viewObject.DefaultStyleKey);
}
if (!this.SceneViewModel.ProjectContext.IsCapabilitySet(PlatformCapability.IsWpf) && PlatformTypes.ComboBoxItem.Equals((object)styleTargetType))
{
styleTargetType = (ITypeId)this.SceneViewModel.ProjectContext.ResolveType(PlatformTypes.ListBoxItem);
}
if (styleTargetType != null)
{
return((object)this.SceneViewModel.ProjectContext.ResolveType(styleTargetType).RuntimeType);
}
return((object)null);
}
public override void UpdateChild(IInstanceBuilderContext context, ViewNode viewNode, int childIndex, DocumentNodeChangeAction action, DocumentNode childNode)
{
if (action == DocumentNodeChangeAction.Remove && childIndex < viewNode.Children.Count)
{
ViewNode item = viewNode.Children[childIndex];
this.RemoveChildViewNodeFromInstance(viewNode, item);
viewNode.Children.Remove(item);
}
if (action == DocumentNodeChangeAction.Add || action == DocumentNodeChangeAction.Replace)
{
IInstanceBuilder builder = context.InstanceBuilderFactory.GetBuilder(childNode.TargetType);
ViewNode viewNode1 = builder.GetViewNode(context, childNode);
if (action != DocumentNodeChangeAction.Replace)
{
viewNode.Children.Insert(childIndex, viewNode1);
}
else
{
this.RemoveChildViewNodeFromInstance(viewNode, viewNode.Children[childIndex]);
viewNode.Children[childIndex] = viewNode1;
}
this.InstantiateChild(context, viewNode, viewNode1);
}
}
public override bool Instantiate(IInstanceBuilderContext context, ViewNode viewNode)
{
string str;
DocumentNode rootNode;
if (viewNode.Instance == null)
{
DesignDataExtension instance = null;
using (IDisposable disposable = context.ChangeSerializationContext(null))
{
base.Instantiate(context, viewNode);
instance = viewNode.Instance as DesignDataExtension;
}
instance.Instance = null;
if (instance.Source != null)
{
DocumentCompositeNode documentNode = (DocumentCompositeNode)viewNode.DocumentNode;
string sourceFilePath = DesignDataInstanceBuilder.GetSourceFilePath(documentNode);
IDocumentRoot sourceXamlDocumentInternal = DesignDataInstanceBuilder.GetSourceXamlDocumentInternal(documentNode, sourceFilePath);
if (sourceXamlDocumentInternal == null && sourceFilePath != null)
{
if (!File.Exists(sourceFilePath))
{
CultureInfo invariantCulture = CultureInfo.InvariantCulture;
string designDataNotFound = ExceptionStringTable.DesignDataNotFound;
object[] objArray = new object[] { sourceFilePath };
str = string.Format(invariantCulture, designDataNotFound, objArray);
}
else
{
CultureInfo cultureInfo = CultureInfo.InvariantCulture;
string designDataHasErrors = ExceptionStringTable.DesignDataHasErrors;
object[] objArray1 = new object[] { sourceFilePath };
str = string.Format(cultureInfo, designDataHasErrors, objArray1);
}
context.WarningDictionary.SetWarning(viewNode, documentNode, str);
}
if (sourceXamlDocumentInternal != null)
{
rootNode = sourceXamlDocumentInternal.RootNode;
}
else
{
rootNode = null;
}
DocumentNode documentNode1 = rootNode;
if (documentNode1 != null)
{
context.DocumentRootResolver.GetDocumentRoot(documentNode1.DocumentRoot.DocumentContext.DocumentUrl);
context.ViewNodeManager.AddRelatedDocumentRoot(viewNode, documentNode1.DocumentRoot);
IInstanceBuilder builder = context.InstanceBuilderFactory.GetBuilder(documentNode1.TargetType);
ViewNode viewNode1 = builder.GetViewNode(context, documentNode1);
try
{
builder.Initialize(context, viewNode1, builder.Instantiate(context, viewNode1));
instance.Instance = viewNode1.Instance;
}
catch (Exception exception)
{
instance.Instance = null;
CultureInfo invariantCulture1 = CultureInfo.InvariantCulture;
string designDataHasErrors1 = ExceptionStringTable.DesignDataHasErrors;
object[] objArray2 = new object[] { sourceFilePath };
string str1 = string.Format(invariantCulture1, designDataHasErrors1, objArray2);
context.WarningDictionary.SetWarning(viewNode, documentNode, str1);
}
if (context.IsSerializationScope)
{
viewNode.Instance = instance.Instance;
viewNode.InstanceState = InstanceState.Valid;
}
else
{
viewNode.Instance = instance;
viewNode.InstanceState = InstanceState.Valid;
}
}
}
if (viewNode.Instance == instance && instance.Instance == null)
{
viewNode.Instance = null;
viewNode.InstanceState = InstanceState.Valid;
}
}
return(viewNode.Instance != null);
}
public PredicatedPipelineEngine(Func<IContext, bool> condition, IInstanceBuilder instanceBuilder)
: this()
{
Condition = condition;
InstanceBuilder = instanceBuilder;
}
public ScriptRunner(IEnumerable <Type> typeUniverse, IInstanceBuilder instanceBuilder, IPathBuilder pathBuilder)
{
this.typeUniverse = typeUniverse;
this.instanceBuilder = instanceBuilder;
this.pathBuilder = pathBuilder;
}
protected override object build(Type pluginType, BuildSession session)
{
IInstanceBuilder builder = PluginCache.FindBuilder(_plugin.PluggedType);
return(Build(pluginType, session, builder));
}
public ServerToClientBlockHandler(IInstanceBuilder instanceBuilder)
{
this.instanceBuilder = instanceBuilder;
}
public Item(Func<IContext, bool> predicate, IInstanceBuilder instanceBuilder)
: this()
{
IsMatch = predicate;
InstanceBuilder = instanceBuilder;
}
private static object CreateClrDataContext(DataSourceInfo dataSource, SceneViewModel viewModel)
{
DocumentNode sourceNode = dataSource.SourceNode;
if (PlatformTypes.DataTemplate.IsAssignableFrom((ITypeId)sourceNode.Type))
{
return((object)null);
}
object obj1 = (object)null;
using (StandaloneInstanceBuilderContext instanceBuilderContext = new StandaloneInstanceBuilderContext(viewModel.Document.DocumentContext, viewModel.DesignerContext))
{
try
{
IInstanceBuilder builder = instanceBuilderContext.InstanceBuilderFactory.GetBuilder(sourceNode.TargetType);
ViewNode viewNode = builder.GetViewNode((IInstanceBuilderContext)instanceBuilderContext, sourceNode);
if (builder.Instantiate((IInstanceBuilderContext)instanceBuilderContext, viewNode))
{
obj1 = DataContextEvaluator.GetEvaluatedValue(viewNode.Instance);
}
}
catch
{
}
}
if (obj1 == null || string.IsNullOrEmpty(dataSource.Path))
{
return(obj1);
}
object instance = obj1;
try
{
IList <ClrPathPart> list1 = ClrPropertyPathHelper.SplitPath(dataSource.Path);
if (list1 == null)
{
return((object)null);
}
for (int index = 0; index < list1.Count; ++index)
{
if (instance != null)
{
Type type = instance.GetType();
object obj2 = (object)null;
ClrPathPart clrPathPart = list1[index];
if (clrPathPart.Category == ClrPathPartCategory.PropertyName)
{
PropertyInfo property = type.GetProperty(clrPathPart.Path);
if (property != (PropertyInfo)null)
{
obj2 = property.GetValue(instance, (object[])null);
}
}
else
{
CollectionAdapterDescription adapterDescription = CollectionAdapterDescription.GetAdapterDescription(type);
if (adapterDescription != null)
{
IList list2 = adapterDescription.GetCollectionAdapter(instance) as IList;
if (list2 != null)
{
int result = 0;
if (clrPathPart.Category == ClrPathPartCategory.IndexStep)
{
if (!int.TryParse(clrPathPart.Path.Trim('[', ']'), out result))
{
goto label_23;
}
}
obj2 = list2[result];
}
}
}
label_23:
instance = obj2;
}
else
{
break;
}
}
}
catch
{
instance = (object)null;
}
return(instance);
}
/// <summary>
/// Injects multiple instances of <typeparamref name="T"/> for this instance builder, one per factory function passed to this method.
/// </summary>
/// <typeparam name="T">The type of instance to create.</typeparam>
/// <param name="builder">The instance builder.</param>
/// <param name="factoryFunctions">A series of factory functions.</param>
public static InstanceBuilder WithMany <T>(this IInstanceBuilder builder, params Func <InstanceBuilder, T>[] factoryFunctions)
{
_ = builder ?? throw new ArgumentNullException(nameof(builder));
_ = factoryFunctions ?? throw new ArgumentNullException(nameof(factoryFunctions));
return(builder.With(factoryFunctions.Select(factoryFunction => factoryFunction(builder.Copy())).ToList()));
}
public void Add(IInstanceBuilder instanceBuilder)
{
_defaultInstanceBuilder = instanceBuilder;
}
public void Add(Func<IContext, bool> condition, IInstanceBuilder instanceBuilder)
{
_conditionalPipelineEngines.Add(new Item(condition, instanceBuilder));
}
/// <summary>
/// Injects a single instance of <typeparamref name="T"/> for this instance builder, using the factory function passed to this method.
/// </summary>
/// <typeparam name="T">The type of instance to create.</typeparam>
/// <param name="builder">The instance builder.</param>
/// <param name="factoryFunction">A factory function.</param>
public static InstanceBuilder With <T>(this IInstanceBuilder builder, Func <InstanceBuilder, T> factoryFunction)
{
_ = builder ?? throw new ArgumentNullException(nameof(builder));
_ = factoryFunction ?? throw new ArgumentNullException(nameof(factoryFunction));
return(builder.With(factoryFunction(builder.Copy()) !));
}
internal void SetInstanceBuilder(IInstanceBuilder instanceBuilder)
{
_instanceBuilder = instanceBuilder;
}
public DesignModeValueProviderBuilder(Type targetType, IInstanceBuilder builder)
{
this.targetType = targetType;
this.builder = builder;
}
public void ProcessType(IType type)
{
Type runtimeType = type.RuntimeType;
if (!Enumerable.Any <FeatureProvider>(this.featureManager.CreateFeatureProviders(typeof(DesignModeValueProvider), runtimeType)))
{
return;
}
IInstanceBuilder builder = this.platform.InstanceBuilderFactory.GetBuilder(runtimeType);
if (!builder.BaseType.Equals(runtimeType))
{
++DesignModeValueProviderService.uniqueId;
TypeBuilder typeBuilder = RuntimeGeneratedTypesHelper.RuntimeGeneratedTypesAssembly.DefineType(runtimeType.Name + (object)".CustomDesignTimeProperties" + (string)(object)DesignModeValueProviderService.uniqueId, TypeAttributes.Public);
foreach (PropertyIdentifier propertyIdentifier in this.ValueTranslationService.GetProperties(runtimeType))
{
ReferenceStep referenceStep = type.GetMember(MemberType.Property, propertyIdentifier.Name, MemberAccessTypes.All) as ReferenceStep;
if (referenceStep != null)
{
string str1 = "Runtime" + (object)referenceStep.Name + (string)(object)DesignModeValueProviderService.uniqueId;
MethodBuilder methodBuilder = typeBuilder.DefineMethod("Get" + str1, MethodAttributes.Public | MethodAttributes.Static, referenceStep.PropertyType.RuntimeType, new Type[1]
{
typeof(object)
});
methodBuilder.GetILGenerator().Emit(OpCodes.Ret);
CustomAttributeBuilder customBuilder1 = new CustomAttributeBuilder(typeof(DesignerSerializationVisibilityAttribute).GetConstructor(new Type[1]
{
typeof(DesignerSerializationVisibility)
}), new object[1]
{
(object)DesignerSerializationVisibility.Hidden
});
methodBuilder.SetCustomAttribute(customBuilder1);
typeBuilder.DefineMethod("Set" + str1, MethodAttributes.Public | MethodAttributes.Static, (Type)null, new Type[2]
{
typeof(object),
referenceStep.PropertyType.RuntimeType
}).GetILGenerator().Emit(OpCodes.Ret);
IType type1 = type.PlatformMetadata.ResolveType(PlatformTypes.TypeConverterAttribute);
List <string> results;
if (PlatformNeutralAttributeHelper.TryGetAttributeValues <string>((IEnumerable)referenceStep.GetCustomAttributes(type1.RuntimeType, false), (ITypeId)type1, "ConverterTypeName", out results))
{
foreach (string str2 in results)
{
CustomAttributeBuilder customBuilder2 = new CustomAttributeBuilder(type1.RuntimeType.GetConstructor(new Type[1]
{
typeof(string)
}), new object[1]
{
(object)str2
});
methodBuilder.SetCustomAttribute(customBuilder2);
}
}
typeBuilder.DefineField(str1 + "Property", this.platform.Metadata.ResolveType(PlatformTypes.DependencyProperty).RuntimeType, FieldAttributes.Public | FieldAttributes.Static);
}
}
IType shadowSourceDeclaringType = (IType) new DesignModeValueProviderService.ShadowPropertyType((IPlatformMetadata)this.platform.Metadata, typeBuilder.CreateType());
foreach (PropertyIdentifier propertyIdentifier in this.ValueTranslationService.GetProperties(runtimeType))
{
ReferenceStep referenceStep = type.GetMember(MemberType.Property, propertyIdentifier.Name, MemberAccessTypes.All) as ReferenceStep;
if (referenceStep != null)
{
string propertyName = "Runtime" + (object)referenceStep.Name + (string)(object)DesignModeValueProviderService.uniqueId;
PropertyIdentifier localProperty = propertyIdentifier;
ValueTranslationService valueTranslationService = this.ValueTranslationService;
object obj = this.platform.Metadata.DesignTimeProperties.ExternalRegisterShadow(propertyName, shadowSourceDeclaringType, (IProperty)referenceStep, DesignerSerializationVisibility.Hidden, true, (DesignTimeProperties.PropertyChangeCallback)(o => DesignModeValueProviderService.RunDesignModeValueProvider(o, this.platform, valueTranslationService, type, runtimeType, localProperty, referenceStep, false)));
shadowSourceDeclaringType.RuntimeType.GetField(propertyName + "Property", BindingFlags.Static | BindingFlags.Public).SetValue((object)null, obj);
}
}
DesignModeValueProviderService.DesignModeValueProviderBuilder valueProviderBuilder = new DesignModeValueProviderService.DesignModeValueProviderBuilder(runtimeType, builder);
this.instanceBuilders.Add(valueProviderBuilder);
this.platform.InstanceBuilderFactory.Register((IInstanceBuilder)valueProviderBuilder);
}
else
{
DesignModeValueProviderService.DesignModeValueProviderBuilder valueProviderBuilder = builder as DesignModeValueProviderService.DesignModeValueProviderBuilder;
if (valueProviderBuilder == null)
{
return;
}
valueProviderBuilder.AddReference();
}
}
internal void SetInstanceBuilder(IInstanceBuilder instanceBuilder)
{
_instanceBuilder = instanceBuilder;
}
/// <summary>
/// Injects an instance of type <c>IOptions<TOptions></c> for this instance builder. The options are referenced by name.
/// </summary>
/// <typeparam name="TOptions">The options type.</typeparam>
/// <param name="builder">The instance builder.</param>
/// <param name="name">The name of the options.</param>
public static InstanceBuilder WithNamedOptions <TOptions>(this IInstanceBuilder builder, string name)
where TOptions : class, new()
{
_ = builder ?? throw new ArgumentNullException(nameof(builder));
return(builder.With(new OptionsWrapper <TOptions>(builder.Provider.GetRequiredService <IOptionsMonitor <TOptions> >().Get(name))));
}
