众所周知
在H5开发中
video标签 在 安卓手机上会出现

1. 层级过高
2. 浮动
3. 无法自动播放

的问题,无论是打开 优酷 , bilbili 都没有解决这个问题

但是今天发现一个 页面 居然所有浏览器全不兼容,非常的完美
不知道怎么实现的,看了一下也没看出所以然
广大的开发者 一起来 研究下吧

这是完美解决了 h5 video 同层问题的 链接地址:

inline video

using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System.Web;

using Westwind.Utilities;

namespace Infrastructure.SelfHost
{
    /// <summary>
    /// A simple self-contained static file Web Server that can be
    /// launched in a folder with a port and serve static files
    /// from that folder. Very basic features but easy to integrate.
    /// </summary>
    /// <example>
    /// StartHttpServerOnThread(@"c:\temp\http",8080);
    /// ...
    /// StopHttpServerOnThread();
    /// </example>
    /// <remarks>
    /// Based mostly on:
    /// https://gist.github.com/aksakalli/9191056
    /// 
    /// Additions to make it easier to host server inside of an
    /// external, non-.NET application.
    ///</remarks>

    public class SimpleHttpServer
    {
        public string[] DefaultDocuments =
        {
            "index.html",
            "index.htm",
            "default.html",
            "default.htm"
        };

        public static SimpleHttpServer Current;

        /// <summary>
        /// This method can be used externally to start a singleton instance of 
        /// the Web Server and keep it running without tracking a reference.                
        /// 
        /// If a server instance is already running it's shut down.
        /// </summary>
        /// <param name="path"></param>
        /// <param name="port"></param>        
        /// <param name="requestHandler">
        /// Optional parameter of an object that has a Process method that gets passed a context 
        /// and returns true if the request is handled or false if default processing should occur
        /// </param>
        public static void StartHttpServerOnThread(string path, int port = 8080, object requestHandler = null)
        {
            var t = new Thread(StartHttpServerThread);
            t.SetApartmentState(ApartmentState.STA);
            t.Start(new ServerStartParameters { Path = path, Port = port, RequestHandler = requestHandler });
        }

        /// <summary>
        /// Call this method to stop the Singleton instance of the server.
        /// </summary>
        public static void StopHttpServerOnThread()
        {
            Current.Stop();
            Current = null;
        }


        /// <summary>
        /// Internal method that instantiates the server instance
        /// </summary>
        /// <param name="parms"></param>
        private static void StartHttpServerThread(object parms)
        {

            if (Current != null)
                StopHttpServerOnThread();

            var httpParms = parms as ServerStartParameters;
            Current = new SimpleHttpServer(httpParms.Path, httpParms.Port);
            Current.RequestHandler = httpParms.RequestHandler;
        }


