# 创建一个简单的.net core 框架程序

最新推荐文章于 2024-06-18 23:35:27 发布
最新推荐文章于 2024-06-18 23:35:27 发布
阅读量701 收藏 1
点赞数 2
分类专栏： web c# .net .net core 文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/i_qiangqiang/article/details/116244347
版权

创建一个简单的.net core 框架程序

​ 最近项目比较紧张，抽空学习了一下框架是怎么搭建的，学习的比较零碎，学习的地方比较多，遇到的问题也是比较多的，自己学习是比较乏味枯燥的过程，学习还是断断续续的，遇到的难点踩坑比较多，过程是比较痛苦的。现在.net core跨平台已经适用于生产环境中去了，我也是在慢慢的研究了一下，并没有去系统的学习，用到什么就学习什么这种状态，记录一下；
第一步先创建一个.net Core MVC项目
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GzqFw58f-1619617941963)(屏幕截图 2021-04-11 194826.png)]

第二步创建一些类库
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ov5SyOwU-1619617941966)(屏幕截图 2021-04-11 195955.png)]

Application:是应用服务层
Core:是实体模型层
EFWork:是连接上下文和仓储服务层
现在互相引用一下,关系如下
Core
EasyFramework
EFWork
Application
Core
Application
EFWork
EFWork
Core

先在Core类库中创建一个实体类和一个抽象类
抽象类里面添加一些常用的字段
抽象类

 public abstract class EntityBase
 {
     public EntityBase()
     {
         CreateTime = DateTime.Now;
     }
     [Key]
     public int Id { get; set; }
     public DateTime CreateTime { get; set; }
 }

一个用户实体并且继承EntityBase


 public class Users : EntityBase
 {

     [StringLength(20)]
     public string UserName { get; set; }
     [StringLength(20, MinimumLength = 6)]
     public string Password { get; set; }
 }

然后在EFWork中引用EntityFrameworkCore和Microsoft.EntityFrameworkCore.SqlServer因为我使用的数据库是Microsoft SQL Server 就用EF这套来连接操作数据库（其他数据库也有异曲同工之妙）
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UpFiCoOU-1619617941969)(屏幕截图 2021-04-11 202343.png)]

操作完毕开始连接数据库和手写仓储方法
在EFWork中创建一个连接数据库的上下文

 public class WebDbContext:DbContext
 {
     public DbSet<Users> users { get; set; }
     public WebDbContext(DbContextOptions<WebDbContext> options) : base(options)
     { 
     
     }
 }

