asp.net – Diffplex入门（asp.net framework）

25-02-04 17

本文的目的是介绍asp.net–Diffplex入门的详细情况，特别关注asp.netframework的相关信息。我们将通过专业的研究、有关数据的分析等多种方式，为您呈现一个全面的了解asp.net

本文的目的是介绍asp.net – Diffplex入门的详细情况，特别关注asp.net framework的相关信息。我们将通过专业的研究、有关数据的分析等多种方式，为您呈现一个全面的了解asp.net – Diffplex入门的机会，同时也不会遗漏关于asp.net core + log4net+exceptionles+DI、ASP.NET Core 入门教程 9、ASP.NET Core 中间件(Middleware)入门、asp.net mvc abp(ASP.NET Boilerplate)集成百度Ueditor富文本编辑器、ASP.NET MVC4 利用uploadify.js多文件上传的知识。

本文目录一览：

asp.net – Diffplex入门（asp.net framework）
asp.net core + log4net+exceptionles+DI
ASP.NET Core 入门教程 9、ASP.NET Core 中间件(Middleware)入门
asp.net mvc abp(ASP.NET Boilerplate)集成百度Ueditor富文本编辑器
ASP.NET MVC4 利用uploadify.js多文件上传

asp.net – Diffplex入门（asp.net framework）

我想强调asp.net中两个文件之间的区别.网络搜索后,我选择了diffplex APi.我是个乞丐.我需要一些如何实施它的指导？我添加了参考图书馆,这就是我能理解的.没有关于Api的任何文档.我之前没有使用过Apis.

解决方法

这是一个简单的例子,来自“文档”(即源代码),应该可以帮助您入门.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using diffplex;
using diffplex.DiffBuilder;
using diffplex.DiffBuilder.Model;
using System.Text;


namespace diffplexTest.Controllers
{
    public class HomeController : Controller
    {
        public ActionResult Index()
        {
            StringBuilder sb = new StringBuilder();

            string oldText =  @"We the people
                of the united states of america
                establish justice
                ensure domestic tranquility
                provide for the common defence
                secure the blessing of liberty
                to ourselves and our posterity";
            string newText = @"We the peaple
                in order to form a more perfect union
                establish justice
                ensure domestic tranquility
                promote the general welfare and
                secure the blessing of liberty
                to ourselves and our posterity
                do ordain and establish this constitution
                for the United States of America";

            var d = new Differ();
            var builder = new InlineDiffBuilder(d);
            var result = builder.BuildDiffModel(oldText,newText);

            foreach (var line in result.Lines)
            {
                if (line.Type == ChangeType.Inserted)
                {
                    sb.Append("+ ");
                }
                else if (line.Type == ChangeType.Deleted)
                {
                    sb.Append("- ");
                }
                else if (line.Type == ChangeType.Modified)
                {
                    sb.Append("* ");
                }
                else if (line.Type == ChangeType.Imaginary)
                {
                    sb.Append("? ");
                }
                else if (line.Type == ChangeType.Unchanged)
                {
                    sb.Append("  ");
                }

                sb.Append(line.Text + "<br/>");
            }

            ViewData["old"] = oldText;
            ViewData["new"] = newText;
            ViewData["result"] = sb.ToString();

            return View();
        }
    }
}

asp.net core + log4net+exceptionles+DI

参考了ABP的代码，我也用依赖注入的原则，设计了日志模块。

与abp不同之处在于：1)DI容器使用的是.net core自带的注入容器，2）集成了excetpionless日志模块，3）不依赖于abp

主要的思想就是，1）定义日志操作接口 2）使用log4net实现日志接口，3）实现注入 4）使用日志

1）定义日志接口，这里直接使用了castle的日志接口