        /// <summary>
        /// Mime Type conversion table
        /// </summary>
        private static IDictionary<string, string> _mimeTypeMappings =
            new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase)
            {
                #region extension to MIME type list
                {".asf", "video/x-ms-asf"},
                {".asx", "video/x-ms-asf"},
                {".avi", "video/x-msvideo"},
                {".bin", "application/octet-stream"},
                {".cco", "application/x-cocoa"},
                {".crt", "application/x-x509-ca-cert"},
                {".css", "text/css"},
                {".deb", "application/octet-stream"},
                {".der", "application/x-x509-ca-cert"},
                {".dll", "application/octet-stream"},
                {".dmg", "application/octet-stream"},
                {".ear", "application/java-archive"},
                {".eot", "application/octet-stream"},
                {".exe", "application/octet-stream"},
                {".flv", "video/x-flv"},
                {".gif", "image/gif"},
                {".hqx", "application/mac-binhex40"},
                {".htc", "text/x-component"},
                {".htm", "text/html"},
                {".html", "text/html"},
                {".ico", "image/x-icon"},
                {".img", "application/octet-stream"},
                {".iso", "application/octet-stream"},
                {".jar", "application/java-archive"},
                {".jardiff", "application/x-java-archive-diff"},
                {".jng", "image/x-jng"},
                {".jnlp", "application/x-java-jnlp-file"},
                {".jpeg", "image/jpeg"},
                {".jpg", "image/jpeg"},
                {".js", "application/x-javascript"},
                {".mml", "text/mathml"},
                {".mng", "video/x-mng"},
                {".mov", "video/quicktime"},
                {".mp3", "audio/mpeg"},
                {".mpeg", "video/mpeg"},
                {".mpg", "video/mpeg"},
                {".msi", "application/octet-stream"},
                {".msm", "application/octet-stream"},
                {".msp", "application/octet-stream"},
                {".pdb", "application/x-pilot"},
                {".pdf", "application/pdf"},
                {".pem", "application/x-x509-ca-cert"},
                {".pl", "application/x-perl"},
                {".pm", "application/x-perl"},
                {".png", "image/png"},
                {".prc", "application/x-pilot"},
                {".ra", "audio/x-realaudio"},
                {".rar", "application/x-rar-compressed"},
                {".rpm", "application/x-redhat-package-manager"},
                {".rss", "text/xml"},
                {".run", "application/x-makeself"},
                {".sea", "application/x-sea"},
                {".shtml", "text/html"},
                {".sit", "application/x-stuffit"},
                {".swf", "application/x-shockwave-flash"},
                {".tcl", "application/x-tcl"},
                {".tk", "application/x-tcl"},
                {".txt", "text/plain"},
                {".war", "application/java-archive"},
                {".wbmp", "image/vnd.wap.wbmp"},
                {".wmv", "video/x-ms-wmv"},
                {".xml", "text/xml"},
                {".xpi", "application/x-xpinstall"},
                {".zip", "application/zip"},

                #endregion
            };

        private Thread _serverThread;
        private string _rootDirectory;
        private HttpListener _listener;
        private int _port;

        public int Port
        {
            get { return _port; }
        }


        /// <summary>
        /// Instance of an object whose Process() method is called on each request.
        /// Return true if the reuqest is handled, fase if it's not.
        /// </summary>
        public object RequestHandler { get; set; }

        /// <summary>
        /// Construct server with given port.
        /// </summary>
        /// <param name="path">Directory path to serve.</param>
        /// <param name="port">Port of the server.</param>
        public SimpleHttpServer(string path, int port = 8080)
        {
            Initialize(path, port);
        }

        /// <summary>
        /// Construct server with suitable port.
        /// </summary>
        /// <param name="path">Directory path to serve.</param>
        public SimpleHttpServer(string path)
        {
            //get an empty port
            TcpListener listener = new TcpListener(IPAddress.Loopback, 0);
            listener.Start();
            int port = ((IPEndPoint)listener.LocalEndpoint).Port;
            listener.Stop();

            Initialize(path, port);
        }

        /// <summary>
        /// Stop server and dispose all functions.
        /// </summary>
        public void Stop()
        {
            _serverThread.Abort();
            _listener.Stop();
        }

        /// <summary>
        /// Internal Handler
        /// </summary>
        private void Listen()
        {
            _listener = new HttpListener();
            _listener.Prefixes.Add("http://*:" + _port.ToString() + "/");
            _listener.Start();

            while (true)
            {
                try
                {
                    HttpListenerContext context = _listener.GetContext();
                    Process(context);
                }
                catch (Exception ex)
                {

                }
            }
        }