然后创建Repository类和IRepository接口类

   public class Repository<TEntity, TDbContext> : IRepository<TEntity> where TEntity : class
  {
     private readonly WebDbContext dbContext;
     public Repository(WebDbContext _dbContext)
     {
         dbContext = _dbContext;
     }
     /// <summary>
     /// 新增数据
     /// </summary>
     /// <param name="entity">实体</param>
     /// <returns></returns>
     public TEntity Add(TEntity entity)
     {
         var result = dbContext.Set<TEntity>().Add(entity).Entity;
         dbContext.SaveChanges();
         return result;
     }
     /// <summary>
     /// 异步新增数据
     /// </summary>
     /// <param name="entity">实体</param>
     /// <returns></returns>
     public async Task<TEntity> AddAsync(TEntity entity)
     {
         var result = (await dbContext.Set<TEntity>().AddAsync(entity)).Entity;
         await dbContext.SaveChangesAsync();
         return result;
     }
     /// <summary>
     /// 删除数据
     /// </summary>
     /// <param name="entity">实体</param>
     public int Delete(TEntity entity)
     {
         dbContext.Set<TEntity>().Remove(entity);
         dbContext.Entry(entity).State = Microsoft.EntityFrameworkCore.EntityState.Deleted;
         return dbContext.SaveChanges();

     }
     /// <summary>
     /// 异步删除数据
     /// </summary>
     /// <param name="entity">实体</param>
     /// <returns></returns>
     public async Task<int> DeleteAsync(TEntity entity)
     {
         return await Task.FromResult(Delete(entity));
     }
     /// <summary>
     /// 更新数据
     /// </summary>
     /// <param name="entity">实体</param>
     /// <returns></returns>
     public TEntity Update(TEntity entity)
     {
         var result = dbContext.Set<TEntity>().Update(entity).Entity;
         dbContext.Entry(entity).State = Microsoft.EntityFrameworkCore.EntityState.Detached;
         dbContext.SaveChanges();
         return result;
     }
     /// <summary>
     /// 异步更新数据
     /// </summary>
     /// <param name="entity">实体</param>
     /// <returns></returns>
     public async Task<TEntity> UpdateAsync(TEntity entity)
     {
         var result = await Task.FromResult(Update(entity));
         return result;
     }
     /// <summary>
     /// 通过拉姆达表达式查找数据
     /// </summary>
     /// <param name="predicate">表达式</param>
     /// <returns></returns>
     public IEnumerable<TEntity> GetAll(Func<TEntity, bool> predicate)
     {
         return dbContext.Set<TEntity>().Where(predicate);
     }
     /// <summary>
     /// 异步通过拉姆达表达式查找数据
     /// </summary>
     /// <param name="predicate">表达式</param>
     /// <returns></returns>
     public async Task<IEnumerable<TEntity>> GetAllList(Func<TEntity, bool> predicate)
     {
         return await Task.FromResult(GetAll(predicate));
     }
     /// <summary>
     /// 通过分页查询数据
     /// </summary>
     /// <param name="predicateOrder">正序排列条件</param>
     /// <param name="predicate">查询条件</param>
     /// <param name="Count">返回条数</param>
     /// <param name="PageIndex">页码</param>
     /// <param name="PageSize">页的大小</param>
     /// <returns></returns>
     public IEnumerable<TEntity> PageRequestResult(Func<TEntity, bool> predicateOrder, Func<TEntity, bool> predicate, out int Count, int PageIndex = 1, int PageSize = 10)
     {
         var result = dbContext.Set<TEntity>().Where(predicate).OrderBy(predicateOrder).Take((PageIndex - 1) * PageSize).Skip(PageSize);
         Count = result.Count();
         return result;
     }
     /// <summary>
     /// 其他方法扩展
     /// </summary>
     /// <returns></returns>
     public DbSet<TEntity> OtherExtend()
     {
         var result = dbContext.Set<TEntity>();
         return result;
     }

 }

  public interface IRepository<TEntity> where TEntity : class
 {
     /// <summary>
     /// 新增数据
     /// </summary>
     /// <param name="entity">实体</param>
     /// <returns></returns>
     TEntity Add(TEntity entity);
     /// <summary>
     /// 异步新增数据
     /// </summary>
     /// <param name="entity">实体</param>
     /// <returns></returns>
     Task<TEntity> AddAsync(TEntity entity);
     /// <summary>
     /// 删除数据
     /// </summary>
     /// <param name="entity">实体</param>
     int Delete(TEntity entity);
     /// <summary>
     /// 异步删除数据
     /// </summary>
     /// <param name="entity">实体</param>
     /// <returns></returns>
     Task<int> DeleteAsync(TEntity entity);
     /// <summary>
     /// 更新数据
     /// </summary>
     /// <param name="entity">实体</param>
     /// <returns></returns>
     TEntity Update(TEntity entity);
     /// <summary>
     /// 异步更新数据
     /// </summary>
     /// <param name="entity">实体</param>
     /// <returns></returns>
     Task<TEntity> UpdateAsync(TEntity entity);
     /// <summary>
     /// 通过拉姆达表达式查找数据
     /// </summary>
     /// <param name="predicate">表达式</param>
     /// <returns></returns>
     IEnumerable<TEntity> GetAll(Func<TEntity, bool> predicate);
     /// <summary>
     /// 异步通过拉姆达表达式查找数据
     /// </summary>
     /// <param name="predicate">表达式</param>
     /// <returns></returns>
     Task<IEnumerable<TEntity>> GetAllList(Func<TEntity, bool> predicate);
     /// <summary>
     /// 通过分页查询数据
     /// </summary>
     /// <param name="predicateOrder">正序排列条件</param>
     /// <param name="predicate">查询条件</param>
     /// <param name="Count">返回条数</param>
     /// <param name="PageIndex">页码</param>
     /// <param name="PageSize">页的大小</param>
     /// <returns></returns>
     IEnumerable<TEntity> PageRequestResult(Func<TEntity, bool> predicateOrder, Func<TEntity, bool> predicate, out int Count, int PageIndex = 1, int PageSize = 10);
     /// <summary>
     /// 其他方法扩展
     /// </summary>
     /// <returns></returns>
     DbSet<TEntity> OtherExtend();

仓储内的方法只写了一些，也可以自由扩展一下
然后迁移数据库，先在appsettings.json中配置数据库

{
"ConnectionStrings": {
 "DefaultConnection": "Server=.;Database=EFWorkDB;Trusted_Connection=True;MultipleActiveResultSets=true"
},
"Logging": {
 "LogLevel": {
   "Default": "Information",
   "Microsoft": "Warning",
   "Microsoft.Hosting.Lifetime": "Information"
 }
},
"AllowedHosts": "*"
}

在Startup中配置service

  public void ConfigureServices(IServiceCollection services)
     {
         //注册DbConfig,连接数据库
         services.AddDbContext<WebDbContext>(options =>
             options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
         //添加数据库异常筛选器 需要下载Microsoft.AspNetCore.Diagnostics.EntityFrameworkCore，并且引用
         services.AddDatabaseDeveloperPageExceptionFilter();
         services.AddControllersWithViews();
     }

找到命令控制台选择默认项目为EFWork项目,然后安装数据迁移命令库Install-Package Microsoft.EntityFrameworkCore.Tools

在mvc项目中安装包Install-Package Microsoft.EntityFrameworkCore.Design

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uZ2AnnMu-1619617941972)(屏幕截图 2021-04-14 165838.png)]

