public MethodBase Resolve(MethodReference methodReference, GenericBindingContext bindingContext)
{
Type declaringType = _typeResolver.Resolve(methodReference.DeclaringType);
BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.ExactBinding;
flags |= methodReference.HasThis ? BindingFlags.Instance : BindingFlags.Static;
IEnumerable <MethodBase> candidates = IsConstructor(methodReference.Name)
? (IEnumerable <MethodBase>)declaringType.GetConstructors(flags)
: declaringType.GetMethods(flags);
MethodBase result;
if (methodReference.IsGenericInstance)
{
MethodBase genericMethod = Resolve(methodReference.Resolve(), bindingContext);
result = BindGenericArguments(methodReference, genericMethod);
}
else
{
TypeReference[] parameterTypes = methodReference.Parameters.Select(parameter =>
parameter.ParameterType).ToArray();
result = FindMethod(candidates, methodReference.Name, parameterTypes,
methodReference.HasGenericParameters, bindingContext);
}
return(result);
}
public ReviewRule EvaluateRule <Model, Context>(
RuleMetadata metadata, Model model, Context context)
{
var rule = typeResolver.Resolve <IRule <Model, Context> >(metadata.RuleType);
return(new ReviewRule()
{
BusinessId = metadata.BusinessId,
Message = rule.Message,
IsSatisfied = rule.IsSatisfiedBy(model, context)
});
}
public object?Resolve(Type?type)
{
if (type == null)
{
throw new CommandRuntimeException("Cannot resolve null type.");
}
try
{
var obj = _resolver?.Resolve(type);
if (obj != null)
{
return(obj);
}
// Fall back to use the activator.
return(Activator.CreateInstance(type));
}
catch (CommandAppException)
{
throw;
}
catch (Exception ex)
{
throw CommandRuntimeException.CouldNotResolveType(type, ex);
}
}
public IMessage Parse(ConsumeResult <Guid, byte[]> consumeResult)
{
if (consumeResult is null)
{
throw new ArgumentNullException(nameof(consumeResult));
}
if (consumeResult.Message?.Headers is null)
{
throw new ArgumentNullException(nameof(consumeResult), "message headers are missing");
}
var messageTypeHeader = consumeResult.Message.Headers.FirstOrDefault(h => h.Key == HeaderNames.MessageType);
if (messageTypeHeader is null)
{
throw new ArgumentException("invalid message type");
}
var messageTypeName = Encoding.UTF8.GetString(messageTypeHeader.GetValueBytes());
var messageType = _typeResolver.Resolve(messageTypeName);
var decodedObj = _serializer.Deserialize(consumeResult.Message.Value, messageType);
if (decodedObj is not IMessage message)
{
throw new ArgumentException($"message has the wrong type: '{messageTypeName}'");
}
return(message);
}
public object Resolve(Type type)
{
try
{
if (_resolver != null)
{
var obj = _resolver.Resolve(type);
if (obj == null)
{
throw RuntimeException.CouldNotResolveType(type);
}
return(obj);
}
// Fall back to use the activator.
return(Activator.CreateInstance(type));
}
catch (CommandAppException)
{
throw;
}
catch (Exception ex)
{
throw RuntimeException.CouldNotResolveType(type, ex);
}
}
public CommandResult Handle(object command)
{
var handlerType = typeof(ICommandHandler <>).MakeGenericType(command.GetType());
dynamic handler = _typeResolver.Resolve(handlerType);
return(handler.Handle((dynamic)command));
}
private Dictionary <VariableReference, LocalBuilder> AddVariables(IILGenerator generator,
IEnumerable <VariableReference> variables)
{
return(variables.ToDictionary(
variable => variable,
variable => generator.DeclareLocal(_typeResolver.Resolve(variable.VariableType))));
}
public void ShowSingleton <T>(object identifier, ITypeResolver resolvr)
where T : WorkspaceVmBase
{
T wrkspce = (T)MainTabs.Where(x => x is T)
.FirstOrDefault(x => x.GetHashCode()
== x.HashCodeFor(identifier));
if (wrkspce == null)
{
try {
wrkspce = ForwardLogs(resolvr.Resolve <T>());
}
catch (Exception ex)
{
Error_n("Error in ShowSingleton<T>()",
$"Unable to create instance of ‹{typeof(T).Name}›."
+ L.F + ex.Details(false, false));
return;
}
MainTabs.Add(wrkspce);
wrkspce.SetIdentifier(identifier);
wrkspce.Refresh();
}
SetActiveWorkspace(wrkspce);
return;
}
/// <summary>
/// Resolves the supplied <paramref name="typeName"/> to a
/// <see cref="System.Type"/>
/// instance.
/// </summary>
/// <param name="typeName">
/// The (possibly partially assembly qualified) name of a
/// <see cref="System.Type"/>.
/// </param>
/// <returns>
/// A resolved <see cref="System.Type"/> instance.
/// </returns>
/// <exception cref="System.TypeLoadException">
/// If the supplied <paramref name="typeName"/> could not be resolved
/// to a <see cref="System.Type"/>.
/// </exception>
public Type Resolve(string typeName)
{
Guard.ArgumentNotNullOrEmpty("typeName", typeName);
Type type = null;
try
{
type = _typeCache[typeName] as Type;
if (type == null)
{
lock (_typeCache)
{
type = _typeCache[typeName] as Type;
if (type == null)
{
type = _typeResolver.Resolve(typeName);
_typeCache[typeName] = type;
}
}
}
}
catch (Exception ex)
{
if (ex is TypeLoadException)
{
throw;
}
ThrowHelper.ThrowTypeLoadExcetpion(ex, "ÀàÐͼÓÔØʧ°Ü", typeName);
}
return(type);
}
private IServiceContainer BuildServiceContainer(Application application, ITypeResolver typeResolver)
{
var serviceProviderType = typeResolver.Resolve(application.ServiceProviderType);
var serviceProvider = (IServiceProvider)Activator.CreateInstance(serviceProviderType);
return(new OverridableServiceContainer(serviceProvider));
}
public IObjectDescriptor Read(object target)
{
var propertyValue = _PropertyInfo.GetValue(target);
var actualType = TypeOverride ?? _TypeResolver.Resolve(Type, propertyValue);
return(new ObjectDescriptor(propertyValue, actualType, Type, ScalarStyle));
}
public static IServiceContainer BuildServiceProvider(Application application, ITypeResolver typeResolver)
{
var localServiceProvider = new TypeServiceProvider();
if (application.ServiceProviderType != null)
{
var serviceProviderType = typeResolver.Resolve(application.ServiceProviderType);
if (serviceProviderType != null)
{
if (!typeof(IServiceProvider).IsAssignableFrom(serviceProviderType))
{
throw new InvalidOperationException($"{application.ServiceProviderType} must be an implementation of '{nameof(IServiceProvider)}'");
}
if (serviceProviderType == typeof(TypeServiceProvider))
{
throw new InvalidOperationException($"{nameof(Application.ServiceProviderType)} type cannot be '{serviceProviderType.Name}'");
}
if (serviceProviderType.GetConstructors(BindingFlags.Instance | BindingFlags.Public).All(c => c.GetParameters().Length != 0))
{
throw new InvalidOperationException($"{nameof(Application.ServiceProviderType)} must have an empty public constructor");
}
localServiceProvider.SecondaryServiceProvider = (IServiceProvider)Activator.CreateInstance(serviceProviderType);
}
}
if (localServiceProvider.SecondaryServiceProvider is IServiceContainer serviceContainer)
{
return(serviceContainer);
}
return(localServiceProvider);
}
/// <summary>
/// Resolve the service given its name and the optional parameters
/// </summary>
/// <returns>The resolved service</returns>
/// <param name="serviceName">Service name.</param>
/// <param name="parameters">Parameters.</param>
public object Resolve(string serviceName, List <Parameter> parameters)
{
// now the service type is the full type name
var serviceType = _typeResolver.Resolve(serviceName);
// Decode the parameters into the relevant types..
var namedParameters = parameters?.Select(parameter =>
{
var resolvedType = _typeResolver.Resolve(parameter.ValueType);
var value = JsonConvert.DeserializeObject(parameter.Value.ToString(), resolvedType);
var np = new NamedParameter(parameter.Name, value);
return(np);
});
return(_container.Resolve(serviceType, namedParameters));
}
public IObjectDescriptor Read(object target)
{
object obj = _propertyInfo.ReadValue(target);
Type type = TypeOverride ?? _typeResolver.Resolve(Type, obj);
return(new ObjectDescriptor(obj, type, Type, ScalarStyle));
}
/// <summary>
/// Resolves the supplied <paramref name="typeName"/> to a
/// <see cref="System.Type"/>
/// instance.
/// </summary>
/// <param name="typeName">
/// The (possibly partially assembly qualified) name of a
/// <see cref="System.Type"/>.
/// </param>
/// <returns>
/// A resolved <see cref="System.Type"/> instance.
/// </returns>
/// <exception cref="System.TypeLoadException">
/// If the supplied <paramref name="typeName"/> could not be resolved
/// to a <see cref="System.Type"/>.
/// </exception>
public Type Resolve(string typeName)
{
if (typeName == null || typeName.Trim().Length == 0)
{
throw new TypeLoadException("Could not load type from string value '" + typeName + "'.");
}
Type type = null;
try
{
if (!_typeCache.TryGetValue(typeName, out type))
{
type = _typeResolver.Resolve(typeName);
_typeCache[typeName] = type;
}
}
catch (Exception ex)
{
if (ex is TypeLoadException)
{
throw;
}
throw new TypeLoadException("Could not load type from string value '" + typeName + "'.", ex);
}
return(type);
}
public IMessage Resolve(IBasicProperties basicProperties, ReadOnlyMemory <byte> body)
{
if (basicProperties is null)
{
throw new ArgumentNullException(nameof(basicProperties));
}
if (basicProperties.Headers is null)
{
throw new ArgumentNullException(nameof(basicProperties), "message headers are missing");
}
if (!basicProperties.Headers.TryGetValue(HeaderNames.MessageType, out var tmp) ||
tmp is not byte[] messageTypeBytes ||
messageTypeBytes is null)
{
throw new ArgumentException("invalid message type");
}
var messageTypeName = Encoding.UTF8.GetString(messageTypeBytes);
var dataType = _typeResolver.Resolve(messageTypeName);
if (dataType is null)
{
throw new ArgumentException("unable to detect message type from headers");
}
var decodedObj = _decoder.Deserialize(body, dataType);
if (decodedObj is not IMessage message)
{
throw new ArgumentException($"message has the wrong type: '{messageTypeName}'");
}
return(message);
}
public T Deserialize <T>(XElement data, StreamingContext context)
{
var declaredType = typeof(T);
var atr = data.Attribute("type");
var type = atr != null?TypeResolver.Resolve(atr.Value) ?? declaredType : declaredType;
if (!declaredType.IsAssignableFrom(type) || atr == null)
{
if (declaredType.IsClass || declaredType.IsValueType)
{
type = declaredType;
}
else if (atr == null)
{
Logger.Trace(() => data.ToString());
throw new FrameworkException(@"Couldn't resolve type from provided Xml.
Root element should embed type attribute with class name or you should provide appropriate type T to Deserialize<T> method.
Trying to deserialize {0}.".With(declaredType.FullName));
}
else
{
Logger.Trace(() => data.ToString());
throw new FrameworkException(@"Can't deserialize provided Xml to {0}.
Type detected for Xml is {1}. Can't deserialize Xml to instance of {1}.".With(declaredType.FullName, type.FullName));
}
}
var document = new XmlDocument();
using (var newReader = data.CreateReader())
{
document.AppendChild(document.ReadNode(newReader));
using (var oldReader = new XmlNodeReader(document.DocumentElement))
return((T)Deserialize(type, oldReader, context));
}
}
/// <summary>
/// Resolves the supplied <paramref name="typeName" /> to a
/// <see cref="System.Type" />
/// instance.
/// </summary>
/// <param name="typeName">
/// The (possibly partially assembly qualified) name of a
/// <see cref="System.Type" />.
/// </param>
/// <returns>
/// A resolved <see cref="System.Type" /> instance.
/// </returns>
/// <exception cref="System.TypeLoadException">
/// If the supplied <paramref name="typeName" /> could not be resolved
/// to a <see cref="System.Type" />.
/// </exception>
public Type Resolve(string typeName)
{
if (StringUtils.IsNullOrEmpty(typeName))
{
throw BuildTypeLoadException(typeName);
}
Type type;
try
{
lock (_typeCache.SyncRoot)
{
type = _typeCache[typeName] as Type;
if (type == null)
{
type = _typeResolver.Resolve(typeName);
_typeCache[typeName] = type;
}
}
}
catch (Exception ex)
{
if (ex is TypeLoadException)
{
throw;
}
throw BuildTypeLoadException(typeName, ex);
}
return(type);
}
public TM Resolve <TM>(IBasicProperties basicProperties, ReadOnlyMemory <byte> body)
where TM : IMessage
{
if (basicProperties is null)
{
throw new ArgumentNullException(nameof(basicProperties));
}
if (basicProperties.Headers is null)
{
throw new ArgumentNullException(nameof(basicProperties), "message headers are missing");
}
if (!basicProperties.Headers.TryGetValue(HeaderNames.MessageType, out var tmp) ||
tmp is not byte[] messageTypeBytes ||
messageTypeBytes is null)
{
throw new ArgumentException("invalid message type");
}
var messageTypeName = Encoding.UTF8.GetString(messageTypeBytes);
var dataType = _typeResolver.Resolve(messageTypeName);
var decodedObj = _decoder.Decode(body, dataType);
if (decodedObj is not TM message)
{
throw new ArgumentException($"type '{messageTypeName}' is not a valid message");
}
return(message);
}
private Type ResolveType(TypeSerializationInfo info)
{
if (!_typeNameShortener.TryExpand(info.Name, out Type type))
{
if (_assemblyNameShortener.TryExpand(info.Assembly?.Name, out Assembly assembly))
{
info.Assembly = assembly.ToAssemblySerializationInfo();
}
var infoForResolving = info.GenericArgs?.Length > 0
? new TypeSerializationInfo
{
Name = info.Name,
Assembly = info.Assembly
}
: info;
type = _typeResolver.Resolve(infoForResolving);
}
if (type.IsGenericTypeDefinition())
{
var genericArguments = new Type[info.GenericArgs.Length];
for (var i = 0; i < genericArguments.Length; i++)
{
var genericArgument = ResolveType(info.GenericArgs[i]);
genericArguments[i] = genericArgument;
}
type = type.MakeGenericType(genericArguments);
}
return(type);
}
/// <summary>
/// Resolves the supplied <paramref name="typeName"/> to a
/// <see cref="System.Type"/>
/// instance.
/// </summary>
/// <param name="typeName">
/// The (possibly partially assembly qualified) name of a
/// <see cref="System.Type"/>.
/// </param>
/// <returns>
/// A resolved <see cref="System.Type"/> instance.
/// </returns>
/// <exception cref="System.TypeLoadException">
/// If the supplied <paramref name="typeName"/> could not be resolved
/// to a <see cref="System.Type"/>.
/// </exception>
public Type Resolve(string typeName)
{
Check.Argument.IsNotEmpty("typeName", typeName);
Type type = null;
try
{
type = _typeCache[typeName] as Type;
if (type == null)
{
lock (_typeCache)
{
type = _typeCache[typeName] as Type;
if (type == null)
{
type = _typeResolver.Resolve(typeName);
_typeCache[typeName] = type;
}
}
}
}
catch (Exception ex)
{
if (ex is TypeLoadException)
{
throw;
}
ThrowHelper.ThrowTypeLoadExcetpion(ex, R.TypeLoadFail, typeName);
}
return(type);
}
/// <summary>
/// Gets a string attribute from the specified element with the given name
/// </summary>
/// <param name="element">Element to get the attribute from</param>
/// <param name="name">Attribute name</param>
/// <param name="resolver">Type name resolver</param>
/// <param name="defaultType">Default type if not specified</param>
/// <returns>Attribute value</returns>
public static Type OptionalTypeAttribute(this XElement element, XName name, ITypeResolver resolver,
Type defaultType = null)
{
var attr = element.Attribute(name);
return(attr == null ? defaultType : resolver.Resolve(attr.Value));
}
protected override JProperty VisitProperty(JProperty property)
{
return
(SoftString.Comparer.Equals(property.Name, _typePropertyName)
? new JProperty(DefaultTypePropertyName, _typeResolver.Resolve(property.Value.Value <string>()))
: base.VisitProperty(property));
}
public object Resolve(Type type)
{
try
{
if (_resolver != null)
{
var obj = _resolver.Resolve(type);
if (obj == null)
{
throw new CommandAppException($"Could not resolve type '{type.FullName}'.");
}
return(obj);
}
// Fall back to use the activator.
return(Activator.CreateInstance(type));
}
catch (CommandAppException)
{
throw;
}
catch (Exception ex)
{
throw new CommandAppException($"Could not resolve type '{type.FullName}'.", ex);
}
}
public static T SUT <T>(this ITypeResolver resolvr) where T : ILogSource
{
if (!resolvr.HasLifetimeScope)
{
resolvr.BeginLifetimeScope();
}
if (_growl == null)
{
_growl = new GrowlListener(nameof(MustExtensions));
}
var obj = resolvr.Resolve <T>();
obj.LogAdded += (s, e) =>
{
if (e.ShowAs == ShowLogAs.Intro)
{
_lastTitle = e.Title;
return;
}
if (e.ShowAs == ShowLogAs.Outro)
{
e.Title = _lastTitle;
}
var m = ShortLog.Format(e);
OutputHelper.WriteLine(m);
};
obj.LogAdded += _growl.HandleLogEvent;
return(obj);
}
public FieldInfo Resolve(FieldReference fieldReference)
{
Type declaringType = _typeResolver.Resolve(fieldReference.DeclaringType);
var flags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public;
FieldInfo result = declaringType.GetField(fieldReference.Name, flags);
return(result);
}
public static T Resolve <T>(this ITypeResolver typeResolver)
{
if (typeResolver == null)
{
throw new ArgumentNullException(nameof(typeResolver));
}
return((T)typeResolver.Resolve(typeof(T), null, null));
}
private static CommandSettings CreateSettings(ITypeResolver resolver, Type settingsType)
{
if (resolver.Resolve(settingsType) is CommandSettings settings)
{
return(settings);
}
throw CommandParseException.CouldNotCreateSettings(settingsType);
}
public static object Resolve(this ITypeResolver typeResolver, Type type, object[] args)
{
if (typeResolver == null)
{
throw new ArgumentNullException(nameof(typeResolver));
}
return(typeResolver.Resolve(type, null, args));
}
public static T Resolve <T>(this ITypeResolver typeResolver, object context, object[] args)
{
if (typeResolver == null)
{
throw new ArgumentNullException(nameof(typeResolver));
}
return((T)typeResolver.Resolve(typeof(T), context, args));
}
public static PersistentReturnType Resolve(IReturnType source, ITypeResolver typeResolver)
{
if (source == null) return null;
PersistentReturnType rt = new PersistentReturnType ();
rt.FullyQualifiedName = typeResolver.Resolve (source.FullyQualifiedName);
rt.pointerNestingLevel = source.PointerNestingLevel;
rt.arrayDimensions = source.ArrayDimensions;
return rt;
}
public static PersistentClass Resolve(IClass sclass, ITypeResolver typeResolver)
{
PersistentClass cls = new PersistentClass ();
cls.FullyQualifiedName = sclass.FullyQualifiedName;
cls.Documentation = sclass.Documentation;
cls.modifiers = sclass.Modifiers;
cls.classType = sclass.ClassType;
foreach (string t in sclass.BaseTypes)
cls.baseTypes.Add (typeResolver.Resolve (t));
foreach (IClass c in sclass.InnerClasses)
cls.innerClasses.Add (PersistentClass.Resolve (c,typeResolver));
foreach (IField f in sclass.Fields)
cls.fields.Add (PersistentField.Resolve (f, typeResolver));
foreach (IProperty p in sclass.Properties)
cls.properties.Add (PersistentProperty.Resolve (p, typeResolver));
foreach (IMethod m in sclass.Methods)
cls.methods.Add (PersistentMethod.Resolve (m, typeResolver));
foreach (IEvent e in sclass.Events)
cls.events.Add (PersistentEvent.Resolve (e, typeResolver));
foreach (IIndexer i in sclass.Indexer)
cls.indexer.Add (PersistentIndexer.Resolve (i, typeResolver));
cls.region = sclass.Region;
return cls;
}
public static IEnumerable<object> GetDependencies(this IEnumerable<ParameterInfo> parameterInfos, ITypeResolver typeResolver)
{
Func<ParameterInfo, object> selector = parameterInfo => typeResolver.Resolve(parameterInfo.ParameterType);
return parameterInfos.Select(selector);
}
