aspose授权亲测可用配套代码

最新推荐文章于 2024-09-03 11:43:05 发布
最新推荐文章于 2024-09-03 11:43:05 发布
阅读量993 收藏 1
点赞数
原文链接：http://www.cnblogs.com/andyz168/p/5602398.html
版权

支持excel，word，ppt，pdf

using Aspose.Cells;
using Aspose.Words.Saving;
using ESBasic;
using OMCS.Engine.WhiteBoard;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Threading;
using System.Web;
using System.Web.UI;
using SMES.LocaleManagerWeb.DoucmentManager;
using ImageSaveOptions = Aspose.Words.Saving.ImageSaveOptions;
using SaveFormat = Aspose.Words.SaveFormat;

namespace SMES.LocaleManagerWeb
{
    public partial class Upload : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            //new Aspose.Words.License().SetLicense(AsposeLicenseHelper.LStream);
            //new Aspose.Cells.License().SetLicense(AsposeLicenseHelper.LStream);
            //new Aspose.Slides.License().SetLicense(AsposeLicenseHelper.LStream);
            //new Aspose.Pdf.License().SetLicense(AsposeLicenseHelper.LStream);
            string documentExts = "pdf|doc|docx|xlsx|xls|ppt|pptx";
            string imageExts = "jpeg|png|jpg|bmp";
            string otherExts = "pdf|xls|xlsx|ppt|pptx";
            HttpFileCollection files = Request.Files;//这里只能用<input type="file" />才能有效果,因为服务器控件是HttpInputFile类型

            FileUpModel model = new FileUpModel();
            if (files.Count == 0 || files[0].InputStream.Length == 0)
            {
                model = new FileUpModel() { State = 0, Error = "没有找到文件" };
                Response.Write(Newtonsoft.Json.JsonConvert.SerializeObject(model));
                //Response.End();
                return;
            }