Add-Migration 命令会通知迁移框架使用当前 DB 架构检查当前 users 模型，并创建必要的代码，将 DB 迁移到新模型。

Update-Database更新数据库
迁移成功后可以查看数据库是否正确，迁移过程中可能会缺少一些相应的库，在nuget上下载即可；
然后我们在Application项目中添加我们的服务，添加一个ApplicationModule类添加一些相关的方法

 public class AsyncCrudAppService<TEntity> : IAsyncCrudAppService<TEntity> where TEntity : class
    {
        private readonly IRepository<TEntity> repository;
        public AsyncCrudAppService(IRepository<TEntity> _repository)
        {
            repository = _repository;
        }
        /// <summary>
        /// 新增数据
        /// </summary>
        /// <param name="entity">实体</param>
        /// <returns></returns>
        public TEntity Add(TEntity entity)
        {
            var result = repository.Add(entity);
            return result;
        }
        /// <summary>
        /// 异步新增数据
        /// </summary>
        /// <param name="entity">实体</param>
        /// <returns></returns>
        public async Task<TEntity> AddAsync(TEntity entity)
        {
            var result = await repository.AddAsync(entity);
            return result;
        }
        /// <summary>
        /// 删除数据
        /// </summary>
        /// <param name="entity">实体</param>
        public int Delete(TEntity entity)
        {

            return repository.Delete(entity);

        }
        /// <summary>
        /// 异步删除数据
        /// </summary>
        /// <param name="entity">实体</param>
        /// <returns></returns>
        public async Task<int> DeleteAsync(TEntity entity)
        {
            return await repository.DeleteAsync(entity);
        }
        /// <summary>
        /// 更新数据
        /// </summary>
        /// <param name="entity">实体</param>
        /// <returns></returns>
        public TEntity Update(TEntity entity)
        {
            var result = repository.Update(entity);
            return result;
        }
        /// <summary>
        /// 异步更新数据
        /// </summary>
        /// <param name="entity">实体</param>
        /// <returns></returns>
        public async Task<TEntity> UpdateAsync(TEntity entity)
        {
            var result = await repository.UpdateAsync(entity);
            return result;
        }
        /// <summary>
        /// 通过拉姆达表达式查找数据
        /// </summary>
        /// <param name="predicate">表达式</param>
        /// <returns></returns>
        public IEnumerable<TEntity> GetAll(Func<TEntity, bool> predicate)
        {
            return repository.GetAll(predicate);
        }
        /// <summary>
        /// 异步通过拉姆达表达式查找数据
        /// </summary>
        /// <param name="predicate">表达式</param>
        /// <returns></returns>
        public async Task<IEnumerable<TEntity>> GetAllList(Func<TEntity, bool> predicate)
        {
            return await repository.GetAllList(predicate);
        }
        /// <summary>
        /// 通过分页查询数据
        /// </summary>
        /// <param name="predicateOrder">正序排列条件</param>
        /// <param name="predicate">查询条件</param>
        /// <param name="Count">返回条数</param>
        /// <param name="PageIndex">页码</param>
        /// <param name="PageSize">页的大小</param>
        /// <returns></returns>
        public IEnumerable<TEntity> PageRequestResult(Func<TEntity, bool> predicateOrder, Func<TEntity, bool> predicate, out int Count, int PageIndex = 1, int PageSize = 10)
        {
            var result = repository.PageRequestResult(predicateOrder,predicate,out Count,PageIndex,PageSize);           
            return result;
        }

    }
    public interface IAsyncCrudAppService<TEntity> where TEntity : class
    {
        /// <summary>
        /// 新增数据
        /// </summary>
        /// <param name="entity">实体</param>
        /// <returns></returns>
        TEntity Add(TEntity entity);
        /// <summary>
        /// 异步新增数据
        /// </summary>
        /// <param name="entity">实体</param>
        /// <returns></returns>
        Task<TEntity> AddAsync(TEntity entity);
        /// <summary>
        /// 删除数据
        /// </summary>
        /// <param name="entity">实体</param>
        int Delete(TEntity entity);
        /// <summary>
        /// 异步删除数据
        /// </summary>
        /// <param name="entity">实体</param>
        /// <returns></returns>
        Task<int> DeleteAsync(TEntity entity);
        /// <summary>
        /// 更新数据
        /// </summary>
        /// <param name="entity">实体</param>
        /// <returns></returns>
        TEntity Update(TEntity entity);
        /// <summary>
        /// 异步更新数据
        /// </summary>
        /// <param name="entity">实体</param>
        /// <returns></returns>
        Task<TEntity> UpdateAsync(TEntity entity);
        /// <summary>
        /// 通过拉姆达表达式查找数据
        /// </summary>
        /// <param name="predicate">表达式</param>
        /// <returns></returns>
        IEnumerable<TEntity> GetAll(Func<TEntity, bool> predicate);
        /// <summary>
        /// 异步通过拉姆达表达式查找数据
        /// </summary>
        /// <param name="predicate">表达式</param>
        /// <returns></returns>
        Task<IEnumerable<TEntity>> GetAllList(Func<TEntity, bool> predicate);
        /// <summary>
        /// 通过分页查询数据
        /// </summary>
        /// <param name="predicateOrder">正序排列条件</param>
        /// <param name="predicate">查询条件</param>
        /// <param name="Count">返回条数</param>
        /// <param name="PageIndex">页码</param>
        /// <param name="PageSize">页的大小</param>
        /// <returns></returns>
        IEnumerable<TEntity> PageRequestResult(Func<TEntity, bool> predicateOrder, Func<TEntity, bool> predicate, out int Count, int PageIndex = 1, int PageSize = 10);

    }