2）使用log4net实现日志接口

    [Serializable]
    public class Log4NetLogger :
            MarshalByRefObject,
            ILogger
    {
        private static readonly Type DeclaringType = typeof(Log4NetLogger);
        
        private log4net.Core.ILogger _logger;
        private Log4NetLoggerFactory _factory;
        public Log4NetLogger()
        {
            _factory = new Log4NetLoggerFactory();
            _logger = _factory.GetLogger("cislog");
        }

        public bool IsDebugEnabled
        {
            get { return _logger.IsEnabledFor(Level.Debug); }
        }

        public bool IsErrorEnabled
        {
            get { return _logger.IsEnabledFor(Level.Error); }
        }

        public bool IsFatalEnabled
        {
            get { return _logger.IsEnabledFor(Level.Fatal); }
        }

        public bool IsInfoEnabled
        {
            get { return _logger.IsEnabledFor(Level.Info); }
        }

        public bool IsWarnEnabled
        {
            get { return _logger.IsEnabledFor(Level.Warn); }
        }



        public override string ToString()
        {
            return _logger.ToString();
        }
        
        public void Debug(string message)
        {
            if (IsDebugEnabled)
            {
                _logger.Log(DeclaringType, Level.Debug, message, null);
            }
        }

        public void Debug(Func<string> messageFactory)
        {
            if (IsDebugEnabled)
            {
                _logger.Log(DeclaringType, Level.Debug, messageFactory.Invoke(), null);
            }
        }

        public void Debug(string message, Exception exception)
        {
            if (IsDebugEnabled)
            {
                _logger.Log(DeclaringType, Level.Debug, message, exception);
            }
        }

        public void DebugFormat(string format, params Object[] args)
        {
            if (IsDebugEnabled)
            {
                _logger.Log(DeclaringType, Level.Debug, new SystemStringFormat(CultureInfo.InvariantCulture, format, args), null);
            }
        }

        public void DebugFormat(Exception exception, string format, params Object[] args)
        {
            if (IsDebugEnabled)
            {
                _logger.Log(DeclaringType, Level.Debug, new SystemStringFormat(CultureInfo.InvariantCulture, format, args), exception);
            }
        }

        public void DebugFormat(IFormatProvider formatProvider, string format, params Object[] args)
        {
            if (IsDebugEnabled)
            {
                _logger.Log(DeclaringType, Level.Debug, new SystemStringFormat(formatProvider, format, args), null);
            }
        }

        public void DebugFormat(Exception exception, IFormatProvider formatProvider, string format, params Object[] args)
        {
            if (IsDebugEnabled)
            {
                _logger.Log(DeclaringType, Level.Debug, new SystemStringFormat(formatProvider, format, args), exception);
            }
        }

        public void Error(string message)
        {
            if (IsErrorEnabled)
            {
                _logger.Log(DeclaringType, Level.Error, message, null);
            }
        }

        public void Error(Func<string> messageFactory)
        {
            if (IsErrorEnabled)
            {
                _logger.Log(DeclaringType, Level.Error, messageFactory.Invoke(), null);
            }
        }

        public void Error(string message, Exception exception)
        {
            if (IsErrorEnabled)
            {
                _logger.Log(DeclaringType, Level.Error, message, exception);
            }
        }

        public void ErrorFormat(string format, params Object[] args)
        {
            if (IsErrorEnabled)
            {
                _logger.Log(DeclaringType, Level.Error, new SystemStringFormat(CultureInfo.InvariantCulture, format, args), null);
            }
        }

        public void ErrorFormat(Exception exception, string format, params Object[] args)
        {
            if (IsErrorEnabled)
            {
                _logger.Log(DeclaringType, Level.Error, new SystemStringFormat(CultureInfo.InvariantCulture, format, args), exception);
            }
        }

        public void ErrorFormat(IFormatProvider formatProvider, string format, params Object[] args)
        {
            if (IsErrorEnabled)
            {
                _logger.Log(DeclaringType, Level.Error, new SystemStringFormat(formatProvider, format, args), null);
            }
        }

        public void ErrorFormat(Exception exception, IFormatProvider formatProvider, string format, params Object[] args)
        {
            if (IsErrorEnabled)
            {
                _logger.Log(DeclaringType, Level.Error, new SystemStringFormat(formatProvider, format, args), exception);
            }
        }

        public void Fatal(string message)
        {
            if (IsFatalEnabled)
            {
                _logger.Log(DeclaringType, Level.Fatal, message, null);
            }
        }

        public void Fatal(Func<string> messageFactory)
        {
            if (IsFatalEnabled)
            {
                _logger.Log(DeclaringType, Level.Fatal, messageFactory.Invoke(), null);
            }
        }

        public void Fatal(string message, Exception exception)
        {
            if (IsFatalEnabled)
            {
                _logger.Log(DeclaringType, Level.Fatal, message, exception);
            }
        }

        public void FatalFormat(string format, params Object[] args)
        {
            if (IsFatalEnabled)
            {
                _logger.Log(DeclaringType, Level.Fatal, new SystemStringFormat(CultureInfo.InvariantCulture, format, args), null);
            }
        }

        public void FatalFormat(Exception exception, string format, params Object[] args)
        {
            if (IsFatalEnabled)
            {
                _logger.Log(DeclaringType, Level.Fatal, new SystemStringFormat(CultureInfo.InvariantCulture, format, args), exception);
            }
        }

        public void FatalFormat(IFormatProvider formatProvider, string format, params Object[] args)
        {
            if (IsFatalEnabled)
            {
                _logger.Log(DeclaringType, Level.Fatal, new SystemStringFormat(formatProvider, format, args), null);
            }
        }

        public void FatalFormat(Exception exception, IFormatProvider formatProvider, string format, params Object[] args)
        {
            if (IsFatalEnabled)
            {
                _logger.Log(DeclaringType, Level.Fatal, new SystemStringFormat(formatProvider, format, args), exception);
            }
        }

        public void Info(string message)
        {
            if (IsInfoEnabled)
            {
                _logger.Log(DeclaringType, Level.Info, message, null);
            }
        }

        public void Info(Func<string> messageFactory)
        {
            if (IsInfoEnabled)
            {
                _logger.Log(DeclaringType, Level.Info, messageFactory.Invoke(), null);
            }
        }

        public void Info(string message, Exception exception)
        {
            if (IsInfoEnabled)
            {
                _logger.Log(DeclaringType, Level.Info, message, exception);
            }
        }

        public void InfoFormat(string format, params Object[] args)
        {
            if (IsInfoEnabled)
            {
                _logger.Log(DeclaringType, Level.Info, new SystemStringFormat(CultureInfo.InvariantCulture, format, args), null);
            }
        }

        public void InfoFormat(Exception exception, string format, params Object[] args)
        {
            if (IsInfoEnabled)
            {
                _logger.Log(DeclaringType, Level.Info, new SystemStringFormat(CultureInfo.InvariantCulture, format, args), exception);
            }
        }

        public void InfoFormat(IFormatProvider formatProvider, string format, params Object[] args)
        {
            if (IsInfoEnabled)
            {
                _logger.Log(DeclaringType, Level.Info, new SystemStringFormat(formatProvider, format, args), null);
            }
        }

        public void InfoFormat(Exception exception, IFormatProvider formatProvider, string format, params Object[] args)
        {
            if (IsInfoEnabled)
            {
                _logger.Log(DeclaringType, Level.Info, new SystemStringFormat(formatProvider, format, args), exception);
            }
        }

        public void Warn(string message)
        {
            if (IsWarnEnabled)
            {
                _logger.Log(DeclaringType, Level.Warn, message, null);
            }
        }

        public void Warn(Func<string> messageFactory)
        {
            if (IsWarnEnabled)
            {
                _logger.Log(DeclaringType, Level.Warn, messageFactory.Invoke(), null);
            }
        }

        public void Warn(string message, Exception exception)
        {
            if (IsWarnEnabled)
            {
                _logger.Log(DeclaringType, Level.Warn, message, exception);
            }
        }

        public void WarnFormat(string format, params Object[] args)
        {
            if (IsWarnEnabled)
            {
                _logger.Log(DeclaringType, Level.Warn, new SystemStringFormat(CultureInfo.InvariantCulture, format, args), null);
            }
        }

        public void WarnFormat(Exception exception, string format, params Object[] args)
        {
            if (IsWarnEnabled)
            {
                _logger.Log(DeclaringType, Level.Warn, new SystemStringFormat(CultureInfo.InvariantCulture, format, args), exception);
            }
        }

        public void WarnFormat(IFormatProvider formatProvider, string format, params Object[] args)
        {
            if (IsWarnEnabled)
            {
                _logger.Log(DeclaringType, Level.Warn, new SystemStringFormat(formatProvider, format, args), null);
            }
        }

        public void WarnFormat(Exception exception, IFormatProvider formatProvider, string format, params Object[] args)
        {
            if (IsWarnEnabled)
            {
                _logger.Log(DeclaringType, Level.Warn, new SystemStringFormat(formatProvider, format, args), exception);
            }
        }

        public ILogger CreateChildLogger(string loggerName)
        {
            throw new NotImplementedException();
        }
    }