            try
            {
                HttpPostedFile file = files[0];
                model.Extension = GetExtension(file.FileName);
                if ((documentExts + "|" + imageExts + "|" + otherExts).IndexOf(model.Extension.ToLower()) == -1)
                {
                    model = new FileUpModel() { State = 0, Error = "不允许上传" + model.Extension + "类型文件" };
                    Response.Write(Newtonsoft.Json.JsonConvert.SerializeObject(model));
                    //Response.End();
                    return;
                }

                model.Size = file.ContentLength / 1024;
                DateTime nowtime = DateTime.Now;
                string dic = "/UpLoadFile/" + nowtime.ToString("yy/MM/dd/");
                string newFilename = "/UpLoadFile/" + nowtime.ToString("yy/MM/dd/") + Guid.NewGuid().ToString("N") + "." + model.Extension;
                string filepath = Server.MapPath("~" + newFilename);
                if (!System.IO.Directory.Exists(Server.MapPath(dic)))
                {
                    System.IO.Directory.CreateDirectory(Server.MapPath(dic));
                }
                file.SaveAs(filepath);
                //将文档装换为图图片
                if (documentExts.IndexOf(model.Extension.ToLower()) != -1)
                {
                    //图片目录
                    string imagedic = newFilename.Replace("." + model.Extension, "");
                    IImageConverterFactory f = new ImageConverterFactory();
                    IImageConverter imageConverter = f.CreateImageConverter("." + model.Extension);
                    string opath = Server.MapPath("~" + newFilename);
                    string imgpath = Server.MapPath("~" + imagedic + "/");
                    Thread thd = new Thread(new ThreadStart(() => { imageConverter.ConvertToImage(opath, imgpath); }));
                    thd.Start();
                    //DocumentToImage(newFilename, imagedic);
                    model.ImagePath = imagedic;
                }

                model.State = 1;
                model.Path = newFilename;

                Response.Write(Newtonsoft.Json.JsonConvert.SerializeObject(model));

            }
            catch (Exception ee)
            {
                model = new FileUpModel() { State = 0, Error = ee.Message };
                Response.Write(Newtonsoft.Json.JsonConvert.SerializeObject(model));
                Response.End();
            }
        }

        private void DocumentToImage(string filename, string imagedic)
        {
            Thread thd = new Thread(new ThreadStart(() =>
            {
                ConvertWordToImage(Server.MapPath("~" + filename), Server.MapPath("~" + imagedic + "/"), "A", 0, 0, ImageFormat.Png, 0);
            }));
            thd.Start();

        }

        private string GetExtension(string filename)
        {
            if (string.IsNullOrEmpty(filename))
                return "";

            string[] strs = filename.Split('.');

            if (strs.Length > 0)
            {
                return strs[strs.Length - 1];
            }
            else
            {
                return "";
            }
        }

        public void ConvertWordToImage(string wordInputPath, string imageOutputPath,
            string imageName, int startPageNum, int endPageNum, ImageFormat imageFormat, float resolution)
        {
            try
            {
                AsposeLicenseHelper.SetWordsLicense();
                // open word file
                Aspose.Words.Document doc = new Aspose.Words.Document(wordInputPath);

                // validate parameter
                if (doc == null) { throw new Exception("Word文件无效或者Word文件被加密！"); }
                if (imageOutputPath.Trim().Length == 0) { imageOutputPath = Path.GetDirectoryName(wordInputPath); }
                if (!Directory.Exists(imageOutputPath)) { Directory.CreateDirectory(imageOutputPath); }
                if (imageName.Trim().Length == 0) { imageName = Path.GetFileNameWithoutExtension(wordInputPath); }
                if (startPageNum <= 0) { startPageNum = 1; }
                if (endPageNum > doc.PageCount || endPageNum <= 0) { endPageNum = doc.PageCount; }
                if (startPageNum > endPageNum) { int tempPageNum = startPageNum; startPageNum = endPageNum; endPageNum = startPageNum; }
                if (imageFormat == null) { imageFormat = ImageFormat.Png; }
                if (resolution <= 0) { resolution = 128; }

                var imageSaveOptions = new ImageSaveOptions(GetSaveFormat(imageFormat))
                {
                    Resolution = resolution
                };

                // start to convert each page
                for (int i = startPageNum; i <= endPageNum; i++)
                {
                    imageSaveOptions.PageIndex = i - 1;
                    doc.Save(Path.Combine(imageOutputPath, imageName) + "_" + i.ToString() + "." + imageFormat.ToString(), imageSaveOptions);
                }
            }
            catch (Exception ex)
            {

            }
        }

        private SaveFormat GetSaveFormat(ImageFormat imageFormat)
        {
            SaveFormat sf = SaveFormat.Unknown;
            if (imageFormat.Equals(ImageFormat.Png))
                sf = SaveFormat.Png;
            else if (imageFormat.Equals(ImageFormat.Jpeg))
                sf = SaveFormat.Jpeg;
            else if (imageFormat.Equals(ImageFormat.Tiff))
                sf = SaveFormat.Tiff;
            else if (imageFormat.Equals(ImageFormat.Bmp))
                sf = SaveFormat.Bmp;
            else
                sf = SaveFormat.Unknown;
            return sf;
        }


    }


    public class FileUpModel
    {
        /// <summary>
        /// 状态  1成功  0失败
        /// </summary>
        public int State
        { get; set; }

        /// <summary>
        /// 错误信息
        /// </summary>
        public string Error
        { get; set; }

        /// <summary>
        /// 文件大小
        /// </summary>
        public decimal Size
        {
            get;
            set;
        }

        /// <summary>
        /// 服务端路径
        /// </summary>
        public string Path
        { get; set; }

        public string ImagePath
        { get; set; }

        public string Extension
        { get; set; }

    }

    #region 图片转换器工厂 -> 将被注入到OMCS的多媒体管理器IMultimediaManager的ImageConverterFactory属性
    /// <summary>
    /// 图片转换器工厂。
    /// </summary>
    public class ImageConverterFactory : IImageConverterFactory
    {
        public IImageConverter CreateImageConverter(string extendName)
        {
            if (extendName == ".doc" || extendName == ".docx")
            {
                return new Word2ImageConverter();
            }

            if (extendName == ".pdf")
            {
                return new Pdf2ImageConverter();
            }

            if (extendName == ".ppt" || extendName == ".pptx")
            {
                return new Ppt2ImageConverter();
            }
            if (extendName == ".xls" || extendName == ".xlsx")
            {
                return new Xls2ImageConverter();
            }
            return null;
        }

        public bool Support(string extendName)
        {
            return extendName == ".doc" || extendName == ".docx" || extendName == ".pdf" || extendName == ".ppt" || extendName == ".pptx" || extendName == ".rar";
        }
    }
    #endregion

    #region 将word文档转换为图片
    public class Word2ImageConverter : IImageConverter
    {
        private bool cancelled = false;
        public event CbGeneric<int, int> ProgressChanged;
        public event CbGeneric ConvertSucceed;
        public event CbGeneric<string> ConvertFailed;

        public void Cancel()
        {
            if (this.cancelled)
            {
                return;
            }

            this.cancelled = true;
        }

        public void ConvertToImage(string originFilePath, string imageOutputDirPath)
        {
            this.cancelled = false;
            ConvertToImage(originFilePath, imageOutputDirPath, 0, 0, null, 200);
        }

        /// <summary>
        /// 将Word文档转换为图片的方法      
        /// </summary>
        /// <param name="wordInputPath">Word文件路径</param>
        /// <param name="imageOutputDirPath">图片输出路径，如果为空，默认值为Word所在路径</param>      
        /// <param name="startPageNum">从PDF文档的第几页开始转换，如果为0，默认值为1</param>
        /// <param name="endPageNum">从PDF文档的第几页开始停止转换，如果为0，默认值为Word总页数</param>
        /// <param name="imageFormat">设置所需图片格式，如果为null，默认格式为PNG</param>
        /// <param name="resolution">设置图片的像素，数字越大越清晰，如果为0，默认值为128，建议最大值不要超过1024</param>
        private void ConvertToImage(string wordInputPath, string imageOutputDirPath, int startPageNum, int endPageNum, ImageFormat imageFormat, int resolution)
        {
            try
            {

                AsposeLicenseHelper.SetWordsLicense();
                Aspose.Words.Document doc = new Aspose.Words.Document(wordInputPath);

                if (doc == null)
                {
                    throw new Exception("Word文件无效或者Word文件被加密！");
                }

                if (imageOutputDirPath.Trim().Length == 0)
                {
                    imageOutputDirPath = Path.GetDirectoryName(wordInputPath);
                }

                if (!Directory.Exists(imageOutputDirPath))
                {
                    Directory.CreateDirectory(imageOutputDirPath);
                }

                if (startPageNum <= 0)
                {
                    startPageNum = 1;
                }

                if (endPageNum > doc.PageCount || endPageNum <= 0)
                {
                    endPageNum = doc.PageCount;
                }

                if (startPageNum > endPageNum)
                {
                    int tempPageNum = startPageNum; startPageNum = endPageNum; endPageNum = startPageNum;
                }

                if (imageFormat == null)
                {
                    imageFormat = ImageFormat.Png;
                }

                if (resolution <= 0)
                {
                    resolution = 128;
                }
                string imageName = Path.GetFileNameWithoutExtension(Path.GetFileNameWithoutExtension(wordInputPath));
                //string imageName = Path.GetFileNameWithoutExtension(wordInputPath);
                Aspose.Words.Saving.ImageSaveOptions imageSaveOptions = new Aspose.Words.Saving.ImageSaveOptions(Aspose.Words.SaveFormat.Png);
                imageSaveOptions.Resolution = resolution;
                for (int i = startPageNum; i <= endPageNum; i++)
                {
                    if (this.cancelled)
                    {
                        break;
                    }

                    MemoryStream stream = new MemoryStream();
                    imageSaveOptions.PageIndex = i - 1;
                    //string imgPath = Path.Combine(imageOutputDirPath, imageName) + "_" + i.ToString("000") + "." + imageFormat.ToString();
                    string imgPath = Path.Combine(imageOutputDirPath, "A") + "_" + i + ".Png";
                    doc.Save(stream, imageSaveOptions);
                    System.Drawing.Image img = System.Drawing.Image.FromStream(stream);
                    Bitmap bm = ESBasic.Helpers.ImageHelper.Zoom(img, 0.6f);
                    bm.Save(imgPath, imageFormat);
                    img.Dispose();
                    stream.Dispose();
                    bm.Dispose();

                    System.Threading.Thread.Sleep(200);
                    if (this.ProgressChanged != null)
                    {
                        this.ProgressChanged(i - 1, endPageNum);
                    }
                }

                if (this.cancelled)
                {
                    return;
                }

                if (this.ConvertSucceed != null)
                {
                    this.ConvertSucceed();
                }
            }
            catch (Exception ex)
            {
                if (this.ConvertFailed != null)
                {
                    this.ConvertFailed(ex.Message);
                }
            }
        }
    }
    #endregion

    #region 将pdf文档转换为图片
    public class Pdf2ImageConverter : IImageConverter
    {
        private bool cancelled = false;
        public event CbGeneric<int, int> ProgressChanged;
        public event CbGeneric ConvertSucceed;
        public event CbGeneric<string> ConvertFailed;

        public void Cancel()
        {
            if (this.cancelled)
            {
                return;
            }

            this.cancelled = true;
        }

        public void ConvertToImage(string originFilePath, string imageOutputDirPath)
        {
            this.cancelled = false;
            ConvertToImage(originFilePath, imageOutputDirPath, 0, 0, 200);
        }

        /// <summary>
        /// 将pdf文档转换为图片的方法      
        /// </summary>
        /// <param name="originFilePath">pdf文件路径</param>
        /// <param name="imageOutputDirPath">图片输出路径，如果为空，默认值为pdf所在路径</param>       
        /// <param name="startPageNum">从PDF文档的第几页开始转换，如果为0，默认值为1</param>
        /// <param name="endPageNum">从PDF文档的第几页开始停止转换，如果为0，默认值为pdf总页数</param>       
        /// <param name="resolution">设置图片的像素，数字越大越清晰，如果为0，默认值为128，建议最大值不要超过1024</param>
        private void ConvertToImage(string originFilePath, string imageOutputDirPath, int startPageNum, int endPageNum, int resolution)
        {
            try
            {
                AsposeLicenseHelper.SetPdfLicense();
                Aspose.Pdf.Document doc = new Aspose.Pdf.Document(originFilePath);

                if (doc == null)
                {
                    throw new Exception("pdf文件无效或者pdf文件被加密！");
                }

                if (imageOutputDirPath.Trim().Length == 0)
                {
                    imageOutputDirPath = Path.GetDirectoryName(originFilePath);
                }

                if (!Directory.Exists(imageOutputDirPath))
                {
                    Directory.CreateDirectory(imageOutputDirPath);
                }

                if (startPageNum <= 0)
                {
                    startPageNum = 1;
                }

                if (endPageNum > doc.Pages.Count || endPageNum <= 0)
                {
                    endPageNum = doc.Pages.Count;
                }

                if (startPageNum > endPageNum)
                {
                    int tempPageNum = startPageNum; startPageNum = endPageNum; endPageNum = startPageNum;
                }

                if (resolution <= 0)
                {
                    resolution = 128;
                }

                string imageNamePrefix = Path.GetFileNameWithoutExtension(Path.GetFileNameWithoutExtension(originFilePath));
                for (int i = startPageNum; i <= endPageNum; i++)
                {
                    if (this.cancelled)
                    {
                        break;
                    }

                    MemoryStream stream = new MemoryStream();
                    //string imgPath = Path.Combine(imageOutputDirPath, imageNamePrefix) + "_" + i.ToString("000") + ".Png";
                    string imgPath = Path.Combine(imageOutputDirPath, "A") + "_" + i + ".Png";
                    Aspose.Pdf.Devices.Resolution reso = new Aspose.Pdf.Devices.Resolution(resolution);
                    Aspose.Pdf.Devices.JpegDevice jpegDevice = new Aspose.Pdf.Devices.JpegDevice(reso, 100);
                    jpegDevice.Process(doc.Pages[i], stream);

                    Image img = Image.FromStream(stream);
                    Bitmap bm = ESBasic.Helpers.ImageHelper.Zoom(img, 0.6f);
                    bm.Save(imgPath, ImageFormat.Jpeg);
                    img.Dispose();
                    stream.Dispose();
                    bm.Dispose();

                    System.Threading.Thread.Sleep(200);
                    if (this.ProgressChanged != null)
                    {
                        this.ProgressChanged(i - 1, endPageNum);
                    }
                }

                if (this.cancelled)
                {
                    return;
                }

                if (this.ConvertSucceed != null)
                {
                    this.ConvertSucceed();
                }
            }
            catch (Exception ex)
            {
                if (this.ConvertFailed != null)
                {
                    this.ConvertFailed(ex.Message);
                }
            }
        }
    }
    #endregion

    #region 将ppt文档转换为图片
    public class Ppt2ImageConverter : IImageConverter
    {
        private Pdf2ImageConverter pdf2ImageConverter;
        public event CbGeneric<int, int> ProgressChanged;
        public event CbGeneric ConvertSucceed;
        public event CbGeneric<string> ConvertFailed;

        public void Cancel()
        {
            if (this.pdf2ImageConverter != null)
            {
                this.pdf2ImageConverter.Cancel();
            }
        }

        public void ConvertToImage(string originFilePath, string imageOutputDirPath)
        {
            ConvertToImage(originFilePath, imageOutputDirPath, 0, 0, 200);
        }

        /// <summary>
        /// 将pdf文档转换为图片的方法      
        /// </summary>
        /// <param name="originFilePath">ppt文件路径</param>
        /// <param name="imageOutputDirPath">图片输出路径，如果为空，默认值为pdf所在路径</param>       
        /// <param name="startPageNum">从PDF文档的第几页开始转换，如果为0，默认值为1</param>
        /// <param name="endPageNum">从PDF文档的第几页开始停止转换，如果为0，默认值为pdf总页数</param>       
        /// <param name="resolution">设置图片的像素，数字越大越清晰，如果为0，默认值为128，建议最大值不要超过1024</param>
        private void ConvertToImage(string originFilePath, string imageOutputDirPath, int startPageNum, int endPageNum, int resolution)
        {
            try
            {
                AsposeLicenseHelper.SetSlidesLicense();
                Aspose.Slides.Presentation doc = new Aspose.Slides.Presentation(originFilePath);

                if (doc == null)
                {
                    throw new Exception("ppt文件无效或者ppt文件被加密！");
                }

                if (imageOutputDirPath.Trim().Length == 0)
                {
                    imageOutputDirPath = Path.GetDirectoryName(originFilePath);
                }

                if (!Directory.Exists(imageOutputDirPath))
                {
                    Directory.CreateDirectory(imageOutputDirPath);
                }

                if (startPageNum <= 0)
                {
                    startPageNum = 1;
                }

                if (endPageNum > doc.Slides.Count || endPageNum <= 0)
                {
                    endPageNum = doc.Slides.Count;
                }

                if (startPageNum > endPageNum)
                {
                    int tempPageNum = startPageNum; startPageNum = endPageNum; endPageNum = startPageNum;
                }

                if (resolution <= 0)
                {
                    resolution = 128;
                }

                //先将ppt转换为pdf临时文件
                string tmpPdfPath = originFilePath + ".pdf";
                doc.Save(tmpPdfPath, Aspose.Slides.Export.SaveFormat.Pdf);

                //再将pdf转换为图片
                Pdf2ImageConverter converter = new Pdf2ImageConverter();
                converter.ConvertFailed += new CbGeneric<string>(converter_ConvertFailed);
                converter.ConvertSucceed += new CbGeneric(converter_ConvertSucceed);
                converter.ProgressChanged += new CbGeneric<int, int>(converter_ProgressChanged);
                converter.ConvertToImage(tmpPdfPath, imageOutputDirPath);

                //删除pdf临时文件
                File.Delete(tmpPdfPath);

                if (this.ConvertSucceed != null)
                {
                    this.ConvertSucceed();
                }
            }
            catch (Exception ex)
            {
                if (this.ConvertFailed != null)
                {
                    this.ConvertFailed(ex.Message);
                }
            }

            this.pdf2ImageConverter = null;
        }

        void converter_ProgressChanged(int done, int total)
        {
            if (this.ProgressChanged != null)
            {
                this.ProgressChanged(done, total);
            }
        }

        void converter_ConvertSucceed()
        {
            if (this.ConvertSucceed != null)
            {
                this.ConvertSucceed();
            }
        }

        void converter_ConvertFailed(string msg)
        {
            if (this.ConvertFailed != null)
            {
                this.ConvertFailed(msg);
            }
        }
    }
    #endregion

    #region Excel
    public class Xls2ImageConverter : IImageConverter
    {
        private Xls2ImageConverter xls2ImageConverter;
        public event CbGeneric<int, int> ProgressChanged;
        public event CbGeneric ConvertSucceed;
        public event CbGeneric<string> ConvertFailed;

        public void Cancel()
        {
            if (this.xls2ImageConverter != null)
            {
                this.xls2ImageConverter.Cancel();
            }
        }

        public void ConvertToImage(string originFilePath, string imageOutputDirPath)
        {
            ConvertToImage(originFilePath, imageOutputDirPath, 0, 0, 200);
        }

        private void ConvertToImage(string originFilePath, string imageOutputDirPath, int startPageNum, int endPageNum, int resolution)
        {
            try
            {
                AsposeLicenseHelper.SetCellsLicense();
                Aspose.Cells.Workbook excel = new Workbook(originFilePath);

                if (excel == null)
                {
                    throw new Exception("excel文件无效或者excel文件被加密！");
                }

                if (imageOutputDirPath.Trim().Length == 0)
                {
                    imageOutputDirPath = Path.GetDirectoryName(originFilePath);
                }

                if (!Directory.Exists(imageOutputDirPath))
                {
                    Directory.CreateDirectory(imageOutputDirPath);
                }

                if (startPageNum <= 0)
                {
                    startPageNum = 1;
                }

                if (endPageNum > excel.Worksheets.Count || endPageNum <= 0)
                {
                    endPageNum = excel.Worksheets.Count;
                }

                if (startPageNum > endPageNum)
                {
                    int tempPageNum = startPageNum; startPageNum = endPageNum; endPageNum = startPageNum;
                }

                if (resolution <= 0)
                {
                    resolution = 128;
                }

                //先将excel转换为pdf临时文件
                string tmpPdfPath = originFilePath + ".pdf";
                excel.Save(tmpPdfPath, Aspose.Cells.SaveFormat.Pdf);

                //再将pdf转换为图片
                Pdf2ImageConverter converter = new Pdf2ImageConverter();
                converter.ConvertFailed += new CbGeneric<string>(converter_ConvertFailed);
                converter.ConvertSucceed += new CbGeneric(converter_ConvertSucceed);
                converter.ProgressChanged += new CbGeneric<int, int>(converter_ProgressChanged);
                converter.ConvertToImage(tmpPdfPath, imageOutputDirPath);

                //删除pdf临时文件
                File.Delete(tmpPdfPath);

                if (this.ConvertSucceed != null)
                {
                    this.ConvertSucceed();
                }
            }
            catch (Exception ex)
            {
                if (this.ConvertFailed != null)
                {
                    this.ConvertFailed(ex.Message);
                }
            }

            this.xls2ImageConverter = null;
        }

        void converter_ProgressChanged(int done, int total)
        {
            if (this.ProgressChanged != null)
            {
                this.ProgressChanged(done, total);
            }
        }

        void converter_ConvertSucceed()
        {
            if (this.ConvertSucceed != null)
            {
                this.ConvertSucceed();
            }
        }

        void converter_ConvertFailed(string msg)
        {
            if (this.ConvertFailed != null)
            {
                this.ConvertFailed(msg);
            }
        }
    }
    #endregion
}

 

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Mime;
using System.Web;
using Aspose.Words;