        /// <summary>
        /// Process an individual request. Handles only static file based requests
        /// </summary>
        /// <param name="context"></param>
        private void Process(HttpListenerContext context)
        {
            string filename = HttpUtility.UrlDecode(context.Request.Url.AbsolutePath);
            Console.WriteLine(filename);

            if (RequestHandler != null)
            {
                if ((bool)ReflectionUtils.CallMethodCom(RequestHandler, "Process", context))
                    return;
            }

            filename = filename.Substring(1);

            if (string.IsNullOrEmpty(filename))
            {
                foreach (string indexFile in DefaultDocuments)
                {
                    if (File.Exists(Path.Combine(_rootDirectory, indexFile)))
                    {
                        filename = indexFile;
                        break;
                    }
                }
            }


            filename = Path.Combine(_rootDirectory, filename);

            if (File.Exists(filename))
            {
                try
                {
                    Stream input = new FileStream(filename, FileMode.Open);

                    //Adding permanent http response headers
                    string mime;
                    context.Response.ContentType = _mimeTypeMappings.TryGetValue(Path.GetExtension(filename), out mime)
                        ? mime
                        : "application/octet-stream";
                    context.Response.ContentLength64 = input.Length;
                    context.Response.AddHeader("Date", DateTime.Now.ToString("r"));
                    context.Response.AddHeader("Last-Modified", File.GetLastWriteTime(filename).ToString("r"));

                    byte[] buffer = new byte[1024 * 32];
                    int nbytes;
                    while ((nbytes = input.Read(buffer, 0, buffer.Length)) > 0)
                        context.Response.OutputStream.Write(buffer, 0, nbytes);
                    input.Close();
                    context.Response.OutputStream.Flush();

                    context.Response.StatusCode = (int)HttpStatusCode.OK;
                }
                catch (Exception ex)
                {
                    context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
                }

            }
            else
            {
                context.Response.StatusCode = (int)HttpStatusCode.NotFound;
            }

            context.Response.OutputStream.Close();
        }

        private void Initialize(string path, int port)
        {
            _rootDirectory = path;
            _port = port;
            _serverThread = new Thread(Listen);
            _serverThread.Start();
        }


    }

    /// <summary>
    /// Parameters thatr are passed to the thread method
    /// </summary>
    public class ServerStartParameters
    {
        public string Path { get; set; }
        public int Port { get; set; }

        /// <summary>
        ///  Any object that implements a Process method
        ///  method should return true (request is handled) 
        /// or false (to fall through and handle as files)
        /// </summary>
        public object RequestHandler { get; set; }
    }

}

如上图 , 在windows电脑上有下面文件夹 , 内容均为图片

使用C#如何实现在当前文件夹启动一个简单的http服务,以实现,在局域网下手机app中直接读取图片,如:
<img data-original='http://192.168.1.14:30001/Slideimages/幻灯片1.PNG'>

rows, err := db.Query("SELECT * FROM user")
checkErr(err)
 
for rows.Next() {
    var userId int
    var userName string
    var userAge int
    var userSex int
    rows.Columns()
    err = rows.Scan(&userId, &userName, &userAge, &userSex)
    checkErr(err)
    fmt.Println(userId)
    fmt.Println(userName)
    fmt.Println(userAge)
    fmt.Println(userSex)
}

如果这时候操作数据在userName前面新增一个字段
这段代码岂不是就废了
在项目中会这样写吗？

rows, err := db.Query("SELECT * FROM user")
checkErr(err)
 
for rows.Next() {
    var userId int
    var userName string
    var userAge int
    var userSex int
    rows.Columns()
    err = rows.Scan(&userId, &userName, &userAge, &userSex)
    checkErr(err)
    fmt.Println(userId)
    fmt.Println(userName)
    fmt.Println(userAge)
    fmt.Println(userSex)
}

如果这时候操作数据在userName前面新增一个字段
这段代码岂不是就废了
在项目中会这样写吗？

请问如何比较两个时间的大小

比如 2016-05-04 和 2016-05-16
一 、 moment(' 2016-05-04')>moment('2016-05-16')返回false

moment('2016-05-04').isBefore('2016-05-16')

就不能去看看API么？？？

这是我封装的在PPT中插入元素的cs代码,没做整理,供参考:

using System;
using System.IO;

using Infrastructure;
using Infrastructure.FileHelper;

using Microsoft.Office.Core;
using Microsoft.Office.Interop.PowerPoint;

using VarEnum;

using Shape = Microsoft.Office.Interop.PowerPoint.Shape;
using Word = Microsoft.Office.Interop.Word;

namespace PowerPointAddIn.Vstor
{
    /// <summary>
    /// 幻灯片扩展_插入元素
    /// </summary>
    public static class InsertElement
    {
        static Word.Application wordApp;
        static Word.Document wordDoc;
        static Word.ContentControl contentControl;
        //public enum AddPictureType
        //{
        //    常规, 有题可推, 未初始化
        //}

