public ResponseConnector(string datafile, string prefix, string keys, ResolveDelegate resolver)
{
_prefix = prefix;
if (keys == null || keys == string.Empty)
{
return;
}
XmlDocument doc = new XmlDocument();
doc.Load(GetResource(datafile));
string[] parts = keys.Split(';');
foreach (string part in parts)
{
XmlNodeList nodes = doc.DocumentElement.SelectNodes("Test[@name='" + part + "']");
if (nodes.Count == 0)
{
continue;
}
XmlNode node = nodes[0];
XmlNodeList responses = node.SelectNodes("Response");
foreach (XmlElement response in responses)
{
_data[response.GetAttribute("path")] = resolver(response);
}
}
}
internal static byte[] ReadBytes(JsonReader reader, JsonDeserializeHandler handler)
{
char c = reader.BeforAnnotation();
if (c == 'n' && reader.StrCompair("ull"))
{
return(null);
}
else if (c == '[')
{
reader.RollbackChar();
if (byteArray == null)
{
lock (ObjLock)
{
if (byteArray == null)
{
byteArray = BuildFactory.Build <byte[]>(DeserializeBuildTypeEnum.Array, typeof(byte[]));
}
}
}
return(byteArray(reader, handler));
}
else
{
reader.RollbackChar();
return(Convert.FromBase64String(PrimitiveResolve.ReadEscapeString(reader, handler)));
}
}
/// <summary>
/// Ends an asynchronous request for DNS information.
/// </summary>
/// <param name="AsyncResult">
/// An System.IAsyncResult instance that is returned by a call to the System.Net.Dns.BeginResolve(System.String,System.AsyncCallback,System.Object)
/// method.
/// </param>
/// <returns>An System.Net.IPHostEntry object that contains DNS information about a host.</returns>
public IPHostEntry EndResolve(IAsyncResult AsyncResult)
{
AsyncResult aResult = (AsyncResult)AsyncResult;
ResolveDelegate g = (ResolveDelegate)aResult.AsyncDelegate;
return(g.EndInvoke(AsyncResult));
}
public object?Resolve(Type type, string?name, ResolveDelegate <PipelineContext> pipeline)
{
var thisContext = this;
unsafe
{
// Setup Context
var context = new PipelineContext
{
ContainerContext = pipeline.Target is ContainerControlledLifetimeManager containerControlled
? (ContainerContext)containerControlled.Scope
: ContainerContext,
List = List,
Type = type,
Name = name,
Overrides = Overrides,
DeclaringType = Type,
#if !NET40
Parent = new IntPtr(Unsafe.AsPointer(ref thisContext))
#endif
};
var manager = pipeline.Target as LifetimeManager;
var value = pipeline(ref context);
manager?.SetValue(value, LifetimeContainer);
return(value);
}
#endregion
}
}
private ResolveDelegate DirectCycleResolveInterceptor(ResolveDelegate next)
{
return(async(originInstance, identifier, context, frame) =>
{
// Direct cycle resolve case.
if (originInstance.ProviderNode.Identifier == identifier)
{
IxResolvePath resolvePath;
// Using parent replacement provider, if it exists.
if (originInstance.ProviderNode.ParentReplacementNodes.TryGetValue(identifier, out resolvePath))
{
return await resolvePath.Target.ScopeBinder(
originInstance,
resolvePath,
context,
frame,
async (parentInstance, provider, c) =>
{
// While we have temporary lock, we needs to put permanent lock.
IIxInstanceLock resolvedInstanceTempLock =
await provider.GetInstance(parentInstance, identifier, c, frame);
return resolvedInstanceTempLock;
});
}
}
return await next(originInstance, identifier, context, frame);
});
}
/// <summary>
/// 新增容器中的外派方法，外派方法可被容器外部通过 Delive 方法调用
/// </summary>
public void Add <InterfaceT>(ResolveDelegate <InterfaceT> target, bool onlyOnce = false)
{
int statu = 0;
MethodInfo method = target.Method;
object[] attributes = method.GetCustomAttributes(callableAttrType, false);
int max = attributes.Length;
string resolverName, alias;
CallableAttribute attribute;
IResolvable resolvable;
for (int i = 0; i < max; i++)
{
attribute = attributes[i] as CallableAttribute;
resolverName = attribute.ResolverName;
resolverName = string.IsNullOrEmpty(resolverName) ? method.Name : resolverName;
alias = attribute.Alias;
resolvable = ServersHolder.GetResolvable(ref alias, out statu);
if (statu == 0)
{
"error".Log(resolvable == default, "Resolvable is null, alias is " + alias);
resolvable.SetResolver(resolverName, target, out statu, onlyOnce);
}
}
}
public BitVector32Matcher(int lowerLimit,
int upperLimit,
Func <int, int, uint> queryFn,
ResolveDelegate resultFn,
Func <int, int, int, TContext> contextFn = null)
{
if (limit < 0 || limit >= 32)
{
throw new ArgumentOutOfRangeException();
}
if (resultFn == null)
{
throw new ArgumentNullException(nameof(resultFn));
}
this.queryFn = queryFn ?? throw new ArgumentNullException(nameof(queryFn));
this.contextFn = contextFn ?? DefaultContext;
this.lowerLimit = lowerLimit;
this.limit = upperLimit;
tiles = new TRenderTile[limit + 1];
tileExists = new bool[limit + 1];
for (int i = lowerLimit; i <= limit; i += 1)
{
tileExists[i] = resultFn(i, out tiles[i]);
}
}
private ResolveDelegate StdResolveInterceptor(ResolveDelegate next)
{
return(async(originInstance, identifier, context, frame) =>
{
IxResolvePath resolvePath;
if (!originInstance.ProviderNode.VisibleNodes.TryGetValue(identifier, out resolvePath))
{
return await next(originInstance, identifier, context, frame);
}
return await resolvePath.Target.ScopeBinder(
originInstance,
resolvePath,
context,
frame,
async (parentInstance, provider, c) =>
{
// While we have temporary lock, we needs to put permanent lock.
IIxInstanceLock resolvedInstanceTempLock =
await provider.GetInstance(parentInstance, identifier, c, frame);
return resolvedInstanceTempLock;
});
});
}
public static P DeliveParam <S, P>(this string serverName, string resolverName, string alias, ResolveDelegate <IParamNotice <P> > newResolver = default, bool isReregister = false) where S : IServer
{
S server = serverName.GetServer <S>();
IParamNotice <P> notice;
if (newResolver != default)
{
if (isReregister)
{
ResolveDelegate <IParamNotice <P> > raw = server.Reregister(newResolver, alias);
notice = server.Delive <IParamNotice <P> >(resolverName, alias);
server.Reregister(raw, alias);
}
else
{
notice = server.Delive <IParamNotice <P> >(resolverName, alias);
newResolver.Invoke(ref notice);
}
}
else
{
notice = server.Delive <IParamNotice <P> >(resolverName, alias);
}
return(notice.ParamValue);
}
private ResolveDelegate ResolverResolveInterceptor(ResolveDelegate next)
{
return(async(originInstance, identifier, context, frame) =>
{
if (identifier.Type != typeof(IIxResolver))
{
return await next(originInstance, identifier, context, frame);
}
if (identifier.Name != null)
{
throw new InvalidOperationException("IIxResolver cannot be queried with name.");
}
if (originInstance.Resolver == null)
{
lock (originInstance)
{
if (originInstance.Resolver == null)
{
originInstance.Resolver = new IxResolver(this, originInstance, context, frame);
}
}
}
return new IxInstanceNoLock((IxResolver)originInstance.Resolver);
});
}
public void SetResolver <InterfaceT>(string resolverName, ResolveDelegate <InterfaceT> resolveDelgate, out int statu, bool onlyOnce = false, bool isMakeResolver = false)
{
statu = 0;
ResolverHandler <InterfaceT> handler;
bool hasRef = mResolverIDMapper.ContainsKey(ref resolverName, out int id);
if (hasRef)
{
statu = 1;
if (isMakeResolver)
{
handler = mResolvers[id] as ResolverHandler <InterfaceT>;
handler.AddDelegate(resolveDelgate);
}
}
else
{
if (isMakeResolver)
{
statu = 2;
return;
}
id = mResolverIDMapper.Add(resolverName, out _);
handler = new ResolverHandler <InterfaceT>();
handler.SetDelegate(resolveDelgate);
handler.OnlyOnce = onlyOnce;
handler.SetID(id);
mResolvers[id] = handler;
}
}
public void AddDelegate(ResolveDelegate <InterfaceT> target)
{
ResolveDelegate <InterfaceT> cur = default;
cur += target;
cur += DelegateTarget;
DelegateTarget = cur;
}
public ResolveContext ChangeInitialContext(DependencyInjectionContainer container, DependencyOverrides dependencyOverrides)
{
_registration = null;
_createInstance = null;
_perResolveInstances?.Clear();
_container = container.MustNotBeNull(nameof(container));
_dependencyOverrides = dependencyOverrides;
return(this);
}
/// <summary>
/// Initializes a new instance of the <see cref="Resolutions" /> class.
/// </summary>
/// <param name="parent">The parent.</param>
/// <param name="resolvable">The resolvable.</param>
public Resolutions(
[CanBeNull] Resolutions parent,
[NotNull] IResolvable resolvable)
: base(resolvable.IsCaseSensitive, resolvable.ResolveOuterTags, resolvable.ResolveControls)
{
if (resolvable == null) throw new ArgumentNullException("resolvable");
Parent = parent;
_resolver = resolvable.Resolve;
}
public static P Resolve <P>(this string serverName, string alias, ResolveDelegate <P> customResolver = default, string resolverName = "")
{
IServer server = serverName.GetServer();
UnityEngine.Debug.Log(server);
P result = server.Resolve(alias, resolverName, customResolver);
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="Resolvable"/> class.
/// </summary>
/// <param name="resolver">The resolver.</param>
/// <param name="isCaseSensitive">if set to <see langword="true"/> then tags are case sensitive.</param>
/// <param name="resolveOuterTags">if set to <see langword="true"/> outer tags should be resolved automatically in formats.</param>
/// <param name="resolveControls">if set to <see langword="true" /> then controls will passed to the resolvable.</param>
public FuncResolvable(
[NotNull] ResolveDelegate resolver,
bool isCaseSensitive = false,
bool resolveOuterTags = true,
bool resolveControls = false)
: base(isCaseSensitive, resolveOuterTags, resolveControls)
{
if (resolver == null) throw new ArgumentNullException(nameof(resolver));
_resolver = resolver;
}
public void RevokeResolver <InterfaceT>(string resolverName, ResolveDelegate <InterfaceT> resolveDelgate)
{
ResolverHandler <InterfaceT> handler;
bool hasRef = mResolverIDMapper.ContainsKey(ref resolverName, out int id);
if (hasRef)
{
handler = mResolvers[id] as ResolverHandler <InterfaceT>;
handler.RemoveDelegate(resolveDelgate);
}
}
/// <summary>
/// 以指定的接口为参数调用容器暴露于外界的外派方法
/// </summary>
public InterfaceT Delive <InterfaceT>(string resolverName, string alias, ResolveDelegate <InterfaceT> customResolver = default, bool isMakeResolver = false)
{
if (isMakeResolver)
{
MakeResolver(alias, resolverName, customResolver);
return(Resolve <InterfaceT>(alias, resolverName));
}
else
{
return(Resolve(alias, resolverName, customResolver));
}
}
public int MakeResolver <InterfaceT>(string alias, string resolverName, ResolveDelegate <InterfaceT> target)
{
int statu = 0;
IResolvable resolvable = ServersHolder.GetResolvable(ref alias, out statu);
if (statu == 0)
{
Tester.Instance.Log(TesterBaseApp.Instance, TesterBaseApp.LOG, resolvable == default, "error: Resolvable is null when MakeResolver, alias is " + alias);
resolvable.SetResolver(resolverName, target, out statu, false, true);
}
return(statu);
}
/// <summary>
/// 撤销已定义在解析器中的一个解析器函数
/// </summary>
public int RevokeResolver <InterfaceT>(string alias, string resolverName, ResolveDelegate <InterfaceT> target)
{
int statu = 0;
IResolvable resolvable = ServersHolder.GetResolvable(ref alias, out statu);
if (statu == 0)
{
"error".Log(resolvable == default, "Resolvable is null when MakeResolver, alias is " + alias);
resolvable.RevokeResolver(resolverName, target);
}
return(statu);
}
/// <summary>
/// Initializes a new instance of the <see cref="Resolutions" /> class.
/// </summary>
/// <param name="parent">The parent.</param>
/// <param name="resolvable">The resolvable.</param>
public Resolutions(
[CanBeNull] Resolutions parent,
[NotNull] IResolvable resolvable)
: base(resolvable.IsCaseSensitive, resolvable.ResolveOuterTags, resolvable.ResolveControls)
{
if (resolvable == null)
{
throw new ArgumentNullException("resolvable");
}
Parent = parent;
_resolver = resolvable.Resolve;
}
public override ResolveDelegate <PipelineContext>?Build(ref PipelineBuilder builder)
{
ResolveDelegate <PipelineContext>?pipeline = builder.Pipeline();
Debug.Assert(null != pipeline);
return(builder.LifetimeManager switch
{
SynchronizedLifetimeManager manager => SynchronizedLifetimeResolution(manager, pipeline),
PerResolveLifetimeManager _ => PerResolveLifetimeResolution(pipeline),
_ => pipeline
});
/// <summary>
/// 重新注册解析器的解析器函数，并返回旧的解析器函数
/// </summary>
public ResolveDelegate <InterfaceT> Reregister <InterfaceT>(ResolveDelegate <InterfaceT> target, string alias)
{
ResolveDelegate <InterfaceT> raw = default;
IResolvable resolvable = ServersHolder.GetResolvable(ref alias, out int resultError);
if (resultError == 0)
{
IResolverCacher <InterfaceT> resolverHandler = resolvable.GetResolver <InterfaceT>(Resolvable.RESOLVER_INIT, out _) as IResolverCacher <InterfaceT>;
raw = resolverHandler.DelegateTarget;
resolverHandler.SetDelegate(target);
}
return(raw);
}
/// <summary>
/// Initializes a new instance of the <see cref="Resolvable"/> class.
/// </summary>
/// <param name="resolver">The resolver.</param>
/// <param name="isCaseSensitive">if set to <see langword="true"/> then tags are case sensitive.</param>
/// <param name="resolveOuterTags">if set to <see langword="true"/> outer tags should be resolved automatically in formats.</param>
/// <param name="resolveControls">if set to <see langword="true" /> then controls will passed to the resolvable.</param>
public FuncResolvable(
[NotNull] ResolveDelegate resolver,
bool isCaseSensitive = false,
bool resolveOuterTags = true,
bool resolveControls = false)
: base(isCaseSensitive, resolveOuterTags, resolveControls)
{
if (resolver == null)
{
throw new ArgumentNullException(nameof(resolver));
}
_resolver = resolver;
}
internal ResolveDelegate <BuilderContext> ResolvingFactory(ref BuilderContext context)
{
ResolveDelegate <BuilderContext> seed = null;
var type = context.Type;
var registration = context.Registration;
foreach (var processor in _processorsChain)
{
seed = processor.GetResolver(type, registration, seed);
}
return(seed);
}
/// <summary>
/// Initializes a new instance of the <see cref="Resolutions" /> class.
/// </summary>
/// <param name="parent">The parent.</param>
/// <param name="resolver">The resolver.</param>
/// <param name="isCaseSensitive">if set to <see langword="true" /> then tags are case sensitive.</param>
/// <param name="resolveOuterTags">if set to <see langword="true" /> outer tags should be resolved automatically in formats.</param>
/// <param name="resolveControls">if set to <see langword="true" /> then controls will passed to the resolvable.</param>
public Resolutions(
[CanBeNull] Resolutions parent,
[NotNull] ResolveDelegate resolver,
bool isCaseSensitive,
bool resolveOuterTags,
bool resolveControls)
: base(isCaseSensitive, resolveOuterTags, resolveControls)
{
if (resolver == null)
{
throw new ArgumentNullException("resolver");
}
Parent = parent;
_resolver = resolver;
}
private ResolveDelegate ResolveContextResolveInterceptor(ResolveDelegate next)
{
return(async(originInstance, identifier, context, frame) =>
{
IIxInstanceLock instance =
_argumentProvider.TryGetInstance(identifier, context);
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
if (instance == null)
{
return await next(originInstance, identifier, context, frame);
}
return instance;
});
}
private ResolveDelegate SelfResolveInterceptor(ResolveDelegate next)
{
return(async(originInstance, identifier, context, frame) =>
{
if (identifier.Type != typeof(IIxSelf))
{
return await next(originInstance, identifier, context, frame);
}
if (identifier.Name != null)
{
throw new InvalidOperationException("IIxSelf cannot be queried with name.");
}
return new IxInstanceNoLock(new IxSelfInstance(_rootScope, (IIxSelf)originInstance));
});
}
private void AsyncCustomCallbackMethod(IAsyncResult ar)
{
// If any exceptions are raised by the called method, they won't
// be thrown until the results are obtained.
try
{
// Unwrap the delegate so that the EndInvoke method can be called.
ResolveDelegate synchMethod = (ResolveDelegate)((System.Runtime.Remoting.Messaging.AsyncResult)ar).AsyncDelegate;
IPHostEntry hostInformation = synchMethod.EndInvoke(ar);
DisplayResults(hostInformation);
}
catch (System.Net.Sockets.SocketException)
{
Console.WriteLine("Bad host name (SocketException)");
resultsDisplayed = true;
}
}
private static ResolveDelegate <BuilderContext> OptimizingFactory(ref BuilderContext context)
{
var counter = 3;
var type = context.Type;
var registration = context.Registration;
ResolveDelegate <BuilderContext> seed = null;
var chain = ((UnityContainer)context.Container)._processorsChain;
// Generate build chain
foreach (var processor in chain)
{
seed = processor.GetResolver(type, registration, seed);
}
// Return delegate
return((ref BuilderContext c) =>
{
// Check if optimization is required
if (0 == Interlocked.Decrement(ref counter))
{
Task.Factory.StartNew(() => {
// Compile build plan on worker thread
var expressions = new List <Expression>();
foreach (var processor in chain)
{
foreach (var step in processor.GetExpressions(type, registration))
{
expressions.Add(step);
}
}
expressions.Add(BuilderContextExpression.Existing);
var lambda = Expression.Lambda <ResolveDelegate <BuilderContext> >(
Expression.Block(expressions), BuilderContextExpression.Context);
// Replace this build plan with compiled
registration.Set(typeof(ResolveDelegate <BuilderContext>), lambda.Compile());
});
}
return seed?.Invoke(ref c);
});
}
private ResolveDelegate <PipelineContext> PipelineFromRegistrationOptimized(Type?type, ExplicitRegistration registration, int position)
{
Debug.Assert(null != _registry);
Debug.Assert(null != type);
var manager = registration.LifetimeManager;
ResolveDelegate <PipelineContext>?pipeline = null;
lock (_syncRegistry)
{
ref var entry = ref _registry.Entries[position];
if (ReferenceEquals(entry.Registration, registration) && null == entry.Pipeline)
{
entry.Pipeline = manager.Pipeline;
manager.PipelineDelegate = (ResolveDelegate <PipelineContext>)SpinWait;
}
}
/// <summary>
/// 注册一个新的解析器
/// </summary>
/// <typeparam name="InterfaceT">要解析对象的接口</typeparam>
/// <param name="target">解析器函数</param>
/// <param name="factory">解析对象的对象池或工厂对象</param>
/// <returns></returns>
public int Register <InterfaceT>(ResolveDelegate <InterfaceT> target, params IPoolBase[] factory)
{
IResolvable[] list = ServersHolder.SetResolvable(target, out int statu);
int max = list != default ? list.Length : 0;
if (max > 0)
{
IResolvable resolvable;
IPoolBase factoryItem;
int factoryCount = factory != default ? factory.Length : 0;
for (int i = 0; i < max; i++)
{
factoryItem = factoryCount > i ? factory[i] : default;
resolvable = list[i];
resolvable.InitResolver <InterfaceT>(ServersHolder, factoryItem);
}
}
return(statu);
}
public ResponseConnector(string datafile, string prefix, string keys, ResolveDelegate resolver)
{
_prefix = prefix;
if (keys == null || keys == string.Empty)
return;
XmlDocument doc = new XmlDocument();
doc.Load(datafile);
string[] parts = keys.Split(';');
foreach (string part in parts)
{
XmlNodeList nodes = doc.DocumentElement.SelectNodes("Test[@name='" + part + "']");
if (nodes.Count == 0)
continue;
XmlNode node = nodes[0];
XmlNodeList responses = node.SelectNodes("Response");
foreach (XmlElement response in responses)
_data[response.GetAttribute("path")] = resolver(response);
}
}
/// <summary>
/// Begins an asynchronous request to resolve a DNS host name or IP address to
/// an System.Net.IPAddress instance.
/// </summary>
/// <param name="hostName">The DNS name of the host.</param>
/// <param name="requestCallback">
/// An System.AsyncCallback delegate that references the method to invoke when
/// the operation is complete.
/// </param>
/// <param name="stateObject">
/// A user-defined object that contains information about the operation. This
/// object is passed to the requestCallback delegate when the operation is complete.
/// </param>
/// <returns>An System.IAsyncResult instance that references the asynchronous request.</returns>
public IAsyncResult BeginResolve(string hostName, AsyncCallback requestCallback, object stateObject)
{
ResolveDelegate g = new ResolveDelegate(Resolve);
return g.BeginInvoke(hostName, requestCallback, stateObject);
}
/// <summary>
/// Initializes a new instance of the <see cref="Resolutions" /> class.
/// </summary>
/// <param name="parent">The parent.</param>
/// <param name="resolver">The resolver.</param>
/// <param name="isCaseSensitive">if set to <see langword="true" /> then tags are case sensitive.</param>
/// <param name="resolveOuterTags">if set to <see langword="true" /> outer tags should be resolved automatically in formats.</param>
/// <param name="resolveControls">if set to <see langword="true" /> then controls will passed to the resolvable.</param>
public Resolutions(
[CanBeNull] Resolutions parent,
[NotNull] ResolveDelegate resolver,
bool isCaseSensitive,
bool resolveOuterTags,
bool resolveControls)
: base(isCaseSensitive, resolveOuterTags, resolveControls)
{
if (resolver == null) throw new ArgumentNullException("resolver");
Parent = parent;
_resolver = resolver;
}