namespace SMES.LocaleManagerWeb.DoucmentManager
{
    public static class AsposeLicenseHelper
    {
        public const string Key =
            "PExpY2Vuc2U+DQogIDxEYXRhPg0KICAgIDxMaWNlbnNlZFRvPkFzcG9zZSBTY290bGFuZCB" +
            "UZWFtPC9MaWNlbnNlZFRvPg0KICAgIDxFbWFpbFRvPmJpbGx5Lmx1bmRpZUBhc3Bvc2UuY2" +
            "9tPC9FbWFpbFRvPg0KICAgIDxMaWNlbnNlVHlwZT5EZXZlbG9wZXIgT0VNPC9MaWNlbnNlV" +
            "HlwZT4NCiAgICA8TGljZW5zZU5vdGU+TGltaXRlZCB0byAxIGRldmVsb3BlciwgdW5saW1p" +
            "dGVkIHBoeXNpY2FsIGxvY2F0aW9uczwvTGljZW5zZU5vdGU+DQogICAgPE9yZGVySUQ+MTQ" +
            "wNDA4MDUyMzI0PC9PcmRlcklEPg0KICAgIDxVc2VySUQ+OTQyMzY8L1VzZXJJRD4NCiAgIC" +
            "A8T0VNPlRoaXMgaXMgYSByZWRpc3RyaWJ1dGFibGUgbGljZW5zZTwvT0VNPg0KICAgIDxQc" +
            "m9kdWN0cz4NCiAgICAgIDxQcm9kdWN0PkFzcG9zZS5Ub3RhbCBmb3IgLk5FVDwvUHJvZHVj" +
            "dD4NCiAgICA8L1Byb2R1Y3RzPg0KICAgIDxFZGl0aW9uVHlwZT5FbnRlcnByaXNlPC9FZGl" +
            "0aW9uVHlwZT4NCiAgICA8U2VyaWFsTnVtYmVyPjlhNTk1NDdjLTQxZjAtNDI4Yi1iYTcyLT" +
            "djNDM2OGYxNTFkNzwvU2VyaWFsTnVtYmVyPg0KICAgIDxTdWJzY3JpcHRpb25FeHBpcnk+M" +
            "jAxNTEyMzE8L1N1YnNjcmlwdGlvbkV4cGlyeT4NCiAgICA8TGljZW5zZVZlcnNpb24+My4w" +
            "PC9MaWNlbnNlVmVyc2lvbj4NCiAgICA8TGljZW5zZUluc3RydWN0aW9ucz5odHRwOi8vd3d" +
            "3LmFzcG9zZS5jb20vY29ycG9yYXRlL3B1cmNoYXNlL2xpY2Vuc2UtaW5zdHJ1Y3Rpb25zLm" +
            "FzcHg8L0xpY2Vuc2VJbnN0cnVjdGlvbnM+DQogIDwvRGF0YT4NCiAgPFNpZ25hdHVyZT5GT" +
            "zNQSHNibGdEdDhGNTlzTVQxbDFhbXlpOXFrMlY2RThkUWtJUDdMZFRKU3hEaWJORUZ1MXpP" +
            "aW5RYnFGZkt2L3J1dHR2Y3hvUk9rYzF0VWUwRHRPNmNQMVpmNkowVmVtZ1NZOGkvTFpFQ1R" +
            "Hc3pScUpWUVJaME1vVm5CaHVQQUprNWVsaTdmaFZjRjhoV2QzRTRYUTNMemZtSkN1YWoyTk" +
            "V0ZVJpNUhyZmc9PC9TaWduYXR1cmU+DQo8L0xpY2Vuc2U+";
        public static Stream LStream = (Stream)new MemoryStream(Convert.FromBase64String(Key));