public class Log4NetLoggerFactory : AbstractLoggerFactory
    {
        internal const string DefaultConfigFileName = "log4net.config";
        private readonly ILoggerRepository _loggerRepository;

        public Log4NetLoggerFactory()
            : this(DefaultConfigFileName)
        {
        }

        public Log4NetLoggerFactory(string configFileName)
        {
            _loggerRepository = LogManager.CreateRepository(
                typeof(Log4NetLoggerFactory).GetAssembly(),
                typeof(log4net.Repository.Hierarchy.Hierarchy)
            );
            
            XmlConfigurator.Configure(_loggerRepository, new FileInfo("log4net.config"));
        }

        public log4net.Core.ILogger GetLogger(string name)
        {
            return LogManager.GetLogger(_loggerRepository.Name, name).Logger;
        }

        public override ILogger Create(string name)
        {
            if (name == null)
            {
                throw new ArgumentNullException(nameof(name));
            }

            return new Log4NetLogger();
        }

        public override ILogger Create(string name, LoggerLevel level)
        {
            throw new NotSupportedException("Logger levels cannot be set at runtime. Please review your configuration file.");
        }
    }

    public static class TypeExtensions
    {
        public static Assembly GetAssembly(this Type type)
        {
            return type.GetTypeInfo().Assembly;
        }
    }