这个类中的相应代码，主要时为了减少代码的重复操作
我们在Sevcies和IService中继承这两个类就行了

                          Service
     public class UserService : AsyncCrudAppService<Users>, IUserService
     {
        private readonly IRepository<Users> repository;
        public UserService(IRepository<Users> _repository) : base(_repository)
        {           
        }
     }
                           IService
    public interface IUserService : IAsyncCrudAppService<Users>
    {
    }

然后我们需要在Startup中注册相关项

 services.AddScoped<IRepository<Users>, Repository<Users>>();
 services.AddScoped<IAsyncCrudAppService<Users>, AsyncCrudAppService<Users>>();
 services.AddScoped<IUserService, UserService>();

在HomeController中添加一些功能
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hvgKVYF1-1619617941973)(屏幕截图 2021-04-14 191048.png)]

写了获取数据和添加数据功能，其他功能可以自由扩展，就不一一列出了
基本的操作已经做完了
接下来就是登录的了

先创建一个AccountController控制器，然后在Startup中配置注册权限过滤

            //身份验证注册
            app.UseAuthentication();

再全局注册权限验证机制和登录时的Cookie信息

//在 Startup.ConfigureServices 方法中，创建具有和方法的身份验证中间件服务 AddAuthentication AddCookie 
            services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme).AddCookie(CookieAuthenticationDefaults.AuthenticationScheme, options =>
           {
               //没有登陆时，将会将请求重定向到这个相对路径
               options.LoginPath = new PathString("/Account/Login");
               //登录后cookie的名称
               options.Cookie.Name = "My_Cookie";
               //没有访问权限时，将会将请求重定向到这个相对路径
               options.AccessDeniedPath = new PathString("/Home/Error");
           });
            //全局加入身份验证
            services.AddMvc(options => options.Filters.Add(new AuthorizeFilter())).SetCompatibilityVersion(CompatibilityVersion.Version_3_0);