        ///// <summary>
        ///// 添加图片
        ///// </summary>
        ///// <param name="slide"></param>
        //public static void AddPicture(Slide slide, string filePath)
        //{

        //}

        /// <summary>
        /// 添加媒体
        /// </summary>
        public static void AddMedia(Slide slide, string filePath)
        {
            if (!File.Exists(filePath))
                return;

            try
            {
                Shape pic = slide.Shapes.AddMediaObject2(filePath, MsoTriState.msoFalse, MsoTriState.msoTrue);
            }
            catch
            {
                string ext = Path.GetExtension(filePath).Replace(".", string.Empty);
                throw new Exception("暂不支持此[" + ext + "]格式添加到PPT");
            }
        }

        /// <summary>
        /// 添加http
        /// </summary>
        public static void AddHttp(Slide slide, string filePath)
        {
            if (!File.Exists(filePath))
                return;

            Shape pic = slide.Shapes.AddOLEObject(FileName: filePath);
        }

        #region 富文本
        /// <summary>
        /// 插入富文本 (使用word剪切板实现 有很大风险  暂时弃用)
        /// </summary>
        public static async void InsertRich(this Slide slide, string html)
        {
            //插入富文本控件
            try
            {
                wordApp = wordApp ?? new Word.Application();
                wordDoc = wordDoc ?? wordApp.Documents.Add();
                contentControl = contentControl ?? wordDoc.ContentControls.Add(Word.WdContentControlType.wdContentControlRichText);

                string path = await HtmlHelper.Save2TempFile(html);

                contentControl.Range.InsertFile(path);
                contentControl.Range.Copy();

                ThisAddIn.application.ActiveWindow.View.PasteSpecial();
            }
            finally
            {
                contentControl.Range.Delete();
            }
        }
        #endregion

        #region 图片
        /// <summary>
        /// 插入图片
        /// </summary>
        /// <param name="slide"></param>
        /// <param name="filePath"></param>
        /// <param name="idName">这张图片的唯一名字</param>
        public static void AddPicture(this Slide slide, string filePath, string name = "", int height = -1, int width = -1, int top = 0, int left = 0)
        {
            //没有设置宽高使用图片原始大小插入
            Shape pic;
            if (height > 0 || width > 0)
                pic = slide.Shapes.AddPicture(filePath, MsoTriState.msoFalse, MsoTriState.msoTrue, left, top, width, height);
            else
                pic = slide.Shapes.AddPicture(filePath, MsoTriState.msoFalse, MsoTriState.msoTrue, left, top);

            pic.Name = name;
            pic.Left = left;
            pic.Top = top;
            pic.Width = width;
            pic.Height = height;
        }

        /// <summary>
        /// 移除形状 包含(图片)
        /// </summary>
        /// <param name="slide"></param>
        /// <param name="name"></param>
        public static void DeletePicture(this Slide slide, string name)
        {
            try
            {
                var Shape = slide.Shapes.Range(name);
                Shape.Delete();
            }
            catch { }
        }
        #endregion
    }
}

已解决,没有整理,直接贴上实现的代码:

using Application.BaseData;
using Application.Config;

using Common.Logging;

using Infrastructure;

using Microsoft.Office.Core;

using stdole;

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;

using Util.Controls.WinForm;

using Utilities.Converter;

using VarEnum;

using WpfUi.View.MaterialSet;
using WpfUi.ViewModel.MaterialSet;
using WpfUi.ViewModel.MaterialSet.Model;

namespace PowerPointAddIn.Vstor
{
    /// <summary>
    /// 操作扩展
    /// </summary>
    public class ContextMenuEx
    {
        private static readonly ILog _log = LogManager.GetLogger("ContextMenuEx");

        readonly CommandBars cmdBars;
        readonly CommandBar cmdThumbnailsBar;

        CommandBarButton insertResourceBtn = null;

