Preface

In this paper, we will discuss several ways of mapping dynamic model , I believe that some children's shoes projects have such demand , Like every day / Generate a table every hour , This kind of dynamic model mapping is very common , After my groping , Here is a detailed idea for each step , Hope to help children's shoes without any clue , This article takes .NET Core 3.1 Console , At the same time SQL Server Database as an example ( Other databases are copied in the same way ), Because of the built-in APi, Due to different versions, the constructor may need to be slightly adjusted . notes : Although it's sample code , But I've encapsulated it as an actual project , Basically universal . This article is a little longer , Please be patient .

Dynamic mapping model introduces premise

First, we give the required features and the corresponding enumeration , Just look at the notes

public enum CustomTableFormat
{
/// <summary>
/// Every day ,(yyyyMMdd)
/// </summary>
[Description(" Every day ")]
DAY,
/// <summary>
/// Every hour ,(yyyyMMddHH)
/// </summary>
[Description(" Every hour ")]
HOUR,
/// <summary>
/// Every minute (yyyyMMddHHmm)
/// </summary>
[Description(" Every minute ")]
MINUTE
} [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
public class EfEntityAttribute : Attribute
{
/// <summary>
/// Whether to enable dynamic table generation
/// </summary>
public bool EnableCustomTable { get; set; } = false;
/// <summary>
/// Dynamically generate table prefixes
/// </summary>
public string Prefix { get; set; }
/// <summary>
/// Table generation rules
/// </summary>
public CustomTableFormat Format { get; set; } = CustomTableFormat.DAY; public override string ToString()
{
if (EnableCustomTable)
{
return string.IsNullOrEmpty(Prefix) ? Format.FormatToDate() : $"{Prefix}{Format.FormatToDate()}";
}
return base.ToString();
}
} public static class CustomTableFormatExetension
{
public static string FormatToDate(this CustomTableFormat tableFormat)
{
return tableFormat switch
{
CustomTableFormat.DAY => DateTime.Now.ToString("yyyyMMdd"),
CustomTableFormat.HOUR => DateTime.Now.ToString("yyyyMMddHH"),
CustomTableFormat.MINUTE => DateTime.Now.ToString("yyyyMMddHHmm"),
_ => DateTime.Now.ToString("yyyyMMdd"),
};
}
}

By defining features , The main starting point is based on two considerations : firstly : Inject the model from the outside instead of writing it dead DbSet Attribute access 、 second : Each model can define dynamic mapping table rules

Dynamic mapping model mode ( One )

First, we give the context we need to use , For the convenience of demonstration, let's take the automatic map per minute model as an example

public class EfDbContext : DbContext
{
public string Date { get; set; } = CustomTableFormat.MINUTE.FormatToDate();
public EfDbContext(DbContextOptions<EfDbContext> options) : base(options)
{ }
}

Dynamic model refers to different table names , For example, we realize that every day / Every hour / Dynamically map the model and generate a table every minute . In the following interface, we need to generate a table format every minute , So define the per minute attribute in context . The first way is through IModelCacheKeyFactory Interface , This interface caches all model table names in the specified context , So we can change it according to the dynamic model table name , as follows :

public class CustomModelCacheKeyFactory : IModelCacheKeyFactory
{
public object Create(DbContext context)
{
var efDbContext = context as EfDbContext;
if (efDbContext != null)
{
return (context.GetType(), efDbContext.Date);
}
return context.GetType();
}
}

The above implementation seems to feel a little incomprehensible , This is mainly to directly implement the interface in one step , The underlying essence is to call an extra instance of a cache key class , We will change the above to the following two steps to make it clear at a glance

public class CustomModelCacheKeyFactory : ModelCacheKeyFactory
{
private string _date;
public CustomModelCacheKeyFactory(ModelCacheKeyFactoryDependencies dependencies)
: base(dependencies)
{ }
public override object Create(DbContext context)
{
if (context is EfDbContext efDbContext)
{
_date = efDbContext.Date;
} return new CustomModelCacheKey(_date, context);
}
} public class CustomModelCacheKey : ModelCacheKey
{
private readonly Type _contextType;
private readonly string _date;
public CustomModelCacheKey(string date, DbContext context) : base(context)
{
_date = date;
_contextType = context.GetType();
} public virtual bool Equals(CustomModelCacheKey other)
=> _contextType == other._contextType && _date == other._date; public override bool Equals(object obj)
=> (obj is CustomModelCacheKey otherAsKey) && Equals(otherAsKey); public override int GetHashCode() => _date.GetHashCode();
}

And then in OnModelCreating Method to scan, identify and register the model , as follows :

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
var entityMethod = typeof(ModelBuilder).GetMethod(nameof(modelBuilder.Entity),
new Type[] { }); var assembly = Assembly.GetExecutingAssembly(); //【1】 Use Entity Methods registration
foreach (var type in assembly.ExportedTypes)
{
if (!(type.GetCustomAttribute(typeof(EfEntityAttribute)) is EfEntityAttribute attribute))
{
continue;
} if (type.IsNotPublic || type.IsAbstract || type.IsSealed
|| type.IsGenericType
|| type.ContainsGenericParameters)
{
continue;
} entityMethod.MakeGenericMethod(type)
.Invoke(modelBuilder, new object[] { });
} //【2】 Use IEntityTypeConfiguration<T> register
modelBuilder.ApplyConfigurationsFromAssembly(assembly); base.OnModelCreating(modelBuilder);
}