下面是扩展方法，这里实现注入：

public static class Log4NetLoggerExtensions
    {
        public static IServiceCollection UseExceptionless(this IServiceCollection services)
        {
            services.AddTransient<ILogger, Log4NetLogger>();

            return services;
        }
    }

然后就可以在startup中使用了

public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc();
            services.UseExceptionless();
        }

比如我们在HomeController中使用：

public class HomeController : Controller
    {
        private ILogger _logger;

        public HomeController(ILogger logger)
        {
            _logger = logger;
        }
        public IActionResult Index()
        {
           // throw new Exception("快点来!!!!!!!!!!!!!!!!!!");
            _logger.Info("index view");
            _logger.Debug("出错了！，快点来，！！");
            _logger.Error("Controller Error");
            return View();
        }
}

最后是配置文件：

最重要的是注意exceptionless的配置

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <!-- This section contains the log4net configuration settings -->
  <log4net>
    <appender name="ConsoleAppender" type="log4net.Appender.ConsoleAppender">
      <layout type="log4net.Layout.PatternLayout" value="%date [%thread] %-5level %logger - %message%newline" />
    </appender>
    <appender name="RollingLogFileAppender" type="log4net.Appender.RollingFileAppender">
      <file value="Logs/" />
      <appendToFile value="true" />
      <rollingStyle value="Composite" />
      <staticLogFileName value="false" />
      <datePattern value="yyyy-MM-dd''.log''" />
      <maxSizeRollBackups value="10" />
      <maximumFileSize value="1MB" />
      <layout type="log4net.Layout.PatternLayout">
        <conversionPattern value="%date [%thread] %-5level %logger [%property{NDC}] - %message%newline" />
      </layout>
    </appender>
    <appender name="Exceptionless" type="Exceptionless.Log4net.ExceptionlessAppender,Exceptionless.Log4net">
      <apiKey value="d5qna1t9qTUVwrRzLFz1T3z8wSUeO3xNtxOGMHLf" />
      <serverUrl value="http://10.117.130.150:9001" />
      <layout type="log4net.Layout.PatternLayout">
        <conversionPattern value="%-4timestamp [%thread] %-5level %logger %ndc - %message%newline"/>
      </layout>
    </appender>
    <!-- Setup the root category, add the appenders and set the default level -->
    <root>
      <level value="ALL" />
      <appender-ref ref="ConsoleAppender" />
      <appender-ref ref="RollingLogFileAppender" />
      <appender-ref ref="Exceptionless"/>
    </root>
  </log4net>
</configuration>

还有一点非常重要，记得引用，否则在exceptionless中也看不到日志

效果如图：

最后，提一点：

现在容器技术很火，如果把这套代码放在容器中运行肯定是不行，因为在配置文件中配置了apikey和url, 所以要稍做修改如下：

添加一个类：

    public class ExceptionlessOption
    {
        /// <summary>
        /// 日志应用标识，从Exceptionless面板获取
        /// </summary>
        public string ApiKey { get; set; }

        /// <summary>
        /// 日志应用接口地址
        /// </summary>
        public string Url { get; set; }
    }

            services.AddMvc();
            
            services.UseExceptionless(() =>
            {
                return new ExceptionlessOption {
                    ApiKey = "234na1t9qTU234234234z8wSUeO3x234234HLf",
                    Url = "http://100.11.13.10:9001" };
            });

public Log4NetLoggerFactory(ExceptionlessOption _option, string configFileName)
        {
            _loggerRepository = LogManager.CreateRepository(
                typeof(Log4NetLoggerFactory).GetAssembly(),
                typeof(log4net.Repository.Hierarchy.Hierarchy)
            );
            //读取配置
            XmlConfigurator.Configure(_loggerRepository, new FileInfo("log4net.config"));

            //TODO这里修改
            ExceptionlessClient.Default.Configuration.ApiKey = _option.ApiKey ?? "d5qna1t9qTUVwrRzLFz1T3z8wSUeO3xNtxOGMHLf";
            ExceptionlessClient.Default.Configuration.ServerUrl = _option.Url ??  "http://10.117.130.150:9001";

        }

然后你就可以在startup中通过读取配置文件，实现参数的传入了。

ASP.NET Core 入门教程 9、ASP.NET Core 中间件(Middleware)入门

一、前言

1、本教程主要内容

ASP.NET Core 中间件介绍
通过自定义 ASP.NET Core 中间件实现请求验签

2、本教程环境信息

软件/环境	说明
操作系统	Windows 10
SDK	2.1.401
ASP.NET Core	2.1.3
MySQL	8.0.x
IDE	Visual Studio Code 1.32.3
浏览器	Chrome 70

VS Code插件	版本	说明
C#	1.17.1	提供C#智能感知， .NET Core 调试、编译等
vscdoe-solution-explorer	0.3.1	提供解决方案视图

