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));
}