在视图Login中创建登录页面

@model LoginViewModel

@{ Layout = null; }
<link rel="stylesheet" href="~/lib/bootstrap/dist/css/bootstrap.min.css" />
<link rel="stylesheet" href="~/css/site.css" />
<div class="row">
    <div class="col-md-8">

        <form asp-action="Login">
            <input type="hidden" name="returnUrl" value="@ViewBag.ReturnUrl" />
            <h4>帐户登录</h4>
            <hr />
            <div asp-validation-summary="ModelOnly" class="text-danger"></div>
            <div class="form-group">
                <label asp-for="Email" class="control-label"></label>
                <input asp-for="Email" class="form-control" />
                <span asp-validation-for="Email" class="text-danger"></span>
            </div>
            <div class="form-group">
                <label asp-for="Password" class="control-label"></label>
                <input asp-for="Password" type="password" class="form-control" />
                <span asp-validation-for="Password" class="text-danger"></span>
            </div>
            <div class="form-group">
                <div class="col-md-offset-2 col-md-10">
                    <div class="checkbox">
                        @Html.CheckBoxFor(m => m.RememberMe)
                        @Html.LabelFor(m => m.RememberMe)
                    </div>
                </div>
            </div>
            <div class="form-group">
                <div class="col-md-offset-2 col-md-10">
                    <input type="submit" value="登录" class="btn btn-success" />
                </div>
            </div>

        </form>


        

    </div>
</div>
@section Scripts {
    @{ await Html.RenderPartialAsync("_ValidationScriptsPartial"); }
}

//登录的model 
public class LoginViewModel
    {
        [Required]
        [Display(Name = "电子邮件")]
        [EmailAddress]
        public string Email { get; set; }

        [Required]
        [DataType(DataType.Password)]
        [Display(Name = "密码")]
        public string Password { get; set; }

        [Display(Name = "记住我?")]
        public bool RememberMe { get; set; }
    }

我们登录的Controller如下

 public class AccountController : Controller
    {
        [AllowAnonymous]
        public IActionResult Login(string returnUrl)
        {
            if (string.IsNullOrWhiteSpace(returnUrl))
            {
                returnUrl = GetAppHomeUrl();
            }
            ViewBag.ReturnUrl = returnUrl;
            return View();
        }
        [HttpPost]
        [AllowAnonymous]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> Login(LoginViewModel model, string returnUrl)
        {            
            if (model.Email.Equals("admin@admin.com") && model.Password.Equals("123qwe"))
            {
                var claims = new List<Claim>
            {
                new Claim(ClaimTypes.Name, model.Email),

            };
                var claimsIdentity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);
                await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, new ClaimsPrincipal(claimsIdentity), new AuthenticationProperties
                {
                    IsPersistent = true,
                    RedirectUri = returnUrl,
                    ExpiresUtc = DateTime.Now.AddSeconds(5)//每访问一下页面会添加一下访问时间，如果时间到期，会跳转到登录页面
                });
                return RedirectToLocal(returnUrl);
            }
            else
            {
                return View();
            }


        }
        public async Task<IActionResult> LogOut()
        {
            await HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
            return RedirectToAction("Login");
        }
        /// <summary>
        /// 重定项
        /// </summary>
        /// <param name="returnUrl"></param>
        /// <returns></returns>
        private ActionResult RedirectToLocal(string returnUrl)
        {
            if (Url.IsLocalUrl(returnUrl))
            {
                return Redirect(returnUrl);
            }
            return RedirectToAction("Index", "Home");
        }
        public string GetAppHomeUrl()
        {
            return Url.Action("Index", "Home");
        }
    }