本篇代码以下代码进行调整：https://github.com/ken-io/asp...

3、前置知识

可能需要的前置知识

C# 委托（Delegate）

http://www.runoob.com/csharp/...

C# 扩展方法

https://docs.microsoft.com/zh...

二、ASP.NET Core 中间件介绍

1、ASP.NET Core 中间件基本说明

当 ASP.NET Core MVC应用从Kestrel接收到请求，会建立HttpContext并交由Application来处理请求。在Application中会有一个处理该请求的通道，这就是ASP.NET Core 管道，通常称之为：请求处理管道

在这个管道中，有一系列有序处理请求的组件，就是中间件（Middleware）。

图中蓝色的部分可以认为是系统内置比较靠前的中间件或者我们自定义的中间件，MVC是一个特殊的中间件且通常放在最后，所以这里单独画出来

对于MVC中间件，如果请求的URL与路由匹配，那么后面的中间件均不会生效。所以MVC通常放在最后。

ASP.NET Core中会内置一些中间件，例如：身份验证、静态文件处理、MVC等。每个中间件在接受到请求后都可以选择是交由下一个中间件处理还是直接返回结果。例如：

身份验证中间件验证未通过会直接引导到登陆页
静态文件中间件判断为静态文件就会直接返回静态文件内容

所以，中间件可以理解为请求处理管道中的请求处理器。我们也可以通过自定义中间件注册到管道中来干预请求。

2、ASP.NET Core 中间件基础使用

在程序中，中间件是基于委托来构建的。在应用启动时通过IApplicationBuilder注册到通道中。

具体见启动类Startup.cs：

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }

    app.UseMvc(routes =>
    {
        //配置默认路由
        routes.MapRoute(
            name: "Default",
            template: "{controller}/{action}",
            defaults: new { controller = "Home", action = "Index" }
        );
    });
}

UseDeveloperExceptionPage、UseMvc都是接口IApplicationBuilder的扩展方法。

三、使用 ASP.NET Core 中间件实现请求验签

如果你开发的API是为手机App服务的，那么你的API是一定要暴露给公网的，如果有人拿到API地址进行非法请求，获取用户信息或者是篡改数据，用户隐私、数据就会受到损害。这是很不安全的，我们可以让客户端请求的时候必须携带签名，在服务器端鉴权(验证签名)通过了再放行，这样就安全很多了。

1、创建验签中间件

在项目Ken.Tutorial.Web创建目录Middlewares，然后创建类：TokenCheckMiddleware.cs

using System;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;

namespace Ken.Tutorial.Web.Middlewares
{
    public class TokenCheckMiddleware
    {
        private readonly RequestDelegate _next;
        public TokenCheckMiddleware(RequestDelegate requestDelegate)
        {
            this._next = requestDelegate;
        }

        public Task Invoke(HttpContext context)
        {
            //先从Url取token，如果取不到就从Form表单中取token
            var token = context.Request.Query["token"].ToString() ?? context.Request.Form["token"].ToString();
            if (string.IsNullOrWhiteSpace(token))
            {
                //如果没有获取到token信息，那么久返回token missing
                return context.Response.WriteAsync("token missing");
            }
            //获取前1分钟和当前的分钟
            var minute0 = DateTime.Now.AddMinutes(-1).ToString("yyyy-MM-dd HH:mm");
            var minute = DateTime.Now.ToString("yyyy-MM-dd HH:mm");
            //当token和前一分钟或当前分钟任一时间字符串的MD5哈希一致，就认为是合法请求
            if (token == MD5Hash(minute) || token == MD5Hash(minute0))
            {
                return _next.Invoke(context);
            }
            //如果token未验证通过返回token error
            return context.Response.WriteAsync("token error");
        }

        public string MD5Hash(string value)
        {
            using (var md5 = MD5.Create())
            {
                var result = md5.ComputeHash(Encoding.ASCII.GetBytes(value));
                var strResult = BitConverter.ToString(result);
                return strResult.Replace("-", "");
            }
        }
    }
}

由于是侧重自定义中间件，所有验签的逻辑就写的非常简单，如果实际项目使用，可以按照自己需求调整

2、创建扩展方法

在Middlewares目录下新建类：MiddlewareExtension.cs

using Microsoft.AspNetCore.Builder;

namespace Ken.Tutorial.Web.Middlewares
{
    public static class MiddlewareExtension
    {
        public static IApplicationBuilder UseTokenCheck(this IApplicationBuilder builder)
        {
            return builder.UseMiddleware<TokenCheckMiddleware>();
        }
    }
}

这里我们通过扩展方法，将TokenCheckMiddleware挂在接口IApplicationBuilder上

3、中间件注册/引用

