public RequestHeaders(IObjectConverter converter, IObjectResolver resolver, IRequestData requestData)
{
_converter = converter;
_resolver = resolver;
_values = requestData.ValuesFor(RequestDataSource.Header);
}
public static void InjectGameObject(this IObjectResolver resolver, GameObject gameObject)
{
var buffer = UnityEngineObjectListBuffer <MonoBehaviour> .Get();
void InjectGameObjectRecursive(GameObject current)
{
if (current == null)
{
return;
}
buffer.Clear();
current.GetComponents(buffer);
foreach (var monoBehaviour in buffer)
{
resolver.Inject(monoBehaviour);
}
var transform = current.transform;
for (var i = 0; i < transform.childCount; i++)
{
var child = transform.GetChild(i);
InjectGameObjectRecursive(child.gameObject);
}
}
InjectGameObjectRecursive(gameObject);
}
static Exception TryResolveWithType(this IObjectResolver resolver, Type contractType, ParameterSet parameters, out object instance)
{
Requires.NotNull(resolver, "resolver");
Requires.NotNull(contractType, "contractType");
ObjectBuilder builder;
var state = resolver.Kernel.TryGet(contractType, out builder);
switch (state)
{
case ObjectBuilderState.Normal:
instance = resolver.Resolve(builder, parameters);
return(null);
case ObjectBuilderState.Invalid:
instance = null;
return(new ObjectBuilderNotFoundException(GetObjectBuilderNotFoundErrorMessage(contractType)));
case ObjectBuilderState.Unregistered:
builder = resolver.Kernel.AutoObjectRegistrar.GetObjectBuilder(contractType);
if (builder == null)
{
instance = null;
return(new ObjectBuilderNotFoundException(GetObjectBuilderNotFoundErrorMessage(contractType)));
}
instance = resolver.Resolve(builder, parameters);
return(null);
default:
throw new ImpossibleException();
}
}
public object CreateInstance(IObjectResolver resolver, IReadOnlyList <IInjectParameter> parameters)
{
var parameterInfos = injectTypeInfo.InjectConstructor.ParameterInfos;
var parameterValues = CappedArrayPool <object> .Shared8Limit.Rent(parameterInfos.Length);
try
{
for (var i = 0; i < parameterInfos.Length; i++)
{
var parameterInfo = parameterInfos[i];
try
{
parameterValues[i] = resolver.ResolveOrParameter(
parameterInfo.ParameterType,
parameterInfo.Name,
parameters);
}
catch (VContainerException ex)
{
throw new VContainerException(parameterInfo.ParameterType, $"Failed to resolve {injectTypeInfo.Type} : {ex.Message}");
}
}
var instance = injectTypeInfo.InjectConstructor.ConstructorInfo.Invoke(parameterValues);
Inject(instance, resolver, parameters);
return(instance);
}
finally
{
CappedArrayPool <object> .Shared8Limit.Return(parameterValues);
}
}
/// <summary>
/// Tries to retrieve all service associated with the <paramref name="contractType"/> and use those components
/// to build a object instances.
/// </summary>
/// <param name="resolver">The resolver.</param>
/// <param name="contractType">Type of the contract.</param>
/// <param name="instances">The instances.</param>
/// <returns></returns>
public static Exception TryResolveAll(this IObjectResolver resolver, Type contractType, out IList <object> instances)
{
Requires.NotNull(resolver, "resolver");
Requires.NotNull(contractType, "contractType");
IEnumerable <ObjectBuilder> builders;
if (!resolver.Kernel.TryGet(contractType, out builders))
{
instances = null;
return(new ObjectBuilderNotFoundException(GetObjectBuilderNotFoundErrorMessage(contractType)));
}
var resolvedInstances = new List <object>();
foreach (var builder in builders)
{
object instance;
var ex = TryResolve(resolver, builder, null, out instance);
if (ex != null)
{
instances = null;
return(ex);
}
resolvedInstances.Add(instance);
}
instances = resolvedInstances;
return(null);
}
public static T Instantiate <T>(this IObjectResolver resolver, T prefab) where T : UnityEngine.Object
{
var instance = UnityEngine.Object.Instantiate(prefab);
InjectUnityEngineObject(resolver, instance);
return(instance);
}
public RequestHeaders(IObjectConverter converter, IObjectResolver resolver, ICurrentHttpRequest request)
{
_converter = converter;
_resolver = resolver;
_values = new HeaderValueSource(request);
}
public XDbProvider(string redisConnectionString, ICosmosDb cosmosCosmosDb)
{
DocumentCosmosDb = cosmosCosmosDb;
Connect(redisConnectionString);
Resolver = new DocDbRedisResolver(this);
}
public MessagePipeDemo(IPublisher <int> publisher, ISubscriber <int> subscriber, IObjectResolver resolver)
{
this.publisher = publisher;
this.subscriber = subscriber;
GlobalMessagePipe.SetProvider(resolver.AsServiceProvider());
}
internal ScopedContainerBuilder(
IObjectResolver root,
IScopedObjectResolver parent)
{
this.root = root;
this.parent = parent;
}
public ObjectBlockReader(IObjectBlockParser parser, IObjectResolver resolver, IServiceLocator services, BlockRegistry blocks)
{
_parser = parser;
_resolver = resolver;
_services = services;
_blocks = blocks;
}
public object SpawnInstance(IObjectResolver resolver)
{
Component component;
var parent = destination.GetParent();
if (destination.Prefab != null)
{
if (destination.Prefab.gameObject.activeSelf)
{
destination.Prefab.gameObject.SetActive(false);
}
component = UnityEngine.Object.Instantiate(destination.Prefab, parent);
}
else
{
var name = string.IsNullOrEmpty(destination.NewGameObjectName)
? ImplementationType.Name
: destination.NewGameObjectName;
var gameObject = new GameObject(name);
gameObject.SetActive(false);
if (parent != null)
{
gameObject.transform.SetParent(parent);
}
component = gameObject.AddComponent(ImplementationType);
}
injector.Inject(component, resolver, Parameters);
component.gameObject.SetActive(true);
return(component);
}
public static T Instantiate <T>(this IObjectResolver resolver, T prefab, Transform parent, bool worldPositionStays = false)
where T : UnityEngine.Object
{
var instance = UnityEngine.Object.Instantiate(prefab, parent, worldPositionStays);
InjectUnityEngineObject(resolver, instance);
return(instance);
}
public void Configure(IQueryControllerConfiguration config)
{
_reader = config.Reader;
_storage = config.Storage;
_readerParameters = config.ReaderParameters;
_resolver = config.Resolver;
_expressions = config.ExpressionEngine;
}
public static T Bind <T>(this IObjectResolver resolver, IDictionary <string, object> dictionary)
{
var source = new SettingsData(dictionary);
var result = resolver.BindModel(typeof(T), source);
result.AssertNoProblems(typeof(T));
return((T)result.Value);
}
public object SpawnInstance(IObjectResolver resolver)
{
if (specificInstance != null)
{
injector.Inject(specificInstance, resolver, parameters);
return(specificInstance);
}
return(injector.CreateInstance(resolver, parameters));
}
public SqlTokenizer(TextReader reader, IObjectResolver resolver)
{
_resolver = resolver;
_operators = _resolver.GetOperators().ToHashSet();
_reader = reader;
NextChar();
NextToken();
}
private void RegisterInterface(Type interfaceType, IObjectResolver objectResolver)
{
if (!_interfaces.ContainsKey(interfaceType))
{
_interfaces.Add(interfaceType, new List <IObjectResolver>());
}
_interfaces[interfaceType].Add(objectResolver);
}
public static T Resolve <T>(this IObjectResolver resolver, IObjectObserver <T> observer)
{
var builder = observer.ObjectBuilder;
if (builder == null)
{
throw new ObsoleteObjectBuilderException(GetObsoleteObjectBuilderErrorMessage(observer.ContractType));
}
return(resolver.Resolve(builder, null));
}
public object GetLogger(IObjectResolver objectResolver, Type declaringType)
{
// method is used to resolve logger instances azure function implementations with [inject] attribute
return(GetLogger(declaringType, delegate
{
var factory = objectResolver.Resolve <ILoggerFactory>();
var loggerName = GetLoggerName(declaringType);
return factory.CreateLogger(loggerName);
}));
}
/// <summary>
/// 设置IObjectResolver的实例，允许在框架外部控制对象的实例化过程。
/// </summary>
/// <param name="objectResolver"></param>
public static void SetResolver(IObjectResolver objectResolver)
{
if (objectResolver == null)
{
throw new ArgumentNullException("objectResolver");
}
// 这个方法通常会在程序初始化时调用，所以暂不考虑线程安全问题。
s_objectResolver = objectResolver;
}
/// <summary>
/// 初始化 <see cref="RemoteObjectContext" /> 类。
/// </summary>
static RemoteObjectContext()
{
var resolver = new DefaultObjectResolver();
resolver.RegisterGenericTypeDefinition(typeof(IQueryProvider <>), typeof(RestQueryProvider <>));
resolver.Register <IExpressionProcessor>(p => new ExpressionProcessor());
resolver.Register <IExpressionWriter>(p => new ExpressionWriter());
DefaultObjectResolver = resolver;
}
public void InstantiateIn(IObjectResolver objectResolver)
{
if (objectResolver is StructureMapObjectResolver)
{
this.InstantiateInStructureMap();
}
else
{
throw new ArgumentException("Unsupported type of object resolver is provided", "objectResolver");
}
}
public JavaScriptJsonReader(IStreamingData data
, IObjectResolver objectResolver,
IRequestData requestData,
IServiceLocator serviceLocator
)
{
_data = data;
_objectResolver = objectResolver;
_requestData = requestData;
_serviceLocator = serviceLocator;
}
void InjectMethods(object obj, IObjectResolver resolver, IReadOnlyList <IInjectParameter> parameters)
{
if (injectTypeInfo.InjectMethods == null)
{
return;
}
foreach (var method in injectTypeInfo.InjectMethods)
{
var parameterInfos = method.ParameterInfos;
var parameterValues = CappedArrayPool <object> .Shared8Limit.Rent(parameterInfos.Length);
try
{
for (var i = 0; i < parameterInfos.Length; i++)
{
var set = false;
var parameterInfo = parameterInfos[i];
if (parameters != null)
{
foreach (var x in parameters)
{
if (x.Match(parameterInfo))
{
parameterValues[i] = x.Value;
set = true;
break;
}
}
}
if (set)
{
continue;
}
var parameterType = parameterInfo.ParameterType;
try
{
parameterValues[i] = resolver.Resolve(parameterType);
}
catch (VContainerException ex)
{
throw new VContainerException(parameterType, $"Failed to resolve {injectTypeInfo.Type.FullName} : {ex.Message}");
}
}
method.Invoke(obj, parameterValues);
}
finally
{
CappedArrayPool <object> .Shared8Limit.Return(parameterValues);
}
}
}
static void InjectUnityEngineObject <T>(IObjectResolver resolver, T instance) where T : UnityEngine.Object
{
if (instance is GameObject gameObject)
{
resolver.InjectGameObject(gameObject);
}
else
{
resolver.Inject(instance);
}
}
public TypeDefinition(Type type, int saveId, IObjectResolver objectResolver)
: base(type, (SaveId) new TypeSaveId(saveId))
{
this._isClass = this.Type.IsClass;
this._errors = new List <string>();
this._properties = new Dictionary <MemberTypeId, PropertyDefinition>();
this._fields = new Dictionary <MemberTypeId, FieldDefinition>();
this.MemberDefinitions = new List <MemberDefinition>();
this.CustomFields = new List <CustomField>();
this._initializationCallbacks = new List <MethodInfo>();
this.ObjectResolver = objectResolver;
}
public static T Instantiate <T>(
this IObjectResolver resolver,
T prefab,
Vector3 position,
Quaternion rotation)
where T : UnityEngine.Object
{
var instance = UnityEngine.Object.Instantiate(prefab, position, rotation);
InjectUnityEngineObject(resolver, instance);
return(instance);
}
public object SpawnInstance(IObjectResolver resolver)
{
if (destination.Find)
{
return(FindComponent(resolver));
}
if (destination.Prefab != null)
{
return(InstantiatePrefab(resolver));
}
return(InstantiateNewGameObject(resolver));
}
protected void EmitCallbacks(IObjectResolver container)
{
if (buildCallbacks == null)
{
return;
}
foreach (var callback in buildCallbacks)
{
callback.Invoke(container);
}
}
public void SetUp()
{
theObjectResolver = ObjectResolver.Basic();
theResolver = new ValidationTargetResolver(theObjectResolver);
}
public override void InitializeForView(IObjectResolver resolver)
{
Recipe = resolver.Resolve<IRecipeProvider>().Get(RecipeId);
}
public ValidationTargetResolver(IObjectResolver resolver)
{
_resolver = resolver;
}
public RecordingObjectResolver(IDebugReport report, ObjectResolver resolver)
{
_report = report;
_resolver = resolver;
}
public void Resolve(IObjectResolver aHandler)
{
aHandler.Resolve(this);
}