到此为止现在的框架基本都差不多了，适合小型项目的使用了，但是还有一个问题就是如果咱们的实体类过多的情况下，需要依赖注入代码量庞大，所以咱们要写一个通用的方法来批量依赖注入，现在来看依赖注入的代码

/// <summary>
    /// 先创建一个抽象类
    /// </summary>
    public abstract class IocManager
    {
        public static void Register(IServiceCollection services)
        {
            Type type = typeof(IDependency);//获取继承IDependency的类型
            //从程序集中找到包含IDependency所有相关
            var Types = AppDomain.CurrentDomain.GetAssemblies().SelectMany(a => a.GetTypes().Where(t => t.GetInterfaces().Contains(type) || t.GetInterfaces().Contains(type)));
            //得到类的集合
            var classList = Types.Where(o => o.IsClass).ToList();
            //得到接口的集合
            var InterfaceList = Types.Where(o => o.IsInterface).ToList();
            foreach (var item in classList)
            {
                var firstInterface = InterfaceList.FirstOrDefault(o => o.IsAssignableFrom(item));//class有接口，注入接口和类
                if (firstInterface != null)
                {
                    services.AddScoped(firstInterface, item);
                }
                else
                {
                    //注入class
                    services.AddScoped(item);
                }
            }
            //派生类注入
            services.AddScoped(typeof(IRepository<>), typeof(Repository<>));
            services.AddScoped(typeof(IAsyncCrudAppService<>), typeof(AsyncCrudAppService<>));

        }
    }

在Startup.ConfigureServices中注入

 //批量依赖注入
IocManager.Register(services);

创建一个IDependency接口

 public interface IDependency
    {
    }

在我们的IService中继承IDependency

 public interface IUserService : IAsyncCrudAppService<Users>, IDependency
    {
    }

就到此结束结束了

[外链图片转存中...(img-IkcgurWo-1619617941975)]