The first way is to register the model through reflection , Its essence is to call modeBuilder.Entity Method , If we use annotations on the model , It will also be applied accordingly

But annotations are not flexible enough , For example, to identify the union primary key , Can only be used Fluent APi, So we do it externally IEntityTypeConfiguration To register , then EF Core Provides registration for this interface assembly , Its underlying nature is also scanning assemblies , Both methods support , Don't worry about external model registration

Then we give the test model , The table name is current minute , Table names cannot be annotated ( Value must be constant ), So we use the second mapping model as follows

[EfEntity(EnableCustomTable = true, Format = CustomTableFormat.MINUTE)]
public class Test
{
[Table(DateTime.Now.ToString("yyyyMMdd"))]
public int Id { get; set; }
public string Name { get; set; }
} public class TestEntityTypeConfiguration : IEntityTypeConfiguration<Test>
{
public void Configure(EntityTypeBuilder<Test> builder)
{
builder.ToTable(DateTime.Now.ToString("yyyyMMddHHmm"));
}
}

The second configuration mentioned above is possible , But we still have a more concise one-step operation , So delete the second method mentioned above , Because in OnModelCreating Method inside , We reflected and called Entity Method , So we call reflection directly Entity Method is cast to EntityTypeBuilder, On the existing basis , The code makes a key mark

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
var entityMethod = typeof(ModelBuilder).GetMethod(nameof(modelBuilder.Entity), new Type[] { });
var assembly = Assembly.GetExecutingAssembly(); //【1】 Use Entity Methods registration
foreach (var type in assembly.ExportedTypes)
{
if (!(type.GetCustomAttribute(typeof(EfEntityAttribute)) is EfEntityAttribute attribute))
{
continue;
} if (type.IsNotPublic || type.IsAbstract || type.IsSealed
|| type.IsGenericType
|| type.ContainsGenericParameters)
{
continue;
} // Cast to EntityTypeBuilder
var entityBuilder = (EntityTypeBuilder)entityMethod.MakeGenericMethod(type)
.Invoke(modelBuilder, new object[] { }); if (attribute.EnableCustomTable)
{
entityBuilder.ToTable(attribute.ToString());
}
} //【2】 Use IEntityTypeConfiguration<T> register
modelBuilder.ApplyConfigurationsFromAssembly(assembly); base.OnModelCreating(modelBuilder);
}

