/// <inheritdoc />
public IKustoOptionsBuilder WithDirectClient()
{
RegisteredDirectTypes.AddRange(RegisteredTypes);
RegisteredTypes.Clear();
return(this);
}
/// <summary>
/// Resolves the last registered service with a matching name.
/// </summary>
/// <typeparam name="TInterface"></typeparam>
/// <param name="name"></param>
/// <returns></returns>
public TInterface Resolve <TInterface>(string name)
{
var interfaceType = typeof(TInterface);
var typeAndName = new TypeAndName(interfaceType, name);
Type type;
if (RegisteredTypes.TryGetValue(typeAndName, out type))
{
object lazyInstance;
if (StoredServices.TryGetValue(typeAndName, out lazyInstance) && lazyInstance.GetType() == typeof(Func <TInterface>))
{
// Lazy singletons must be invoked when called first time.
var invokedLazy = ((Func <TInterface>)lazyInstance).Invoke();
StoredServices.AddOrUpdate(typeAndName, k => invokedLazy, (k, v) => invokedLazy);
}
object instance;
if (StoredServices.TryGetValue(typeAndName, out instance))
{
// Return the stored singleton object.
return((TInterface)instance);
}
// Get the first constructor from the registered type.
var constructor = type.GetConstructors().First();
// Create a new instance and return it.
var activator = Common.Activator.GetActivator(constructor);
return((TInterface)activator());
}
return(default(TInterface));
}
/// <inheritdoc />
public IKustoOptionsBuilder WithQueuedClient()
{
RegisteredQueuedTypes.AddRange(RegisteredTypes);
RegisteredTypes.Clear();
return(this);
}
/// <summary>
/// Whether or not the variable name provided is an external host language( C# ) type name.
/// </summary>
/// <param name="memory">The memory space of the runtime.</param>
/// <param name="types">The collection of registered external types.</param>
/// <param name="varName">The name associated with the member access.</param>
/// <returns></returns>
public static BoolMsgObj IsExternalTypeName(Memory memory, RegisteredTypes types, string varName)
{
Type type = null;
var isStatic = false;
// 1. Class name : "Person" as in "Person.Create" -> so definitely a static method call on custom object.
if (types.Contains(varName))
{
type = types.Get(varName);
}
// 2. Case insensitive Class name: "person" as in "Person.Create" but "person" variable doesn't exist.
else if (!memory.Contains(varName))
{
// Only do this check for "user" -> "User" class / static method.
var first = Char.ToUpper(varName[0]);
var name = first + varName.Substring(1);
if (types.Contains(name))
{
type = types.Get(name);
}
}
if (type != null)
{
isStatic = true;
}
return(new BoolMsgObj(type, isStatic, string.Empty));
}
private void LoadFiles(object sender, MouseButtonEventArgs e)
{
if (RegisteredTypes?.Any != true)
{
throw new Exception("You must specify at least one supported file type.");
}
var dialog = new OpenFileDialog
{
Multiselect = true,
Filter = RegisteredTypes.ToString()
};
dialog.ShowDialog();
if (!dialog.FileNames.Any())
{
return;
}
this.ProcessingFiles(true);
var eventArgs = new DragAndDropEventArgs(this);
SortData(dialog.FileNames, eventArgs);
OnDataRecievedFromDropOperation(eventArgs);
this.ProcessingFiles(eventArgs.WaitForAsync);
}
/// <summary>
/// Is the type registered. Does not trigger building of the container.
/// </summary>
/// <typeparam name="T">Type to verify</typeparam>
/// <returns>True if the type is registered, otherwise false</returns>
public override bool IsRegistered <T>()
{
if (_container.IsValueCreated)
{
return(_container.Value.IsRegistered <T>());
}
return(RegisteredTypes.Contains(typeof(T)));
}
public static void RegisterType <TType>(params string[] properties)
{
RegisteredTypes.Add(typeof(TType).Name, typeof(TType));
foreach (var pi in typeof(TType).GetProperties())
{
if (properties.Contains(pi.Name))
{
ValidProperties[(typeof(TType), pi.Name)] = pi;
public override bool IsRegistered <T>()
{
if (_container != null)
{
return(_container.IsRegistered <T>());
}
return(RegisteredTypes.Contains(typeof(T)));
}
private object InternalResolve(Type targetType)
{
if (targetType.IsClass)
{
ITypeDefinition typeDefinition;
if (RegisteredTypes.TryGetValue(targetType, out typeDefinition))
{
if (typeDefinition.SingletonInstance != null)
{
return(typeDefinition.SingletonInstance);
}
if (typeDefinition.ConstructorMethods == null || typeDefinition.ConstructorMethods.Length == 0)
{
throw new Exception(string.Format("constructor method cannot be found in type '{0}'", targetType.FullName));
}
var defaultConstructor = typeDefinition.ConstructorMethods[0];
var parameterValues = new object[defaultConstructor.ParameterInfos.Length];
for (int i = 0; i < parameterValues.Length; i++)
{
var parameterInfo = defaultConstructor.ParameterInfos.FirstOrDefault(x => x.Index == i);
if (parameterInfo == null)
{
throw new Exception(string.Format("parameter is missing in contructor method."));
}
parameterValues[i] = InternalResolve(parameterInfo.TypeDefinition.Info as Type);
}
return(typeDefinition.GetInstance(parameterValues));
}
return(null);
}
else if (targetType.IsInterface)
{
var typeDefinition = RegisteredTypes.Values.ToArray().Where(x => x.Inference != null && x.Inference.Equals(targetType))
.OrderByDescending(x => x.Priority).FirstOrDefault();
if (typeDefinition == null)
{
throw new Exception(string.Format("failed to find registered type inferred from interface '{0}'.", targetType.FullName));
}
if (typeDefinition.SingletonInstance != null)
{
return(typeDefinition.SingletonInstance);
}
return(InternalResolve(typeDefinition.Info as Type));
}
else
{
return(null);
}
}
public bool CanInfer(Type targetType)
{
if (targetType.IsClass)
{
return(RegisteredTypes.ContainsKey(targetType));
}
return(RegisteredTypes.Values.ToArray().Exists(x => x.Inference != null && x.Inference.Equals(targetType)));
}
static void Main()
{
var config = CrystalConfig.FromDirectory("Config/");
RegisteredTypes.LoadAllIn("Assemblies/");
var game = new CrystalGame(config);
game.Run();
}
/// <summary>
/// Casts a scalar node to a C# object following the rules:
/// Single-Length, single quoted strings become char
/// Else, quoted (single or double), literal or folded values become strings
/// Else, plain values equal to the string "null" become null
/// Else, plain values that start with "~" become scene resources
/// Else, plain values that can be cast to int become int
/// Else, plain values that can be cast to float become float
/// Else, plain values are cast to a object using the parameterless constructor
/// (For parameterized constructors, see casting a mapping node)
/// </summary>
/// <param name="node"></param>
private object parseArgument(YamlScalarNode node)
{
switch (node.Style)
{
case ScalarStyle.SingleQuoted:
if (node.String().Length == 1)
{
return(node.String()[0]);
}
else
{
return(node.String());
}
case ScalarStyle.DoubleQuoted:
case ScalarStyle.Literal:
case ScalarStyle.Folded:
return(node.String());
case ScalarStyle.Plain:
if (node.String() == "null")
{
return(null);
}
if (node.String().StartsWith("~"))
{
return(new ObjectModel
{
Type = typeof(Resource),
CtorArgs = new Object[] { node.String().Substring(1) }
});
}
int i;
float f;
if (node.TryInt(out i))
{
return(i);
}
if (node.TryFloat(out f))
{
return(f);
}
return(new ObjectModel
{
Type = RegisteredTypes.GetType(node.String()),
CtorArgs = new object[] { }
});
default:
throw new Exception("Trying to parse arguments from invalid node!");
}
}
/// <summary>
/// Determines whether a given type should be injected.
/// </summary>
/// <param name="member">The member info to check.</param>
/// <returns><see langword="true"/> if a given type needs to be injected; otherwise <see langword="false"/>.</returns>
public bool ShouldInject(MemberInfo member)
{
var propertyInfo = member as PropertyInfo;
if (propertyInfo == null || propertyInfo.GetSetMethod(Settings.InjectNonPublic) == null)
{
return(false);
}
return(registeredTypes.Any(x => propertyInfo.DeclaringType.IsAssignableFrom(x)) &&
RegisteredTypes.Any(x => propertyInfo.PropertyType.IsAssignableFrom(x)) &&
propertyInfo.CanWrite);
}
/// <summary>
/// Releases unmanaged and - optionally - managed resources
/// </summary>
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
private void Dispose(bool disposing)
{
if (disposed)
{
return;
}
if (disposing)
{
RegisteredTypes.Clear();
}
disposed = true;
}
private ObjectModel parseObject(YamlNode node)
{
if (node.NodeType == YamlNodeType.Scalar)
{
return(new ObjectModel
{
Type = RegisteredTypes.GetType(node.Val().String()),
CtorArgs = new object[] { }
});
}
else if (node.NodeType == YamlNodeType.Mapping)
{
return(parseObject(node.Map().Children));
}
throw new YamlException(node.Start, node.End, "Invalid object structure");
}
private ObjectModel parseObject(IDictionary <YamlNode, YamlNode> map)
{
if (map.Count != 1)
{
throw new YamlException(
map.First().Key.Start,
map.First().Key.End,
"Invalid object structure"
);
}
var component = map.First();
return(new ObjectModel
{
Type = RegisteredTypes.GetType(component.Key.Val().String()),
CtorArgs = parseArguments(component.Value.Seq())
});
}
/// <summary>
/// Unregisters a service with a name. When this method is called,
/// everything related is removed.
/// </summary>
/// <param name="interfaceType"></param>
/// <param name="name"></param>
public void Unregister(Type interfaceType, string name)
{
if (interfaceType == null)
{
throw new ArgumentNullException("interfaceType");
}
if (IsNameNullOrValid(name) == false)
{
throw new ArgumentNullException("name");
}
var typeAndName = new TypeAndName(interfaceType, name);
Type type;
RegisteredTypes.TryRemove(typeAndName, out type);
CleanupServices(interfaceType, name);
}
public void RegisterHandler <T>(Func <IMessage <T>, object> processMessageFn, Action <IMessage <T>, Exception> processExceptionEx, MessageHandlerSettings settings = null)
{
var type = typeof(T);
if (handlerMap.ContainsKey(type))
{
throw new ArgumentException("Message handler has already been registered for type: " + type.Name);
}
RegisteredTypes.Add(type);
if (settings == null)
{
settings = new MessageHandlerSettings();
}
handlerMap[type] = CreateMessageHandlerFactory(processMessageFn, processExceptionEx, settings);
handlerThreadCountMap[type] = settings.NoOfThreads;
}
public virtual object Resolve(Type abs)
{
abs = abs ?? throw new ArgumentNullException(nameof(abs));
if (!RegisteredTypes.ContainsKey(abs))
{
throw new NotSupportedException(
$"Тип {abs.FullName} не зарегистрирован в контейнере.");
}
if (Singletons.TryGetValue(abs, out var singleton) && singleton != null)
{
return(singleton);
}
if (ScopedInstances.TryGetValue(abs, out var scoped) && scoped != null)
{
return(scoped);
}
var imp = RegisteredTypes[abs];
var ctorInfo = imp.GetConstructors().Single();
var parameters = ctorInfo.GetParameters();
var args = parameters.Select(p => Resolve(p.ParameterType)).ToArray();
var instance = Activator.CreateInstance(imp, args);
if (Singletons.ContainsKey(abs))
{
Singletons[abs] = instance;
}
else if (ScopedInstances.ContainsKey(abs))
{
ScopedInstances[abs] = instance;
}
return(instance);
}
public object Diagnostics(
[FromServices] ConfigurationInstanceHolder configurationInstanceHolder,
[FromServices] IEnumerable <MySampleMultipleInstance> multipleInstances)
{
if (configurationInstanceHolder is null)
{
throw new ArgumentNullException(nameof(configurationInstanceHolder));
}
if (multipleInstances is null)
{
throw new ArgumentNullException(nameof(multipleInstances));
}
return(new
{
Instances = configurationInstanceHolder !.RegisteredTypes
.Select(type => new
{
type.FullName, Instances = configurationInstanceHolder.GetInstances(type).ToArray()
})
.ToArray(),
multipleInstances
});
/// <summary>
/// Registers a type with a name. When Resolve is called, a new object will
/// be create.
/// </summary>
/// <param name="interfaceType"></param>
/// <param name="type"></param>
/// <param name="name"></param>
public void RegisterType(Type interfaceType, Type type, string name)
{
if (interfaceType == null)
{
throw new ArgumentNullException("interfaceType");
}
if (type == null)
{
throw new ArgumentNullException("type");
}
if (IsNameNullOrValid(name) == false)
{
throw new ArgumentNullException("name");
}
var typeAndName = new TypeAndName(interfaceType, name);
// Cleanup previous stored services, with the same interface type and name.
CleanupServices(interfaceType, name);
// Add the typeAndName/type or update a previous registered type, with the same
// typeAndName.
RegisteredTypes.AddOrUpdate(typeAndName, k => type, (k, v) => type);
}
public bool HasTypeInfo(ComponentTypeInfo componentTypeInfo)
{
return(RegisteredTypes.FindAll(i => i.MostlyEquals(componentTypeInfo))?.Count > 0);
}
public virtual void RegisterTransient(Type abs, Type imp, bool rewrite = false)
{
abs = abs ?? throw new ArgumentNullException(nameof(abs));
imp = imp ?? throw new ArgumentNullException(nameof(imp));
if (!imp.IsClass)
{
throw new NotSupportedException(
$"Тип {imp.FullName} не является классом.");
}
if (!rewrite && RegisteredTypes.ContainsKey(abs))
{
throw new InvalidOperationException(
$"Тип {abs.FullName} уже зарегистрирован в контейнере.");
}
if (!abs.IsAssignableFrom(imp))
{
throw new InvalidOperationException(
$"Тип {imp.FullName} не может быть приведён к типу {abs.FullName}.");
}
var foundTypes = new List <Type>();
if (!Singletons.ContainsKey(abs) && !ScopedInstances.ContainsKey(abs))
{
foundTypes.Add(abs);
}
if (!Singletons.ContainsKey(imp) && !ScopedInstances.ContainsKey(imp) && !foundTypes.Contains(imp))
{
foundTypes.Add(imp);
}
void CheckRecursion(Type type)
{
var ctors = type.GetConstructors();
if (ctors.Length != 1)
{
throw new NotSupportedException(
$"Неразрешимая зависимость: контейнер не может выбрать вызываемый конструктор для типа {type.FullName}.");
}
var constructorInfo = ctors.Single();
var parameterTransientTypes = constructorInfo.GetParameters()
.Select(p => p.ParameterType)
.Except(Singletons.Keys)
.Except(ScopedInstances.Keys)
.Distinct()
.ToArray();
foreach (var parameterType in parameterTransientTypes)
{
if (foundTypes.Contains(parameterType))
{
throw new NotSupportedException(
$"Неразрешимая зависимость: циклическая зависимость для типа {type.FullName} в типе параметра {parameterType.FullName}.");
}
if (parameterType.IsClass)
{
CheckRecursion(parameterType);
}
}
foundTypes.AddRange(parameterTransientTypes);
}
CheckRecursion(imp);
RegisteredTypes[abs] = imp;
}
private SceneInitializer fromText(string text)
{
var yaml = new YamlStream();
yaml.Load(new StringReader(text));
var root = yaml.Documents[0].RootNode.Map();
var size = new Point(1280, 720);
var scaler = new LetterboxingScaler();
var systems = new List <ObjectModel>();
var renderers = new List <ObjectModel>();
var entities = new List <EntityModel>();
var actions = new List <InputAction>();
if (root.Children.ContainsKey("size"))
{
// TODO
}
if (root.Children.ContainsKey("scaler"))
{
// TODO
}
// Add systems
if (root.Children.ContainsKey("systems"))
{
foreach (var system in root["systems"].Seq().Children)
{
switch (system.NodeType)
{
case YamlNodeType.Scalar:
systems.Add(
new ObjectModel
{
Type = RegisteredTypes.GetType(system.Val().String()),
CtorArgs = new object[] { },
}
);
break;
case YamlNodeType.Mapping:
systems.Add(
new ObjectModel
{
Type = RegisteredTypes.GetType(system.Map().First().Key.Val().String()),
CtorArgs = parseArguments(system.Map().First().Value),
}
);
break;
}
}
}
// Add renderers
if (root.Children.ContainsKey("renderers"))
{
foreach (var renderer in root["renderers"].Seq().Children)
{
switch (renderer.NodeType)
{
case YamlNodeType.Scalar:
renderers.Add(
new ObjectModel
{
Type = RegisteredTypes.GetType(renderer.Val().String()),
CtorArgs = new object[] { },
}
);
break;
case YamlNodeType.Mapping:
renderers.Add(
new ObjectModel
{
Type = RegisteredTypes.GetType(renderer.Map().First().Key.Val().String()),
CtorArgs = parseArguments(renderer.Map().First().Value),
}
);
break;
}
}
}
// Add entities
if (root.Children.ContainsKey("entities"))
{
foreach (var entity in root["entities"].Seq().Children)
{
var model = parseEntity(entity);
entities.Add(model);
}
}
// Add actions
if (root.Children.ContainsKey("actions"))
{
foreach (var actionPair in root["actions"].Map())
{
var name = actionPair.Key.Val().String();
var yamlKeys = actionPair.Value;
String[] keys;
switch (yamlKeys.NodeType)
{
// Single key
case YamlNodeType.Scalar:
keys = new string[] { yamlKeys.Val().String() };
break;
// Many keys
case YamlNodeType.Sequence:
keys = yamlKeys.Seq().Select(n => n.Val().String()).ToArray();
break;
default:
throw new YamlException(
yamlKeys.Start,
yamlKeys.End,
"Expected a sequence or value node, but got none!"
);
}
var buttons = keys.Select(k => (Buttons)Enum.Parse(typeof(Buttons), k));
actions.Add(new InputAction(name, buttons.ToArray()));
}
}
return(new SceneInitializer(size, scaler, systems, renderers, entities, actions));
}
public TypesResolver(Func <Type[]> registerAction)
{
RegisteredTypes = registerAction?.Invoke();
resolveAction = (s) => RegisteredTypes.FirstOrDefault(t => t.Name == s);
}
/// <summary>
/// Gets the list of registered types.
/// </summary>
public static IEnumerable <Type> GetRegisteredTypes()
{
return(RegisteredTypes.Select(reg => reg.Key));
}
/// <inheritdoc />
public IKustoOptionsTypeBuilder RegisterAssembly(Assembly assembly)
{
RegisteredTypes.AddRange(assembly.GetTypes().Where(t => t.IsSubclassOf(typeof(TelemetryEvent))));
return(this);
}
/// <inheritdoc />
public IKustoOptionsTypeBuilder RegisterType <T>()
where T : TelemetryEvent
{
RegisteredTypes.Add(typeof(T));
return(this);
}
protected string CheckRegisteredType() => RegisteredTypes.TryGetValue(Arguments[0], out var type) && ((DataType = type) == type) ? null : $"invalid type '{Arguments[0]}'";
