public static T ParseArgs <T>(string[] args) where T : new()
{
Dictionary <string, string> namedArgs = new Dictionary <string, string>();
for (int i = 0; i < args.Length; i++)
{
string str = args[i];
if (str.StartsWith("-"))
{
namedArgs[str.Substring(1).ToLower()] = args[++i];
}
}
CachedType t = typeof(T);
T instance = new T();
foreach (var propertyInfo in t.Query(ClassQueries.GetPublicImplementedProperties))
{
string argKey = propertyInfo.Name.ToLower();
propertyInfo.SetValue(instance, namedArgs[argKey]);
}
return(instance);
}
static DependencyInjectionLambdaGenerator()
{
CachedType argType = typeof(Container);
dependencyMethod = argType
.Query(t => t.GetMethod(nameof(Container.Resolve), new Type[] { typeof(Type) }));
}
public Func <Container, object> CreateInstanceFactory(CachedType type, InjectionOptions containerInjectionOptions, InjectionOptions injectionOptions)
{
CachedConstructorInfo constructor =
(injectionOptions.ChooseInjectionConstructor ?? containerInjectionOptions.ChooseInjectionConstructor)(
type.Query(ClassQueries.GetPublicConstructors)
.Select(c => (CachedConstructorInfo)c));
var constructLamda = constructor.Query(info => lambdaGenerator.CreateConstructorInjectionLambda(info));
List <Action <Container, object> > injectionLambdas = new List <Action <Container, object> >();
var chooseInjectionMethods = injectionOptions.ChooseInjectionMethods ??
containerInjectionOptions.ChooseInjectionMethods;
if (chooseInjectionMethods != null)
{
var injectionMethods = chooseInjectionMethods(type
.Query(ClassQueries.GetPublicImplementedMethods).Select(m => (CachedMethodInfo)m));
foreach (var cachedMethodInfo in injectionMethods)
{
var methodInjectionLambda = cachedMethodInfo.Query(m =>
lambdaGenerator.CreateMethodInjectionLambda(type, cachedMethodInfo));
injectionLambdas.Add(methodInjectionLambda);
}
}
var chooseInjectionProperties = injectionOptions.ChooseInjectionProperties ??
containerInjectionOptions.ChooseInjectionProperties;
if (chooseInjectionProperties != null)
{
var injectionProperties = chooseInjectionProperties(type.Query(ClassQueries.GetPublicImplementedProperties).Select(p => (CachedPropertyInfo)p)).ToArray();
if (injectionProperties.Length > 0)
{
injectionLambdas.Add(lambdaGenerator.CreatePropertyInjectionLambda(type, injectionProperties));
}
}
return(CombineConstructorInjectionAndMemberInjectionLambdas(constructLamda, injectionLambdas.ToArray()));
}
public static object Activate(Type t)
{
if (t.IsValueType)
{
return(System.Activator.CreateInstance(t));
}
else if (t.IsInterface)
{
return(DispatchProxy.DispatchProxy.Create(t, typeof(InterfaceProxy)));
}
else if (t.IsClass)
{
CachedType type = t;
return(type.Query(ClassQueries.GetDefaultConstructor).Invoke(null));
}
return(null);
}
public void GetCachedType_MatchesTestType()
{
CachedType cachedType = ReflectionCache.CurrentCache.GetCachedMetaData(TestReflectionCacheTypes.TestType);
Assert.IsTrue(cachedType.Query(AttributeLocationQueries.GetAttributes).Length == 1);
Assert.IsTrue(cachedType.Query(ClassQueries.GetPublicFields).Count() == 2);
Assert.IsTrue(cachedType.Query(ClassQueries.GetPublicImplementedProperties).Count() == 2);
Assert.IsTrue(cachedType.Query(ClassQueries.GetPublicImplementedMethods).Count() == 2);
Assert.IsTrue(cachedType.Query(ClassQueries.GetPublicImplementedEvents).Count() == 2);
Assert.IsTrue(cachedType.Query(ClassQueries.GetPublicImplementedMethods).Count() == 2);
Assert.IsTrue(cachedType.Query(ClassQueries.GetGenericArguments).Length == 1);
}
public void RenderService(CachedType tService, object serviceObject)
{
Dictionary <int, CachedMethodInfo> choose = new Dictionary <int, CachedMethodInfo>();
int i = 1;
IEnumerable <CachedMethodInfo> methods = tService.Query(TypeQueries.GetMethods).Select(m => (CachedMethodInfo)m);
foreach (var methodInfo in methods)
{
choose[i] = methodInfo;
i++;
}
while (true)
{
_console.WriteLine($"{_translationProvider.Translate("ServiceOfType")} {tService.InnerMetaData.FullName}:");
i = 1;
if (methods.Any())
{
_console.WriteLine($"{_translationProvider.Translate("Methods")}:");
foreach (var methodInfo in methods)
{
_console.WriteLine($"{i}) {methodInfo.InnerMetaData.Name}");
i++;
}
}
string input;
_console.WriteLine($"{_translationProvider.Translate("ChoosePropertyOrMethod")}");
input = _console.ReadLine();
if (input == "x")
{
return;
}
int choice;
try
{
choice = int.Parse(input);
}
catch
{
continue;
}
if (choice > choose.Count)
{
_console.WriteLine($"{choice} {_translationProvider.Translate("IsOutOfRange")}");
continue;
}
CachedMethodInfo metaData = choose[choice];
CreateMethodInvocation(metaData, serviceObject);
}
}
public bool EditObject <T>(CachedType t, T obj, out T modified)
{
T cloned = (T)JsonConvert.DeserializeObject(JsonConvert.SerializeObject(obj, t, Formatting.None,
new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.All
}), t);
Dictionary <int, object> choose = new Dictionary <int, object>();
int i = 1;
IEnumerable <CachedPropertyInfo> properties = t.Query(TypeQueries.GetProperties).Select(p => (CachedPropertyInfo)p);
IEnumerable <CachedMethodInfo> methods = t.Query(TypeQueries.GetMethods).Select(m => (CachedMethodInfo)m);
foreach (var propertyInfo in properties)
{
choose[i] = propertyInfo;
i++;
}
foreach (var methodInfo in methods)
{
choose[i] = methodInfo;
i++;
}
string input;
while (true)
{
_console.WriteLine($"{_translationProvider.Translate("EditObjectOfType")} {t.InnerMetaData.FullName}:");
i = 1;
if (properties.Any())
{
_console.WriteLine($"{_translationProvider.Translate("Properties")}:");
foreach (var propertyInfo in properties)
{
_console.WriteLine($"{i}) {propertyInfo.InnerMetaData.Name}");
i++;
}
}
if (methods.Any())
{
_console.WriteLine($"{_translationProvider.Translate("Methods")}:");
foreach (var methodInfo in methods)
{
_console.WriteLine($"{i}) {methodInfo.InnerMetaData.Name}");
i++;
}
}
_console.WriteLine($"{_translationProvider.Translate("EditObjectMenu")}");
input = _console.ReadLine();
if (input == "x")
{
modified = obj;
return(false);
}
else if (input == "ok")
{
modified = cloned;
return(true);
}
else if (input == "e")
{
_console.WriteLine(JsonConvert.SerializeObject(cloned, Formatting.Indented));
continue;
}
else if (input == "c")
{
StoreObjectInClipboard(obj);
continue;
}
else if (input == "p")
{
cloned = modified = (T)PasteObjectFromClipboard();
continue;
}
int choice;
try
{
choice = int.Parse(input);
}
catch
{
continue;
}
if (choice > choose.Count)
{
_console.WriteLine($"{choice} {_translationProvider.Translate("IsOutOfRange")}");
continue;
}
object metaData = choose[choice];
if (metaData is CachedPropertyInfo p)
{
AssignProperty(p, cloned);
}
else if (metaData is CachedMethodInfo m)
{
CreateMethodInvocation(m, cloned);
}
}
}