Finally, context Injection , Here we distinguish the internal and external containers (EF Core Why is it divided into internal containers , Please refer to the article for specific reasons 《EntityFramework Core 3.x Context constructors can inject instances ?》)

Because in a real project, the context may need to inject other interfaces into the context constructor , For example, we may inject an interface into the context constructor to change the table schema or different table name rules according to the specific interface implementation

static IServiceProvider Initialize()
{
var services = new ServiceCollection(); services.AddEntityFrameworkSqlServer()
.AddDbContext<EfDbContext>(
(serviceProvider, options) =>
options.UseSqlServer("server=.;database=efcore;uid=sa;pwd=sa123;")
.UseInternalServiceProvider(serviceProvider)); services.Replace(ServiceDescriptor.Singleton<IModelCacheKeyFactory, CustomModelCacheKeyFactory>()); return services.BuildServiceProvider();
}

Because we have distinguished EF Core Internal and external containers , So when replacing the custom cache key factory , It can no longer be called directly as follows ReplaceService Methods to replace , It's bound to throw an exception

options.UseSqlServer("server=.;database=efcore;uid=sa;pwd=sa123;")
.ReplaceService<IModelCacheKeyFactory, CustomModelCacheKeyFactory>()

At the same time, keep in mind that Web Project utilization EF Core Always use scope (scope) To release the context , Unlike Web Can be based on HTTP Ask to act as scope, Finally, we test as follows

using (var scope1 = ServiceProvider.CreateScope())
{
var context1 = scope1.ServiceProvider.GetService<EfDbContext>(); context1.Database.EnsureCreated(); var type = context1.Model.FindEntityType(typeof(Test)); Console.WriteLine(type?.GetTableName()); var tests = context1.Set<Test>().ToList();
} Thread.Sleep(60000); using (var scope2 = ServiceProvider.CreateScope())
{
var context2 = scope2.ServiceProvider.GetService<EfDbContext>(); context2.Database.EnsureCreated(); var type = context2.Model.FindEntityType(typeof(Test)); Console.WriteLine(type?.GetTableName()); var tests1 = context2.Set<Test>().ToList();
}

For the convenience of seeing the actual effect , We build two scope, Then sleep for a minute , Print out the table name on the interface , If the name of the printed table is inconsistent after two minutes , It shows that we have achieved our expectation

Dynamic mapping model mode ( Two )

As mentioned above, we use the rule per minute dynamic mapping table , At the same time, different models can have their own rules ( Prefix , Every hour or every day ) wait , This is the first way

If you understand the first way completely , There may be doubts , Because the interface life cycle of the first method is singleton , If not, all models in the context will be cached

call OnModelCreating The method is just model building , But now we call the built-in APi To use all the models manually , There will be no caching at this point , So you don't need it anymore IModelCacheKeyFactory Interface

Yes EF Core If you know a little bit , We know OnModelCreating Method will only be called once , We use and dispose of all models manually , In other words, each request uses a new model , Said so much , So what are we going to do ?

If you've seen my previous principle analysis , Probably know EntityFramework Core For model processing ( Except for the default model cache ) There are three steps , Except for the model cache : Build the model , Using the model , Disposal model .

We will OnModelCreating The method code is copied directly , It's just three more steps , In our case ModelBuilder when , We need to provide the default contract for the corresponding database , Then use the model 、 Disposal model , It turns out like this

 services.AddEntityFrameworkSqlServer()
.AddDbContext<EfDbContext>(
(serviceProvider, options) => { options.UseSqlServer("server=.;database=efcore;uid=sa;pwd=sa123;")
.UseInternalServiceProvider(serviceProvider); var conventionSet = SqlServerConventionSetBuilder.Build(); var modelBuilder = new ModelBuilder(conventionSet); // OnModelCreating Method , Code duplication options.UseModel(modelBuilder.Model); modelBuilder.FinalizeModel();
)};