在启动类Startup.cs的Configure方法中注册/引用中间件

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    
    //省略部分代码

    app.UseTokenCheck();
    
    app.UseMvc(routes =>
    {
        //省略路由配置代码
    });
}

如果你觉得扩展方法有点多余，也可以直接使用UseMiddleware方法注册

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
    
    //省略部分代码

    app.UseMiddleware<TokenCheckMiddleware>();
    
    app.UseMvc(routes =>
    {
        //省略路由配置代码
    });
}

这里要注意的是，如果你是一个MVC应用，请一定要把MVC这个中间件作为最后一个注册。因为中间件是按照注册顺序被调用的。如果放在MVC之后，请求的URL也有对应路由适配，那么整个请求已经被MVC接管。后面的中间件就不会被调用了。

4、验签中间件测试

启动应用，然后验证不同情况下的访问结果

URL	Response
localhost:5001	token missing
localhost:5001?token=test	token error
localhost:5001?token=3D76FEA1D0ADD0C7639B73023436C6EA	Hello World ！ -ken.io

为了方便测试，MD5哈希的值我们可以在线生成：ttp://tool.chinaz.com/tools/md5.aspx

把当前分钟，例如：2019-03-27 23:23 通过MD5在线生成那就是3D76FEA1D0ADD0C7639B73023436C6EA

四、备注

本文代码示例

https://github.com/ken-io/asp...

本文参考

https://docs.microsoft.com/zh...

延伸阅读

https://www.cnblogs.com/artec...

本文首发于我的独立博客：https://ken.io/note/asp.net-c...

asp.net mvc abp(ASP.NET Boilerplate)集成百度Ueditor富文本编辑器

如果不修改,不管imageUrlPrefix修改成什么,图片只能保存在ueditor\net\目录下。

修改ueditor\net\App_Code\UploadHandler.cs。

//var localPath = Server.MapPath(savePath);
改为var localPath = Server.MapPath("~/" + Config.GetString("imageUrlPrefix") + savePath);
因为前台js 返回图片路径时加了而后台没加

修改ueditor\net\App_Code\ListFileHandler.cs
github上有人提交了修复服务器返回图片列表不能倒序Bug但是没有在新版本中

var localPath = Server.MapPath(PathToList);
改为var localPath = Server.MapPath(Config.GetString("imageManagerUrlPrefix") + PathToList);

配置ueditor\net\config.json。