i-小小公子
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
两种创建.NET Core应用程序方法
ab1234_123的博客
08-04 428
.NET Core平台 @.NET Core应用程序 1.什么是.NET Core平台 2.两种创建两种创建.NET Core应用程序方法 1.0 NET Core是适用与windows，Mac, OSX和Linux 操作系统免费的，开源托管的计算及软件平台，是微软公司开发的第一个官方版本，具有跨平台（windows，Mac, OSX）能力应用的应用程序。 2.0 2.1.0使用命令符创建.NET Core项目 首先新建一个文件夹（命名为你制定项目的名称） ...
Falco：一种功能优先的工具包，用于使用F＃构建出色的ASP.NET Core应用程序
01-30
Falco是一个专为F#开发者设计的轻量级、功能优先的Web开发框架，它旨在帮助创建高性能、可维护且易于理解的ASP.NET Core应用程序。 Falco的核心设计理念是利用F#语言的强类型特性和函数式编程的优势，提供简洁的API...
以DonetCore+vue+Element搭建的简单框架
09-30
本项目是以asp.net core mvc+vue+element-ui为基础搭建的框架，实现基础的cms功能，开发工具为visual studio2019，vue版本为2.6.12.
新建 .NET Core 项目 -- Hello World!
weixin_30389003的博客
09-19 195
索引： 目录索引 一.开发工具安装 　　1.可选模式一 (不推荐,此为Windows开发方式) 　　　　安装 Visual Studio 2015 / Visual Studio 2015 Update 3 / .NET Core 1.0.1 - VS 2015 Tooling Preview 2 , 　　　　visualstudio 　　　　.NET Core 1.0.1 - VS ...
ASP.NET Core MVC 项目的创建（超详细教程）
最新发布
qq_74405602的博客
06-18 1319
asp.net core mvc项目的创建
第一章 搭建一个通用的.net core项目框架
weixin_34007886的博客
04-19 203
项目目标部署环境:CentOS 7+ 项目技术点:.netcore2.0 + Autofac +webAPI + NHibernate5.1 + mysql5.6 + nginx 开源地址:https://github.com/wmowm/nh.core 作为.net开发人员,我们最熟悉的肯定是经典的三层架构了 这里插入一个题外话,很多人喜欢拿三层跟mvc,mvvm 做一些比较,它们...
使用插件创建 .NET Core 应用程序
dotNET跨平台
01-08 368
使用插件创建 .NET Core 应用程序本教程展示了如何创建自定义的 AssemblyLoadContext 来加载插件。AssemblyDependencyResolver 用于...
.Net core 微服务框架搭建
Martin 的博客
03-02 2030
建微服务框架 可采用集成.NET Core+Swagger+Consul+Polly+Ocelot+IdentityServer4+Exceptionless+Apollo Consul：实现分布式系统的服务发现与配置https://www.consul.io/ Polly：瞬态故障处理库NuGet>Install-Package Polly　　 Ocelot：API网关 IdentityServer4：认证框架 Exceptionless：异常收 Apollo ： ...
.NET Core创建一个控制台（Console）程序
10-20
.NET Core是一个开源的通用跨平台框架，由微软开发和维护，用于构建各种应用程序，包括Web应用、IoT应用以及服务器应用等。它适用于构建云服务和微服务架构。.NET Core支持跨平台运行，并且支持在一个平台上开发，在...
TimeDisplay：创建一个ASP.NET Core应用程序，该应用程序查找当前日期和时间并显示在前端
02-16
"TimeDisplay" 是一个基于ASP.NET Core框架构建的Web应用程序项目，它的主要功能是获取服务器上的当前日期和时间，并将其在前端页面上展示给用户。这个项目对于初学者来说是一个很好的起点，因为它涉及到基础的...
dotnet 简单方法在一个进程内同时跑起 WPF 和 ASP.NET Core 框架.rar
06-03
8. **.NET Maui框架**：虽然主题主要集中在WPF和ASP.NET Core，但提到的标签`.NET Maui`是微软的一个新框架，它允许开发者使用一套代码库创建跨平台的移动和桌面应用。了解Maui可以为未来可能的跨平台集成提供便利。...
.NETCorex项目框架搭建
12-11
本文介绍了.netcore框架如何连接数据库，以及项目架构
Asp.net core 框架
10-11
Asp.net core 是16年微软发布的新技术，最近公司使用，我也有机会学习一下，本代码是一个Asp.net core 学习框架。
dotnet-Anet是一个NETCore通用框架特点是简单易用
08-15
A .NET Core Common Library , Framework and Boilerplate.
创建第一个 .NET Core 应用程序
在开始创建第一个 .NET Core 应用程序之前，让我们先了解一下什么是.NET Core。 .NET Core 是一个开源的跨平台框架，用于构建现代化的云应用程序、微服务和库。它是.NET Framework的跨平台版本，旨在提供更高的性能...
新建.NET Core程序
Hans的博客
08-15 215
.NET Core入门程序
weixin_33872566的博客
04-16 54
    易百教程 https://www.yiibai.com/dotnet_core/dotnet_core_getting_started.html
创建ASP.NET Core程序
Maybe_ch的博客
01-22 379
在控制台下创建 1.这里我们可以先通过cmd查询下可以创建什么类型的项目，dotnet new --help 指令。 2.通过上一步查出的项目类型 我们以 ASP.NET Core Web App 为例，他的短名称为webapp，我们到文件需要创建的位置，使用命令进行创建 dotnet new webapp 3.项目创建成功，我们运行试一下，使用指令dotnet run webapp 我们可...
.netCore+Vue 搭建的简捷开发框架
weixin_30875157的博客
08-22 337
话不多说，上图： 整体项目结构如图所示，我的设计初衷是基于.netCore + DI + Vue 打造一个适合初学者的简捷开发框架。 架构模型采用基于RESTful API风格的前后台分离框架，总体分为五层：表示层（前端UI）、交互层、业务层、数据访问层、数据存储层。 项目中用到的技术如下图所示： 这里可能有些内容是NetCore涉及到的一些语法糖，为了方便学习整理，我都...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值