Run the first way to test the code , And then there's no problem

The problem is coming. , If there are multiple databases , Don't we all have to do it again like the above ? The above implementation essentially builds and reuses a new model each time a context is constructed , So we put it in context constructors , Then write an extension method to build the model , as follows :

public static class ModelBuilderExetension
{
public static ModelBuilder BuildModel(this ModelBuilder modelBuilder)
{ var entityMethod = typeof(ModelBuilder).GetMethod(nameof(modelBuilder.Entity), new Type[] { });
var assembly = Assembly.GetExecutingAssembly(); //【1】 Use Entity Methods registration
foreach (var type in assembly.ExportedTypes)
{
if (!(type.GetCustomAttribute(typeof(EfEntityAttribute)) is EfEntityAttribute attribute))
{
continue;
} if (type.IsNotPublic || type.IsAbstract || type.IsSealed
|| type.IsGenericType
|| type.ContainsGenericParameters)
{
continue;
} var entityBuilder = (EntityTypeBuilder)entityMethod.MakeGenericMethod(type)
.Invoke(modelBuilder, new object[] { }); if (attribute.EnableCustomTable)
{
entityBuilder.ToTable(attribute.ToString());
}
} //【2】 Use IEntityTypeConfiguration<T> register
modelBuilder.ApplyConfigurationsFromAssembly(assembly); return modelBuilder;
}
}

Finally, in the context constructor , Simple call , as follows :

public class EfDbContext : DbContext
{
public string Date { get; set; } = CustomTableFormat.MINUTE.FormatToDate();
public EfDbContext(DbContextOptions<EfDbContext> options) : base(options)
{
// Provide different database default conventions
ConventionSet conventionSet = null; if (Database.ProviderName == "Microsoft.EntityFrameworkCore.SqlServer")
{
conventionSet = SqlServerConventionSetBuilder.Build();
}
else if (Database.ProviderName == "Microsoft.EntityFrameworkCore.Sqllite")
{
conventionSet = SqliteConventionSetBuilder.Build();
}
else if (Database.ProviderName == "Microsoft.EntityFrameworkCore.MySql")
{
conventionSet = MySqlConventionSetBuilder.Build();
} var modelBuilder = new ModelBuilder(conventionSet); var optionBuilder = new DbContextOptionsBuilder(options); // Using the model
optionBuilder.UseModel(modelBuilder.Model); // Disposal model
modelBuilder.FinalizeModel();
} protected override void OnModelCreating(ModelBuilder modelBuilder)
{
// Build the model
modelBuilder.BuildModel(); base.OnModelCreating(modelBuilder);
}
}

Dynamic mapping model table generation

See here , Careful, you don't know if you have found , How did my printout work , No exception was thrown , The reality is that an exception must be thrown , Because we only do model dynamic mapping , But table auto generation, which I've ignored before , as follows :

How to generate this table also depends on the actual situation , such as SQL Server Write a job, automatically generate a table every day, etc , To be compatible with multiple databases , I'm afraid it's a little bit of trouble

I didn't spend much time looking at the source code , A little look at , If you take a chance, you may be able to directly find the interface implementation to create tables based on the model , It doesn't seem to be , Even if there is one, it's troublesome , So let's build it manually SQL Statement or pass lambda Construction can also