"imageUrlPrefix": "/upload/", /* 图片访问路径前缀 */
"imagePathFormat": "upload/image/{yyyy}{mm}{dd}/{time}{rand:6}", /* 上传保存路径,可以自定义保存路径和文件名格式 *

在视图面引入js并初始化。

<!-- 配置文件 -->
<script type="text/javascript" src="~/content/ueditor/ueditor.config.js"></script>
<!-- 编辑器源码文件 -->
<script type="text/javascript" src="~/content/ueditor/ueditor.all.js"></script>
<h2>Ueditor</h2>
 
<script id="container" name="content" type="text/plain">
    Ueditor
</script>
 
<script type="text/javascript">
    var ue = UE.getEditor(''container'');
</script>

如果用的模态框防止窗口遮挡，可在ueditor/ueditor.config.js 设置zIndex : XXXX。

模态窗内第二次加载Ueditor不显示。
在 UE.getEditor后面再追加一个方法render，或者先调用UE.delEditor删除后再执行。

UE.getEditor(''_editor'').render(''_editor'')
// 或者
UE.delEditor(''选择器'');
UE.getEditor(''选择器''); 
// 关闭Dialog前移除编辑器
    UE.delEditor(''选择器'');

单独使用上传组件

https://www.cnblogs.com/sadkilo/p/5951336.html

ASP.NET MVC4 利用uploadify.js多文件上传

页面代码：

1.引入js和css文件

　　<link href="~/Scripts/uploadify/uploadify.css" rel="external nofollow" rel="stylesheet" />
  <style type="text/css">
  #upDiv {
   width: 550px;
   height: 400px;
   border: 2px solid red;
   margin-top: 30px;
   margin-left: 50px;
   float: left;
  }
  div form {
   text-align: center;
   vertical-align: middle;
  }
  h2, h3 {
   text-align: center;
   color: #00B2EE;
  }
  #upList {
   width: 900px;
   height: 400px;
   float: left;
   margin-top: 30px;
   margin-left: 50px;
   overflow-y: scroll;
   border: 2px solid red;
  }
  #filelist {
   width: 45%;
   height: 400px;
   float: left;
  }
  #lineDiv {
   width: 50px;
   height: 400px;
   float: left;
  }
  #imglist {
   width: 45%;
   height: 400px;
   float: left;
  }
  #form1 {
   margin-top: 25px;
  }
  img {
   width: 25px;
   height: 25px;
  }
  .btn {
   width: 150px;
   height: 40px;
   text-align: center;
   background-color: #b58061;
   color: white;
  }
  p {
   cursor: pointer;
  }
 </style>
 <script src="~/Scripts/jquery-1.8.2.min.js"></script>
 <script src="~/Scripts/uploadify/jquery.uploadify-3.1.js"></script>
 <script type="text/javascript">
  $(function () {
   $("#myfile").uploadify({
    "auto": false,
    "swf": "../Scripts/uploadify/uploadify.swf",
    "uploader": "../Home/UploadFiles",
    "removeCompleted": false,
    "onUploadSuccess": function (file, data, response) {
    },
    "onQueueComplete": function () {
     window.location.reload();
    }
   });
   $.ajax({
    url: "/home/loadFileInfo",
    datatype: ''html'',
    success: function (result) {
     $(''#filelist'').append(result);
    }
   });
   $.ajax({
    url: "/home/loadImgInfo",
    datatype: ''html'',
    success: function (result) {
     $(''#imglist'').append(result);
    }
   });
  });
  //在线打开文件
  function openFile(doc) {
   try {
    var fileName = $(doc).text();
    var url = window.location.protocol + "//" + window.location.host + "/UploadFile/File/"
    url = url + fileName;
    window.open(url);
   } catch (EventException) {
    alert("此文件无法打开！");
   }
  }
  //在线打开图片
  function openImg(doc) {
   var fileName = $(doc).text();
   var url = window.location.protocol + "//" + window.location.host + "/UploadImg/Img/"
   url = url + fileName;
   window.open(url);
  }
 </script>

2.body内代码

　　<body>
 <h2>ASP .NET MVC4 多文件文件上传实例</h2>
 <form id="form1">
  <div>
   <input type="file" id="myfile" name="myfile" />
  </div>
  <div>
   <ahref="javascript:$(''#myfile'').uploadify(''upload'');" rel="external nofollow" >上传第一个</a>
   <ahref="javascript:$(''#myfile'').uploadify(''upload'',''*'');" rel="external nofollow" >上传队列</a>
   <ahref="javascript:$(''#myfile'').uploadify(''cancel'');" rel="external nofollow" >取消第一个</a>
   <ahref="javascript:$(''#myfile'').uploadify(''cancel'', ''*'');" rel="external nofollow" >取消队列</a>
  </div>
 </form>
 <div id="upList">
  <div id="filelist">
   <h3>文件列表</h3>
  </div>
  <div id="lineDiv"></div>

  <div id="imglist">
   <h3>图片列表</h3>
  </div>
 </div>
</body>

后台代码：

public ActionResult loadFileInfo()
  {
   StringBuilder sb = new StringBuilder();
   DirectoryInfo theFolder = new DirectoryInfo(Server.MapPath("~/UploadFile/"));
   DirectoryInfo[] dirInfo = theFolder.GetDirectories();
   //遍历文件夹
   foreach (DirectoryInfo NextFolder in dirInfo)
   {
    FileInfo[] fileInfo = NextFolder.GetFiles();
    //遍历文件
    foreach (FileInfo NextFile in fileInfo)
    {
     string exStr = NextFile.Extension;
     string str = NextFile.Name;
     if (exStr == ".zip" || exStr == ".7z" || exStr == ".rar" || exStr.ToLower() == ".rars")
     {
      sb.Append("<p onclick=''openFile(this)''><img src=''../../Images/zip.png'' width=''25'' height=''25'' />" + str + "</p>");
     }
     else if (exStr == ".doc" || exStr == ".docx")
     {
      sb.Append("<p onclick=''openFile(this)''><img src=''../../Images/words.png'' width=''25'' height=''25'' />" + str + "</p>");
     }
     else if (exStr == ".ppt" || exStr == ".pptx")
     {
      sb.Append("<p onclick=''openFile(this)''><img src=''../../Images/ppt.jpg'' width=''25'' height=''25'' />" + str + "</p>");
     }
     else if (exStr == ".xlsx" || exStr == ".xls" || exStr == ".XLS")
     {
      sb.Append("<p onclick=''openFile(this)''><img src=''../../Images/excel.png'' width=''25'' height=''25'' />" + str + "</p>");
     }
     else if (exStr == ".pdf")
     {
      sb.Append("<p onclick=''openFile(this)''><img src=''../../Images/pdf.jpg'' width=''25'' height=''25'' />" + str + "</p>");
     }
     else if (exStr == ".js" || exStr == ".JS")
     {
      sb.Append("<p onclick=''openFile(this)''><img src=''../../Images/js.png'' width=''25'' height=''25'' />" + str + "</p>");
     }
     else if (exStr == ".html" || exStr == ".HTML")
     {
      sb.Append("<p onclick=''openFile(this)''><img src=''../../Images/html.png'' width=''25'' height=''25'' />" + str + "</p>");
     }
     else if (exStr == ".txt" || exStr == ".TXT")
     {
      sb.Append("<p onclick=''openFile(this)''><img src=''../../Images/txt.png'' width=''25'' height=''25'' />" + str + "</p>");
     }
     else if (exStr == ".mp3" || exStr == ".wmv" || exStr == ".aac")
     {
      sb.Append("<p onclick=''openFile(this)''><img src=''../../Images/mp3.png'' width=''25'' height=''25'' />" + str + "</p>");
     }
     else if (exStr == ".avi" || exStr == ".mov" || exStr == ".mp4" || exStr == ".ram" || exStr == ".flv")
     {
      sb.Append("<p onclick=''openFile(this)''><img src=''../../Images/video.png'' width=''25'' height=''25'' />" + str + "</p>");
     }
     else {
      sb.Append("<p onclick=''openFile(this)''><img src=''../../Images/file.jpg'' width=''25'' height=''25'' />" + str + "</p>");
     }
    }
   }
   return Content(sb.ToString());
  }
  public ActionResult loadImgInfo()
  {
   StringBuilder sb = new StringBuilder();
   DirectoryInfo theFolder = new DirectoryInfo(Server.MapPath("~/UploadImg/"));
   DirectoryInfo[] dirInfo = theFolder.GetDirectories();
   //遍历文件夹
   foreach (DirectoryInfo NextFolder in dirInfo)
   {
    FileInfo[] fileInfo = NextFolder.GetFiles();
    //遍历文件
    foreach (FileInfo NextFile in fileInfo)
    {
     string str = NextFile.Name;
     sb.Append("<p onclick=''openImg(this)''><img src=''../../Images/img.png'' width=''25'' height=''25'' />" + str + "</p>");
    }
   }
   return Content(sb.ToString());
  }
  public ActionResult UploadFile()
  {
   string filepath = "";
   bool fileOK = false;
   //判断是否已经选择上传文件
   HttpPostedFileBase file = Request.Files["myfile"];
   if (file != null && file.ContentLength > 0)
   {
    String fileExtension = System.IO.Path.GetExtension(file.FileName).ToLower();
    //判断是否为图片类型
    String[] allowedExtensions = { ".gif", ".png", ".bmp", ".jpg" };
    for (int i = 0; i < allowedExtensions.Length; i++)
    {
     if (fileExtension == allowedExtensions[i])
     {
      fileOK = true;
     }
    }
    if (fileOK)
    {
     //设置上传目录
     string path = Server.MapPath("~/UploadImg/Img/");
     if (!Directory.Exists(path))
      Directory.CreateDirectory(path);
     string filenNamer = file.FileName;
     //文件路径
     filepath = path + filenNamer;
     file.SaveAs(filepath);
     return RedirectToAction("Upload", "Home");
    }
    else
    {
     //设置上传目录
     string path = Server.MapPath("~/UploadFile/File/");
     if (!Directory.Exists(path))
      Directory.CreateDirectory(path);
     //不为图片类型的文件存入到File目录中
     string filenNamer = file.FileName;
     //文件路径
     filepath = path + filenNamer;
     file.SaveAs(filepath);
     return RedirectToAction("Upload", "Home"); 
    }
   }
   else
   {
    var script = String.Format("<script>alert(''请选择文件后再上传！'');location.href=''{0}''</script>", Url.Action("Upload"));
    return Content(script, "text/html");
   }
  }

以上就是本文的全部内容，希望本文的内容对大家的学习或者工作能带来一定的帮助，同时也希望多多支持！

您可能感兴趣的文章:

ASP.NET MVC HttpPostedFileBase文件上传的实例代码
asp.net core mvc实现文件上传实例
asp.net mvc 实现文件上传带进度条的思路与方法
解决ASP.NET Core Mvc文件上传限制问题实例
ASP.NET MVC文件上传教程(二）
ASP.NET MVC 文件上传教程(一）
ASP.NET MVC5实现文件上传与地址变化处理（5）
ASP.NET MVC处理文件上传的小例子
用Fine Uploader+ASP.NET MVC实现ajax文件上传[代码示例]
ASP.NET MVC实现批量文件上传

今天关于asp.net – Diffplex入门和asp.net framework的分享就到这里，希望大家有所收获，若想了解更多关于asp.net core + log4net+exceptionles+DI、ASP.NET Core 入门教程 9、ASP.NET Core 中间件(Middleware)入门、asp.net mvc abp(ASP.NET Boilerplate)集成百度Ueditor富文本编辑器、ASP.NET MVC4 利用uploadify.js多文件上传等相关知识，可以在本站进行查询。

本文标签：