public DynamicTypeDescriptor GetTypeDescriptor(string typeName, string nameSpace = null) { List <DynamicTypeDescriptor> results = new List <DynamicTypeDescriptor>(); if (string.IsNullOrWhiteSpace(nameSpace)) { results = DynamicTypeDataRepository.DynamicTypeDescriptorsWhere(d => d.TypeName == typeName).ToList(); } else { DynamicNamespaceDescriptor nspace = DynamicTypeDataRepository.DynamicNamespaceDescriptorsWhere(ns => ns.Namespace == nameSpace).FirstOrDefault(); Args.ThrowIfNull(nspace, "nameSpace"); results = DynamicTypeDataRepository.DynamicTypeDescriptorsWhere(d => d.TypeName == typeName && d.DynamicNamespaceDescriptorId == nspace.Id).ToList(); } if (results.Count > 1) { FireEvent(MultipleTypesFoundWarning, new DynamicTypeManagerEventArgs { DynamicTypeDescriptors = results.ToArray(), TypeName = typeName, FoundTypes = string.Join(", ", results.Select(dt => $"{dt.DynamicNamespaceDescriptor.Namespace}.{dt.TypeName}").ToArray()) }); } return(results.FirstOrDefault()); }
public DynamicNamespaceDescriptor GetNamespaceDescriptor(string nameSpaceName) { DynamicNamespaceDescriptor result = DynamicTypeDataRepository.DynamicNamespaceDescriptorsWhere(d => d.Namespace == nameSpaceName).FirstOrDefault(); if (result != null) { result = DynamicTypeDataRepository.Retrieve <DynamicNamespaceDescriptor>(result.Id); } return(result); }
public void CanSpecifyNamespace() { DynamicTypeManager mgr = new DynamicTypeManager(new DynamicTypeDataRepository(), DataSettings.Default); mgr.DynamicTypeDataRepository.Query <DynamicTypeDescriptor>(d => d.Id > 0).Each(d => mgr.DynamicTypeDataRepository.Delete(d)); mgr.DynamicTypeDataRepository.Query <DynamicTypePropertyDescriptor>(p => p.Id > 0).Each(p => mgr.DynamicTypeDataRepository.Delete(p)); string testType = nameof(CanSpecifyNamespace); string testType2 = nameof(CanSpecifyNamespace) + "2"; string testNamespace = "My.Test.Namespace"; mgr.AddType(testType, testNamespace); mgr.AddType(testType2, testNamespace); DynamicNamespaceDescriptor ns = mgr.GetNamespaceDescriptor(testNamespace); Expect.IsNotNull(ns, "namspace was null"); Expect.IsTrue(ns.Types.Count == 2); }
protected DynamicNamespaceDescriptor EnsureNamespace(string nameSpace = null) { lock (_nameSpaceLock) { nameSpace = nameSpace ?? DynamicNamespaceDescriptor.DefaultNamespace; DynamicNamespaceDescriptor nspace = DynamicTypeDataRepository.Query <DynamicNamespaceDescriptor>(ns => ns.Namespace == nameSpace).FirstOrDefault(); if (nspace == null) { nspace = new DynamicNamespaceDescriptor() { Namespace = nameSpace }; nspace = DynamicTypeDataRepository.Save(nspace); } return(nspace); } }
protected DynamicTypeDescriptor EnsureType(string typeName, DynamicNamespaceDescriptor nspace) { lock (_typeDescriptorLock) { DynamicTypeDescriptor descriptor = DynamicTypeDataRepository.Query <DynamicTypeDescriptor>(td => td.TypeName == typeName).FirstOrDefault(); if (descriptor == null) { descriptor = new DynamicTypeDescriptor() { DynamicNamespaceDescriptorId = nspace.Id, TypeName = typeName }; descriptor = DynamicTypeDataRepository.Save(descriptor); } return(descriptor); } }
public void AssociationsAreMade() { DynamicTypeManager mgr = new DynamicTypeManager(new DynamicTypeDataRepository(), DataSettings.Default); DynamicNamespaceDescriptor ns = new DynamicNamespaceDescriptor { Namespace = $"Test.Name.Space.{nameof(AssociationsAreMade)}" }; ns = mgr.DynamicTypeDataRepository.Save(ns); DynamicTypeDescriptor typeDescriptor = new DynamicTypeDescriptor { DynamicNamespaceDescriptorId = ns.Id }; Expect.IsNull(typeDescriptor.DynamicNamespaceDescriptor); typeDescriptor = mgr.DynamicTypeDataRepository.Save(typeDescriptor); Expect.IsNotNull(typeDescriptor.DynamicNamespaceDescriptor); Expect.AreEqual(ns, typeDescriptor.DynamicNamespaceDescriptor); }
public DynamicTypePropertyDescriptor AddProperty(string typeName, string propertyName, string propertyType, string nameSpace = null) { Type type = Type.GetType(propertyType); if (type == null) { type = Type.GetType($"System.{propertyType}"); } Args.ThrowIfNull(type, "propertyType"); nameSpace = nameSpace ?? DynamicNamespaceDescriptor.DefaultNamespace; DynamicNamespaceDescriptor nameSpaceDescriptor = EnsureNamespace(nameSpace); DynamicTypeDescriptor typeDescriptor = EnsureType(typeName, nameSpaceDescriptor); return(SetDynamicTypePropertyDescriptor(new DynamicTypePropertyDescriptor { DynamicTypeDescriptorId = typeDescriptor.Id, ParentTypeName = typeDescriptor.TypeName, PropertyType = propertyType, PropertyName = propertyName })); }
public Assembly GetAssembly(string nameSpace = null) { List <DynamicTypeDescriptor> types = new List <DynamicTypeDescriptor>(); DynamicNamespaceDescriptor ns = null; if (nameSpace != null) { ns = GetNamespaceDescriptor(nameSpace); } else { ns = DynamicTypeDataRepository.GetOneDynamicNamespaceDescriptorWhere(d => d.Namespace == DynamicNamespaceDescriptor.DefaultNamespace); } types = DynamicTypeDataRepository.DynamicTypeDescriptorsWhere(t => t.DynamicNamespaceDescriptorId == ns.Id).ToList(); StringBuilder src = new StringBuilder(); foreach (DynamicTypeDescriptor typeDescriptor in types) { DtoModel dto = new DtoModel ( ns.Namespace, GetClrTypeName(typeDescriptor.TypeName), typeDescriptor.Properties.Select(p => new DtoPropertyModel { PropertyName = GetClrPropertyName(p.PropertyName), PropertyType = GetClrTypeName(p.PropertyType) }).ToArray() ); src.AppendLine(dto.Render()); } CompilerResults results = AdHocCSharpCompiler.CompileSource(src.ToString(), $"{ns.Namespace}.dll"); if (results.Errors.Count > 0) { throw new CompilationException(results); } return(results.CompiledAssembly); }
protected DynamicTypeDescriptor EnsureType(string typeName, string nameSpace = null) { DynamicNamespaceDescriptor nspace = EnsureNamespace(nameSpace); return(EnsureType(typeName, nspace)); }