/// <summary> /// Generates the business logic class type. We override this to control the base class and imports /// </summary> /// <param name="codeGenContext">The context to use to generate code.</param> /// <param name="codeNamespace">The namespace into which to generate code.</param> /// <param name="className">The name to use for the class.</param> /// <returns>The new type</returns> protected override CodeTypeDeclaration CreateBusinessLogicClass(CodeGenContext codeGenContext, CodeNamespace codeNamespace, string className) { // Add an import for our domain service foreach (string import in BusinessLogicClassConstants.LinqToEntitiesDbImports) { codeNamespace.Imports.Add(new CodeNamespaceImport(import)); } // Add an import for the namespace of the DomainContext if (this.ContextType.Namespace != codeNamespace.Name) { codeNamespace.Imports.Add(new CodeNamespaceImport(BusinessLogicClassConstants.DbContextNamespace)); codeNamespace.Imports.Add(new CodeNamespaceImport(this.ContextType.Namespace)); } // Add to the set of known references codeGenContext.AddReference(typeof(EntityState).Assembly.FullName); // We used to add OpenRiaServices.DomainServices.EntityFramework, but due to // vstfdevdiv/DevDiv2 Bug 442272 - Domain Service Wizard failing when an EF DbContext is selected, // we need to avoid doing that. if (DbContextUtilities.DbContextTypeReference != null) { codeGenContext.AddReference(DbContextUtilities.DbContextTypeReference.Assembly.FullName); } CodeTypeDeclaration businessLogicClass = CodeGenUtilities.CreateTypeDeclaration(className, codeNamespace.Name); CodeTypeReference baseClass = new CodeTypeReference(BusinessLogicClassConstants.DbDomainServiceTypeName, new CodeTypeReference(this.ContextType.Name)); businessLogicClass.BaseTypes.Add(baseClass); return(businessLogicClass); }
/// <summary> /// Creates the business logic class. Overridden to add imports, base class, etc. /// </summary> /// <param name="codeGenContext">The code gen context.></param> /// <param name="codeNamespace">The namespace name.</param> /// <param name="className">The class name.</param> /// <returns>the new type</returns> protected override CodeTypeDeclaration CreateBusinessLogicClass(CodeGenContext codeGenContext, CodeNamespace codeNamespace, string className) { Debug.Assert(LinqToSqlContext.linqToSqlDomainServiceAssemblyPath != null, "Unexpected method call when LinqToSqlDomainService assembly path has not been initialized!"); if (LinqToSqlContext.linqToSqlDomainServiceAssemblyPath == null) { return(null); } // Add an import for our domain service foreach (string import in BusinessLogicClassConstants.LinqToSqlImports) { codeNamespace.Imports.Add(new CodeNamespaceImport(import)); } // Add an import for the namespace of the DomainContext if (this.ContextType.Namespace != codeNamespace.Name) { codeNamespace.Imports.Add(new CodeNamespaceImport(this.ContextType.Namespace)); } // Add to the set of known references codeGenContext.AddReference(typeof(DataContext).Assembly.FullName); codeGenContext.AddReference(LinqToSqlContext.linqToSqlDomainServiceAssemblyPath); CodeTypeDeclaration businessLogicClass = CodeGenUtilities.CreateTypeDeclaration(className, codeNamespace.Name); CodeTypeReference baseClass = new CodeTypeReference(BusinessLogicClassConstants.LinqToSqlDomainServiceTypeName, new CodeTypeReference(this.ContextType.Name)); businessLogicClass.BaseTypes.Add(baseClass); return(businessLogicClass); }
/// <summary> /// Generates the business logic class type. We override this to control the base class and imports /// </summary> /// <param name="codeGenContext">The context to use to generate code.</param> /// <param name="codeNamespace">The namespace into which to generate code.</param> /// <param name="className">The name to use for the class.</param> /// <returns>The new type</returns> protected override CodeTypeDeclaration CreateBusinessLogicClass(CodeGenContext codeGenContext, CodeNamespace codeNamespace, string className) { // Add an import for our domain service foreach (string import in BusinessLogicClassConstants.LinqToEntitiesImports) { codeNamespace.Imports.Add(new CodeNamespaceImport(import)); } // Add an import for the namespace of the DomainContext if (this.ContextType.Namespace != codeNamespace.Name) { codeNamespace.Imports.Add(new CodeNamespaceImport(this.ContextType.Namespace)); } // Add to the set of known references codeGenContext.AddReference(typeof(ObjectContext).Assembly.FullName); codeGenContext.AddReference(typeof(LinqToEntitiesDomainService <>).Assembly.FullName); CodeTypeDeclaration businessLogicClass = CodeGenUtilities.CreateTypeDeclaration(className, codeNamespace.Name); CodeTypeReference baseClass = new CodeTypeReference(BusinessLogicClassConstants.LinqToEntitiesDomainServiceTypeName, new CodeTypeReference(this.ContextType.Name)); businessLogicClass.BaseTypes.Add(baseClass); return(businessLogicClass); }
/// <summary> /// Creates the entire business logic class within the specified namespace name /// </summary> /// <param name="codeGenContext">The context into which to generate code. It cannot be null.</param> /// <param name="className">The name of the class to generate. It cannot be null or empty.</param> /// <param name="namespaceName">The namespace to use for the generated code. It cannot be empty.</param> protected void GenerateBusinessLogicClass(CodeGenContext codeGenContext, string className, string namespaceName) { if (codeGenContext == null) { throw new ArgumentNullException("codeGenContext"); } if (string.IsNullOrEmpty(className)) { throw new ArgumentNullException("className"); } if (string.IsNullOrEmpty(namespaceName)) { throw new ArgumentNullException("namespaceName"); } // namespace XXX { } CodeNamespace ns = codeGenContext.GetOrGenNamespace(namespaceName); // public class $classname$ { } CodeTypeDeclaration businessLogicClass = this.CreateBusinessLogicClass(codeGenContext, ns, className); ns.Types.Add(businessLogicClass); // Class-level Xml comments // Empty class gets its own comment because it has no ContextType to describe string remarksComment; if (this.ContextType == null) { remarksComment = Resources.BusinessLogicClass_Class_Remarks_Empty; } else { remarksComment = String.Format(CultureInfo.CurrentCulture, Resources.BusinessLogicClass_Class_Remarks, this.ContextType.Name); } // Add developer comment explaining what this class does businessLogicClass.Comments.Add(new CodeCommentStatement(remarksComment, false)); // Add [RequiresAuthentication] as a comment if (this.ContextType != null) { remarksComment = codeGenContext.IsCSharp ? Resources.BusinessLogicClass_RequiresAuthentication_CSharp : Resources.BusinessLogicClass_RequiresAuthentication_VB; businessLogicClass.Comments.Add(new CodeCommentStatement(remarksComment, false)); } if (this.IsClientAccessEnabled) { // [EnableClientAccess] CodeAttributeDeclaration attr = CodeGenUtilities.CreateAttributeDeclaration(BusinessLogicClassConstants.EnableClientAccessAttributeTypeName); businessLogicClass.CustomAttributes.Add(attr); } else { // if not enabled, add a comment explaining how to enable it businessLogicClass.Comments.Add(new CodeCommentStatement(Resources.BusinessLogicClass_EnableClientAccess_Comment)); } // Gen all domain operation entries // Sort by name for baseline predictability foreach (BusinessLogicEntity entity in this.Entities.OrderBy(e => e.Name)) { if (entity.IsIncluded) { // Add an import for this entity's namespace if needed // This is necessary only when entities exist in a different namespace from the context CodeGenUtilities.AddImportIfNeeded(ns, entity.ClrType.Namespace); this.GenerateEntityDomainOperationEntries(codeGenContext, businessLogicClass, entity); } } // If any private helper methods were generated, append them now. // We sort by their keys to give baseline predictability. Dictionary <string, CodeTypeMember> helpers = BusinessLogicContext.GetHelperMemberDictionary(businessLogicClass); foreach (string key in helpers.Keys.OrderBy(s => s)) { businessLogicClass.Members.Add(helpers[key]); } // If we exposed an OData endpoint, add a reference to the OData assembly // so it appears in the server project, allowing the user to chose // CopyLocal=true for bin deploy scenarios if (this.IsODataEndpointEnabled) { codeGenContext.AddReference(typeof(ODataEndpointFactory).Assembly.FullName); } }
/// <summary> /// Creates the entire business logic class within the specified namespace name /// </summary> /// <param name="codeGenContext">The context into which to generate code. It cannot be null.</param> /// <param name="className">The name of the class to generate. It cannot be null or empty.</param> /// <param name="namespaceName">The namespace to use for the generated code. It cannot be empty.</param> protected void GenerateBusinessLogicClass(CodeGenContext codeGenContext, string className, string namespaceName) { if (codeGenContext == null) { throw new ArgumentNullException("codeGenContext"); } if (string.IsNullOrEmpty(className)) { throw new ArgumentNullException("className"); } if (string.IsNullOrEmpty(namespaceName)) { throw new ArgumentNullException("namespaceName"); } // namespace XXX { } CodeNamespace ns = codeGenContext.GetOrGenNamespace(namespaceName); // public class $classname$ { } CodeTypeDeclaration businessLogicClass = this.CreateBusinessLogicClass(codeGenContext, ns, className); ns.Types.Add(businessLogicClass); // Class-level Xml comments // Empty class gets its own comment because it has no ContextType to describe string remarksComment; if (this.ContextType == null) { remarksComment = Resources.BusinessLogicClass_Class_Remarks_Empty; } else { remarksComment = String.Format(CultureInfo.CurrentCulture, Resources.BusinessLogicClass_Class_Remarks, this.ContextType.Name); } // Add developer comment explaining what this class does businessLogicClass.Comments.Add(new CodeCommentStatement(remarksComment, false)); // Add [RequiresAuthentication] as a comment if (this.ContextType != null) { remarksComment = codeGenContext.IsCSharp ? Resources.BusinessLogicClass_RequiresAuthentication_CSharp : Resources.BusinessLogicClass_RequiresAuthentication_VB; businessLogicClass.Comments.Add(new CodeCommentStatement(remarksComment, false)); } if (this.IsClientAccessEnabled) { // [EnableClientAccess] CodeAttributeDeclaration attr = CodeGenUtilities.CreateAttributeDeclaration(BusinessLogicClassConstants.EnableClientAccessAttributeTypeName); businessLogicClass.CustomAttributes.Add(attr); } else { // if not enabled, add a comment explaining how to enable it businessLogicClass.Comments.Add(new CodeCommentStatement(Resources.BusinessLogicClass_EnableClientAccess_Comment)); } // Gen all domain operation entries // Sort by name for baseline predictability foreach (BusinessLogicEntity entity in this.Entities.OrderBy(e => e.Name)) { if (entity.IsIncluded) { // Add an import for this entity's namespace if needed // This is necessary only when entities exist in a different namespace from the context CodeGenUtilities.AddImportIfNeeded(ns, entity.ClrType.Namespace); this.GenerateEntityDomainOperationEntries(codeGenContext, businessLogicClass, entity); } } // If any private helper methods were generated, append them now. // We sort by their keys to give baseline predictability. Dictionary<string, CodeTypeMember> helpers = BusinessLogicContext.GetHelperMemberDictionary(businessLogicClass); foreach (string key in helpers.Keys.OrderBy(s => s)) { businessLogicClass.Members.Add(helpers[key]); } // If we exposed an OData endpoint, add a reference to the OData assembly // so it appears in the server project, allowing the user to chose // CopyLocal=true for bin deploy scenarios if (this.IsODataEndpointEnabled) { codeGenContext.AddReference(typeof(ODataEndpointFactory).Assembly.FullName); } }