public static Type GetDataWrapperType(DataTypeDescriptor dataTypeDescriptor) { Type wrapperType = TryGetWrapperType(dataTypeDescriptor.GetFullInterfaceName()); if (wrapperType != null) { return(wrapperType); } lock (_compilationLock) { wrapperType = TryGetWrapperType(dataTypeDescriptor.GetFullInterfaceName()); if (wrapperType != null) { return(wrapperType); } var codeGenerationBuilder = new CodeGenerationBuilder("DataWrapper:" + dataTypeDescriptor.GetFullInterfaceName()); DataWrapperCodeGenerator.AddDataWrapperClassCode(codeGenerationBuilder, dataTypeDescriptor); IEnumerable <Type> types = CodeGenerationManager.CompileRuntimeTempTypes(codeGenerationBuilder); return(types.Single()); } }
public CodeTypeDeclaration CreateClass() { var codeTypeDeclaration = new CodeTypeDeclaration(_entityBaseClassName) { IsClass = true, TypeAttributes = TypeAttributes.Public | TypeAttributes.Abstract }; codeTypeDeclaration.BaseTypes.Add(typeof(INotifyPropertyChanged)); codeTypeDeclaration.BaseTypes.Add(typeof(INotifyPropertyChanging)); codeTypeDeclaration.BaseTypes.Add(typeof(IEntity)); codeTypeDeclaration.BaseTypes.Add(_dataTypeDescriptor.GetFullInterfaceName()); codeTypeDeclaration.Members.Add(new CodeMemberField(new CodeTypeReference(typeof(DataSourceId).FullName), EntityClassesFieldNames.DataSourceIdFieldName)); codeTypeDeclaration.Members.Add(new CodeMemberField(new CodeTypeReference(typeof(DataScopeIdentifier).FullName), EntityClassesFieldNames.DataSourceIdScopeFieldName) { Attributes = MemberAttributes.Family }); codeTypeDeclaration.Members.Add(new CodeMemberField(new CodeTypeReference(typeof(CultureInfo).FullName), EntityClassesFieldNames.DataSourceIdCultureFieldName) { Attributes = MemberAttributes.Family }); AddConstructor(codeTypeDeclaration); AddIEntityImplementation(codeTypeDeclaration); AddIDataSourceProperty(codeTypeDeclaration); AddProperties(codeTypeDeclaration); EntityCodeGeneratorHelper.AddPropertyChanging(codeTypeDeclaration); EntityCodeGeneratorHelper.AddPropertyChanged(codeTypeDeclaration); return(codeTypeDeclaration); }
private static CodeTypeDeclaration CreateCodeTypeDeclaration(DataTypeDescriptor dataTypeDescriptor) { string interfaceTypeFullName = dataTypeDescriptor.GetFullInterfaceName(); var debugDisplayText = $"Data wrapper for '{interfaceTypeFullName}'"; foreach (var keyPropertyName in dataTypeDescriptor.KeyPropertyNames) { debugDisplayText += $", {keyPropertyName} = {{{keyPropertyName}}}"; } var labelFieldName = dataTypeDescriptor.LabelFieldName; if (!string.IsNullOrEmpty(labelFieldName) && !dataTypeDescriptor.KeyPropertyNames.Contains(labelFieldName)) { debugDisplayText += $", {labelFieldName} = {{{labelFieldName}}}"; } IEnumerable <Tuple <string, Type, bool> > properties = dataTypeDescriptor.Fields. Select(f => new Tuple <string, Type, bool>(f.Name, f.InstanceType, f.IsReadOnly)). Concat(new[] { new Tuple <string, Type, bool>("DataSourceId", typeof(DataSourceId), true) }); var declaration = new CodeTypeDeclaration { Name = CreateWrapperClassName(interfaceTypeFullName), IsClass = true, TypeAttributes = TypeAttributes.Public | TypeAttributes.Sealed }; declaration.BaseTypes.Add(interfaceTypeFullName); declaration.BaseTypes.Add(typeof(IDataWrapper)); declaration.CustomAttributes.AddRange(new[] { new CodeAttributeDeclaration( new CodeTypeReference(typeof(EditorBrowsableAttribute)), new CodeAttributeArgument( new CodeFieldReferenceExpression( new CodeTypeReferenceExpression(typeof(EditorBrowsableState)), EditorBrowsableState.Never.ToString() ) ) ), new CodeAttributeDeclaration( new CodeTypeReference(typeof(DebuggerDisplayAttribute)), new CodeAttributeArgument( new CodePrimitiveExpression(debugDisplayText) ) ) }); declaration.Members.Add(new CodeMemberField(interfaceTypeFullName, WrappedObjectName)); AddConstructor(declaration, interfaceTypeFullName); AddInterfaceProperties(declaration, properties); AddMethods(declaration, properties); return(declaration); }
/// <summary> /// This method will return type given by the dataTypeDescriptor. /// If the data type does not exist, one will be dynamically /// runtime code generated. /// </summary> /// <param name="dataTypeDescriptor"></param> /// <param name="forceReCompilation">If this is true a new type will be compiled regardless if one already exists.</param> /// <returns></returns> public static Type GetType(DataTypeDescriptor dataTypeDescriptor, bool forceReCompilation = false) { bool codeGenerationNeeded; Type type = TryGetType(dataTypeDescriptor, forceReCompilation, out codeGenerationNeeded); if (type != null) { return(type); } if (codeGenerationNeeded) { lock (_lock) { type = TypeManager.TryGetType(dataTypeDescriptor.GetFullInterfaceName()); if (type != null) { return(type); } var codeGenerationBuilder = new CodeGenerationBuilder("DataInterface: " + dataTypeDescriptor.Name); InterfaceCodeGenerator.AddAssemblyReferences(codeGenerationBuilder, dataTypeDescriptor); InterfaceCodeGenerator.AddInterfaceTypeCode(codeGenerationBuilder, dataTypeDescriptor); IEnumerable <Type> types = CodeGenerationManager.CompileRuntimeTempTypes(codeGenerationBuilder); return(types.Single()); } } return(null); }
/// <summary> /// This method will return the type of the empty data class type. /// If the type does not exist, one will be runtime code generated /// using the <paramref name="dataTypeDescriptor"/>. /// </summary> /// <param name="dataTypeDescriptor"> /// The data type descriptor for the data type to get /// the empty class type for. /// </param> /// <param name="forceReCompilation"> /// If this is true a new empty class will be /// compiled at runtime regardless if it exists or not. /// Use with caution! /// </param> /// <returns>The empty class type for the given data interface type.</returns> public static Type GetEmptyDataClassType(DataTypeDescriptor dataTypeDescriptor, bool forceReCompilation = false) { if (!string.IsNullOrEmpty(dataTypeDescriptor.BuildNewHandlerTypeName)) { return(GetEmptyClassFromBuildNewHandler(dataTypeDescriptor)); } if (forceReCompilation) { return(CreateEmptyDataClassType(dataTypeDescriptor)); } Type interfaceType = TypeManager.TryGetType(dataTypeDescriptor.GetFullInterfaceName()); string emptyClassFullName = EmptyDataClassCodeGenerator.GetEmptyClassTypeFullName(dataTypeDescriptor); Type emptyClassType = TypeManager.TryGetType(emptyClassFullName); bool isRecompileNeeded = true; if (interfaceType != null) { isRecompileNeeded = CodeGenerationManager.IsRecompileNeeded(interfaceType, new[] { emptyClassType }); } if (isRecompileNeeded) { lock (_lock) { interfaceType = TypeManager.TryGetType(dataTypeDescriptor.GetFullInterfaceName()); emptyClassType = TypeManager.TryGetType(emptyClassFullName); if (interfaceType != null) { isRecompileNeeded = CodeGenerationManager.IsRecompileNeeded(interfaceType, new[] { emptyClassType }); } if (isRecompileNeeded) { emptyClassType = CreateEmptyDataClassType(dataTypeDescriptor); } } } return(emptyClassType); }
internal static Type TryGetType(DataTypeDescriptor dataTypeDescriptor, bool forceReCompilation, out bool codeGenerationNeeded) { Verify.ArgumentNotNull(dataTypeDescriptor, "dataTypeDescriptor"); codeGenerationNeeded = false; Type type; if (!forceReCompilation) { type = TypeManager.TryGetType(dataTypeDescriptor.GetFullInterfaceName()); if (type != null) { return(type); } if (!dataTypeDescriptor.IsCodeGenerated) { type = TypeManager.TryGetType(dataTypeDescriptor.TypeManagerTypeName); if (type != null) { return(type); } } } if (!dataTypeDescriptor.IsCodeGenerated) { return(null); } if (forceReCompilation) { type = TypeManager.TryGetType(dataTypeDescriptor.GetFullInterfaceName()); if (type != null) { return(type); } } codeGenerationNeeded = true; return(null); }
private static CodeTypeDeclaration CreateCodeTypeDeclaration(DataTypeDescriptor dataTypeDescriptor) { string fullName = dataTypeDescriptor.GetFullInterfaceName(); IEnumerable <Tuple <string, Type, bool> > properties = dataTypeDescriptor.Fields. Select(f => new Tuple <string, Type, bool>(f.Name, f.InstanceType, f.IsReadOnly)). Concat(new[] { new Tuple <string, Type, bool>("DataSourceId", typeof(DataSourceId), true) }); return(CreateCodeTypeDeclaration(fullName, properties)); }
private static string GetTempFileName(DataTypeDescriptor typeDescriptor) { string folderPath = PathUtil.Resolve(GlobalSettingsFacade.GeneratedAssembliesDirectory); string filePath = Path.Combine(folderPath, typeDescriptor.GetFullInterfaceName() + ".cs"); if (filePath.Length > 255) { filePath = Path.Combine(folderPath, typeDescriptor.DataTypeId + ".cs"); } return(filePath); }
/// <summary> /// Gets the runtime data type for the given data type id. /// In case of generated types, this call might result in a interface code compilation. /// </summary> /// <param name="dataTypeDescriptor"> /// The DataTypeDescriptor for the data type. /// </param> /// <returns>Returns the data type. Never null.</returns> public static Type GetDataType(DataTypeDescriptor dataTypeDescriptor) { Verify.ArgumentNotNull(dataTypeDescriptor, "dataTypeDescriptor"); Type loadedDataType = _LoadedDataTypes.FirstOrDefault(f => f.FullName == dataTypeDescriptor.GetFullInterfaceName()); if (loadedDataType != null) { return(loadedDataType); } Type type = InterfaceCodeManager.GetType(dataTypeDescriptor); return(type); }
private void AddInterfaceTypeProperty(CodeTypeDeclaration declaration) { CodeMemberProperty property = new CodeMemberProperty(); property.Name = "_InterfaceType"; property.HasGet = true; property.HasSet = false; property.Type = new CodeTypeReference(typeof(Type)); property.Attributes = MemberAttributes.Public | MemberAttributes.Override; property.GetStatements.Add(new CodeMethodReturnStatement( new CodeTypeOfExpression(_dataTypeDescriptor.GetFullInterfaceName()) )); declaration.Members.Add(property); }
internal static string GenerateTableName(DataTypeDescriptor dataTypeDescriptor, DataScopeIdentifier dataScope, CultureInfo cultureInfo) { string tableName = dataTypeDescriptor.GetFullInterfaceName().Replace('.', '_'); switch (dataScope.Name) { case DataScopeIdentifier.PublicName: break; case DataScopeIdentifier.AdministratedName: tableName += "_Unpublished"; break; default: throw new InvalidOperationException("Unsupported data scope identifier: '{0}'".FormatWith(dataScope.Name)); } if (!cultureInfo.Name.IsNullOrEmpty()) { tableName += "_" + cultureInfo.Name.Replace('-', '_').Replace(' ', '_'); } return(tableName); }
internal static string GenerateTableName(DataTypeDescriptor dataTypeDescriptor) { return(dataTypeDescriptor.GetFullInterfaceName().Replace('.', '_')); }
private void AddAddDataMethod(CodeTypeDeclaration declaration) { const string dataContextVariableName = "dataContext"; const string dataToAddVariableName = "dataToAdd"; const string dataProivderContextVariableName = "dataProivderContext"; const string castedDataToAddVariableName = "castedDataToAdd"; const string entityClassVariableName = "entity"; CodeMemberMethod codeMethod = new CodeMemberMethod(); codeMethod.Name = "AddData"; codeMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final; codeMethod.ReturnType = new CodeTypeReference(typeof(IData)); codeMethod.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(ISqlDataContext)), dataContextVariableName)); codeMethod.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(IData)), dataToAddVariableName)); codeMethod.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(DataProviderContext)), dataProivderContextVariableName)); codeMethod.Statements.Add( new CodeVariableDeclarationStatement( new CodeTypeReference(_dataTypeDescriptor.GetFullInterfaceName()), castedDataToAddVariableName, new CodeCastExpression( new CodeTypeReference(_dataTypeDescriptor.GetFullInterfaceName()), new CodeVariableReferenceExpression(dataToAddVariableName) ) )); codeMethod.Statements.Add( new CodeVariableDeclarationStatement( new CodeTypeReference(_entityClassName), entityClassVariableName, new CodeObjectCreateExpression( new CodeTypeReference(_entityClassName), new CodeExpression[] { } ) )); foreach (string propertyName in _dataTypeDescriptor.Fields.Select(f => f.Name)) { codeMethod.Statements.Add(new CodeCommentStatement(string.Format("Interface property {0}", propertyName))); codeMethod.Statements.Add( new CodeAssignStatement( new CodePropertyReferenceExpression( new CodeVariableReferenceExpression(entityClassVariableName), propertyName ), new CodePropertyReferenceExpression( new CodeVariableReferenceExpression(castedDataToAddVariableName), propertyName ) )); } codeMethod.Statements.Add(new CodeCommentStatement("Done with properties")); codeMethod.Statements.Add( new CodeExpressionStatement( new CodeMethodInvokeExpression( new CodeVariableReferenceExpression(dataContextVariableName), "Add", new CodeExpression[] { new CodeVariableReferenceExpression(entityClassVariableName), new CodePrimitiveExpression(_dataContextFieldName) } ) )); codeMethod.Statements.Add( new CodeMethodReturnStatement( new CodeVariableReferenceExpression(entityClassVariableName) )); declaration.Members.Add(codeMethod); }
internal static string MakeDataProviderHelperClassName(DataTypeDescriptor dataTypeDescriptor) { return(string.Format("{0}DataProviderHelper", dataTypeDescriptor.GetFullInterfaceName().Replace('.', '_').Replace('+', '_'))); }
public void AlterStore(UpdateDataTypeDescriptor updateDataTypeDescriptor, bool forceCompile) { XmlDataProviderDocumentCache.ClearCache(); XmlProviderInterfaceConfigurationElement element = InterfaceConfigurationManipulator.Change(updateDataTypeDescriptor); if (forceCompile) { DataTypeDescriptor dataTypeDescriptor = updateDataTypeDescriptor.NewDataTypeDescriptor; Type dataProviderHelperType; Type dataIdClassType; bool typesExists = EnsureNeededTypes(dataTypeDescriptor, out dataProviderHelperType, out dataIdClassType, true); Verify.That(typesExists, "Could not find or code generated the type '{0}' or one of the needed helper types", dataTypeDescriptor.GetFullInterfaceName()); var xmlDataTypeStoreDataScopes = new List <XmlDataTypeStoreDataScope>(); foreach (DataScopeConfigurationElement dataScopeConfigurationElement in element.ConfigurationStores) { var xmlDataTypeStoreDataScope = new XmlDataTypeStoreDataScope { DataScopeName = dataScopeConfigurationElement.DataScope, CultureName = dataScopeConfigurationElement.CultureName, ElementName = dataScopeConfigurationElement.ElementName, Filename = Path.Combine(_fileStoreDirectory, dataScopeConfigurationElement.Filename) }; xmlDataTypeStoreDataScopes.Add(xmlDataTypeStoreDataScope); } var xmlDataTypeStoreCreator = new XmlDataTypeStoreCreator(_fileStoreDirectory); XmlDataTypeStore xmlDateTypeStore = xmlDataTypeStoreCreator.CreateStoreResult(dataTypeDescriptor, dataProviderHelperType, dataIdClassType, xmlDataTypeStoreDataScopes); Type interfaceType = DataTypeTypesManager.GetDataType(dataTypeDescriptor); UpdateDataTypeStore(dataTypeDescriptor, interfaceType, xmlDateTypeStore); } }
public CodeTypeDeclaration CreateClass() { var debugDisplayText = $"SQL entity for '{_dataTypeDescriptor.GetFullInterfaceName()}', culture = '{_localeCultureName}', scope = '{_dataScopeIdentifierName}'"; foreach (var keyPropertyName in _dataTypeDescriptor.KeyPropertyNames) { debugDisplayText += $", {keyPropertyName} = {{{keyPropertyName}}}"; } var labelFieldName = _dataTypeDescriptor.LabelFieldName; if (!string.IsNullOrEmpty(labelFieldName) && !_dataTypeDescriptor.KeyPropertyNames.Contains(labelFieldName)) { debugDisplayText += $", {labelFieldName} = {{{labelFieldName}}}"; } var codeTypeDeclaration = new CodeTypeDeclaration(_entityClassName) { IsClass = true, TypeAttributes = TypeAttributes.Public }; codeTypeDeclaration.BaseTypes.Add(new CodeTypeReference(_entityBaseClassName)); codeTypeDeclaration.CustomAttributes.AddRange(new [] { new CodeAttributeDeclaration( new CodeTypeReference(typeof(TableAttribute)), new CodeAttributeArgument("Name", new CodePrimitiveExpression(_tableName)) ), new CodeAttributeDeclaration( new CodeTypeReference(typeof(DebuggerDisplayAttribute)), new CodeAttributeArgument( new CodePrimitiveExpression(debugDisplayText) ) ) }); string propertyName = typeof(DataScopeIdentifier).GetProperties(BindingFlags.Static | BindingFlags.Public). Where(f => f.Name.Equals(_dataScopeIdentifierName, StringComparison.OrdinalIgnoreCase)). Select(f => f.Name). Single(); CodeMemberField constDataSourceIdCodeMemberField = new CodeMemberField( new CodeTypeReference(typeof(DataScopeIdentifier).FullName), EntityClassesFieldNames.DataSourceIdScopeConstFieldName ); constDataSourceIdCodeMemberField.Attributes = MemberAttributes.Static; constDataSourceIdCodeMemberField.InitExpression = new CodePropertyReferenceExpression( new CodeTypeReferenceExpression(typeof(DataScopeIdentifier)), propertyName ); codeTypeDeclaration.Members.Add(constDataSourceIdCodeMemberField); CodeMemberField constCultureCodeMemberField = new CodeMemberField( new CodeTypeReference(typeof(CultureInfo).FullName), EntityClassesFieldNames.DataSourceIdCultureConstFieldName ); constCultureCodeMemberField.Attributes = MemberAttributes.Static; constCultureCodeMemberField.InitExpression = new CodeObjectCreateExpression( new CodeTypeReference(typeof(CultureInfo)), new CodePrimitiveExpression(_localeCultureName) ); codeTypeDeclaration.Members.Add(constCultureCodeMemberField); AddEntityClassConstructor(codeTypeDeclaration); AddProperties(codeTypeDeclaration); return(codeTypeDeclaration); }
private static string GetStoreName(DataTypeDescriptor dtd) => dtd.GetFullInterfaceName();
private static string MakeNiceTypeFullName(DataTypeDescriptor dataTypeDescriptor) { return(dataTypeDescriptor.GetFullInterfaceName().Replace('.', '_').Replace('+', '_')); }
internal static string MakeEntityBaseClassName(DataTypeDescriptor dataTypeDescriptor) { return(string.Format("{0}EntityBase", dataTypeDescriptor.GetFullInterfaceName().Replace('.', '_').Replace('+', '_'))); }
internal static string GetEmptyClassTypeFullName(DataTypeDescriptor dataTypeDescriptor) { return(NamespaceName + "." + CreateClassName(dataTypeDescriptor.GetFullInterfaceName())); }