We can get the model that needs to be dynamically generated to implement its features in context , Then set up a timer to generate the corresponding table every minute , For different database types , We can get it through the following properties ( It's the same name as the package )

//  such as SQL Server:Microsoft.EntityFrameworkCore.SqlServer
context.Database.ProviderName

Here I use SQL Server Database, for example , Other databases like MySqL、Sqlite The only difference is that self growth settings and column types are different , Create table , It's made up of five parts : Does the table exist , Table name , Primary key , All columns , constraint . We define it as follows :

internal sealed class CustomTableModel
{
public CustomEntityType CustomEntityType { get; set; } public string TableName { get; set; } = string.Empty;
public string CheckTable { get; set; } = string.Empty;
public string PrimaryKey { get; set; } = string.Empty;
public string Columns { get; set; } = string.Empty;
public string Constraint { get; set; } = string.Empty; public override string ToString()
{
var placeHolder = $"{CheckTable} create table {TableName} ({PrimaryKey} {Columns}"; placeHolder = string.IsNullOrEmpty(Constraint) ? $"{placeHolder.TrimEnd(',')})" : $"{placeHolder}{Constraint})"; return placeHolder.Replace("@placeholder_table_name", CustomEntityType.ToString());
}
}

Because each generation only has a different table name , So we cache the entire table data structure , Just replace the table name inside . The whole implementation logic is as follows :

public static void Execute()
{
using var scope = Program.ServiceProvider.CreateScope();
var context = scope.ServiceProvider.GetService<EfDbContext>(); context.Database.EnsureCreated(); var cache = scope.ServiceProvider.GetService<IMemoryCache>(); var cacheKey = context.GetType().FullName; if (!cache.TryGetValue(cacheKey, out List<CustomTableModel> models))
{
lock (_syncObject)
{
if (!cache.TryGetValue(cacheKey, out models))
{
models = CreateModels(context); models = cache.Set(cacheKey, models, new MemoryCacheEntryOptions { Size = 100, Priority = CacheItemPriority.High });
}
}
} Create(context, models);
} private static void Create(EfDbContext context, List<CustomTableModel> models)
{
foreach (var m in models)
{
context.Execute(m.ToString());
}
} internal static void CreateEntityTypes(CustomEntityType customEntityType)
{
EntityTypes.Add(customEntityType);
}

The red part above is very important , Why? ? Let's do it first OnModelCreating Method , That is to say, we have to make sure that all models have been built , We can get all the model metadata in context

And then there's OnModeCreating In the method , On the basis of starting the automatic mapping model , Add the following code ( Of course, you also need to check whether the table name is duplicate ):

 if (attribute.EnableCustomTable)
{
entityBuilder.ToTable(attribute.ToString()); var customType = new CustomEntityType()
{
ClrType = type,
Prefix = attribute.Prefix,
Format = attribute.Format
}; var existTable = CreateCustomTable.EntityTypes.FirstOrDefault(c => c.ToString() == customType.ToString()); if (existTable != null)
{
throw new ArgumentNullException($"Cannot use table '{customType}' for entity type '{type.Name}' since it is being used for entity type '{existTable.ClrType.Name}' ");
} CreateCustomTable.CreateEntityTypes(customType);
}

Believe in building SQL I don't care about the sentence , No more , Children's shoes in real need , But I don't know , If there are more people , I will be compatible with different databases SQL Statement construction will be placed in github Up , The console entry method is called as follows :

private const int TIME_INTERVAL_IN_MILLISECONDS = 60000;
private static Timer _timer { get; set; }
public static IServiceProvider ServiceProvider { get; set; }
static void Main(string[] args)
{
ServiceProvider = Initialize(); // Check once during initialization
CreateCustomTable.Execute(); // Timing check
_timer = new Timer(TimerCallback, null, TIME_INTERVAL_IN_MILLISECONDS, Timeout.Infinite); using (var scope1 = ServiceProvider.CreateScope())
{
var context1 = scope1.ServiceProvider.GetService<EfDbContext>(); context1.Database.EnsureCreated(); var type = context1.Model.FindEntityType(typeof(Test1)); Console.WriteLine(type?.GetTableName()); var tests = context1.Set<Test1>().ToList();
} Thread.Sleep(60000); using (var scope2 = ServiceProvider.CreateScope())
{
var context2 = scope2.ServiceProvider.GetService<EfDbContext>(); context2.Database.EnsureCreated(); var type = context2.Model.FindEntityType(typeof(Test2)); Console.WriteLine(type?.GetTableName()); var tests1 = context2.Set<Test2>().ToList();
} Console.ReadKey(); }

The next step is to define the timer , Callbacks call the above Execute Method , as follows :

static void TimerCallback(object state)
{
var watch = new Stopwatch(); watch.Start(); CreateCustomTable.Execute(); _timer.Change(Math.Max(0, TIME_INTERVAL_IN_MILLISECONDS - watch.ElapsedMilliseconds), Timeout.Infinite);
}

Finally, let's test the actual effect of two models

[EfEntity(EnableCustomTable = true, Prefix = "test1", Format = CustomTableFormat.MINUTE)]
public class Test1
{
public int Id { get; set; }
public int UserId { get; set; }
public string Name { get; set; }
} public class Test1EntityTypeConfiguration : IEntityTypeConfiguration<Test1>
{
public void Configure(EntityTypeBuilder<Test1> builder)
{
builder.HasKey(k => new { k.Id, k.UserId });
}
} [EfEntity(EnableCustomTable = true, Prefix = "test2", Format = CustomTableFormat.MINUTE)]
public class Test2
{
public int Id { get; set; }
public int UserId { get; set; }
public string Name { get; set; }
} public class Test2EntityTypeConfiguration : IEntityTypeConfiguration<Test2>
{
public void Configure(EntityTypeBuilder<Test2> builder)
{
builder.HasKey(k => new { k.Id, k.UserId });
}
}

summary

Last, last , Old rules , There are two ways to implement dynamic mapping model , By manually building SQL Statement and cache , Summarized below !

Use IModelCacheKeyFactory

Using the model manually 、 Disposal model

Compatible with different databases , Build... Manually SQL Statement and cache

EntityFramework Core How to map dynamic models ? More articles about

  1. What you don't know about inventory overruns How many servers are there in general qps better [ turn ] JAVA Learning from things : The return code you don't know Deepen understanding EntityFramework Core 2.1 Delay loading (Lazy Loading) EntityFramework 6.x and EntityFramework Core The navigation attribute in a relational mapping must be public? The pitfalls of regular expressions Two interview questions , Take you to analyze Java Class loading mechanism

    What you don't know about inventory overruns In Internet enterprises , The practice of purchase restriction , Various , Some are original , Some are old-fashioned , But the purpose of all kinds of methods is to achieve , There are no more than a few , The goods are sold out , The system can withstand , Inventory is not over limit . Although just a few words , But there is a lot to say , Tao not ...

  2. EntityFramework 6.x and EntityFramework Core The navigation attribute in a relational mapping must be public?

    Preface I wonder if we have ever thought about a problem , In relation mapping, whether the access modifier for navigation properties must be public Well ? If you never thought about it , So let's talk about this next . EF 6.x and EF Core Under what circumstances must be equipped with ...

  3. EntityFramework Core Learning notes —— Creating models

    Original address :https://docs.efproject.net/en/latest/modeling/index.html Preface : EntityFramework Use a set of conventions to start with our entity class details ...

  4. EntityFramework Core Once and for all dynamic loading model , What do we need to know ?

    Preface This article comes from a child who asked me about children's shoes : stay EntityFramework Core How to load the model dynamically in ? I'm learning EntityFramwork The answer to this question has already been given by the corresponding garden friends , So there is not much research , Although it was solved in the end ...

  5. EntityFramework Core The navigation property problem is ignored

    Preface .NET Core Project utilization EntityFramework Core As a data access layer, it's ongoing , I haven't paid much attention to the generation behind it SQL sentence , Then the boss fished out the log file to have a look , Okay , There's a problem , So this article has produced , also ...

  6. EntityFramework Core Automatically bind model maps

    When I was working on a project with my colleagues recently , You need to read entity information from the class library containing database entity type provided by them and bind it to your own project ( But it's all in the same solution ), So a very direct way is to put all the entities in the project as public Db ...

  7. ASP.NET Core 2.2 nineteen . Action Parameter mapping and model binding

    As I said before Action Activation , The key operation here is Action Parameter mapping and model binding , Here is the simple string.int Other types , Also contains Json Etc , This article shares the process in detail .(ASP.NET ...

  8. Cookies First time to know Dotnetspider EF 6.x、EF Core Realization dynamic Dynamic query and EF Core Inject multiple context instance pools, you know what the problem is ? EntityFramework Core function dotnet ef What is the essence behind command migration ?(EF Core Migration principle )

    Cookies   1. establish HttpCookies Cookie=new HttpCookies("CookieName");2. Add content Cookie.Values.Add(&qu ...

  9. EntityFramework Core Can private properties be mapped ? Get to know .

    Preface I've been feeling a little sick in recent days , It takes courage to speak , Cry bitterly . Today, I'd like to write a brief exploration , Just to know , Thank you for reading . EF Core Mapping private properties stay EF 6.x In this series, I wrote an article about mapping private properties , explain EF The flexibility of the ...

  10. The first 15 Chapter Use EntityFramework Core Configure and manipulate data - Identity Server 4 Chinese document (v1.0.0)

    IdentityServer Designed for scalability , One of the extensible points is for IdentityServer Storage mechanism of required data . This quick start shows how to configure IdentityServer To use the EntityFramewo ...

Random recommendation

  1. 【 turn 】 Various versions IIS Next ASP.net Request processing is different

    Original address :http://www.cnblogs.com/fsjohnhuang/articles/2332074.html ASP.NET It's a very powerful build Web Application platform , It provides great flexibility and energy ...

  2. The 236th day how can I insist

    It's too cold , Down jacket, no hat , The cold ear hurts . She didn't go to work today , It turned out to be a day off . In fact, it should be something to think of , You should write down , I forget to write in the evening , I don't remember anything , That's a demand . sleep .

  3. [android]netd And NetworkManagementService First impression

    [ function ]Netd What is it? , What functions are they mainly responsible for Why contact this time Netd The main reason is that when setting up the firewall, we encountered . About Netd What can be done from Netd In the source code CommandListener And get the answer . As I understand it , ...

  4. android Application version update function --- Full version

    Source code download address :csdn Download address :http://download.csdn.net/download/csdn576038874/9526085 Blog Park download address :http://files.cnblogs ...

  5. Hook SSDT in NtCreateProcessEx

    #ifdef __cplusplus extern "C" { #endif #include <ntddk.h> #ifdef __cplusplus } #endi ...

  6. 201521123044 《Java Programming 》 The first 8 Weekly learning summary

    1. Summary of this chapter 2. Written work The problem set of homework 1.List Deletion of specified elements in ( subject 4-1) 1.1 Summary of the experiment ( See note ) public static List<String> conv ...

  7. JDBC The use of five steps and query operation - Database programming ( Two )

    jdbc How to use 1. load jdbc The driver . 2. Open the connection to the database . 3. Set up a conversation , Then perform basic operations such as adding, deleting, modifying, and checking . 4. Process the results 5. Clean up the environment , For example, close the conversation . Query operation First use Cla ...

  8. Hibernate Operating the database

    com.tao.pojo Entity class package com.tao.pojo; public class User { private int id; private String name; priva ...

  9. .net The pictures uploaded on the website will not be displayed on the computer

    When not using the website IP Address access picture , When accessing only relative paths , When publishing the website , The destination folder where the image will be uploaded , Included in the project and then published .

  10. Compare the nodes host And Standard nodes host Differential script

    Put the nodes together host Copy to a node This can be done by reading the host name configuration I'm lazy here echo 'starting' ssh hadoop01 "cp /etc/hosts ~/hadoop01-ho ...