        static readonly string LicensePath = AppDomain.CurrentDomain.SetupInformation.ApplicationBase + "\\DoucmentManager\\Aspose.Total.lic";
        public static void SetWordsLicense()
        {
            var l=new License(); 
            l.SetLicense(LicensePath);
        }
        public static void SetPdfLicense()
        {
            var l = new Aspose.Pdf.License();
            l.SetLicense(LicensePath);
        }
        public static void SetSlidesLicense()
        {
            var l = new Aspose.Slides.License();
            l.SetLicense(LicensePath);
        }
        /// <summary>
        /// Excel
        /// </summary>
        public static void SetCellsLicense()
        {
            var l = new Aspose.Cells.License();
            l.SetLicense(LicensePath);
        }
    }
}

 下载地址

转载于:https://www.cnblogs.com/andyz168/p/5602398.html

weixin_30872671
关注
C#------Aspose的License文件
weixin_34323858的博客
08-05 3584
Aspose官网： https://docs.aspose.com/display/cellsnet/Home   下载地址： http://vdisk.weibo.com/s/uoya0tRiZNf0X?category_id=0...re 代码： &lt;?xml version="1.0" encoding="utf-8"?&gt; &lt;License&gt; &lt;Da...
Aspose.Cells.18.10 亲测可用包含.net core
09-21
亲测可用，在docker 下pdf导出需要安装图形库相关支持，加入windows字体，否则出现文档大小为0和中文乱码情况
Aspose.words工具授权
03-26
Aspose.words工具授权
ASPOSE及授权
06-21
Aspose.Cells.dll 文件版本8.3 Aspose.Pdf.dll 文件版本9.8 Aspose.Slides.dll文件版本14.10 Aspose.Words.dll 文件版本14.10
aspose-words最新版本代码心得（android开发版本）
最新发布
weixin_52282455的博客
09-03 480
aspose 为收费软件，以下仅仅用于学习技术，请勿做任何商业用途，如果需要请到官网购买正版！参考了具体分析该博主已写得十分清晰，可以对照查看，这里我只整理了破解需要查看的文件和属性，并对博主在分析中部分没提到的信息进行了小小整理，用于android开发项目中，将word转为pdf无水印，了解以下内容基本可实现对大多版本进行破解。
Word控件 Aspose.words for.NET 授权须知
励志做最业余的专业博主，控件产品可以私我~
01-10 2918
本文主要介绍Aspose.words for.NET 购买授权须知，欢迎查阅
Aspose.word保存PDF时进行授权访问设置
greystar的专栏
08-13 6155
#region DOC TO PDF public void ConvertDocToPDF(string docPath,string savePdfPath) { Aspose.Words.Document wordDocument = new Aspose.Words.Document(docPath); Ins
Aspose.Word.dll 支持.net core 无水印 亲测可用
05-16
8. **兼容性**：Aspose.Word.dll不仅支持.NET Framework，还支持.NET Core，确保了代码在不同平台上的兼容性和可移植性。 在实际开发中，开发者可以通过NuGet包管理器或直接下载Aspose.Word.dll来引入这个组件。...
aspose words cells slide破解版 亲测可用
11-02
aspose破解版 支持 doc、docx、xls、xlsx、ppt、pptx ......亲测可用
Aspose.Words.dll 19.6（本人亲测可用版本）
09-25
目前你能找到的最新的最好用的Aspose.Words的DLL,目前市面上20版本的还不太好用，所以最高的就是这个版本了，Windows平台下没有问题，Docker下目前发现有问题要20版本才行，如果是在Docker下部署，就不要下载了，...
Aspose.Words2013 C#、.net，亲测可用.dll文件，附C#测试源码
05-10
我是用来把文档转图片，这个版本转换速度很快，是18版的5倍以上。但是有一个缺点，不能转成gif图片。。Aspose.Words2013 C#、.net，亲测可用.dll文件，附C#测试源码，需要的赶紧下载吧
aspose-words的license和jar
12-26
支持将Word转化为png和 pdf等各种格式，且无需Office环境
aspose word license.xml
04-18
java利用Aspose.cells.jar将本地excel文档转化成pdf（完美破解版 无水印 无中文乱码）
aspose-word+license.xml
09-15
解决利用freemarker技术生成word文档无法使用office打开的问题。
Aspose-word+license.zip
08-11
Java word转pdf，wordAspose-words相关jar和license.xml
Aspose.Cells for .NET v17.9 with License Key破解版
12-20
Aspose.Cells允许开发人员创建和管理Excel， 而不需要安装Microsoft Excel或者Microsoft Office Excel。 所有Aspose组件是完全独立的，无隶属关系，也没有授权，赞助，或以其他方式的微软公司批准。 总之Aspose.Cells是一个更好的选择 ， 自动化 ，安全，稳定，可扩展性延伸，速度快，功能强大
Aspose.Total for .NET 21.6 License Version
控件与插件之大全
06-18 8650
Aspose.Total for .NET is the most complete package of all .NET file format APIs offered by Aspose. It empowers developers to create, edit, render, print and convert between most popular file formats within any .NET, C#, ASP.NET and VB.NET applications. As
html控件Aspose.Html for .NET 授权须知
励志做最业余的专业博主，控件产品可以私我~
02-09 734
如果您将任何其他 Aspose for .NET 组件与 Aspose.HTML for .NET 一起使用，请为许可证指定完整的名称空间，如。将许可证与您的应用程序打包在一起的另一种巧妙方法是将其作为嵌入式资源包含到调用 Aspose.HTML for .NET 的程序集中。应用许可证最简单的方法是将许可证文件放在与 Aspose.HTML.dll 文件相同的文件夹中，并仅指定文件名而不指定路径。Aspose.HTML for .NET 为您提供了多种申请许可证的方法。也可以从许可证文件流中申请许可证。
Java版Spire.Doc和aspose-words无限制亲测使用体验
资源摘要信息:"Spire.Doc for Java 11.4.2和aspose-words-24.01全功能无限制使用，无水印，亲测可用" 1. 关于Spire.Doc for Java Spire.Doc for Java 是一款Java库，允许开发人员在Java应用程序中创建、编辑、保存...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值