精华内容
下载资源
问答
  • 计算机图形学课程实验,有源代码和报告,实验内容是实现迭代次数6次以内knok曲线(直线、三角形生成元),还有日地月模型。
  • 用有限方法求解非均匀阻尼系统模式分析 APDL-Task_1.txt包含在Ansys APDL中生成和求解3-D FEM结构模型代码。 该脚本应与“ ExportData_10_modes_imag.inp”(导出已分析FEM物理特性10种模式虚部),“ ...
  • 什么是生成元? 假设有质数P,求P运算,那么结果集为0到P-1,例如P=13,求0到12的乘法的P运算,结果如表...同样的,当G=6、7和11的时候,结果各不相同,也是13的生成元。 也就是说,生成元中没有重复的元素。 ...

    什么是生成元?

    假设有质数P,求模P运算,那么结果集为0到P-1,例如P=13,求0到12的乘法的模P运算,结果如表所示

    当G=2时,模的结果都不相同,所以2是13的生成元。

    同样的,当G=6、7和11的时候,结果各不相同,也是13的生成元。

    也就是说,生成元中没有重复的元素。

    展开全文
  • 关于代码生成文章网上已经多不能太多了,在6年前我写过两篇文章介绍代码生成,一篇主要代码生成7种模型架构设计思想:也谈代码生成器,另外一篇再谈代码生成器介绍了基于其中一种模型架构实践文章,...

      关于代码生成器的文章网上已经多的不能太多了,在6年前我写过两篇文章介绍代码生成器的,一篇主要代码生成器的7种模型架构设计思想:也谈代码生成器,另外一篇再谈代码生成器介绍了基于其中一种模型架构的实践文章,现在回顾一下6年前的文章拿到现在其设计思想也从不过时,呵呵自大了。好了废话不多说,今天给大家分享一下利用ELinq内置的数据库元数据模型和T4 模版引擎制作多文件实体代码生成器。(ELinq:是一个轻量简单易用的开源Linq ORM数据访问组件,支持Nullable类型和枚举类型,支持根据实体类自动建库建表建关系,支持根据数据库通过T4模版自动生成实体代码,对Linq 的谓词提供了完美的支持,旨在让绝大部份的主流数据库都使用 Linq 来进行程序开发,让开发人员访问数据库从SQL中解放出来,易学易用上手快,配置简单,并且提供了源代码下载,方便定制。支持多数据库,目前支持 Access、SQLServer、SqlCE、  SQLite、MySQL、ORACLE,未来还会支持更多的数据库

      本文使用以下工具:

    1. VS2010 SP1
    2. T4 模版引擎
    3. ELinq 数据库元数据模型(借助ELinq强大的ORM框架,支持多种数据库)
    4. SqlServer 数据库

        操作步骤

    1.   创建控制台应用程序 Demo
    2.   通过Nuget添加ELinq 的引用:在Nuget控制台中输入:install-package ELinq, Nuget会自动的将你引用的库的这个库的依赖文件添加到你的项目引用中.
    3.   配置SqlServer数据库连接信息。添加App.Config 文件,并添加如下的配置信
      <add name="Northwind" connectionString="Data Source=.;Initial Catalog=northwind;Persist Security Info=True;User ID=sa;Password="
      providerName="System.Data.SqlClient" />

       

    4. 编译项目,保证ELinq已经输出到Bin目录下,为T4 模版准备

    5. 添加T4 文件,MultipleOutputHelper.ttinclude,该文件的作用是:生成多文件,获取当前活动项目的信息(配置文件路径,项目路径,数据路径,AppConfig等)
      View Code
      <#@ template language="C#" debug="True" hostspecific="True" #>
      <#@ assembly name="System.Core"
      #><#@ assembly name="EnvDTE"
      #><#@ assembly name="System.Xml"
      #><#@ assembly name="System.Xml.Linq"
      #><#@ assembly name="System.Configuration" #>
      <#@ import namespace="System"
      #><#@ import namespace="System.CodeDom"
      #><#@ import namespace="System.CodeDom.Compiler"
      #><#@ import namespace="System.Collections.Generic"
      #><#@ import namespace="System.IO"
      #><#@ import namespace="System.Linq"
      #><#@ import namespace="System.Reflection"
      #><#@ import namespace="System.Text"
      #><#@ import namespace="System.Xml.Linq"
      #><#@ import namespace="Microsoft.VisualStudio.TextTemplating"
      #><#@ import namespace="System.Configuration" #>
      <#+
          public ConnectionStringSettings GetConnectionStringSettings(string connectionStringName){
              if (string.IsNullOrEmpty(connectionStringName))
                  throw new ArgumentNullException("connectionStringName");
              var configFile = new ExeConfigurationFileMap();
              configFile.ExeConfigFilename = GetConfigPath();
              if (string.IsNullOrEmpty(configFile.ExeConfigFilename))
                  throw new ArgumentNullException("The project does not contain App.config or Web.config file.");
              var config = System.Configuration.ConfigurationManager.OpenMappedExeConfiguration(configFile, ConfigurationUserLevel.None);
              var connSection = config.ConnectionStrings;
              var connectionStringSettings = connSection.ConnectionStrings[connectionStringName];
              if(connectionStringSettings == null)
                  throw new ArgumentNullException("connectionStringName not exists");
              return connectionStringSettings;
          }
          public string GetConfigPath(){
              EnvDTE.Project project = GetCurrentProject();
              foreach (EnvDTE.ProjectItem item in project.ProjectItems){
                  if (item.Name.Equals("App.config", StringComparison.InvariantCultureIgnoreCase) || item.Name.Equals("Web.config", StringComparison.InvariantCultureIgnoreCase))
                  return GetProjectPath() + "\\" + item.Name;
              }
              return String.Empty;
          }
          public string GetProjectPath(){
              EnvDTE.Project project = GetCurrentProject();
              System.IO.FileInfo info = new System.IO.FileInfo(project.FullName);
              return info.Directory.FullName;
          }
          public string GetDataDirectory(){
              EnvDTE.Project project = GetCurrentProject();
              return System.IO.Path.GetDirectoryName(project.FileName) + "\\App_Data\\";
          }
          
          public EnvDTE.Project GetCurrentProject(){
              IServiceProvider _ServiceProvider = (IServiceProvider)Host;
              if (_ServiceProvider == null)
                  throw new Exception("Host property returned unexpected value (null)");
      
              EnvDTE.DTE dte = (EnvDTE.DTE)_ServiceProvider.GetService(typeof(EnvDTE.DTE));
              if (dte == null)
                  throw new Exception("Unable to retrieve EnvDTE.DTE");
      
              Array activeSolutionProjects = (Array)dte.ActiveSolutionProjects;
              if (activeSolutionProjects == null)
                  throw new Exception("DTE.ActiveSolutionProjects returned null");
      
              EnvDTE.Project dteProject = (EnvDTE.Project)activeSolutionProjects.GetValue(0);
              if (dteProject == null)
                  throw new Exception("DTE.ActiveSolutionProjects[0] returned null");
      
              return dteProject;
      }
          // Manager class records the various blocks so it can split them up
      class Manager {
          private class Block {
              public String Name;
              public int Start, Length;
              public bool IncludeInDefault;
          }
      
          private Block currentBlock;
          private List<Block> files = new List<Block>();
          private Block footer = new Block();
          private Block header = new Block();
          private ITextTemplatingEngineHost host;
          private StringBuilder template;
          protected List<String> generatedFileNames = new List<String>();
      
          public static Manager Create(ITextTemplatingEngineHost host, StringBuilder template) {
              return (host is IServiceProvider) ? new VSManager(host, template) : new Manager(host, template);
          }
      
          public void StartNewFile(String name) {
              if (name == null)
                  throw new ArgumentNullException("name");
              CurrentBlock = new Block { Name = name };
          }
      
          public void StartFooter(bool includeInDefault = true) {
              CurrentBlock = footer;
              footer.IncludeInDefault = includeInDefault;
          }
      
          public void StartHeader(bool includeInDefault = true) {
              CurrentBlock = header;
              header.IncludeInDefault = includeInDefault;
          }
      
          public void EndBlock() {
              if (CurrentBlock == null)
                  return;
              CurrentBlock.Length = template.Length - CurrentBlock.Start;
              if (CurrentBlock != header && CurrentBlock != footer)
                  files.Add(CurrentBlock);
              currentBlock = null;
          }
      
          public virtual void Process(bool split, bool sync = true) {
              if (split) {
                  EndBlock();
                  String headerText = template.ToString(header.Start, header.Length);
                  String footerText = template.ToString(footer.Start, footer.Length);
                  String outputPath = Path.GetDirectoryName(host.TemplateFile);
                  files.Reverse();
                  if (!footer.IncludeInDefault)
                      template.Remove(footer.Start, footer.Length);
                  foreach(Block block in files) {
                      String fileName = Path.Combine(outputPath, block.Name);
                      String content = headerText + template.ToString(block.Start, block.Length) + footerText;
                      generatedFileNames.Add(fileName);
                      CreateFile(fileName, content);
                      template.Remove(block.Start, block.Length);
                  }
                  if (!header.IncludeInDefault)
                      template.Remove(header.Start, header.Length);
              }
          }
      
          protected virtual void CreateFile(String fileName, String content) {
              if (IsFileContentDifferent(fileName, content))
                  File.WriteAllText(fileName, content);
          }
      
          public virtual String GetCustomToolNamespace(String fileName) {
              return null;
          }
      
          public virtual String DefaultProjectNamespace {
              get { return null; }
          }
      
          protected bool IsFileContentDifferent(String fileName, String newContent) {
              return !(File.Exists(fileName) && File.ReadAllText(fileName) == newContent);
          }
      
          private Manager(ITextTemplatingEngineHost host, StringBuilder template) {
              this.host = host;
              this.template = template;
          }
      
          private Block CurrentBlock {
              get { return currentBlock; }
              set {
                  if (CurrentBlock != null)
                      EndBlock();
                  if (value != null)
                      value.Start = template.Length;
                  currentBlock = value;
              }
          }
      
          private class VSManager: Manager {
              private EnvDTE.ProjectItem templateProjectItem;
              private EnvDTE.DTE dte;
              private Action<String> checkOutAction;
              private Action<IEnumerable<String>> projectSyncAction;
      
              public override String DefaultProjectNamespace {
                  get {
                      return templateProjectItem.ContainingProject.Properties.Item("DefaultNamespace").Value.ToString();
                  }
              }
      
              public override String GetCustomToolNamespace(string fileName) {
                  return dte.Solution.FindProjectItem(fileName).Properties.Item("CustomToolNamespace").Value.ToString();
              }
      
              public override void Process(bool split, bool sync) {
                  if (templateProjectItem.ProjectItems == null)
                      return;
                  base.Process(split, sync);
                  if (sync)
                      projectSyncAction.EndInvoke(projectSyncAction.BeginInvoke(generatedFileNames, null, null));
              }
      
              protected override void CreateFile(String fileName, String content) {
                  if (IsFileContentDifferent(fileName, content)) {
                      CheckoutFileIfRequired(fileName);
                      File.WriteAllText(fileName, content);
                  }
              }
      
              internal VSManager(ITextTemplatingEngineHost host, StringBuilder template)
                  : base(host, template) {
                  var hostServiceProvider = (IServiceProvider) host;
                  if (hostServiceProvider == null)
                      throw new ArgumentNullException("Could not obtain IServiceProvider");
                  dte = (EnvDTE.DTE) hostServiceProvider.GetService(typeof(EnvDTE.DTE));
                  if (dte == null)
                      throw new ArgumentNullException("Could not obtain DTE from host");
                  templateProjectItem = dte.Solution.FindProjectItem(host.TemplateFile);
                  checkOutAction = (String fileName) => dte.SourceControl.CheckOutItem(fileName);
                  projectSyncAction = (IEnumerable<String> keepFileNames) => ProjectSync(templateProjectItem, keepFileNames);
              }
      
              private static void ProjectSync(EnvDTE.ProjectItem templateProjectItem, IEnumerable<String> keepFileNames) {
                  var keepFileNameSet = new HashSet<String>(keepFileNames);
                  var projectFiles = new Dictionary<String, EnvDTE.ProjectItem>();
                  var originalFilePrefix = Path.GetFileNameWithoutExtension(templateProjectItem.get_FileNames(0)) + ".";
                  foreach(EnvDTE.ProjectItem projectItem in templateProjectItem.ProjectItems)
                      projectFiles.Add(projectItem.get_FileNames(0), projectItem);
      
                  // Remove unused items from the project
                  foreach(var pair in projectFiles)
                      if (!keepFileNames.Contains(pair.Key) && !(Path.GetFileNameWithoutExtension(pair.Key) + ".").StartsWith(originalFilePrefix))
                          pair.Value.Delete();
      
                  // Add missing files to the project
                  foreach(String fileName in keepFileNameSet)
                      if (!projectFiles.ContainsKey(fileName))
                          templateProjectItem.ProjectItems.AddFromFile(fileName);
              }
      
              private void CheckoutFileIfRequired(String fileName) {
                  var sc = dte.SourceControl;
                  if (sc != null && sc.IsItemUnderSCC(fileName) && !sc.IsItemCheckedOut(fileName))
                      checkOutAction.EndInvoke(checkOutAction.BeginInvoke(fileName, null, null));
              }
          }
      } #>
        1 <#@ template language="C#" debug="True" hostspecific="True" #>
        2 <#@ assembly name="System.Core"
        3 #><#@ assembly name="EnvDTE"
        4 #><#@ assembly name="System.Xml"
        5 #><#@ assembly name="System.Xml.Linq"
        6 #><#@ assembly name="System.Configuration" #>
        7 <#@ import namespace="System"
        8 #><#@ import namespace="System.CodeDom"
        9 #><#@ import namespace="System.CodeDom.Compiler"
       10 #><#@ import namespace="System.Collections.Generic"
       11 #><#@ import namespace="System.IO"
       12 #><#@ import namespace="System.Linq"
       13 #><#@ import namespace="System.Reflection"
       14 #><#@ import namespace="System.Text"
       15 #><#@ import namespace="System.Xml.Linq"
       16 #><#@ import namespace="Microsoft.VisualStudio.TextTemplating"
       17 #><#@ import namespace="System.Configuration" #>
       18 <#+
       19     public ConnectionStringSettings GetConnectionStringSettings(string connectionStringName){
       20         if (string.IsNullOrEmpty(connectionStringName))
       21             throw new ArgumentNullException("connectionStringName");
       22         var configFile = new ExeConfigurationFileMap();
       23         configFile.ExeConfigFilename = GetConfigPath();
       24         if (string.IsNullOrEmpty(configFile.ExeConfigFilename))
       25             throw new ArgumentNullException("The project does not contain App.config or Web.config file.");
       26         var config = System.Configuration.ConfigurationManager.OpenMappedExeConfiguration(configFile, ConfigurationUserLevel.None);
       27         var connSection = config.ConnectionStrings;
       28         var connectionStringSettings = connSection.ConnectionStrings[connectionStringName];
       29         if(connectionStringSettings == null)
       30             throw new ArgumentNullException("connectionStringName not exists");
       31         return connectionStringSettings;
       32     }
       33     public string GetConfigPath(){
       34         EnvDTE.Project project = GetCurrentProject();
       35         foreach (EnvDTE.ProjectItem item in project.ProjectItems){
       36             if (item.Name.Equals("App.config", StringComparison.InvariantCultureIgnoreCase) || item.Name.Equals("Web.config", StringComparison.InvariantCultureIgnoreCase))
       37             return GetProjectPath() + "\\" + item.Name;
       38         }
       39         return String.Empty;
       40     }
       41     public string GetProjectPath(){
       42         EnvDTE.Project project = GetCurrentProject();
       43         System.IO.FileInfo info = new System.IO.FileInfo(project.FullName);
       44         return info.Directory.FullName;
       45     }
       46     public string GetDataDirectory(){
       47         EnvDTE.Project project = GetCurrentProject();
       48         return System.IO.Path.GetDirectoryName(project.FileName) + "\\App_Data\\";
       49     }
       50     
       51     public EnvDTE.Project GetCurrentProject(){
       52         IServiceProvider _ServiceProvider = (IServiceProvider)Host;
       53         if (_ServiceProvider == null)
       54             throw new Exception("Host property returned unexpected value (null)");
       55 
       56         EnvDTE.DTE dte = (EnvDTE.DTE)_ServiceProvider.GetService(typeof(EnvDTE.DTE));
       57         if (dte == null)
       58             throw new Exception("Unable to retrieve EnvDTE.DTE");
       59 
       60         Array activeSolutionProjects = (Array)dte.ActiveSolutionProjects;
       61         if (activeSolutionProjects == null)
       62             throw new Exception("DTE.ActiveSolutionProjects returned null");
       63 
       64         EnvDTE.Project dteProject = (EnvDTE.Project)activeSolutionProjects.GetValue(0);
       65         if (dteProject == null)
       66             throw new Exception("DTE.ActiveSolutionProjects[0] returned null");
       67 
       68         return dteProject;
       69 }
       70     // Manager class records the various blocks so it can split them up
       71 class Manager {
       72     private class Block {
       73         public String Name;
       74         public int Start, Length;
       75         public bool IncludeInDefault;
       76     }
       77 
       78     private Block currentBlock;
       79     private List<Block> files = new List<Block>();
       80     private Block footer = new Block();
       81     private Block header = new Block();
       82     private ITextTemplatingEngineHost host;
       83     private StringBuilder template;
       84     protected List<String> generatedFileNames = new List<String>();
       85 
       86     public static Manager Create(ITextTemplatingEngineHost host, StringBuilder template) {
       87         return (host is IServiceProvider) ? new VSManager(host, template) : new Manager(host, template);
       88     }
       89 
       90     public void StartNewFile(String name) {
       91         if (name == null)
       92             throw new ArgumentNullException("name");
       93         CurrentBlock = new Block { Name = name };
       94     }
       95 
       96     public void StartFooter(bool includeInDefault = true) {
       97         CurrentBlock = footer;
       98         footer.IncludeInDefault = includeInDefault;
       99     }
      100 
      101     public void StartHeader(bool includeInDefault = true) {
      102         CurrentBlock = header;
      103         header.IncludeInDefault = includeInDefault;
      104     }
      105 
      106     public void EndBlock() {
      107         if (CurrentBlock == null)
      108             return;
      109         CurrentBlock.Length = template.Length - CurrentBlock.Start;
      110         if (CurrentBlock != header && CurrentBlock != footer)
      111             files.Add(CurrentBlock);
      112         currentBlock = null;
      113     }
      114 
      115     public virtual void Process(bool split, bool sync = true) {
      116         if (split) {
      117             EndBlock();
      118             String headerText = template.ToString(header.Start, header.Length);
      119             String footerText = template.ToString(footer.Start, footer.Length);
      120             String outputPath = Path.GetDirectoryName(host.TemplateFile);
      121             files.Reverse();
      122             if (!footer.IncludeInDefault)
      123                 template.Remove(footer.Start, footer.Length);
      124             foreach(Block block in files) {
      125                 String fileName = Path.Combine(outputPath, block.Name);
      126                 String content = headerText + template.ToString(block.Start, block.Length) + footerText;
      127                 generatedFileNames.Add(fileName);
      128                 CreateFile(fileName, content);
      129                 template.Remove(block.Start, block.Length);
      130             }
      131             if (!header.IncludeInDefault)
      132                 template.Remove(header.Start, header.Length);
      133         }
      134     }
      135 
      136     protected virtual void CreateFile(String fileName, String content) {
      137         if (IsFileContentDifferent(fileName, content))
      138             File.WriteAllText(fileName, content);
      139     }
      140 
      141     public virtual String GetCustomToolNamespace(String fileName) {
      142         return null;
      143     }
      144 
      145     public virtual String DefaultProjectNamespace {
      146         get { return null; }
      147     }
      148 
      149     protected bool IsFileContentDifferent(String fileName, String newContent) {
      150         return !(File.Exists(fileName) && File.ReadAllText(fileName) == newContent);
      151     }
      152 
      153     private Manager(ITextTemplatingEngineHost host, StringBuilder template) {
      154         this.host = host;
      155         this.template = template;
      156     }
      157 
      158     private Block CurrentBlock {
      159         get { return currentBlock; }
      160         set {
      161             if (CurrentBlock != null)
      162                 EndBlock();
      163             if (value != null)
      164                 value.Start = template.Length;
      165             currentBlock = value;
      166         }
      167     }
      168 
      169     private class VSManager: Manager {
      170         private EnvDTE.ProjectItem templateProjectItem;
      171         private EnvDTE.DTE dte;
      172         private Action<String> checkOutAction;
      173         private Action<IEnumerable<String>> projectSyncAction;
      174 
      175         public override String DefaultProjectNamespace {
      176             get {
      177                 return templateProjectItem.ContainingProject.Properties.Item("DefaultNamespace").Value.ToString();
      178             }
      179         }
      180 
      181         public override String GetCustomToolNamespace(string fileName) {
      182             return dte.Solution.FindProjectItem(fileName).Properties.Item("CustomToolNamespace").Value.ToString();
      183         }
      184 
      185         public override void Process(bool split, bool sync) {
      186             if (templateProjectItem.ProjectItems == null)
      187                 return;
      188             base.Process(split, sync);
      189             if (sync)
      190                 projectSyncAction.EndInvoke(projectSyncAction.BeginInvoke(generatedFileNames, null, null));
      191         }
      192 
      193         protected override void CreateFile(String fileName, String content) {
      194             if (IsFileContentDifferent(fileName, content)) {
      195                 CheckoutFileIfRequired(fileName);
      196                 File.WriteAllText(fileName, content);
      197             }
      198         }
      199 
      200         internal VSManager(ITextTemplatingEngineHost host, StringBuilder template)
      201             : base(host, template) {
      202             var hostServiceProvider = (IServiceProvider) host;
      203             if (hostServiceProvider == null)
      204                 throw new ArgumentNullException("Could not obtain IServiceProvider");
      205             dte = (EnvDTE.DTE) hostServiceProvider.GetService(typeof(EnvDTE.DTE));
      206             if (dte == null)
      207                 throw new ArgumentNullException("Could not obtain DTE from host");
      208             templateProjectItem = dte.Solution.FindProjectItem(host.TemplateFile);
      209             checkOutAction = (String fileName) => dte.SourceControl.CheckOutItem(fileName);
      210             projectSyncAction = (IEnumerable<String> keepFileNames) => ProjectSync(templateProjectItem, keepFileNames);
      211         }
      212 
      213         private static void ProjectSync(EnvDTE.ProjectItem templateProjectItem, IEnumerable<String> keepFileNames) {
      214             var keepFileNameSet = new HashSet<String>(keepFileNames);
      215             var projectFiles = new Dictionary<String, EnvDTE.ProjectItem>();
      216             var originalFilePrefix = Path.GetFileNameWithoutExtension(templateProjectItem.get_FileNames(0)) + ".";
      217             foreach(EnvDTE.ProjectItem projectItem in templateProjectItem.ProjectItems)
      218                 projectFiles.Add(projectItem.get_FileNames(0), projectItem);
      219 
      220             // Remove unused items from the project
      221             foreach(var pair in projectFiles)
      222                 if (!keepFileNames.Contains(pair.Key) && !(Path.GetFileNameWithoutExtension(pair.Key) + ".").StartsWith(originalFilePrefix))
      223                     pair.Value.Delete();
      224 
      225             // Add missing files to the project
      226             foreach(String fileName in keepFileNameSet)
      227                 if (!projectFiles.ContainsKey(fileName))
      228                     templateProjectItem.ProjectItems.AddFromFile(fileName);
      229         }
      230 
      231         private void CheckoutFileIfRequired(String fileName) {
      232             var sc = dte.SourceControl;
      233             if (sc != null && sc.IsItemUnderSCC(fileName) && !sc.IsItemCheckedOut(fileName))
      234                 checkOutAction.EndInvoke(checkOutAction.BeginInvoke(fileName, null, null));
      235         }
      236     }
      237 } #>
    6. 添加T4文件:NorthwindContext.tt
      View Code
      <#@ template debug="True" hostspecific="True" language="C#" #>
      <#@ Include File="MultipleOutputHelper.ttinclude" #>
      <#@ Assembly Name="$(TargetDir)NLite.dll" #>
      <#@ Assembly Name="$(TargetDir)ELinq.dll" #>
      <#@ Assembly Name="System.Data" #>
      <#@ Import Namespace="NLite.Data" #>
      <#@ Import Namespace="NLite.Data.CodeGeneration" #>
      <#@ output extension=".cs" #>
      <#
          var @namespace = "NLite.Data.CodeGenerationDemo";
          var connectionStringName = "Northwind";
          var dbContextName = Host.TemplateFile.Split('\\')[Host.TemplateFile.Split('\\').Length - 1].TrimEnd('.', 't');
          var connectionStringSetting = GetConnectionStringSettings(connectionStringName);
          var connectionString = connectionStringSetting.ConnectionString;
          var dbProviderName = connectionStringSetting.ProviderName;
          var dbConfiguration = DbConfiguration.Configure(connectionString, dbProviderName);
          var databaseSchema = dbConfiguration.Schema;
          var manager = Manager.Create(Host, GenerationEnvironment);
          manager.StartHeader();
      #>
      using System;
      using System.Collections.Generic;
      using System.Linq;
      using NLite.Data;
      namespace <#= @namespace #>
      {
      <#
          manager.EndBlock();
      #>
          using NLite.Reflection;
      
          public partial class <#= dbContextName #>:DbContext
          {
              //连接字符串名称:基于Config文件中连接字符串的配置
              const string connectionStringName = "<#= connectionStringName #>";
      
              //构造dbConfiguration 对象
              static DbConfiguration dbConfiguration;
      
              static <#= dbContextName #>()
              {
                   dbConfiguration = DbConfiguration
                        .Configure(connectionStringName)
                        .SetSqlLogger(() =>SqlLog.Debug)
                        .AddFromAssemblyOf<<#= dbContextName #>>(t=>t.HasAttribute<TableAttribute>(false))
                        ;
              }
      
              public <#= dbContextName #>():base(dbConfiguration){}
              
      <#foreach (var tb in databaseSchema.Tables.Union(databaseSchema.Views)){#>
              public IDbSet<<#=NamingConversion.Default.ClassName(tb.TableName)  #>> <#= NamingConversion.Default.QueryableName(tb.TableName) #> { get; private set; }
      <#}#>
          }
      <#foreach (var tb in databaseSchema.Tables){
              manager.StartNewFile(NamingConversion.Default.ClassName(tb.TableName) + ".generated.cs");#>
          [Table("<#= tb.TableName #>")]
          public partial class <#= NamingConversion.Default.ClassName( tb.TableName) #> 
          {
      <#foreach (var col in tb.PrimaryKeys){#>    
              [Id("<#= col.ColumnName#>",IsDbGenerated=<#= col.IsGenerated.ToString().ToLower() #>)]
              public <#= NamingConversion.Default.DataType(col) #> <#= NamingConversion.Default.PropertyName(col.ColumnName) #> { get;set; }
      <#}#> 
      <#foreach (var col in tb.Columns){#>
              [Column("<#= col.ColumnName#>")]
              public <#= NamingConversion.Default.DataType(col) #> <#= NamingConversion.Default.PropertyName(col.ColumnName) #> { get;set; }
      <#}#> 
      <#foreach (var fk in tb.ForeignKeys){#>
              [ManyToOne(ThisKey="<#= NamingConversion.Default.PropertyName( fk.ThisKey.ColumnName) #>",OtherKey="<#= NamingConversion.Default.PropertyName(fk.OtherKey.ColumnName) #>")]
              public <#= NamingConversion.Default.ClassName(fk.OtherTable.TableName) #> <#= NamingConversion.Default.ManyToOneName(fk) #> { get;set; }
      <#}#> 
      <#foreach (var fk in tb.Children){#>
              [OneToMany(ThisKey="<#= NamingConversion.Default.PropertyName( fk.ThisKey.ColumnName) #>",OtherKey="<#= NamingConversion.Default.PropertyName(fk.OtherKey.ColumnName) #>")]
              public IList<<#= NamingConversion.Default.ClassName(fk.OtherTable.TableName) #>> <#= NamingConversion.Default.QueryableName(fk.OtherTable.TableName) #> { get;set; }
      <#}#> 
          }
      <# } manager.EndBlock();
       foreach (var tb in databaseSchema.Views){
           manager.StartNewFile(NamingConversion.Default.ClassName(tb.TableName) + ".generated.cs");#>
          [Table("<#= tb.TableName #>",Readonly=true)]
          public partial class <#= NamingConversion.Default.ClassName( tb.TableName) #> 
          {
      <#foreach (var col in tb.Columns){#>
              [Column("<#= col.ColumnName#>")]
              public <#= col.Type.Name #> <#= NamingConversion.Default.PropertyName(col.ColumnName) #> { get;set; }
      <#}#> 
          }
      <# 
          } manager.EndBlock();
          manager.StartFooter();
      #>
      }
      <#
       manager.EndBlock();
       manager.Process(true);
      #>
    7. 保存一下NorthwindContext.tt 文件,系统会自动创建实体、实体间的关系(一对多,多对一)和DbContext, 见下图

     

      8. 运行代码查看

       补充

      1. ELinq 数据库Schema元数据结构图(只要配置好了DbConfiguration对象,只需要调用其Schema属性就会自动得到如下Schema数据

     

      

          2. ELinq 还提供了表名到类名、列名到属性等转换约定,针对特殊情况可以自行定制

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using NLite.Data.Schema;
    
    namespace NLite.Data.CodeGeneration
    {
    
         /// <summary>
        /// 命名约定
        /// </summary>
        public static class NamingConversion
        {
            /// <summary>
            /// 缺省命名约定
            /// </summary>
            public static readonly INamingConversion Default = new DefaultNamingConversion();
        }
    
        /// <summary>
        /// 命名约定
        /// </summary>
        public interface INamingConversion
        {
            /// <summary>
            /// 表名转集合名
            /// </summary>
            /// <param name="tableName"></param>
            /// <returns></returns>
            string QueryableName(string tableName);
            /// <summary>
            /// 表名转类名
            /// </summary>
            /// <param name="tableName"></param>
            /// <returns></returns>
            string ClassName(string tableName);
    
            /// <summary>
            /// 列名转字段名
            /// </summary>
            /// <param name="columnName"></param>
            /// <returns></returns>
            string FieldName(string columnName);
    
            /// <summary>
            /// 列名属性名转
            /// </summary>
            /// <param name="columnName"></param>
            /// <returns></returns>
            string PropertyName(string columnName);
    
            /// <summary>
            /// 得到类的数据类型
            /// </summary>
            /// <param name="col"></param>
            /// <returns></returns>
            string DataType(IColumnSchema col);
    
            /// <summary>
            /// 得到外键对应的导航属性名称
            /// </summary>
            /// <param name="fk"></param>
            /// <returns></returns>
            string ManyToOneName(IForeignKeySchema fk);
        }
    }

       3. 默认情况下自定义DbContext名称和T4模版文件的名称一致

       4. 如何修该代码生成的命名空间以及数据库配置

      

    总结

        最后附上Demo代码,大家可以修改一下配置文件,即可支持其它数据库的代码生成,也可以修改T4 模版DIY 自己的代码生成器!随后会发布基于Nuget安装方式的T4 模版代码生成器包,供大家方便使用、

    技术支持:

    1. 官方网站
    2. Nuge 下载页面
    3. ORM组件 ELinq系列
    4. ORM组件 ELinq 更新日志
    5. ORM组件 ELinq 使用答疑
    6. 在我的博客留言,我会尽可能地抽时间来答复大家的问题。
    7. 加入 ELinq用户的 QQ群(271342583)。

       新年伊始,祝大家春节愉快,万事如意,谢谢大家的阅读,麻烦大伙点一下推荐,再次谢谢大家。 ^_^

    展开全文
  • 学习C++模板编程(6

    千次阅读 2006-12-22 16:00:00
    接下来是第六章一道习题,要求实现一个binary_tree_inserter,以使用mpl::copy算法从其它序列生成一棵二分查找树(Binary Search Tree,即满足以下条件一种二分树:左子树所有元素小于根,右子树所有元素大于根...
     
    
    接下来是第六章的一道习题,要求实现一个binary_tree_inserter,以使用mpl::copy算法从其它序列生成一棵二分查找树(Binary Search Tree,即满足以下条件的一种二分树:左子树所有元素小于根,右子树所有元素大于根,且左右子树全都是二分查找树)。习题中给出的测试代码如下:
    typedef mpl::copy<
          mpl::vector_c<int,17,25,10,2,11>
        , binary_tree_inserter< tree<> >
        >::type bst;
     
    //       int_<17>
    //       /      /
    //    int_<10> int_<25>
    //     /    /
    // int_<2> int_<11>
    BOOST_STATIC_ASSERT(( mpl::equal<
          inorder_view<bst>
        , mpl::vector_c<int,2,10,11,17,25>
        >::value ));
     
    使用mpl::copy算法依据一个mpl::vector<>生成二分查找树,生成过程中使用一个inserter依次将mpl::vector<>中的各个元素插入到开始为空的tree<>中,inserter要确保插入后,tree<>保持满足二分查找树的条件。
    明显,inserter要做的就是:从当前tree<>的根开始,如果要插入的元素小于根,则选择左子树插入,否则选择右子树插入;左右子树的插入方法与上同,重复以上步骤。
    参照书中给出的关于inserter的例子,binary_tree_inserter应该是这样的:
    template <class S, class T>
    struct push_bst;
     
    template <class S>
    struct binary_tree_inserter
        : mpl::inserter<
            S,
            push_bst<_, _>
        >
    {
    };
     
    其中有一个push_bst是辅助类,它执行实际的插入算法。binary_tree_inserter基于push_bst实现。留意binary_tree_inserter定义中的push_bst<_, _>,使用了mpl的占位符(placeholder),占位符的确是一个非常有意思,也非常有用的工具。它可以很方便地将mpl::copy算法在调用binary_tree_inserter时传入的参数,转送到push_bst,不需要你显式地定义出来,大大简化了我们编写MPL程序的工作。
    接着看看push_bst的实现。push_pst的实现分为三种情况:插入到空的树中、插入到只有一个元素的树中、插入非平凡的树中。为了表示空的树,还要定义一个none类来表示空的元素。根据这些想法,修改tree的定义如下:
    struct none {};
     
    template <class R = none, class LC = none, class RC = none>
    struct tree
    {
        typedef tree type;
        typedef R root;
        typedef LC left;
        typedef RC right;
    };
     
    空的树既可以直接用none表示,也可以表示为tree<none, none, none>,所以push_bst的第一种情况可以写为:
    template <class T>
    struct push_bst<none, T>
        : T
    {
    };
     
    template <class T>
    struct push_bst<tree<>, T>
        : tree<T>
    {
    };
     
    push_bst的第三种情况(插入到一棵真正的tree中)写为:
    template <class R, class LC, class RC, class T>
    struct push_bst<tree<R, LC, RC>, T>
        : mpl::eval_if<
            typename mpl::less<T, R>::type,
            tree<R, typename push_bst<LC, T>::type, RC>,
            tree<R, LC, typename push_bst<RC, T>::type>
        >
    {
    };
     
    先判断插入的元素T是否小于被插入树的根,是则将T插入到左子树后形成新的树,否则将T插入右子树后形成新的树。
    最后是push_bst的第二种情况(插入到只有一个元素的树中,且该树使用该元素直接表示),这也是push_bst的主模板,代码如下:
    template <class S, class T>
    struct push_bst
        : mpl::eval_if<
            typename mpl::less<T, S>::type,
            tree< S, T >,
            tree< S, none, T >
        >
    {
    };
     
    代码与前一种情况相似,只不过这次不是用tree<>来表示树,而是直接以元素本身表示。
    其实,第二、三种情况也可以合并起来写,不过就需要另外实现几个辅助类,分别用于取出二分树的根、左子树和右子树。如果给出的是普通的树,取出这几样东西都很容易(因为我们已经在 tree<>的定义里typedef了这几样东西);但是如果给出的是退化的表示方法(即以元素本身来表示只含单个元素的树)的话,就必须使用模板偏特化来实现了:
    template <class T>
    struct root
    {
        typedef T type;
    };
     
    template <class R, class LC, class RC>
    struct root< tree<R, LC, RC> >
    {
        typedef R type;
    };
     
    template <class T>
    struct left_child
    {
       typedef none type;
    };
     
    template <class R, class LC, class RC>
    struct left_child< tree<R, LC, RC> >
    {
        typedef LC type;
    };
     
    template <class T>
    struct right_child
    {
        typedef none type;
    };
     
    template <class R, class LC, class RC>
    struct right_child< tree<R, LC, RC> >
    {
        typedef RC type;
    };
     
    有了以上辅助类,就可以将push_bst的后两种情况合并为一种写法:
    template <class S, class T>
    struct push_bst
        : mpl::eval_if<
            typename mpl::less<T, typename root<S>::type>::type,
            tree< 
                typename root<S>::type, 
                typename push_bst<typename left_child<S>::type, T>::type, 
                typename right_child<S>::type 
            >,
            tree< 
                typename root<S>::type, 
                typename left_child<S>::type,
                typename push_bst<typename right_child<S>::type, T>::type
            >
        >
    {
    };
     
    当然,另两个push_bst的特化版本(push_bst<none, T>和push_bst<tree<>, T>)还得保留。不过,比较这两种写法,后一种写法虽然减少了push_bst的特化版本,但是引入了多个辅助类,如果这些辅助类没有其它用途的话,我觉得还是前一种写法更简练些。
    在进入到最后的测试代码之前,还要稍微修改一下上一篇给出的inorder_view,这是因为这次我们加入了一个none,而上一篇给出的inorder_view没有考虑none的情况。改动其实很少,增加一个针对none的特化版本就行了:
    template <>
    struct inorder_view<none> : mpl::vector<>
    {
    };
     
    照例,最后是测试用的代码:
    int main()
    {
        typedef mpl::copy<
              mpl::vector_c<int,17,25,10,2,11>
            , binary_tree_inserter< tree<> >
            >::type bst;
     
        BOOST_STATIC_ASSERT(( mpl::equal<
              inorder_view<bst>::type
            , mpl::vector_c<int,2,10,11,17,25>
            >::value ));
        
        return 0;
    }
     
    这次的inserter实现比上一次的xxxorder_view相比稍微复杂一些,但也不太难,关键是要理解清楚mpl中的inserter的原理,剩下就都好办了。下一篇将会实现一个完整的编译期Binary Tree,包括了一整套的begin、end、iterator、deref、next、prior等等,然后是在此基础上实现的binary_tree_search算法。
     
     
    展开全文
  • 定义模型 定义模型注意事项及特性说明. 1. 在模型中定义属性,会生成表中字段 2. django根据属性类型确定以下信息: ...6. django会为表增加自动增长主键列,每个模型只能有一个主键列,如果使用选项设置...

    定义模型

    定义模型的注意事项及特性说明.
    1. 在模型中定义属性,会生成表中的字段
    2. django根据属性的类型确定以下信息:
    3. 当前选择的数据库支持字段的类型
    4. 渲染管理表单时使用的默认html控件
    5. 在管理站点最低限度的验证
    6. django会为表增加自动增长的主键列,每个模型只能有一个主键列,如果使用选项设置某属性为主键列后,则django不会再生成默认的主键列
    7. 属性命名限制
    8. 不能是python的保留关键字
    9. 由于django的查询方式,不允许使用连续的下划线

    字段类型

    AutoField:一个根据实际ID自动增长的IntegerField,通常不指定,如果不指定,一个主键字段将自动添加到模型中
    BooleanField:true/false 字段,此字段的默认表单控制是CheckboxInput
    NullBooleanField:支持nulltruefalse三种值
    CharField(max_length=字符长度):字符串,默认的表单样式是 TextInput
    TextField:大文本字段,一般超过4000使用,默认的表单控件是Textarea
    IntegerField:整数
    DecimalField(max_digits=None, decimal_places=None):使用python的Decimal实例表示的十进制浮点数
    DecimalField.max_digits:位数总数
    DecimalField.decimal_places:小数点后的数字位数
    FloatField:用Python的float实例来表示的浮点数
    DateField[auto_now=False, auto_now_add=False]):使用Python的datetime.date实例表示的日期
        参数DateField.auto_now:每次保存对象时,自动设置该字段为当前时间,用于"最后一次修改"的时间戳,它总是使用当前日期,默认为false
        参数DateField.auto_now_add:当对象第一次被创建时自动设置当前时间,用于创建的时间戳,它总是使用当前日期,默认为false
        该字段默认对应的表单控件是一个TextInput. 在管理员站点添加了一个JavaScript写的日历控件,和一个“Today"的快捷按钮,包含了一个额外的invalid_date错误消息键
    auto_now_add, auto_now, and default 这些设置是相互排斥的,他们之间的任何组合将会发生错误的结果
    TimeField:使用Python的datetime.time实例表示的时间,参数同DateField
    DateTimeField:使用Python的datetime.datetime实例表示的日期和时间,参数同DateField
    FileField:一个上传文件的字段
    ImageField:继承了FileField的所有属性和方法,但对上传的对象进行校验,确保它是个有效的image

    字段选项

    通过字段选项,可以实现对字段的约束

    在创建字段对象时通过关键字参数指定
    null:如果为True,Django 将空值以NULL 存储到数据库中,默认值是 False
    blank:如果为True,则该字段允许为空白,默认值是 False
    对比:null是数据库范畴的概念,blank是表单验证证范畴的
    db_column:字段的名称,如果未指定,则使用属性的名称
    db_index:若值为 True, 则在表中会为此字段创建索引
    default:默认值
    primary_key:若为 True, 则该字段会成为模型的主键字段
    unique:如果为 True, 这个字段在表中必须有唯一值
    

    关系

    关系的类型包括
        ForeignKey:一对多,将字段定义在多的端中
        ManyToManyField:多对多,将字段定义在两端中
        OneToOneField:一对一,将字段定义在任意一端中
    
    用一访问多:对象.模型类小写_set
    bookinfo.heroinfo_set
    用一访问一:对象.模型类小写
    heroinfo.bookinfo
    访问id:对象.属性_id
    heroinfo.book_id
    

    元选项

    在模型类中定义类Meta,用于设置元信息
    元信息db_table:定义数据表名称,推荐使用小写字母,
    ordering:对象的默认排序字段,获取对象的列表时使用,接收属性构成的列表

    管理器

    当定义模型类时没有指定管理器,则Django会为模型类提供一个名为objects的管理器
    objects:是Manager类型的对象,用于与数据库进行交互
    当为模型类指定管理器后,django不再为模型类生成名为objects的默认管理器
    管理器是Django的模型进行数据库的查询操作的接口,Django应用的每个模型都拥有至少一个管理器

    自定义管理器的两种方法;

    1.向管理类中添加额外的方法
    2.修改管理器返回的原始查询集
    class BookInfoManager(models.Manager):
        # 该管理器将原始的查询集进行了筛选,值显示未被逻辑删除的
        def get_queryset(self):
            return super(BookInfoManager, self).get_queryset().filter(isDelete=False)
    class BookInfo(models.Model):
        ...
        books = BookInfoManager()

    调用的时候就不能调用默认的管理器object了

    调用方法:
        BookInfo.books.all(),返回结果管理器筛选之后的对象的一个类列表的数据,但实际上不是列表

    快速的为对象添加属性

    方法一

    class BookInfoManager(models.Manager):
        def create_book(self, title, pub_date):
            book = self.model()
            book.btitle = title
            book.bpub_date = pub_date
            book.bread=0
            book.bcommet=0
            book.isDelete = False
            return book
    class BookInfo(models.Model):
        ...
        books = BookInfoManager()
    _____________________
    调用:book=BookInfo.books.create_book("abc",datetime(1980,1,1))
    保存:book.save()

    方法二

    class BookInfoManager(models.Manager):
        def create_book(self, title, pub_date):
            # 调用父类的create方法,直接创建并保存
            book = self.create(btitle = title,bpub_date = pub_date,bread=0,bcommet=0,isDelete = False)
            return book
    class BookInfo(models.Model):
        ...
        books = BookInfoManager()
    调用:book=Book.books.create_book("abc",datetime(1980,1,1))
    查看:book.pk

    也可以在模型类中使用类方法来完成,但不建议使用.

    一个简单的模型类示例

    from django.db import models
    
    
    class BookInfoManage(models.Manager):
        def get_queryset(self):
            return super(BookInfoManage,self).get_queryset().filter(isDelete=False)
    
    
    class BookInfo(models.Model):
        btitle = models.CharField(max_length=20)
        bpub_date = models.DateTimeField(db_column='pub_date')
        bread = models.IntegerField(default=0)
        bcommet = models.IntegerField(default=0)
        isDelete = models.BooleanField(default=False)
        books = models.Manager()
        books2 = BookInfoManage()
        class Meta():
            db_table = 'bookinfo'
    
        def __str__(self):
            return self.btitle.encode('utf-8')
    
    class HeroInfo(models.Model):
        hname = models.CharField(max_length=20)
        hgender = models.BooleanField(default=True)
        hbook = models.ForeignKey('BookInfo')
        hcontent = models.CharField(max_length=100)
        isDelete = models.BooleanField(default=False)
    
        def __str__(self):
            return self.hname.encode('utf-8')
    

    转载于:https://www.cnblogs.com/fanlei5458/p/9235468.html

    展开全文
  • 基于速率模型,捕获简化V4-vlPFC神经网络动力学。 蔡汉娜(),2017年6月27日。 这些MATLAB代码生成V4(2)和vlPFC(2)单位在不同遮挡水平下对模拟首选/非首选形状刺激动态响应(射击速率)。 V4和...
  • C++自动化(模板)编程基础与应用(6)

    千次阅读 2006-04-24 19:55:00
    #if 0 在上一章里面讨论了代码自动生成机制,经常会遇到根据不同类型选择不同操作情况,也就是静态分派问题。这就需要有一种机制用来识别不同类型,在本章里面将会系统讨论C++里面可用类型识别问题...
  • 4.HQL 查询语句从词法分析、语法分析、编译、优化以及查询计划的生成靠什么完成? 5.生成的查询计划存储在什么位置? 6.Hive 将数据存储在 RDBMS 中,有三种模式可以连接到数据库? 分别哪几种? 7.Hive数据...
  •   隐马尔可夫模型(HMM)是可用于标注问题统计学习模型,描述由隐藏马尔科夫链随机生成观测序列过程,属于生成模型,被认为是解决大多数自然语言处理问题最快速、有效方法;20世纪70年代被应用在语音...
  • 作为模板部分结束节,本条款谈到了模板编程,编程本质上就是将运行期代价转移到编译期,它利用template编译生成C++源码,举下面阶乘例子: 1 template <int N> 2 struct Factorial 3 { 4 ...
  • 与医学有关的matlab代码claustral网络的胆碱能偏向 研究对抗胆碱能增益控制在 claustrum 网络模型中的影响 ...“平衡网络中瞬态动力学的最佳控制支持复杂运动的生成。” 神经 82,没有。 6 (2014): 1394-1406
  • ASP.NET网页代码模型及生命周期

    热门讨论 2009-07-28 14:22:11
    当浏览者再一次浏览该页面时候,生成的.DLL就会在服务器上运行,并响应用户在该页面上请求或响应,ASP.NET应用程序解释过程图如4-6所示。 图4-6 代码隐藏页模型页面执行过程 在客户端浏览器访问该页面时,...
  • 现实主义来自将生成模型拟合到具有假定因果结构数据。 安装 创建虚拟环境(例如,使用conda,virtualenv等)后,请安装所需软件包: pip install -r requirements.txt 对我们因果预测指标数据集进行自己...
  • 5.最小生成6.最短路 7.离散化 8.tarjan缩点 9.KMP算法 10.高斯消法 一.堆(stl版) 1.大根堆 #include<cstdio> #include<cstring> #include<cmath> #include<algori...
  • ACM 算法模板集

    2018-04-19 20:35:45
    6. Modular Linear Equation线性方程(同余方程) 7. Chinese Remainder Theorem中国余数定理(互素于非互素) 8. Euler Function欧拉函数 9. Farey总数 9. Farey序列构造 10. Miller_Rabbin素数测试,Pollard_rho因式...
  • ACM巨全模板 .pdf

    2019-10-07 11:51:34
    17.限制顶点度数MST(k度限制生成树) 18.多源最短路(spfa,floyd) 19.最短路 (输出字典序最小) 20.最长路 图论题目简述 字符串: 1.字典树(多个字符串前缀) 2.KMP(关键字搜索) 3.EXKMP(找到S中所有P匹配) 4.马拉...
  • 原理:导入模板,连接数据库获取数据库表的元数据,解析获取到的元数据,将解析到所有表数据遍历,使用FreeMarker将数据与模板合成,最终以输出流形式生成文件。 〇、代码生成三要素 数据...
  • 解释像大小、栅格数据分辨率和空间要素栅格表示三者之间关系6.解释被动和主动卫星系统之间区别8.什么是数字高程模型9.介绍生成DEMs三种常用方法14.请解释无损压缩和有损压缩方法有何不同15.什么是矢量化 1...
  • 2 Model层 -定义模型

    2019-09-28 03:30:29
    4.使用数据库生成模型类 5.定义模型 6.字段类型 7.字段选项 8.关系 9.选项 Meta 10 示例演示 11.测试数据 回到顶部 1 ORM简介 MVC框架中包括一个重要部分,就是ORM,它实现了数据模型与数...
  • 页面场景模板配置化

    2020-12-09 08:59:53
    这个文件描述了整个物料集合的元数据。 第四步:发布物料数据 接着通过 <code>iceworks sync</code> 方式将物料数据同步到物料中心,也可以通过私有服务托管,同步完成后我们会得到一个 url ...
  • 6、JS代码管理:可以选择不同形式JS代码进行添加,分为文字和图片两种,图片又分为纵横和图文混排两种,完全生成静态JS文件,同时可以对JS进行文件添加 7、JS代码获取:JS代码插入代码显示,只需进行...
  • 1.新增信息生成html静态页面功能。 2.新增商家可以开店,店铺仿淘宝店铺风格,集成(绿色,橙色,粉色)3套商家模板,商家可以自由发布公司简介,联系方式,公告信息,产品信息。 3.新增顶部图标导航菜单后台修改...
  • FreeMarker基本用法(1)FreeMarker依赖(2)指定模板并生成(3)指定字符串模板并生成3,测试数据库数据操作(1)获取数据库基本信息(2)获取数据库列表(3)获取指定数据库中表信息(4)获取指定表中...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 749
精华内容 299
关键字:

模6的生成元