        public ContextMenuEx()
        {
            try
            {
                cmdBars = ThisAddIn.application.CommandBars;
                cmdThumbnailsBar = cmdBars[ThisAddIn.officeType == OfficeType.Office ? "Thumbnails" : "Slide Miniature Popup Menu"];
                cmdThumbnailsBar.Reset();

                SetInsertResource();
            }
            catch (Exception err)
            {
                _log.Error(err);
            }
        }
        /// <summary>
        ///  设置素材插入
        /// </summary>
        public void SetInsertResource()
        {
            CommandBarControls commandBarControls = cmdThumbnailsBar.Controls;

            foreach (CommandBarControl cmdBarCtrl in commandBarControls)
                if (cmdBarCtrl.Tag == "InsertResource")
                    cmdBarCtrl?.Delete();

            string icon_stem = Path.Combine(AppDomain.CurrentDomain.SetupInformation.ApplicationBase, @"Resources\icon-sucai32.png");
            IPictureDisp pictureInsertResource = AxHostConverter.GetIPictureDisp(icon_stem);

            Globals.ThisAddIn.Dispatcher.Invoke(() =>
            {
                insertResourceBtn = (CommandBarButton)commandBarControls.Add(MsoControlType.msoControlButton);
                insertResourceBtn.BeginGroup = true;
                insertResourceBtn.Tag = "InsertResource";
                insertResourceBtn.Caption = "从云端插入";
                insertResourceBtn.Picture = pictureInsertResource;
                insertResourceBtn.Click += InsertResourceBtn_Click;
                insertResourceBtn.Visible = true;
            });
        }

        /// <summary>
        /// 切换素材插入
        /// </summary>
        /// <param name="state">切换状态</param>
        public void SwitchInsertResource(bool state)
        {
            if (insertResourceBtn == null) return;
            try
            {
                insertResourceBtn.Visible = state;
            }
            catch (Exception err)
            {
                _log.Error(err);
            }
        }

        private void InsertResourceBtn_Click(CommandBarButton Ctrl, ref bool CancelDefault)
        {
            try
            {
                if (string.IsNullOrEmpty(Config.UserInfo?.UserId))
                    throw new Exception("请先登录")
                    {
                        Source = Envirment.ErrUiSource
                    };

                var viewMode = new MaterialSetViewModel(new BaseDataApplication(), Config.UserInfo.UserId, Config.SchoolCode);
                viewMode.InsertElement2Slide += InsertElement2Slide;
                viewMode.SetWindow(new MaterialSetView());
                ThisAddIn.Show(viewMode.Window);
            }
            catch (Exception err)
            {
                Ex.GlobalUnCatchError(err);
            }
        }


        void InsertElement2Slide(List<Material> ChooseMaterials)
        {
            if (ChooseMaterials?.Count < 1)
                return;

            PptHelp pptHelp = new PptHelp();
            try
            {
                ChooseMaterials.ForEach(p =>
                {
                    if (!InternetHelp.IsFileOrExt(p.MaterialUrl, out string ext))
                    {
                        ThisAddIn.ShowDialog(new Resource.Control.AlertWin.alertWindow(new
                        {
                            message = "不是有效的文件[" + p.Name + "]，导入失败",
                        }));
                        return;
                    }

                    if (p.MaterialType == MaterialType.图片)
                    {
                        pptHelp.AddImg(p.MaterialUrl);
                    }
                    else if (p.MaterialType == MaterialType.音频 || p.MaterialType == MaterialType.视频)
                    {
                        if (string.IsNullOrEmpty(ext))
                        {
                            ThisAddIn.ShowDialog(new Resource.Control.AlertWin.alertWindow(new
                            {
                                message = "不能识别此文件[" + p.Name + "]的格式，导入失败",
                            }));
                            return;
                        }

                        string fileName = Path.Combine(Path.GetTempPath(), Path.ChangeExtension(Path.GetRandomFileName(), ext));

                        FormDownload formDownload = new FormDownload(new Uri(p.MaterialUrl), fileName);
                        formDownload.ShowDialog();

                        pptHelp.AddMedia(fileName);

                        Task.Run(() =>
                        {
                            try
                            {
                                if (File.Exists(fileName))
                                {
                                    File.Delete(fileName);
                                }
                            }
                            catch { }
                        });

                    }
                });
            }
            catch (Exception ex)
            {
                ThisAddIn.ShowDialog(new Resource.Control.AlertWin.alertWindow(new
                {
                    message = ex.Message,
                }));
            }
        }
    }
}