private void WriteCustomAttributes(XmlWriter writer, ConstructorInfo constructorInfo)
{
try
{
WriteCustomAttributes(writer, constructorInfo.GetCustomAttributes(this.rep.DocumentInheritedAttributes), "");
}
catch (Exception e)
{
TraceErrorOutput("Error retrieving custom attributes for " + MemberID.GetMemberID(constructorInfo), e);
}
}
/// <summary>
/// Formats the constructor.
/// </summary>
/// <param name="constructor">The constructor.</param>
/// <param name="sw">The string writer.</param>
private static void FormatConstructor(ConstructorInfo constructor, StringWriter sw)
{
foreach (Attribute attribute in constructor.GetCustomAttributes(false))
{
FormatAttribute(sw, attribute);
}
sw.Write(constructor.DeclaringType.GetTypeInfo().Name);
sw.Write("(");
foreach (var parameterInfo in constructor.GetParameters())
{
foreach (Attribute attribute in parameterInfo.GetCustomAttributes(false))
{
FormatAttribute(sw, attribute);
}
sw.Write(parameterInfo.ParameterType.Format());
sw.Write(" ");
sw.Write(parameterInfo.Name);
}
sw.WriteLine(")");
}
public static bool IsConstructable( ConstructorInfo ctor, AccessLevel accessLevel )
{
object[] attrs = ctor.GetCustomAttributes( m_ConstructableType, false );
if ( attrs.Length == 0 )
return false;
return accessLevel >= ((ConstructableAttribute)attrs[0]).AccessLevel;
}
public Expression GetConstructorExpression(out ConstructorInfo constructorInfo, out IEnumerable<Expression> constructorParameters)
{
CompiledExportDelegateInfo exportDelegateInfo = _instanceCompiledExport.exportDelegateInfo;
constructorInfo = _instanceCompiledExport.exportDelegateInfo.ImportConstructor ??
_instanceCompiledExport.PickConstructor(exportDelegateInfo.ActivationType);
if (constructorInfo == null)
{
throw new PublicConstructorNotFoundException(exportDelegateInfo.ActivationType);
}
List<Expression> parameters = new List<Expression>();
constructorParameters = parameters;
Attribute[] constructorAttributes = constructorInfo.GetCustomAttributes(true).ToArray();
if (constructorAttributes.Length == 0)
{
constructorAttributes = EmptyAttributesArray;
}
foreach (ParameterInfo parameterInfo in constructorInfo.GetParameters())
{
Attribute[] parameterAttributes = parameterInfo.GetCustomAttributes(true).ToArray();
if (parameterAttributes.Length == 0)
{
parameterAttributes = EmptyAttributesArray;
}
IExportValueProvider valueProvider = null;
ExportStrategyFilter exportStrategyFilter = null;
string importName = null;
object comparerObject = null;
ILocateKeyValueProvider locateKey = null;
if (exportDelegateInfo.ConstructorParams != null)
{
foreach (ConstructorParamInfo constructorParamInfo in exportDelegateInfo.ConstructorParams)
{
if (string.Compare(parameterInfo.Name,
constructorParamInfo.ParameterName,
StringComparison.OrdinalIgnoreCase) == 0)
{
importName = constructorParamInfo.ImportName;
exportStrategyFilter = constructorParamInfo.ExportStrategyFilter;
valueProvider = constructorParamInfo.ValueProvider;
comparerObject = constructorParamInfo.ComparerObject;
locateKey = constructorParamInfo.LocateKeyProvider;
break;
}
}
if (valueProvider == null)
{
foreach (ConstructorParamInfo constructorParamInfo in exportDelegateInfo.ConstructorParams)
{
if (string.IsNullOrEmpty(constructorParamInfo.ParameterName) &&
parameterInfo.ParameterType.GetTypeInfo().IsAssignableFrom(
constructorParamInfo.ParameterType.GetTypeInfo()))
{
importName = constructorParamInfo.ImportName;
exportStrategyFilter = constructorParamInfo.ExportStrategyFilter;
valueProvider = constructorParamInfo.ValueProvider;
comparerObject = constructorParamInfo.ComparerObject;
locateKey = constructorParamInfo.LocateKeyProvider;
break;
}
}
}
}
InjectionTargetInfo targetInfo = null;
if (importName != null)
{
targetInfo = new InjectionTargetInfo(exportDelegateInfo.ActivationType,
_instanceCompiledExport.activationTypeAttributes,
parameterInfo,
parameterAttributes,
constructorAttributes,
importName,
null);
}
else if (InjectionKernel.ImportTypeByName(parameterInfo.ParameterType))
{
targetInfo = new InjectionTargetInfo(exportDelegateInfo.ActivationType,
_instanceCompiledExport.activationTypeAttributes,
parameterInfo,
parameterAttributes,
constructorAttributes,
parameterInfo.Name,
null);
}
else
{
targetInfo = new InjectionTargetInfo(exportDelegateInfo.ActivationType,
_instanceCompiledExport.activationTypeAttributes,
parameterInfo,
parameterAttributes,
constructorAttributes,
null,
parameterInfo.ParameterType);
}
ParameterExpression parameterExpression =
_instanceCompiledExport.CreateImportExpression(parameterInfo.ParameterType,
targetInfo,
ExportStrategyDependencyType.ConstructorParameter,
importName,
parameterInfo.Name + "CVar",
true,
valueProvider,
exportStrategyFilter,
locateKey,
comparerObject,
null);
parameters.Add(Expression.Convert(parameterExpression, parameterInfo.ParameterType));
}
Expression constructExpression = Expression.New(constructorInfo, parameters.ToArray());
return Expression.Assign(_instanceCompiledExport.instanceVariable, constructExpression);
}
public static T GetCustomAttribute <T>(this ConstructorInfo type, bool inherit)
where T : Attribute
{
return(type.GetCustomAttributes(inherit).OfType <T>().FirstOrDefault());
}
public Constructor(ConstructorInfo constructorInfo, Dictionary<string, object> parameterDictionary)
{
_constructorInfo = constructorInfo;
_parameterNames = new List<string>();
_parameterTypes = new List<Type>();
_match = true;
_usedAllParameters = true;
// look through the constructor attributes for a RegisterConstructorAttribute
// if this attribute exists, the factory is allowed to use the constructor.
var registerConstructorAttributes = (RegisterConstructorAttribute[])_constructorInfo.GetCustomAttributes(typeof(RegisterConstructorAttribute), false);
if (registerConstructorAttributes.Length == 0)
{
_match = false;
_usedAllParameters = false;
return;
}
// populate _parameterNames and _parameterTypes from _constructorInfo
ParameterInfo[] parameterInfos = _constructorInfo.GetParameters();
foreach (ParameterInfo parameterInfo in parameterInfos)
{
var factoryParameterAttributes = (FactoryParameterAttribute[])parameterInfo.GetCustomAttributes(typeof(FactoryParameterAttribute),false);
string parameterName = parameterInfo.Name.ToLower(); // use raw parameter name
if (factoryParameterAttributes.Length == 1) parameterName = factoryParameterAttributes[0].RegisteredName; // replace with friendly name for the parameter.
else if (factoryParameterAttributes.Length > 1) throw new Exception("Parameter can have at most one FactoryParameterAttribute");
_parameterNames.Add(parameterName);
_parameterTypes.Add(parameterInfo.ParameterType);
}
// populate _parameterValues from parameterDictionary
_parameterValues = new object[_parameterNames.Count];
for (int i = 0; i < _parameterNames.Count; ++i)
{
string parameterName = _parameterNames[i].ToLower();
Type parameterType = _parameterTypes[i];
object parameterValue;
if (parameterDictionary.ContainsKey(parameterName))
{
parameterValue = parameterDictionary[parameterName];
if (!parameterType.IsInstanceOfType(parameterValue)) // Parameter parameterName has the wrong type
{
if (parameterValue.GetType() == typeof(Dictionary<string, object>))
{
var dictionary = (Dictionary<string, object>) parameterValue;
MethodInfo factoryGetInstanceMethod = typeof(Factory).GetMethod("GetInstance").MakeGenericMethod(parameterType);
try
{
parameterValue = factoryGetInstanceMethod.Invoke(null, new object[] { dictionary });
}
catch (TargetInvocationException e)
{
throw new Exception(e.InnerException.Message);
}
}
else
_match = false;
}
}
else // Can't find parameter parameterName in parameterDictionary
{
_match = false;
parameterValue = new object();
}
_parameterValues[i] = parameterValue;
}
// check to see whether all parameters in parameterDictionary have been used up
foreach (KeyValuePair<string, object> entry in parameterDictionary.Where(entry => entry.Key != "name" && !_parameterNames.Contains(entry.Key)))
_usedAllParameters = false;
}
private bool HasInjectAttribute(ConstructorInfo constructor)
{
return constructor.GetCustomAttributes(false).Any(a => a.GetType().Name.ToLower().Contains("inject"));
}
public static CAL GetCAL(ConstructorInfo ctor)
{
object[] attrs = ctor.GetCustomAttributes(m_ConstructableAccessLevel, false);
if (attrs.Length == 0)
return null;
return attrs[0] as CAL;
}
public void PublicConstructor_IsTaggedWithPublicAPIAttribute(ConstructorInfo constructor)
{
bool attributeIsPresent = constructor.GetCustomAttributes(typeof(PublicAPIAttribute), true).Any();
Assume.That(constructor.DeclaringType != null);
Assert.That(attributeIsPresent, "Constructor (" + string.Join(", ", constructor.GetParameters().Select(p => p.ParameterType.Name)) + " of type " + constructor.DeclaringType.Name + " is not tagged with [PublicAPI]");
}
public static ExcelObjectConstructorAttribute GetAttribute(ConstructorInfo ci)
{
object[] o = ci.GetCustomAttributes(typeof(ExcelObjectConstructorAttribute), false);
ExcelObjectConstructorAttribute r = (ExcelObjectConstructorAttribute)o[0];
return r;
}
private static ConstructorDefinition BuildConstructorDefinition(ConstructorInfo constructorInfo)
{
IEnumerable<ParameterDefinition> parameters = constructorInfo
.GetParameters()
.Select(p => new ParameterDefinition(p.Name, p.ParameterType));
ConstructorMethod constructorMethod = ObjectInterfaceProvider.GetConstructor(constructorInfo);
bool isPreferredConstructor = constructorInfo.GetCustomAttributes(typeof(SerializationConstructorAttribute), true).Any();
return new ConstructorDefinition(constructorMethod, parameters, isPreferredConstructor);
}
public static T[] GetAttributes <T>(ConstructorInfo ci, bool inherit) where T : Attribute
{
object[] objects = ci.GetCustomAttributes(typeof(T), inherit);
return((T[])objects);
}
