Hello, world!
"); +``` + +**نصيحة حالة حافة:** إذا كانت علامتك تشير إلى موارد خارجية (صور، ملفات CSS)، تأكد من أن تلك الروابط قابلة للوصول من الجهاز الذي يشغّل الكود، أو ضمّنها كـ data‑URIs لتجنب الروابط المعطلة. + +## الخطوة 4: تحويل HTML إلى تدفق PNG + +الآن يأتي جوهر **كيفية تحويل HTML** – نستدعي `RenderToStream`، مع تمرير تدفق الإخراج والخيارات التي ضبطناها مسبقًا. تقوم هذه الطريقة بكل الأعمال الثقيلة: التخطيط، تسلسل CSS، استبدال الخطوط، والتحويل إلى صورة نقطية. + +```csharp +using System.IO; + +// Choose an output path – replace with your own directory +string outputPath = @"C:\Temp\Images\output.png"; + +using (FileStream outputStream = File.OpenWrite(outputPath)) +{ + // Render the HTML document into the PNG file + htmlDoc.RenderToStream(outputStream, renderingOptions); +} +``` + +بعد انتهاء كتلة `using`، سيحتوي `output.png` على صورة بحجم 800 × 600 بكسل للفقرة التي حمّلناها. افتحها بأي عارض صور للتحقق من النتيجة. + +### النتيجة المتوقعة + +يجب أن ترى لوحة بيضاء نظيفة مع النص **“Hello, world!”** معروضًا بخط Arial، عريض ومائل، بحجم 24 pt بالضبط. أبعاد الصورة تتطابق مع القيم 800 × 600 التي حددناها. + +## الخطوة 5: التحقق ومعالجة المشكلات الشائعة + +### 5.1 التحقق من وجود الملف + +فحص سريع يمنع الفشل الصامت: + +```csharp +if (File.Exists(outputPath)) +{ + Console.WriteLine($"✅ PNG created successfully at {outputPath}"); +} +else +{ + Console.WriteLine("❌ Something went wrong – PNG not found."); +} +``` + +### 5.2 التعامل مع الخطوط المفقودة + +إذا كان الجهاز المستهدف لا يحتوي على الخط المطلوب، سيعود Aspose.HTML إلى خط sans‑serif عام. لضمان التناسق، يمكنك إما: + +- تضمين ملف الخط باستخدام قاعدة `@font-face` في HTML الخاص بك، **أو** +- تسجيل الخط برمجيًا قبل التحويل. + +```csharp +// Example of registering a custom TrueType font +htmlDoc.Fonts.AddFontFile(@"C:\Fonts\OpenSans-Regular.ttf"); +``` + +### 5.3 تحويل الصفحات الكبيرة + +عند إنشاء صور مصغرة لقطات شاشة لصفحات كاملة، راقب استهلاك الذاكرة. يمكنك تقليل الحجم بعد التحويل، أو ضبط `renderingOptions.Width`/`Height` إلى حجم أصغر ودع Aspose.HTML يتولى التحجيم. + +## مثال كامل يعمل + +فيما يلي البرنامج الكامل الذي يمكنك وضعه في تطبيق Console وتشغيله فورًا. + +```csharp +// ----------------------------------------------------------- +// How to render HTML as PNG – Complete, runnable example +// ----------------------------------------------------------- +using System; +using System.IO; +using Aspose.Html; +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +class Program +{ + static void Main() + { + // 1️⃣ Configure rendering options + ImageRenderingOptions renderingOptions = new ImageRenderingOptions + { + Width = 800, + Height = 600, + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic + }; + + // 2️⃣ Load HTML markup + HtmlDocument htmlDoc = new HtmlDocument(); + htmlDoc.Open("Hello, world!
"); + + // 3️⃣ Define output path + string outputPath = @"C:\Temp\Images\output.png"; + + // 4️⃣ Render to PNG + using (FileStream outputStream = File.OpenWrite(outputPath)) + { + htmlDoc.RenderToStream(outputStream, renderingOptions); + } + + // 5️⃣ Verify the result + Console.WriteLine(File.Exists(outputPath) + ? $"✅ PNG saved at {outputPath}" + : "❌ Failed to create PNG"); + } +} +``` + +شغّل البرنامج (`dotnet run`)، ثم افتح `C:\Temp\Images\output.png`. إذا سارت الأمور بسلاسة، فقد **حوّلت HTML إلى صورة** و**حفظت HTML كملف PNG** باستخدام كود C# نقي. + +## الأسئلة المتكررة + +| السؤال | الإجابة | +|----------|--------| +| **هل يمكنني عرض صفحة ويب كاملة مع CSS/JS خارجي؟** | نعم – فقط استدعِ `htmlDoc.Open("https://example.com")`. سيقوم المحرك بتحميل الموارد المرتبطة، لكنك تحتاج إلى اتصال بالإنترنت. | +| **ما الصيغ المدعومة بجانب PNG؟** | `ImageRenderingOptions` يدعم JPEG، BMP، GIF، و TIFF. غير امتداد الملف واضبط `ImageFormat` إذا لزم الأمر. | +| **هل هناك حد لحجم الصورة؟** | من الناحية التقنية يمكنك الوصول إلى عدة آلاف من البكسلات، لكن الأبعاد الكبيرة جدًا قد تستنزف الذاكرة. فكر في التحويل على شكل بلاطات للنتائج فائقة الدقة. | +| **كيف أتعامل مع DPI للحصول على صور بجودة طباعة؟** | اضبط `renderingOptions.DpiX` و `renderingOptions.DpiY` (القيمة الافتراضية 96). DPI أعلى ينتج صورة أكثر حدة للطباعة. | +| **هل أحتاج إلى ترخيص لـ Aspose.HTML؟** | النسخة التجريبية المجانية تعمل مع علامة مائية. للإنتاج، اشترِ ترخيصًا لإزالة العلامة المائية وفتح جميع الميزات. | + +## الخطوات التالية والمواضيع ذات الصلة + +- **تحويل HTML إلى JPEG** – غيّر امتداد الملف واختياريًا اضبط `renderingOptions.ImageFormat = ImageFormat.Jpeg`. +- **المعالجة الدفعية** – كرّر العملية على قائمة من عناوين URL لتوليد صور مصغرة لكل منها. +- **تضمين الخطوط** – تعلّم كيفية استخدام `@font-face` داخل علامتك للحصول على طباعة دقيقة. +- **التخطيط المتقدم** – جرّب خيارات `PageSize` و `Margin` و `BackgroundColor` للحصول على مظهر مخصص. + +لا تتردد في تعديل الأبعاد، تجربة مقتطفات HTML مختلفة، أو دمج هذا المقتطف في واجهة API ويب تُقدّم معاينات PNG عند الطلب. السماء هي الحد عندما تعرف **كيفية تحويل HTML** برمجيًا. + +--- + + + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/chinese/net/html-extensions-and-conversions/_index.md b/html/chinese/net/html-extensions-and-conversions/_index.md index 59e136371b..78e4fda53d 100644 --- a/html/chinese/net/html-extensions-and-conversions/_index.md +++ b/html/chinese/net/html-extensions-and-conversions/_index.md @@ -126,6 +126,8 @@ Aspose.HTML for .NET 不仅仅是一个库；它是 Web 开发领域的变革者 通过完整的分步示例，学习在 C# 中使用 Aspose.HTML 将 HTML 转换为 PDF 的全部技巧。 ### [Aspose HTML 保存选项：在 C# 中将 HTML 保存到流](./aspose-html-save-options-save-html-to-stream-in-c/) 了解如何使用 Aspose.HTML for .NET 在 C# 中将 HTML 保存到流，提供代码示例和关键步骤。 +### [如何在 Aspose.HTML 中使用处理程序 – 加载 HTML 并保存为 ZIP](./how-to-use-handler-in-aspose-html-load-html-save-as-zip/) +演示如何使用 Aspose.HTML 的处理程序加载 HTML 并将其压缩保存为 ZIP 文件的完整步骤。 ## 结论 diff --git a/html/chinese/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md b/html/chinese/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md new file mode 100644 index 0000000000..9952fb056b --- /dev/null +++ b/html/chinese/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md @@ -0,0 +1,184 @@ +--- +category: general +date: 2026-02-25 +description: 如何使用处理程序从 URL 加载 HTML 并使用 Aspose.HTML 将网页保存为 ZIP – 完整的 C# 步骤指南。 +draft: false +keywords: +- how to use handler +- load html from url +- custom resource handler +- save webpage as zip +- create zip from html +language: zh +og_description: 如何使用处理程序从 URL 加载 HTML 并使用 Aspose.HTML 将网页保存为 ZIP。几分钟内学习完整的 C# 工作流。 +og_title: 如何在 Aspose.HTML 中使用处理程序 – 加载 HTML，保存为 ZIP +tags: +- Aspose.HTML +- C# +- Web Scraping +title: 如何在 Aspose.HTML 中使用处理程序 – 加载 HTML，保存为 ZIP +url: /zh/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# 如何在 Aspose.HTML 中使用处理程序 – 加载 HTML，保存为 ZIP + +是否曾想过在将网页拉取到 .NET 应用时 **如何使用处理程序**？也许你已经尝试了 `HtmlDocument.Open` 并得到了 HTML，但图像、CSS 和字体却消失得无影无踪。这是一个常见的难题——除非你告诉 Aspose.HTML 如何处理这些资源，否则它们会丢失。 + +在本教程中，我们将演示如何从 URL 加载 HTML，连接一个 **自定义资源处理程序**，并最终 **将网页保存为 zip**，从而得到一个可携带的单一归档文件。完成后，你将拥有一个可直接运行的 C# 代码片段，可放入任何项目中使用，并附带一些后期省时的技巧。 + +## 你需要的条件 + +- .NET 6+（该 API 同样适用于 .NET Core 和 .NET Framework） +- Aspose.HTML for .NET（NuGet 包 `Aspose.HTML`） +- 具备一定的 C# 经验（只要写过 `Console.WriteLine` 就没问题） + +无需额外工具或外部服务——只需库本身和你想要归档的 URL。 + + + +## 步骤 1：从 URL 加载 HTML + +在任何网页抓取流程中，第一步都是获取页面源码。Aspose.HTML 只需一行代码即可完成，但请记住我们是使用内置网络栈 **从 URL 加载 html**。 + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +// 1️⃣ Load the page you want to archive +HtmlDocument htmlDoc = new HtmlDocument(); +htmlDoc.Open("https://example.com"); // replace with any public URL +``` + +> **为什么这很重要：** `HtmlDocument.Open` 解析标记 *并且* 在内部解析相对 URL，但它不会自动保存外部资源。这就是后面需要处理程序的原因。 + +## 步骤 2：创建自定义资源处理程序 + +现在进入关键部分——**如何使用处理程序**来拦截每个外部资源请求（图像、CSS、字体等）。通过继承 `ResourceHandler`，你可以完全控制每个资源对应的流。 + +```csharp +// 2️⃣ Define your own handler (optional but powerful) +public class MyResourceHandler : ResourceHandler +{ + // Called for each external resource the document needs + public override Stream HandleResource(ResourceInfo info) + { + // Here you could download the file, cache it, or rewrite it. + // For this demo we simply return an empty stream – Aspose will + // still create the entry in the ZIP, keeping the folder structure. + return new MemoryStream(); + } +} +``` + +> **专业提示：** 在生产环境中，你可能希望下载实际的字节（`HttpClient.GetStreamAsync(info.Uri)`）并返回该流。这样保存的 ZIP 就会包含真实的图像，而不是空占位符。 + +## 步骤 3：配置保存选项并附加处理程序 + +处理程序准备好后，我们告诉 Aspose.HTML 如何打包所有内容。`HtmlSaveOptions` 类可以打开 `SaveToZipArchive` 开关并插入你的 `MyResourceHandler`。 + +```csharp +// 3️⃣ Set up saving options – this is where we **save webpage as zip** +HtmlSaveOptions saveOptions = new HtmlSaveOptions +{ + // Attach our custom handler – new API as of v22.10 + OutputStorage = new MyResourceHandler(), + + // Instruct Aspose to bundle HTML + resources into a single ZIP file + SaveToZipArchive = true +}; +``` + +> **说明：** `OutputStorage` 是接收处理程序实例的属性。当保存器遍历 DOM 时，它会对每个外部链接调用 `HandleResource`。由于 `SaveToZipArchive` 为 true，保存器会将每个返回的流写入与原始路径相匹配的 ZIP 条目。 + +## 步骤 4：将文档保存到内存流 + +我们可以直接写入磁盘，但将所有内容保存在内存中可以让代码在 ASP.NET、Azure Functions 或任何不想生成临时文件的场景下使用。下面是最终步骤，即 **从 html 创建 zip**。 + +```csharp +// 4️⃣ Save everything – HTML + resources – into a MemoryStream +using (MemoryStream outputStream = new MemoryStream()) +{ + htmlDoc.Save(outputStream, saveOptions); + + // At this point outputStream holds a valid ZIP archive. + // For demo purposes we write it to the file system: + File.WriteAllBytes("example_page.zip", outputStream.ToArray()); +} +``` + +### 预期结果 + +- `example_page.zip` 会出现在你的项目文件夹中。 +- 在 ZIP 内部，你会看到 `index.html` 以及文件夹结构（`images/`、`css/` 等）。 +- 即使我们的演示处理程序返回了空流，ZIP 的布局仍然与原页面相同——以后替换为真实下载器时非常方便。 + +## 常见变体与边缘情况 + +### 加载本地文件而非 URL + +如果需要从磁盘上的类似 **load html from url** 的路径加载，只需将 `htmlDoc.Open("https://example.com")` 替换为 `htmlDoc.Open(@"C:\path\to\file.html")`。其余流程保持不变。 + +### 持久化真实资源 + +要真正嵌入图像，请修改 `HandleResource`： + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Download the resource using HttpClient + HttpClient client = new HttpClient(); + var data = client.GetByteArrayAsync(info.Uri).Result; + return new MemoryStream(data); +} +``` + +> **注意：** 处理程序内部的网络调用会阻塞保存线程；对于大型页面，考虑将处理程序改为异步（在新版 Aspose 中可用）。 + +### 更改 ZIP 条目名称 + +`ResourceInfo` 包含 `FileName` 和 `Path`。你可以重写它们以扁平化层级或添加前缀： + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Example: prepend "assets/" to every entry + info.Path = Path.Combine("assets", info.Path); + return base.HandleResource(info); +} +``` + +### 使用不同的输出存储 + +`OutputStorage` 也可以是 `FileSystemStorage`，如果你更喜欢文件夹而不是 ZIP。只需将 `SaveToZipArchive = false`，并将 `OutputStorage` 指向目录路径即可。 + +## 专业提示与陷阱 + +- **不要忘记释放** `HtmlDocument`，如果在循环中打开许多页面，否则可能泄漏本机资源。 +- **内存使用情况：** 将大型页面保存到 `MemoryStream` 可能导致内存激增。对于多兆字节的归档，建议直接流式写入文件（`FileStream`）。 +- **字符编码：** Aspose.HTML 会遵循 `` 标签。如果源页面使用不常见的编码，请在提取后验证生成的 HTML 是否正确渲染。 +- **测试：** 在浏览器中打开生成的 ZIP（将 `index.html` 拖出）以确保所有资源都能解析。如果图像缺失，可能是你的 `HandleResource` 返回了空流。 + +## 小结 + +我们已经介绍了 **如何使用处理程序** 来拦截外部资源，演示了 **从 url 加载 html**，构建了 **自定义资源处理程序**，并最终 **将网页保存为 zip**——实际上只用了几行 C# 代码就实现了 **从 html 创建 zip**。该模式可扩展：将空的 `MemoryStream` 替换为真实的下载器，改变输出目标，或将逻辑嵌入返回 ZIP 的 Web API 中。 + +--- + +### 接下来做什么？ + +- **批量处理：** 对 URL 列表循环，为每个页面生成一个 ZIP。 +- **压缩调优：** 使用 `ZipSaveOptions` 调整压缩级别，以加快下载速度。 +- **与 ASP.NET Core 集成：** 将 `MemoryStream` 作为 `FileResult` 返回，使用户能够直接从 Web 端点下载归档。 +- **探索其他 Aspose.HTML 功能：** PDF 转换、DOM 操作或无头渲染。 + +如果对特定用例有疑问——比如需要保留 JavaScript 或处理需要身份验证的页面？请在下方留言，我很乐意进一步探讨。祝编码愉快！ + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/chinese/net/rendering-html-documents/_index.md b/html/chinese/net/rendering-html-documents/_index.md index a13fc53cca..60f8f3508d 100644 --- a/html/chinese/net/rendering-html-documents/_index.md +++ b/html/chinese/net/rendering-html-documents/_index.md @@ -98,6 +98,9 @@ Aspose.HTML for .NET 凭借其丰富的功能、出色的文档和活跃的社 ### [使用 Aspose.HTML 在 .NET 中将 HTML 渲染为 PDF – 步骤指南](./render-html-to-pdf-with-aspose-html-step-by-step-guide/) 学习使用 Aspose.HTML for .NET 将 HTML 渲染为 PDF 的完整步骤指南，涵盖关键设置和最佳实践。 +### [如何在 C# 中将 HTML 渲染为 PNG – 步骤指南](./how-to-render-html-as-png-in-c-step-by-step-guide/) +本指南详细演示如何使用 Aspose.HTML for .NET 在 C# 中将 HTML 渲染为 PNG，提供分步示例和最佳实践。 + {{< /blocks/products/pf/tutorial-page-section >}} {{< /blocks/products/pf/main-container >}} diff --git a/html/chinese/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md b/html/chinese/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..b37a5f06b5 --- /dev/null +++ b/html/chinese/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md @@ -0,0 +1,222 @@ +--- +category: general +date: 2026-02-25 +description: 如何使用 Aspose.HTML 在 C# 中将 HTML 渲染为 PNG。学习将 HTML 转换为图像、将 HTML 保存为 PNG，以及快速从 + HTML 创建 PNG。 +draft: false +keywords: +- how to render html +- convert html to image +- save html as png +- create png from html +- generate png from html +language: zh +og_description: 如何在 C# 中使用 Aspose.HTML 将 HTML 渲染为 PNG。请按照本教程将 HTML 转换为图像，将 HTML 保存为 + PNG，并从 HTML 生成 PNG。 +og_title: 如何在 C# 中将 HTML 渲染为 PNG – 完整指南 +tags: +- C# +- Aspose.HTML +- Image Rendering +title: 如何在 C# 中将 HTML 渲染为 PNG – 步骤指南 +url: /zh/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# 如何在 C# 中将 HTML 渲染为 PNG – 步骤指南 + +有没有想过 **如何将 HTML** 直接渲染成 PNG 文件而不需要打开浏览器？也许你需要在电子邮件中嵌入网页的微型快照，或者正在为 CMS 构建缩略图服务。无论哪种情况，核心问题都是把标记转换为可以存储或提供的位图。 + +在本教程中，你将看到一个完整、可直接运行的解决方案，使用 Aspose.HTML for .NET **将 HTML 转换为图像**。我们还会涉及如何 **将 HTML 保存为 PNG**、**从 HTML 创建 PNG**，以及使用自定义字体和尺寸 **生成 PNG**。没有模糊的引用——只提供可复制粘贴的代码以及每行代码意义的解释。 + +## 需要的环境 + +- .NET 6（或任何近期的 .NET 运行时）——API 在 .NET Framework 4.6+ 上表现相同。 +- Visual Studio 2022 或 VS Code——任选其一。 +- **Aspose.HTML** NuGet 包（`Aspose.HTML.NET`）——安装一次即可使用。 +- 一个可写入的文件夹用于输出 PNG（例如 `C:\Temp\Images`）。 + +就这些。无需额外的二进制文件、外部 Web 服务，也没有隐藏的配置文件。 + +## 第 1 步：通过 NuGet 安装 Aspose.HTML + +首先，将库添加到项目中。打开解决方案文件夹下的终端并运行： + +```bash +dotnet add package Aspose.HTML.NET +``` + +*小技巧：* 如果你使用 Visual Studio，右键 **Dependencies → Manage NuGet Packages**，搜索 “Aspose.HTML”，然后点击 **Install**。这样就可以使用 `HtmlDocument`、`ImageRenderingOptions` 等我们将在后面使用的类。 + +## 第 2 步：设置渲染选项（尺寸、样式和字体） + +在把任何标记送入渲染器之前，我们需要决定图片的大小以及要保留哪些字体样式。`ImageRenderingOptions` 对象可以让你微调宽度、高度，甚至强制粗体/斜体渲染。 + +```csharp +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +// Configure image rendering options – width, height, and font style +ImageRenderingOptions renderingOptions = new ImageRenderingOptions +{ + Width = 800, // Desired image width in pixels + Height = 600, // Desired image height in pixels + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic // Preserve bold & italic +}; +``` + +**为什么这很重要：** +- **Width/Height** 决定最终的像素尺寸；如果省略，渲染引擎会根据 HTML 布局自行猜测，可能导致意外裁剪。 +- **FontStyle** 确保 `` 或 `` 标签在光栅化后仍保持视觉强调。 + +## 第 3 步：加载 HTML 标记 + +你可以从字符串、文件或 URL 加载 HTML。为简便起见，我们直接在代码中嵌入一个小片段。请注意内联 CSS 中设置的字体族——Aspose.HTML 会遵循标准的 Web CSS，确保渲染忠实。 + +```csharp +using Aspose.Html; + +// Create an empty HTML document +HtmlDocument htmlDoc = new HtmlDocument(); + +// Load simple markup – you could also use htmlDoc.Open("path/to/file.html") +htmlDoc.Open("Hello, world!
"); +``` + +**边缘情况提示：** 如果你的标记引用了外部资源（图片、CSS 文件），请确保这些 URL 在运行代码的机器上可访问，或将它们嵌入为 data‑URI，以免出现断链。 + +## 第 4 步：将 HTML 渲染为 PNG 流 + +现在进入 **如何渲染 HTML** 的核心——调用 `RenderToStream`，传入输出流和前面配置的选项。该方法完成所有繁重工作：布局、CSS 级联、字体替换以及光栅化。 + +```csharp +using System.IO; + +// Choose an output path – replace with your own directory +string outputPath = @"C:\Temp\Images\output.png"; + +using (FileStream outputStream = File.OpenWrite(outputPath)) +{ + // Render the HTML document into the PNG file + htmlDoc.RenderToStream(outputStream, renderingOptions); +} +``` + +`using` 块结束后，`output.png` 将包含一张 800 × 600 像素的图片，展示我们加载的段落。使用任意图像查看器打开即可验证结果。 + +### 预期结果 + +你应该看到一块干净的白色画布，文字 **“Hello, world!”** 以 Arial、粗体斜体、24 pt 大小渲染。图像尺寸正好是我们设定的 800 × 600。 + +## 第 5 步：验证并处理常见陷阱 + +### 5.1 检查文件是否存在 + +快速的完整性检查可以防止静默失败： + +```csharp +if (File.Exists(outputPath)) +{ + Console.WriteLine($"✅ PNG created successfully at {outputPath}"); +} +else +{ + Console.WriteLine("❌ Something went wrong – PNG not found."); +} +``` + +### 5.2 处理缺失的字体 + +如果目标机器没有所请求的字体，Aspose.HTML 会回退到通用的无衬线字体。为保证一致性，可以： + +- 在 HTML 中使用 `@font-face` 规则嵌入字体文件，**或** +- 在渲染前以编程方式注册字体。 + +```csharp +// Example of registering a custom TrueType font +htmlDoc.Fonts.AddFontFile(@"C:\Fonts\OpenSans-Regular.ttf"); +``` + +### 5.3 渲染大页面 + +在为整页截图生成缩略图时，需要关注内存使用情况。可以在渲染后进行降采样，或将 `renderingOptions.Width`/`Height` 设置为较小尺寸，让 Aspose.HTML 负责缩放。 + +## 完整可运行示例 + +下面是完整的程序代码，可直接放入控制台应用并立即运行。 + +```csharp +// ----------------------------------------------------------- +// How to render HTML as PNG – Complete, runnable example +// ----------------------------------------------------------- +using System; +using System.IO; +using Aspose.Html; +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +class Program +{ + static void Main() + { + // 1️⃣ Configure rendering options + ImageRenderingOptions renderingOptions = new ImageRenderingOptions + { + Width = 800, + Height = 600, + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic + }; + + // 2️⃣ Load HTML markup + HtmlDocument htmlDoc = new HtmlDocument(); + htmlDoc.Open("Hello, world!
"); + + // 3️⃣ Define output path + string outputPath = @"C:\Temp\Images\output.png"; + + // 4️⃣ Render to PNG + using (FileStream outputStream = File.OpenWrite(outputPath)) + { + htmlDoc.RenderToStream(outputStream, renderingOptions); + } + + // 5️⃣ Verify the result + Console.WriteLine(File.Exists(outputPath) + ? $"✅ PNG saved at {outputPath}" + : "❌ Failed to create PNG"); + } +} +``` + +运行程序（`dotnet run`），然后打开 `C:\Temp\Images\output.png`。如果一切顺利，你已经使用纯 C# 代码 **将 HTML 转换为图像** 并 **将 HTML 保存为 PNG**。 + +## 常见问题 + +| Question | Answer | +|----------|--------| +| **我可以渲染带有外部 CSS/JS 的完整网页吗？** | 可以——只需调用 `htmlDoc.Open("https://example.com")`。引擎会下载关联资源，但需要网络访问。 | +| **除了 PNG 之外还有哪些格式受支持？** | `ImageRenderingOptions` 同时支持 JPEG、BMP、GIF 和 TIFF。需要时更改文件扩展名并设置 `ImageFormat` 即可。 | +| **图像尺寸有没有上限？** | 技术上可以达到数千像素，但尺寸过大可能耗尽内存。超高分辨率输出建议采用分块渲染。 | +| **如何处理打印质量图像的 DPI？** | 设置 `renderingOptions.DpiX` 和 `renderingOptions.DpiY`（默认 96）。更高的 DPI 能在打印时提供更清晰的效果。 | +| **使用 Aspose.HTML 是否需要许可证？** | 免费评估版会带水印。正式生产环境请购买许可证以去除水印并解锁全部功能。 | + +## 后续步骤与相关主题 + +- **将 HTML 转换为 JPEG** —— 更换文件扩展名，并可选地设置 `renderingOptions.ImageFormat = ImageFormat.Jpeg`。 +- **批量处理** —— 循环遍历 URL 列表，为每个页面生成缩略图。 +- **嵌入字体** —— 学习在标记中使用 `@font-face` 以实现完美排版。 +- **高级布局** —— 试验 `PageSize`、`Margin` 和 `BackgroundColor` 选项，打造自定义外观。 + +随意调整尺寸、尝试不同的 HTML 片段，或将此代码片段集成到提供 PNG 预览的 Web API 中。只要掌握了 **如何程序化渲染 HTML**，想象力就是唯一的限制。 + +--- + + + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/czech/net/html-extensions-and-conversions/_index.md b/html/czech/net/html-extensions-and-conversions/_index.md index 75faac1c40..126b1601d8 100644 --- a/html/czech/net/html-extensions-and-conversions/_index.md +++ b/html/czech/net/html-extensions-and-conversions/_index.md @@ -113,6 +113,8 @@ Naučte se pomocí Aspose.HTML v C# uložit celou webovou stránku do jediného Naučte se pomocí Aspose.HTML pro .NET vytvořit vlastní handler zdrojů pro kompresi HTML do ZIP v C#. ### [Aspose HTML možnosti uložení: Uložení HTML do streamu v C#](./aspose-html-save-options-save-html-to-stream-in-c/) Naučte se, jak pomocí Aspose.HTML pro .NET uložit HTML do streamu v C# s podrobným průvodcem a ukázkami kódu. +### [Jak použít handler v Aspose.HTML – načíst HTML a uložit jako ZIP](./how-to-use-handler-in-aspose-html-load-html-save-as-zip/) +Naučte se pomocí Aspose.HTML načíst HTML dokument a uložit jej do ZIP archivu pomocí handleru v C#. ## Závěr diff --git a/html/czech/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md b/html/czech/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md new file mode 100644 index 0000000000..e5143a698a --- /dev/null +++ b/html/czech/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md @@ -0,0 +1,182 @@ +--- +category: general +date: 2026-02-25 +description: Jak použít handler k načtení HTML z URL a uložit webovou stránku jako + ZIP pomocí Aspose.HTML – kompletní krok‑za‑krokem průvodce v C#. +draft: false +keywords: +- how to use handler +- load html from url +- custom resource handler +- save webpage as zip +- create zip from html +language: cs +og_description: jak použít handler k načtení HTML z URL a uložit webovou stránku jako + zip pomocí Aspose.HTML. Naučte se kompletní workflow v C# během několika minut. +og_title: Jak používat handler v Aspose.HTML – načíst HTML, uložit jako ZIP +tags: +- Aspose.HTML +- C# +- Web Scraping +title: Jak použít handler v Aspose.HTML – načíst HTML, uložit jako ZIP +url: /cs/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# jak použít handler v Aspose.HTML – načíst HTML, uložit jako ZIP + +Už jste se někdy zamysleli **jak použít handler** při načítání webové stránky do vaší .NET aplikace? Možná jste zkusili `HtmlDocument.Open` a získali HTML, ale obrázky, CSS a fonty zmizely. To je častý problém – zdroje se ztratí, pokud Aspose.HTML neřeknete, co s nimi má dělat. + +V tomto tutoriálu si projdeme načtení HTML z URL, nastavení **vlastního resource handleru** a nakonec **uložení webové stránky jako zip**, takže získáte jeden přenosný archiv. Na konci budete mít připravený C# úryvek, který můžete vložit do libovolného projektu, a několik tipů, které vám později ušetří spoustu starostí. + +## Co budete potřebovat + +- .NET 6+ (API funguje také na .NET Core a .NET Framework) +- Aspose.HTML for .NET (NuGet balíček `Aspose.HTML`) +- Základní zkušenost s C# (budete v pohodě, pokud jste už někdy napsali `Console.WriteLine`) + +Žádné další nástroje, žádné externí služby – jen knihovna a URL, kterou chcete archivovat. + + + +## Krok 1: Načíst HTML z URL + +Prvním krokem v jakémkoli procesu web‑scrapingu je získání zdrojového kódu stránky. Aspose.HTML to dokáže jedním řádkem, ale pamatujte, že **načítáme html z url** pomocí vestavěného síťového zásobníku. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +// 1️⃣ Load the page you want to archive +HtmlDocument htmlDoc = new HtmlDocument(); +htmlDoc.Open("https://example.com"); // replace with any public URL +``` + +> **Proč je to důležité:** `HtmlDocument.Open` parsuje markup *a* interně řeší relativní URL, ale automaticky neukládá externí assety. Proto později potřebujeme handler. + +## Krok 2: Vytvořit vlastní Resource Handler + +Nyní přichází jádro věci – **jak použít handler** k zachycení každého požadavku na externí zdroj (obrázky, CSS, fonty atd.). Děděním z `ResourceHandler` získáte plnou kontrolu nad streamem, který poskytuje každý asset. + +```csharp +// 2️⃣ Define your own handler (optional but powerful) +public class MyResourceHandler : ResourceHandler +{ + // Called for each external resource the document needs + public override Stream HandleResource(ResourceInfo info) + { + // Here you could download the file, cache it, or rewrite it. + // For this demo we simply return an empty stream – Aspose will + // still create the entry in the ZIP, keeping the folder structure. + return new MemoryStream(); + } +} +``` + +> **Pro tip:** V produkčním scénáři můžete chtít stáhnout skutečné bajty (`HttpClient.GetStreamAsync(info.Uri)`) a vrátit ten stream. Tím zajistíte, že uložený ZIP bude obsahovat skutečné obrázky místo prázdných zástupců. + +## Krok 3: Nakonfigurovat možnosti uložení a připojit handler + +S připraveným handlerem řekneme Aspose.HTML, jak má vše zabalit. Třída `HtmlSaveOptions` umožňuje přepnout přepínač `SaveToZipArchive` a připojit váš `MyResourceHandler`. + +```csharp +// 3️⃣ Set up saving options – this is where we **save webpage as zip** +HtmlSaveOptions saveOptions = new HtmlSaveOptions +{ + // Attach our custom handler – new API as of v22.10 + OutputStorage = new MyResourceHandler(), + + // Instruct Aspose to bundle HTML + resources into a single ZIP file + SaveToZipArchive = true +}; +``` + +> **Vysvětlení:** `OutputStorage` je vlastnost, která přijímá instanci handleru. Když saver prochází DOM, volá `HandleResource` pro každý externí odkaz. Protože je `SaveToZipArchive` nastaveno na true, saver zapisuje každý vrácený stream do ZIP položky odpovídající původní cestě. + +## Krok 4: Uložit dokument do Memory Stream + +Můžeme zapisovat přímo na disk, ale udržení všeho v paměti činí kód použitelným v ASP.NET, Azure Functions nebo kdekoliv, kde nechcete dočasný soubor. Zde je poslední krok, který **vytvoří zip z html**. + +```csharp +// 4️⃣ Save everything – HTML + resources – into a MemoryStream +using (MemoryStream outputStream = new MemoryStream()) +{ + htmlDoc.Save(outputStream, saveOptions); + + // At this point outputStream holds a valid ZIP archive. + // For demo purposes we write it to the file system: + File.WriteAllBytes("example_page.zip", outputStream.ToArray()); +} +``` + +### Očekávaný výsledek + +- `example_page.zip` se objeví ve složce vašeho projektu. +- V ZIPu najdete `index.html` plus strukturu složek (`images/`, `css/`, atd.). +- I když náš demo handler vrátil prázdné streamy, rozložení ZIPu odráží původní stránku – ideální pro pozdější výměnu za skutečný downloader. + +## Běžné varianty a okrajové případy + +### Načtení lokálního souboru místo URL +Pokud potřebujete **načíst html z url**‑like cesty na disku, stačí nahradit `htmlDoc.Open("https://example.com")` za `htmlDoc.Open(@"C:\path\to\file.html")`. Zbytek pipeline zůstane stejný. + +### Ukládání skutečných zdrojů +Pro skutečné vložení obrázků upravte `HandleResource`: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Download the resource using HttpClient + HttpClient client = new HttpClient(); + var data = client.GetByteArrayAsync(info.Uri).Result; + return new MemoryStream(data); +} +``` + +> **Upozornění:** Síťová volání uvnitř handleru blokují ukládací vlákno; u velkých stránek zvažte asynchronní handler (k dispozici v novějších verzích Aspose). + +### Změna názvů ZIP položek +`ResourceInfo` obsahuje `FileName` a `Path`. Můžete je přepsat, abyste zploštili hierarchii nebo přidali prefix: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Example: prepend "assets/" to every entry + info.Path = Path.Combine("assets", info.Path); + return base.HandleResource(info); +} +``` + +### Použití jiného Output Storage +`OutputStorage` může být také `FileSystemStorage`, pokud dáváte přednost složce místo ZIPu. Stačí nastavit `SaveToZipArchive = false` a nasměrovat `OutputStorage` na cestu ke složce. + +## Profesionální tipy a úskalí + +- **Nezapomeňte uvolnit** (`dispose`) `HtmlDocument`, pokud otevíráte mnoho stránek ve smyčce; jinak můžete uniknout nativním zdrojům. +- **Spotřeba paměti:** Ukládání obrovských stránek do `MemoryStream` může nafouknout RAM. Pro archivy o velikosti několika megabajtů raději streamujte přímo do souboru (`FileStream`). +- **Kódování znaků:** Aspose.HTML respektuje tag ``. Pokud zdrojová stránka používá neobvyklé kódování, ověřte, že výsledné HTML se po extrakci správně vykresluje. +- **Testování:** Otevřete vygenerovaný ZIP v prohlížeči (přetáhněte `index.html` ven), abyste se ujistili, že všechny zdroje jsou dostupné. Pokud chybí obrázky, váš `HandleResource` pravděpodobně vrátil prázdný stream. + +## Shrnutí + +Probrali jsme **jak použít handler** k zachycení externích zdrojů, ukázali **načítání html z url**, vytvořili **vlastní resource handler** a nakonec **uložili webovou stránku jako zip** – efektivně **vytvořili zip z html** pomocí několika řádků C#. Tento vzor je škálovatelný: vyměňte prázdný `MemoryStream` za skutečný downloader, změňte cíl výstupu nebo vložte logiku do webového API, které ZIP vrací na vyžádání. + +--- + +### Co dál? + +- **Dávkové zpracování:** Procházet seznam URL a generovat ZIP pro každou stránku. +- **Úpravy komprese:** Použít `ZipSaveOptions` k nastavení úrovně komprese pro rychlejší stahování. +- **Integrace s ASP.NET Core:** Vrátit `MemoryStream` jako `FileResult`, aby si uživatelé mohli archiv stáhnout přímo z webového endpointu. +- **Prozkoumejte další funkce Aspose.HTML:** Konverze do PDF, manipulace s DOM nebo headless rendering. + +Máte otázky k konkrétnímu případu – třeba potřebujete zachovat JavaScript nebo řešit stránky chráněné autentizací? Zanechte komentář níže; rád se ponořím hlouběji. Šťastné kódování! + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/czech/net/rendering-html-documents/_index.md b/html/czech/net/rendering-html-documents/_index.md index c2f88f8ea3..7ceeccf0f5 100644 --- a/html/czech/net/rendering-html-documents/_index.md +++ b/html/czech/net/rendering-html-documents/_index.md @@ -52,6 +52,9 @@ Kompletní návod v C#, jak pomocí Aspose.HTML převést HTML soubory do formá Naučte se, jak pomocí Aspose.HTML v C# převést HTML do obrázku. Kompletní průvodce krok za krokem. ### [Jak použít Aspose k vykreslení HTML do PNG v C#](./how-to-use-aspose-to-render-html-to-png-in-c/) Naučte se, jak pomocí Aspose.HTML v C# převést HTML soubory do PNG formátu. Praktické ukázky a tipy pro rychlé vykreslení. +### [Jak vykreslit HTML jako PNG v C# – krok za krokem](./how-to-render-html-as-png-in-c-step-by-step-guide/) +Kompletní průvodce v C#, který ukazuje, jak převést HTML do PNG pomocí Aspose.HTML krok po kroku. + ### [Renderujte EPUB jako XPS v .NET pomocí Aspose.HTML](./render-epub-as-xps/) V tomto komplexním kurzu se dozvíte, jak vytvářet a vykreslovat dokumenty HTML pomocí Aspose.HTML for .NET. Ponořte se do světa HTML manipulace, web scraping a další. diff --git a/html/czech/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md b/html/czech/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..db64f91a1b --- /dev/null +++ b/html/czech/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md @@ -0,0 +1,222 @@ +--- +category: general +date: 2026-02-25 +description: Jak renderovat HTML jako PNG v C# pomocí Aspose.HTML. Naučte se převádět + HTML na obrázek, uložit HTML jako PNG a rychle vytvořit PNG z HTML. +draft: false +keywords: +- how to render html +- convert html to image +- save html as png +- create png from html +- generate png from html +language: cs +og_description: Jak renderovat HTML jako PNG v C# s Aspose.HTML. Sledujte tento tutoriál, + jak převést HTML na obrázek, uložit HTML jako PNG a vygenerovat PNG z HTML. +og_title: Jak renderovat HTML jako PNG v C# – Kompletní průvodce +tags: +- C# +- Aspose.HTML +- Image Rendering +title: Jak renderovat HTML jako PNG v C# – krok za krokem průvodce +url: /cs/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Jak v C# vykreslit HTML jako PNG – krok za krokem + +Už jste se někdy zamýšleli **jak vykreslit HTML** přímo do souboru PNG bez používání prohlížeče? Možná potřebujete vložit malý snímek webové stránky do e‑mailu, nebo budujete službu pro tvorbu miniatur pro CMS. V každém případě jde o převod značkovacího jazyka na bitmapu, kterou můžete uložit nebo naservírovat. + +V tomto tutoriálu uvidíte kompletní, připravené řešení, které **převádí HTML na obrázek** pomocí Aspose.HTML pro .NET. Dotkneme se také toho, **jak uložit HTML jako PNG**, **vytvořit PNG z HTML** a dokonce **generovat PNG z HTML** s vlastními fonty a rozměry. Žádné vágní odkazy – jen kód, který můžete zkopírovat‑vložit, a vysvětlení, proč je každý řádek důležitý. + +## Co budete potřebovat + +- .NET 6 (nebo jakékoli novější .NET runtime) – API funguje stejně i na .NET Framework 4.6+. +- Visual Studio 2022 nebo VS Code – podle toho, co preferujete. +- NuGet balíček **Aspose.HTML** (`Aspose.HTML.NET`) – nainstalujete jednou a máte hotovo. +- Zapisovatelná složka pro výstupní PNG (např. `C:\Temp\Images`). + +A to je vše. Žádné další binární soubory, žádné externí webové služby a žádné skryté konfigurační soubory. + +## Krok 1: Instalace Aspose.HTML přes NuGet + +Nejprve přidejte knihovnu do svého projektu. Otevřete terminál ve složce řešení a spusťte: + +```bash +dotnet add package Aspose.HTML.NET +``` + +*Tip:* Pokud pracujete ve Visual Studiu, klikněte pravým tlačítkem na **Dependencies → Manage NuGet Packages**, vyhledejte „Aspose.HTML“ a klikněte na **Install**. Získáte tak přístup ke třídám `HtmlDocument`, `ImageRenderingOptions` a dalším, které použijeme. + +## Krok 2: Nastavení možností vykreslování (velikost, styl a fonty) + +Než předáme jakýkoli markup rendereru, rozhodneme, jak velký obrázek má být a které styly fontů chceme zachovat. Objekt `ImageRenderingOptions` vám umožní upravit šířku, výšku a dokonce vynutit vykreslení tučného/kurzívního textu. + +```csharp +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +// Configure image rendering options – width, height, and font style +ImageRenderingOptions renderingOptions = new ImageRenderingOptions +{ + Width = 800, // Desired image width in pixels + Height = 600, // Desired image height in pixels + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic // Preserve bold & italic +}; +``` + +**Proč je to důležité:** +- **Width/Height** určují konečné rozměry v pixelech; pokud je vynecháte, engine odhadne velikost podle HTML rozvržení, což může vést k neočekávanému oříznutí. +- **FontStyle** zajišťuje, že značky `` nebo `` si zachovají vizuální důraz při rasterizaci. + +## Krok 3: Načtení vašeho HTML markupu + +HTML můžete načíst ze řetězce, souboru nebo URL. Pro jednoduchost vložíme malý úryvek přímo do kódu. Všimněte si inline CSS, který nastavuje rodinu fontů – Aspose.HTML respektuje standardní webové CSS, takže získáte věrné vykreslení. + +```csharp +using Aspose.Html; + +// Create an empty HTML document +HtmlDocument htmlDoc = new HtmlDocument(); + +// Load simple markup – you could also use htmlDoc.Open("path/to/file.html") +htmlDoc.Open("Hello, world!
"); +``` + +**Tip pro okrajové případy:** Pokud váš markup odkazuje na externí zdroje (obrázky, CSS soubory), ujistěte se, že jsou URL přístupné z počítače, na kterém kód běží, nebo je vložte jako data‑URI, aby nedošlo k rozbitým odkazům. + +## Krok 4: Vykreslení HTML do PNG proudu + +Nyní přichází jádro **jak vykreslit HTML** – zavoláme `RenderToStream`, předáme výstupní stream a možnosti, které jsme nakonfigurovali dříve. Metoda provede veškerou těžkou práci: rozvržení, CSS kaskádu, substituci fontů a rasterizaci. + +```csharp +using System.IO; + +// Choose an output path – replace with your own directory +string outputPath = @"C:\Temp\Images\output.png"; + +using (FileStream outputStream = File.OpenWrite(outputPath)) +{ + // Render the HTML document into the PNG file + htmlDoc.RenderToStream(outputStream, renderingOptions); +} +``` + +Po ukončení bloku `using` bude soubor `output.png` obsahovat obrázek 800 × 600 pixelů odstavce, který jsme načetli. Otevřete jej libovolným **prohlížečem obrázků** a ověřte výsledek. + +### Očekávaný výsledek + +Měli byste vidět čisté bílé plátno s textem **„Hello, world!“** vykresleným v Arial, tučným a kurzívním, přesně 24 pt. Rozměry obrázku odpovídají nastaveným hodnotám 800 × 600. + +## Krok 5: Ověření a řešení běžných problémů + +### 5.1 Kontrola existence souboru + +Rychlá kontrola zabraňuje tichým selháním: + +```csharp +if (File.Exists(outputPath)) +{ + Console.WriteLine($"✅ PNG created successfully at {outputPath}"); +} +else +{ + Console.WriteLine("❌ Something went wrong – PNG not found."); +} +``` + +### 5.2 Řešení chybějících fontů + +Pokud cílový počítač nemá požadovaný font, Aspose.HTML přejde na generický sans‑serif. Pro zajištění konzistence můžete: + +- Vložit soubor fontu pomocí pravidla `@font-face` ve vašem HTML, **nebo** +- Zaregistrovat font programově před vykreslením. + +```csharp +// Example of registering a custom TrueType font +htmlDoc.Fonts.AddFontFile(@"C:\Fonts\OpenSans-Regular.ttf"); +``` + +### 5.3 Vykreslování velkých stránek + +Při tvorbě miniatur pro celé stránky sledujte využití paměti. Můžete obrázek po vykreslení zmenšit, nebo nastavit `renderingOptions.Width`/`Height` na menší hodnoty a nechat Aspose.HTML provést škálování. + +## Kompletní funkční příklad + +Níže je kompletní program, který můžete vložit do konzolové aplikace a spustit okamžitě. + +```csharp +// ----------------------------------------------------------- +// How to render HTML as PNG – Complete, runnable example +// ----------------------------------------------------------- +using System; +using System.IO; +using Aspose.Html; +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +class Program +{ + static void Main() + { + // 1️⃣ Configure rendering options + ImageRenderingOptions renderingOptions = new ImageRenderingOptions + { + Width = 800, + Height = 600, + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic + }; + + // 2️⃣ Load HTML markup + HtmlDocument htmlDoc = new HtmlDocument(); + htmlDoc.Open("Hello, world!
"); + + // 3️⃣ Define output path + string outputPath = @"C:\Temp\Images\output.png"; + + // 4️⃣ Render to PNG + using (FileStream outputStream = File.OpenWrite(outputPath)) + { + htmlDoc.RenderToStream(outputStream, renderingOptions); + } + + // 5️⃣ Verify the result + Console.WriteLine(File.Exists(outputPath) + ? $"✅ PNG saved at {outputPath}" + : "❌ Failed to create PNG"); + } +} +``` + +Spusťte program (`dotnet run`) a poté otevřete `C:\Temp\Images\output.png`. Pokud vše proběhlo hladce, právě jste **převáděli HTML na obrázek** a **ukládali HTML jako PNG** pomocí čistého C# kódu. + +## Často kladené otázky + +| Otázka | Odpověď | +|----------|--------| +| **Mohu vykreslit celou webovou stránku s externím CSS/JS?** | Ano – stačí zavolat `htmlDoc.Open("https://example.com")`. Engine stáhne propojené zdroje, ale potřebujete síťové připojení. | +| **Jaké formáty jsou kromě PNG podporovány?** | `ImageRenderingOptions` funguje s JPEG, BMP, GIF a TIFF. Změňte příponu souboru a nastavte `ImageFormat`, pokud je potřeba. | +| **Existuje limit velikosti obrázku?** | Technicky můžete jít až na několik tisíc pixelů, ale velmi velké rozměry mohou vyčerpávat paměť. Zvažte vykreslování po částech (tiles) pro ultra‑vysoké rozlišení. | +| **Jak nastavit DPI pro tiskové kvality?** | Nastavte `renderingOptions.DpiX` a `renderingOptions.DpiY` (výchozí je 96). Vyšší DPI poskytuje ostřejší výstup pro tisk. | +| **Potřebuji licenci na Aspose.HTML?** | Bezplatná evaluační verze funguje s vodoznakem. Pro produkci zakupte licenci, která vodoznak odstraní a odemkne všechny funkce. | + +## Další kroky a související témata + +- **Převod HTML na JPEG** – změňte příponu souboru a volitelně nastavte `renderingOptions.ImageFormat = ImageFormat.Jpeg`. +- **Dávkové zpracování** – projděte seznam URL a pro každou vygenerujte miniaturu. +- **Vkládání fontů** – naučte se používat `@font-face` ve vašem markupu pro dokonalou typografii. +- **Pokročilé rozvržení** – experimentujte s možnostmi `PageSize`, `Margin` a `BackgroundColor` pro vlastní vzhled. + +Klidně upravujte rozměry, zkoušejte různé HTML úryvky nebo integrujte tento úryvek do webového API, které na požádání poskytuje PNG náhledy. Možnosti jsou neomezené, když víte **jak programově vykreslit HTML**. + +--- + + + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/dutch/net/html-extensions-and-conversions/_index.md b/html/dutch/net/html-extensions-and-conversions/_index.md index aececa26e3..41c4e98b02 100644 --- a/html/dutch/net/html-extensions-and-conversions/_index.md +++ b/html/dutch/net/html-extensions-and-conversions/_index.md @@ -113,6 +113,8 @@ Leer hoe u HTML opslaat als ZIP-bestand in C# met Aspose.HTML. Volg onze stapsge ### [HTML opslaan als ZIP in C# – Complete gids](./save-html-to-zip-in-c-complete-guide/) Leer hoe u HTML naar een ZIP-bestand opslaat met een volledige C#-handleiding en Aspose.HTML voor .NET. ### [Enkel bestand HTML – Een webpagina opslaan als één HTML-bestand in C#](./single-file-html-save-a-web-page-as-one-html-file-in-c/) +### [Hoe handler te gebruiken in Aspose.HTML – HTML laden, opslaan als ZIP](./how-to-use-handler-in-aspose-html-load-html-save-as-zip/) +Leer hoe u een handler gebruikt om HTML te laden en vervolgens op te slaan als ZIP-bestand met Aspose.HTML voor .NET. ## Conclusie diff --git a/html/dutch/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md b/html/dutch/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md new file mode 100644 index 0000000000..962c1e187d --- /dev/null +++ b/html/dutch/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md @@ -0,0 +1,182 @@ +--- +category: general +date: 2026-02-25 +description: Hoe je een handler gebruikt om HTML van een URL te laden en de webpagina + als zip op te slaan met Aspose.HTML – een complete C# stap‑voor‑stap gids. +draft: false +keywords: +- how to use handler +- load html from url +- custom resource handler +- save webpage as zip +- create zip from html +language: nl +og_description: hoe je handler gebruikt om HTML van een URL te laden en de webpagina + als zip op te slaan met Aspose.HTML. Leer de volledige C#‑workflow in enkele minuten. +og_title: hoe je een handler gebruikt in Aspose.HTML – HTML laden, opslaan als ZIP +tags: +- Aspose.HTML +- C# +- Web Scraping +title: hoe gebruik je handler in Aspose.HTML – HTML laden, opslaan als ZIP +url: /nl/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# how to use handler in Aspose.HTML – Load HTML, Save as ZIP + +Heb je je ooit afgevraagd **hoe je een handler gebruikt** bij het ophalen van een webpagina in je .NET‑applicatie? Misschien heb je `HtmlDocument.Open` geprobeerd en kreeg je de HTML, maar verdwenen de afbeeldingen, CSS en lettertypen in het niets. Dat is een veelvoorkomend probleem—bronnen gaan verloren tenzij je Aspose.HTML vertelt wat ermee te doen. + +In deze tutorial lopen we stap voor stap door het laden van HTML vanaf een URL, het opzetten van een **aangepaste resource‑handler**, en uiteindelijk **het opslaan van de webpagina als zip** zodat je één draagbaar archief krijgt. Aan het einde heb je een kant‑klaar C#‑fragment dat je in elk project kunt plakken, plus een aantal tips die je later hoofdpijn besparen. + +## What You’ll Need + +- .NET 6+ (de API werkt ook op .NET Core en .NET Framework) +- Aspose.HTML for .NET (NuGet‑pakket `Aspose.HTML`) +- Een bescheiden hoeveelheid C#‑ervaring (je bent in orde als je eerder een `Console.WriteLine` hebt geschreven) + +Geen extra tools, geen externe services—alleen de bibliotheek en een URL die je wilt archiveren. + + + +## Stap 1: HTML laden vanaf URL + +Het eerste in elke web‑scraping‑flow is het ophalen van de paginabron. Aspose.HTML maakt dit een één‑regel‑code, maar onthoud dat we **html laden vanaf url** met de ingebouwde netwerkmogelijkheid. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +// 1️⃣ Load the page you want to archive +HtmlDocument htmlDoc = new HtmlDocument(); +htmlDoc.Open("https://example.com"); // replace with any public URL +``` + +> **Waarom dit belangrijk is:** `HtmlDocument.Open` parseert de markup *en* lost relatieve URL’s intern op, maar het slaat de externe assets niet automatisch op. Daarom hebben we later een handler nodig. + +## Stap 2: Een aangepaste resource‑handler maken + +Nu komt het hart van de zaak—**hoe je een handler gebruikt** om elk extern resource‑verzoek (afbeeldingen, CSS, lettertypen, enz.) af te vangen. Door `ResourceHandler` te subklassen krijg je volledige controle over de stream die elke asset ondersteunt. + +```csharp +// 2️⃣ Define your own handler (optional but powerful) +public class MyResourceHandler : ResourceHandler +{ + // Called for each external resource the document needs + public override Stream HandleResource(ResourceInfo info) + { + // Here you could download the file, cache it, or rewrite it. + // For this demo we simply return an empty stream – Aspose will + // still create the entry in the ZIP, keeping the folder structure. + return new MemoryStream(); + } +} +``` + +> **Pro tip:** In een productie‑scenario wil je misschien de daadwerkelijke bytes downloaden (`HttpClient.GetStreamAsync(info.Uri)`) en die stream teruggeven. Zo bevat de opgeslagen ZIP de echte afbeeldingen in plaats van lege placeholders. + +## Stap 3: Opslagopties configureren en de handler koppelen + +Met de handler klaar, vertellen we Aspose.HTML hoe alles te verpakken. De klasse `HtmlSaveOptions` laat je de schakelaar `SaveToZipArchive` omzetten en je `MyResourceHandler` aansluiten. + +```csharp +// 3️⃣ Set up saving options – this is where we **save webpage as zip** +HtmlSaveOptions saveOptions = new HtmlSaveOptions +{ + // Attach our custom handler – new API as of v22.10 + OutputStorage = new MyResourceHandler(), + + // Instruct Aspose to bundle HTML + resources into a single ZIP file + SaveToZipArchive = true +}; +``` + +> **Uitleg:** `OutputStorage` is de eigenschap die de handler‑instantie ontvangt. Wanneer de saver door de DOM loopt, roept hij `HandleResource` aan voor elke externe link. Omdat `SaveToZipArchive` true is, schrijft de saver elke teruggegeven stream naar een ZIP‑item met het oorspronkelijke pad. + +## Stap 4: Het document opslaan in een Memory Stream + +We zouden direct naar schijf kunnen schrijven, maar alles in het geheugen houden maakt de code bruikbaar in ASP.NET, Azure Functions, of elke omgeving waar je geen tijdelijk bestand wilt. Hier is de laatste stap die **zip maakt van html**. + +```csharp +// 4️⃣ Save everything – HTML + resources – into a MemoryStream +using (MemoryStream outputStream = new MemoryStream()) +{ + htmlDoc.Save(outputStream, saveOptions); + + // At this point outputStream holds a valid ZIP archive. + // For demo purposes we write it to the file system: + File.WriteAllBytes("example_page.zip", outputStream.ToArray()); +} +``` + +### Verwacht resultaat + +- `example_page.zip` verschijnt in je projectmap. +- In de ZIP vind je `index.html` plus een mapstructuur (`images/`, `css/`, enz.). +- Ook al gaf onze demo‑handler lege streams terug, de ZIP‑structuur spiegelt de originele pagina—perfect om later een echte downloader in te voegen. + +## Veelvoorkomende variaties & randgevallen + +### Een lokaal bestand laden in plaats van een URL +Als je **html laden vanaf url**‑achtige paden op schijf nodig hebt, vervang dan `htmlDoc.Open("https://example.com")` door `htmlDoc.Open(@"C:\path\to\file.html")`. De rest van de pijplijn blijft identiek. + +### Werkelijke bronnen behouden +Om daadwerkelijk afbeeldingen in te sluiten, wijzig `HandleResource`: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Download the resource using HttpClient + HttpClient client = new HttpClient(); + var data = client.GetByteArrayAsync(info.Uri).Result; + return new MemoryStream(data); +} +``` + +> **Let op:** Netwerk‑aanroepen binnen de handler blokkeren de opslaathread; overweeg voor grote pagina’s de handler asynchroon te maken (beschikbaar in nieuwere Aspose‑releases). + +### De namen van ZIP‑items wijzigen +`ResourceInfo` bevat `FileName` en `Path`. Je kunt ze herschrijven om de hiërarchie te flattenen of een prefix toe te voegen: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Example: prepend "assets/" to every entry + info.Path = Path.Combine("assets", info.Path); + return base.HandleResource(info); +} +``` + +### Een andere opslag gebruiken +`OutputStorage` kan ook een `FileSystemStorage` zijn als je een map in plaats van een ZIP wilt. Zet gewoon `SaveToZipArchive = false` en wijs `OutputStorage` naar een directory‑pad. + +## Pro‑tips & valkuilen + +- **Vergeet niet te disposen** de `HtmlDocument` als je veel pagina’s in een lus opent; anders lekken native resources. +- **Geheugengebruik:** Het opslaan van enorme pagina’s in een `MemoryStream` kan RAM doen groeien. Voor multi‑megabyte archieven, stream direct naar een bestand (`FileStream`) in plaats daarvan. +- **Tekencodering:** Aspose.HTML respecteert de ``‑tag. Als de bronpagina een ongebruikelijke codering gebruikt, controleer dan of de resulterende HTML correct rendert na extractie. +- **Testen:** Open de gegenereerde ZIP in een browser (sleep `index.html` eruit) om te verifiëren dat alle resources worden gevonden. Als afbeeldingen ontbreken, heeft je `HandleResource` waarschijnlijk een lege stream teruggegeven. + +## Samenvatting + +We hebben **hoe je een handler gebruikt** om externe resources af te vangen, **html laden vanaf url** gedemonstreerd, een **aangepaste resource‑handler** gebouwd, en tenslotte **webpagina opslaan als zip**—effectief **zip maken van html** met een handvol C#‑regels. Het patroon schaalt: vervang de lege `MemoryStream` door een echte downloader, wijzig het output‑doel, of embed de logica in een web‑API die de ZIP op aanvraag teruggeeft. + +--- + +### Wat is het vervolg? + +- **Batchverwerking:** Loop over een lijst van URL’s en genereer een ZIP per pagina. +- **Compressie‑aanpassingen:** Gebruik `ZipSaveOptions` om het compressieniveau aan te passen voor snellere downloads. +- **Integratie met ASP.NET Core:** Retourneer de `MemoryStream` als een `FileResult` zodat gebruikers het archief direct van een web‑endpoint kunnen downloaden. +- **Verken andere Aspose.HTML‑functies:** PDF‑conversie, DOM‑manipulatie, of headless rendering. + +Heb je vragen over een specifiek gebruiksscenario—misschien wil je JavaScript behouden of pagina’s met authenticatie‑bescherming verwerken? Laat een reactie achter; ik duik graag dieper in. Veel programmeerplezier! + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/dutch/net/rendering-html-documents/_index.md b/html/dutch/net/rendering-html-documents/_index.md index 7dae7326b7..a4efba8841 100644 --- a/html/dutch/net/rendering-html-documents/_index.md +++ b/html/dutch/net/rendering-html-documents/_index.md @@ -49,6 +49,8 @@ Leer hoe u HTML naar PNG kunt renderen in C# met Aspose.HTML. Volg deze volledig Leer stap voor stap hoe u HTML naar PNG converteert met C# en Aspose.HTML in deze volledige gids. ### [HTML renderen naar PNG – Complete C#-gids](./how-to-render-html-to-png-complete-c-guide/) Leer hoe u HTML naar PNG kunt renderen met een volledige C#-handleiding in Aspose.HTML voor .NET. +### [HTML als PNG renderen in C# – Stapsgewijze gids](./how-to-render-html-as-png-in-c-step-by-step-guide/) +Leer stap voor stap hoe u HTML naar PNG rendert in C# met Aspose.HTML. ### [EPUB renderen als XPS in .NET met Aspose.HTML](./render-epub-as-xps/) Leer hoe u HTML-documenten kunt maken en renderen met Aspose.HTML voor .NET in deze uitgebreide tutorial. Duik in de wereld van HTML-manipulatie, webscraping en meer. diff --git a/html/dutch/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md b/html/dutch/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..04f75e359f --- /dev/null +++ b/html/dutch/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md @@ -0,0 +1,223 @@ +--- +category: general +date: 2026-02-25 +description: Hoe HTML renderen als PNG in C# met Aspose.HTML. Leer hoe je HTML naar + afbeelding converteert, HTML opslaat als PNG en snel een PNG van HTML maakt. +draft: false +keywords: +- how to render html +- convert html to image +- save html as png +- create png from html +- generate png from html +language: nl +og_description: Hoe HTML renderen als PNG in C# met Aspose.HTML. Volg deze tutorial + om HTML naar afbeelding te converteren, HTML op te slaan als PNG en PNG te genereren + vanuit HTML. +og_title: Hoe HTML als PNG renderen in C# – Complete gids +tags: +- C# +- Aspose.HTML +- Image Rendering +title: Hoe HTML renderen als PNG in C# – Stapsgewijze handleiding +url: /nl/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Hoe HTML te renderen als PNG in C# – Stapsgewijze gids + +Heb je je ooit afgevraagd **hoe je HTML** rechtstreeks naar een PNG‑bestand kunt renderen zonder een browser te gebruiken? Misschien moet je een klein momentopname van een webpagina in een e‑mail invoegen, of bouw je een thumbnail‑service voor een CMS. Hoe dan ook, het probleem draait om het omzetten van markup naar een bitmap die je kunt opslaan of serveren. + +In deze tutorial zie je een volledige, kant‑en‑klaar oplossing die **HTML naar afbeelding** converteert met Aspose.HTML voor .NET. We behandelen ook hoe je **HTML opslaat als PNG**, **PNG maakt vanuit HTML**, en zelfs **PNG genereert vanuit HTML** met aangepaste lettertypen en afmetingen. Geen vage verwijzingen—alleen de code die je kunt copy‑pasten, plus uitleg waarom elke regel belangrijk is. + +## Wat je nodig hebt + +- .NET 6 (of een recente .NET‑runtime) – de API werkt hetzelfde op .NET Framework 4.6+. +- Visual Studio 2022 of VS Code – wat je maar prefereert. +- Het **Aspose.HTML** NuGet‑pakket (`Aspose.HTML.NET`) – installeer het één keer en je bent klaar. +- Een schrijfbare map voor de uitvoer‑PNG (bijv. `C:\Temp\Images`). + +Dat is alles. Geen extra binaries, geen externe webservices en geen verborgen configuratiebestanden. + +## Stap 1: Installeer Aspose.HTML via NuGet + +Voeg eerst de bibliotheek toe aan je project. Open de terminal in je solution‑map en voer uit: + +```bash +dotnet add package Aspose.HTML.NET +``` + +*Pro tip:* Als je Visual Studio gebruikt, klik met de rechtermuisknop op **Dependencies → Manage NuGet Packages**, zoek naar “Aspose.HTML” en klik op **Install**. Hiermee krijg je toegang tot `HtmlDocument`, `ImageRenderingOptions` en andere klassen die we gaan gebruiken. + +## Stap 2: Stel renderopties in (grootte, stijl en lettertypen) + +Voordat we enige markup aan de renderer geven, bepalen we hoe groot de afbeelding moet worden en welke lettertype‑stijlen we willen behouden. Het `ImageRenderingOptions`‑object laat je breedte, hoogte en zelfs geforceerde vet/italic‑rendering aanpassen. + +```csharp +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +// Configure image rendering options – width, height, and font style +ImageRenderingOptions renderingOptions = new ImageRenderingOptions +{ + Width = 800, // Desired image width in pixels + Height = 600, // Desired image height in pixels + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic // Preserve bold & italic +}; +``` + +**Waarom dit belangrijk is:** +- **Width/Height** bepalen de uiteindelijke pixelafmetingen; als je ze weglaten, raadt de engine de afmetingen op basis van de HTML‑layout, wat kan leiden tot onverwachte bijsnijdingen. +- **FontStyle** zorgt ervoor dat ``‑ of ``‑tags hun visuele nadruk behouden bij rasteren. + +## Stap 3: Laad je HTML‑markup + +Je kunt HTML laden vanuit een string, een bestand of een URL. Voor de eenvoud embedden we een klein fragment direct in de code. Let op de inline‑CSS die het lettertype instelt – Aspose.HTML respecteert standaard web‑CSS, dus je krijgt een getrouwe weergave. + +```csharp +using Aspose.Html; + +// Create an empty HTML document +HtmlDocument htmlDoc = new HtmlDocument(); + +// Load simple markup – you could also use htmlDoc.Open("path/to/file.html") +htmlDoc.Open("Hello, world!
"); +``` + +**Edge‑case tip:** Als je markup externe bronnen (afbeeldingen, CSS‑bestanden) verwijst, zorg er dan voor dat die URL’s bereikbaar zijn vanaf de machine die de code uitvoert, of embed ze als data‑URI’s om gebroken links te vermijden. + +## Stap 4: Render de HTML naar een PNG‑stream + +Nu volgt de kern van **hoe je HTML rendert** – we roepen `RenderToStream` aan, geven de output‑stream en de eerder geconfigureerde opties mee. De methode doet al het zware werk: layout, CSS‑cascade, lettertype‑substitutie en rasteren. + +```csharp +using System.IO; + +// Choose an output path – replace with your own directory +string outputPath = @"C:\Temp\Images\output.png"; + +using (FileStream outputStream = File.OpenWrite(outputPath)) +{ + // Render the HTML document into the PNG file + htmlDoc.RenderToStream(outputStream, renderingOptions); +} +``` + +Na het einde van het `using`‑blok bevat `output.png` een afbeelding van 800 × 600 pixel van de alinea die we geladen hebben. Open het met een willekeurige afbeeldingsviewer om het resultaat te verifiëren. + +### Verwacht resultaat + +Je zou een schoon wit canvas moeten zien met de tekst **“Hello, world!”** gerenderd in Arial, vet en cursief, precies 24 pt groot. De afbeeldingsafmetingen komen overeen met de 800 × 600‑waarden die we hebben ingesteld. + +## Stap 5: Verifieer en behandel veelvoorkomende valkuilen + +### 5.1 Controleren of het bestand bestaat + +Een snelle sanity‑check voorkomt stille fouten: + +```csharp +if (File.Exists(outputPath)) +{ + Console.WriteLine($"✅ PNG created successfully at {outputPath}"); +} +else +{ + Console.WriteLine("❌ Something went wrong – PNG not found."); +} +``` + +### 5.2 Omgaan met ontbrekende lettertypen + +Als de doelmachine het gevraagde lettertype niet heeft, valt Aspose.HTML terug op een generiek sans‑serif. Om consistentie te garanderen, kun je: + +- Het lettertype‑bestand embedden met een `@font-face`‑regel in je HTML, **of** +- Het lettertype programmatically registreren vóór het renderen. + +```csharp +// Example of registering a custom TrueType font +htmlDoc.Fonts.AddFontFile(@"C:\Fonts\OpenSans-Regular.ttf"); +``` + +### 5.3 Grote pagina’s renderen + +Wanneer je thumbnails maakt van volledige pagina‑screenshots, houd dan het geheugenverbruik in de gaten. Je kunt na het renderen downscalen, of `renderingOptions.Width`/`Height` op een kleinere waarde zetten en Aspose.HTML de schaal laten uitvoeren. + +## Volledig werkend voorbeeld + +Hieronder staat het complete programma dat je in een console‑applicatie kunt plakken en direct kunt uitvoeren. + +```csharp +// ----------------------------------------------------------- +// How to render HTML as PNG – Complete, runnable example +// ----------------------------------------------------------- +using System; +using System.IO; +using Aspose.Html; +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +class Program +{ + static void Main() + { + // 1️⃣ Configure rendering options + ImageRenderingOptions renderingOptions = new ImageRenderingOptions + { + Width = 800, + Height = 600, + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic + }; + + // 2️⃣ Load HTML markup + HtmlDocument htmlDoc = new HtmlDocument(); + htmlDoc.Open("Hello, world!
"); + + // 3️⃣ Define output path + string outputPath = @"C:\Temp\Images\output.png"; + + // 4️⃣ Render to PNG + using (FileStream outputStream = File.OpenWrite(outputPath)) + { + htmlDoc.RenderToStream(outputStream, renderingOptions); + } + + // 5️⃣ Verify the result + Console.WriteLine(File.Exists(outputPath) + ? $"✅ PNG saved at {outputPath}" + : "❌ Failed to create PNG"); + } +} +``` + +Voer het programma uit (`dotnet run`) en open vervolgens `C:\Temp\Images\output.png`. Als alles soepel verliep, heb je zojuist **HTML naar afbeelding** geconverteerd en **HTML als PNG** opgeslagen met pure C#‑code. + +## Veelgestelde vragen + +| Vraag | Antwoord | +|----------|--------| +| **Kan ik een volledige webpagina met externe CSS/JS renderen?** | Ja – roep simpelweg `htmlDoc.Open("https://example.com")` aan. De engine downloadt gekoppelde bronnen, maar je hebt wel netwerktoegang nodig. | +| **Welke formaten worden naast PNG ondersteund?** | `ImageRenderingOptions` werkt met JPEG, BMP, GIF en TIFF. Verander de bestandsextensie en stel `ImageFormat` in indien nodig. | +| **Is er een limiet aan de afbeeldingsgrootte?** | Technisch kun je tot enkele duizenden pixels gaan, maar zeer grote afmetingen kunnen het geheugen uitputten. Overweeg om in tegels te renderen voor ultra‑high‑res output. | +| **Hoe ga ik om met DPI voor print‑kwaliteit afbeeldingen?** | Stel `renderingOptions.DpiX` en `renderingOptions.DpiY` in (standaard is 96). Een hogere DPI levert scherpere output voor afdrukken op. | +| **Heb ik een licentie nodig voor Aspose.HTML?** | Een gratis evaluatie werkt met een watermerk. Voor productie koop je een licentie om het watermerk te verwijderen en alle functies te ontgrendelen. | + +## Volgende stappen en gerelateerde onderwerpen + +- **HTML naar JPEG converteren** – wijzig de bestandsextensie en stel eventueel `renderingOptions.ImageFormat = ImageFormat.Jpeg` in. +- **Batchverwerking** – loop over een lijst met URL’s en genereer thumbnails voor elk. +- **Lettertypen embedden** – leer hoe je `@font-face` in je markup gebruikt voor perfecte typografie. +- **Geavanceerde layout** – experimenteer met `PageSize`, `Margin` en `BackgroundColor`‑opties voor aangepaste looks. + +Voel je vrij om de afmetingen aan te passen, verschillende HTML‑fragmenten te proberen, of dit fragment te integreren in een web‑API die PNG‑voorbeelden on‑the‑fly levert. De mogelijkheden zijn eindeloos zodra je **HTML programmatically kunt renderen**. + +--- + + + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/english/net/html-extensions-and-conversions/_index.md b/html/english/net/html-extensions-and-conversions/_index.md index aea6cd8c9d..9bab90ed9e 100644 --- a/html/english/net/html-extensions-and-conversions/_index.md +++ b/html/english/net/html-extensions-and-conversions/_index.md @@ -111,6 +111,8 @@ Learn how to save HTML content into a ZIP archive using C# and Aspose.HTML for . Learn how to save HTML content into a ZIP archive in memory using C# and Aspose.HTML for .NET in this step-by-step tutorial. ### [Aspose HTML Save Options: Save HTML to Stream in C#](./aspose-html-save-options-save-html-to-stream-in-c/) Learn how to save an HTML document directly to a stream using Aspose.HTML in C# with a clear, step-by-step tutorial. +### [how to use handler in Aspose.HTML – Load HTML, Save as ZIP](./how-to-use-handler-in-aspose-html-load-html-save-as-zip/) +Learn how to use a handler in Aspose.HTML to load HTML content and save it as a ZIP archive with step-by-step C# examples. ## Conclusion diff --git a/html/english/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md b/html/english/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md new file mode 100644 index 0000000000..c1d1cd12b9 --- /dev/null +++ b/html/english/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md @@ -0,0 +1,182 @@ +--- +category: general +date: 2026-02-25 +description: how to use handler to load html from url and save webpage as zip with + Aspose.HTML – a complete C# step‑by‑step guide. +draft: false +keywords: +- how to use handler +- load html from url +- custom resource handler +- save webpage as zip +- create zip from html +language: en +og_description: how to use handler to load html from url and save webpage as zip with + Aspose.HTML. Learn the complete C# workflow in minutes. +og_title: how to use handler in Aspose.HTML – Load HTML, Save as ZIP +tags: +- Aspose.HTML +- C# +- Web Scraping +title: how to use handler in Aspose.HTML – Load HTML, Save as ZIP +url: /net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# how to use handler in Aspose.HTML – Load HTML, Save as ZIP + +Ever wondered **how to use handler** when pulling a web page into your .NET app? Maybe you’ve tried `HtmlDocument.Open` and got the HTML, but the images, CSS, and fonts vanished into thin air. That’s a common snag—resources get lost unless you tell Aspose.HTML what to do with them. + +In this tutorial we’ll walk through loading HTML from a URL, wiring up a **custom resource handler**, and finally **save webpage as zip** so you end up with a single portable archive. By the end you’ll have a ready‑to‑run C# snippet that you can drop into any project, plus a handful of tips that save you headaches later. + +## What You’ll Need + +- .NET 6+ (the API works on .NET Core and .NET Framework as well) +- Aspose.HTML for .NET (NuGet package `Aspose.HTML`) +- A modest amount of C# experience (you’ll be fine if you’ve written a `Console.WriteLine` before) + +No extra tools, no external services—just the library and a URL you want to archive. + + + +## Step 1: Load HTML from URL + +The first thing in any web‑scraping flow is fetching the page source. Aspose.HTML makes this a one‑liner, but remember we’re **loading html from url** with the built‑in network stack. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +// 1️⃣ Load the page you want to archive +HtmlDocument htmlDoc = new HtmlDocument(); +htmlDoc.Open("https://example.com"); // replace with any public URL +``` + +> **Why this matters:** `HtmlDocument.Open` parses the markup *and* resolves relative URLs internally, but it doesn’t automatically persist the external assets. That’s why we need a handler later. + +## Step 2: Create a Custom Resource Handler + +Now comes the heart of the matter—**how to use handler** to intercept every external resource request (images, CSS, fonts, etc.). By subclassing `ResourceHandler` you gain full control over the stream that backs each asset. + +```csharp +// 2️⃣ Define your own handler (optional but powerful) +public class MyResourceHandler : ResourceHandler +{ + // Called for each external resource the document needs + public override Stream HandleResource(ResourceInfo info) + { + // Here you could download the file, cache it, or rewrite it. + // For this demo we simply return an empty stream – Aspose will + // still create the entry in the ZIP, keeping the folder structure. + return new MemoryStream(); + } +} +``` + +> **Pro tip:** In a production scenario you might want to download the actual bytes (`HttpClient.GetStreamAsync(info.Uri)`) and return that stream. This ensures the saved ZIP contains the real images instead of empty placeholders. + +## Step 3: Configure Save Options and Attach the Handler + +With the handler ready, we tell Aspose.HTML how to package everything. The `HtmlSaveOptions` class lets you flip the `SaveToZipArchive` switch and plug in your `MyResourceHandler`. + +```csharp +// 3️⃣ Set up saving options – this is where we **save webpage as zip** +HtmlSaveOptions saveOptions = new HtmlSaveOptions +{ + // Attach our custom handler – new API as of v22.10 + OutputStorage = new MyResourceHandler(), + + // Instruct Aspose to bundle HTML + resources into a single ZIP file + SaveToZipArchive = true +}; +``` + +> **Explanation:** `OutputStorage` is the property that receives the handler instance. When the saver walks the DOM it calls `HandleResource` for each external link. Because `SaveToZipArchive` is true, the saver writes each returned stream into a ZIP entry matching the original path. + +## Step 4: Save the Document into a Memory Stream + +We could write straight to disk, but keeping everything in memory makes the code usable in ASP.NET, Azure Functions, or any place where you don’t want a temporary file. Here’s the final step that **creates zip from html**. + +```csharp +// 4️⃣ Save everything – HTML + resources – into a MemoryStream +using (MemoryStream outputStream = new MemoryStream()) +{ + htmlDoc.Save(outputStream, saveOptions); + + // At this point outputStream holds a valid ZIP archive. + // For demo purposes we write it to the file system: + File.WriteAllBytes("example_page.zip", outputStream.ToArray()); +} +``` + +### Expected Result + +- `example_page.zip` appears in your project folder. +- Inside the ZIP you’ll find `index.html` plus a folder structure (`images/`, `css/`, etc.). +- Even though our demo handler returned empty streams, the ZIP layout mirrors the original page—perfect for swapping in a real downloader later. + +## Common Variations & Edge Cases + +### Loading a Local File Instead of a URL +If you need to **load html from url**‑like paths on disk, just replace `htmlDoc.Open("https://example.com")` with `htmlDoc.Open(@"C:\path\to\file.html")`. The rest of the pipeline stays identical. + +### Persisting Real Resources +To actually embed images, modify `HandleResource`: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Download the resource using HttpClient + HttpClient client = new HttpClient(); + var data = client.GetByteArrayAsync(info.Uri).Result; + return new MemoryStream(data); +} +``` + +> **Caution:** Network calls inside the handler block the saving thread; for large pages consider making the handler asynchronous (available in newer Aspose releases). + +### Changing the ZIP Entry Names +`ResourceInfo` contains `FileName` and `Path`. You can rewrite them to flatten the hierarchy or add a prefix: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Example: prepend "assets/" to every entry + info.Path = Path.Combine("assets", info.Path); + return base.HandleResource(info); +} +``` + +### Using a Different Output Storage +`OutputStorage` can also be a `FileSystemStorage` if you prefer a folder instead of a ZIP. Just set `SaveToZipArchive = false` and point `OutputStorage` to a directory path. + +## Pro Tips & Pitfalls + +- **Don't forget to dispose** the `HtmlDocument` if you open many pages in a loop; otherwise you may leak native resources. +- **Memory usage:** Saving huge pages into a `MemoryStream` can balloon RAM. For multi‑megabyte archives, stream directly to a file (`FileStream`) instead. +- **Character encoding:** Aspose.HTML respects the `` tag. If the source page uses an uncommon encoding, verify the resulting HTML renders correctly after extraction. +- **Testing:** Open the generated ZIP in a browser (drag `index.html` out) to ensure all resources resolve. If images are missing, your `HandleResource` likely returned an empty stream. + +## Recap + +We’ve covered **how to use handler** to intercept external resources, demonstrated **load html from url**, built a **custom resource handler**, and finally **save webpage as zip**—effectively **create zip from html** with a handful of lines of C#. The pattern scales: swap the empty `MemoryStream` for a real downloader, change the output target, or embed the logic in a web API that returns the ZIP on demand. + +--- + +### What’s Next? + +- **Batch processing:** Loop over a list of URLs and generate a ZIP per page. +- **Compression tweaks:** Use `ZipSaveOptions` to adjust compression level for faster downloads. +- **Integration with ASP.NET Core:** Return the `MemoryStream` as a `FileResult` so users can download the archive directly from a web endpoint. +- **Explore other Aspose.HTML features:** PDF conversion, DOM manipulation, or headless rendering. + +Got questions about a specific use case—maybe you need to preserve JavaScript or handle authentication‑protected pages? Drop a comment below; I’ll be happy to dive deeper. Happy coding! + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/english/net/rendering-html-documents/_index.md b/html/english/net/rendering-html-documents/_index.md index f71f869b4c..68afbd0d8d 100644 --- a/html/english/net/rendering-html-documents/_index.md +++ b/html/english/net/rendering-html-documents/_index.md @@ -48,6 +48,8 @@ Step-by-step guide to rendering HTML to PNG using Aspose.HTML for .NET, covering Step-by-step C# guide to render HTML pages as PNG images using Aspose.HTML for .NET, covering setup, options, and best practices! ### [How to Use Aspose to Render HTML to PNG – Step‑by‑Step Guide](./how-to-use-aspose-to-render-html-to-png-step-by-step-guide/) Step by step guide to render HTML to PNG using Aspose.HTML for .NET. Learn the process, code examples, and best practices. +### [How to render HTML as PNG in C# – Step‑by‑Step Guide](./how-to-render-html-as-png-in-c-step-by-step-guide/) +Step‑by‑step C# guide to render HTML pages as PNG images using Aspose.HTML for .NET, covering setup, options, and best practices. ### [How to Render HTML to PNG with Aspose – Complete Guide](./how-to-render-html-to-png-with-aspose-complete-guide/) Comprehensive guide to render HTML to PNG using Aspose.HTML for .NET. Includes code examples and best practices. ### [Create PNG from HTML – Full C# Rendering Guide](./create-png-from-html-full-c-rendering-guide/) diff --git a/html/english/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md b/html/english/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..e04c80485a --- /dev/null +++ b/html/english/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md @@ -0,0 +1,222 @@ +--- +category: general +date: 2026-02-25 +description: How to render HTML as PNG in C# using Aspose.HTML. Learn to convert HTML + to image, save HTML as PNG, and create PNG from HTML quickly. +draft: false +keywords: +- how to render html +- convert html to image +- save html as png +- create png from html +- generate png from html +language: en +og_description: How to render HTML as PNG in C# with Aspose.HTML. Follow this tutorial + to convert HTML to image, save HTML as PNG, and generate PNG from HTML. +og_title: How to render HTML as PNG in C# – Complete Guide +tags: +- C# +- Aspose.HTML +- Image Rendering +title: How to render HTML as PNG in C# – Step‑by‑Step Guide +url: /net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# How to render HTML as PNG in C# – Step‑by‑Step Guide + +Ever wondered **how to render HTML** straight to a PNG file without juggling a browser? Maybe you need to embed a tiny snapshot of a webpage in an email, or you’re building a thumbnail service for a CMS. Either way, the problem boils down to turning markup into a bitmap you can store or serve. + +In this tutorial you’ll see a complete, ready‑to‑run solution that **converts HTML to image** using Aspose.HTML for .NET. We’ll also touch on how to **save HTML as PNG**, **create PNG from HTML**, and even **generate PNG from HTML** with custom fonts and dimensions. No vague references—just the code you can copy‑paste, plus explanations of why each line matters. + +## What You’ll Need + +- .NET 6 (or any recent .NET runtime) – the API works the same on .NET Framework 4.6+. +- Visual Studio 2022 or VS Code – whichever you prefer. +- The **Aspose.HTML** NuGet package (`Aspose.HTML.NET`) – install it once and you’re set. +- A writable folder for the output PNG (e.g., `C:\Temp\Images`). + +That’s it. No extra binaries, no external web services, and no hidden configuration files. + +## Step 1: Install Aspose.HTML via NuGet + +First, add the library to your project. Open the terminal in your solution folder and run: + +```bash +dotnet add package Aspose.HTML.NET +``` + +*Pro tip:* If you’re in Visual Studio, right‑click **Dependencies → Manage NuGet Packages**, search for “Aspose.HTML”, and click **Install**. This gives you access to the `HtmlDocument`, `ImageRenderingOptions`, and other classes we’ll use. + +## Step 2: Set Up Rendering Options (size, style, and fonts) + +Before we feed any markup to the renderer, we decide how big the picture should be and which font styles we want to preserve. The `ImageRenderingOptions` object lets you tweak width, height, and even force bold/italic rendering. + +```csharp +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +// Configure image rendering options – width, height, and font style +ImageRenderingOptions renderingOptions = new ImageRenderingOptions +{ + Width = 800, // Desired image width in pixels + Height = 600, // Desired image height in pixels + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic // Preserve bold & italic +}; +``` + +**Why this matters:** +- **Width/Height** determine the final pixel dimensions; if you omit them the engine guesses based on the HTML layout, which can lead to unexpected cropping. +- **FontStyle** ensures that any `` or `` tags keep their visual emphasis when rasterized. + +## Step 3: Load Your HTML Markup + +You can load HTML from a string, a file, or a URL. For the sake of simplicity, we’ll embed a tiny snippet directly in code. Notice the inline CSS that sets the font family – Aspose.HTML respects standard web CSS, so you get a faithful rendering. + +```csharp +using Aspose.Html; + +// Create an empty HTML document +HtmlDocument htmlDoc = new HtmlDocument(); + +// Load simple markup – you could also use htmlDoc.Open("path/to/file.html") +htmlDoc.Open("Hello, world!
"); +``` + +**Edge case tip:** If your markup references external resources (images, CSS files), make sure those URLs are reachable from the machine running the code, or embed them as data‑URIs to avoid broken links. + +## Step 4: Render the HTML to a PNG Stream + +Now comes the core of **how to render HTML** – we call `RenderToStream`, passing the output stream and the options we configured earlier. The method does all the heavy lifting: layout, CSS cascade, font substitution, and rasterization. + +```csharp +using System.IO; + +// Choose an output path – replace with your own directory +string outputPath = @"C:\Temp\Images\output.png"; + +using (FileStream outputStream = File.OpenWrite(outputPath)) +{ + // Render the HTML document into the PNG file + htmlDoc.RenderToStream(outputStream, renderingOptions); +} +``` + +After the `using` block finishes, `output.png` will contain a 800 × 600 pixel image of the paragraph we loaded. Open it with any image viewer to verify the result. + +### Expected Result + +You should see a clean white canvas with the text **“Hello, world!”** rendered in Arial, bold and italic, exactly 24 pt in size. The image dimensions match the 800 × 600 values we set. + +## Step 5: Verify and Handle Common Pitfalls + +### 5.1 Checking the File Exists + +A quick sanity check prevents silent failures: + +```csharp +if (File.Exists(outputPath)) +{ + Console.WriteLine($"✅ PNG created successfully at {outputPath}"); +} +else +{ + Console.WriteLine("❌ Something went wrong – PNG not found."); +} +``` + +### 5.2 Dealing with Missing Fonts + +If the target machine lacks the requested font, Aspose.HTML falls back to a generic sans‑serif. To guarantee consistency, either: + +- Embed the font file using a `@font-face` rule in your HTML, **or** +- Register the font programmatically before rendering. + +```csharp +// Example of registering a custom TrueType font +htmlDoc.Fonts.AddFontFile(@"C:\Fonts\OpenSans-Regular.ttf"); +``` + +### 5.3 Rendering Large Pages + +When creating thumbnails for full‑page screenshots, keep an eye on memory usage. You can downscale after rendering, or set `renderingOptions.Width`/`Height` to a smaller size and let Aspose.HTML handle the scaling. + +## Full Working Example + +Below is the complete program you can drop into a console application and run immediately. + +```csharp +// ----------------------------------------------------------- +// How to render HTML as PNG – Complete, runnable example +// ----------------------------------------------------------- +using System; +using System.IO; +using Aspose.Html; +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +class Program +{ + static void Main() + { + // 1️⃣ Configure rendering options + ImageRenderingOptions renderingOptions = new ImageRenderingOptions + { + Width = 800, + Height = 600, + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic + }; + + // 2️⃣ Load HTML markup + HtmlDocument htmlDoc = new HtmlDocument(); + htmlDoc.Open("Hello, world!
"); + + // 3️⃣ Define output path + string outputPath = @"C:\Temp\Images\output.png"; + + // 4️⃣ Render to PNG + using (FileStream outputStream = File.OpenWrite(outputPath)) + { + htmlDoc.RenderToStream(outputStream, renderingOptions); + } + + // 5️⃣ Verify the result + Console.WriteLine(File.Exists(outputPath) + ? $"✅ PNG saved at {outputPath}" + : "❌ Failed to create PNG"); + } +} +``` + +Run the program (`dotnet run`), then open `C:\Temp\Images\output.png`. If everything went smoothly, you’ve just **converted HTML to image** and **saved HTML as PNG** using pure C# code. + +## Frequently Asked Questions + +| Question | Answer | +|----------|--------| +| **Can I render a full webpage with external CSS/JS?** | Yes – just call `htmlDoc.Open("https://example.com")`. The engine will download linked resources, but you need network access. | +| **What formats are supported besides PNG?** | `ImageRenderingOptions` works with JPEG, BMP, GIF, and TIFF. Change the file extension and set `ImageFormat` if needed. | +| **Is there a limit on image size?** | Technically you can go up to several thousand pixels, but very large dimensions may exhaust memory. Consider rendering in tiles for ultra‑high‑res output. | +| **How do I handle DPI for print‑quality images?** | Set `renderingOptions.DpiX` and `renderingOptions.DpiY` (default is 96). Higher DPI yields sharper output for printing. | +| **Do I need a license for Aspose.HTML?** | A free evaluation works with a watermark. For production, purchase a license to remove it and unlock full features. | + +## Next Steps and Related Topics + +- **Convert HTML to JPEG** – swap the file extension and optionally set `renderingOptions.ImageFormat = ImageFormat.Jpeg`. +- **Batch processing** – loop over a list of URLs and generate thumbnails for each. +- **Embedding fonts** – learn how to use `@font-face` inside your markup for perfect typography. +- **Advanced layout** – experiment with `PageSize`, `Margin`, and `BackgroundColor` options for custom looks. + +Feel free to tweak the dimensions, try different HTML snippets, or integrate this snippet into a web API that serves PNG previews on the fly. The sky’s the limit when you know **how to render HTML** programmatically. + +--- + + + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/french/net/html-extensions-and-conversions/_index.md b/html/french/net/html-extensions-and-conversions/_index.md index c68da760cf..35abc7a3a8 100644 --- a/html/french/net/html-extensions-and-conversions/_index.md +++ b/html/french/net/html-extensions-and-conversions/_index.md @@ -118,6 +118,8 @@ Apprenez à générer un PDF à partir de HTML en C# avec un guide détaillé é Apprenez à sauvegarder un document HTML dans une archive ZIP en C# avec Aspose.HTML, grâce à un guide détaillé pas à pas. ### [Comment zipper du HTML en C# – Tutoriel sur le gestionnaire de ressources personnalisé](./how-to-zip-html-in-c-custom-resource-handler-tutorial/) Apprenez à zipper du HTML en C# en utilisant un gestionnaire de ressources personnalisé avec Aspose.HTML pour .NET. +### [Comment utiliser le gestionnaire dans Aspose.HTML – Charger le HTML, enregistrer en ZIP](./how-to-use-handler-in-aspose-html-load-html-save-as-zip/) +Apprenez à charger un document HTML et à l’enregistrer dans un fichier ZIP en utilisant le gestionnaire d’Aspose.HTML. ## Conclusion diff --git a/html/french/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md b/html/french/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md new file mode 100644 index 0000000000..42f55988e8 --- /dev/null +++ b/html/french/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md @@ -0,0 +1,186 @@ +--- +category: general +date: 2026-02-25 +description: Comment utiliser le gestionnaire pour charger le HTML depuis une URL + et enregistrer la page Web au format zip avec Aspose.HTML – un guide complet C# + étape par étape. +draft: false +keywords: +- how to use handler +- load html from url +- custom resource handler +- save webpage as zip +- create zip from html +language: fr +og_description: Comment utiliser le gestionnaire pour charger du HTML depuis une URL + et enregistrer la page Web en zip avec Aspose.HTML. Apprenez le flux de travail + complet en C# en quelques minutes. +og_title: Comment utiliser le gestionnaire dans Aspose.HTML – Charger le HTML, enregistrer + en ZIP +tags: +- Aspose.HTML +- C# +- Web Scraping +title: Comment utiliser le gestionnaire dans Aspose.HTML – Charger le HTML, enregistrer + en ZIP +url: /fr/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# comment utiliser le gestionnaire dans Aspose.HTML – Charger du HTML, enregistrer en ZIP + +Vous vous êtes déjà demandé **comment utiliser le gestionnaire** lorsque vous récupérez une page web dans votre application .NET ? Peut‑être avez‑vous essayé `HtmlDocument.Open` et obtenu le HTML, mais les images, le CSS et les polices ont disparu. C’est un problème fréquent — les ressources sont perdues à moins d’indiquer à Aspose.HTML quoi en faire. + +Dans ce tutoriel, nous allons charger du HTML depuis une URL, brancher un **gestionnaire de ressources personnalisé**, puis **enregistrer la page web en zip** afin d’obtenir une archive portable unique. À la fin, vous disposerez d’un extrait C# prêt à l’emploi que vous pourrez insérer dans n’importe quel projet, ainsi que de quelques astuces pour éviter les maux de tête plus tard. + +## Ce dont vous avez besoin + +- .NET 6+ (l’API fonctionne également sur .NET Core et .NET Framework) +- Aspose.HTML for .NET (package NuGet `Aspose.HTML`) +- Un minimum d’expérience en C# (vous vous débrouillerez si vous avez déjà écrit un `Console.WriteLine`) + +Aucun outil supplémentaire, aucun service externe — juste la bibliothèque et une URL que vous souhaitez archiver. + + + +## Étape 1 : Charger le HTML depuis une URL + +La première chose dans tout flux de scraping web est de récupérer le code source de la page. Aspose.HTML le fait en une seule ligne, mais n’oubliez pas que nous **chargeons le html depuis une url** avec la pile réseau intégrée. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +// 1️⃣ Load the page you want to archive +HtmlDocument htmlDoc = new HtmlDocument(); +htmlDoc.Open("https://example.com"); // replace with any public URL +``` + +> **Pourquoi c’est important :** `HtmlDocument.Open` analyse le balisage *et* résout les URL relatives en interne, mais il ne persiste pas automatiquement les actifs externes. C’est pourquoi nous aurons besoin d’un gestionnaire plus tard. + +## Étape 2 : Créer un gestionnaire de ressources personnalisé + +Voici le cœur du sujet — **comment utiliser le gestionnaire** pour intercepter chaque requête de ressource externe (images, CSS, polices, etc.). En sous‑classant `ResourceHandler`, vous obtenez le contrôle total du flux qui alimente chaque actif. + +```csharp +// 2️⃣ Define your own handler (optional but powerful) +public class MyResourceHandler : ResourceHandler +{ + // Called for each external resource the document needs + public override Stream HandleResource(ResourceInfo info) + { + // Here you could download the file, cache it, or rewrite it. + // For this demo we simply return an empty stream – Aspose will + // still create the entry in the ZIP, keeping the folder structure. + return new MemoryStream(); + } +} +``` + +> **Astuce pro :** Dans un scénario de production, vous voudrez peut‑être télécharger les octets réels (`HttpClient.GetStreamAsync(info.Uri)`) et renvoyer ce flux. Ainsi, le ZIP enregistré contiendra les vraies images au lieu de simples espaces réservés vides. + +## Étape 3 : Configurer les options d’enregistrement et attacher le gestionnaire + +Une fois le gestionnaire prêt, nous indiquons à Aspose.HTML comment empaqueter le tout. La classe `HtmlSaveOptions` vous permet d’activer le commutateur `SaveToZipArchive` et de brancher votre `MyResourceHandler`. + +```csharp +// 3️⃣ Set up saving options – this is where we **save webpage as zip** +HtmlSaveOptions saveOptions = new HtmlSaveOptions +{ + // Attach our custom handler – new API as of v22.10 + OutputStorage = new MyResourceHandler(), + + // Instruct Aspose to bundle HTML + resources into a single ZIP file + SaveToZipArchive = true +}; +``` + +> **Explication :** `OutputStorage` est la propriété qui reçoit l’instance du gestionnaire. Lorsque le sauvegardeur parcourt le DOM, il appelle `HandleResource` pour chaque lien externe. Comme `SaveToZipArchive` est vrai, le sauvegardeur écrit chaque flux retourné dans une entrée ZIP correspondant au chemin d’origine. + +## Étape 4 : Enregistrer le document dans un flux mémoire + +Nous pourrions écrire directement sur le disque, mais garder tout en mémoire rend le code réutilisable dans ASP.NET, Azure Functions ou tout autre contexte où l’on ne veut pas de fichier temporaire. Voici l’étape finale qui **crée un zip à partir du html**. + +```csharp +// 4️⃣ Save everything – HTML + resources – into a MemoryStream +using (MemoryStream outputStream = new MemoryStream()) +{ + htmlDoc.Save(outputStream, saveOptions); + + // At this point outputStream holds a valid ZIP archive. + // For demo purposes we write it to the file system: + File.WriteAllBytes("example_page.zip", outputStream.ToArray()); +} +``` + +### Résultat attendu + +- `example_page.zip` apparaît dans le dossier de votre projet. +- À l’intérieur du ZIP, vous trouverez `index.html` ainsi qu’une structure de dossiers (`images/`, `css/`, etc.). +- Même si notre gestionnaire de démonstration a renvoyé des flux vides, la structure du ZIP reflète la page originale — prête à être remplacée par un vrai téléchargeur plus tard. + +## Variantes courantes et cas limites + +### Charger un fichier local au lieu d’une URL +Si vous devez **charger le html depuis une url**‑type chemins sur disque, remplacez simplement `htmlDoc.Open("https://example.com")` par `htmlDoc.Open(@"C:\path\to\file.html")`. Le reste du pipeline reste identique. + +### Persister les vraies ressources +Pour réellement incorporer les images, modifiez `HandleResource` : + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Download the resource using HttpClient + HttpClient client = new HttpClient(); + var data = client.GetByteArrayAsync(info.Uri).Result; + return new MemoryStream(data); +} +``` + +> **Attention :** Les appels réseau à l’intérieur du gestionnaire bloquent le fil d’exécution d’enregistrement ; pour les pages volumineuses, envisagez de rendre le gestionnaire asynchrone (disponible dans les versions récentes d’Aspose). + +### Modifier les noms des entrées ZIP +`ResourceInfo` contient `FileName` et `Path`. Vous pouvez les réécrire pour aplatir la hiérarchie ou ajouter un préfixe : + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Example: prepend "assets/" to every entry + info.Path = Path.Combine("assets", info.Path); + return base.HandleResource(info); +} +``` + +### Utiliser un autre stockage de sortie +`OutputStorage` peut également être un `FileSystemStorage` si vous préférez un dossier plutôt qu’un ZIP. Il suffit de définir `SaveToZipArchive = false` et de pointer `OutputStorage` vers un chemin de répertoire. + +## Astuces pro & pièges à éviter + +- **N’oubliez pas de libérer** le `HtmlDocument` si vous ouvrez de nombreuses pages dans une boucle ; sinon vous risquez de fuir des ressources natives. +- **Utilisation de la mémoire :** Enregistrer de très grandes pages dans un `MemoryStream` peut gonfler la RAM. Pour des archives de plusieurs mégaoctets, écrivez directement dans un fichier (`FileStream`). +- **Encodage des caractères :** Aspose.HTML respecte la balise ``. Si la page source utilise un encodage rare, vérifiez que le HTML résultant s’affiche correctement après extraction. +- **Tests :** Ouvrez le ZIP généré dans un navigateur (glissez `index.html` hors du ZIP) pour vous assurer que toutes les ressources se résolvent. Si des images manquent, votre `HandleResource` a probablement renvoyé un flux vide. + +## Récapitulatif + +Nous avons vu **comment utiliser le gestionnaire** pour intercepter les ressources externes, démontré **le chargement du html depuis une url**, construit un **gestionnaire de ressources personnalisé**, puis **enregistré la page web en zip** — c’est‑à‑dire **créer un zip à partir du html** avec quelques lignes de C#. Le modèle est extensible : remplacez le `MemoryStream` vide par un vrai téléchargeur, changez la cible de sortie, ou intégrez la logique dans une API web qui renvoie le ZIP à la demande. + +--- + +### Et après ? + +- **Traitement par lots :** Parcourez une liste d’URL et générez un ZIP par page. +- **Ajustements de compression :** Utilisez `ZipSaveOptions` pour modifier le niveau de compression et accélérer les téléchargements. +- **Intégration avec ASP.NET Core :** Retournez le `MemoryStream` comme un `FileResult` afin que les utilisateurs puissent télécharger l’archive directement depuis un point de terminaison web. +- **Explorez les autres fonctionnalités d’Aspose.HTML :** Conversion PDF, manipulation du DOM ou rendu sans tête. + +Des questions sur un cas d’utilisation particulier — peut‑être devez‑vous préserver le JavaScript ou gérer des pages protégées par authentification ? Laissez un commentaire ci‑dessous ; je serai ravi d’approfondir. Bon codage ! + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/french/net/rendering-html-documents/_index.md b/html/french/net/rendering-html-documents/_index.md index 1ab0284fcc..9204ab2f94 100644 --- a/html/french/net/rendering-html-documents/_index.md +++ b/html/french/net/rendering-html-documents/_index.md @@ -96,6 +96,9 @@ Apprenez à générer des images à partir de HTML en C# avec Aspose.HTML grâce ### [Rendre HTML au format PDF avec Aspose.HTML – Guide étape par étape](./render-html-to-pdf-with-aspose-html-step-by-step-guide/) Apprenez à convertir du HTML en PDF avec Aspose.HTML pour .NET grâce à ce guide complet étape par étape. +### [Comment rendre le HTML au format PNG en C# – Guide étape par étape](./how-to-render-html-as-png-in-c-step-by-step-guide/) +Apprenez à convertir du HTML en images PNG en C# grâce à ce guide détaillé étape par étape. + {{< /blocks/products/pf/tutorial-page-section >}} {{< /blocks/products/pf/main-container >}} diff --git a/html/french/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md b/html/french/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..a5ec2e53c2 --- /dev/null +++ b/html/french/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md @@ -0,0 +1,224 @@ +--- +category: general +date: 2026-02-25 +description: Comment rendre du HTML en PNG en C# avec Aspose.HTML. Apprenez à convertir + du HTML en image, à enregistrer du HTML au format PNG et à créer rapidement un PNG + à partir du HTML. +draft: false +keywords: +- how to render html +- convert html to image +- save html as png +- create png from html +- generate png from html +language: fr +og_description: Comment rendre le HTML en PNG en C# avec Aspose.HTML. Suivez ce tutoriel + pour convertir le HTML en image, enregistrer le HTML au format PNG et générer un + PNG à partir du HTML. +og_title: Comment rendre du HTML en PNG en C# – Guide complet +tags: +- C# +- Aspose.HTML +- Image Rendering +title: Comment rendre du HTML en PNG en C# – Guide étape par étape +url: /fr/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Comment rendre du HTML en PNG en C# – Guide étape par étape + +Vous vous êtes déjà demandé **comment rendre du HTML** directement en fichier PNG sans passer par un navigateur ? Peut-être devez‑vous intégrer une petite capture d’écran d’une page web dans un e‑mail, ou vous créez un service de miniatures pour un CMS. Dans tous les cas, le problème se résume à transformer du balisage en une image bitmap que vous pouvez stocker ou diffuser. + +Dans ce tutoriel, vous verrez une solution complète, prête à l’emploi, qui **convertit du HTML en image** en utilisant Aspose.HTML pour .NET. Nous aborderons également comment **enregistrer du HTML en PNG**, **créer un PNG à partir de HTML**, et même **générer un PNG à partir de HTML** avec des polices et des dimensions personnalisées. Pas de références vagues — juste le code que vous pouvez copier‑coller, ainsi que des explications sur l’importance de chaque ligne. + +## Ce dont vous avez besoin + +- .NET 6 (ou tout runtime .NET récent) – l’API fonctionne de la même façon sur .NET Framework 4.6+. +- Visual Studio 2022 ou VS Code – selon votre préférence. +- Le package NuGet **Aspose.HTML** (`Aspose.HTML.NET`) – installez‑le une fois et vous êtes prêt. +- Un dossier accessible en écriture pour le PNG de sortie (par ex. `C:\Temp\Images`). + +C’est tout. Aucun binaire supplémentaire, aucun service web externe, et aucun fichier de configuration caché. + +## Étape 1 : Installer Aspose.HTML via NuGet + +Tout d’abord, ajoutez la bibliothèque à votre projet. Ouvrez le terminal dans le dossier de votre solution et exécutez : + +```bash +dotnet add package Aspose.HTML.NET +``` + +*Astuce :* Si vous êtes dans Visual Studio, faites un clic droit sur **Dependencies → Manage NuGet Packages**, recherchez “Aspose.HTML”, et cliquez sur **Install**. Cela vous donne accès aux classes `HtmlDocument`, `ImageRenderingOptions`, et autres que nous utiliserons. + +## Étape 2 : Configurer les options de rendu (taille, style et polices) + +Avant d’alimenter le moteur avec du balisage, nous décidons de la taille de l’image et des styles de police que nous souhaitons conserver. L’objet `ImageRenderingOptions` vous permet d’ajuster la largeur, la hauteur, et même d’imposer le rendu en gras/italique. + +```csharp +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +// Configure image rendering options – width, height, and font style +ImageRenderingOptions renderingOptions = new ImageRenderingOptions +{ + Width = 800, // Desired image width in pixels + Height = 600, // Desired image height in pixels + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic // Preserve bold & italic +}; +``` + +**Pourquoi c’est important :** +- **Width/Height** déterminent les dimensions finales en pixels ; si vous les omettez, le moteur devine en fonction de la mise en page HTML, ce qui peut entraîner des découpes inattendues. +- **FontStyle** garantit que les balises `` ou `` conservent leur emphase visuelle lors du rastérisation. + +## Étape 3 : Charger votre balisage HTML + +Vous pouvez charger du HTML depuis une chaîne, un fichier ou une URL. Pour simplifier, nous intégrerons un petit extrait directement dans le code. Remarquez le CSS en ligne qui définit la famille de police — Aspose.HTML respecte le CSS web standard, vous obtenez ainsi un rendu fidèle. + +```csharp +using Aspose.Html; + +// Create an empty HTML document +HtmlDocument htmlDoc = new HtmlDocument(); + +// Load simple markup – you could also use htmlDoc.Open("path/to/file.html") +htmlDoc.Open("Hello, world!
"); +``` + +**Astuce pour les cas limites :** Si votre balisage fait référence à des ressources externes (images, fichiers CSS), assurez‑vous que ces URL soient accessibles depuis la machine exécutant le code, ou intégrez‑les sous forme de data‑URI pour éviter les liens brisés. + +## Étape 4 : Rendre le HTML vers un flux PNG + +Voici le cœur du **comment rendre du HTML** — nous appelons `RenderToStream`, en passant le flux de sortie et les options que nous avons configurées précédemment. La méthode effectue tout le travail lourd : mise en page, cascade CSS, substitution de polices, et rastérisation. + +```csharp +using System.IO; + +// Choose an output path – replace with your own directory +string outputPath = @"C:\Temp\Images\output.png"; + +using (FileStream outputStream = File.OpenWrite(outputPath)) +{ + // Render the HTML document into the PNG file + htmlDoc.RenderToStream(outputStream, renderingOptions); +} +``` + +Après la fin du bloc `using`, `output.png` contiendra une image de 800 × 600 pixels du paragraphe que nous avons chargé. Ouvrez‑la avec n’importe quel visualiseur d’images pour vérifier le résultat. + +### Résultat attendu + +Vous devriez voir un canevas blanc propre avec le texte **« Hello, world! »** rendu en Arial, gras et italique, exactement 24 pt de taille. Les dimensions de l’image correspondent aux valeurs 800 × 600 que nous avons définies. + +## Étape 5 : Vérifier et gérer les problèmes courants + +### 5.1 Vérification de l’existence du fichier + +Une vérification rapide évite les échecs silencieux : + +```csharp +if (File.Exists(outputPath)) +{ + Console.WriteLine($"✅ PNG created successfully at {outputPath}"); +} +else +{ + Console.WriteLine("❌ Something went wrong – PNG not found."); +} +``` + +### 5.2 Gestion des polices manquantes + +Si la machine cible ne possède pas la police demandée, Aspose.HTML revient à une police sans‑serif générique. Pour garantir la cohérence, soit : + +- Intégrer le fichier de police à l’aide d’une règle `@font-face` dans votre HTML, **ou** +- Enregistrer la police programmatique avant le rendu. + +```csharp +// Example of registering a custom TrueType font +htmlDoc.Fonts.AddFontFile(@"C:\Fonts\OpenSans-Regular.ttf"); +``` + +### 5.3 Rendu de pages volumineuses + +Lors de la création de miniatures pour des captures d’écran de pages complètes, surveillez l’utilisation de la mémoire. Vous pouvez réduire l’échelle après le rendu, ou définir `renderingOptions.Width`/`Height` à une taille plus petite et laisser Aspose.HTML gérer le redimensionnement. + +## Exemple complet fonctionnel + +Ci‑dessous se trouve le programme complet que vous pouvez placer dans une application console et exécuter immédiatement. + +```csharp +// ----------------------------------------------------------- +// How to render HTML as PNG – Complete, runnable example +// ----------------------------------------------------------- +using System; +using System.IO; +using Aspose.Html; +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +class Program +{ + static void Main() + { + // 1️⃣ Configure rendering options + ImageRenderingOptions renderingOptions = new ImageRenderingOptions + { + Width = 800, + Height = 600, + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic + }; + + // 2️⃣ Load HTML markup + HtmlDocument htmlDoc = new HtmlDocument(); + htmlDoc.Open("Hello, world!
"); + + // 3️⃣ Define output path + string outputPath = @"C:\Temp\Images\output.png"; + + // 4️⃣ Render to PNG + using (FileStream outputStream = File.OpenWrite(outputPath)) + { + htmlDoc.RenderToStream(outputStream, renderingOptions); + } + + // 5️⃣ Verify the result + Console.WriteLine(File.Exists(outputPath) + ? $"✅ PNG saved at {outputPath}" + : "❌ Failed to create PNG"); + } +} +``` + +Exécutez le programme (`dotnet run`), puis ouvrez `C:\Temp\Images\output.png`. Si tout s’est déroulé correctement, vous avez simplement **converti du HTML en image** et **enregistré du HTML en PNG** en utilisant du code C# pur. + +## Questions fréquentes + +| Question | Réponse | +|----------|--------| +| **Puis-je rendre une page complète avec du CSS/JS externe ?** | Oui – il suffit d’appeler `htmlDoc.Open("https://example.com")`. Le moteur téléchargera les ressources liées, mais vous avez besoin d’un accès réseau. | +| **Quels formats sont supportés en plus du PNG ?** | `ImageRenderingOptions` fonctionne avec JPEG, BMP, GIF et TIFF. Changez l’extension du fichier et définissez `ImageFormat` si nécessaire. | +| **Existe‑t‑il une limite de taille d’image ?** | Techniquement, vous pouvez atteindre plusieurs milliers de pixels, mais des dimensions très grandes peuvent épuiser la mémoire. Envisagez de rendre en tuiles pour une sortie ultra‑haute résolution. | +| **Comment gérer le DPI pour des images de qualité impression ?** | Définissez `renderingOptions.DpiX` et `renderingOptions.DpiY` (la valeur par défaut est 96). Un DPI plus élevé donne un rendu plus net pour l’impression. | +| **Ai‑je besoin d’une licence pour Aspose.HTML ?** | Une évaluation gratuite fonctionne avec un filigrane. Pour la production, achetez une licence pour le supprimer et débloquer toutes les fonctionnalités. | + +## Prochaines étapes et sujets associés + +- **Convert HTML to JPEG** – changez l’extension du fichier et éventuellement définissez `renderingOptions.ImageFormat = ImageFormat.Jpeg`. +- **Batch processing** – parcourez une liste d’URL et générez des miniatures pour chacune. +- **Embedding fonts** – apprenez à utiliser `@font-face` dans votre balisage pour une typographie parfaite. +- **Advanced layout** – expérimentez les options `PageSize`, `Margin` et `BackgroundColor` pour des apparences personnalisées. + +N’hésitez pas à ajuster les dimensions, essayer différents extraits HTML, ou intégrer ce fragment dans une API web qui fournit des aperçus PNG à la volée. Le ciel est la limite quand vous savez **comment rendre du HTML** de façon programmatique. + +--- + + + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/german/net/html-extensions-and-conversions/_index.md b/html/german/net/html-extensions-and-conversions/_index.md index eed971beed..26c39f54b2 100644 --- a/html/german/net/html-extensions-and-conversions/_index.md +++ b/html/german/net/html-extensions-and-conversions/_index.md @@ -89,6 +89,9 @@ Erfahren Sie, wie Sie mit Aspose in C# PDFs aus HTML generieren – vollständig Erfahren Sie, wie Sie HTML‑Inhalte mit Aspose.HTML für .NET in ein ZIP‑Archiv speichern – vollständige Schritt‑für‑Schritt‑Anleitung in C#. ### [HTML in ZIP speichern in C# – Komplettes In‑Memory‑Beispiel](./save-html-to-zip-in-c-complete-in-memory-example/) Speichern Sie HTML‑Inhalte in ein ZIP‑Archiv komplett im Speicher mit Aspose.HTML für .NET. Schritt‑für‑Schritt‑Anleitung. +### [Wie man Handler in Aspose.HTML verwendet – HTML laden, als ZIP speichern](./how-to-use-handler-in-aspose-html-load-html-save-as-zip/) +Erfahren Sie, wie Sie mit Aspose.HTML einen Handler nutzen, HTML laden und das Ergebnis als ZIP‑Archiv speichern. + ### [Benutzerdefinierter Ressourcen-Handler in C# – HTML in ZIP-Archiv aus dem Speicher konvertieren](./custom-resource-handler-in-c-convert-html-to-zip-archive-fro/) Erfahren Sie, wie Sie mit einem benutzerdefinierten Ressourcen-Handler HTML‑Inhalte im Speicher zu einem ZIP‑Archiv komprimieren. ### [HTML in C# zippen – HTML laden und benutzerdefinierten Handler verwenden](./how-to-zip-html-in-c-load-html-use-custom-handler/) diff --git a/html/german/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md b/html/german/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md new file mode 100644 index 0000000000..ccbda039d5 --- /dev/null +++ b/html/german/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md @@ -0,0 +1,183 @@ +--- +category: general +date: 2026-02-25 +description: Wie man einen Handler verwendet, um HTML von einer URL zu laden und die + Webseite mit Aspose.HTML als ZIP zu speichern – ein vollständiger C# Schritt‑für‑Schritt‑Leitfaden. +draft: false +keywords: +- how to use handler +- load html from url +- custom resource handler +- save webpage as zip +- create zip from html +language: de +og_description: Wie man einen Handler verwendet, um HTML von einer URL zu laden und + die Webseite mit Aspose.HTML als ZIP zu speichern. Lernen Sie den kompletten C#‑Workflow + in wenigen Minuten. +og_title: Wie man Handler in Aspose.HTML verwendet – HTML laden, als ZIP speichern +tags: +- Aspose.HTML +- C# +- Web Scraping +title: Wie man den Handler in Aspose.HTML verwendet – HTML laden, als ZIP speichern +url: /de/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Wie man einen Handler in Aspose.HTML verwendet – HTML laden, als ZIP speichern + +Haben Sie sich schon einmal gefragt, **wie man einen Handler** verwendet, wenn man eine Webseite in Ihre .NET‑App lädt? Vielleicht haben Sie `HtmlDocument.Open` ausprobiert und den HTML‑Code erhalten, aber die Bilder, CSS‑Dateien und Schriften sind wie vom Erdboden verschluckt. Das ist ein häufiges Problem – Ressourcen gehen verloren, wenn Sie Aspose.HTML nicht mitteilen, was damit geschehen soll. + +In diesem Tutorial gehen wir Schritt für Schritt durch das Laden von HTML von einer URL, das Einbinden eines **benutzerdefinierten Ressourcen‑Handlers** und schließlich das **Speichern der Webseite als ZIP**, sodass Sie ein einziges portables Archiv erhalten. Am Ende haben Sie ein einsatzbereites C#‑Snippet, das Sie in jedes Projekt einbinden können, plus einige Tipps, die Ihnen später Kopfschmerzen ersparen. + +## Was Sie benötigen + +- .NET 6+ (die API funktioniert auch mit .NET Core und .NET Framework) +- Aspose.HTML für .NET (NuGet‑Paket `Aspose.HTML`) +- Ein wenig C#‑Erfahrung (Sie kommen zurecht, wenn Sie schon einmal `Console.WriteLine` geschrieben haben) + +Keine zusätzlichen Tools, keine externen Dienste – nur die Bibliothek und eine URL, die Sie archivieren möchten. + + + +## Schritt 1: HTML von URL laden + +Der erste Schritt in jedem Web‑Scraping‑Ablauf ist das Abrufen des Seitenquelltexts. Aspose.HTML macht das mit einer einzigen Zeile möglich, aber denken Sie daran, dass wir **HTML von URL laden** mit dem integrierten Netzwerk‑Stack. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +// 1️⃣ Load the page you want to archive +HtmlDocument htmlDoc = new HtmlDocument(); +htmlDoc.Open("https://example.com"); // replace with any public URL +``` + +> **Warum das wichtig ist:** `HtmlDocument.Open` analysiert das Markup *und* löst relative URLs intern auf, aber es speichert die externen Assets nicht automatisch. Deshalb benötigen wir später einen Handler. + +## Schritt 2: Einen benutzerdefinierten Ressourcen‑Handler erstellen + +Jetzt kommt das Kernstück – **wie man einen Handler verwendet**, um jede externe Ressourcen‑Anfrage (Bilder, CSS, Schriften usw.) abzufangen. Durch das Ableiten von `ResourceHandler` erhalten Sie die volle Kontrolle über den Stream, der jedes Asset liefert. + +```csharp +// 2️⃣ Define your own handler (optional but powerful) +public class MyResourceHandler : ResourceHandler +{ + // Called for each external resource the document needs + public override Stream HandleResource(ResourceInfo info) + { + // Here you could download the file, cache it, or rewrite it. + // For this demo we simply return an empty stream – Aspose will + // still create the entry in the ZIP, keeping the folder structure. + return new MemoryStream(); + } +} +``` + +> **Pro‑Tipp:** In einer Produktionsumgebung möchten Sie vielleicht die tatsächlichen Bytes herunterladen (`HttpClient.GetStreamAsync(info.Uri)`) und diesen Stream zurückgeben. So stellt das gespeicherte ZIP die echten Bilder anstelle leerer Platzhalter bereit. + +## Schritt 3: Speicheroptionen konfigurieren und den Handler anhängen + +Nachdem der Handler fertig ist, teilen wir Aspose.HTML mit, wie alles verpackt werden soll. Die Klasse `HtmlSaveOptions` ermöglicht das Einschalten des Schalters `SaveToZipArchive` und das Einbinden Ihres `MyResourceHandler`. + +```csharp +// 3️⃣ Set up saving options – this is where we **save webpage as zip** +HtmlSaveOptions saveOptions = new HtmlSaveOptions +{ + // Attach our custom handler – new API as of v22.10 + OutputStorage = new MyResourceHandler(), + + // Instruct Aspose to bundle HTML + resources into a single ZIP file + SaveToZipArchive = true +}; +``` + +> **Erläuterung:** `OutputStorage` ist die Eigenschaft, die die Handler‑Instanz erhält. Wenn der Saver den DOM durchläuft, ruft er `HandleResource` für jeden externen Link auf. Da `SaveToZipArchive` auf true gesetzt ist, schreibt der Saver jeden zurückgegebenen Stream in einen ZIP‑Eintrag, der dem ursprünglichen Pfad entspricht. + +## Schritt 4: Das Dokument in einen MemoryStream speichern + +Wir könnten direkt auf die Festplatte schreiben, aber alles im Speicher zu behalten macht den Code in ASP.NET, Azure Functions oder überall dort, wo keine temporäre Datei gewünscht wird, nutzbar. Hier ist der letzte Schritt, der **ZIP aus HTML erstellt**. + +```csharp +// 4️⃣ Save everything – HTML + resources – into a MemoryStream +using (MemoryStream outputStream = new MemoryStream()) +{ + htmlDoc.Save(outputStream, saveOptions); + + // At this point outputStream holds a valid ZIP archive. + // For demo purposes we write it to the file system: + File.WriteAllBytes("example_page.zip", outputStream.ToArray()); +} +``` + +### Erwartetes Ergebnis + +- `example_page.zip` erscheint im Projektordner. +- Im ZIP finden Sie `index.html` plus eine Ordnerstruktur (`images/`, `css/` usw.). +- Obwohl unser Demo‑Handler leere Streams zurückgab, spiegelt das ZIP‑Layout die Originalseite wider – perfekt, um später einen echten Downloader einzusetzen. + +## Häufige Varianten & Randfälle + +### Laden einer lokalen Datei anstelle einer URL +Wenn Sie **HTML von URL‑ähnlichen** Pfaden auf der Festplatte laden müssen, ersetzen Sie einfach `htmlDoc.Open("https://example.com")` durch `htmlDoc.Open(@"C:\path\to\file.html")`. Der Rest der Pipeline bleibt unverändert. + +### Echte Ressourcen persistieren +Um tatsächlich Bilder einzubetten, passen Sie `HandleResource` an: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Download the resource using HttpClient + HttpClient client = new HttpClient(); + var data = client.GetByteArrayAsync(info.Uri).Result; + return new MemoryStream(data); +} +``` + +> **Vorsicht:** Netzwerkaufrufe im Handler blockieren den Speicher‑Thread; bei großen Seiten sollten Sie den Handler asynchron gestalten (in neueren Aspose‑Versionen verfügbar). + +### Ändern der ZIP‑Eintragsnamen +`ResourceInfo` enthält `FileName` und `Path`. Sie können diese umschreiben, um die Hierarchie zu flach zu machen oder ein Präfix hinzuzufügen: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Example: prepend "assets/" to every entry + info.Path = Path.Combine("assets", info.Path); + return base.HandleResource(info); +} +``` + +### Verwendung eines anderen Output‑Speichers +`OutputStorage` kann auch ein `FileSystemStorage` sein, wenn Sie lieber einen Ordner statt eines ZIPs möchten. Setzen Sie einfach `SaveToZipArchive = false` und verweisen Sie `OutputStorage` auf einen Verzeichnispfad. + +## Pro‑Tipps & Fallstricke + +- **Nicht vergessen, zu entsorgen** (`dispose`) das `HtmlDocument`, wenn Sie viele Seiten in einer Schleife öffnen; sonst können native Ressourcen lecken. +- **Speichernutzung:** Das Speichern riesiger Seiten in einem `MemoryStream` kann den RAM stark beanspruchen. Für Multi‑Megabyte‑Archive streamen Sie lieber direkt in eine Datei (`FileStream`). +- **Zeichencodierung:** Aspose.HTML respektiert das ``‑Tag. Wenn die Quellseite eine ungewöhnliche Codierung verwendet, prüfen Sie, ob das resultierende HTML nach der Extraktion korrekt gerendert wird. +- **Testing:** Öffnen Sie das erzeugte ZIP in einem Browser (ziehen Sie `index.html` heraus), um sicherzustellen, dass alle Ressourcen aufgelöst werden. Wenn Bilder fehlen, hat Ihr `HandleResource` wahrscheinlich einen leeren Stream zurückgegeben. + +## Zusammenfassung + +Wir haben **wie man einen Handler verwendet**, um externe Ressourcen abzufangen, **HTML von URL laden** demonstriert, einen **benutzerdefinierten Ressourcen‑Handler** gebaut und schließlich **die Webseite als ZIP gespeichert** – effektiv **ZIP aus HTML erstellen** mit wenigen Zeilen C#. Das Muster skaliert: Ersetzen Sie den leeren `MemoryStream` durch einen echten Downloader, ändern Sie das Ausgabemedium oder betten Sie die Logik in eine Web‑API ein, die das ZIP auf Abruf zurückgibt. + +--- + +### Was kommt als Nächstes? + +- **Batch‑Verarbeitung:** Durchlaufen Sie eine Liste von URLs und erzeugen Sie für jede Seite ein ZIP. +- **Kompressions‑Feinabstimmung:** Verwenden Sie `ZipSaveOptions`, um den Kompressionsgrad für schnellere Downloads anzupassen. +- **Integration mit ASP.NET Core:** Geben Sie den `MemoryStream` als `FileResult` zurück, sodass Benutzer das Archiv direkt von einem Web‑Endpoint herunterladen können. +- **Weitere Aspose.HTML‑Features erkunden:** PDF‑Konvertierung, DOM‑Manipulation oder headless Rendering. + +Haben Sie Fragen zu einem speziellen Anwendungsfall – vielleicht möchten Sie JavaScript erhalten oder Seiten mit Authentifizierung verarbeiten? Hinterlassen Sie einen Kommentar unten; ich helfe gern weiter. Viel Spaß beim Coden! + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/german/net/rendering-html-documents/_index.md b/html/german/net/rendering-html-documents/_index.md index 8f40982745..d1d1c6c0e5 100644 --- a/html/german/net/rendering-html-documents/_index.md +++ b/html/german/net/rendering-html-documents/_index.md @@ -53,6 +53,8 @@ Erfahren Sie, wie Sie mit Aspose.HTML für .NET HTML in PNG konvertieren, inklus ### [Wie Sie HTML in C# zu PNG rendern – Schritt‑für‑Schritt‑Leitfaden](./how-to-render-html-to-png-in-c-step-by-step-guide/) Erfahren Sie, wie Sie mit Aspose.HTML HTML in PNG konvertieren – vollständiger C#‑Schritt‑für‑Schritt‑Leitfaden. +### [HTML als PNG rendern in C# – Schritt‑für‑Schritt‑Leitfaden](./how-to-render-html-as-png-in-c-step-by-step-guide/) +Erfahren Sie, wie Sie HTML mit Aspose.HTML in C# als PNG rendern – eine detaillierte Schritt‑für‑Schritt‑Anleitung. ### [Wie Sie Aspose zum Rendern von HTML nach PNG verwenden – Schritt‑für‑Schritt‑Anleitung](./how-to-use-aspose-to-render-html-to-png-step-by-step-guide/) Erfahren Sie, wie Sie mit Aspose.HTML HTML‑Inhalte in PNG‑Bilder umwandeln – detaillierte Schritt‑für‑Schritt‑Anleitung. diff --git a/html/german/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md b/html/german/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..083f661a62 --- /dev/null +++ b/html/german/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md @@ -0,0 +1,224 @@ +--- +category: general +date: 2026-02-25 +description: Wie man HTML in C# mit Aspose.HTML als PNG rendert. Lernen Sie, HTML + in ein Bild zu konvertieren, HTML als PNG zu speichern und schnell ein PNG aus HTML + zu erstellen. +draft: false +keywords: +- how to render html +- convert html to image +- save html as png +- create png from html +- generate png from html +language: de +og_description: Wie man HTML in C# mit Aspose.HTML als PNG rendert. Folgen Sie diesem + Tutorial, um HTML in ein Bild zu konvertieren, HTML als PNG zu speichern und PNG + aus HTML zu erzeugen. +og_title: Wie man HTML in C# als PNG rendert – Vollständige Anleitung +tags: +- C# +- Aspose.HTML +- Image Rendering +title: Wie man HTML in C# als PNG rendert – Schritt‑für‑Schritt‑Anleitung +url: /de/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Wie man HTML in C# als PNG rendert – Schritt‑für‑Schritt‑Anleitung + +Haben Sie sich jemals gefragt, **wie man HTML** direkt in eine PNG‑Datei rendert, ohne einen Browser zu verwenden? Vielleicht müssen Sie einen kleinen Schnappschuss einer Webseite in eine E‑Mail einbetten, oder Sie bauen einen Thumbnail‑Dienst für ein CMS. So oder so geht es im Wesentlichen darum, Markup in ein Bitmap zu verwandeln, das Sie speichern oder bereitstellen können. + +In diesem Tutorial sehen Sie eine komplette, sofort ausführbare Lösung, die **HTML in ein Bild** mit Aspose.HTML für .NET **konvertiert**. Wir gehen auch darauf ein, wie man **HTML als PNG speichert**, **PNG aus HTML erstellt** und sogar **PNG aus HTML generiert** mit benutzerdefinierten Schriftarten und Abmessungen. Keine vagen Verweise – nur der Code, den Sie kopieren‑einfügen können, plus Erklärungen, warum jede Zeile wichtig ist. + +## Was Sie benötigen + +- .NET 6 (oder jede aktuelle .NET‑Runtime) – die API funktioniert genauso unter .NET Framework 4.6+. +- Visual Studio 2022 oder VS Code – je nach Vorliebe. +- Das **Aspose.HTML**‑NuGet‑Paket (`Aspose.HTML.NET`) – einmal installieren und Sie sind bereit. +- Ein beschreibbarer Ordner für das Ausgabe‑PNG (z. B. `C:\Temp\Images`). + +Das war’s. Keine zusätzlichen Binärdateien, keine externen Web‑Dienste und keine versteckten Konfigurationsdateien. + +## Schritt 1: Aspose.HTML über NuGet installieren + +Fügen Sie zunächst die Bibliothek zu Ihrem Projekt hinzu. Öffnen Sie das Terminal im Ordner Ihrer Lösung und führen Sie aus: + +```bash +dotnet add package Aspose.HTML.NET +``` + +*Pro‑Tipp:* Wenn Sie Visual Studio verwenden, klicken Sie mit der rechten Maustaste auf **Dependencies → Manage NuGet Packages**, suchen Sie nach „Aspose.HTML“ und klicken Sie auf **Install**. Damit erhalten Sie Zugriff auf `HtmlDocument`, `ImageRenderingOptions` und weitere Klassen, die wir verwenden werden. + +## Schritt 2: Rendering‑Optionen festlegen (Größe, Stil und Schriftarten) + +Bevor wir irgendein Markup an den Renderer übergeben, entscheiden wir, wie groß das Bild sein soll und welche Schriftstil‑Varianten wir erhalten wollen. Das Objekt `ImageRenderingOptions` ermöglicht das Anpassen von Breite, Höhe und sogar das Erzwingen von Fett‑/Kursiv‑Darstellung. + +```csharp +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +// Configure image rendering options – width, height, and font style +ImageRenderingOptions renderingOptions = new ImageRenderingOptions +{ + Width = 800, // Desired image width in pixels + Height = 600, // Desired image height in pixels + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic // Preserve bold & italic +}; +``` + +**Warum das wichtig ist:** +- **Width/Height** bestimmen die endgültigen Pixelabmessungen; wenn Sie sie weglassen, schätzt die Engine basierend auf dem HTML‑Layout, was zu unerwartetem Abschneiden führen kann. +- **FontStyle** sorgt dafür, dass ``‑ oder ``‑Tags ihre visuelle Betonung beim Rasterisieren behalten. + +## Schritt 3: Laden Ihres HTML‑Markups + +Sie können HTML aus einem String, einer Datei oder einer URL laden. Der Einfachheit halber betten wir ein kleines Snippet direkt im Code ein. Beachten Sie das Inline‑CSS, das die Schriftfamilie festlegt – Aspose.HTML respektiert standardmäßiges Web‑CSS, sodass Sie eine getreue Darstellung erhalten. + +```csharp +using Aspose.Html; + +// Create an empty HTML document +HtmlDocument htmlDoc = new HtmlDocument(); + +// Load simple markup – you could also use htmlDoc.Open("path/to/file.html") +htmlDoc.Open("Hello, world!
"); +``` + +**Hinweis für Sonderfälle:** Wenn Ihr Markup externe Ressourcen (Bilder, CSS‑Dateien) referenziert, stellen Sie sicher, dass diese URLs von der Maschine, die den Code ausführt, erreichbar sind, oder betten Sie sie als data‑URIs ein, um defekte Links zu vermeiden. + +## Schritt 4: Rendern des HTML zu einem PNG‑Stream + +Jetzt kommt der Kern von **wie man HTML rendert** – wir rufen `RenderToStream` auf und übergeben den Ausgabestream sowie die zuvor konfigurierten Optionen. Die Methode übernimmt das gesamte schwere Heben: Layout, CSS‑Kaskade, Schriftarten‑Ersetzung und Rasterisierung. + +```csharp +using System.IO; + +// Choose an output path – replace with your own directory +string outputPath = @"C:\Temp\Images\output.png"; + +using (FileStream outputStream = File.OpenWrite(outputPath)) +{ + // Render the HTML document into the PNG file + htmlDoc.RenderToStream(outputStream, renderingOptions); +} +``` + +Nachdem der `using`‑Block abgeschlossen ist, enthält `output.png` ein 800 × 600‑Pixel‑Bild des geladenen Absatzes. Öffnen Sie es mit einem beliebigen Bildbetrachter, um das Ergebnis zu prüfen. + +### Erwartetes Ergebnis + +Sie sollten eine saubere weiße Leinwand sehen, auf der der Text **„Hello, world!“** in Arial, fett und kursiv, exakt 24 pt groß, gerendert ist. Die Bildabmessungen entsprechen den von uns gesetzten 800 × 600 Werten. + +## Schritt 5: Überprüfen und häufige Fallstricke behandeln + +### 5.1 Überprüfen, ob die Datei existiert + +Eine schnelle Plausibilitätsprüfung verhindert stille Fehler: + +```csharp +if (File.Exists(outputPath)) +{ + Console.WriteLine($"✅ PNG created successfully at {outputPath}"); +} +else +{ + Console.WriteLine("❌ Something went wrong – PNG not found."); +} +``` + +### 5.2 Umgang mit fehlenden Schriftarten + +Wenn die Zielmaschine die angeforderte Schriftart nicht hat, greift Aspose.HTML auf eine generische Sans‑Serif‑Schrift zurück. Um Konsistenz zu gewährleisten, können Sie entweder: + +- Die Schriftdatei über eine `@font-face`‑Regel in Ihrem HTML einbetten, **oder** +- Die Schriftart programmgesteuert vor dem Rendern registrieren. + +```csharp +// Example of registering a custom TrueType font +htmlDoc.Fonts.AddFontFile(@"C:\Fonts\OpenSans-Regular.ttf"); +``` + +### 5.3 Rendern großer Seiten + +Beim Erstellen von Thumbnails für Vollseiten‑Screenshots sollten Sie den Speicherverbrauch im Auge behalten. Sie können nach dem Rendern verkleinern oder `renderingOptions.Width`/`Height` auf eine kleinere Größe setzen und Aspose.HTML die Skalierung übernehmen lassen. + +## Vollständiges funktionierendes Beispiel + +Unten finden Sie das komplette Programm, das Sie in eine Konsolenanwendung einfügen und sofort ausführen können. + +```csharp +// ----------------------------------------------------------- +// How to render HTML as PNG – Complete, runnable example +// ----------------------------------------------------------- +using System; +using System.IO; +using Aspose.Html; +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +class Program +{ + static void Main() + { + // 1️⃣ Configure rendering options + ImageRenderingOptions renderingOptions = new ImageRenderingOptions + { + Width = 800, + Height = 600, + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic + }; + + // 2️⃣ Load HTML markup + HtmlDocument htmlDoc = new HtmlDocument(); + htmlDoc.Open("Hello, world!
"); + + // 3️⃣ Define output path + string outputPath = @"C:\Temp\Images\output.png"; + + // 4️⃣ Render to PNG + using (FileStream outputStream = File.OpenWrite(outputPath)) + { + htmlDoc.RenderToStream(outputStream, renderingOptions); + } + + // 5️⃣ Verify the result + Console.WriteLine(File.Exists(outputPath) + ? $"✅ PNG saved at {outputPath}" + : "❌ Failed to create PNG"); + } +} +``` + +Führen Sie das Programm aus (`dotnet run`) und öffnen Sie anschließend `C:\Temp\Images\output.png`. Wenn alles reibungslos verlief, haben Sie gerade **HTML in ein Bild konvertiert** und **HTML als PNG gespeichert** mit reinem C#‑Code. + +## Häufig gestellte Fragen + +| Frage | Antwort | +|----------|--------| +| **Kann ich eine komplette Webseite mit externem CSS/JS rendern?** | Ja – rufen Sie einfach `htmlDoc.Open("https://example.com")` auf. Die Engine lädt verknüpfte Ressourcen herunter, Sie benötigen jedoch Netzwerkzugriff. | +| **Welche Formate werden neben PNG unterstützt?** | `ImageRenderingOptions` funktioniert mit JPEG, BMP, GIF und TIFF. Ändern Sie die Dateierweiterung und setzen Sie bei Bedarf `ImageFormat`. | +| **Gibt es ein Limit für die Bildgröße?** | Technisch können Sie mehrere tausend Pixel erreichen, aber sehr große Abmessungen können den Speicher erschöpfen. Erwägen Sie das Rendern in Kacheln für ultra‑hochauflösende Ausgaben. | +| **Wie gehe ich mit DPI für druckqualitätige Bilder um?** | Setzen Sie `renderingOptions.DpiX` und `renderingOptions.DpiY` (Standard ist 96). Höhere DPI liefert schärfere Ausgaben für den Druck. | +| **Benötige ich eine Lizenz für Aspose.HTML?** | Eine kostenlose Evaluation funktioniert mit einem Wasserzeichen. Für die Produktion erwerben Sie eine Lizenz, um das Wasserzeichen zu entfernen und alle Funktionen freizuschalten. | + +## Nächste Schritte und verwandte Themen + +- **HTML zu JPEG konvertieren** – ändern Sie die Dateierweiterung und setzen Sie optional `renderingOptions.ImageFormat = ImageFormat.Jpeg`. +- **Batch‑Verarbeitung** – iterieren Sie über eine Liste von URLs und erzeugen Sie für jede ein Thumbnail. +- **Schriftarten einbetten** – lernen Sie, wie Sie `@font-face` in Ihrem Markup für perfekte Typografie verwenden. +- **Erweitertes Layout** – experimentieren Sie mit den Optionen `PageSize`, `Margin` und `BackgroundColor` für individuelle Darstellungen. + +Passen Sie die Abmessungen nach Belieben an, probieren Sie verschiedene HTML‑Snippets aus oder integrieren Sie dieses Snippet in eine Web‑API, die PNG‑Vorschauen on‑the‑fly bereitstellt. Der Himmel ist das Limit, wenn Sie **wissen, wie man HTML** programmgesteuert rendert. + +--- + + + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/greek/net/html-extensions-and-conversions/_index.md b/html/greek/net/html-extensions-and-conversions/_index.md index a7911194c2..1242c40af4 100644 --- a/html/greek/net/html-extensions-and-conversions/_index.md +++ b/html/greek/net/html-extensions-and-conversions/_index.md @@ -103,6 +103,8 @@ url: /el/net/html-extensions-and-conversions/ Μάθετε πώς να αποθηκεύετε αρχεία HTML σε αρχείο ZIP χρησιμοποιώντας C# και Aspose.HTML με πλήρη παράδειγμα. ### [single file html – Αποθήκευση ιστοσελίδας ως ένα αρχείο HTML σε C#](./single-file-html-save-a-web-page-as-one-html-file-in-c/) Μάθετε πώς να αποθηκεύσετε μια ιστοσελίδα ως ένα ενιαίο αρχείο HTML χρησιμοποιώντας C# και Aspose.HTML. +### [Πώς να χρησιμοποιήσετε το handler στο Aspose.HTML – Φόρτωση HTML, αποθήκευση ως ZIP](./how-to-use-handler-in-aspose-html-load-html-save-as-zip/) +Μάθετε πώς να φορτώνετε HTML με handler και να το αποθηκεύετε σε αρχείο ZIP χρησιμοποιώντας το Aspose.HTML για .NET. {{< /blocks/products/pf/tutorial-page-section >}} diff --git a/html/greek/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md b/html/greek/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md new file mode 100644 index 0000000000..d40ae9fbca --- /dev/null +++ b/html/greek/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md @@ -0,0 +1,186 @@ +--- +category: general +date: 2026-02-25 +description: πώς να χρησιμοποιήσετε το handler για να φορτώσετε HTML από URL και να + αποθηκεύσετε τη σελίδα ως zip με το Aspose.HTML – ένας πλήρης οδηγός βήμα‑βήμα σε + C# +draft: false +keywords: +- how to use handler +- load html from url +- custom resource handler +- save webpage as zip +- create zip from html +language: el +og_description: πώς να χρησιμοποιήσετε το handler για να φορτώσετε HTML από URL και + να αποθηκεύσετε τη σελίδα ως zip με το Aspose.HTML. Μάθετε τη πλήρη ροή εργασίας + C# σε λίγα λεπτά. +og_title: πώς να χρησιμοποιήσετε το handler στο Aspose.HTML – Φόρτωση HTML, Αποθήκευση + ως ZIP +tags: +- Aspose.HTML +- C# +- Web Scraping +title: Πώς να χρησιμοποιήσετε το handler στο Aspose.HTML – Φόρτωση HTML, Αποθήκευση + ως ZIP +url: /el/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# πώς να χρησιμοποιήσετε handler στο Aspose.HTML – Φόρτωση HTML, Αποθήκευση ως ZIP + +Έχετε αναρωτηθεί ποτέ **πώς να χρησιμοποιήσετε handler** όταν φορτώνετε μια ιστοσελίδα στην .NET εφαρμογή σας; Ίσως έχετε δοκιμάσει το `HtmlDocument.Open` και έχετε λάβει το HTML, αλλά οι εικόνες, τα CSS και οι γραμματοσειρές εξαφανίστηκαν. Αυτό είναι ένα συχνό πρόβλημα — οι πόροι χάνονται εκτός αν πείτε στο Aspose.HTML τι πρέπει να κάνει με αυτούς. + +Σε αυτό το tutorial θα δούμε πώς να φορτώσουμε HTML από ένα URL, να δημιουργήσουμε έναν **προσαρμοσμένο resource handler**, και τελικά **να αποθηκεύσουμε τη σελίδα ως zip** ώστε να έχετε ένα ενιαίο φορητό αρχείο. Στο τέλος θα έχετε ένα έτοιμο απόσπασμα C# που μπορείτε να ενσωματώσετε σε οποιοδήποτε project, καθώς και μερικές συμβουλές που θα σας εξοικονομήσουν προβλήματα αργότερα. + +## Τι Θα Χρειαστείτε + +- .NET 6+ (το API λειτουργεί και σε .NET Core και .NET Framework) +- Aspose.HTML for .NET (πακέτο NuGet `Aspose.HTML`) +- Μια βασική εξοικείωση με C# (αρκεί να έχετε γράψει ένα `Console.WriteLine`) + +Καμία επιπλέον εργαλειοθήκη, καμία εξωτερική υπηρεσία — μόνο η βιβλιοθήκη και ένα URL που θέλετε να αρχειοθετήσετε. + + + +## Βήμα 1: Φόρτωση HTML από URL + +Το πρώτο βήμα σε κάθε ροή web‑scraping είναι η λήψη του πηγαίου κώδικα της σελίδας. Το Aspose.HTML το κάνει με μία γραμμή κώδικα, αλλά θυμηθείτε ότι **φορτώνουμε html από url** χρησιμοποιώντας το ενσωματωμένο δίκτυο. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +// 1️⃣ Load the page you want to archive +HtmlDocument htmlDoc = new HtmlDocument(); +htmlDoc.Open("https://example.com"); // replace with any public URL +``` + +> **Γιατί είναι σημαντικό:** Η μέθοδος `HtmlDocument.Open` αναλύει το markup *και* επιλύει τις σχετικές URL εσωτερικά, αλλά δεν αποθηκεύει αυτόματα τα εξωτερικά assets. Γι’ αυτό χρειάζεται ένας handler αργότερα. + +## Βήμα 2: Δημιουργία Προσαρμοσμένου Resource Handler + +Τώρα έρχεται η ουσία — **πώς να χρησιμοποιήσετε handler** για να παρεμβείτε σε κάθε αίτηση εξωτερικού πόρου (εικόνες, CSS, γραμματοσειρές κ.λπ.). Κάνοντας subclass το `ResourceHandler` αποκτάτε πλήρη έλεγχο του stream που υποστηρίζει κάθε asset. + +```csharp +// 2️⃣ Define your own handler (optional but powerful) +public class MyResourceHandler : ResourceHandler +{ + // Called for each external resource the document needs + public override Stream HandleResource(ResourceInfo info) + { + // Here you could download the file, cache it, or rewrite it. + // For this demo we simply return an empty stream – Aspose will + // still create the entry in the ZIP, keeping the folder structure. + return new MemoryStream(); + } +} +``` + +> **Pro tip:** Σε παραγωγικό σενάριο ίσως θέλετε να κατεβάζετε τα πραγματικά bytes (`HttpClient.GetStreamAsync(info.Uri)`) και να επιστρέφετε αυτό το stream. Αυτό εξασφαλίζει ότι το αποθηκευμένο ZIP περιέχει τις πραγματικές εικόνες αντί για κενά placeholders. + +## Βήμα 3: Διαμόρφωση Επιλογών Αποθήκευσης και Σύνδεση του Handler + +Με τον handler έτοιμο, λέμε στο Aspose.HTML πώς να πακετάρει τα πάντα. Η κλάση `HtmlSaveOptions` σας επιτρέπει να ενεργοποιήσετε το `SaveToZipArchive` και να συνδέσετε το `MyResourceHandler`. + +```csharp +// 3️⃣ Set up saving options – this is where we **save webpage as zip** +HtmlSaveOptions saveOptions = new HtmlSaveOptions +{ + // Attach our custom handler – new API as of v22.10 + OutputStorage = new MyResourceHandler(), + + // Instruct Aspose to bundle HTML + resources into a single ZIP file + SaveToZipArchive = true +}; +``` + +> **Εξήγηση:** Η ιδιότητα `OutputStorage` λαμβάνει το στιγμιότυπο του handler. Όταν ο saver διασχίζει το DOM, καλεί το `HandleResource` για κάθε εξωτερικό link. Επειδή το `SaveToZipArchive` είναι true, ο saver γράφει κάθε επιστρεφόμενο stream σε μια εγγραφή ZIP που ταιριάζει με το αρχικό μονοπάτι. + +## Βήμα 4: Αποθήκευση του Εγγράφου σε Memory Stream + +Μπορούσαμε να γράψουμε κατευθείαν στο δίσκο, αλλά η διατήρηση όλων στη μνήμη κάνει τον κώδικα χρήσιμο σε ASP.NET, Azure Functions ή οπουδήποτε δεν θέλετε προσωρινό αρχείο. Εδώ είναι το τελικό βήμα που **δημιουργεί zip από html**. + +```csharp +// 4️⃣ Save everything – HTML + resources – into a MemoryStream +using (MemoryStream outputStream = new MemoryStream()) +{ + htmlDoc.Save(outputStream, saveOptions); + + // At this point outputStream holds a valid ZIP archive. + // For demo purposes we write it to the file system: + File.WriteAllBytes("example_page.zip", outputStream.ToArray()); +} +``` + +### Αναμενόμενο Αποτέλεσμα + +- Το `example_page.zip` εμφανίζεται στο φάκελο του project. +- Μέσα στο ZIP θα βρείτε το `index.html` συν μια δομή φακέλων (`images/`, `css/`, κ.λπ.). +- Παρόλο που ο demo handler επέστρεψε κενά streams, η δομή του ZIP αντικατοπτρίζει την αρχική σελίδα — τέλειο για να αντικαταστήσετε αργότερα με έναν πραγματικό downloader. + +## Συνηθισμένες Παραλλαγές & Edge Cases + +### Φόρτωση Τοπικού Αρχείου Αντί για URL +Αν χρειάζεται να **φορτώσετε html από url**‑στυλ διαδρομές στον δίσκο, απλώς αντικαταστήστε το `htmlDoc.Open("https://example.com")` με `htmlDoc.Open(@"C:\path\to\file.html")`. Το υπόλοιπο της αλυσίδας παραμένει αμετάβλητο. + +### Ενσωμάτωση Πραγματικών Πόρων +Για να ενσωματώσετε πραγματικές εικόνες, τροποποιήστε το `HandleResource`: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Download the resource using HttpClient + HttpClient client = new HttpClient(); + var data = client.GetByteArrayAsync(info.Uri).Result; + return new MemoryStream(data); +} +``` + +> **Προειδοποίηση:** Κλήσεις δικτύου μέσα στον handler μπλοκάρουν το νήμα αποθήκευσης· για μεγάλες σελίδες σκεφτείτε να κάνετε τον handler ασύγχρονο (διαθέσιμο σε νεότερες εκδόσεις Aspose). + +### Αλλαγή Ονομάτων Εγγραφών ZIP +Το `ResourceInfo` περιέχει `FileName` και `Path`. Μπορείτε να τα ξαναγράψετε για να επίπεδοποιήσετε τη ιεραρχία ή να προσθέσετε πρόθεμα: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Example: prepend "assets/" to every entry + info.Path = Path.Combine("assets", info.Path); + return base.HandleResource(info); +} +``` + +### Χρήση Διαφορετικού Output Storage +Το `OutputStorage` μπορεί επίσης να είναι `FileSystemStorage` αν προτιμάτε φάκελο αντί για ZIP. Απλώς ορίστε `SaveToZipArchive = false` και δείξτε το `OutputStorage` σε διαδρομή καταλόγου. + +## Pro Tips & Pitfalls + +- **Μην ξεχνάτε να κάνετε dispose** το `HtmlDocument` αν ανοίγετε πολλές σελίδες σε βρόχο· διαφορετικά μπορεί να διαρρεύσουν native resources. +- **Χρήση μνήμης:** Η αποθήκευση τεράστιων σελίδων σε `MemoryStream` μπορεί να αυξήσει τη RAM. Για αρχεία πολλαπλών megabytes, ρέξτε απευθείας σε αρχείο (`FileStream`) αντί. +- **Κωδικοποίηση χαρακτήρων:** Το Aspose.HTML σέβεται την ετικέτα ``. Αν η πηγή χρησιμοποιεί ασυνήθιστη κωδικοποίηση, ελέγξτε ότι το παραγόμενο HTML εμφανίζεται σωστά μετά την εξαγωγή. +- **Δοκιμές:** Ανοίξτε το παραγόμενο ZIP σε πρόγραμμα περιήγησης (σύρετε το `index.html` έξω) για να βεβαιωθείτε ότι όλα τα resources φορτώνονται. Αν λείπουν εικόνες, το `HandleResource` πιθανότατα επέστρεψε κενό stream. + +## Ανακεφαλαίωση + +Καλύψαμε **πώς να χρησιμοποιήσετε handler** για την παρεμβολή εξωτερικών πόρων, δείξαμε **φόρτωση html από url**, δημιουργήσαμε έναν **προσαρμοσμένο resource handler**, και τέλος **αποθηκεύσαμε τη σελίδα ως zip** — ουσιαστικά **δημιουργώντας zip από html** με λίγες γραμμές C#. Το μοτίβο κλιμακώνεται: αντικαταστήστε το κενό `MemoryStream` με έναν πραγματικό downloader, αλλάξτε τον προορισμό εξόδου, ή ενσωματώστε τη λογική σε web API που επιστρέφει το ZIP κατ’ απαίτηση. + +--- + +### Τι Ακολουθεί; + +- **Batch processing:** Επανάληψη πάνω σε λίστα URLs και δημιουργία ZIP ανά σελίδα. +- **Ρυθμίσεις συμπίεσης:** Χρήση `ZipSaveOptions` για προσαρμογή επιπέδου συμπίεσης για ταχύτερες λήψεις. +- **Ενσωμάτωση με ASP.NET Core:** Επιστρέψτε το `MemoryStream` ως `FileResult` ώστε οι χρήστες να κατεβάζουν το αρχείο απευθείας από ένα web endpoint. +- **Εξερευνήστε άλλες δυνατότητες του Aspose.HTML:** Μετατροπή σε PDF, χειρισμός DOM, ή headless rendering. + +Έχετε ερωτήσεις για συγκεκριμένη περίπτωση χρήσης — ίσως χρειάζεστε διατήρηση JavaScript ή χειρισμό σελίδων με προστασία authentication; Αφήστε ένα σχόλιο παρακάτω· θα χαρώ να εμβαθύνω. Καλό coding! + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/greek/net/rendering-html-documents/_index.md b/html/greek/net/rendering-html-documents/_index.md index eea6b62db6..2359f98407 100644 --- a/html/greek/net/rendering-html-documents/_index.md +++ b/html/greek/net/rendering-html-documents/_index.md @@ -70,6 +70,9 @@ url: /el/net/rendering-html-documents/ Μάθετε πώς να μετατρέψετε HTML σε PNG χρησιμοποιώντας C# και το Aspose.HTML για .NET σε αυτό το ολοκληρωμένο σεμινάριο! ### [Πώς να χρησιμοποιήσετε το Aspose για απόδοση HTML σε PNG – Οδηγός βήμα‑βήμα](./how-to-use-aspose-to-render-html-to-png-step-by-step-guide/) Μάθετε πώς να μετατρέψετε HTML σε PNG χρησιμοποιώντας το Aspose.HTML για .NET με αυτόν τον αναλυτικό οδηγό βήμα‑βήμα. +### [Πώς να αποδώσετε HTML ως PNG σε C# – Οδηγός βήμα‑βήμα](./how-to-render-html-as-png-in-c-step-by-step-guide/) +Μάθετε πώς να μετατρέψετε HTML σε PNG με C# και Aspose.HTML για .NET σε αυτόν τον πλήρη οδηγό βήμα‑βήμα. + ### [Πώς να αποδώσετε HTML σε PNG με το Aspose – Πλήρης οδηγός](./how-to-render-html-to-png-with-aspose-complete-guide/) Μάθετε πώς να μετατρέψετε HTML σε PNG χρησιμοποιώντας το Aspose.HTML για .NET σε αυτόν τον πλήρη οδηγό. ### [Δημιουργία PNG από HTML – Πλήρης Οδηγός Απόδοσης C#](./create-png-from-html-full-c-rendering-guide/) diff --git a/html/greek/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md b/html/greek/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..be8c76d49f --- /dev/null +++ b/html/greek/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md @@ -0,0 +1,224 @@ +--- +category: general +date: 2026-02-25 +description: Πώς να αποδώσετε HTML ως PNG σε C# χρησιμοποιώντας το Aspose.HTML. Μάθετε + πώς να μετατρέψετε HTML σε εικόνα, να αποθηκεύσετε HTML ως PNG και να δημιουργήσετε + PNG από HTML γρήγορα. +draft: false +keywords: +- how to render html +- convert html to image +- save html as png +- create png from html +- generate png from html +language: el +og_description: Πώς να αποδώσετε HTML ως PNG σε C# με το Aspose.HTML. Ακολουθήστε + αυτό το σεμινάριο για να μετατρέψετε HTML σε εικόνα, να αποθηκεύσετε HTML ως PNG + και να δημιουργήσετε PNG από HTML. +og_title: Πώς να αποδώσετε HTML ως PNG σε C# – Πλήρης Οδηγός +tags: +- C# +- Aspose.HTML +- Image Rendering +title: Πώς να αποδώσετε HTML ως PNG σε C# – Οδηγός βήμα‑βήμα +url: /el/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Πώς να αποδώσετε HTML ως PNG σε C# – Οδηγός βήμα‑βήμα + +Έχετε αναρωτηθεί ποτέ **πώς να αποδώσετε HTML** απευθείας σε αρχείο PNG χωρίς να χρησιμοποιήσετε πρόγραμμα περιήγησης; Ίσως χρειάζεστε να ενσωματώσετε μια μικρή εικόνα μιας ιστοσελίδας σε ένα email, ή να δημιουργείτε μια υπηρεσία μικρογραφιών για ένα CMS. Σε κάθε περίπτωση, το πρόβλημα συνοψίζεται στο να μετατρέψετε markup σε bitmap που μπορείτε να αποθηκεύσετε ή να σερβίρετε. + +Σε αυτό το tutorial θα δείτε μια πλήρη, έτοιμη‑για‑εκτέλεση λύση που **μετατρέπει HTML σε εικόνα** χρησιμοποιώντας το Aspose.HTML για .NET. Θα αγγίξουμε επίσης πώς να **αποθηκεύσετε HTML ως PNG**, **δημιουργήσετε PNG από HTML**, και ακόμη **παράγετε PNG από HTML** με προσαρμοσμένες γραμματοσειρές και διαστάσεις. Χωρίς ασαφείς αναφορές—απλώς ο κώδικας που μπορείτε να αντιγράψετε‑και‑επικολλήσετε, μαζί με εξηγήσεις για το γιατί κάθε γραμμή είναι σημαντική. + +## Τι θα χρειαστείτε + +- .NET 6 (ή οποιοδήποτε πρόσφατο .NET runtime) – το API λειτουργεί το ίδιο και σε .NET Framework 4.6+. +- Visual Studio 2022 ή VS Code – ό,τι προτιμάτε. +- Το **Aspose.HTML** πακέτο NuGet (`Aspose.HTML.NET`) – εγκαταστήστε το μία φορά και είστε έτοιμοι. +- Ένας φάκελος με δικαιώματα εγγραφής για το παραγόμενο PNG (π.χ., `C:\Temp\Images`). + +Αυτό είναι όλο. Χωρίς επιπλέον δυαδικά αρχεία, χωρίς εξωτερικές υπηρεσίες web, και χωρίς κρυφά αρχεία ρυθμίσεων. + +## Βήμα 1: Εγκατάσταση Aspose.HTML μέσω NuGet + +Πρώτα, προσθέστε τη βιβλιοθήκη στο πρόγραμμά σας. Ανοίξτε το τερματικό στο φάκελο της λύσης και εκτελέστε: + +```bash +dotnet add package Aspose.HTML.NET +``` + +*Συμβουλή:* Αν χρησιμοποιείτε Visual Studio, κάντε δεξί‑κλικ στο **Dependencies → Manage NuGet Packages**, ψάξτε για “Aspose.HTML” και κάντε κλικ στο **Install**. Έτσι θα έχετε πρόσβαση στις κλάσεις `HtmlDocument`, `ImageRenderingOptions` και άλλες που θα χρησιμοποιήσουμε. + +## Βήμα 2: Ρύθμιση επιλογών απόδοσης (μέγεθος, στυλ και γραμματοσειρές) + +Πριν τροφοδοτήσουμε το renderer με κάποιο markup, αποφασίζουμε πόσο μεγάλη θα είναι η εικόνα και ποιες γραμματοσειρές θέλουμε να διατηρήσουμε. Το αντικείμενο `ImageRenderingOptions` σας επιτρέπει να ρυθμίσετε πλάτος, ύψος και ακόμη να εξαναγκάσετε την απόδοση bold/italic. + +```csharp +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +// Configure image rendering options – width, height, and font style +ImageRenderingOptions renderingOptions = new ImageRenderingOptions +{ + Width = 800, // Desired image width in pixels + Height = 600, // Desired image height in pixels + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic // Preserve bold & italic +}; +``` + +**Γιατί είναι σημαντικό:** +- **Width/Height** καθορίζουν τις τελικές διαστάσεις σε pixel· αν τα παραλείψετε, η μηχανή θα κάνει εκτίμηση βάσει του layout του HTML, κάτι που μπορεί να οδηγήσει σε ανεπιθύμητο κόψιμο. +- **FontStyle** διασφαλίζει ότι τυχόν ετικέτες `` ή `` διατηρούν την οπτική τους έμφαση κατά τη rasterization. + +## Βήμα 3: Φόρτωση του HTML markup σας + +Μπορείτε να φορτώσετε HTML από string, αρχείο ή URL. Για απλότητα, θα ενσωματώσουμε ένα μικρό απόσπασμα απευθείας στον κώδικα. Παρατηρήστε το inline CSS που ορίζει την οικογένεια γραμματοσειρών – το Aspose.HTML σέβεται το τυπικό web CSS, οπότε λαμβάνετε πιστή απόδοση. + +```csharp +using Aspose.Html; + +// Create an empty HTML document +HtmlDocument htmlDoc = new HtmlDocument(); + +// Load simple markup – you could also use htmlDoc.Open("path/to/file.html") +htmlDoc.Open("Hello, world!
"); +``` + +**Συμβουλή για ειδικές περιπτώσεις:** Αν το markup σας αναφέρεται σε εξωτερικούς πόρους (εικόνες, αρχεία CSS), βεβαιωθείτε ότι τα URLs είναι προσβάσιμα από το μηχάνημα που εκτελεί τον κώδικα, ή ενσωματώστε τα ως data‑URIs ώστε να αποφύγετε σπασμένα links. + +## Βήμα 4: Απόδοση του HTML σε ροή PNG + +Τώρα έρχεται η ουσία του **πώς να αποδώσετε HTML** – καλούμε τη `RenderToStream`, περνώντας τη ροή εξόδου και τις επιλογές που διαμορφώσαμε νωρίτερα. Η μέθοδος κάνει όλη τη βαριά δουλειά: layout, CSS cascade, αντικατάσταση γραμματοσειρών και rasterization. + +```csharp +using System.IO; + +// Choose an output path – replace with your own directory +string outputPath = @"C:\Temp\Images\output.png"; + +using (FileStream outputStream = File.OpenWrite(outputPath)) +{ + // Render the HTML document into the PNG file + htmlDoc.RenderToStream(outputStream, renderingOptions); +} +``` + +Μετά το τέλος του μπλοκ `using`, το `output.png` θα περιέχει μια εικόνα 800 × 600 pixel της παραγράφου που φορτώσαμε. Ανοίξτε το με οποιονδήποτε προβολέα εικόνων για να επαληθεύσετε το αποτέλεσμα. + +### Αναμενόμενο αποτέλεσμα + +Θα πρέπει να δείτε έναν καθαρό λευκό καμβά με το κείμενο **«Hello, world!»** αποδομένο σε Arial, bold και italic, ακριβώς 24 pt. Οι διαστάσεις της εικόνας ταιριάζουν με τις τιμές 800 × 600 που ορίσαμε. + +## Βήμα 5: Επαλήθευση και αντιμετώπιση κοινών προβλημάτων + +### 5.1 Έλεγχος αν το αρχείο υπάρχει + +Μια γρήγορη επιβεβαίωση αποτρέπει σιωπηλές αποτυχίες: + +```csharp +if (File.Exists(outputPath)) +{ + Console.WriteLine($"✅ PNG created successfully at {outputPath}"); +} +else +{ + Console.WriteLine("❌ Something went wrong – PNG not found."); +} +``` + +### 5.2 Αντιμετώπιση ελλιπών γραμματοσειρών + +Αν η μηχανή-στόχος δεν διαθέτει τη ζητούμενη γραμματοσειρά, το Aspose.HTML θα επιστρέψει μια γενική sans‑serif. Για να εξασφαλίσετε συνέπεια, είτε: + +- Ενσωματώστε το αρχείο γραμματοσειράς χρησιμοποιώντας κανόνα `@font-face` στο HTML, **ή** +- Καταχωρίστε τη γραμματοσειρά προγραμματιστικά πριν από την απόδοση. + +```csharp +// Example of registering a custom TrueType font +htmlDoc.Fonts.AddFontFile(@"C:\Fonts\OpenSans-Regular.ttf"); +``` + +### 5.3 Απόδοση μεγάλων σελίδων + +Όταν δημιουργείτε μικρογραφίες για πλήρεις σελίδες, προσέξτε τη χρήση μνήμης. Μπορείτε να μειώσετε την ανάλυση μετά την απόδοση, ή να ορίσετε `renderingOptions.Width`/`Height` σε μικρότερο μέγεθος και να αφήσετε το Aspose.HTML να κάνει το scaling. + +## Πλήρες λειτουργικό παράδειγμα + +Παρακάτω βρίσκεται το πλήρες πρόγραμμα που μπορείτε να ενσωματώσετε σε μια εφαρμογή console και να τρέξετε αμέσως. + +```csharp +// ----------------------------------------------------------- +// How to render HTML as PNG – Complete, runnable example +// ----------------------------------------------------------- +using System; +using System.IO; +using Aspose.Html; +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +class Program +{ + static void Main() + { + // 1️⃣ Configure rendering options + ImageRenderingOptions renderingOptions = new ImageRenderingOptions + { + Width = 800, + Height = 600, + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic + }; + + // 2️⃣ Load HTML markup + HtmlDocument htmlDoc = new HtmlDocument(); + htmlDoc.Open("Hello, world!
"); + + // 3️⃣ Define output path + string outputPath = @"C:\Temp\Images\output.png"; + + // 4️⃣ Render to PNG + using (FileStream outputStream = File.OpenWrite(outputPath)) + { + htmlDoc.RenderToStream(outputStream, renderingOptions); + } + + // 5️⃣ Verify the result + Console.WriteLine(File.Exists(outputPath) + ? $"✅ PNG saved at {outputPath}" + : "❌ Failed to create PNG"); + } +} +``` + +Τρέξτε το πρόγραμμα (`dotnet run`), μετά ανοίξτε το `C:\Temp\Images\output.png`. Αν όλα πήγαν ομαλά, μόλις **μετατρέψατε HTML σε εικόνα** και **αποθηκεύσατε HTML ως PNG** χρησιμοποιώντας καθαρό κώδικα C#. + +## Συχνές Ερωτήσεις + +| Ερώτηση | Απάντηση | +|----------|--------| +| **Μπορώ να αποδώσω μια πλήρη ιστοσελίδα με εξωτερικό CSS/JS;** | Ναι – απλώς καλέστε `htmlDoc.Open("https://example.com")`. Η μηχανή θα κατεβάσει τους συνδεδεμένους πόρους, αλλά απαιτείται πρόσβαση στο διαδίκτυο. | +| **Ποιοι μορφότυποι υποστηρίζονται εκτός από PNG;** | Το `ImageRenderingOptions` λειτουργεί με JPEG, BMP, GIF και TIFF. Αλλάξτε την επέκταση αρχείου και ορίστε `ImageFormat` αν χρειάζεται. | +| **Υπάρχει όριο στο μέγεθος της εικόνας;** | Θεωρητικά μπορείτε να φτάσετε σε αρκετές χιλιάδες pixel, αλλά πολύ μεγάλες διαστάσεις μπορεί να εξαντλήσουν τη μνήμη. Σκεφτείτε rendering σε tiles για εξαιρετικά υψηλή ανάλυση. | +| **Πώς διαχειρίζομαι το DPI για εικόνες εκτύπωσης;** | Ορίστε `renderingOptions.DpiX` και `renderingOptions.DpiY` (η προεπιλογή είναι 96). Μεγαλύτερο DPI δίνει πιο οξεία έξοδο για εκτύπωση. | +| **Χρειάζομαι άδεια για το Aspose.HTML;** | Η δωρεάν αξιολόγηση λειτουργεί με υδατογράφημα. Για παραγωγική χρήση, αγοράστε άδεια για να το αφαιρέσετε και να ξεκλειδώσετε όλες τις δυνατότητες. | + +## Επόμενα βήματα και συναφή θέματα + +- **Μετατροπή HTML σε JPEG** – αλλάξτε την επέκταση αρχείου και προαιρετικά ορίστε `renderingOptions.ImageFormat = ImageFormat.Jpeg`. +- **Επεξεργασία σε batch** – κάντε βρόχο πάνω σε λίστα URLs και δημιουργήστε μικρογραφίες για κάθε μία. +- **Ενσωμάτωση γραμματοσειρών** – μάθετε πώς να χρησιμοποιείτε `@font-face` μέσα στο markup για τέλεια τυπογραφία. +- **Προηγμένο layout** – πειραματιστείτε με τις επιλογές `PageSize`, `Margin` και `BackgroundColor` για προσαρμοσμένες εμφανίσεις. + +Μη διστάσετε να τροποποιήσετε τις διαστάσεις, να δοκιμάσετε διαφορετικά HTML αποσπάσματα, ή να ενσωματώσετε αυτό το snippet σε ένα web API που εξυπηρετεί προεπισκοπήσεις PNG σε πραγματικό χρόνο. Ο ουρανός είναι το όριο όταν ξέρετε **πώς να αποδώσετε HTML** προγραμματιστικά. + +--- + + + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/hindi/net/html-extensions-and-conversions/_index.md b/html/hindi/net/html-extensions-and-conversions/_index.md index 2ff0fefcfb..9fd80eef32 100644 --- a/html/hindi/net/html-extensions-and-conversions/_index.md +++ b/html/hindi/net/html-extensions-and-conversions/_index.md @@ -103,6 +103,9 @@ Aspose.HTML for .NET का उपयोग करके स्टाइल् .NET के लिए Aspose.HTML की शक्ति का पता लगाएं: HTML को XPS में आसानी से बदलें। पूर्वापेक्षाएँ, चरण-दर-स्टेप मार्गदर्शिका और FAQ शामिल हैं। ### [C# में HTML को ZIP में सहेजें – पूर्ण इन‑मेमोरी उदाहरण](./save-html-to-zip-in-c-complete-in-memory-example/) C# में इन‑मेमोरी में HTML को ZIP फ़ाइल में सहेजने का पूरा उदाहरण देखें। +### [Aspose.HTML में हैंडलर का उपयोग कैसे करें – HTML लोड करें, ZIP के रूप में सहेजें](./how-to-use-handler-in-aspose-html-load-html-save-as-zip/) +Aspose.HTML के हैंडलर का उपयोग करके HTML लोड करें और उसे ZIP फ़ाइल में सहेजने के चरण‑दर‑चरण मार्गदर्शन। + ### [Aspose HTML सेव विकल्प: C# में HTML को स्ट्रीम में सहेजें](./aspose-html-save-options-save-html-to-stream-in-c/) C# में Aspose.HTML का उपयोग करके HTML को स्ट्रीम में सहेजने के चरण‑दर‑स्टेप गाइड। diff --git a/html/hindi/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md b/html/hindi/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md new file mode 100644 index 0000000000..7023e0d15d --- /dev/null +++ b/html/hindi/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md @@ -0,0 +1,183 @@ +--- +category: general +date: 2026-02-25 +description: हैंडलर का उपयोग करके URL से HTML लोड करना और Aspose.HTML के साथ वेबपेज + को ज़िप के रूप में सहेजना – C# में एक पूर्ण चरण‑दर‑चरण गाइड। +draft: false +keywords: +- how to use handler +- load html from url +- custom resource handler +- save webpage as zip +- create zip from html +language: hi +og_description: कैसे हैंडलर का उपयोग करके URL से HTML लोड करें और Aspose.HTML के साथ + वेबपेज को ज़िप के रूप में सहेजें। मिनटों में पूरी C# वर्कफ़्लो सीखें। +og_title: Aspose.HTML में हैंडलर का उपयोग कैसे करें – HTML लोड करें, ZIP के रूप में + सहेजें +tags: +- Aspose.HTML +- C# +- Web Scraping +title: Aspose.HTML में हैंडलर का उपयोग कैसे करें – HTML लोड करें, ZIP के रूप में सहेजें +url: /hi/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Aspose.HTML में हैंडलर का उपयोग कैसे करें – HTML लोड करें, ZIP के रूप में सहेजें + +क्या आपने कभी सोचा है **how to use handler** जब आप अपनी .NET एप्लिकेशन में वेब पेज खींचते हैं? शायद आपने `HtmlDocument.Open` आज़माया और HTML प्राप्त किया, लेकिन इमेज़, CSS, और फ़ॉन्ट्स हवा में गायब हो गए। यह एक आम समस्या है—संसाधन खो जाते हैं जब तक आप Aspose.HTML को नहीं बताते कि उनके साथ क्या करना है। + +इस ट्यूटोरियल में हम URL से HTML लोड करने, एक **custom resource handler** को सेट करने, और अंत में **save webpage as zip** करने की प्रक्रिया देखेंगे ताकि आपको एक एकल पोर्टेबल आर्काइव मिल सके। अंत तक आपके पास एक तैयार‑चलाने‑योग्य C# स्निपेट होगा जिसे आप किसी भी प्रोजेक्ट में डाल सकते हैं, साथ ही कुछ ऐसे टिप्स भी मिलेंगे जो बाद में झंझट बचाएँगे। + +## आपको क्या चाहिए + +- .NET 6+ (API .NET Core और .NET Framework पर भी काम करता है) +- Aspose.HTML for .NET (NuGet पैकेज `Aspose.HTML`) +- थोड़ा बहुत C# अनुभव (यदि आपने पहले `Console.WriteLine` लिखा है तो आप ठीक रहेंगे) + +कोई अतिरिक्त टूल्स नहीं, कोई बाहरी सेवाएँ नहीं—सिर्फ लाइब्रेरी और वह URL जिसे आप आर्काइव करना चाहते हैं। + + + +## चरण 1: URL से HTML लोड करें + +किसी भी वेब‑स्क्रैपिंग प्रक्रिया में पहला कदम पेज सोर्स को प्राप्त करना होता है। Aspose.HTML इसे एक लाइनर बनाता है, लेकिन याद रखें कि हम **loading html from url** को बिल्ट‑इन नेटवर्क स्टैक के साथ कर रहे हैं। + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +// 1️⃣ Load the page you want to archive +HtmlDocument htmlDoc = new HtmlDocument(); +htmlDoc.Open("https://example.com"); // replace with any public URL +``` + +> **यह क्यों महत्वपूर्ण है:** `HtmlDocument.Open` मार्कअप को पार्स करता है *और* आंतरिक रूप से रिलेटिव URLs को रिजॉल्व करता है, लेकिन यह बाहरी एसेट्स को स्वचालित रूप से सहेजता नहीं है। इसलिए बाद में हमें एक हैंडलर की आवश्यकता होती है। + +## चरण 2: एक Custom Resource Handler बनाएं + +अब आता है मुख्य भाग—**how to use handler** को हर बाहरी संसाधन अनुरोध (इमेज़, CSS, फ़ॉन्ट्स, आदि) को इंटरसेप्ट करने के लिए। `ResourceHandler` को सबक्लास करके आप प्रत्येक एसेट के स्ट्रीम पर पूर्ण नियंत्रण प्राप्त करते हैं। + +```csharp +// 2️⃣ Define your own handler (optional but powerful) +public class MyResourceHandler : ResourceHandler +{ + // Called for each external resource the document needs + public override Stream HandleResource(ResourceInfo info) + { + // Here you could download the file, cache it, or rewrite it. + // For this demo we simply return an empty stream – Aspose will + // still create the entry in the ZIP, keeping the folder structure. + return new MemoryStream(); + } +} +``` + +> **प्रो टिप:** प्रोडक्शन परिदृश्य में आप वास्तविक बाइट्स डाउनलोड करना चाह सकते हैं (`HttpClient.GetStreamAsync(info.Uri)`) और वह स्ट्रीम रिटर्न करें। इससे सहेजे गए ZIP में वास्तविक इमेज़ होंगी, खाली प्लेसहोल्डर नहीं। + +## चरण 3: Save Options कॉन्फ़िगर करें और हैंडलर अटैच करें + +हैंडलर तैयार होने पर, हम Aspose.HTML को बताते हैं कि सब कुछ कैसे पैकेज किया जाए। `HtmlSaveOptions` क्लास आपको `SaveToZipArchive` स्विच को ऑन करने और अपने `MyResourceHandler` को प्लग इन करने की सुविधा देती है। + +```csharp +// 3️⃣ Set up saving options – this is where we **save webpage as zip** +HtmlSaveOptions saveOptions = new HtmlSaveOptions +{ + // Attach our custom handler – new API as of v22.10 + OutputStorage = new MyResourceHandler(), + + // Instruct Aspose to bundle HTML + resources into a single ZIP file + SaveToZipArchive = true +}; +``` + +> **व्याख्या:** `OutputStorage` वह प्रॉपर्टी है जो हैंडलर इंस्टेंस प्राप्त करती है। जब सेवर DOM को ट्रैवर्स करता है तो वह प्रत्येक बाहरी लिंक के लिए `HandleResource` को कॉल करता है। क्योंकि `SaveToZipArchive` true है, सेवर प्रत्येक रिटर्न किए गए स्ट्रीम को मूल पाथ के अनुसार ZIP एंट्री में लिखता है। + +## चरण 4: दस्तावेज़ को Memory Stream में सहेजें + +हम सीधे डिस्क पर लिख सकते थे, लेकिन सब कुछ मेमोरी में रखने से कोड ASP.NET, Azure Functions, या किसी भी जगह पर उपयोगी बन जाता है जहाँ आप अस्थायी फ़ाइल नहीं चाहते। यहाँ अंतिम चरण है जो **creates zip from html** करता है। + +```csharp +// 4️⃣ Save everything – HTML + resources – into a MemoryStream +using (MemoryStream outputStream = new MemoryStream()) +{ + htmlDoc.Save(outputStream, saveOptions); + + // At this point outputStream holds a valid ZIP archive. + // For demo purposes we write it to the file system: + File.WriteAllBytes("example_page.zip", outputStream.ToArray()); +} +``` + +### अपेक्षित परिणाम + +- `example_page.zip` आपके प्रोजेक्ट फ़ोल्डर में दिखाई देगा। +- ZIP के अंदर आपको `index.html` और एक फ़ोल्डर संरचना (`images/`, `css/`, आदि) मिलेगी। +- हालांकि हमारे डेमो हैंडलर ने खाली स्ट्रीम रिटर्न किए, ZIP लेआउट मूल पेज को प्रतिबिंबित करता है—बाद में वास्तविक डाउनलोडर बदलने के लिए परफेक्ट। + +## सामान्य विविधताएँ और एज केस + +### URL के बजाय स्थानीय फ़ाइल लोड करना +यदि आपको डिस्क पर **load html from url**‑जैसे पाथ्स की आवश्यकता है, तो बस `htmlDoc.Open("https://example.com")` को `htmlDoc.Open(@"C:\path\to\file.html")` से बदल दें। बाकी पाइपलाइन समान रहती है। + +### वास्तविक संसाधनों को सहेजना +वास्तव में इमेज़ एम्बेड करने के लिए, `HandleResource` को संशोधित करें: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Download the resource using HttpClient + HttpClient client = new HttpClient(); + var data = client.GetByteArrayAsync(info.Uri).Result; + return new MemoryStream(data); +} +``` + +> **सावधानी:** हैंडलर के अंदर नेटवर्क कॉल्स सेविंग थ्रेड को ब्लॉक कर देते हैं; बड़े पेज़ के लिए हैंडलर को असिंक्रोनस बनाने पर विचार करें (नए Aspose रिलीज़ में उपलब्ध)। + +### ZIP एंट्री नाम बदलना +`ResourceInfo` में `FileName` और `Path` होते हैं। आप उन्हें हायरार्की को फ्लैट करने या प्रीफ़िक्स जोड़ने के लिए री‑राइट कर सकते हैं: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Example: prepend "assets/" to every entry + info.Path = Path.Combine("assets", info.Path); + return base.HandleResource(info); +} +``` + +### अलग Output Storage का उपयोग +`OutputStorage` को `FileSystemStorage` भी बनाया जा सकता है यदि आप ZIP के बजाय फ़ोल्डर पसंद करते हैं। बस `SaveToZipArchive = false` सेट करें और `OutputStorage` को एक डायरेक्टरी पाथ पर पॉइंट करें। + +## प्रो टिप्स और pitfalls + +- **`HtmlDocument` को डिस्पोज़ करना न भूलें** यदि आप लूप में कई पेज़ खोलते हैं; अन्यथा आप नेटिव रिसोर्सेज़ लीक कर सकते हैं। +- **मेमोरी उपयोग:** बड़े पेज़ को `MemoryStream` में सहेजने से RAM बढ़ सकता है। मल्टी‑मेगाबाइट आर्काइव्स के लिए सीधे फ़ाइल (`FileStream`) में स्ट्रीम करें। +- **कैरेक्टर एन्कोडिंग:** Aspose.HTML `` टैग का सम्मान करता है। यदि स्रोत पेज में असामान्य एन्कोडिंग है, तो एक्सट्रैक्शन के बाद उत्पन्न HTML सही रेंडर हो रहा है या नहीं, जांचें। +- **टेस्टिंग:** जनरेटेड ZIP को ब्राउज़र में खोलें ( `index.html` को बाहर ड्रैग करें) ताकि सभी रिसोर्सेज़ रिजॉल्व हों। यदि इमेज़ गायब हैं, तो आपका `HandleResource` संभवतः खाली स्ट्रीम रिटर्न कर रहा है। + +## पुनरावलोकन + +हमने **how to use handler** को बाहरी रिसोर्सेज़ को इंटरसेप्ट करने के लिए कवर किया, **load html from url** को दर्शाया, एक **custom resource handler** बनाया, और अंत में **save webpage as zip** किया—प्रभावी रूप से कुछ ही C# लाइनों से **create zip from html** किया। यह पैटर्न स्केलेबल है: खाली `MemoryStream` को वास्तविक डाउनलोडर से बदलें, आउटपुट टारगेट बदलें, या लॉजिक को वेब API में एम्बेड करें जो मांग पर ZIP रिटर्न करता है। + +--- + +### आगे क्या? + +- **बैच प्रोसेसिंग:** URLs की सूची पर लूप करें और प्रत्येक पेज़ के लिए एक ZIP जनरेट करें। +- **कम्प्रेशन ट्यूनिंग:** तेज़ डाउनलोड के लिए `ZipSaveOptions` का उपयोग करके कम्प्रेशन लेवल समायोजित करें। +- **ASP.NET Core के साथ इंटीग्रेशन:** `MemoryStream` को `FileResult` के रूप में रिटर्न करें ताकि उपयोगकर्ता वेब एन्डपॉइंट से सीधे आर्काइव डाउनलोड कर सकें। +- **अन्य Aspose.HTML फीचर्स का अन्वेषण:** PDF कन्वर्ज़न, DOM मैनिपुलेशन, या हेडलेस रेंडरिंग। + +यदि आपके पास किसी विशिष्ट उपयोग केस के बारे में प्रश्न हैं—शायद आपको JavaScript को संरक्षित करना है या ऑथेंटिकेशन‑प्रोटेक्टेड पेज़ को हैंडल करना है? नीचे कमेंट करें; मैं गहराई से मदद करने में खुशी महसूस करूंगा। कोडिंग का आनंद लें! + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/hindi/net/rendering-html-documents/_index.md b/html/hindi/net/rendering-html-documents/_index.md index eb2343fdeb..c59af08e48 100644 --- a/html/hindi/net/rendering-html-documents/_index.md +++ b/html/hindi/net/rendering-html-documents/_index.md @@ -99,6 +99,9 @@ C# में Aspose.HTML का उपयोग करके HTML को इम ### [Aspose.HTML के साथ HTML को PDF में रेंडर करें – चरण‑दर‑चरण गाइड](./render-html-to-pdf-with-aspose-html-step-by-step-guide/) Aspose.HTML के साथ HTML को PDF में बदलने के चरण‑दर‑चरण निर्देश, कोड उदाहरण और उपयोगी टिप्स। +### [C# में HTML को PNG के रूप में रेंडर करने का चरण‑दर‑चरण गाइड](./how-to-render-html-as-png-in-c-step-by-step-guide/) +C# में Aspose.HTML का उपयोग करके HTML को PNG में बदलने की चरण‑दर‑चरण प्रक्रिया सीखें। + {{< /blocks/products/pf/tutorial-page-section >}} {{< /blocks/products/pf/main-container >}} diff --git a/html/hindi/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md b/html/hindi/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..c0d07cdcb7 --- /dev/null +++ b/html/hindi/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md @@ -0,0 +1,224 @@ +--- +category: general +date: 2026-02-25 +description: C# में Aspose.HTML का उपयोग करके HTML को PNG के रूप में रेंडर कैसे करें। + HTML को इमेज में बदलना, HTML को PNG के रूप में सहेजना, और HTML से जल्दी PNG बनाना + सीखें। +draft: false +keywords: +- how to render html +- convert html to image +- save html as png +- create png from html +- generate png from html +language: hi +og_description: Aspose.HTML के साथ C# में HTML को PNG के रूप में रेंडर कैसे करें। + इस ट्यूटोरियल का पालन करके HTML को इमेज में बदलें, HTML को PNG के रूप में सहेजें, + और HTML से PNG जनरेट करें। +og_title: C# में HTML को PNG के रूप में रेंडर कैसे करें – पूर्ण गाइड +tags: +- C# +- Aspose.HTML +- Image Rendering +title: C# में HTML को PNG के रूप में रेंडर कैसे करें – चरण‑दर‑चरण गाइड +url: /hi/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# C# में HTML को PNG के रूप में रेंडर कैसे करें – चरण‑दर‑चरण गाइड + +क्या आपने कभी सोचा है **HTML को कैसे रेंडर** किया जाए सीधे PNG फ़ाइल में बिना ब्राउज़र के झंझट के? शायद आपको ईमेल में वेबपेज की एक छोटी स्नैपशॉट एम्बेड करनी है, या आप CMS के लिए थंबनेल सेवा बना रहे हैं। किसी भी तरह, समस्या मूल रूप से मार्कअप को एक बिटमैप में बदलने की है जिसे आप स्टोर या सर्व कर सकते हैं। + +इस ट्यूटोरियल में आप एक पूर्ण, तैयार‑चलाने योग्य समाधान देखेंगे जो Aspose.HTML for .NET का उपयोग करके **HTML को इमेज में बदलता** है। हम यह भी बताएँगे कि कैसे **HTML को PNG के रूप में सेव करें**, **HTML से PNG बनाएं**, और यहाँ तक कि कस्टम फ़ॉन्ट्स और डाइमेंशन्स के साथ **HTML से PNG जेनरेट करें**। कोई अस्पष्ट संदर्भ नहीं—सिर्फ वह कोड जिसे आप कॉपी‑पेस्ट कर सकते हैं, साथ ही यह समझाने के लिए कि प्रत्येक पंक्ति क्यों महत्वपूर्ण है। + +## आपको क्या चाहिए + +- .NET 6 (या कोई भी हालिया .NET रनटाइम) – API .NET Framework 4.6+ पर भी समान रूप से काम करता है। +- Visual Studio 2022 या VS Code – जो भी आपको पसंद हो। +- The **Aspose.HTML** NuGet package (`Aspose.HTML.NET`) – इसे एक बार इंस्टॉल करें और आप तैयार हैं। +- आउटपुट PNG के लिए एक लिखने योग्य फ़ोल्डर (जैसे, `C:\Temp\Images`). + +बस इतना ही। कोई अतिरिक्त बाइनरी नहीं, कोई बाहरी वेब सर्विस नहीं, और कोई छिपी हुई कॉन्फ़िगरेशन फ़ाइलें नहीं। + +## चरण 1: NuGet के माध्यम से Aspose.HTML इंस्टॉल करें + +सबसे पहले, लाइब्रेरी को अपने प्रोजेक्ट में जोड़ें। अपने सॉल्यूशन फ़ोल्डर में टर्मिनल खोलें और चलाएँ: + +```bash +dotnet add package Aspose.HTML.NET +``` + +*Pro tip:* यदि आप Visual Studio में हैं, तो **Dependencies → Manage NuGet Packages** पर राइट‑क्लिक करें, “Aspose.HTML” खोजें, और **Install** पर क्लिक करें। इससे आपको `HtmlDocument`, `ImageRenderingOptions`, और अन्य क्लासेज़ तक पहुँच मिलती है जिनका हम उपयोग करेंगे। + +## चरण 2: रेंडरिंग विकल्प सेट करें (आकार, शैली, और फ़ॉन्ट्स) + +रेंडरर को कोई भी मार्कअप देने से पहले, हम तय करते हैं कि चित्र कितना बड़ा होना चाहिए और कौन सी फ़ॉन्ट शैलियों को हम संरक्षित रखना चाहते हैं। `ImageRenderingOptions` ऑब्जेक्ट आपको चौड़ाई, ऊँचाई को समायोजित करने और यहाँ तक कि बोल्ड/इटैलिक रेंडरिंग को मजबूर करने की सुविधा देता है। + +```csharp +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +// Configure image rendering options – width, height, and font style +ImageRenderingOptions renderingOptions = new ImageRenderingOptions +{ + Width = 800, // Desired image width in pixels + Height = 600, // Desired image height in pixels + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic // Preserve bold & italic +}; +``` + +**यह क्यों महत्वपूर्ण है:** +- **Width/Height** अंतिम पिक्सेल डाइमेंशन निर्धारित करते हैं; यदि आप इन्हें छोड़ देते हैं तो इंजन HTML लेआउट के आधार पर अनुमान लगाता है, जिससे अनपेक्षित क्रॉपिंग हो सकती है। +- **FontStyle** सुनिश्चित करता है कि कोई भी `` या `` टैग रास्टराइज़ होने पर अपना दृश्य ज़ोर बनाए रखें। + +## चरण 3: अपना HTML मार्कअप लोड करें + +आप HTML को स्ट्रिंग, फ़ाइल, या URL से लोड कर सकते हैं। सरलता के लिए, हम कोड में सीधे एक छोटा स्निपेट एम्बेड करेंगे। ध्यान दें कि इनलाइन CSS फ़ॉन्ट फ़ैमिली सेट करता है – Aspose.HTML मानक वेब CSS का सम्मान करता है, इसलिए आपको एक सटीक रेंडरिंग मिलती है। + +```csharp +using Aspose.Html; + +// Create an empty HTML document +HtmlDocument htmlDoc = new HtmlDocument(); + +// Load simple markup – you could also use htmlDoc.Open("path/to/file.html") +htmlDoc.Open("Hello, world!
"); +``` + +**एज केस टिप:** यदि आपका मार्कअप बाहरी संसाधनों (इमेजेज़, CSS फ़ाइलें) को संदर्भित करता है, तो सुनिश्चित करें कि उन URLs तक कोड चलाने वाली मशीन से पहुँच हो, या उन्हें डेटा‑URIs के रूप में एम्बेड करें ताकि टूटे हुए लिंक न हों। + +## चरण 4: HTML को PNG स्ट्रीम में रेंडर करें + +अब **HTML को कैसे रेंडर करें** का मुख्य भाग आता है – हम `RenderToStream` को कॉल करते हैं, आउटपुट स्ट्रीम और पहले कॉन्फ़िगर किए गए विकल्प पास करते हैं। यह मेथड सभी भारी काम करता है: लेआउट, CSS कैस्केड, फ़ॉन्ट प्रतिस्थापन, और रास्टराइज़ेशन। + +```csharp +using System.IO; + +// Choose an output path – replace with your own directory +string outputPath = @"C:\Temp\Images\output.png"; + +using (FileStream outputStream = File.OpenWrite(outputPath)) +{ + // Render the HTML document into the PNG file + htmlDoc.RenderToStream(outputStream, renderingOptions); +} +``` + +`using` ब्लॉक समाप्त होने के बाद, `output.png` में वह 800 × 600 पिक्सेल इमेज होगी जो हमने लोड किए पैराग्राफ की है। परिणाम सत्यापित करने के लिए इसे किसी भी इमेज व्यूअर से खोलें। + +### अपेक्षित परिणाम + +आपको एक साफ़ सफ़ेद कैनवास दिखना चाहिए जिसमें टेक्स्ट **“Hello, world!”** Arial में, बोल्ड और इटैलिक, ठीक 24 pt आकार में रेंडर हुआ हो। इमेज डाइमेंशन हमारे सेट किए हुए 800 × 600 मानों से मेल खाते हैं। + +## चरण 5: सामान्य समस्याओं की जाँच और समाधान + +### 5.1 फ़ाइल मौजूद है या नहीं जांचना + +एक त्वरित सत्यापन चेक साइलेंट फेल्यर्स को रोकता है: + +```csharp +if (File.Exists(outputPath)) +{ + Console.WriteLine($"✅ PNG created successfully at {outputPath}"); +} +else +{ + Console.WriteLine("❌ Something went wrong – PNG not found."); +} +``` + +### 5.2 गायब फ़ॉन्ट्स से निपटना + +यदि लक्ष्य मशीन में अनुरोधित फ़ॉन्ट नहीं है, तो Aspose.HTML एक सामान्य सैंस‑सेरिफ़ पर फ़ॉल बैक करता है। स्थिरता सुनिश्चित करने के लिए, या तो: + +- अपने HTML में `@font-face` नियम का उपयोग करके फ़ॉन्ट फ़ाइल एम्बेड करें, **या** +- रेंडरिंग से पहले प्रोग्रामेटिकली फ़ॉन्ट रजिस्टर करें। + +```csharp +// Example of registering a custom TrueType font +htmlDoc.Fonts.AddFontFile(@"C:\Fonts\OpenSans-Regular.ttf"); +``` + +### 5.3 बड़े पेज रेंडर करना + +पूर्ण‑पेज स्क्रीनशॉट के थंबनेल बनाते समय, मेमोरी उपयोग पर नज़र रखें। आप रेंडरिंग के बाद डाउनस्केल कर सकते हैं, या `renderingOptions.Width`/`Height` को छोटे आकार पर सेट कर सकते हैं और Aspose.HTML को स्केलिंग संभालने दें। + +## पूर्ण कार्यशील उदाहरण + +नीचे पूर्ण प्रोग्राम दिया गया है जिसे आप एक कंसोल एप्लिकेशन में डाल सकते हैं और तुरंत चला सकते हैं। + +```csharp +// ----------------------------------------------------------- +// How to render HTML as PNG – Complete, runnable example +// ----------------------------------------------------------- +using System; +using System.IO; +using Aspose.Html; +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +class Program +{ + static void Main() + { + // 1️⃣ Configure rendering options + ImageRenderingOptions renderingOptions = new ImageRenderingOptions + { + Width = 800, + Height = 600, + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic + }; + + // 2️⃣ Load HTML markup + HtmlDocument htmlDoc = new HtmlDocument(); + htmlDoc.Open("Hello, world!
"); + + // 3️⃣ Define output path + string outputPath = @"C:\Temp\Images\output.png"; + + // 4️⃣ Render to PNG + using (FileStream outputStream = File.OpenWrite(outputPath)) + { + htmlDoc.RenderToStream(outputStream, renderingOptions); + } + + // 5️⃣ Verify the result + Console.WriteLine(File.Exists(outputPath) + ? $"✅ PNG saved at {outputPath}" + : "❌ Failed to create PNG"); + } +} +``` + +प्रोग्राम चलाएँ (`dotnet run`), फिर `C:\Temp\Images\output.png` खोलें। यदि सब कुछ सुचारू रूप से हुआ, तो आपने अभी **HTML को इमेज में बदल दिया** और शुद्ध C# कोड का उपयोग करके **HTML को PNG के रूप में सेव किया**। + +## अक्सर पूछे जाने वाले प्रश्न + +| Question | Answer | +|----------|--------| +| **क्या मैं बाहरी CSS/JS के साथ पूरी वेबपेज रेंडर कर सकता हूँ?** | हाँ – बस `htmlDoc.Open("https://example.com")` कॉल करें। इंजन लिंक्ड रिसोर्सेज़ को डाउनलोड करेगा, लेकिन आपको नेटवर्क एक्सेस चाहिए। | +| **PNG के अलावा कौन‑से फॉर्मेट सपोर्टेड हैं?** | `ImageRenderingOptions` JPEG, BMP, GIF, और TIFF के साथ काम करता है। आवश्यक होने पर फ़ाइल एक्सटेंशन बदलें और `ImageFormat` सेट करें। | +| **इमेज साइज पर कोई सीमा है क्या?** | तकनीकी रूप से आप कई हजार पिक्सेल तक जा सकते हैं, लेकिन बहुत बड़े डाइमेंशन मेमोरी समाप्त कर सकते हैं। अल्ट्रा‑हाई‑रेज़ आउटपुट के लिए टाइल्स में रेंडर करने पर विचार करें। | +| **प्रिंट‑क्वालिटी इमेज के लिए DPI कैसे संभालूँ?** | `renderingOptions.DpiX` और `renderingOptions.DpiY` सेट करें (डिफ़ॉल्ट 96 है)। उच्च DPI प्रिंटिंग के लिए तेज़ आउटपुट देता है। | +| **क्या मुझे Aspose.HTML के लिए लाइसेंस चाहिए?** | एक मुफ्त इवैल्यूएशन वॉटरमार्क के साथ काम करता है। प्रोडक्शन के लिए, लाइसेंस खरीदें ताकि वॉटरमार्क हटे और सभी फीचर्स अनलॉक हों। | + +## अगले कदम और संबंधित विषय + +- **Convert HTML to JPEG** – फ़ाइल एक्सटेंशन बदलें और वैकल्पिक रूप से `renderingOptions.ImageFormat = ImageFormat.Jpeg` सेट करें। +- **Batch processing** – URLs की सूची पर लूप करें और प्रत्येक के लिए थंबनेल जेनरेट करें। +- **Embedding fonts** – परफेक्ट टाइपोग्राफी के लिए अपने मार्कअप में `@font-face` का उपयोग करना सीखें। +- **Advanced layout** – कस्टम लुक्स के लिए `PageSize`, `Margin`, और `BackgroundColor` विकल्पों के साथ प्रयोग करें। + +डाइमेंशन को बदलने, विभिन्न HTML स्निपेट्स आज़माने, या इस स्निपेट को वेब API में इंटीग्रेट करने में संकोच न करें जो तुरंत PNG प्रीव्यू सर्व करता है। जब आप प्रोग्रामेटिकली **HTML को कैसे रेंडर करें** जानते हैं, तो संभावनाएँ असीमित हैं। + +--- + + + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/hongkong/net/html-extensions-and-conversions/_index.md b/html/hongkong/net/html-extensions-and-conversions/_index.md index 32e7b8fe8b..71c3be7b3e 100644 --- a/html/hongkong/net/html-extensions-and-conversions/_index.md +++ b/html/hongkong/net/html-extensions-and-conversions/_index.md @@ -115,6 +115,8 @@ Aspose.HTML for .NET 不只是一個函式庫；它還是一個函式庫。它 使用 Aspose.HTML for .NET 在 C# 中將整個網頁保存為單一 HTML 檔案，方便部署與分享。 ### [Aspose HTML 儲存選項：在 C# 中將 HTML 儲存至串流](./aspose-html-save-options-save-html-to-stream-in-c/) 示範使用 Aspose.HTML Save Options 將 HTML 輸出為記憶體串流的步驟與範例程式碼。 +### [如何在 Aspose.HTML 中使用處理程序 – 載入 HTML，儲存為 ZIP](./how-to-use-handler-in-aspose-html-load-html-save-as-zip/) +使用 Aspose.HTML for .NET 透過處理程序載入 HTML 並將其壓縮為 ZIP 檔案的完整步驟指南。 ## 結論 diff --git a/html/hongkong/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md b/html/hongkong/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md new file mode 100644 index 0000000000..bbd5a013b1 --- /dev/null +++ b/html/hongkong/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md @@ -0,0 +1,184 @@ +--- +category: general +date: 2026-02-25 +description: 如何使用處理程式從 URL 載入 HTML，並使用 Aspose.HTML 將網頁儲存為 ZIP – 完整的 C# 步驟指南. +draft: false +keywords: +- how to use handler +- load html from url +- custom resource handler +- save webpage as zip +- create zip from html +language: zh-hant +og_description: 如何使用處理程式從 URL 載入 HTML，並使用 Aspose.HTML 將網頁儲存為 ZIP。只需數分鐘即可學會完整的 C# 工作流程。 +og_title: 如何在 Aspose.HTML 中使用處理程式 – 載入 HTML，另存為 ZIP +tags: +- Aspose.HTML +- C# +- Web Scraping +title: 如何在 Aspose.HTML 中使用 handler – 載入 HTML，另存為 ZIP +url: /zh-hant/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# 如何在 Aspose.HTML 中使用處理程式 – 載入 HTML，儲存為 ZIP + +有沒有想過在將網頁拉入 .NET 應用程式時 **如何使用處理程式**？也許你已嘗試 `HtmlDocument.Open` 並取得了 HTML，但圖片、CSS 與字型卻消失不見。這是常見的問題——資源會遺失，除非你告訴 Aspose.HTML 該如何處理它們。 + +在本教學中，我們將示範如何從 URL 載入 HTML、設定 **自訂資源處理程式**，最後 **將網頁儲存為 zip**，讓你得到一個可攜式的單一壓縮檔。完成後，你將擁有一段可直接放入任何專案的 C# 程式碼片段，並附上數個能減少未來麻煩的技巧。 + +## 需要的條件 + +- .NET 6+（此 API 亦支援 .NET Core 與 .NET Framework） +- Aspose.HTML for .NET（NuGet 套件 `Aspose.HTML`） +- 具備基本的 C# 經驗（只要寫過 `Console.WriteLine` 就足夠） + +不需要額外工具或外部服務——只要有此函式庫與你想要封存的 URL 即可。 + + + +## 步驟 1：從 URL 載入 HTML + +在任何網頁抓取流程中，第一件事就是取得頁面原始碼。Aspose.HTML 讓這一步變成一行程式碼，但請記得我們是 **loading html from url**，使用內建的網路堆疊。 + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +// 1️⃣ Load the page you want to archive +HtmlDocument htmlDoc = new HtmlDocument(); +htmlDoc.Open("https://example.com"); // replace with any public URL +``` + +> **為什麼這很重要：** `HtmlDocument.Open` 會解析標記 *並* 內部解析相對 URL，但它不會自動保存外部資源。因此稍後需要使用處理程式。 + +## 步驟 2：建立自訂資源處理程式 + +現在進入核心——**how to use handler** 以攔截每一個外部資源請求（圖片、CSS、字型等）。透過繼承 `ResourceHandler`，你可以完全掌控每個資產背後的串流。 + +```csharp +// 2️⃣ Define your own handler (optional but powerful) +public class MyResourceHandler : ResourceHandler +{ + // Called for each external resource the document needs + public override Stream HandleResource(ResourceInfo info) + { + // Here you could download the file, cache it, or rewrite it. + // For this demo we simply return an empty stream – Aspose will + // still create the entry in the ZIP, keeping the folder structure. + return new MemoryStream(); + } +} +``` + +> **專業提示：** 在正式環境中，你可能想下載實際的位元組（`HttpClient.GetStreamAsync(info.Uri)`）並回傳該串流。這樣儲存的 ZIP 才會包含真實的圖片，而不是空白佔位符。 + +## 步驟 3：設定儲存選項並附加處理程式 + +處理程式準備好後，我們告訴 Aspose.HTML 如何打包所有內容。`HtmlSaveOptions` 類別允許你開啟 `SaveToZipArchive` 開關，並插入自訂的 `MyResourceHandler`。 + +```csharp +// 3️⃣ Set up saving options – this is where we **save webpage as zip** +HtmlSaveOptions saveOptions = new HtmlSaveOptions +{ + // Attach our custom handler – new API as of v22.10 + OutputStorage = new MyResourceHandler(), + + // Instruct Aspose to bundle HTML + resources into a single ZIP file + SaveToZipArchive = true +}; +``` + +> **說明：** `OutputStorage` 是接收處理程式實例的屬性。當儲存器遍歷 DOM 時，會對每個外部連結呼叫 `HandleResource`。因為 `SaveToZipArchive` 為 true，儲存器會將每個回傳的串流寫入與原始路徑相對應的 ZIP 條目。 + +## 步驟 4：將文件儲存至 MemoryStream + +我們可以直接寫入磁碟，但將所有內容保留在記憶體中，可讓程式碼在 ASP.NET、Azure Functions 或任何不想產生暫存檔的環境下使用。以下是最終步驟，**creates zip from html**。 + +```csharp +// 4️⃣ Save everything – HTML + resources – into a MemoryStream +using (MemoryStream outputStream = new MemoryStream()) +{ + htmlDoc.Save(outputStream, saveOptions); + + // At this point outputStream holds a valid ZIP archive. + // For demo purposes we write it to the file system: + File.WriteAllBytes("example_page.zip", outputStream.ToArray()); +} +``` + +### 預期結果 + +- `example_page.zip` 會出現在你的專案資料夾中。 +- 解壓縮後會看到 `index.html` 以及 `images/`、`css/` 等資料夾結構。 +- 雖然我們的示範處理程式回傳了空串流，ZIP 佈局仍與原始頁面相同，日後只要換成真實的下載器即可。 + +## 常見變化與邊緣情況 + +### 載入本機檔案而非 URL + +如果需要 **load html from url**‑類似的本機路徑，只要將 `htmlDoc.Open("https://example.com")` 改成 `htmlDoc.Open(@"C:\path\to\file.html")` 即可。其餘流程保持不變。 + +### 保存真實資源 + +若要真正嵌入圖片，請修改 `HandleResource`： + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Download the resource using HttpClient + HttpClient client = new HttpClient(); + var data = client.GetByteArrayAsync(info.Uri).Result; + return new MemoryStream(data); +} +``` + +> **注意：** 在處理程式內部執行網路呼叫會阻塞儲存執行緒；對於大型頁面，建議改用非同步處理程式（新版 Aspose 已支援）。 + +### 更改 ZIP 條目名稱 + +`ResourceInfo` 包含 `FileName` 與 `Path`。你可以重新寫入這兩個屬性，以平鋪層級或加入前綴： + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Example: prepend "assets/" to every entry + info.Path = Path.Combine("assets", info.Path); + return base.HandleResource(info); +} +``` + +### 使用不同的 OutputStorage + +`OutputStorage` 也可以是 `FileSystemStorage`，如果你想要輸出到資料夾而非 ZIP。只要將 `SaveToZipArchive = false`，並將 `OutputStorage` 指向目錄路徑即可。 + +## 專業提示與陷阱 + +- **不要忘記釋放** `HtmlDocument`，如果在迴圈中開啟多個頁面，否則可能會洩漏原生資源。 +- **記憶體使用量：** 將巨大的頁面儲存至 `MemoryStream` 會佔用大量 RAM。對於多 MB 的壓縮檔，建議直接串流至檔案（`FileStream`）。 +- **字元編碼：** Aspose.HTML 會遵循 `` 標籤。若來源頁面使用不常見的編碼，請確認抽取後的 HTML 能正確顯示。 +- **測試方式：** 在瀏覽器中開啟產生的 ZIP（將 `index.html` 拖出），確認所有資源均能正確解析。若圖片缺失，可能是 `HandleResource` 回傳了空串流。 + +## 重點回顧 + +我們已說明 **how to use handler** 以攔截外部資源，示範 **load html from url**，建立 **custom resource handler**，最後 **save webpage as zip**——也就是以少量 C# 程式碼 **create zip from html**。此模式具備可擴充性：只要把空的 `MemoryStream` 換成真實的下載器、變更輸出目標，或將邏輯嵌入 Web API，即可即時回傳 ZIP。 + +--- + +### 接下來？ + +- **批次處理：** 迭代 URL 清單，為每個頁面產生一個 ZIP。 +- **壓縮調整：** 使用 `ZipSaveOptions` 調整壓縮等級，以加快下載速度。 +- **與 ASP.NET Core 整合：** 將 `MemoryStream` 以 `FileResult` 回傳，讓使用者直接從 Web 端點下載壓縮檔。 +- **探索其他 Aspose.HTML 功能：** PDF 轉換、DOM 操作或無頭渲染。 + +對特定使用情境有疑問——例如需要保留 JavaScript 或處理需要驗證的頁面？歡迎在下方留言，我會進一步說明。祝 coding 愉快！ + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/hongkong/net/rendering-html-documents/_index.md b/html/hongkong/net/rendering-html-documents/_index.md index bb417e6894..d9ac6d90ad 100644 --- a/html/hongkong/net/rendering-html-documents/_index.md +++ b/html/hongkong/net/rendering-html-documents/_index.md @@ -79,6 +79,9 @@ Aspose.HTML for .NET 因其豐富的功能、優秀的文件和活躍的社群 ### [如何使用 Aspose 將 HTML 渲染為 PNG – 步驟指南](./how-to-use-aspose-to-render-html-to-png-step-by-step-guide/) 一步步教您使用 Aspose.HTML for .NET 將 HTML 轉換為 PNG 圖像，掌握渲染技巧與設定。 +### [如何在 C# 中將 HTML 渲染為 PNG – 步驟指南](./how-to-render-html-as-png-in-c-step-by-step-guide/) +一步步教您在 C# 中使用 Aspose.HTML for .NET 將 HTML 轉換為 PNG 圖像，掌握關鍵設定與技巧。 + ### [如何使用 Aspose 將 HTML 渲染為 PNG – 完整指南](./how-to-render-html-to-png-with-aspose-complete-guide/) 完整步驟教您使用 Aspose.HTML for .NET 將 HTML 轉換為 PNG 圖像，掌握所有設定與最佳實踐。 ### [使用 C# 建立 HTML 文件 – 以粗斜體字型渲染為 PNG](./create-html-document-c-render-to-png-with-bold-italic-font/) diff --git a/html/hongkong/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md b/html/hongkong/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..2abb8215ba --- /dev/null +++ b/html/hongkong/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md @@ -0,0 +1,222 @@ +--- +category: general +date: 2026-02-25 +description: 如何在 C# 中使用 Aspose.HTML 將 HTML 渲染為 PNG。學習將 HTML 轉換為圖像、將 HTML 儲存為 PNG，並快速從 + HTML 建立 PNG。 +draft: false +keywords: +- how to render html +- convert html to image +- save html as png +- create png from html +- generate png from html +language: zh-hant +og_description: 如何在 C# 中使用 Aspose.HTML 將 HTML 渲染為 PNG。請參考本教學將 HTML 轉換為圖片、儲存為 PNG，並從 + HTML 產生 PNG。 +og_title: 如何在 C# 中將 HTML 轉換為 PNG – 完整指南 +tags: +- C# +- Aspose.HTML +- Image Rendering +title: 如何在 C# 中將 HTML 渲染為 PNG – 逐步指南 +url: /zh-hant/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# 如何在 C# 中將 HTML 渲染為 PNG – 步驟指南 + +有沒有想過 **如何將 HTML 渲染** 直接成 PNG 檔案，而不需要啟動瀏覽器？也許你需要在電郵中嵌入網頁的微型快照，或是為 CMS 建立縮圖服務。無論哪種情況，問題最終都是把標記轉換成可儲存或提供的位圖。 + +在本教學中，你將看到一個完整、可直接執行的解決方案，使用 Aspose.HTML for .NET **將 HTML 轉換為影像**。我們還會說明如何 **將 HTML 儲存為 PNG**、**從 HTML 建立 PNG**，甚至 **使用自訂字型與尺寸產生 PNG**。不會有模糊的參考——只提供可直接複製貼上的程式碼，並說明每一行的意義。 + +## 需要的環境 + +- .NET 6（或任何較新的 .NET 執行環境）— API 在 .NET Framework 4.6+ 上的行為相同。 +- Visual Studio 2022 或 VS Code — 依你喜好選擇。 +- **Aspose.HTML** NuGet 套件 (`Aspose.HTML.NET`) — 安裝一次即可使用。 +- 一個可寫入的資料夾作為輸出 PNG（例如 `C:\Temp\Images`）。 + +就這樣。沒有額外的二進位檔案、沒有外部網路服務，也沒有隱藏的設定檔。 + +## 步驟 1：透過 NuGet 安裝 Aspose.HTML + +首先，將函式庫加入你的專案。於解決方案資料夾開啟終端機並執行： + +```bash +dotnet add package Aspose.HTML.NET +``` + +*小技巧：* 若你使用 Visual Studio，右鍵點選 **Dependencies → Manage NuGet Packages**，搜尋 “Aspose.HTML”，然後點擊 **Install**。這樣即可取得 `HtmlDocument`、`ImageRenderingOptions` 以及其他我們將會使用的類別。 + +## 步驟 2：設定渲染選項（尺寸、樣式與字型） + +在將任何標記送入渲染器之前，我們先決定圖片的大小以及要保留的字型樣式。`ImageRenderingOptions` 物件讓你調整寬度、高度，甚至強制粗體/斜體的渲染。 + +```csharp +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +// Configure image rendering options – width, height, and font style +ImageRenderingOptions renderingOptions = new ImageRenderingOptions +{ + Width = 800, // Desired image width in pixels + Height = 600, // Desired image height in pixels + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic // Preserve bold & italic +}; +``` + +**為什麼這很重要：** +- **Width/Height** 決定最終的像素尺寸；若未指定，引擎會根據 HTML 版面自行推測，可能導致意外裁切。 +- **FontStyle** 確保任何 `` 或 `` 標籤在光柵化時仍保留其視覺強調。 + +## 步驟 3：載入 HTML 標記 + +你可以從字串、檔案或 URL 載入 HTML。為了簡化示範，我們會直接在程式碼中嵌入一小段片段。請注意設定字型族的內嵌 CSS——Aspose.HTML 會遵循標準的網頁 CSS，因而產生忠實的渲染結果。 + +```csharp +using Aspose.Html; + +// Create an empty HTML document +HtmlDocument htmlDoc = new HtmlDocument(); + +// Load simple markup – you could also use htmlDoc.Open("path/to/file.html") +htmlDoc.Open("Hello, world!
"); +``` + +**特殊情況提示：** 若你的標記引用了外部資源（圖片、CSS 檔案），請確保這些 URL 在執行程式的機器上可存取，或以 data‑URI 方式嵌入，以避免連結失效。 + +## 步驟 4：將 HTML 渲染為 PNG 串流 + +現在進入 **如何渲染 HTML** 的核心——呼叫 `RenderToStream`，傳入輸出串流以及先前設定的選項。此方法會處理所有繁重工作：版面配置、CSS 繼承、字型替換與光柵化。 + +```csharp +using System.IO; + +// Choose an output path – replace with your own directory +string outputPath = @"C:\Temp\Images\output.png"; + +using (FileStream outputStream = File.OpenWrite(outputPath)) +{ + // Render the HTML document into the PNG file + htmlDoc.RenderToStream(outputStream, renderingOptions); +} +``` + +當 `using` 區塊結束後，`output.png` 會包含一張 800 × 600 像素的圖片，內容為我們載入的段落。使用任何影像檢視器開啟即可驗證結果。 + +### 預期結果 + +你應該會看到一個乾淨的白色畫布，文字 **“Hello, world!”** 以 Arial、粗體斜體、正好 24 pt 大小渲染。影像尺寸與我們設定的 800 × 600 相符。 + +## 步驟 5：驗證與處理常見問題 + +### 5.1 檢查檔案是否存在 + +快速的健全性檢查可避免無聲失敗： + +```csharp +if (File.Exists(outputPath)) +{ + Console.WriteLine($"✅ PNG created successfully at {outputPath}"); +} +else +{ + Console.WriteLine("❌ Something went wrong – PNG not found."); +} +``` + +### 5.2 處理缺少的字型 + +若目標機器缺少所請求的字型，Aspose.HTML 會退回使用通用的無襯線字型。為確保一致性，可採取以下任一方式： + +- 在 HTML 中使用 `@font-face` 規則嵌入字型檔案，**或** +- 在渲染前以程式方式註冊字型。 + +```csharp +// Example of registering a custom TrueType font +htmlDoc.Fonts.AddFontFile(@"C:\Fonts\OpenSans-Regular.ttf"); +``` + +### 5.3 渲染大型頁面 + +在為整頁螢幕截圖建立縮圖時，請留意記憶體使用量。你可以在渲染後縮小尺寸，或將 `renderingOptions.Width`/`Height` 設為較小的值，讓 Aspose.HTML 處理縮放。 + +## 完整可執行範例 + +以下是完整程式碼，你可以直接放入主控台應用程式並立即執行。 + +```csharp +// ----------------------------------------------------------- +// How to render HTML as PNG – Complete, runnable example +// ----------------------------------------------------------- +using System; +using System.IO; +using Aspose.Html; +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +class Program +{ + static void Main() + { + // 1️⃣ Configure rendering options + ImageRenderingOptions renderingOptions = new ImageRenderingOptions + { + Width = 800, + Height = 600, + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic + }; + + // 2️⃣ Load HTML markup + HtmlDocument htmlDoc = new HtmlDocument(); + htmlDoc.Open("Hello, world!
"); + + // 3️⃣ Define output path + string outputPath = @"C:\Temp\Images\output.png"; + + // 4️⃣ Render to PNG + using (FileStream outputStream = File.OpenWrite(outputPath)) + { + htmlDoc.RenderToStream(outputStream, renderingOptions); + } + + // 5️⃣ Verify the result + Console.WriteLine(File.Exists(outputPath) + ? $"✅ PNG saved at {outputPath}" + : "❌ Failed to create PNG"); + } +} +``` + +執行程式 (`dotnet run`)，然後開啟 `C:\Temp\Images\output.png`。若一切順利，你剛剛已使用純 C# 程式碼 **將 HTML 轉換為影像** 並 **將 HTML 儲存為 PNG**。 + +## 常見問題 + +| Question | Answer | +|----------|--------| +| **我可以渲染包含外部 CSS/JS 的完整網頁嗎？** | 可以——只要呼叫 `htmlDoc.Open("https://example.com")`。引擎會下載連結的資源，但需要網路存取。 | +| **除了 PNG，還支援哪些格式？** | `ImageRenderingOptions` 支援 JPEG、BMP、GIF 與 TIFF。視需要更改檔案副檔名並設定 `ImageFormat`。 | +| **影像尺寸有上限嗎？** | 技術上可以到數千像素，但過大的尺寸可能耗盡記憶體。若需超高解析度，建議分區塊渲染。 | +| **如何處理列印品質影像的 DPI？** | 設定 `renderingOptions.DpiX` 與 `renderingOptions.DpiY`（預設為 96）。較高的 DPI 可產生更銳利的列印輸出。 | +| **使用 Aspose.HTML 是否需要授權？** | 免費評估版會加上浮水印。正式使用時，購買授權即可移除浮水印並解鎖全部功能。 | + +## 後續步驟與相關主題 + +- **將 HTML 轉換為 JPEG** – 更換檔案副檔名，並可選擇設定 `renderingOptions.ImageFormat = ImageFormat.Jpeg`。 +- **批次處理** – 迭代 URL 清單，為每個產生縮圖。 +- **嵌入字型** – 了解如何在標記中使用 `@font-face` 以獲得完美排版。 +- **進階版面** – 嘗試 `PageSize`、`Margin` 與 `BackgroundColor` 等選項，以打造自訂外觀。 + +隨意調整尺寸、嘗試不同的 HTML 片段，或將此程式碼整合至即時提供 PNG 預覽的 Web API。只要掌握 **如何程式化渲染 HTML**，就沒有做不到的事。 + +--- + + + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/hungarian/net/html-extensions-and-conversions/_index.md b/html/hungarian/net/html-extensions-and-conversions/_index.md index e234e71db1..38e5794c97 100644 --- a/html/hungarian/net/html-extensions-and-conversions/_index.md +++ b/html/hungarian/net/html-extensions-and-conversions/_index.md @@ -97,6 +97,8 @@ Ismerje meg, hogyan hozhat létre PDF-et HTML-ből C#-ban az Aspose.HTML for .NE Ismerje meg, hogyan menthet HTML-fájlt ZIP-archívumba C#-ban az Aspose.HTML for .NET segítségével. ### [HTML zip-elése C#-ban – Egyéni erőforráskezelő oktatóanyag](./how-to-zip-html-in-c-custom-resource-handler-tutorial/) Ismerje meg, hogyan használhat egyéni erőforráskezelőt a HTML zip-eléséhez C#-ban az Aspose.HTML for .NET segítségével. +### [Hogyan használjon handlert az Aspose.HTML-ben – HTML betöltése, mentés ZIP-be](./how-to-use-handler-in-aspose-html-load-html-save-as-zip/) +Ismerje meg, hogyan használhat handlert az Aspose.HTML-ben HTML betöltéséhez és ZIP-archívumba mentéséhez C#-ban. ## Következtetés diff --git a/html/hungarian/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md b/html/hungarian/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md new file mode 100644 index 0000000000..21c061e398 --- /dev/null +++ b/html/hungarian/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md @@ -0,0 +1,187 @@ +--- +category: general +date: 2026-02-25 +description: Hogyan használjunk kezelőt a HTML betöltéséhez URL-ről, és hogyan menthetjük + el a weboldalt zip fájlként az Aspose.HTML segítségével – egy teljes C# lépésről‑lépésre + útmutató. +draft: false +keywords: +- how to use handler +- load html from url +- custom resource handler +- save webpage as zip +- create zip from html +language: hu +og_description: Hogyan használjunk handlert HTML betöltéséhez URL-ről, és mentse a + weboldalt zip fájlként az Aspose.HTML segítségével. Tanulja meg a teljes C# munkafolyamatot + percek alatt. +og_title: Hogyan használjuk a kezelőt az Aspose.HTML-ben – HTML betöltése, ZIP-be + mentés +tags: +- Aspose.HTML +- C# +- Web Scraping +title: Hogyan használjuk a kezelőt az Aspose.HTML-ben – HTML betöltése, ZIP-be mentés +url: /hu/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Hogyan használjunk kezelőt az Aspose.HTML‑ben – HTML betöltése, ZIP‑ként mentés + +Gondolkodtál már azon, **hogyan használjunk kezelőt**, amikor egy weboldalt húzol be a .NET alkalmazásodba? Lehet, hogy már kipróbáltad a `HtmlDocument.Open`‑t, és megkaptad a HTML‑t, de a képek, a CSS és a betűtípusok a levegőbe szálltak. Ez egy gyakori csapda – az erőforrások elvesznek, hacsak nem mondod meg az Aspose.HTML‑nek, mit tegyen velük. + +Ebben az útmutatóban végigvezetünk a HTML betöltésén egy URL‑ről, egy **egyedi erőforráskezelő** felépítésén, és végül a **weboldal ZIP‑ként mentésén**, így egyetlen hordozható archívumot kapsz. A végére egy kész C# kódrészletet fogsz kapni, amelyet bármely projektbe beilleszthetsz, valamint néhány tippet, amelyek később megkímélnek a fejfájástól. + +## Amire szükséged lesz + +- .NET 6+ (az API működik .NET Core‑on és .NET Framework‑ön is) +- Aspose.HTML for .NET (NuGet csomag `Aspose.HTML`) +- Mérsékelt C# tapasztalat (rendben leszel, ha már írtál egy `Console.WriteLine`‑t korábban) + +Nincs szükség extra eszközökre, külső szolgáltatásokra – csak a könyvtárra és egy URL‑re, amelyet archiválni szeretnél. + + + +## 1. lépés: HTML betöltése URL‑ről + +Az első dolog minden web‑kaparási folyamatban az oldal forrásának lekérése. Az Aspose.HTML ezt egyetlen sorra csökkenti, de ne feledd, hogy **HTML betöltése URL‑ről** a beépített hálózati stackkel történik. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +// 1️⃣ Load the page you want to archive +HtmlDocument htmlDoc = new HtmlDocument(); +htmlDoc.Open("https://example.com"); // replace with any public URL +``` + +> **Miért fontos:** `HtmlDocument.Open` elemzi a jelölőnyelvet *és* belsőleg feloldja a relatív URL‑ket, de nem menti automatikusan a külső erőforrásokat. Ezért lesz később szükségünk egy kezelőre. + +## 2. lépés: Egyedi erőforráskezelő létrehozása + +Most jön a lényeg – **hogyan használjunk kezelőt**, hogy minden külső erőforráskérést (képek, CSS, betűtípusok stb.) elfogj. A `ResourceHandler` alosztályozásával teljes irányítást kapsz az egyes eszközöket támogató stream felett. + +```csharp +// 2️⃣ Define your own handler (optional but powerful) +public class MyResourceHandler : ResourceHandler +{ + // Called for each external resource the document needs + public override Stream HandleResource(ResourceInfo info) + { + // Here you could download the file, cache it, or rewrite it. + // For this demo we simply return an empty stream – Aspose will + // still create the entry in the ZIP, keeping the folder structure. + return new MemoryStream(); + } +} +``` + +> **Pro tipp:** Egy éles környezetben érdemes lehet letölteni a tényleges bájtokat (`HttpClient.GetStreamAsync(info.Uri)`) és visszaadni azt a streamet. Ez biztosítja, hogy a mentett ZIP a valódi képeket tartalmazza, ne üres helyőrzőket. + +## 3. lépés: Mentési beállítások konfigurálása és a kezelő csatolása + +Miután a kezelő készen áll, megmondjuk az Aspose.HTML‑nek, hogyan csomagolja össze az egészet. A `HtmlSaveOptions` osztály lehetővé teszi a `SaveToZipArchive` kapcsoló átkapcsolását és a saját `MyResourceHandler` beillesztését. + +```csharp +// 3️⃣ Set up saving options – this is where we **save webpage as zip** +HtmlSaveOptions saveOptions = new HtmlSaveOptions +{ + // Attach our custom handler – new API as of v22.10 + OutputStorage = new MyResourceHandler(), + + // Instruct Aspose to bundle HTML + resources into a single ZIP file + SaveToZipArchive = true +}; +``` + +> **Magyarázat:** Az `OutputStorage` az a tulajdonság, amely a kezelő példányt kapja. Amikor a mentő bejárja a DOM‑ot, minden külső hivatkozáshoz meghívja a `HandleResource`‑t. Mivel a `SaveToZipArchive` igaz, a mentő minden visszaadott streamet egy eredeti útvonalnak megfelelő ZIP bejegyzésbe ír. + +## 4. lépés: Dokumentum mentése memória‑streambe + +Írhatnánk közvetlenül a lemezre, de a memória‑ban tartás lehetővé teszi a kód használatát ASP.NET‑ben, Azure Functions‑ben vagy bármilyen helyen, ahol nem szeretnél ideiglenes fájlt. Íme az utolsó lépés, amely **ZIP‑et hoz létre HTML‑ből**. + +```csharp +// 4️⃣ Save everything – HTML + resources – into a MemoryStream +using (MemoryStream outputStream = new MemoryStream()) +{ + htmlDoc.Save(outputStream, saveOptions); + + // At this point outputStream holds a valid ZIP archive. + // For demo purposes we write it to the file system: + File.WriteAllBytes("example_page.zip", outputStream.ToArray()); +} +``` + +### Várható eredmény + +- `example_page.zip` megjelenik a projekt mappádban. +- A ZIP‑ben megtalálod az `index.html`‑t és egy mappaszerkezetet (`images/`, `css/`, stb.). +- Bár a demó kezelő üres streameket adott vissza, a ZIP felépítése tükrözi az eredeti oldalt – tökéletes a későbbi valódi letöltő beillesztéséhez. + +## Gyakori variációk és szélhelyzetek + +### Helyi fájl betöltése URL helyett + +Ha **HTML betöltése URL‑hez hasonló** útvonalakon a lemezen szükséges, egyszerűen cseréld le a `htmlDoc.Open("https://example.com")`‑t erre: `htmlDoc.Open(@"C:\path\to\file.html")`. A csővezeték többi része változatlan marad. + +### Valódi erőforrások mentése + +A képek tényleges beágyazásához módosítsd a `HandleResource`‑t: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Download the resource using HttpClient + HttpClient client = new HttpClient(); + var data = client.GetByteArrayAsync(info.Uri).Result; + return new MemoryStream(data); +} +``` + +> **Figyelmeztetés:** A hálózati hívások a kezelőben blokkolják a mentő szálat; nagy oldalak esetén fontold meg a kezelő aszinkronná tételét (újabb Aspose kiadásokban elérhető). + +### A ZIP bejegyzés nevének módosítása + +`ResourceInfo` tartalmazza a `FileName` és a `Path` mezőket. Átírhatod őket a hierarchia laposításához vagy egy előtag hozzáadásához: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Example: prepend "assets/" to every entry + info.Path = Path.Combine("assets", info.Path); + return base.HandleResource(info); +} +``` + +### Másik kimeneti tároló használata + +`OutputStorage` lehet `FileSystemStorage` is, ha mappát szeretnél ZIP helyett. Csak állítsd be a `SaveToZipArchive = false` értéket, és irányítsd az `OutputStorage`‑t egy könyvtár útvonalára. + +## Profi tippek és buktatók + +- **Ne felejtsd el eldobni** a `HtmlDocument`‑et, ha egy ciklusban sok oldalt nyitsz; különben natív erőforrásokat szivárogtathatsz. +- **Memóriahasználat:** Nagy oldalak `MemoryStream`‑be mentése RAM‑ot pufferelhet. Több megabájtos archívumok esetén streamelj közvetlenül egy fájlba (`FileStream`) helyette. +- **Karakterkódolás:** Az Aspose.HTML tiszteletben tartja a `` tag-et. Ha a forrásoldal ritka kódolást használ, ellenőrizd, hogy a kinyert HTML helyesen jelenik‑e meg. +- **Tesztelés:** Nyisd meg a generált ZIP‑et egy böngészőben (húzd ki az `index.html`‑t), hogy megbizonyosodj a források feloldásáról. Ha képek hiányoznak, a `HandleResource` valószínűleg üres streamet adott vissza. + +## Összefoglaló + +Áttekintettük, **hogyan használjunk kezelőt** a külső erőforrások elfogásához, bemutattuk a **HTML betöltését URL‑ről**, felépítettünk egy **egyedi erőforráskezelőt**, és végül **weboldal mentését ZIP‑ként** – hatékonyan **ZIP‑et hozunk létre HTML‑ből** néhány C# sorral. A minta skálázható: cseréld le az üres `MemoryStream`‑et egy valódi letöltőre, módosítsd a kimeneti célt, vagy ágyazd be a logikát egy web‑API‑ba, amely kérésre visszaadja a ZIP‑et. + +### Mi következik? + +- **Kötegelt feldolgozás:** Ciklus egy URL‑lista felett, és ZIP generálása oldalanként. +- **Tömörítési finomhangolás:** Használd a `ZipSaveOptions`‑t a tömörítési szint beállításához a gyorsabb letöltés érdekében. +- **Integráció ASP.NET Core‑dal:** Add vissza a `MemoryStream`‑et `FileResult`‑ként, hogy a felhasználók közvetlenül egy web‑végpontról letölthessék az archívumot. +- **Fedezd fel az Aspose.HTML további funkcióit:** PDF konverzió, DOM manipuláció vagy headless renderelés. + +Van kérdésed egy konkrét felhasználási esettel kapcsolatban – talán meg kell őrizned a JavaScript‑et vagy kezelned kell a hitelesítéssel védett oldalakat? Írj egy megjegyzést alább; szívesen merülök el részletesebben. Boldog kódolást! + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/hungarian/net/rendering-html-documents/_index.md b/html/hungarian/net/rendering-html-documents/_index.md index aac1f3d3ee..54ed8cc0a7 100644 --- a/html/hungarian/net/rendering-html-documents/_index.md +++ b/html/hungarian/net/rendering-html-documents/_index.md @@ -50,6 +50,8 @@ Tanulja meg, hogyan renderelhet HTML-t PNG formátumba az Aspose.HTML for .NET s Ismerje meg, hogyan renderelhet HTML-t PNG formátumba C#-ban az Aspose.HTML segítségével, lépésről lépésre útmutató. ### [HTML renderelése PNG-ként C#-ban – Lépésről‑lépésre útmutató](./how-to-render-html-to-png-in-c-step-by-step-guide/) Tanulja meg, hogyan renderelhet HTML-t PNG formátumba C#-ban az Aspose.HTML for .NET használatával. +### [HTML renderelése PNG-ként C#-ban – Lépésről lépésre útmutató](./how-to-render-html-as-png-in-c-step-by-step-guide/) +Tanulja meg, hogyan renderelhet HTML-t PNG formátumba C#-ban az Aspose segítségével, részletes lépésről lépésre útmutató. ### [Az EPUB megjelenítése XPS-ként .NET-ben az Aspose.HTML segítségével](./render-epub-as-xps/) Ebben az átfogó oktatóanyagban megtudhatja, hogyan hozhat létre és jeleníthet meg HTML-dokumentumokat az Aspose.HTML for .NET segítségével. Merüljön el a webkaparás és egyebek világában. ### [Renderelési időtúllépés .NET-ben az Aspose.HTML-lel](./rendering-timeout/) diff --git a/html/hungarian/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md b/html/hungarian/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..3ef64a61cc --- /dev/null +++ b/html/hungarian/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md @@ -0,0 +1,224 @@ +--- +category: general +date: 2026-02-25 +description: Hogyan lehet HTML-t PNG-ként megjeleníteni C#-ban az Aspose.HTML használatával. + Tanulja meg, hogyan konvertálja a HTML-t képpé, mentse a HTML-t PNG-ként, és gyorsan + hozzon létre PNG-t a HTML-ből. +draft: false +keywords: +- how to render html +- convert html to image +- save html as png +- create png from html +- generate png from html +language: hu +og_description: HTML renderelése PNG-ként C#-ban az Aspose.HTML segítségével. Kövesd + ezt az útmutatót, hogy HTML-t képpé konvertálj, HTML-t PNG-ként ments, és PNG-t + generálj HTML-ből. +og_title: HTML renderelése PNG-ként C#-ban – Teljes útmutató +tags: +- C# +- Aspose.HTML +- Image Rendering +title: HTML PNG‑ként történő renderelése C#‑ban – Lépésről lépésre útmutató +url: /hu/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Hogyan rendereljük a HTML-t PNG‑ként C#‑ban – Lépésről lépésre útmutató + +Gondolkodtál már azon, **hogyan rendereljük a HTML‑t** közvetlenül egy PNG fájlba anélkül, hogy böngészőt kellene használni? Lehet, hogy egy apró weboldal‑pillanatképet kell beágyaznod egy e‑mailbe, vagy egy bélyegkép‑szolgáltatást építesz egy CMS‑hez. Bárhogy is, a feladat lényege, hogy a jelölőnyelvet egy olyan bitmap‑képpé alakítsuk, amelyet tárolhatunk vagy kiszolgálhatunk. + +Ebben a tutorialban egy teljes, azonnal futtatható megoldást látsz, amely **HTML‑t képpé konvertál** az Aspose.HTML for .NET segítségével. Megérintjük azt is, hogyan **menthetünk HTML‑t PNG‑ként**, **hozhatunk létre PNG‑t HTML‑ből**, és akár **generálhatunk PNG‑t HTML‑ből** egyedi betűtípusokkal és méretekkel. Nincsenek homályos hivatkozások – csak a másolás‑beillesztésre kész kód, valamint magyarázatok arról, miért fontos minden egyes sor. + +## Amit szükséged lesz + +- .NET 6 (vagy bármely friss .NET runtime) – az API ugyanúgy működik a .NET Framework 4.6+ alatt is. +- Visual Studio 2022 vagy VS Code – bármelyik, amit kedvelsz. +- Az **Aspose.HTML** NuGet csomag (`Aspose.HTML.NET`) – telepítsd egyszer, és készen állsz. +- Írási jogosultsággal rendelkező mappa a kimeneti PNG‑hez (pl. `C:\Temp\Images`). + +Ennyi. Nincs extra bináris, nincs külső webszolgáltatás, és nincs rejtett konfigurációs fájl. + +## 1. lépés: Aspose.HTML telepítése NuGet‑en keresztül + +Először add hozzá a könyvtárat a projekthez. Nyisd meg a terminált a megoldás mappájában, és futtasd: + +```bash +dotnet add package Aspose.HTML.NET +``` + +*Pro tipp:* Ha Visual Studio‑t használsz, kattints jobb‑gombbal a **Dependencies → Manage NuGet Packages**‑re, keresd meg a “Aspose.HTML”‑t, és nyomd meg a **Install** gombot. Így hozzáférsz a `HtmlDocument`, `ImageRenderingOptions` és a további osztályokhoz, amelyeket használni fogunk. + +## 2. lépés: Renderelési beállítások konfigurálása (méret, stílus, betűk) + +Mielőtt bármilyen jelölőt átadnánk a renderelőnek, meg kell határoznunk, mekkora legyen a kép, és mely betűstílusokat akarjuk megőrizni. Az `ImageRenderingOptions` objektum lehetővé teszi a szélesség, magasság és akár a félkövér/dőlt megjelenítés kényszerítését is. + +```csharp +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +// Configure image rendering options – width, height, and font style +ImageRenderingOptions renderingOptions = new ImageRenderingOptions +{ + Width = 800, // Desired image width in pixels + Height = 600, // Desired image height in pixels + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic // Preserve bold & italic +}; +``` + +**Miért fontos:** +- **Width/Height** meghatározza a végső pixelméreteket; ha ezeket kihagyod, a motor a HTML‑elrendezés alapján tippel, ami váratlan levágáshoz vezethet. +- **FontStyle** biztosítja, hogy a `` vagy `` elemek vizuális hangsúlya megmaradjon a rasterizálás során. + +## 3. lépés: HTML jelölő betöltése + +HTML‑t betölthetsz egy stringből, fájlból vagy URL‑ből. Egyszerűség kedvéért egy apró kódrészletet ágyazunk be közvetlenül a forrásba. Figyeld meg az inline CSS‑t, amely a betűcsaládot állítja – az Aspose.HTML a szabványos web‑CSS‑t tiszteletben tartja, így hű renderelést kapsz. + +```csharp +using Aspose.Html; + +// Create an empty HTML document +HtmlDocument htmlDoc = new HtmlDocument(); + +// Load simple markup – you could also use htmlDoc.Open("path/to/file.html") +htmlDoc.Open("Hello, world!
"); +``` + +**Edge case tipp:** Ha a jelölőd külső erőforrásokra (képek, CSS‑fájlok) hivatkozik, győződj meg róla, hogy ezek az URL‑ek elérhetők legyenek a kódot futtató gépről, vagy ágyazd be őket data‑URI‑ként, hogy elkerüld a törött hivatkozásokat. + +## 4. lépés: HTML renderelése PNG‑stream‑be + +Most jön a **hogyan rendereljük a HTML‑t** lényege – meghívjuk a `RenderToStream`‑et, átadva a kimeneti stream‑et és a korábban beállított opciókat. A metódus elvégzi a nehéz munkát: elrendezés, CSS‑kaszkád, betűtípus‑helyettesítés és rasterizálás. + +```csharp +using System.IO; + +// Choose an output path – replace with your own directory +string outputPath = @"C:\Temp\Images\output.png"; + +using (FileStream outputStream = File.OpenWrite(outputPath)) +{ + // Render the HTML document into the PNG file + htmlDoc.RenderToStream(outputStream, renderingOptions); +} +``` + +Miután a `using` blokk befejeződik, az `output.png` egy 800 × 600 pixeles képet tartalmaz a betöltött bekezdésről. Nyisd meg bármely képnézővel, hogy ellenőrizd az eredményt. + +### Várható eredmény + +Egy tiszta fehér vászonra kell látnod a **„Hello, world!”** szöveget Arial, félkövér és dőlt betűtípussal, pontosan 24 pt méretben. A kép méretei megegyeznek a beállított 800 × 600 értékekkel. + +## 5. lépés: Ellenőrzés és gyakori buktatók kezelése + +### 5.1 A fájl létezésének ellenőrzése + +Egy gyors szanitás‑ellenőrzés megakadályozza a hallgató hibákat: + +```csharp +if (File.Exists(outputPath)) +{ + Console.WriteLine($"✅ PNG created successfully at {outputPath}"); +} +else +{ + Console.WriteLine("❌ Something went wrong – PNG not found."); +} +``` + +### 5.2 Hiányzó betűtípusok kezelése + +Ha a célgép nem rendelkezik a kért betűtípussal, az Aspose.HTML egy általános sans‑serif‑re vált. A konzisztencia biztosításához vagy: + +- Ágyazd be a betűtípust egy `@font-face` szabállyal a HTML‑edben, **vagy** +- Regisztráld a betűtípust programozottan a renderelés előtt. + +```csharp +// Example of registering a custom TrueType font +htmlDoc.Fonts.AddFontFile(@"C:\Fonts\OpenSans-Regular.ttf"); +``` + +### 5.3 Nagy oldalak renderelése + +Teljes oldalak bélyegképének készítésekor figyelj a memóriahasználatra. Renderelés után le is skálázhatsz, vagy beállíthatod a `renderingOptions.Width`/`Height` értékét kisebbre, és hagyhatod, hogy az Aspose.HTML végezze a méretezést. + +## Teljes működő példa + +Az alábbi programot egyszerűen másold be egy konzolalkalmazásba, és futtasd azonnal. + +```csharp +// ----------------------------------------------------------- +// How to render HTML as PNG – Complete, runnable example +// ----------------------------------------------------------- +using System; +using System.IO; +using Aspose.Html; +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +class Program +{ + static void Main() + { + // 1️⃣ Configure rendering options + ImageRenderingOptions renderingOptions = new ImageRenderingOptions + { + Width = 800, + Height = 600, + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic + }; + + // 2️⃣ Load HTML markup + HtmlDocument htmlDoc = new HtmlDocument(); + htmlDoc.Open("Hello, world!
"); + + // 3️⃣ Define output path + string outputPath = @"C:\Temp\Images\output.png"; + + // 4️⃣ Render to PNG + using (FileStream outputStream = File.OpenWrite(outputPath)) + { + htmlDoc.RenderToStream(outputStream, renderingOptions); + } + + // 5️⃣ Verify the result + Console.WriteLine(File.Exists(outputPath) + ? $"✅ PNG saved at {outputPath}" + : "❌ Failed to create PNG"); + } +} +``` + +Futtasd a programot (`dotnet run`), majd nyisd meg a `C:\Temp\Images\output.png` fájlt. Ha minden rendben ment, akkor **HTML‑t képpé konvertáltál** és **HTML‑t PNG‑ként mentettél** tiszta C# kóddal. + +## Gyakran ismételt kérdések + +| Kérdés | Válasz | +|----------|--------| +| **Renderelhetek teljes weboldalt külső CSS/JS‑szel?** | Igen – egyszerűen hívd a `htmlDoc.Open("https://example.com")`‑t. A motor letölti a hivatkozott erőforrásokat, de szükség van hálózati kapcsolatra. | +| **Milyen formátumok támogatottak a PNG‑en kívül?** | Az `ImageRenderingOptions` támogatja a JPEG, BMP, GIF és TIFF formátumokat. Csak a fájlkiterjesztést és az `ImageFormat`‑ot módosítsd. | +| **Van korlátozás a kép méretére?** | Technikai szempontból több ezer pixel is lehetséges, de a nagyon nagy méretek memóriahiányhoz vezethetnek. Nagy felbontású kimenethez fontold meg a csempézéses renderelést. | +| **Hogyan kezelem a DPI‑t nyomtatási minőségű képekhez?** | Állítsd be a `renderingOptions.DpiX` és `renderingOptions.DpiY` értékeket (alapértelmezett 96). A magasabb DPI élesebb kimenetet ad nyomtatáshoz. | +| **Szükségem van licencre az Aspose.HTML‑hez?** | Az ingyenes értékelő verzió vízjelet helyez el. Termeléshez vásárolj licencet, hogy eltávolítsd a vízjelet és elérd a teljes funkcionalitást. | + +## Következő lépések és kapcsolódó témák + +- **HTML konvertálása JPEG‑re** – cseréld ki a fájlkiterjesztést, és opcionálisan állítsd be a `renderingOptions.ImageFormat = ImageFormat.Jpeg`‑et. +- **Kötegelt feldolgozás** – iterálj egy URL‑listán, és generálj minden egyeshez bélyegképet. +- **Betűtípusok beágyazása** – tanuld meg, hogyan használj `@font-face`‑t a jelölésedben a tökéletes tipográfiáért. +- **Haladó elrendezés** – kísérletezz a `PageSize`, `Margin` és `BackgroundColor` opciókkal egyedi megjelenésért. + +Nyugodtan módosítsd a méreteket, próbálj ki különböző HTML‑részleteket, vagy integráld ezt a kódrészletet egy web‑API‑ba, amely PNG‑előnézeteket szolgáltat „on‑the‑fly”. A lehetőségek határtalanok, ha tudod, **hogyan rendereljük a HTML‑t** programozottan. + +--- + + + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/indonesian/net/html-extensions-and-conversions/_index.md b/html/indonesian/net/html-extensions-and-conversions/_index.md index 7c77913dd3..193c9e6136 100644 --- a/html/indonesian/net/html-extensions-and-conversions/_index.md +++ b/html/indonesian/net/html-extensions-and-conversions/_index.md @@ -111,6 +111,8 @@ Pelajari cara menyimpan HTML sebagai arsip ZIP menggunakan C# dengan panduan len Pelajari cara menyimpan seluruh halaman web menjadi satu file HTML menggunakan C# dan Aspose.HTML. ### [Aspose HTML Save Options: Simpan HTML ke Stream dalam C#](./aspose-html-save-options-save-html-to-stream-in-c/) Pelajari cara menyimpan HTML ke stream menggunakan Aspose.HTML untuk .NET dengan C#. +### [Cara menggunakan handler di Aspose.HTML – Muat HTML, Simpan sebagai ZIP](./how-to-use-handler-in-aspose-html-load-html-save-as-zip/) +Pelajari cara memuat file HTML dengan handler dan menyimpannya sebagai arsip ZIP menggunakan Aspose.HTML di .NET. ## Kesimpulan diff --git a/html/indonesian/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md b/html/indonesian/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md new file mode 100644 index 0000000000..0efde8c84e --- /dev/null +++ b/html/indonesian/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md @@ -0,0 +1,183 @@ +--- +category: general +date: 2026-02-25 +description: cara menggunakan handler untuk memuat html dari url dan menyimpan halaman + web sebagai zip dengan Aspose.HTML – panduan lengkap langkah demi langkah C# +draft: false +keywords: +- how to use handler +- load html from url +- custom resource handler +- save webpage as zip +- create zip from html +language: id +og_description: Cara menggunakan handler untuk memuat HTML dari URL dan menyimpan + halaman web sebagai ZIP dengan Aspose.HTML. Pelajari alur kerja C# lengkap dalam + hitungan menit. +og_title: cara menggunakan handler di Aspose.HTML – Muat HTML, Simpan sebagai ZIP +tags: +- Aspose.HTML +- C# +- Web Scraping +title: Cara menggunakan handler di Aspose.HTML – Memuat HTML, Menyimpan sebagai ZIP +url: /id/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# cara menggunakan handler di Aspose.HTML – Memuat HTML, Menyimpan sebagai ZIP + +Pernah bertanya‑tanya **cara menggunakan handler** saat mengambil halaman web ke dalam aplikasi .NET Anda? Mungkin Anda sudah mencoba `HtmlDocument.Open` dan mendapatkan HTML, tetapi gambar, CSS, dan font menghilang begitu saja. Itu adalah masalah umum—sumber daya hilang kecuali Anda memberi tahu Aspose.HTML apa yang harus dilakukan dengan mereka. + +Dalam tutorial ini kita akan melangkah melalui memuat HTML dari URL, menyiapkan **handler sumber daya khusus**, dan akhirnya **menyimpan halaman web sebagai zip** sehingga Anda mendapatkan satu arsip portabel. Pada akhir tutorial Anda akan memiliki cuplikan C# siap‑pakai yang dapat ditempelkan ke proyek mana pun, plus beberapa tips yang menghemat sakit kepala di kemudian hari. + +## Apa yang Anda Butuhkan + +- .NET 6+ (API ini juga bekerja di .NET Core dan .NET Framework) +- Aspose.HTML untuk .NET (paket NuGet `Aspose.HTML`) +- Sedikit pengalaman C# (Anda akan baik‑baik jika pernah menulis `Console.WriteLine`) + +Tidak ada alat tambahan, tidak ada layanan eksternal—hanya pustaka dan URL yang ingin Anda arsipkan. + + + +## Langkah 1: Memuat HTML dari URL + +Hal pertama dalam alur web‑scraping apa pun adalah mengambil sumber halaman. Aspose.HTML menjadikannya satu baris kode, tetapi ingat kita **memuat html dari url** dengan tumpukan jaringan bawaan. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +// 1️⃣ Load the page you want to archive +HtmlDocument htmlDoc = new HtmlDocument(); +htmlDoc.Open("https://example.com"); // replace with any public URL +``` + +> **Mengapa ini penting:** `HtmlDocument.Open` mem-parsing markup *dan* menyelesaikan URL relatif secara internal, tetapi tidak secara otomatis menyimpan aset eksternal. Itulah mengapa kita memerlukan handler nanti. + +## Langkah 2: Membuat Custom Resource Handler + +Sekarang masuk ke inti masalah—**cara menggunakan handler** untuk menyela setiap permintaan sumber daya eksternal (gambar, CSS, font, dll.). Dengan menurunkan kelas `ResourceHandler` Anda mendapatkan kontrol penuh atas aliran (stream) yang mendasari setiap aset. + +```csharp +// 2️⃣ Define your own handler (optional but powerful) +public class MyResourceHandler : ResourceHandler +{ + // Called for each external resource the document needs + public override Stream HandleResource(ResourceInfo info) + { + // Here you could download the file, cache it, or rewrite it. + // For this demo we simply return an empty stream – Aspose will + // still create the entry in the ZIP, keeping the folder structure. + return new MemoryStream(); + } +} +``` + +> **Pro tip:** Dalam skenario produksi Anda mungkin ingin mengunduh byte sebenarnya (`HttpClient.GetStreamAsync(info.Uri)`) dan mengembalikan stream tersebut. Ini memastikan ZIP yang disimpan berisi gambar asli, bukan placeholder kosong. + +## Langkah 3: Mengonfigurasi Opsi Penyimpanan dan Menempelkan Handler + +Setelah handler siap, kita memberi tahu Aspose.HTML cara mengemas semuanya. Kelas `HtmlSaveOptions` memungkinkan Anda mengaktifkan saklar `SaveToZipArchive` dan menyambungkan `MyResourceHandler` Anda. + +```csharp +// 3️⃣ Set up saving options – this is where we **save webpage as zip** +HtmlSaveOptions saveOptions = new HtmlSaveOptions +{ + // Attach our custom handler – new API as of v22.10 + OutputStorage = new MyResourceHandler(), + + // Instruct Aspose to bundle HTML + resources into a single ZIP file + SaveToZipArchive = true +}; +``` + +> **Penjelasan:** `OutputStorage` adalah properti yang menerima instance handler. Saat penyimpan berjalan melalui DOM, ia memanggil `HandleResource` untuk setiap tautan eksternal. Karena `SaveToZipArchive` bernilai true, penyimpan menulis setiap stream yang dikembalikan ke entri ZIP yang cocok dengan jalur aslinya. + +## Langkah 4: Menyimpan Dokumen ke Memory Stream + +Kita bisa menulis langsung ke disk, tetapi menyimpan semuanya di memori membuat kode dapat digunakan di ASP.NET, Azure Functions, atau tempat lain di mana Anda tidak menginginkan file sementara. Berikut langkah akhir yang **membuat zip dari html**. + +```csharp +// 4️⃣ Save everything – HTML + resources – into a MemoryStream +using (MemoryStream outputStream = new MemoryStream()) +{ + htmlDoc.Save(outputStream, saveOptions); + + // At this point outputStream holds a valid ZIP archive. + // For demo purposes we write it to the file system: + File.WriteAllBytes("example_page.zip", outputStream.ToArray()); +} +``` + +### Hasil yang Diharapkan + +- `example_page.zip` muncul di folder proyek Anda. +- Di dalam ZIP Anda akan menemukan `index.html` plus struktur folder (`images/`, `css/`, dll.). +- Meskipun handler demo kami mengembalikan stream kosong, tata letak ZIP mencerminkan halaman asli—sempurna untuk diganti dengan downloader nyata nanti. + +## Variasi Umum & Kasus Tepi + +### Memuat File Lokal Alih‑alih URL +Jika Anda perlu **memuat html dari url**‑seperti jalur di disk, cukup ganti `htmlDoc.Open("https://example.com")` dengan `htmlDoc.Open(@"C:\path\to\file.html")`. Sisa alur tetap sama. + +### Menyimpan Sumber Daya Nyata +Untuk benar‑benarnya menyematkan gambar, ubah `HandleResource`: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Download the resource using HttpClient + HttpClient client = new HttpClient(); + var data = client.GetByteArrayAsync(info.Uri).Result; + return new MemoryStream(data); +} +``` + +> **Peringatan:** Panggilan jaringan di dalam handler memblokir thread penyimpanan; untuk halaman besar pertimbangkan membuat handler menjadi asynchronous (tersedia di rilis Aspose yang lebih baru). + +### Mengubah Nama Entri ZIP +`ResourceInfo` berisi `FileName` dan `Path`. Anda dapat menulis ulang keduanya untuk meratakan hierarki atau menambahkan prefiks: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Example: prepend "assets/" to every entry + info.Path = Path.Combine("assets", info.Path); + return base.HandleResource(info); +} +``` + +### Menggunakan Output Storage yang Berbeda +`OutputStorage` juga dapat berupa `FileSystemStorage` jika Anda lebih suka folder daripada ZIP. Cukup set `SaveToZipArchive = false` dan arahkan `OutputStorage` ke jalur direktori. + +## Pro Tips & Jebakan + +- **Jangan lupa dispose** `HtmlDocument` jika Anda membuka banyak halaman dalam loop; jika tidak, Anda dapat kebocoran sumber daya native. +- **Penggunaan memori:** Menyimpan halaman besar ke dalam `MemoryStream` dapat membengkak RAM. Untuk arsip multi‑megabyte, alirkan langsung ke file (`FileStream`) saja. +- **Encoding karakter:** Aspose.HTML menghormati tag ``. Jika halaman sumber menggunakan encoding yang tidak umum, pastikan HTML hasil ekstraksi tetap menampilkan dengan benar. +- **Pengujian:** Buka ZIP yang dihasilkan di browser (seret `index.html` keluar) untuk memastikan semua sumber daya ter‑resolve. Jika gambar hilang, kemungkinan besar `HandleResource` Anda mengembalikan stream kosong. + +## Ringkasan + +Kami telah membahas **cara menggunakan handler** untuk menyela sumber daya eksternal, mendemonstrasikan **memuat html dari url**, membangun **custom resource handler**, dan akhirnya **menyimpan halaman web sebagai zip**—secara efektif **membuat zip dari html** dengan beberapa baris C#. Pola ini dapat diskalakan: ganti `MemoryStream` kosong dengan downloader nyata, ubah target output, atau sematkan logika dalam API web yang mengembalikan ZIP sesuai permintaan. + +--- + +### Apa Selanjutnya? + +- **Pemrosesan batch:** Loop melalui daftar URL dan hasilkan ZIP per halaman. +- **Pengaturan kompresi:** Gunakan `ZipSaveOptions` untuk menyesuaikan level kompresi agar unduhan lebih cepat. +- **Integrasi dengan ASP.NET Core:** Kembalikan `MemoryStream` sebagai `FileResult` sehingga pengguna dapat mengunduh arsip langsung dari endpoint web. +- **Jelajahi fitur Aspose.HTML lainnya:** Konversi PDF, manipulasi DOM, atau rendering headless. + +Punya pertanyaan tentang kasus penggunaan tertentu—mungkin Anda perlu mempertahankan JavaScript atau menangani halaman yang dilindungi otentikasi? Tinggalkan komentar di bawah; saya akan senang membantu lebih dalam. Selamat coding! + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/indonesian/net/rendering-html-documents/_index.md b/html/indonesian/net/rendering-html-documents/_index.md index dc001f6a0f..a4641a80d5 100644 --- a/html/indonesian/net/rendering-html-documents/_index.md +++ b/html/indonesian/net/rendering-html-documents/_index.md @@ -97,6 +97,9 @@ Pelajari cara membuat gambar dari HTML menggunakan C# dengan Aspose.HTML melalui ### [Render HTML ke PDF dengan Aspose.HTML – Panduan Langkah‑demi‑Langkah](./render-html-to-pdf-with-aspose-html-step-by-step-guide/) Pelajari cara merender HTML menjadi PDF menggunakan Aspose.HTML dengan panduan langkah demi langkah yang lengkap. +### [Cara Merender HTML sebagai PNG di C# – Panduan Langkah‑demi‑Langkah](./how-to-render-html-as-png-in-c-step-by-step-guide/) +Pelajari cara merender HTML menjadi PNG menggunakan Aspose.HTML untuk .NET dengan panduan langkah demi langkah dalam C#. + {{< /blocks/products/pf/tutorial-page-section >}} {{< /blocks/products/pf/main-container >}} diff --git a/html/indonesian/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md b/html/indonesian/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..c1aeda0ffa --- /dev/null +++ b/html/indonesian/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md @@ -0,0 +1,224 @@ +--- +category: general +date: 2026-02-25 +description: Cara merender HTML menjadi PNG di C# menggunakan Aspose.HTML. Pelajari + cara mengonversi HTML ke gambar, menyimpan HTML sebagai PNG, dan membuat PNG dari + HTML dengan cepat. +draft: false +keywords: +- how to render html +- convert html to image +- save html as png +- create png from html +- generate png from html +language: id +og_description: Cara merender HTML menjadi PNG di C# dengan Aspose.HTML. Ikuti tutorial + ini untuk mengonversi HTML ke gambar, menyimpan HTML sebagai PNG, dan menghasilkan + PNG dari HTML. +og_title: Cara merender HTML menjadi PNG di C# – Panduan Lengkap +tags: +- C# +- Aspose.HTML +- Image Rendering +title: Cara merender HTML menjadi PNG di C# – Panduan Langkah demi Langkah +url: /id/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Cara merender HTML menjadi PNG di C# – Panduan Langkah‑per‑Langkah + +Pernah bertanya‑tanya **bagaimana cara merender HTML** langsung ke file PNG tanpa harus mengoperasikan browser? Mungkin Anda perlu menyematkan cuplikan kecil dari sebuah halaman web dalam email, atau Anda sedang membangun layanan thumbnail untuk sebuah CMS. Bagaimanapun, masalahnya pada mengubah markup menjadi bitmap yang dapat Anda simpan atau layani. + +Dalam tutorial ini Anda akan melihat solusi lengkap yang siap dijalankan yang **mengonversi HTML ke gambar** menggunakan Aspose.HTML untuk .NET. Kami juga akan membahas cara **menyimpan HTML sebagai PNG**, **membuat PNG dari HTML**, dan bahkan **menghasilkan PNG dari HTML** dengan font dan dimensi khusus. Tanpa referensi samar—hanya kode yang dapat Anda salin‑tempel, plus penjelasan mengapa setiap baris penting. + +## Apa yang Anda Butuhkan + +- .NET 6 (atau runtime .NET terbaru apa pun) – API bekerja sama pada .NET Framework 4.6+. +- Visual Studio 2022 atau VS Code – mana pun yang Anda sukai. +- Paket NuGet **Aspose.HTML** (`Aspose.HTML.NET`) – instal sekali dan Anda siap. +- Folder yang dapat ditulisi untuk output PNG (misalnya `C:\Temp\Images`). + +Itu saja. Tidak ada binary tambahan, tidak ada layanan web eksternal, dan tidak ada file konfigurasi tersembunyi. + +## Langkah 1: Instal Aspose.HTML via NuGet + +Pertama, tambahkan pustaka ke proyek Anda. Buka terminal di folder solusi Anda dan jalankan: + +```bash +dotnet add package Aspose.HTML.NET +``` + +*Pro tip:* Jika Anda berada di Visual Studio, klik kanan **Dependencies → Manage NuGet Packages**, cari “Aspose.HTML”, dan klik **Install**. Ini memberi Anda akses ke `HtmlDocument`, `ImageRenderingOptions`, dan kelas lain yang akan kami gunakan. + +## Langkah 2: Siapkan Opsi Rendering (ukuran, gaya, dan font) + +Sebelum kami memberi markup apa pun ke renderer, kami memutuskan seberapa besar gambar yang diinginkan dan gaya font mana yang ingin dipertahankan. Objek `ImageRenderingOptions` memungkinkan Anda menyesuaikan lebar, tinggi, dan bahkan memaksa rendering tebal/miring. + +```csharp +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +// Configure image rendering options – width, height, and font style +ImageRenderingOptions renderingOptions = new ImageRenderingOptions +{ + Width = 800, // Desired image width in pixels + Height = 600, // Desired image height in pixels + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic // Preserve bold & italic +}; +``` + +**Mengapa ini penting:** +- **Width/Height** menentukan dimensi piksel akhir; jika Anda melewatkannya mesin akan menebak berdasarkan tata letak HTML, yang dapat menyebabkan pemotongan tak terduga. +- **FontStyle** memastikan bahwa tag `` atau `` tetap menonjol secara visual saat dirasterisasi. + +## Langkah 3: Muat Markup HTML Anda + +Anda dapat memuat HTML dari string, file, atau URL. Untuk kesederhanaan, kami akan menyematkan cuplikan kecil langsung di kode. Perhatikan CSS inline yang mengatur keluarga font – Aspose.HTML menghormati CSS web standar, sehingga Anda mendapatkan rendering yang akurat. + +```csharp +using Aspose.Html; + +// Create an empty HTML document +HtmlDocument htmlDoc = new HtmlDocument(); + +// Load simple markup – you could also use htmlDoc.Open("path/to/file.html") +htmlDoc.Open("Hello, world!
"); +``` + +**Tips kasus tepi:** Jika markup Anda merujuk ke sumber eksternal (gambar, file CSS), pastikan URL tersebut dapat dijangkau dari mesin yang menjalankan kode, atau sematkan sebagai data‑URI untuk menghindari tautan yang rusak. + +## Langkah 4: Render HTML ke Stream PNG + +Sekarang datang inti dari **bagaimana cara merender HTML** – kami memanggil `RenderToStream`, memberikan stream output dan opsi yang telah kami konfigurasikan sebelumnya. Metode ini melakukan semua pekerjaan berat: layout, cascade CSS, substitusi font, dan rasterisasi. + +```csharp +using System.IO; + +// Choose an output path – replace with your own directory +string outputPath = @"C:\Temp\Images\output.png"; + +using (FileStream outputStream = File.OpenWrite(outputPath)) +{ + // Render the HTML document into the PNG file + htmlDoc.RenderToStream(outputStream, renderingOptions); +} +``` + +Setelah blok `using` selesai, `output.png` akan berisi gambar berukuran 800 × 600 piksel dari paragraf yang kami muat. Buka dengan penampil gambar apa pun untuk memverifikasi hasilnya. + +### Hasil yang Diharapkan + +Anda akan melihat kanvas putih bersih dengan teks **“Hello, world!”** dirender dalam Arial, tebal dan miring, tepat 24 pt. Dimensi gambar cocok dengan nilai 800 × 600 yang kami tetapkan. + +## Langkah 5: Verifikasi dan Tangani Kendala Umum + +### 5.1 Memeriksa File Ada + +Pemeriksaan cepat mencegah kegagalan diam: + +```csharp +if (File.Exists(outputPath)) +{ + Console.WriteLine($"✅ PNG created successfully at {outputPath}"); +} +else +{ + Console.WriteLine("❌ Something went wrong – PNG not found."); +} +``` + +### 5.2 Menangani Font yang Hilang + +Jika mesin target tidak memiliki font yang diminta, Aspose.HTML akan beralih ke sans‑serif generik. Untuk menjamin konsistensi, lakukan salah satu hal berikut: + +- Sematkan file font menggunakan aturan `@font-face` di HTML Anda, **atau** +- Daftarkan font secara programatis sebelum rendering. + +```csharp +// Example of registering a custom TrueType font +htmlDoc.Fonts.AddFontFile(@"C:\Fonts\OpenSans-Regular.ttf"); +``` + +### 5.3 Merender Halaman Besar + +Saat membuat thumbnail untuk screenshot halaman penuh, perhatikan penggunaan memori. Anda dapat menurunkan skala setelah rendering, atau mengatur `renderingOptions.Width`/`Height` ke ukuran lebih kecil dan biarkan Aspose.HTML menangani skala. + +## Contoh Program Lengkap + +Berikut adalah program lengkap yang dapat Anda masukkan ke aplikasi console dan jalankan langsung. + +```csharp +// ----------------------------------------------------------- +// How to render HTML as PNG – Complete, runnable example +// ----------------------------------------------------------- +using System; +using System.IO; +using Aspose.Html; +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +class Program +{ + static void Main() + { + // 1️⃣ Configure rendering options + ImageRenderingOptions renderingOptions = new ImageRenderingOptions + { + Width = 800, + Height = 600, + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic + }; + + // 2️⃣ Load HTML markup + HtmlDocument htmlDoc = new HtmlDocument(); + htmlDoc.Open("Hello, world!
"); + + // 3️⃣ Define output path + string outputPath = @"C:\Temp\Images\output.png"; + + // 4️⃣ Render to PNG + using (FileStream outputStream = File.OpenWrite(outputPath)) + { + htmlDoc.RenderToStream(outputStream, renderingOptions); + } + + // 5️⃣ Verify the result + Console.WriteLine(File.Exists(outputPath) + ? $"✅ PNG saved at {outputPath}" + : "❌ Failed to create PNG"); + } +} +``` + +Jalankan program (`dotnet run`), lalu buka `C:\Temp\Images\output.png`. Jika semuanya berjalan lancar, Anda baru saja **mengonversi HTML ke gambar** dan **menyimpan HTML sebagai PNG** menggunakan kode C# murni. + +## Pertanyaan yang Sering Diajukan + +| Pertanyaan | Jawaban | +|------------|---------| +| **Apakah saya dapat merender halaman web lengkap dengan CSS/JS eksternal?** | Ya – cukup panggil `htmlDoc.Open("https://example.com")`. Mesin akan mengunduh sumber yang terhubung, tetapi Anda memerlukan akses jaringan. | +| **Format apa saja yang didukung selain PNG?** | `ImageRenderingOptions` bekerja dengan JPEG, BMP, GIF, dan TIFF. Ubah ekstensi file dan atur `ImageFormat` bila diperlukan. | +| **Apakah ada batas ukuran gambar?** | Secara teknis Anda dapat mencapai beberapa ribu piksel, tetapi dimensi sangat besar dapat menghabiskan memori. Pertimbangkan merender dalam ubin untuk output ultra‑high‑res. | +| **Bagaimana cara menangani DPI untuk gambar kualitas cetak?** | Atur `renderingOptions.DpiX` dan `renderingOptions.DpiY` (default 96). DPI lebih tinggi menghasilkan output lebih tajam untuk pencetakan. | +| **Apakah saya memerlukan lisensi untuk Aspose.HTML?** | Evaluasi gratis berfungsi dengan watermark. Untuk produksi, beli lisensi untuk menghilangkan watermark dan membuka semua fitur. | + +## Langkah Selanjutnya dan Topik Terkait + +- **Konversi HTML ke JPEG** – ganti ekstensi file dan opsional atur `renderingOptions.ImageFormat = ImageFormat.Jpeg`. +- **Pemrosesan batch** – loop daftar URL dan hasilkan thumbnail untuk masing‑masing. +- **Menyematkan font** – pelajari cara menggunakan `@font-face` di markup Anda untuk tipografi sempurna. +- **Layout lanjutan** – bereksperimen dengan opsi `PageSize`, `Margin`, dan `BackgroundColor` untuk tampilan khusus. + +Silakan ubah dimensi, coba snippet HTML berbeda, atau integrasikan potongan kode ini ke dalam API web yang menyajikan preview PNG secara dinamis. Langit adalah batasnya ketika Anda tahu **bagaimana cara merender HTML** secara programatis. + +--- + + + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/italian/net/html-extensions-and-conversions/_index.md b/html/italian/net/html-extensions-and-conversions/_index.md index 213c82d817..ad8418ffba 100644 --- a/html/italian/net/html-extensions-and-conversions/_index.md +++ b/html/italian/net/html-extensions-and-conversions/_index.md @@ -112,6 +112,8 @@ Scopri come salvare una pagina web intera in un unico file HTML usando Aspose.HT Scopri come salvare un documento HTML in un archivio ZIP completo usando Aspose.HTML per .NET in C#. ### [Opzioni di salvataggio Aspose HTML: salva HTML su stream in C#](./aspose-html-save-options-save-html-to-stream-in-c/) Scopri come salvare un documento HTML direttamente in uno stream usando le opzioni di salvataggio di Aspose.HTML in C#. +### [Come usare il gestore in Aspose.HTML – Carica HTML, salva come ZIP](./how-to-use-handler-in-aspose-html-load-html-save-as-zip/) +Scopri come utilizzare il gestore di Aspose.HTML per caricare un documento HTML e salvarlo in un archivio ZIP in C#. ## Conclusione diff --git a/html/italian/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md b/html/italian/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md new file mode 100644 index 0000000000..42c26794ba --- /dev/null +++ b/html/italian/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md @@ -0,0 +1,182 @@ +--- +category: general +date: 2026-02-25 +description: come utilizzare il gestore per caricare HTML da URL e salvare la pagina + web come zip con Aspose.HTML – una guida completa passo‑passo in C# +draft: false +keywords: +- how to use handler +- load html from url +- custom resource handler +- save webpage as zip +- create zip from html +language: it +og_description: Come usare un handler per caricare HTML da URL e salvare la pagina + web come zip con Aspose.HTML. Scopri l’intero flusso di lavoro C# in pochi minuti. +og_title: come utilizzare il gestore in Aspose.HTML – Carica HTML, salva come ZIP +tags: +- Aspose.HTML +- C# +- Web Scraping +title: come utilizzare l'handler in Aspose.HTML – Carica HTML, Salva come ZIP +url: /it/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# come usare handler in Aspose.HTML – Carica HTML, Salva come ZIP + +Ti sei mai chiesto **come usare handler** quando importi una pagina web nella tua app .NET? Forse hai provato `HtmlDocument.Open` e hai ottenuto l'HTML, ma immagini, CSS e font sono spariti nel nulla. È un problema comune: le risorse vanno perse se non dici ad Aspose.HTML cosa fare con esse. + +In questo tutorial vedremo come caricare HTML da un URL, configurare un **custom resource handler**, e infine **salvare la pagina web come zip** così otterrai un unico archivio portatile. Alla fine avrai uno snippet C# pronto‑da‑eseguire da inserire in qualsiasi progetto, più una serie di consigli che ti faranno risparmiare mal di testa in futuro. + +## What You’ll Need + +- .NET 6+ (l'API funziona anche su .NET Core e .NET Framework) +- Aspose.HTML for .NET (pacchetto NuGet `Aspose.HTML`) +- Un modesto livello di esperienza in C# (andrà bene se hai scritto almeno un `Console.WriteLine`) + +Nessuno strumento aggiuntivo, nessun servizio esterno—solo la libreria e un URL che vuoi archiviare. + + + +## Step 1: Load HTML from URL + +La prima cosa in qualsiasi flusso di web‑scraping è recuperare il sorgente della pagina. Aspose.HTML lo rende un'operazione a una riga, ma ricorda che stiamo **loading html from url** con lo stack di rete integrato. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +// 1️⃣ Load the page you want to archive +HtmlDocument htmlDoc = new HtmlDocument(); +htmlDoc.Open("https://example.com"); // replace with any public URL +``` + +> **Perché è importante:** `HtmlDocument.Open` analizza il markup *e* risolve gli URL relativi internamente, ma non persiste automaticamente le risorse esterne. Per questo abbiamo bisogno di un handler in seguito. + +## Step 2: Create a Custom Resource Handler + +Ora arriva il cuore della questione—**come usare handler** per intercettare ogni richiesta di risorsa esterna (immagini, CSS, font, ecc.). Sottoclassando `ResourceHandler` ottieni il pieno controllo sullo stream che supporta ciascuna risorsa. + +```csharp +// 2️⃣ Define your own handler (optional but powerful) +public class MyResourceHandler : ResourceHandler +{ + // Called for each external resource the document needs + public override Stream HandleResource(ResourceInfo info) + { + // Here you could download the file, cache it, or rewrite it. + // For this demo we simply return an empty stream – Aspose will + // still create the entry in the ZIP, keeping the folder structure. + return new MemoryStream(); + } +} +``` + +> **Pro tip:** In uno scenario di produzione potresti voler scaricare i byte reali (`HttpClient.GetStreamAsync(info.Uri)`) e restituire quello stream. Questo garantisce che lo ZIP salvato contenga le immagini vere invece di segnaposto vuoti. + +## Step 3: Configure Save Options and Attach the Handler + +Con l'handler pronto, diciamo ad Aspose.HTML come impacchettare tutto. La classe `HtmlSaveOptions` ti permette di attivare l'opzione `SaveToZipArchive` e collegare il tuo `MyResourceHandler`. + +```csharp +// 3️⃣ Set up saving options – this is where we **save webpage as zip** +HtmlSaveOptions saveOptions = new HtmlSaveOptions +{ + // Attach our custom handler – new API as of v22.10 + OutputStorage = new MyResourceHandler(), + + // Instruct Aspose to bundle HTML + resources into a single ZIP file + SaveToZipArchive = true +}; +``` + +> **Spiegazione:** `OutputStorage` è la proprietà che riceve l'istanza dell'handler. Quando il salvataggio percorre il DOM chiama `HandleResource` per ogni link esterno. Poiché `SaveToZipArchive` è true, il salvataggio scrive ogni stream restituito in una voce ZIP che corrisponde al percorso originale. + +## Step 4: Save the Document into a Memory Stream + +Potremmo scrivere direttamente su disco, ma mantenere tutto in memoria rende il codice utilizzabile in ASP.NET, Azure Functions o in qualsiasi contesto in cui non vuoi un file temporaneo. Ecco l'ultimo passaggio che **creates zip from html**. + +```csharp +// 4️⃣ Save everything – HTML + resources – into a MemoryStream +using (MemoryStream outputStream = new MemoryStream()) +{ + htmlDoc.Save(outputStream, saveOptions); + + // At this point outputStream holds a valid ZIP archive. + // For demo purposes we write it to the file system: + File.WriteAllBytes("example_page.zip", outputStream.ToArray()); +} +``` + +### Expected Result + +- appare `example_page.zip` nella cartella del tuo progetto. +- All'interno dello ZIP troverai `index.html` più una struttura di cartelle (`images/`, `css/`, ecc.). +- Anche se il nostro handler di esempio ha restituito stream vuoti, la struttura dello ZIP rispecchia la pagina originale—perfetta per sostituire in seguito con un downloader reale. + +## Common Variations & Edge Cases + +### Loading a Local File Instead of a URL +Se devi **load html from url**‑like percorsi su disco, sostituisci semplicemente `htmlDoc.Open("https://example.com")` con `htmlDoc.Open(@"C:\path\to\file.html")`. Il resto della pipeline rimane identico. + +### Persisting Real Resources +Per incorporare effettivamente le immagini, modifica `HandleResource`: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Download the resource using HttpClient + HttpClient client = new HttpClient(); + var data = client.GetByteArrayAsync(info.Uri).Result; + return new MemoryStream(data); +} +``` + +> **Attenzione:** Le chiamate di rete all'interno dell'handler bloccano il thread di salvataggio; per pagine grandi considera di rendere l'handler asincrono (disponibile nelle versioni più recenti di Aspose). + +### Changing the ZIP Entry Names +`ResourceInfo` contiene `FileName` e `Path`. Puoi riscriverli per appiattire la gerarchia o aggiungere un prefisso: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Example: prepend "assets/" to every entry + info.Path = Path.Combine("assets", info.Path); + return base.HandleResource(info); +} +``` + +### Using a Different Output Storage +`OutputStorage` può anche essere un `FileSystemStorage` se preferisci una cartella invece di uno ZIP. Basta impostare `SaveToZipArchive = false` e puntare `OutputStorage` a un percorso di directory. + +## Pro Tips & Pitfalls + +- **Non dimenticare di dispose** l'`HtmlDocument` se apri molte pagine in un ciclo; altrimenti potresti perdere risorse native. +- **Utilizzo della memoria:** Salvare pagine enormi in un `MemoryStream` può gonfiare la RAM. Per archivi multi‑megabyte, stream direttamente su file (`FileStream`) invece. +- **Codifica dei caratteri:** Aspose.HTML rispetta il tag ``. Se la pagina sorgente usa una codifica poco comune, verifica che l'HTML risultante venga renderizzato correttamente dopo l'estrazione. +- **Testing:** Apri lo ZIP generato in un browser (trascina fuori `index.html`) per assicurarti che tutte le risorse vengano risolte. Se le immagini mancano, probabilmente il tuo `HandleResource` ha restituito uno stream vuoto. + +## Recap + +Abbiamo coperto **come usare handler** per intercettare risorse esterne, dimostrato **load html from url**, costruito un **custom resource handler**, e infine **save webpage as zip**—effettivamente **create zip from html** con poche righe di C#. Il pattern è scalabile: sostituisci lo `MemoryStream` vuoto con un downloader reale, cambia il target di output, o incorpora la logica in una Web API che restituisce lo ZIP su richiesta. + +--- + +### What’s Next? + +- **Elaborazione batch:** Cicla su una lista di URL e genera uno ZIP per ogni pagina. +- **Ottimizzazioni di compressione:** Usa `ZipSaveOptions` per regolare il livello di compressione e velocizzare i download. +- **Integrazione con ASP.NET Core:** Restituisci il `MemoryStream` come `FileResult` così gli utenti possono scaricare l'archivio direttamente da un endpoint web. +- **Esplora altre funzionalità di Aspose.HTML:** Conversione PDF, manipolazione DOM, o rendering headless. + +Hai domande su un caso d'uso specifico—magari devi preservare JavaScript o gestire pagine protette da autenticazione? Lascia un commento qui sotto; sarò felice di approfondire. Buon coding! + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/italian/net/rendering-html-documents/_index.md b/html/italian/net/rendering-html-documents/_index.md index bf541ad47e..75552b6b18 100644 --- a/html/italian/net/rendering-html-documents/_index.md +++ b/html/italian/net/rendering-html-documents/_index.md @@ -54,10 +54,11 @@ Scopri come convertire facilmente file HTML in PNG usando Aspose.HTML con questa ### [Come usare Aspose per rendere HTML in PNG – Guida passo‑passo](./how-to-use-aspose-to-render-html-to-png-step-by-step-guide/) Scopri come convertire facilmente file HTML in PNG usando Aspose.HTML per .NET con questa guida dettagliata. - ### [Come rendere HTML in PNG in C# – Guida passo‑passo](./how-to-render-html-to-png-in-c-step-by-step-guide/) Scopri come convertire HTML in PNG usando C# con Aspose.HTML, seguendo una guida dettagliata passo dopo passo. +### [Come rendere HTML come PNG in C# – Guida passo‑passo](./how-to-render-html-as-png-in-c-step-by-step-guide/) +Scopri come convertire HTML in PNG usando C# con Aspose.HTML. Segui la guida passo passo per risultati perfetti! ### [Crea PNG da HTML – Guida completa al rendering C#](./create-png-from-html-full-c-rendering-guide/) Scopri come generare PNG da HTML usando Aspose.HTML per .NET con una guida completa passo passo in C#. ### [Come rendere HTML in PNG – Guida completa C#](./how-to-render-html-to-png-complete-c-guide/) diff --git a/html/italian/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md b/html/italian/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..f20a0d8604 --- /dev/null +++ b/html/italian/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md @@ -0,0 +1,222 @@ +--- +category: general +date: 2026-02-25 +description: Come rendere HTML in PNG in C# usando Aspose.HTML. Impara a convertire + HTML in immagine, salvare HTML come PNG e creare PNG da HTML rapidamente. +draft: false +keywords: +- how to render html +- convert html to image +- save html as png +- create png from html +- generate png from html +language: it +og_description: Come rendere HTML in PNG in C# con Aspose.HTML. Segui questo tutorial + per convertire HTML in immagine, salvare HTML come PNG e generare PNG da HTML. +og_title: Come rendere HTML in PNG in C# – Guida completa +tags: +- C# +- Aspose.HTML +- Image Rendering +title: Come trasformare HTML in PNG in C# – Guida passo passo +url: /it/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Come rendere HTML in PNG con C# – Guida passo‑passo + +Ti sei mai chiesto **come rendere HTML** direttamente in un file PNG senza dover aprire un browser? Forse devi inserire una piccola anteprima di una pagina web in una email, o stai costruendo un servizio di thumbnail per un CMS. In entrambi i casi, il problema si riduce a trasformare il markup in una bitmap che puoi salvare o servire. + +In questo tutorial vedrai una soluzione completa, pronta all'uso, che **converte HTML in immagine** usando Aspose.HTML per .NET. Tratteremo anche come **salvare HTML come PNG**, **creare PNG da HTML**, e persino **generare PNG da HTML** con font e dimensioni personalizzate. Niente riferimenti vaghi—solo il codice da copiare‑incollare, più le spiegazioni del perché ogni riga è importante. + +## Cosa ti serve + +- .NET 6 (o qualsiasi runtime .NET recente) – l'API funziona allo stesso modo su .NET Framework 4.6+. +- Visual Studio 2022 o VS Code – quello che preferisci. +- Il pacchetto NuGet **Aspose.HTML** (`Aspose.HTML.NET`) – installalo una volta e sei a posto. +- Una cartella scrivibile per il PNG di output (ad es., `C:\Temp\Images`). + +Tutto qui. Nessun binario extra, nessun servizio web esterno e nessun file di configurazione nascosto. + +## Passo 1: Installa Aspose.HTML via NuGet + +Per prima cosa, aggiungi la libreria al tuo progetto. Apri il terminale nella cartella della soluzione ed esegui: + +```bash +dotnet add package Aspose.HTML.NET +``` + +*Consiglio:* Se usi Visual Studio, fai clic destro su **Dependencies → Manage NuGet Packages**, cerca “Aspose.HTML” e premi **Install**. Questo ti darà accesso a `HtmlDocument`, `ImageRenderingOptions` e altre classi che utilizzeremo. + +## Passo 2: Configura le opzioni di rendering (dimensioni, stile e font) + +Prima di fornire qualsiasi markup al renderer, decidiamo quanto grande deve essere l’immagine e quali stili di font vogliamo preservare. L'oggetto `ImageRenderingOptions` ti permette di regolare larghezza, altezza e persino forzare il rendering in grassetto/italico. + +```csharp +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +// Configure image rendering options – width, height, and font style +ImageRenderingOptions renderingOptions = new ImageRenderingOptions +{ + Width = 800, // Desired image width in pixels + Height = 600, // Desired image height in pixels + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic // Preserve bold & italic +}; +``` + +**Perché è importante:** +- **Width/Height** determinano le dimensioni finali in pixel; se le ometti il motore fa una stima basata sul layout HTML, il che può causare ritagli inaspettati. +- **FontStyle** garantisce che i tag `` o `` mantengano la loro enfasi visiva quando rasterizzati. + +## Passo 3: Carica il tuo markup HTML + +Puoi caricare HTML da una stringa, da un file o da un URL. Per semplicità, inseriremo un piccolo snippet direttamente nel codice. Nota il CSS inline che imposta la famiglia di font – Aspose.HTML rispetta il CSS web standard, quindi otterrai un rendering fedele. + +```csharp +using Aspose.Html; + +// Create an empty HTML document +HtmlDocument htmlDoc = new HtmlDocument(); + +// Load simple markup – you could also use htmlDoc.Open("path/to/file.html") +htmlDoc.Open("Hello, world!
"); +``` + +**Suggerimento per casi particolari:** Se il tuo markup fa riferimento a risorse esterne (immagini, file CSS), assicurati che quegli URL siano raggiungibili dalla macchina che esegue il codice, oppure incorporali come data‑URI per evitare link rotti. + +## Passo 4: Renderizza l'HTML in uno stream PNG + +Ora arriva il cuore di **come rendere HTML** – chiamiamo `RenderToStream`, passando lo stream di output e le opzioni configurate in precedenza. Il metodo si occupa di tutto il lavoro pesante: layout, cascata CSS, sostituzione dei font e rasterizzazione. + +```csharp +using System.IO; + +// Choose an output path – replace with your own directory +string outputPath = @"C:\Temp\Images\output.png"; + +using (FileStream outputStream = File.OpenWrite(outputPath)) +{ + // Render the HTML document into the PNG file + htmlDoc.RenderToStream(outputStream, renderingOptions); +} +``` + +Al termine del blocco `using`, `output.png` conterrà un'immagine di 800 × 600 pixel del paragrafo che abbiamo caricato. Aprila con qualsiasi visualizzatore di immagini per verificare il risultato. + +### Risultato atteso + +Dovresti vedere una tela bianca pulita con il testo **“Hello, world!”** renderizzato in Arial, grassetto e italico, esattamente a 24 pt. Le dimensioni dell’immagine corrispondono ai valori 800 × 600 che abbiamo impostato. + +## Passo 5: Verifica e gestisci le insidie comuni + +### 5.1 Controllare che il file esista + +Un rapido controllo di sanità evita fallimenti silenziosi: + +```csharp +if (File.Exists(outputPath)) +{ + Console.WriteLine($"✅ PNG created successfully at {outputPath}"); +} +else +{ + Console.WriteLine("❌ Something went wrong – PNG not found."); +} +``` + +### 5.2 Gestire i font mancanti + +Se la macchina di destinazione non dispone del font richiesto, Aspose.HTML ricade su un sans‑serif generico. Per garantire coerenza, puoi: + +- Incorporare il file del font usando una regola `@font-face` nel tuo HTML, **oppure** +- Registrare il font programmaticamente prima del rendering. + +```csharp +// Example of registering a custom TrueType font +htmlDoc.Fonts.AddFontFile(@"C:\Fonts\OpenSans-Regular.ttf"); +``` + +### 5.3 Renderizzare pagine grandi + +Quando crei thumbnail per screenshot a pagina intera, tieni d'occhio l'uso della memoria. Puoi ridimensionare dopo il rendering, oppure impostare `renderingOptions.Width`/`Height` a dimensioni più piccole e lasciare che Aspose.HTML gestisca lo scaling. + +## Esempio completo funzionante + +Di seguito trovi il programma completo che puoi incollare in un’applicazione console e avviare subito. + +```csharp +// ----------------------------------------------------------- +// How to render HTML as PNG – Complete, runnable example +// ----------------------------------------------------------- +using System; +using System.IO; +using Aspose.Html; +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +class Program +{ + static void Main() + { + // 1️⃣ Configure rendering options + ImageRenderingOptions renderingOptions = new ImageRenderingOptions + { + Width = 800, + Height = 600, + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic + }; + + // 2️⃣ Load HTML markup + HtmlDocument htmlDoc = new HtmlDocument(); + htmlDoc.Open("Hello, world!
"); + + // 3️⃣ Define output path + string outputPath = @"C:\Temp\Images\output.png"; + + // 4️⃣ Render to PNG + using (FileStream outputStream = File.OpenWrite(outputPath)) + { + htmlDoc.RenderToStream(outputStream, renderingOptions); + } + + // 5️⃣ Verify the result + Console.WriteLine(File.Exists(outputPath) + ? $"✅ PNG saved at {outputPath}" + : "❌ Failed to create PNG"); + } +} +``` + +Esegui il programma (`dotnet run`), poi apri `C:\Temp\Images\output.png`. Se tutto è andato a buon fine, hai appena **convertito HTML in immagine** e **salvato HTML come PNG** usando puro codice C#. + +## Domande frequenti + +| Domanda | Risposta | +|----------|--------| +| **Posso renderizzare una pagina web completa con CSS/JS esterni?** | Sì – basta chiamare `htmlDoc.Open("https://example.com")`. Il motore scaricherà le risorse collegate, ma serve l'accesso alla rete. | +| **Quali formati sono supportati oltre al PNG?** | `ImageRenderingOptions` funziona con JPEG, BMP, GIF e TIFF. Cambia l’estensione del file e imposta `ImageFormat` se necessario. | +| **C’è un limite alle dimensioni dell’immagine?** | Tecnicamente puoi arrivare a diverse migliaia di pixel, ma dimensioni molto grandi possono esaurire la memoria. Considera il rendering a tasselli per output ultra‑alta risoluzione. | +| **Come gestire i DPI per immagini di qualità stampa?** | Imposta `renderingOptions.DpiX` e `renderingOptions.DpiY` (il valore predefinito è 96). DPI più alti producono output più nitido per la stampa. | +| **È necessaria una licenza per Aspose.HTML?** | Una valutazione gratuita funziona con una filigrana. Per la produzione, acquista una licenza per rimuoverla e sbloccare tutte le funzionalità. | + +## Prossimi passi e argomenti correlati + +- **Convertire HTML in JPEG** – cambia l’estensione del file e, opzionalmente, imposta `renderingOptions.ImageFormat = ImageFormat.Jpeg`. +- **Elaborazione batch** – itera su una lista di URL e genera thumbnail per ciascuno. +- **Incorporare font** – scopri come usare `@font-face` nel tuo markup per una tipografia perfetta. +- **Layout avanzato** – sperimenta con le opzioni `PageSize`, `Margin` e `BackgroundColor` per look personalizzati. + +Sentiti libero di modificare le dimensioni, provare snippet HTML diversi, o integrare questo frammento in una Web API che fornisce anteprime PNG al volo. Il cielo è il limite quando sai **come rendere HTML** in modo programmatico. + +--- + + + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/japanese/net/html-extensions-and-conversions/_index.md b/html/japanese/net/html-extensions-and-conversions/_index.md index cb3a6003a6..5151c2f6a2 100644 --- a/html/japanese/net/html-extensions-and-conversions/_index.md +++ b/html/japanese/net/html-extensions-and-conversions/_index.md @@ -110,6 +110,9 @@ Aspose.HTML for .NET を使用して、C# で Web ページを単一の HTML フ ### [Aspose.HTML Save Options: C# で HTML をストリームに保存](./aspose-html-save-options-save-html-to-stream-in-c/) +### [Aspose.HTML のハンドラを使用する方法 – HTML を読み込み、ZIP に保存](./how-to-use-handler-in-aspose-html-load-html-save-as-zip/) +Aspose.HTML のハンドラを利用して HTML をロードし、ZIP アーカイブとして保存する手順をステップバイステップで解説します。 + ## 結論 結論として、HTML の拡張と変換は、現代の Web 開発に不可欠な要素です。Aspose.HTML for .NET はプロセスを簡素化し、あらゆるレベルの開発者が利用できるようにします。当社のチュートリアルに従うことで、幅広いスキルを備えた熟練した Web 開発者になるための道を順調に進むことができます。 diff --git a/html/japanese/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md b/html/japanese/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md new file mode 100644 index 0000000000..ffb9973b71 --- /dev/null +++ b/html/japanese/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md @@ -0,0 +1,185 @@ +--- +category: general +date: 2026-02-25 +description: Aspose.HTML を使用してハンドラで URL から HTML を読み込み、Web ページを ZIP として保存する方法 – 完全な + C# ステップバイステップガイド. +draft: false +keywords: +- how to use handler +- load html from url +- custom resource handler +- save webpage as zip +- create zip from html +language: ja +og_description: ハンドラを使用してURLからHTMLを読み込み、Aspose.HTMLでウェブページをZIPとして保存する方法。数分でC#の完全なワークフローを学びましょう。 +og_title: Aspose.HTMLでハンドラを使用する方法 – HTMLを読み込み、ZIPとして保存 +tags: +- Aspose.HTML +- C# +- Web Scraping +title: Aspose.HTMLでハンドラを使用する方法 – HTMLをロードし、ZIPとして保存 +url: /ja/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Aspose.HTML でハンドラを使用する方法 – HTML をロードし、ZIP として保存 + +Web ページを .NET アプリに取り込むときに **handler の使い方** を疑問に思ったことはありませんか？ `HtmlDocument.Open` を使って HTML は取得できても、画像や CSS、フォントがすべて消えてしまうことがあります。これはよくある問題で、Aspose.HTML にリソースの取り扱いを指示しない限り、リソースは失われてしまいます。 + +このチュートリアルでは、URL から HTML を読み込み、**カスタム リソース ハンドラ** を設定し、最終的に **Web ページを ZIP として保存** する手順を解説します。最後には、任意のプロジェクトに貼り付けられる実行可能な C# スニペットと、後々のトラブルを防ぐためのいくつかのヒントが手に入ります。 + +## 必要なもの + +- .NET 6+（API は .NET Core および .NET Framework でも動作します） +- Aspose.HTML for .NET（NuGet パッケージ `Aspose.HTML`） +- ある程度の C# 経験（`Console.WriteLine` くらい書ければ問題ありません） + +余計なツールや外部サービスは不要です。ライブラリとアーカイブしたい URL だけで完結します。 + + + +## 手順 1: URL から HTML をロード + +Web スクレイピングの最初のステップはページのソースを取得することです。Aspose.HTML ならワンライナーで実現できますが、組み込みのネットワークスタックで **URL から HTML をロード** していることを忘れないでください。 + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +// 1️⃣ Load the page you want to archive +HtmlDocument htmlDoc = new HtmlDocument(); +htmlDoc.Open("https://example.com"); // replace with any public URL +``` + +> **重要な理由:** `HtmlDocument.Open` はマークアップを解析し、相対 URL を内部で解決しますが、外部アセットを自動的に保存しません。そのため、後でハンドラが必要になるのです。 + +## 手順 2: カスタム リソース ハンドラの作成 + +ここからが本題です—**handler の使い方** で外部リソース（画像、CSS、フォントなど）へのすべてのリクエストをインターセプトします。`ResourceHandler` をサブクラス化することで、各アセットを支えるストリームを完全に制御できます。 + +```csharp +// 2️⃣ Define your own handler (optional but powerful) +public class MyResourceHandler : ResourceHandler +{ + // Called for each external resource the document needs + public override Stream HandleResource(ResourceInfo info) + { + // Here you could download the file, cache it, or rewrite it. + // For this demo we simply return an empty stream – Aspose will + // still create the entry in the ZIP, keeping the folder structure. + return new MemoryStream(); + } +} +``` + +> **プロのコツ:** 本番環境では実際のバイト列（`HttpClient.GetStreamAsync(info.Uri)`）をダウンロードしてそのストリームを返すと良いでしょう。これにより、保存された ZIP に空のプレースホルダーではなく実際の画像が含まれます。 + +## 手順 3: 保存オプションの設定とハンドラの接続 + +ハンドラの準備ができたら、Aspose.HTML に全体をどのようにパッケージ化するか指示します。`HtmlSaveOptions` クラスで `SaveToZipArchive` スイッチをオンにし、`MyResourceHandler` を設定できます。 + +```csharp +// 3️⃣ Set up saving options – this is where we **save webpage as zip** +HtmlSaveOptions saveOptions = new HtmlSaveOptions +{ + // Attach our custom handler – new API as of v22.10 + OutputStorage = new MyResourceHandler(), + + // Instruct Aspose to bundle HTML + resources into a single ZIP file + SaveToZipArchive = true +}; +``` + +> **解説:** `OutputStorage` はハンドラインスタンスを受け取るプロパティです。セーバーが DOM を走査すると、外部リンクごとに `HandleResource` が呼び出されます。`SaveToZipArchive` が true のため、返されたストリームは元のパスに対応する ZIP エントリとして書き込まれます。 + +## 手順 4: ドキュメントを MemoryStream に保存 + +ディスクに直接書き込むこともできますが、すべてをメモリ上に保持すれば、ASP.NET、Azure Functions、または一時ファイルを作成したくない環境でもコードを利用できます。以下が **HTML から ZIP を作成** する最終ステップです。 + +```csharp +// 4️⃣ Save everything – HTML + resources – into a MemoryStream +using (MemoryStream outputStream = new MemoryStream()) +{ + htmlDoc.Save(outputStream, saveOptions); + + // At this point outputStream holds a valid ZIP archive. + // For demo purposes we write it to the file system: + File.WriteAllBytes("example_page.zip", outputStream.ToArray()); +} +``` + +### 期待される結果 + +- `example_page.zip` がプロジェクトフォルダーに作成されます。 +- ZIP の中には `index.html` とフォルダー構造（`images/`、`css/` など）が含まれます。 +- デモ用ハンドラが空のストリームを返したにもかかわらず、ZIP のレイアウトは元ページと同じになるので、後で実際のダウンローダに差し替えるのに最適です。 + +## 一般的なバリエーションとエッジケース + +### URL の代わりにローカルファイルをロードする + +ディスク上の **URL のようなパス**（例: `file://`）からロードしたい場合は、`htmlDoc.Open("https://example.com")` を `htmlDoc.Open(@"C:\path\to\file.html")` に置き換えるだけです。残りのパイプラインは同じです。 + +### 実際のリソースを永続化する + +実際に画像を埋め込むには、`HandleResource` を次のように変更します： + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Download the resource using HttpClient + HttpClient client = new HttpClient(); + var data = client.GetByteArrayAsync(info.Uri).Result; + return new MemoryStream(data); +} +``` + +> **注意:** ハンドラ内でのネットワーク呼び出しは保存スレッドをブロックします。大きなページの場合は、ハンドラを非同期化することを検討してください（新しい Aspose のリリースで利用可能）。 + +### ZIP エントリ名の変更 + +`ResourceInfo` には `FileName` と `Path` が含まれます。階層を平坦化したり、プレフィックスを付与したりするために書き換えることができます： + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Example: prepend "assets/" to every entry + info.Path = Path.Combine("assets", info.Path); + return base.HandleResource(info); +} +``` + +### 別の OutputStorage の使用 + +`OutputStorage` は ZIP の代わりにフォルダーを使用したい場合、`FileSystemStorage` に設定できます。`SaveToZipArchive = false` とし、`OutputStorage` にディレクトリパスを指定してください。 + +## プロのコツと落とし穴 + +- **Dispose を忘れずに**：ループで多数のページを開く場合は `HtmlDocument` を必ず破棄してください。そうしないとネイティブリソースがリークします。 +- **メモリ使用量:** 巨大なページを `MemoryStream` に保存すると RAM が急増します。数メガバイト規模のアーカイブは、直接ファイル (`FileStream`) にストリームすると良いでしょう。 +- **文字エンコーディング:** Aspose.HTML は `` タグを尊重します。ソースページが珍しいエンコーディングを使用している場合、抽出後の HTML が正しく表示されるか確認してください。 +- **テスト:** 生成された ZIP をブラウザで開き（`index.html` をドラッグして）、すべてのリソースが解決するか確認します。画像が欠けている場合、`HandleResource` が空のストリームを返している可能性があります。 + +## まとめ + +ここでは、外部リソースをインターセプトする **handler の使い方**、**URL から HTML をロード**、**カスタム リソース ハンドラ** の構築、そして最終的に **Web ページを ZIP として保存** する方法を解説しました。実質的に数行の C# で **HTML から ZIP を作成** できます。このパターンはスケーラブルで、空の `MemoryStream` を実際のダウンローダに置き換えたり、出力先を変更したり、要求に応じて ZIP を返す Web API に組み込んだりできます。 + +--- + +### 次にやること + +- **バッチ処理:** URL のリストをループし、ページごとに ZIP を生成する。 +- **圧縮の調整:** `ZipSaveOptions` を使用して圧縮レベルを調整し、ダウンロードを高速化する。 +- **ASP.NET Core との統合:** `MemoryStream` を `FileResult` として返し、ユーザーが Web エンドポイントから直接アーカイブをダウンロードできるようにする。 +- **その他の Aspose.HTML 機能を探る:** PDF 変換、DOM 操作、ヘッドレスレンダリング など。 + +特定のユースケースについて質問がありますか？たとえば JavaScript を保持したり、認証が必要なページを処理したりする必要がある場合は、下にコメントを残してください。詳しく掘り下げてお答えします。コーディングを楽しんでください！ + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/japanese/net/rendering-html-documents/_index.md b/html/japanese/net/rendering-html-documents/_index.md index f859510ded..ea969a3353 100644 --- a/html/japanese/net/rendering-html-documents/_index.md +++ b/html/japanese/net/rendering-html-documents/_index.md @@ -52,6 +52,9 @@ Aspose.HTML for .NET を使い、HTML を高品質な PNG 画像に変換する ### [C# で Aspose を使用して HTML を PNG にレンダリングする方法](./how-to-use-aspose-to-render-html-to-png-in-c/) C# で Aspose.HTML を使用し、HTML を PNG 画像に変換する手順を学びます。 +### [C# で HTML を PNG にレンダリングする方法 – ステップバイステップ ガイド](./how-to-render-html-as-png-in-c-step-by-step-guide/) +C# を使用して HTML を PNG 画像に変換する手順を段階的に解説します。初心者にも分かりやすい完全ガイドです。 + ### [Aspose.HTML を使用して .NET で EPUB を XPS としてレンダリングする](./render-epub-as-xps/) この包括的なチュートリアルでは、Aspose.HTML for .NET を使用して HTML ドキュメントを作成し、レンダリングする方法を学びます。HTML 操作、Web スクレイピングなどの世界に飛び込んでみましょう。 diff --git a/html/japanese/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md b/html/japanese/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..348a49f348 --- /dev/null +++ b/html/japanese/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md @@ -0,0 +1,222 @@ +--- +category: general +date: 2026-02-25 +description: Aspose.HTML を使用して C# で HTML を PNG にレンダリングする方法。HTML を画像に変換し、HTML を PNG + として保存し、HTML から PNG をすばやく作成する方法を学びましょう。 +draft: false +keywords: +- how to render html +- convert html to image +- save html as png +- create png from html +- generate png from html +language: ja +og_description: C# と Aspose.HTML を使用して HTML を PNG にレンダリングする方法。このチュートリアルに従って、HTML を画像に変換し、HTML + を PNG として保存し、HTML から PNG を生成します。 +og_title: C#でHTMLをPNGに変換する方法 – 完全ガイド +tags: +- C# +- Aspose.HTML +- Image Rendering +title: C#でHTMLをPNGに変換する方法 – ステップバイステップガイド +url: /ja/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# C# で HTML を PNG にレンダリングする方法 – ステップバイステップガイド + +ブラウザを操作せずに **HTML を直接 PNG ファイルにレンダリング** したことはありませんか？メールにウェブページの小さなスナップショットを埋め込む必要があるかもしれませんし、CMS 用のサムネイルサービスを構築しているかもしれません。どちらにせよ、問題はマークアップを保存または配信できるビットマップに変換することに帰着します。 + +このチュートリアルでは、Aspose.HTML for .NET を使用して **HTML を画像に変換** する完全な実行可能ソリューションをご紹介します。**HTML を PNG として保存**、**HTML から PNG を作成**、さらにはカスタムフォントやサイズで **HTML から PNG を生成** する方法にも触れます。曖昧な参照は一切なく、コピー＆ペーストできるコードと各行が重要な理由の説明だけです。 + +## 必要なもの + +- .NET 6（または最近の .NET ランタイム） – API は .NET Framework 4.6+ でも同様に動作します。 +- Visual Studio 2022 または VS Code – お好みのものを使用してください。 +- **Aspose.HTML** NuGet パッケージ (`Aspose.HTML.NET`) – 一度インストールすれば完了です。 +- 出力 PNG を保存できる書き込み可能フォルダー（例: `C:\Temp\Images`）。 + +以上です。余計なバイナリや外部ウェブサービス、隠し設定ファイルは不要です。 + +## Step 1: Install Aspose.HTML via NuGet + +まず、ライブラリをプロジェクトに追加します。ソリューションフォルダーでターミナルを開き、次のコマンドを実行してください。 + +```bash +dotnet add package Aspose.HTML.NET +``` + +*Pro tip:* Visual Studio を使用している場合は **Dependencies → Manage NuGet Packages** を右クリックし、“Aspose.HTML” を検索して **Install** をクリックします。これで `HtmlDocument`、`ImageRenderingOptions` など、今回使用するクラスが利用可能になります。 + +## Step 2: Set Up Rendering Options (size, style, and fonts) + +レンダラにマークアップを渡す前に、画像のサイズと保持したいフォントスタイルを決めます。`ImageRenderingOptions` オブジェクトを使って幅・高さを調整したり、太字・斜体の強制レンダリングを設定できます。 + +```csharp +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +// Configure image rendering options – width, height, and font style +ImageRenderingOptions renderingOptions = new ImageRenderingOptions +{ + Width = 800, // Desired image width in pixels + Height = 600, // Desired image height in pixels + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic // Preserve bold & italic +}; +``` + +**Why this matters:** +- **Width/Height** は最終的なピクセル寸法を決定します。指定しない場合、エンジンは HTML のレイアウトから自動推測し、予期しない切り取りが発生することがあります。 +- **FontStyle** は `` や `` タグの視覚的強調がラスタライズ時に保持されることを保証します。 + +## Step 3: Load Your HTML Markup + +HTML は文字列、ファイル、または URL から読み込めます。ここでは簡単のため、コード内に小さなスニペットを直接埋め込みます。フォントファミリーを設定したインライン CSS に注目してください – Aspose.HTML は標準的な Web CSS を尊重するため、忠実なレンダリングが得られます。 + +```csharp +using Aspose.Html; + +// Create an empty HTML document +HtmlDocument htmlDoc = new HtmlDocument(); + +// Load simple markup – you could also use htmlDoc.Open("path/to/file.html") +htmlDoc.Open("Hello, world!
"); +``` + +**Edge case tip:** マークアップが外部リソース（画像、CSS ファイル）を参照している場合、その URL がコード実行マシンからアクセス可能であることを確認するか、データ URI として埋め込んでリンク切れを防いでください。 + +## Step 4: Render the HTML to a PNG Stream + +ここが **HTML をレンダリングする方法** の核心です。`RenderToStream` を呼び出し、出力ストリームと先ほど設定したオプションを渡します。このメソッドがレイアウト、CSS カスケード、フォント置換、ラスタライズといった重い処理をすべて行います。 + +```csharp +using System.IO; + +// Choose an output path – replace with your own directory +string outputPath = @"C:\Temp\Images\output.png"; + +using (FileStream outputStream = File.OpenWrite(outputPath)) +{ + // Render the HTML document into the PNG file + htmlDoc.RenderToStream(outputStream, renderingOptions); +} +``` + +`using` ブロックが終了すると、`output.png` に幅 800 × 高さ 600 ピクセルの画像が生成されます。任意の画像ビューアで開き、結果を確認してください。 + +### Expected Result + +白いキャンバス上に **“Hello, world!”** というテキストが Arial の太字・斜体で、サイズ 24 pt で正確に描画されているはずです。画像サイズは設定した 800 × 600 ピクセルと一致します。 + +## Step 5: Verify and Handle Common Pitfalls + +### 5.1 Checking the File Exists + +簡単なサニティチェックでサイレント失敗を防げます: + +```csharp +if (File.Exists(outputPath)) +{ + Console.WriteLine($"✅ PNG created successfully at {outputPath}"); +} +else +{ + Console.WriteLine("❌ Something went wrong – PNG not found."); +} +``` + +### 5.2 Dealing with Missing Fonts + +対象マシンに指定フォントが存在しない場合、Aspose.HTML は汎用のサンセリフにフォールバックします。一貫性を保つには、以下のいずれかを行ってください: + +- HTML 内で `@font-face` ルールを使用してフォントファイルを埋め込む **または** +- レンダリング前にプログラムからフォントを登録する。 + +```csharp +// Example of registering a custom TrueType font +htmlDoc.Fonts.AddFontFile(@"C:\Fonts\OpenSans-Regular.ttf"); +``` + +### 5.3 Rendering Large Pages + +フルページのスクリーンショット用サムネイルを作成する際はメモリ使用量に注意してください。レンダリング後にダウンスケールするか、`renderingOptions.Width`/`Height` を小さめに設定して Aspose.HTML にスケーリングさせることができます。 + +## Full Working Example + +以下はコンソールアプリケーションに貼り付けてすぐに実行できる完全なプログラムです。 + +```csharp +// ----------------------------------------------------------- +// How to render HTML as PNG – Complete, runnable example +// ----------------------------------------------------------- +using System; +using System.IO; +using Aspose.Html; +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +class Program +{ + static void Main() + { + // 1️⃣ Configure rendering options + ImageRenderingOptions renderingOptions = new ImageRenderingOptions + { + Width = 800, + Height = 600, + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic + }; + + // 2️⃣ Load HTML markup + HtmlDocument htmlDoc = new HtmlDocument(); + htmlDoc.Open("Hello, world!
"); + + // 3️⃣ Define output path + string outputPath = @"C:\Temp\Images\output.png"; + + // 4️⃣ Render to PNG + using (FileStream outputStream = File.OpenWrite(outputPath)) + { + htmlDoc.RenderToStream(outputStream, renderingOptions); + } + + // 5️⃣ Verify the result + Console.WriteLine(File.Exists(outputPath) + ? $"✅ PNG saved at {outputPath}" + : "❌ Failed to create PNG"); + } +} +``` + +プログラムを実行 (`dotnet run`) し、`C:\Temp\Images\output.png` を開いてください。すべてが正常に動作すれば、純粋な C# コードだけで **HTML を画像に変換** し、**HTML を PNG として保存** したことになります。 + +## Frequently Asked Questions + +| Question | Answer | +|----------|--------| +| **Can I render a full webpage with external CSS/JS?** | Yes – just call `htmlDoc.Open("https://example.com")`. The engine will download linked resources, but you need network access. | +| **What formats are supported besides PNG?** | `ImageRenderingOptions` works with JPEG, BMP, GIF, and TIFF. Change the file extension and set `ImageFormat` if needed. | +| **Is there a limit on image size?** | Technically you can go up to several thousand pixels, but very large dimensions may exhaust memory. Consider rendering in tiles for ultra‑high‑res output. | +| **How do I handle DPI for print‑quality images?** | Set `renderingOptions.DpiX` and `renderingOptions.DpiY` (default is 96). Higher DPI yields sharper output for printing. | +| **Do I need a license for Aspose.HTML?** | A free evaluation works with a watermark. For production, purchase a license to remove it and unlock full features. | + +## Next Steps and Related Topics + +- **Convert HTML to JPEG** – ファイル拡張子を変更し、必要に応じて `renderingOptions.ImageFormat = ImageFormat.Jpeg` を設定します。 +- **Batch processing** – URL のリストをループしてそれぞれサムネイルを生成します。 +- **Embedding fonts** – 完璧なタイポグラフィのためにマークアップ内で `@font-face` の使い方を学びます。 +- **Advanced layout** – カスタム外観のために `PageSize`、`Margin`、`BackgroundColor` オプションを試してみてください。 + +次元を調整したり、別の HTML スニペットを試したり、このコードを Web API に組み込んで PNG プレビューをオンデマンドで提供したりしてみてください。**HTML をプログラムでレンダリング**できれば、可能性は無限に広がります。 + +--- + + + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/korean/net/html-extensions-and-conversions/_index.md b/html/korean/net/html-extensions-and-conversions/_index.md index 88fbf791fb..a892b0b414 100644 --- a/html/korean/net/html-extensions-and-conversions/_index.md +++ b/html/korean/net/html-extensions-and-conversions/_index.md @@ -109,6 +109,8 @@ C#와 Aspose.HTML을 사용해 사용자 정의 리소스 핸들러로 HTML을 Z Aspose.HTML for .NET을 활용해 C#에서 HTML을 PDF로 변환하는 전체 단계별 가이드입니다. ### [Aspose HTML 저장 옵션: C#에서 HTML을 스트림으로 저장](./aspose-html-save-options-save-html-to-stream-in-c/) Aspose.HTML for .NET을 사용해 C#에서 HTML을 메모리 스트림으로 저장하는 방법을 단계별로 안내합니다. +### [Aspose.HTML에서 핸들러 사용 방법 – HTML 로드 및 ZIP으로 저장](./how-to-use-handler-in-aspose-html-load-html-save-as-zip/) +Aspose.HTML의 핸들러를 활용해 HTML을 로드하고 ZIP 파일로 저장하는 단계별 가이드를 제공합니다. ## 결론 diff --git a/html/korean/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md b/html/korean/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md new file mode 100644 index 0000000000..133d91a82b --- /dev/null +++ b/html/korean/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md @@ -0,0 +1,186 @@ +--- +category: general +date: 2026-02-25 +description: Aspose.HTML를 사용하여 핸들러로 URL에서 HTML을 로드하고 웹 페이지를 ZIP으로 저장하는 방법 – 완전한 C# + 단계별 가이드. +draft: false +keywords: +- how to use handler +- load html from url +- custom resource handler +- save webpage as zip +- create zip from html +language: ko +og_description: 핸들러를 사용해 URL에서 HTML을 로드하고 Aspose.HTML로 웹페이지를 ZIP 파일로 저장하는 방법. 몇 분 + 안에 전체 C# 워크플로를 배워보세요. +og_title: Aspose.HTML에서 핸들러 사용 방법 – HTML 로드, ZIP으로 저장 +tags: +- Aspose.HTML +- C# +- Web Scraping +title: Aspose.HTML에서 핸들러 사용 방법 – HTML 로드, ZIP으로 저장 +url: /ko/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Aspose.HTML에서 핸들러 사용 방법 – HTML 로드, ZIP으로 저장 + +웹 페이지를 .NET 앱으로 가져올 때 **핸들러 사용 방법**이 궁금했나요? `HtmlDocument.Open`을 사용해 HTML을 얻었지만 이미지, CSS, 폰트가 사라진 적이 있나요? 이는 흔한 문제로, Aspose.HTML에 리소스를 어떻게 처리할지 알려주지 않으면 리소스가 손실됩니다. + +이 튜토리얼에서는 URL에서 HTML을 로드하고 **커스텀 리소스 핸들러**를 연결한 뒤 **웹 페이지를 zip으로 저장**하는 과정을 단계별로 살펴봅니다. 최종적으로 어떤 프로젝트에든 삽입할 수 있는 실행 준비가 된 C# 코드 조각과, 이후에 발생할 수 있는 문제를 방지하는 몇 가지 팁을 제공합니다. + +## 필요 사항 + +- .NET 6+ (API는 .NET Core 및 .NET Framework에서도 작동합니다) +- Aspose.HTML for .NET (NuGet 패키지 `Aspose.HTML`) +- 약간의 C# 경험 (`Console.WriteLine` 정도만 작성해 본 적 있으면 충분합니다) + +추가 도구나 외부 서비스는 필요 없습니다—라이브러리와 아카이브하려는 URL만 있으면 됩니다. + + + +## 단계 1: URL에서 HTML 로드 + +웹 스크래핑 흐름에서 가장 먼저 하는 일은 페이지 소스를 가져오는 것입니다. Aspose.HTML은 이를 한 줄 코드로 처리하지만, 우리는 내장 네트워크 스택을 사용해 **URL에서 HTML 로드**하고 있다는 점을 기억하세요. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +// 1️⃣ Load the page you want to archive +HtmlDocument htmlDoc = new HtmlDocument(); +htmlDoc.Open("https://example.com"); // replace with any public URL +``` + +> **왜 중요한가:** `HtmlDocument.Open`은 마크업을 파싱하고 *내부적으로* 상대 URL을 해결하지만, 외부 자산을 자동으로 저장하지는 않습니다. 그래서 나중에 핸들러가 필요합니다. + +## 단계 2: 커스텀 리소스 핸들러 만들기 + +이제 핵심 단계인 **핸들러 사용 방법**으로 모든 외부 리소스 요청(이미지, CSS, 폰트 등)을 가로채는 단계입니다. `ResourceHandler`를 서브클래스화하면 각 자산을 제공하는 스트림을 완전히 제어할 수 있습니다. + +```csharp +// 2️⃣ Define your own handler (optional but powerful) +public class MyResourceHandler : ResourceHandler +{ + // Called for each external resource the document needs + public override Stream HandleResource(ResourceInfo info) + { + // Here you could download the file, cache it, or rewrite it. + // For this demo we simply return an empty stream – Aspose will + // still create the entry in the ZIP, keeping the folder structure. + return new MemoryStream(); + } +} +``` + +> **프로 팁:** 실제 운영 환경에서는 실제 바이트(`HttpClient.GetStreamAsync(info.Uri)`)를 다운로드하여 해당 스트림을 반환하는 것이 좋습니다. 이렇게 하면 저장된 ZIP에 빈 자리표시자가 아닌 실제 이미지가 포함됩니다. + +## 단계 3: 저장 옵션 구성 및 핸들러 연결 + +핸들러가 준비되면 Aspose.HTML에 모든 것을 어떻게 패키징할지 알려줍니다. `HtmlSaveOptions` 클래스에서 `SaveToZipArchive` 스위치를 켜고 `MyResourceHandler`를 연결할 수 있습니다. + +```csharp +// 3️⃣ Set up saving options – this is where we **save webpage as zip** +HtmlSaveOptions saveOptions = new HtmlSaveOptions +{ + // Attach our custom handler – new API as of v22.10 + OutputStorage = new MyResourceHandler(), + + // Instruct Aspose to bundle HTML + resources into a single ZIP file + SaveToZipArchive = true +}; +``` + +> **설명:** `OutputStorage`는 핸들러 인스턴스를 받는 속성입니다. 저장기가 DOM을 순회하면서 각 외부 링크에 대해 `HandleResource`를 호출합니다. `SaveToZipArchive`가 true이므로 반환된 각 스트림을 원본 경로와 일치하는 ZIP 엔트리로 기록합니다. + +## 단계 4: 문서를 MemoryStream에 저장 + +디스크에 바로 쓸 수도 있지만, 모든 것을 메모리에 보관하면 ASP.NET, Azure Functions 등 임시 파일이 필요 없는 환경에서도 코드를 사용할 수 있습니다. 여기서는 **HTML에서 ZIP 만들기** 최종 단계입니다. + +```csharp +// 4️⃣ Save everything – HTML + resources – into a MemoryStream +using (MemoryStream outputStream = new MemoryStream()) +{ + htmlDoc.Save(outputStream, saveOptions); + + // At this point outputStream holds a valid ZIP archive. + // For demo purposes we write it to the file system: + File.WriteAllBytes("example_page.zip", outputStream.ToArray()); +} +``` + +### 예상 결과 + +- `example_page.zip` 파일이 프로젝트 폴더에 생성됩니다. +- ZIP 내부에는 `index.html`과 폴더 구조(`images/`, `css/` 등)가 포함됩니다. +- 데모 핸들러가 빈 스트림을 반환했지만, ZIP 레이아웃은 원본 페이지와 동일하게 구성되어 나중에 실제 다운로더로 교체하기에 적합합니다. + +## 일반적인 변형 및 엣지 케이스 + +### URL 대신 로컬 파일 로드 + +디스크에 있는 **URL과 같은 경로**에서 HTML을 로드해야 한다면 `htmlDoc.Open("https://example.com")`을 `htmlDoc.Open(@"C:\path\to\file.html")`로 교체하면 됩니다. 나머지 파이프라인은 동일하게 유지됩니다. + +### 실제 리소스 저장 + +실제로 이미지를 포함하려면 `HandleResource`를 다음과 같이 수정합니다: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Download the resource using HttpClient + HttpClient client = new HttpClient(); + var data = client.GetByteArrayAsync(info.Uri).Result; + return new MemoryStream(data); +} +``` + +> **주의:** 핸들러 내부에서 네트워크 호출을 하면 저장 스레드가 차단됩니다; 큰 페이지의 경우 핸들러를 비동기로 구현하는 것을 고려하세요(새로운 Aspose 릴리스에서 지원). + +### ZIP 엔트리 이름 변경 + +`ResourceInfo`에는 `FileName`과 `Path`가 포함됩니다. 계층 구조를 평탄화하거나 접두사를 추가하도록 재작성할 수 있습니다. + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Example: prepend "assets/" to every entry + info.Path = Path.Combine("assets", info.Path); + return base.HandleResource(info); +} +``` + +### 다른 OutputStorage 사용 + +`OutputStorage`는 ZIP 대신 폴더를 원한다면 `FileSystemStorage`로 설정할 수도 있습니다. `SaveToZipArchive = false`로 설정하고 `OutputStorage`를 디렉터리 경로로 지정하면 됩니다. + +## 전문가 팁 및 함정 + +- **Dispose**를 잊지 마세요: 루프에서 여러 페이지를 열 경우 `HtmlDocument`를 반드시 dispose 해야 네이티브 리소스 누수를 방지할 수 있습니다. +- **메모리 사용량:** 큰 페이지를 `MemoryStream`에 저장하면 RAM 사용량이 급증합니다. 멀티 메가바이트 아카이브의 경우 파일(`FileStream`)에 직접 스트리밍하는 것이 좋습니다. +- **문자 인코딩:** Aspose.HTML은 `` 태그를 존중합니다. 원본 페이지가 흔하지 않은 인코딩을 사용한다면 추출 후 HTML이 올바르게 렌더링되는지 확인하세요. +- **테스트:** 생성된 ZIP을 브라우저에서 열어(`index.html`을 끌어다 놓기) 모든 리소스가 정상적으로 로드되는지 확인합니다. 이미지가 없으면 `HandleResource`가 빈 스트림을 반환했을 가능성이 높습니다. + +## 요약 + +우리는 외부 리소스를 가로채는 **핸들러 사용 방법**을 다루고, **URL에서 HTML 로드**를 시연했으며, **커스텀 리소스 핸들러**를 구축하고, 최종적으로 **웹 페이지를 ZIP으로 저장**하는 과정을 보여주었습니다—즉, 몇 줄의 C# 코드만으로 **HTML에서 ZIP 만들기**를 구현했습니다. 이 패턴은 확장성이 있어 빈 `MemoryStream`을 실제 다운로더로 교체하거나, 출력 대상을 변경하거나, 필요 시 ZIP을 반환하는 웹 API에 로직을 삽입할 수 있습니다. + +--- + +### 다음 단계는? + +- **배치 처리:** URL 목록을 순회하며 페이지당 ZIP을 생성합니다. +- **압축 조정:** `ZipSaveOptions`를 사용해 압축 레벨을 조정하여 다운로드 속도를 높입니다. +- **ASP.NET Core와 통합:** `MemoryStream`을 `FileResult`로 반환해 사용자가 웹 엔드포인트에서 직접 아카이브를 다운로드하도록 합니다. +- **다른 Aspose.HTML 기능 탐색:** PDF 변환, DOM 조작, 헤드리스 렌더링 등. + +특정 사용 사례에 대한 질문이 있나요? 예를 들어 JavaScript를 보존하거나 인증이 필요한 페이지를 처리해야 한다면 아래에 댓글을 남겨 주세요. 더 자세히 설명해 드리겠습니다. 즐거운 코딩 되세요! + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/korean/net/rendering-html-documents/_index.md b/html/korean/net/rendering-html-documents/_index.md index 472cf9650b..e76e190560 100644 --- a/html/korean/net/rendering-html-documents/_index.md +++ b/html/korean/net/rendering-html-documents/_index.md @@ -50,6 +50,10 @@ HTML을 PNG 이미지로 변환하는 전체 과정을 단계별로 안내합니 Aspose.HTML for .NET을 사용해 C#으로 HTML을 PNG 이미지로 변환하는 전체 과정을 단계별로 안내합니다. ### [Aspose를 사용하여 HTML을 PNG로 렌더링하는 단계별 가이드](./how-to-use-aspose-to-render-html-to-png-step-by-step-guide/) Aspose를 활용해 HTML을 PNG로 변환하는 과정을 단계별로 자세히 설명합니다. + +### [C#에서 HTML을 PNG로 렌더링하는 방법 – 단계별 가이드](./how-to-render-html-as-png-in-c-step-by-step-guide/) +Aspose.HTML for .NET을 사용해 C#으로 HTML을 PNG 이미지로 변환하는 전체 과정을 단계별로 안내합니다. + ### [Aspose를 사용하여 HTML을 PNG로 렌더링하는 완전 가이드](./how-to-render-html-to-png-with-aspose-complete-guide/) Aspose를 활용해 HTML을 PNG 이미지로 변환하는 전체 단계별 가이드를 확인하세요. ### [C#에서 HTML을 PNG로 렌더링하는 방법 – 단계별 가이드](./how-to-render-html-to-png-in-c-step-by-step-guide/) diff --git a/html/korean/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md b/html/korean/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..c0e5cdfef0 --- /dev/null +++ b/html/korean/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md @@ -0,0 +1,222 @@ +--- +category: general +date: 2026-02-25 +description: Aspose.HTML을 사용하여 C#에서 HTML을 PNG로 렌더링하는 방법. HTML을 이미지로 변환하고, HTML을 PNG로 + 저장하며, HTML에서 빠르게 PNG를 만드는 방법을 배워보세요. +draft: false +keywords: +- how to render html +- convert html to image +- save html as png +- create png from html +- generate png from html +language: ko +og_description: Aspose.HTML를 사용하여 C#에서 HTML을 PNG로 렌더링하는 방법. 이 튜토리얼을 따라 HTML을 이미지로 + 변환하고, HTML을 PNG로 저장하며, HTML에서 PNG를 생성하세요. +og_title: C#에서 HTML을 PNG로 렌더링하는 방법 – 완전 가이드 +tags: +- C# +- Aspose.HTML +- Image Rendering +title: C#에서 HTML을 PNG로 렌더링하는 방법 – 단계별 가이드 +url: /ko/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# C#에서 HTML을 PNG로 렌더링하는 방법 – 단계별 가이드 + +브라우저를 사용하지 않고 **HTML을 직접 PNG 파일**로 렌더링하는 방법이 궁금하셨나요? 이메일에 웹페이지의 작은 스냅샷을 삽입해야 할 수도 있고, CMS용 썸네일 서비스를 구축하고 있을 수도 있습니다. 어느 경우든 문제는 마크업을 저장하거나 제공할 수 있는 비트맵으로 변환하는 것입니다. + +이 튜토리얼에서는 Aspose.HTML for .NET을 사용하여 **HTML을 이미지로 변환**하는 완전하고 바로 실행 가능한 솔루션을 보여드립니다. 또한 **HTML을 PNG로 저장**, **HTML에서 PNG 만들기**, 그리고 사용자 지정 폰트와 크기를 사용해 **HTML에서 PNG 생성**하는 방법도 다룹니다. 모호한 설명은 없습니다—복사‑붙여넣기 할 수 있는 코드와 각 라인이 왜 중요한지에 대한 설명만 제공합니다. + +## 필요 사항 + +- .NET 6 (또는 최신 .NET 런타임) – API는 .NET Framework 4.6+에서도 동일하게 작동합니다. +- Visual Studio 2022 또는 VS Code – 원하는 것을 사용하세요. +- **Aspose.HTML** NuGet 패키지(`Aspose.HTML.NET`) – 한 번 설치하면 바로 사용할 수 있습니다. +- 출력 PNG를 저장할 쓰기 가능한 폴더 (예: `C:\Temp\Images`). + +그게 전부입니다. 추가 바이너리, 외부 웹 서비스, 숨겨진 구성 파일이 필요하지 않습니다. + +## 단계 1: NuGet을 통해 Aspose.HTML 설치 + +먼저 라이브러리를 프로젝트에 추가합니다. 솔루션 폴더에서 터미널을 열고 다음을 실행하세요: + +```bash +dotnet add package Aspose.HTML.NET +``` + +*Pro tip:* Visual Studio를 사용 중이라면 **Dependencies → Manage NuGet Packages**를 마우스 오른쪽 버튼으로 클릭하고 “Aspose.HTML”을 검색한 뒤 **Install**를 클릭합니다. 이렇게 하면 `HtmlDocument`, `ImageRenderingOptions` 등 우리가 사용할 클래스에 접근할 수 있습니다. + +## 단계 2: 렌더링 옵션 설정 (크기, 스타일 및 폰트) + +렌더러에 마크업을 전달하기 전에 그림의 크기와 보존하고 싶은 폰트 스타일을 결정합니다. `ImageRenderingOptions` 객체를 사용하면 너비, 높이 및 굵게/기울임 렌더링을 강제할 수 있습니다. + +```csharp +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +// Configure image rendering options – width, height, and font style +ImageRenderingOptions renderingOptions = new ImageRenderingOptions +{ + Width = 800, // Desired image width in pixels + Height = 600, // Desired image height in pixels + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic // Preserve bold & italic +}; +``` + +**왜 중요한가:** +- **Width/Height**는 최종 픽셀 차원을 결정합니다; 이를 생략하면 엔진이 HTML 레이아웃을 기반으로 추측하게 되며, 예상치 못한 잘림이 발생할 수 있습니다. +- **FontStyle**은 `` 또는 `` 태그가 래스터화될 때 시각적 강조를 유지하도록 보장합니다. + +## 단계 3: HTML 마크업 로드 + +HTML을 문자열, 파일 또는 URL에서 로드할 수 있습니다. 여기서는 간단히 코딩에 직접 작은 스니펫을 삽입합니다. 폰트 패밀리를 지정하는 인라인 CSS에 주목하세요 – Aspose.HTML은 표준 웹 CSS를 그대로 적용하므로 충실한 렌더링을 얻을 수 있습니다. + +```csharp +using Aspose.Html; + +// Create an empty HTML document +HtmlDocument htmlDoc = new HtmlDocument(); + +// Load simple markup – you could also use htmlDoc.Open("path/to/file.html") +htmlDoc.Open("Hello, world!
"); +``` + +**Edge case tip:** 마크업이 외부 리소스(이미지, CSS 파일)를 참조한다면 해당 URL이 코드를 실행하는 머신에서 접근 가능하도록 하거나, 깨진 링크를 방지하기 위해 data‑URI로 임베드하세요. + +## 단계 4: HTML을 PNG 스트림으로 렌더링 + +이제 **HTML을 렌더링하는 방법**의 핵심이 등장합니다 – `RenderToStream`을 호출하고, 앞서 구성한 출력 스트림과 옵션을 전달합니다. 이 메서드는 레이아웃, CSS 계단식, 폰트 대체 및 래스터화를 모두 수행합니다. + +```csharp +using System.IO; + +// Choose an output path – replace with your own directory +string outputPath = @"C:\Temp\Images\output.png"; + +using (FileStream outputStream = File.OpenWrite(outputPath)) +{ + // Render the HTML document into the PNG file + htmlDoc.RenderToStream(outputStream, renderingOptions); +} +``` + +`using` 블록이 끝나면 `output.png`에 로드한 단락의 800 × 600 픽셀 이미지가 저장됩니다. 이미지 뷰어로 열어 결과를 확인하세요. + +### 예상 결과 + +흰색 배경에 **“Hello, world!”** 텍스트가 Arial 폰트로 굵게·기울임체, 정확히 24 pt 크기로 렌더링된 모습을 볼 수 있습니다. 이미지 차원은 우리가 설정한 800 × 600 값과 일치합니다. + +## 단계 5: 검증 및 일반적인 함정 처리 + +### 5.1 파일 존재 여부 확인 + +간단한 정상 확인으로 무음 실패를 방지합니다: + +```csharp +if (File.Exists(outputPath)) +{ + Console.WriteLine($"✅ PNG created successfully at {outputPath}"); +} +else +{ + Console.WriteLine("❌ Something went wrong – PNG not found."); +} +``` + +### 5.2 누락된 폰트 처리 + +대상 머신에 요청한 폰트가 없으면 Aspose.HTML은 일반 sans‑serif 폰트로 대체합니다. 일관성을 보장하려면 다음 중 하나를 선택하세요: + +- HTML에 `@font-face` 규칙을 사용해 폰트 파일을 임베드 **또는** +- 렌더링 전에 프로그래밍 방식으로 폰트를 등록합니다. + +```csharp +// Example of registering a custom TrueType font +htmlDoc.Fonts.AddFontFile(@"C:\Fonts\OpenSans-Regular.ttf"); +``` + +### 5.3 큰 페이지 렌더링 + +전체 페이지 스크린샷용 썸네일을 만들 때는 메모리 사용량을 주시하세요. 렌더링 후에 다운스케일하거나 `renderingOptions.Width`/`Height`를 더 작은 값으로 설정해 Aspose.HTML이 스케일링을 처리하도록 할 수 있습니다. + +## 전체 작업 예제 + +아래는 콘솔 애플리케이션에 바로 넣어 실행할 수 있는 완전한 프로그램입니다. + +```csharp +// ----------------------------------------------------------- +// How to render HTML as PNG – Complete, runnable example +// ----------------------------------------------------------- +using System; +using System.IO; +using Aspose.Html; +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +class Program +{ + static void Main() + { + // 1️⃣ Configure rendering options + ImageRenderingOptions renderingOptions = new ImageRenderingOptions + { + Width = 800, + Height = 600, + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic + }; + + // 2️⃣ Load HTML markup + HtmlDocument htmlDoc = new HtmlDocument(); + htmlDoc.Open("Hello, world!
"); + + // 3️⃣ Define output path + string outputPath = @"C:\Temp\Images\output.png"; + + // 4️⃣ Render to PNG + using (FileStream outputStream = File.OpenWrite(outputPath)) + { + htmlDoc.RenderToStream(outputStream, renderingOptions); + } + + // 5️⃣ Verify the result + Console.WriteLine(File.Exists(outputPath) + ? $"✅ PNG saved at {outputPath}" + : "❌ Failed to create PNG"); + } +} +``` + +프로그램을 실행(`dotnet run`)한 뒤 `C:\Temp\Images\output.png`를 열어 보세요. 모든 것이 순조롭게 진행되었다면 순수 C# 코드만으로 **HTML을 이미지로 변환**하고 **HTML을 PNG로 저장**한 것입니다. + +## 자주 묻는 질문 + +| Question | Answer | +|----------|--------| +| **외부 CSS/JS가 포함된 전체 웹페이지를 렌더링할 수 있나요?** | 예 – `htmlDoc.Open("https://example.com")`을 호출하면 됩니다. 엔진이 연결된 리소스를 다운로드하지만 네트워크 접근 권한이 필요합니다. | +| **PNG 외에 지원되는 포맷은 무엇인가요?** | `ImageRenderingOptions`는 JPEG, BMP, GIF, TIFF도 지원합니다. 파일 확장자를 변경하고 필요하면 `ImageFormat`을 설정하세요. | +| **이미지 크기에 제한이 있나요?** | 기술적으로 수천 픽셀까지 가능하지만, 매우 큰 차원은 메모리를 소모할 수 있습니다. 초고해상도 출력이 필요하면 타일 단위로 렌더링하는 것을 고려하세요. | +| **인쇄 품질 이미지를 위한 DPI는 어떻게 설정하나요?** | `renderingOptions.DpiX`와 `renderingOptions.DpiY`를 설정합니다(기본값은 96). DPI를 높이면 인쇄 시 더 선명한 결과를 얻을 수 있습니다. | +| **Aspose.HTML 라이선스가 필요한가요?** | 무료 평가판은 워터마크가 표시됩니다. 제품 환경에서는 라이선스를 구매해 워터마크를 제거하고 모든 기능을 활성화하세요. | + +## 다음 단계 및 관련 주제 + +- **HTML을 JPEG로 변환** – 파일 확장자를 교체하고 필요하면 `renderingOptions.ImageFormat = ImageFormat.Jpeg`를 설정합니다. +- **배치 처리** – URL 목록을 순회하면서 각각에 대한 썸네일을 생성합니다. +- **폰트 임베드** – 완벽한 타이포그래피를 위해 마크업 내 `@font-face` 사용 방법을 학습합니다. +- **고급 레이아웃** – `PageSize`, `Margin`, `BackgroundColor` 옵션을 실험해 맞춤형 디자인을 구현합니다. + +차원 값을 조정하거나 다른 HTML 스니펫을 시도해 보세요. 혹은 이 코드를 웹 API에 통합해 실시간으로 PNG 미리보기를 제공할 수도 있습니다. **HTML을 프로그래밍 방식으로 렌더링**하는 방법을 알면 가능성은 무한합니다. + +--- + + + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/polish/net/html-extensions-and-conversions/_index.md b/html/polish/net/html-extensions-and-conversions/_index.md index 1d50751b6d..0a317fc118 100644 --- a/html/polish/net/html-extensions-and-conversions/_index.md +++ b/html/polish/net/html-extensions-and-conversions/_index.md @@ -111,6 +111,8 @@ Pełny przewodnik, jak konwertować HTML do PDF w C# przy użyciu Aspose.HTML i Dowiedz się, jak zapisać całą stronę internetową jako jeden plik HTML przy użyciu Aspose.HTML w C#. ### [Opcje zapisu Aspose HTML: Zapisz HTML do strumienia w C#](./aspose-html-save-options-save-html-to-stream-in-c/) Dowiedz się, jak zapisać dokument HTML bezpośrednio do strumienia w C# przy użyciu Aspose.HTML. +### [Jak używać handlera w Aspose.HTML – wczytaj HTML i zapisz jako ZIP](./how-to-use-handler-in-aspose-html-load-html-save-as-zip/) +Dowiedz się, jak używać handlera w Aspose.HTML do wczytywania HTML i zapisywania go jako pliku ZIP. ## Wniosek diff --git a/html/polish/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md b/html/polish/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md new file mode 100644 index 0000000000..a146f2b647 --- /dev/null +++ b/html/polish/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md @@ -0,0 +1,183 @@ +--- +category: general +date: 2026-02-25 +description: jak używać handlera do ładowania HTML z adresu URL i zapisywania strony + jako zip przy użyciu Aspose.HTML – kompletny przewodnik krok po kroku w C# +draft: false +keywords: +- how to use handler +- load html from url +- custom resource handler +- save webpage as zip +- create zip from html +language: pl +og_description: Jak używać handlera do ładowania HTML z adresu URL i zapisywania strony + jako plik ZIP przy użyciu Aspose.HTML. Poznaj kompletny przepływ pracy w C# w kilka + minut. +og_title: jak używać handlera w Aspose.HTML – ładowanie HTML, zapisywanie jako ZIP +tags: +- Aspose.HTML +- C# +- Web Scraping +title: Jak używać handlera w Aspose.HTML – Ładowanie HTML, zapis jako ZIP +url: /pl/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# jak używać handlera w Aspose.HTML – Ładowanie HTML, zapis jako ZIP + +Zastanawiałeś się kiedyś **jak używać handlera**, pobierając stronę internetową do swojej aplikacji .NET? Być może próbowałeś `HtmlDocument.Open` i otrzymałeś HTML, ale obrazy, CSS i czcionki zniknęły w powietrzu. To częsty problem — zasoby zostają utracone, jeśli nie powiesz Aspose.HTML, co z nimi zrobić. + +W tym tutorialu przejdziemy przez ładowanie HTML z URL, podłączenie **custom resource handler**, a na końcu **save webpage as zip**, tak abyś otrzymał jedną przenośną archiwum. Na koniec będziesz mieć gotowy do uruchomienia fragment C# , który możesz wkleić do dowolnego projektu, plus kilka wskazówek, które zaoszczędzą Ci problemów później. + +## Czego będziesz potrzebować + +- .NET 6+ (API działa również na .NET Core i .NET Framework) +- Aspose.HTML for .NET (pakiet NuGet `Aspose.HTML`) +- Umiarkowane doświadczenie w C# (poradzisz sobie, jeśli wcześniej napisałeś `Console.WriteLine`) + +Bez dodatkowych narzędzi, bez zewnętrznych usług — tylko biblioteka i URL, który chcesz zarchiwizować. + + + +## Krok 1: Ładowanie HTML z URL + +Pierwszą rzeczą w każdym procesie web‑scrapingu jest pobranie źródła strony. Aspose.HTML robi to w jednej linii, ale pamiętaj, że **loading html from url** odbywa się przy użyciu wbudowanego stosu sieciowego. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +// 1️⃣ Load the page you want to archive +HtmlDocument htmlDoc = new HtmlDocument(); +htmlDoc.Open("https://example.com"); // replace with any public URL +``` + +> **Why this matters:** `HtmlDocument.Open` parses the markup *and* resolves relative URLs internally, but it doesn’t automatically persist the external assets. That’s why we need a handler later. + +## Krok 2: Utworzenie własnego Resource Handlera + +Teraz przychodzi sedno sprawy — **how to use handler** do przechwytywania każdego żądania zewnętrznego zasobu (obrazy, CSS, czcionki itp.). Dziedzicząc po `ResourceHandler` zyskujesz pełną kontrolę nad strumieniem, który obsługuje każdy zasób. + +```csharp +// 2️⃣ Define your own handler (optional but powerful) +public class MyResourceHandler : ResourceHandler +{ + // Called for each external resource the document needs + public override Stream HandleResource(ResourceInfo info) + { + // Here you could download the file, cache it, or rewrite it. + // For this demo we simply return an empty stream – Aspose will + // still create the entry in the ZIP, keeping the folder structure. + return new MemoryStream(); + } +} +``` + +> **Pro tip:** In a production scenario you might want to download the actual bytes (`HttpClient.GetStreamAsync(info.Uri)`) and return that stream. This ensures the saved ZIP contains the real images instead of empty placeholders. + +## Krok 3: Konfiguracja opcji zapisu i podłączenie handlera + +Z gotowym handlerem informujemy Aspose.HTML, jak spakować wszystko. Klasa `HtmlSaveOptions` pozwala przełączyć `SaveToZipArchive` i podłączyć własny `MyResourceHandler`. + +```csharp +// 3️⃣ Set up saving options – this is where we **save webpage as zip** +HtmlSaveOptions saveOptions = new HtmlSaveOptions +{ + // Attach our custom handler – new API as of v22.10 + OutputStorage = new MyResourceHandler(), + + // Instruct Aspose to bundle HTML + resources into a single ZIP file + SaveToZipArchive = true +}; +``` + +> **Explanation:** `OutputStorage` is the property that receives the handler instance. When the saver walks the DOM it calls `HandleResource` for each external link. Because `SaveToZipArchive` is true, the saver writes each returned stream into a ZIP entry matching the original path. + +## Krok 4: Zapis dokumentu do Memory Stream + +Można by zapisać od razu na dysk, ale trzymanie wszystkiego w pamięci sprawia, że kod jest użyteczny w ASP.NET, Azure Functions lub w każdym miejscu, gdzie nie chcesz pliku tymczasowego. Oto ostatni krok, który **creates zip from html**. + +```csharp +// 4️⃣ Save everything – HTML + resources – into a MemoryStream +using (MemoryStream outputStream = new MemoryStream()) +{ + htmlDoc.Save(outputStream, saveOptions); + + // At this point outputStream holds a valid ZIP archive. + // For demo purposes we write it to the file system: + File.WriteAllBytes("example_page.zip", outputStream.ToArray()); +} +``` + +### Oczekiwany wynik + +- `example_page.zip` pojawia się w folderze projektu. +- Wewnątrz ZIP znajdziesz `index.html` oraz strukturę folderów (`images/`, `css/` itp.). +- Mimo że nasz demo handler zwrócił puste strumienie, układ ZIP odzwierciedla oryginalną stronę — idealny do późniejszej wymiany na prawdziwy downloader. + +## Typowe warianty i przypadki brzegowe + +### Ładowanie pliku lokalnego zamiast URL +Jeśli potrzebujesz **load html from url**‑like paths on disk, just replace `htmlDoc.Open("https://example.com")` with `htmlDoc.Open(@"C:\path\to\file.html")`. The rest of the pipeline stays identical. + +### Zachowywanie rzeczywistych zasobów +Aby naprawdę osadzić obrazy, zmodyfikuj `HandleResource`: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Download the resource using HttpClient + HttpClient client = new HttpClient(); + var data = client.GetByteArrayAsync(info.Uri).Result; + return new MemoryStream(data); +} +``` + +> **Caution:** Network calls inside the handler block the saving thread; for large pages consider making the handler asynchronous (available in newer Aspose releases). + +### Zmiana nazw wpisów w ZIP +`ResourceInfo` contains `FileName` and `Path`. You can rewrite them to flatten the hierarchy or add a prefix: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Example: prepend "assets/" to every entry + info.Path = Path.Combine("assets", info.Path); + return base.HandleResource(info); +} +``` + +### Użycie innego Output Storage +`OutputStorage` can also be a `FileSystemStorage` if you prefer a folder instead of a ZIP. Just set `SaveToZipArchive = false` and point `OutputStorage` to a directory path. + +## Porady i pułapki + +- **Nie zapomnij zwolnić** the `HtmlDocument` if you open many pages in a loop; otherwise you may leak native resources. +- **Użycie pamięci:** Saving huge pages into a `MemoryStream` can balloon RAM. For multi‑megabyte archives, stream directly to a file (`FileStream`) instead. +- **Kodowanie znaków:** Aspose.HTML respects the `` tag. If the source page uses an uncommon encoding, verify the resulting HTML renders correctly after extraction. +- **Testowanie:** Open the generated ZIP in a browser (drag `index.html` out) to ensure all resources resolve. If images are missing, your `HandleResource` likely returned an empty stream. + +## Podsumowanie + +Omówiliśmy **how to use handler** to intercept external resources, demonstrated **load html from url**, built a **custom resource handler**, and finally **save webpage as zip**—effectively **create zip from html** with a handful of lines of C#. The pattern scales: swap the empty `MemoryStream` for a real downloader, change the output target, or embed the logic in a web API that returns the ZIP on demand. + +--- + +### Co dalej? + +- **Przetwarzanie wsadowe:** Loop over a list of URLs and generate a ZIP per page. +- **Ustawienia kompresji:** Use `ZipSaveOptions` to adjust compression level for faster downloads. +- **Integracja z ASP.NET Core:** Return the `MemoryStream` as a `FileResult` so users can download the archive directly from a web endpoint. +- **Poznaj inne funkcje Aspose.HTML:** PDF conversion, DOM manipulation, or headless rendering. + +Masz pytania dotyczące konkretnego scenariusza — może potrzebujesz zachować JavaScript lub obsłużyć strony chronione uwierzytelnieniem? Dodaj komentarz poniżej; z przyjemnością zagłębię się w szczegóły. Happy coding! + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/polish/net/rendering-html-documents/_index.md b/html/polish/net/rendering-html-documents/_index.md index ff01b258d7..d93c40e7cd 100644 --- a/html/polish/net/rendering-html-documents/_index.md +++ b/html/polish/net/rendering-html-documents/_index.md @@ -58,6 +58,9 @@ Pełny przewodnik pokazujący, jak przy użyciu Aspose.HTML renderować dokument ### [Jak renderować HTML do PNG w C# – przewodnik krok po kroku](./how-to-render-html-to-png-in-c-step-by-step-guide/) Kompletny przewodnik w C#, pokazujący, jak przy użyciu Aspose.HTML renderować HTML do formatu PNG krok po kroku. +### [Jak renderować HTML jako PNG w C# – Przewodnik krok po kroku](./how-to-render-html-as-png-in-c-step-by-step-guide/) +Kompletny przewodnik w C# pokazujący, jak przy użyciu Aspose.HTML renderować HTML jako PNG krok po kroku. + ### [Renderuj EPUB jako XPS w .NET za pomocą Aspose.HTML](./render-epub-as-xps/) Dowiedz się, jak tworzyć i renderować dokumenty HTML za pomocą Aspose.HTML dla .NET w tym kompleksowym samouczku. Zanurz się w świecie manipulacji HTML, web scrapingu i nie tylko. @@ -65,7 +68,7 @@ Dowiedz się, jak tworzyć i renderować dokumenty HTML za pomocą Aspose.HTML d Dowiedz się, jak skutecznie kontrolować limity czasu renderowania w Aspose.HTML dla .NET. Poznaj opcje renderowania i zapewnij płynne renderowanie dokumentów HTML. ### [Renderuj MHTML jako XPS w .NET za pomocą Aspose.HTML](./render-mhtml-as-xps/) - Naucz się renderować MHTML jako XPS w .NET z Aspose.HTML. Udoskonal swoje umiejętności manipulacji HTML i przyspiesz swoje projekty rozwoju sieci! +Naucz się renderować MHTML jako XPS w .NET z Aspose.HTML. Udoskonal swoje umiejętności manipulacji HTML i przyspiesz swoje projekty rozwoju sieci! Naucz się renderować MHTML jako XPS w .NET z Aspose.HTML. Udoskonal swoje umiejętności manipulacji HTML i przyspiesz swoje projekty rozwoju sieci! diff --git a/html/polish/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md b/html/polish/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..af1bc28baf --- /dev/null +++ b/html/polish/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md @@ -0,0 +1,224 @@ +--- +category: general +date: 2026-02-25 +description: Jak renderować HTML jako PNG w C# przy użyciu Aspose.HTML. Dowiedz się, + jak konwertować HTML na obraz, zapisywać HTML jako PNG oraz szybko tworzyć PNG z + HTML. +draft: false +keywords: +- how to render html +- convert html to image +- save html as png +- create png from html +- generate png from html +language: pl +og_description: Jak renderować HTML jako PNG w C# przy użyciu Aspose.HTML. Skorzystaj + z tego samouczka, aby konwertować HTML na obraz, zapisać HTML jako PNG oraz generować + PNG z HTML. +og_title: Jak renderować HTML jako PNG w C# – Kompletny przewodnik +tags: +- C# +- Aspose.HTML +- Image Rendering +title: Jak renderować HTML jako PNG w C# – Przewodnik krok po kroku +url: /pl/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Jak renderować HTML jako PNG w C# – Przewodnik krok po kroku + +Zastanawiałeś się kiedyś, **jak renderować HTML** bezpośrednio do pliku PNG, nie uruchamiając przeglądarki? Może potrzebujesz osadzić mały podgląd strony w e‑mailu albo budujesz usługę miniatur dla CMS‑a. W każdym wypadku problem sprowadza się do przekształcenia znaczników w bitmapę, którą można zapisać lub udostępnić. + +W tym tutorialu zobaczysz kompletną, gotową do uruchomienia rozwiązanie, które **konwertuje HTML na obraz** przy użyciu Aspose.HTML for .NET. Poruszymy także tematy **zapisywania HTML jako PNG**, **tworzenia PNG z HTML** oraz **generowania PNG z HTML** z własnymi czcionkami i wymiarami. Bez niejasnych odwołań – po prostu kod, który możesz skopiować‑wkleić, oraz wyjaśnienia, dlaczego każda linijka ma znaczenie. + +## Co będzie potrzebne + +- .NET 6 (lub dowolny nowszy runtime .NET) – API działa tak samo na .NET Framework 4.6+. +- Visual Studio 2022 lub VS Code – wedle własnych preferencji. +- Pakiet NuGet **Aspose.HTML** (`Aspose.HTML.NET`) – zainstaluj go raz i gotowe. +- Zapisywalny folder na wyjściowy PNG (np. `C:\Temp\Images`). + +To wszystko. Bez dodatkowych binarek, zewnętrznych usług webowych i ukrytych plików konfiguracyjnych. + +## Krok 1: Instalacja Aspose.HTML przez NuGet + +Najpierw dodaj bibliotekę do projektu. Otwórz terminal w folderze rozwiązania i uruchom: + +```bash +dotnet add package Aspose.HTML.NET +``` + +*Wskazówka:* Jeśli pracujesz w Visual Studio, kliknij prawym przyciskiem **Dependencies → Manage NuGet Packages**, wyszukaj „Aspose.HTML” i kliknij **Install**. Dzięki temu uzyskasz dostęp do klas `HtmlDocument`, `ImageRenderingOptions` i innych, których użyjemy. + +## Krok 2: Konfiguracja opcji renderowania (rozmiar, styl i czcionki) + +Zanim przekażemy jakikolwiek znacznik do renderera, określamy, jak duży ma być obraz i które style czcionek chcemy zachować. Obiekt `ImageRenderingOptions` pozwala dostosować szerokość, wysokość oraz wymusić renderowanie pogrubień/pochyleń. + +```csharp +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +// Configure image rendering options – width, height, and font style +ImageRenderingOptions renderingOptions = new ImageRenderingOptions +{ + Width = 800, // Desired image width in pixels + Height = 600, // Desired image height in pixels + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic // Preserve bold & italic +}; +``` + +**Dlaczego to ważne:** +- **Width/Height** określają ostateczne wymiary w pikselach; jeśli ich nie podasz, silnik zgaduje na podstawie układu HTML, co może skutkować nieoczekiwanym przycięciem. +- **FontStyle** zapewnia, że tagi `` lub `` zachowają swój wizualny akcent po rasteryzacji. + +## Krok 3: Załadowanie znacznika HTML + +HTML możesz wczytać ze stringa, pliku lub URL. Dla prostoty wstawimy mały fragment bezpośrednio w kodzie. Zwróć uwagę na wbudowany CSS ustawiający rodzinę czcionki – Aspose.HTML respektuje standardowy CSS, więc otrzymasz wierne odwzorowanie. + +```csharp +using Aspose.Html; + +// Create an empty HTML document +HtmlDocument htmlDoc = new HtmlDocument(); + +// Load simple markup – you could also use htmlDoc.Open("path/to/file.html") +htmlDoc.Open("Hello, world!
"); +``` + +**Wskazówka dotycząca przypadków brzegowych:** Jeśli Twój znacznik odwołuje się do zewnętrznych zasobów (obrazów, plików CSS), upewnij się, że te URL‑e są dostępne z maszyny uruchamiającej kod, albo osadź je jako data‑URI, aby uniknąć zepsutych odnośników. + +## Krok 4: Renderowanie HTML do strumienia PNG + +Teraz dochodzimy do sedna **jak renderować HTML** – wywołujemy `RenderToStream`, przekazując strumień wyjściowy oraz wcześniej skonfigurowane opcje. Metoda zajmuje się całą ciężką pracą: układem, kaskadą CSS, podstawianiem czcionek i rasteryzacją. + +```csharp +using System.IO; + +// Choose an output path – replace with your own directory +string outputPath = @"C:\Temp\Images\output.png"; + +using (FileStream outputStream = File.OpenWrite(outputPath)) +{ + // Render the HTML document into the PNG file + htmlDoc.RenderToStream(outputStream, renderingOptions); +} +``` + +Po zakończeniu bloku `using` plik `output.png` będzie zawierał obraz 800 × 600 pikseli z załadowanym paragrafem. Otwórz go w dowolnym przeglądarce obrazów, aby zweryfikować rezultat. + +### Oczekiwany rezultat + +Powinieneś zobaczyć czyste białe tło z tekstem **„Hello, world!”** wyrenderowanym w Arial, pogrubionym i pochyłym, dokładnie 24 pt. Wymiary obrazu odpowiadają ustawionym wartościom 800 × 600. + +## Krok 5: Weryfikacja i obsługa typowych problemów + +### 5.1 Sprawdzanie, czy plik istnieje + +Krótka kontrola zapobiega cichym awariom: + +```csharp +if (File.Exists(outputPath)) +{ + Console.WriteLine($"✅ PNG created successfully at {outputPath}"); +} +else +{ + Console.WriteLine("❌ Something went wrong – PNG not found."); +} +``` + +### 5.2 Brakujące czcionki + +Jeśli docelowa maszyna nie ma żądanej czcionki, Aspose.HTML przełącza się na domyślną sans‑serif. Aby zapewnić spójność, możesz: + +- Osadzić plik czcionki przy pomocy reguły `@font-face` w HTML, **lub** +- Zarejestrować czcionkę programowo przed renderowaniem. + +```csharp +// Example of registering a custom TrueType font +htmlDoc.Fonts.AddFontFile(@"C:\Fonts\OpenSans-Regular.ttf"); +``` + +### 5.3 Renderowanie dużych stron + +Tworząc miniatury pełnostronicowych zrzutów, zwróć uwagę na zużycie pamięci. Możesz zmniejszyć rozmiar po renderowaniu lub ustawić `renderingOptions.Width`/`Height` na mniejsze wartości i pozwolić Aspose.HTML wykonać skalowanie. + +## Pełny działający przykład + +Poniżej znajduje się kompletny program, który możesz wkleić do aplikacji konsolowej i uruchomić od razu. + +```csharp +// ----------------------------------------------------------- +// How to render HTML as PNG – Complete, runnable example +// ----------------------------------------------------------- +using System; +using System.IO; +using Aspose.Html; +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +class Program +{ + static void Main() + { + // 1️⃣ Configure rendering options + ImageRenderingOptions renderingOptions = new ImageRenderingOptions + { + Width = 800, + Height = 600, + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic + }; + + // 2️⃣ Load HTML markup + HtmlDocument htmlDoc = new HtmlDocument(); + htmlDoc.Open("Hello, world!
"); + + // 3️⃣ Define output path + string outputPath = @"C:\Temp\Images\output.png"; + + // 4️⃣ Render to PNG + using (FileStream outputStream = File.OpenWrite(outputPath)) + { + htmlDoc.RenderToStream(outputStream, renderingOptions); + } + + // 5️⃣ Verify the result + Console.WriteLine(File.Exists(outputPath) + ? $"✅ PNG saved at {outputPath}" + : "❌ Failed to create PNG"); + } +} +``` + +Uruchom program (`dotnet run`), a następnie otwórz `C:\Temp\Images\output.png`. Jeśli wszystko poszło gładko, właśnie **przekonwertowałeś HTML na obraz** i **zapisałeś HTML jako PNG** przy użyciu czystego kodu C#. + +## Najczęściej zadawane pytania + +| Pytanie | Odpowiedź | +|----------|-----------| +| **Czy mogę renderować pełną stronę z zewnętrznym CSS/JS?** | Tak – wystarczy wywołać `htmlDoc.Open("https://example.com")`. Silnik pobierze powiązane zasoby, ale wymaga dostępu do sieci. | +| **Jakie formaty są obsługiwane oprócz PNG?** | `ImageRenderingOptions` działa z JPEG, BMP, GIF i TIFF. Zmieniasz rozszerzenie pliku i ustawiasz `ImageFormat`, jeśli potrzebujesz. | +| **Czy istnieje limit rozmiaru obrazu?** | Technicznie możesz sięgać kilku tysięcy pikseli, ale bardzo duże wymiary mogą wyczerpać pamięć. Rozważ renderowanie w kafelkach przy ultra‑wysokiej rozdzielczości. | +| **Jak obsłużyć DPI dla obrazów w jakości druku?** | Ustaw `renderingOptions.DpiX` i `renderingOptions.DpiY` (domyślnie 96). Wyższe DPI daje ostrzejszy wynik przy drukowaniu. | +| **Czy potrzebna jest licencja na Aspose.HTML?** | Ocena darmowa działa z watermarkiem. W produkcji zakup licencji, aby go usunąć i odblokować pełne funkcje. | + +## Kolejne kroki i tematy pokrewne + +- **Konwersja HTML do JPEG** – zmień rozszerzenie pliku i opcjonalnie ustaw `renderingOptions.ImageFormat = ImageFormat.Jpeg`. +- **Przetwarzanie wsadowe** – iteruj listę URL‑i i generuj miniatury dla każdego. +- **Osadzanie czcionek** – dowiedz się, jak używać `@font-face` w znaczniku, aby uzyskać perfekcyjną typografię. +- **Zaawansowany układ** – eksperymentuj z opcjami `PageSize`, `Margin` i `BackgroundColor`, aby uzyskać własny wygląd. + +Śmiało modyfikuj wymiary, wypróbuj różne fragmenty HTML lub wbuduj ten kod w API webowe, które na żądanie serwuje podglądy PNG. Nie ma granic, gdy wiesz **jak renderować HTML** programowo. + +--- + + + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/portuguese/net/html-extensions-and-conversions/_index.md b/html/portuguese/net/html-extensions-and-conversions/_index.md index 3fe9226f9b..9c8e8dd9ab 100644 --- a/html/portuguese/net/html-extensions-and-conversions/_index.md +++ b/html/portuguese/net/html-extensions-and-conversions/_index.md @@ -122,6 +122,9 @@ Aprenda a compactar HTML em C# usando um manipulador de recursos personalizado c ### [Aspose HTML Opções de Salvamento: Salvar HTML em Stream no C#](./aspose-html-save-options-save-html-to-stream-in-c/) Aprenda a salvar documentos HTML em um fluxo usando Aspose.HTML para .NET com C#. Guia passo a passo com exemplos de código. +### [Como usar handler no Aspose.HTML – Carregar HTML, Salvar como ZIP](./how-to-use-handler-in-aspose-html-load-html-save-as-zip/) +Aprenda a usar o handler do Aspose.HTML para carregar documentos HTML e salvá-los como arquivos ZIP em C#. + ## Conclusão Concluindo, extensões e conversões HTML são elementos essenciais do desenvolvimento web moderno. O Aspose.HTML para .NET simplifica o processo e o torna acessível a desenvolvedores de todos os níveis. Ao seguir nossos tutoriais, você estará no caminho certo para se tornar um desenvolvedor web proficiente com um amplo conjunto de habilidades. diff --git a/html/portuguese/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md b/html/portuguese/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md new file mode 100644 index 0000000000..08528dfa0b --- /dev/null +++ b/html/portuguese/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md @@ -0,0 +1,183 @@ +--- +category: general +date: 2026-02-25 +description: Como usar o manipulador para carregar HTML de uma URL e salvar a página + da web como zip com Aspose.HTML – um guia completo passo a passo em C#. +draft: false +keywords: +- how to use handler +- load html from url +- custom resource handler +- save webpage as zip +- create zip from html +language: pt +og_description: Como usar o handler para carregar HTML a partir de uma URL e salvar + a página da web como zip com Aspose.HTML. Aprenda todo o fluxo de trabalho em C# + em minutos. +og_title: como usar o manipulador no Aspose.HTML – Carregar HTML, Salvar como ZIP +tags: +- Aspose.HTML +- C# +- Web Scraping +title: Como usar o manipulador no Aspose.HTML – Carregar HTML, Salvar como ZIP +url: /pt/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# como usar handler no Aspose.HTML – Carregar HTML, Salvar como ZIP + +Já se perguntou **como usar handler** ao puxar uma página da web para seu aplicativo .NET? Talvez você tenha tentado `HtmlDocument.Open` e obtido o HTML, mas as imagens, CSS e fontes desapareceram. Isso é um problema comum—os recursos se perdem a menos que você indique ao Aspose.HTML o que fazer com eles. + +Neste tutorial vamos percorrer o carregamento de HTML a partir de uma URL, configurar um **custom resource handler**, e finalmente **save webpage as zip** para que você obtenha um único arquivo portátil. Ao final, você terá um trecho de C# pronto‑para‑executar que pode inserir em qualquer projeto, além de algumas dicas que evitam dores de cabeça mais tarde. + +## O que você precisará + +- .NET 6+ (a API funciona no .NET Core e no .NET Framework também) +- Aspose.HTML for .NET (pacote NuGet `Aspose.HTML`) +- Um modesto nível de experiência em C# (você ficará bem se já escreveu um `Console.WriteLine` antes) + +Nenhuma ferramenta extra, nenhum serviço externo—apenas a biblioteca e uma URL que você deseja arquivar. + + + +## Etapa 1: Carregar HTML a partir da URL + +A primeira coisa em qualquer fluxo de web‑scraping é buscar o código-fonte da página. Aspose.HTML torna isso uma única linha, mas lembre‑se de que estamos **loading html from url** com a pilha de rede incorporada. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +// 1️⃣ Load the page you want to archive +HtmlDocument htmlDoc = new HtmlDocument(); +htmlDoc.Open("https://example.com"); // replace with any public URL +``` + +> **Por que isso importa:** `HtmlDocument.Open` analisa a marcação *e* resolve URLs relativas internamente, mas não persiste automaticamente os recursos externos. Por isso precisamos de um handler mais tarde. + +## Etapa 2: Criar um Custom Resource Handler + +Agora vem o cerne da questão—**how to use handler** para interceptar cada solicitação de recurso externo (imagens, CSS, fontes, etc.). Ao subclassificar `ResourceHandler` você obtém controle total sobre o stream que sustenta cada ativo. + +```csharp +// 2️⃣ Define your own handler (optional but powerful) +public class MyResourceHandler : ResourceHandler +{ + // Called for each external resource the document needs + public override Stream HandleResource(ResourceInfo info) + { + // Here you could download the file, cache it, or rewrite it. + // For this demo we simply return an empty stream – Aspose will + // still create the entry in the ZIP, keeping the folder structure. + return new MemoryStream(); + } +} +``` + +> **Dica profissional:** Em um cenário de produção você pode querer baixar os bytes reais (`HttpClient.GetStreamAsync(info.Uri)`) e retornar esse stream. Isso garante que o ZIP salvo contenha as imagens reais em vez de marcadores vazios. + +## Etapa 3: Configurar as Opções de Salvamento e Anexar o Handler + +Com o handler pronto, informamos ao Aspose.HTML como empacotar tudo. A classe `HtmlSaveOptions` permite ativar a opção `SaveToZipArchive` e conectar seu `MyResourceHandler`. + +```csharp +// 3️⃣ Set up saving options – this is where we **save webpage as zip** +HtmlSaveOptions saveOptions = new HtmlSaveOptions +{ + // Attach our custom handler – new API as of v22.10 + OutputStorage = new MyResourceHandler(), + + // Instruct Aspose to bundle HTML + resources into a single ZIP file + SaveToZipArchive = true +}; +``` + +> **Explicação:** `OutputStorage` é a propriedade que recebe a instância do handler. Quando o salvador percorre o DOM ele chama `HandleResource` para cada link externo. Como `SaveToZipArchive` está true, o salvador grava cada stream retornado em uma entrada ZIP que corresponde ao caminho original. + +## Etapa 4: Salvar o Documento em um Memory Stream + +Poderíamos gravar diretamente no disco, mas manter tudo na memória torna o código utilizável em ASP.NET, Azure Functions ou qualquer lugar onde você não queira um arquivo temporário. Aqui está a etapa final que **creates zip from html**. + +```csharp +// 4️⃣ Save everything – HTML + resources – into a MemoryStream +using (MemoryStream outputStream = new MemoryStream()) +{ + htmlDoc.Save(outputStream, saveOptions); + + // At this point outputStream holds a valid ZIP archive. + // For demo purposes we write it to the file system: + File.WriteAllBytes("example_page.zip", outputStream.ToArray()); +} +``` + +### Resultado Esperado + +- `example_page.zip` aparece na pasta do seu projeto. +- Dentro do ZIP você encontrará `index.html` mais uma estrutura de pastas (`images/`, `css/`, etc.). +- Mesmo que nosso handler de demonstração tenha retornado streams vazios, o layout do ZIP espelha a página original—perfeito para substituir por um downloader real mais tarde. + +## Variações Comuns e Casos Limítrofes + +### Carregando um Arquivo Local em vez de uma URL +Se você precisar de caminhos semelhantes a **load html from url** no disco, basta substituir `htmlDoc.Open("https://example.com")` por `htmlDoc.Open(@"C:\path\to\file.html")`. O resto do pipeline permanece idêntico. + +### Persistindo Recursos Reais +Para realmente incorporar imagens, modifique `HandleResource`: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Download the resource using HttpClient + HttpClient client = new HttpClient(); + var data = client.GetByteArrayAsync(info.Uri).Result; + return new MemoryStream(data); +} +``` + +> **Atenção:** Chamadas de rede dentro do handler bloqueiam a thread de salvamento; para páginas grandes considere tornar o handler assíncrono (disponível em versões mais recentes do Aspose). + +### Alterando os Nomes das Entradas ZIP +`ResourceInfo` contém `FileName` e `Path`. Você pode reescrevê-los para achatar a hierarquia ou adicionar um prefixo: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Example: prepend "assets/" to every entry + info.Path = Path.Combine("assets", info.Path); + return base.HandleResource(info); +} +``` + +### Usando um Armazenamento de Saída Diferente +`OutputStorage` também pode ser um `FileSystemStorage` se você preferir uma pasta em vez de um ZIP. Basta definir `SaveToZipArchive = false` e apontar `OutputStorage` para um caminho de diretório. + +## Dicas Profissionais e Armadilhas + +- **Não se esqueça de descartar** o `HtmlDocument` se você abrir muitas páginas em um loop; caso contrário, pode vazar recursos nativos. +- **Uso de memória:** Salvar páginas enormes em um `MemoryStream` pode inflar a RAM. Para arquivos de vários megabytes, faça streaming direto para um arquivo (`FileStream`) em vez disso. +- **Codificação de caracteres:** Aspose.HTML respeita a tag ``. Se a página fonte usar uma codificação incomum, verifique se o HTML resultante renderiza corretamente após a extração. +- **Teste:** Abra o ZIP gerado em um navegador (arraste `index.html` para fora) para garantir que todos os recursos sejam resolvidos. Se imagens estiverem faltando, seu `HandleResource` provavelmente retornou um stream vazio. + +## Recapitulação + +Cobrimos **how to use handler** para interceptar recursos externos, demonstramos **load html from url**, criamos um **custom resource handler**, e finalmente **save webpage as zip**—efetivamente **create zip from html** com algumas linhas de C#. O padrão escala: troque o `MemoryStream` vazio por um downloader real, altere o destino de saída ou incorpore a lógica em uma API web que retorna o ZIP sob demanda. + +--- + +### O que vem a seguir? + +- **Processamento em lote:** Percorra uma lista de URLs e gere um ZIP por página. +- **Ajustes de compressão:** Use `ZipSaveOptions` para ajustar o nível de compressão para downloads mais rápidos. +- **Integração com ASP.NET Core:** Retorne o `MemoryStream` como um `FileResult` para que os usuários possam baixar o arquivo diretamente de um endpoint web. +- **Explore outros recursos do Aspose.HTML:** conversão para PDF, manipulação de DOM ou renderização headless. + +Tem perguntas sobre um caso de uso específico—talvez você precise preservar JavaScript ou lidar com páginas protegidas por autenticação? Deixe um comentário abaixo; ficarei feliz em aprofundar. Feliz codificação! + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/portuguese/net/rendering-html-documents/_index.md b/html/portuguese/net/rendering-html-documents/_index.md index 25f787dca4..bc302d3b94 100644 --- a/html/portuguese/net/rendering-html-documents/_index.md +++ b/html/portuguese/net/rendering-html-documents/_index.md @@ -60,6 +60,8 @@ Aprenda a converter HTML em PNG usando Aspose.HTML para .NET com este guia passo Aprenda a converter HTML em PNG usando C# com Aspose.HTML neste guia passo a passo detalhado. ### [Como usar Aspose para renderizar HTML em PNG em C#](./how-to-use-aspose-to-render-html-to-png-in-c/) Aprenda a usar Aspose.HTML para converter documentos HTML em imagens PNG usando C# de forma simples e eficaz. +### [Como renderizar HTML como PNG em C# – Guia passo a passo](./how-to-render-html-as-png-in-c-step-by-step-guide/) +Aprenda a converter HTML em PNG usando Aspose.HTML para .NET com um guia detalhado passo a passo em C#. ### [Renderizar EPUB como XPS em .NET com Aspose.HTML](./render-epub-as-xps/) Aprenda como criar e renderizar documentos HTML com Aspose.HTML para .NET neste tutorial abrangente. Mergulhe no mundo da manipulação de HTML, web scraping e muito mais. diff --git a/html/portuguese/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md b/html/portuguese/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..1ae64ccdba --- /dev/null +++ b/html/portuguese/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md @@ -0,0 +1,222 @@ +--- +category: general +date: 2026-02-25 +description: Como renderizar HTML como PNG em C# usando Aspose.HTML. Aprenda a converter + HTML em imagem, salvar HTML como PNG e criar PNG a partir de HTML rapidamente. +draft: false +keywords: +- how to render html +- convert html to image +- save html as png +- create png from html +- generate png from html +language: pt +og_description: Como renderizar HTML como PNG em C# com Aspose.HTML. Siga este tutorial + para converter HTML em imagem, salvar HTML como PNG e gerar PNG a partir de HTML. +og_title: Como renderizar HTML como PNG em C# – Guia Completo +tags: +- C# +- Aspose.HTML +- Image Rendering +title: Como renderizar HTML como PNG em C# – Guia passo a passo +url: /pt/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Como renderizar HTML como PNG em C# – Guia passo a passo + +Já se perguntou **como renderizar HTML** diretamente para um arquivo PNG sem precisar abrir um navegador? Talvez você precise incorporar uma pequena captura de uma página da web em um e‑mail, ou esteja construindo um serviço de miniaturas para um CMS. De qualquer forma, o problema se resume a transformar marcação em um bitmap que você pode armazenar ou servir. + +Neste tutorial você verá uma solução completa, pronta‑para‑executar que **converte HTML em imagem** usando Aspose.HTML para .NET. Também abordaremos como **salvar HTML como PNG**, **criar PNG a partir de HTML**, e até **gerar PNG a partir de HTML** com fontes e dimensões personalizadas. Sem referências vagas – apenas o código que você pode copiar‑colar, mais explicações sobre por que cada linha é importante. + +## O que você vai precisar + +- .NET 6 (ou qualquer runtime .NET recente) – a API funciona da mesma forma no .NET Framework 4.6+. +- Visual Studio 2022 ou VS Code – o que preferir. +- O pacote NuGet **Aspose.HTML** (`Aspose.HTML.NET`) – instale‑o uma vez e pronto. +- Uma pasta gravável para o PNG de saída (por exemplo, `C:\Temp\Images`). + +É só isso. Sem binários extras, sem serviços web externos e sem arquivos de configuração ocultos. + +## Etapa 1: Instalar Aspose.HTML via NuGet + +Primeiro, adicione a biblioteca ao seu projeto. Abra o terminal na pasta da solução e execute: + +```bash +dotnet add package Aspose.HTML.NET +``` + +*Dica profissional:* Se estiver no Visual Studio, clique com o botão direito em **Dependencies → Manage NuGet Packages**, procure por “Aspose.HTML” e clique em **Install**. Isso lhe dá acesso às classes `HtmlDocument`, `ImageRenderingOptions` e outras que usaremos. + +## Etapa 2: Configurar as Opções de Renderização (tamanho, estilo e fontes) + +Antes de alimentar qualquer marcação ao renderizador, decidimos quão grande a imagem deve ser e quais estilos de fonte queremos preservar. O objeto `ImageRenderingOptions` permite ajustar largura, altura e até forçar a renderização em negrito/itálico. + +```csharp +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +// Configure image rendering options – width, height, and font style +ImageRenderingOptions renderingOptions = new ImageRenderingOptions +{ + Width = 800, // Desired image width in pixels + Height = 600, // Desired image height in pixels + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic // Preserve bold & italic +}; +``` + +**Por que isso importa:** +- **Width/Height** determinam as dimensões finais em pixels; se você omiti‑los, o motor adivinha com base no layout HTML, o que pode causar cortes inesperados. +- **FontStyle** garante que quaisquer tags `` ou `` mantenham seu destaque visual ao serem rasterizadas. + +## Etapa 3: Carregar sua Marca HTML + +Você pode carregar HTML a partir de uma string, de um arquivo ou de uma URL. Para simplificar, vamos incorporar um pequeno trecho diretamente no código. Observe o CSS inline que define a família de fontes – Aspose.HTML respeita o CSS web padrão, então você obtém uma renderização fiel. + +```csharp +using Aspose.Html; + +// Create an empty HTML document +HtmlDocument htmlDoc = new HtmlDocument(); + +// Load simple markup – you could also use htmlDoc.Open("path/to/file.html") +htmlDoc.Open("Hello, world!
"); +``` + +**Dica para casos extremos:** Se sua marcação referenciar recursos externos (imagens, arquivos CSS), certifique‑se de que essas URLs estejam acessíveis a partir da máquina que executa o código, ou incorpore‑os como data‑URIs para evitar links quebrados. + +## Etapa 4: Renderizar o HTML para um Stream PNG + +Agora vem o núcleo de **como renderizar HTML** – chamamos `RenderToStream`, passando o stream de saída e as opções configuradas anteriormente. O método faz todo o trabalho pesado: layout, cascata CSS, substituição de fontes e rasterização. + +```csharp +using System.IO; + +// Choose an output path – replace with your own directory +string outputPath = @"C:\Temp\Images\output.png"; + +using (FileStream outputStream = File.OpenWrite(outputPath)) +{ + // Render the HTML document into the PNG file + htmlDoc.RenderToStream(outputStream, renderingOptions); +} +``` + +Depois que o bloco `using` termina, `output.png` conterá uma imagem de 800 × 600 pixels do parágrafo que carregamos. Abra‑a com qualquer visualizador de imagens para verificar o resultado. + +### Resultado esperado + +Você deverá ver uma tela branca limpa com o texto **“Hello, world!”** renderizado em Arial, negrito e itálico, exatamente 24 pt de tamanho. As dimensões da imagem correspondem aos valores 800 × 600 que definimos. + +## Etapa 5: Verificar e Tratar Armadilhas Comuns + +### 5.1 Verificando se o Arquivo Existe + +Uma verificação rápida evita falhas silenciosas: + +```csharp +if (File.Exists(outputPath)) +{ + Console.WriteLine($"✅ PNG created successfully at {outputPath}"); +} +else +{ + Console.WriteLine("❌ Something went wrong – PNG not found."); +} +``` + +### 5.2 Lidando com Fontes Ausentes + +Se a máquina de destino não possuir a fonte solicitada, Aspose.HTML recorre a uma fonte genérica sans‑serif. Para garantir consistência, você pode: + +- Incorporar o arquivo de fonte usando uma regra `@font-face` no seu HTML, **ou** +- Registrar a fonte programaticamente antes da renderização. + +```csharp +// Example of registering a custom TrueType font +htmlDoc.Fonts.AddFontFile(@"C:\Fonts\OpenSans-Regular.ttf"); +``` + +### 5.3 Renderizando Páginas Grandes + +Ao criar miniaturas de capturas de tela de páginas completas, fique de olho no uso de memória. Você pode reduzir a escala após a renderização, ou definir `renderingOptions.Width`/`Height` para um tamanho menor e deixar o Aspose.HTML cuidar do redimensionamento. + +## Exemplo Completo Funcionando + +Abaixo está o programa completo que você pode colar em uma aplicação console e executar imediatamente. + +```csharp +// ----------------------------------------------------------- +// How to render HTML as PNG – Complete, runnable example +// ----------------------------------------------------------- +using System; +using System.IO; +using Aspose.Html; +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +class Program +{ + static void Main() + { + // 1️⃣ Configure rendering options + ImageRenderingOptions renderingOptions = new ImageRenderingOptions + { + Width = 800, + Height = 600, + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic + }; + + // 2️⃣ Load HTML markup + HtmlDocument htmlDoc = new HtmlDocument(); + htmlDoc.Open("Hello, world!
"); + + // 3️⃣ Define output path + string outputPath = @"C:\Temp\Images\output.png"; + + // 4️⃣ Render to PNG + using (FileStream outputStream = File.OpenWrite(outputPath)) + { + htmlDoc.RenderToStream(outputStream, renderingOptions); + } + + // 5️⃣ Verify the result + Console.WriteLine(File.Exists(outputPath) + ? $"✅ PNG saved at {outputPath}" + : "❌ Failed to create PNG"); + } +} +``` + +Execute o programa (`dotnet run`), então abra `C:\Temp\Images\output.png`. Se tudo correu bem, você acabou de **converter HTML em imagem** e **salvar HTML como PNG** usando código puro em C#. + +## Perguntas Frequentes + +| Pergunta | Resposta | +|----------|----------| +| **Posso renderizar uma página completa com CSS/JS externos?** | Sim – basta chamar `htmlDoc.Open("https://example.com")`. O motor baixará os recursos vinculados, mas você precisará de acesso à rede. | +| **Quais formatos são suportados além de PNG?** | `ImageRenderingOptions` funciona com JPEG, BMP, GIF e TIFF. Altere a extensão do arquivo e defina `ImageFormat` se necessário. | +| **Existe um limite para o tamanho da imagem?** | Tecnicamente você pode chegar a vários milhares de pixels, mas dimensões muito grandes podem esgotar a memória. Considere renderizar em blocos (tiles) para saídas ultra‑alta resolução. | +| **Como tratar DPI para imagens de qualidade de impressão?** | Defina `renderingOptions.DpiX` e `renderingOptions.DpiY` (o padrão é 96). DPI mais alto gera saída mais nítida para impressão. | +| **Preciso de licença para o Aspose.HTML?** | Uma avaliação gratuita funciona com marca d'água. Para produção, adquira uma licença para removê‑la e desbloquear todos os recursos. | + +## Próximos Passos e Tópicos Relacionados + +- **Converter HTML para JPEG** – troque a extensão do arquivo e, opcionalmente, defina `renderingOptions.ImageFormat = ImageFormat.Jpeg`. +- **Processamento em lote** – itere sobre uma lista de URLs e gere miniaturas para cada uma. +- **Incorporação de fontes** – aprenda a usar `@font-face` dentro da sua marcação para tipografia perfeita. +- **Layout avançado** – experimente as opções `PageSize`, `Margin` e `BackgroundColor` para aparências personalizadas. + +Sinta‑se à vontade para ajustar as dimensões, testar diferentes trechos HTML ou integrar este fragmento a uma API web que sirva pré‑visualizações PNG sob demanda. O céu é o limite quando você sabe **como renderizar HTML** programaticamente. + +--- + + + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/russian/net/html-extensions-and-conversions/_index.md b/html/russian/net/html-extensions-and-conversions/_index.md index ff702261dc..3bd0dfcf1a 100644 --- a/html/russian/net/html-extensions-and-conversions/_index.md +++ b/html/russian/net/html-extensions-and-conversions/_index.md @@ -113,6 +113,8 @@ Aspose.HTML для .NET — это не просто библиотека; эт Узнайте, как сохранить всю веб‑страницу в один HTML‑файл с помощью Aspose.HTML для .NET и C#. ### [Aspose HTML Параметры сохранения: Сохранить HTML в поток в C#](./aspose-html-save-options-save-html-to-stream-in-c/) Узнайте, как сохранить HTML в поток с помощью Aspose.HTML в C# с использованием параметров сохранения. +### [Как использовать обработчик в Aspose.HTML – загрузить HTML и сохранить в ZIP](./how-to-use-handler-in-aspose-html-load-html-save-as-zip/) +Узнайте, как загрузить HTML‑документ с помощью обработчика Aspose.HTML и сохранить его в архив ZIP в .NET. ## Заключение diff --git a/html/russian/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md b/html/russian/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md new file mode 100644 index 0000000000..23f6566b3f --- /dev/null +++ b/html/russian/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md @@ -0,0 +1,184 @@ +--- +category: general +date: 2026-02-25 +description: Как использовать обработчик для загрузки HTML из URL и сохранения веб‑страницы + в виде ZIP с помощью Aspose.HTML — полное пошаговое руководство на C#. +draft: false +keywords: +- how to use handler +- load html from url +- custom resource handler +- save webpage as zip +- create zip from html +language: ru +og_description: Как использовать обработчик для загрузки HTML с URL и сохранения веб‑страницы + в виде ZIP с помощью Aspose.HTML. Узнайте полный рабочий процесс C# за несколько + минут. +og_title: как использовать обработчик в Aspose.HTML – загрузить HTML, сохранить в + ZIP +tags: +- Aspose.HTML +- C# +- Web Scraping +title: Как использовать обработчик в Aspose.HTML – загрузить HTML, сохранить как ZIP +url: /ru/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# как использовать обработчик в Aspose.HTML – загрузить HTML, сохранить как ZIP + +Когда‑нибудь задумывались **как использовать обработчик** при загрузке веб‑страницы в ваше .NET‑приложение? Возможно, вы пробовали `HtmlDocument.Open` и получили HTML, но изображения, CSS и шрифты исчезли. Это распространённая проблема — ресурсы теряются, если не указать Aspose.HTML, что с ними делать. + +В этом руководстве мы пройдём процесс загрузки HTML по URL, подключим **пользовательский обработчик ресурсов**, а затем **сохраним веб‑страницу как zip**, чтобы получить один переносимый архив. К концу вы получите готовый фрагмент C#, который можно вставить в любой проект, а также несколько советов, экономящих время в дальнейшем. + +## Что понадобится + +- .NET 6+ (API работает на .NET Core и .NET Framework) +- Aspose.HTML for .NET (пакет NuGet `Aspose.HTML`) +- Небольшой опыт работы с C# (вам будет достаточно, если вы писали `Console.WriteLine` ранее) + +Никаких дополнительных инструментов, никаких внешних сервисов — только библиотека и URL, который вы хотите заархивировать. + + + +## Шаг 1: Загрузить HTML из URL + +Первый шаг в любом процессе веб‑скрейпинга — получить исходный код страницы. Aspose.HTML делает это в одну строку, но помните, что мы **загружаем html из url** с помощью встроенного сетевого стека. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +// 1️⃣ Load the page you want to archive +HtmlDocument htmlDoc = new HtmlDocument(); +htmlDoc.Open("https://example.com"); // replace with any public URL +``` + +> **Почему это важно:** `HtmlDocument.Open` разбирает разметку *и* внутренне разрешает относительные URL, но автоматически не сохраняет внешние ресурсы. Поэтому позже нам понадобится обработчик. + +## Шаг 2: Создать пользовательский обработчик ресурсов + +Теперь переходим к сути — **как использовать обработчик** для перехвата каждого внешнего запроса ресурса (изображения, CSS, шрифты и т.д.). Наследуясь от `ResourceHandler`, вы получаете полный контроль над потоком, который представляет каждый ресурс. + +```csharp +// 2️⃣ Define your own handler (optional but powerful) +public class MyResourceHandler : ResourceHandler +{ + // Called for each external resource the document needs + public override Stream HandleResource(ResourceInfo info) + { + // Here you could download the file, cache it, or rewrite it. + // For this demo we simply return an empty stream – Aspose will + // still create the entry in the ZIP, keeping the folder structure. + return new MemoryStream(); + } +} +``` + +> **Pro tip:** В продакшн‑сценарии вы, вероятно, захотите скачать реальные байты (`HttpClient.GetStreamAsync(info.Uri)`) и вернуть этот поток. Это гарантирует, что сохраняемый ZIP будет содержать настоящие изображения, а не пустые заглушки. + +## Шаг 3: Настроить параметры сохранения и подключить обработчик + +Когда обработчик готов, мы указываем Aspose.HTML, как упаковать всё вместе. Класс `HtmlSaveOptions` позволяет включить переключатель `SaveToZipArchive` и передать ваш `MyResourceHandler`. + +```csharp +// 3️⃣ Set up saving options – this is where we **save webpage as zip** +HtmlSaveOptions saveOptions = new HtmlSaveOptions +{ + // Attach our custom handler – new API as of v22.10 + OutputStorage = new MyResourceHandler(), + + // Instruct Aspose to bundle HTML + resources into a single ZIP file + SaveToZipArchive = true +}; +``` + +> **Объяснение:** `OutputStorage` — это свойство, получающее экземпляр обработчика. Когда сохранитель проходит по DOM, он вызывает `HandleResource` для каждой внешней ссылки. Поскольку `SaveToZipArchive` установлен в `true`, сохранитель записывает каждый возвращённый поток в запись ZIP с оригинальным путём. + +## Шаг 4: Сохранить документ в поток памяти + +Можно было бы сразу записать на диск, но хранение всего в памяти делает код пригодным для ASP.NET, Azure Functions или любого места, где не нужен временный файл. Ниже финальный шаг, который **создаёт zip из html**. + +```csharp +// 4️⃣ Save everything – HTML + resources – into a MemoryStream +using (MemoryStream outputStream = new MemoryStream()) +{ + htmlDoc.Save(outputStream, saveOptions); + + // At this point outputStream holds a valid ZIP archive. + // For demo purposes we write it to the file system: + File.WriteAllBytes("example_page.zip", outputStream.ToArray()); +} +``` + +### Ожидаемый результат + +- В папке проекта появляется `example_page.zip`. +- Внутри ZIP‑файла вы найдёте `index.html` и структуру папок (`images/`, `css/` и т.д.). +- Несмотря на то, что наш демонстрационный обработчик возвращал пустые потоки, структура ZIP отражает оригинальную страницу — идеально для замены реальным загрузчиком позже. + +## Общие варианты и особые случаи + +### Загрузка локального файла вместо URL +Если нужно **загрузить html из url**‑подобных путей на диске, просто замените `htmlDoc.Open("https://example.com")` на `htmlDoc.Open(@"C:\path\to\file.html")`. Остальная часть конвейера остаётся без изменений. + +### Сохранение реальных ресурсов +Чтобы действительно внедрить изображения, измените `HandleResource`: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Download the resource using HttpClient + HttpClient client = new HttpClient(); + var data = client.GetByteArrayAsync(info.Uri).Result; + return new MemoryStream(data); +} +``` + +> **Caution:** Сетевые вызовы внутри обработчика блокируют поток сохранения; для больших страниц рассмотрите асинхронный обработчик (доступен в новых версиях Aspose). + +### Изменение имён записей ZIP +`ResourceInfo` содержит `FileName` и `Path`. Вы можете переименовать их, чтобы упростить иерархию или добавить префикс: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Example: prepend "assets/" to every entry + info.Path = Path.Combine("assets", info.Path); + return base.HandleResource(info); +} +``` + +### Использование другого хранилища вывода +`OutputStorage` может быть также `FileSystemStorage`, если вам нужен каталог вместо ZIP. Просто установите `SaveToZipArchive = false` и укажите `OutputStorage` путь к директории. + +## Профессиональные советы и подводные камни + +- **Не забывайте освобождать** `HtmlDocument`, если открываете много страниц в цикле; иначе могут утекать нативные ресурсы. +- **Использование памяти:** Сохранение огромных страниц в `MemoryStream` может сильно увеличить RAM. Для архивов в несколько мегабайт лучше писать напрямую в файл (`FileStream`). +- **Кодировка символов:** Aspose.HTML учитывает тег ``. Если исходная страница использует редкую кодировку, проверьте корректность отображения полученного HTML после извлечения. +- **Тестирование:** Откройте сгенерированный ZIP в браузере (перетащите `index.html`) и убедитесь, что все ресурсы находятся. Если изображения отсутствуют, ваш `HandleResource`, скорее всего, возвращает пустой поток. + +## Итоги + +Мы рассмотрели **как использовать обработчик** для перехвата внешних ресурсов, продемонстрировали **загрузить html из url**, создали **пользовательский обработчик ресурсов** и, наконец, **сохранили веб‑страницу как zip** — фактически **создали zip из html** несколькими строками C#. Этот подход масштабируется: замените пустой `MemoryStream` на реальный загрузчик, измените цель вывода или внедрите логику в веб‑API, возвращающий ZIP по запросу. + +--- + +### Что дальше? + +- **Пакетная обработка:** Перебрать список URL и генерировать ZIP для каждой страницы. +- **Настройки сжатия:** Использовать `ZipSaveOptions` для изменения уровня компрессии и ускорения загрузки. +- **Интеграция с ASP.NET Core:** Возвратить `MemoryStream` как `FileResult`, чтобы пользователи могли скачать архив напрямую из веб‑конечного пункта. +- **Изучить другие возможности Aspose.HTML:** Конвертация в PDF, манипуляции DOM, рендеринг без окна браузера. + +Есть вопросы по конкретному случаю — возможно, нужно сохранить JavaScript или работать со страницами, защищёнными аутентификацией? Оставляйте комментарий ниже; с радостью помогу разобраться. Happy coding! + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/russian/net/rendering-html-documents/_index.md b/html/russian/net/rendering-html-documents/_index.md index 7d25baeb4d..14e01cd309 100644 --- a/html/russian/net/rendering-html-documents/_index.md +++ b/html/russian/net/rendering-html-documents/_index.md @@ -48,7 +48,8 @@ Aspose.HTML для .NET выделяется как лучший выбор дл Подробное руководство по рендерингу HTML в PNG с использованием Aspose.HTML для .NET, включающее все необходимые шаги и примеры. ### [Как отрендерить HTML в PNG – Полное руководство C#](./how-to-render-html-as-png-complete-c-guide/) Полное руководство по рендерингу HTML в PNG с использованием Aspose.HTML и C#. - +### [Как отрендерить HTML в PNG на C# – пошаговое руководство](./how-to-render-html-as-png-in-c-step-by-step-guide/) +Подробный пошаговый учебник по рендерингу HTML в PNG с использованием Aspose.HTML в C#. ### [Создание PNG из HTML – Полное руководство по рендерингу на C#](./create-png-from-html-full-c-rendering-guide/) Подробный учебник по созданию PNG из HTML с использованием Aspose.HTML для .NET на C#. ### [Как отрендерить HTML в PNG – Полное руководство C#](./how-to-render-html-to-png-complete-c-guide/) diff --git a/html/russian/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md b/html/russian/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..47c7bcf1cd --- /dev/null +++ b/html/russian/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md @@ -0,0 +1,223 @@ +--- +category: general +date: 2026-02-25 +description: Как отобразить HTML в PNG в C# с помощью Aspose.HTML. Узнайте, как преобразовать + HTML в изображение, сохранить HTML как PNG и быстро создать PNG из HTML. +draft: false +keywords: +- how to render html +- convert html to image +- save html as png +- create png from html +- generate png from html +language: ru +og_description: Как отобразить HTML в PNG в C# с помощью Aspose.HTML. Следуйте этому + руководству, чтобы преобразовать HTML в изображение, сохранить HTML как PNG и создать + PNG из HTML. +og_title: Как отобразить HTML в PNG на C# – Полное руководство +tags: +- C# +- Aspose.HTML +- Image Rendering +title: Как преобразовать HTML в PNG в C# – пошаговое руководство +url: /ru/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Как преобразовать HTML в PNG на C# – пошаговое руководство + +Когда‑нибудь задавались вопросом **как отобразить HTML** напрямую в файл PNG без использования браузера? Возможно, вам нужно встроить небольшую копию веб‑страницы в письмо, или вы создаёте сервис миниатюр для CMS. В любом случае, задача сводится к преобразованию разметки в растровое изображение, которое можно сохранить или отдать. + +В этом руководстве вы увидите полное, готовое к запуску решение, которое **преобразует HTML в изображение** с помощью Aspose.HTML для .NET. Мы также коснёмся того, как **сохранить HTML как PNG**, **создать PNG из HTML**, и даже **сгенерировать PNG из HTML** с пользовательскими шрифтами и размерами. Никаких расплывчатых ссылок — только код, который можно скопировать‑вставить, плюс объяснения, почему каждая строка важна. + +## Что понадобится + +- .NET 6 (или любой современный .NET runtime) — API работает одинаково на .NET Framework 4.6+. +- Visual Studio 2022 или VS Code — что вам больше нравится. +- Пакет NuGet **Aspose.HTML** (`Aspose.HTML.NET`) — установите один раз и всё готово. +- Папка с правом записи для выходного PNG (например, `C:\Temp\Images`). + +Это всё. Никаких дополнительных бинарных файлов, внешних веб‑сервисов и скрытых конфигураций. + +## Шаг 1: Установить Aspose.HTML через NuGet + +Сначала добавьте библиотеку в проект. Откройте терминал в папке решения и выполните: + +```bash +dotnet add package Aspose.HTML.NET +``` + +*Pro tip:* Если вы работаете в Visual Studio, щёлкните правой кнопкой **Dependencies → Manage NuGet Packages**, найдите “Aspose.HTML” и нажмите **Install**. Это даст вам доступ к классам `HtmlDocument`, `ImageRenderingOptions` и другим, которые мы будем использовать. + +## Шаг 2: Настроить параметры рендеринга (размер, стиль и шрифты) + +Прежде чем передать разметку рендереру, решаем, какого размера должно быть изображение и какие стили шрифтов нужно сохранить. Объект `ImageRenderingOptions` позволяет настроить ширину, высоту и даже принудительно включить рендеринг жирного/курсивного текста. + +```csharp +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +// Configure image rendering options – width, height, and font style +ImageRenderingOptions renderingOptions = new ImageRenderingOptions +{ + Width = 800, // Desired image width in pixels + Height = 600, // Desired image height in pixels + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic // Preserve bold & italic +}; +``` + +**Почему это важно:** +- **Width/Height** определяют окончательные пиксельные размеры; если их не задать, движок попытается угадать их на основе HTML‑разметки, что может привести к неожиданному обрезанию. +- **FontStyle** гарантирует, что теги `` или `` сохранят визуальное выделение при растеризации. + +## Шаг 3: Загрузить вашу HTML‑разметку + +HTML можно загрузить из строки, файла или URL. Для простоты мы встроим небольшой фрагмент прямо в код. Обратите внимание на встроенный CSS, задающий семейство шрифтов — Aspose.HTML соблюдает стандартный веб‑CSS, поэтому вы получаете точную визуализацию. + +```csharp +using Aspose.Html; + +// Create an empty HTML document +HtmlDocument htmlDoc = new HtmlDocument(); + +// Load simple markup – you could also use htmlDoc.Open("path/to/file.html") +htmlDoc.Open("Hello, world!
"); +``` + +**Подсказка для граничных случаев:** Если ваша разметка ссылается на внешние ресурсы (изображения, CSS‑файлы), убедитесь, что эти URL доступны с машины, где выполняется код, или внедрите их как data‑URI, чтобы избежать битых ссылок. + +## Шаг 4: Рендерить HTML в PNG‑поток + +Теперь переходим к основной части **как отобразить HTML** — вызываем `RenderToStream`, передавая выходной поток и ранее настроенные параметры. Метод выполняет всю тяжёлую работу: разметку, каскад CSS, подстановку шрифтов и растеризацию. + +```csharp +using System.IO; + +// Choose an output path – replace with your own directory +string outputPath = @"C:\Temp\Images\output.png"; + +using (FileStream outputStream = File.OpenWrite(outputPath)) +{ + // Render the HTML document into the PNG file + htmlDoc.RenderToStream(outputStream, renderingOptions); +} +``` + +После завершения блока `using` файл `output.png` будет содержать изображение 800 × 600 пикселей с загруженным абзацем. Откройте его в любом просмотрщике изображений, чтобы проверить результат. + +### Ожидаемый результат + +Вы должны увидеть чистый белый холст с текстом **«Hello, world!»**, отрисованным шрифтом Arial, жирным и курсивом, размером ровно 24 pt. Размеры изображения соответствуют заданным 800 × 600. + +## Шаг 5: Проверка и обработка распространённых проблем + +### 5.1 Проверка существования файла + +Быстрая проверка помогает избежать тихих сбоев: + +```csharp +if (File.Exists(outputPath)) +{ + Console.WriteLine($"✅ PNG created successfully at {outputPath}"); +} +else +{ + Console.WriteLine("❌ Something went wrong – PNG not found."); +} +``` + +### 5.2 Работа с отсутствующими шрифтами + +Если на целевой машине нет запрошенного шрифта, Aspose.HTML переключится на общий sans‑serif. Чтобы обеспечить согласованность, сделайте одно из следующего: + +- Внедрите файл шрифта с помощью правила `@font-face` в вашем HTML, **или** +- Зарегистрируйте шрифт программно перед рендерингом. + +```csharp +// Example of registering a custom TrueType font +htmlDoc.Fonts.AddFontFile(@"C:\Fonts\OpenSans-Regular.ttf"); +``` + +### 5.3 Рендеринг больших страниц + +При создании миниатюр полноразмерных скриншотов следите за потреблением памяти. Вы можете уменьшить масштаб после рендеринга или задать `renderingOptions.Width`/`Height` меньшего размера и позволить Aspose.HTML выполнить масштабирование. + +## Полный рабочий пример + +Ниже полностью готовая программа, которую можно вставить в консольное приложение и сразу запустить. + +```csharp +// ----------------------------------------------------------- +// How to render HTML as PNG – Complete, runnable example +// ----------------------------------------------------------- +using System; +using System.IO; +using Aspose.Html; +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +class Program +{ + static void Main() + { + // 1️⃣ Configure rendering options + ImageRenderingOptions renderingOptions = new ImageRenderingOptions + { + Width = 800, + Height = 600, + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic + }; + + // 2️⃣ Load HTML markup + HtmlDocument htmlDoc = new HtmlDocument(); + htmlDoc.Open("Hello, world!
"); + + // 3️⃣ Define output path + string outputPath = @"C:\Temp\Images\output.png"; + + // 4️⃣ Render to PNG + using (FileStream outputStream = File.OpenWrite(outputPath)) + { + htmlDoc.RenderToStream(outputStream, renderingOptions); + } + + // 5️⃣ Verify the result + Console.WriteLine(File.Exists(outputPath) + ? $"✅ PNG saved at {outputPath}" + : "❌ Failed to create PNG"); + } +} +``` + +Запустите программу (`dotnet run`), затем откройте `C:\Temp\Images\output.png`. Если всё прошло гладко, вы только что **преобразовали HTML в изображение** и **сохранили HTML как PNG** с помощью чистого кода C#. + +## Часто задаваемые вопросы + +| Question | Answer | +|----------|--------| +| **Can I render a full webpage with external CSS/JS?** | Yes – just call `htmlDoc.Open("https://example.com")`. The engine will download linked resources, but you need network access. | +| **What formats are supported besides PNG?** | `ImageRenderingOptions` works with JPEG, BMP, GIF, and TIFF. Change the file extension and set `ImageFormat` if needed. | +| **Is there a limit on image size?** | Technically you can go up to several thousand pixels, but very large dimensions may exhaust memory. Consider rendering in tiles for ultra‑high‑res output. | +| **How do I handle DPI for print‑quality images?** | Set `renderingOptions.DpiX` and `renderingOptions.DpiY` (default is 96). Higher DPI yields sharper output for printing. | +| **Do I need a license for Aspose.HTML?** | A free evaluation works with a watermark. For production, purchase a license to remove it and unlock full features. | + +## Следующие шаги и связанные темы + +- **Convert HTML to JPEG** – swap the file extension and optionally set `renderingOptions.ImageFormat = ImageFormat.Jpeg`. +- **Batch processing** – loop over a list of URLs and generate thumbnails for each. +- **Embedding fonts** – learn how to use `@font-face` inside your markup for perfect typography. +- **Advanced layout** – experiment with `PageSize`, `Margin`, and `BackgroundColor` options for custom looks. + +Не стесняйтесь менять размеры, пробовать разные HTML‑фрагменты или интегрировать этот код в веб‑API, которое будет отдавать PNG‑превью «на лету». Возможности безграничны, когда вы знаете **как отобразить HTML** программно. + +--- + + + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/spanish/net/html-extensions-and-conversions/_index.md b/html/spanish/net/html-extensions-and-conversions/_index.md index 23b1ac5469..ce7351dc7f 100644 --- a/html/spanish/net/html-extensions-and-conversions/_index.md +++ b/html/spanish/net/html-extensions-and-conversions/_index.md @@ -112,6 +112,8 @@ Aprenda a guardar documentos HTML en un archivo ZIP usando C# con Aspose.HTML, s Aprenda a guardar archivos HTML en un archivo ZIP usando C# y Aspose.HTML con una guía paso a paso completa. ### [Archivo HTML único – Guardar una página web como un solo archivo HTML en C#](./single-file-html-save-a-web-page-as-one-html-file-in-c/) Aprenda a guardar una página web completa en un solo archivo HTML usando Aspose.HTML y C# paso a paso. +### [Cómo usar el controlador en Aspose.HTML – Cargar HTML, Guardar como ZIP](./how-to-use-handler-in-aspose-html-load-html-save-as-zip/) +Aprenda a cargar HTML y guardarlo como archivo ZIP usando un handler en Aspose.HTML para .NET. ## Conclusión diff --git a/html/spanish/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md b/html/spanish/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md new file mode 100644 index 0000000000..f349a1e44c --- /dev/null +++ b/html/spanish/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md @@ -0,0 +1,181 @@ +--- +category: general +date: 2026-02-25 +description: cómo usar un controlador para cargar HTML desde una URL y guardar la + página web como zip con Aspose.HTML – una guía completa paso a paso en C# +draft: false +keywords: +- how to use handler +- load html from url +- custom resource handler +- save webpage as zip +- create zip from html +language: es +og_description: cómo usar el controlador para cargar HTML desde una URL y guardar + la página web como zip con Aspose.HTML. Aprende el flujo de trabajo completo en + C# en minutos. +og_title: Cómo usar el controlador en Aspose.HTML – Cargar HTML, Guardar como ZIP +tags: +- Aspose.HTML +- C# +- Web Scraping +title: cómo usar el manejador en Aspose.HTML – Cargar HTML, Guardar como ZIP +url: /es/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# cómo usar handler en Aspose.HTML – Cargar HTML, Guardar como ZIP + +¿Alguna vez te has preguntado **cómo usar handler** al extraer una página web en tu aplicación .NET? Tal vez hayas probado `HtmlDocument.Open` y obtenido el HTML, pero las imágenes, CSS y fuentes desaparecieron. Ese es un problema común: los recursos se pierden a menos que le indiques a Aspose.HTML qué hacer con ellos. + +En este tutorial recorreremos la carga de HTML desde una URL, la configuración de un **custom resource handler**, y finalmente **save webpage as zip** para que termines con un único archivo portátil. Al final tendrás un fragmento de C# listo para ejecutar que puedes insertar en cualquier proyecto, además de varios consejos que te ahorrarán dolores de cabeza más adelante. + +## Lo que necesitarás + +- .NET 6+ (la API funciona también en .NET Core y .NET Framework) +- Aspose.HTML for .NET (paquete NuGet `Aspose.HTML`) +- Un nivel básico de experiencia en C# (te irá bien si has escrito un `Console.WriteLine` antes) + +Sin herramientas extra, sin servicios externos—solo la biblioteca y una URL que deseas archivar. + + + +## Paso 1: Cargar HTML desde URL + +Lo primero en cualquier flujo de web‑scraping es obtener el código fuente de la página. Aspose.HTML lo hace en una sola línea, pero recuerda que estamos **loading html from url** con la pila de red incorporada. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +// 1️⃣ Load the page you want to archive +HtmlDocument htmlDoc = new HtmlDocument(); +htmlDoc.Open("https://example.com"); // replace with any public URL +``` + +> **Por qué es importante:** `HtmlDocument.Open` analiza el marcado *y* resuelve internamente las URLs relativas, pero no persiste automáticamente los recursos externos. Por eso necesitamos un handler más adelante. + +## Paso 2: Crear un Custom Resource Handler + +Ahora llega el corazón del asunto—**how to use handler** para interceptar cada solicitud de recurso externo (imágenes, CSS, fuentes, etc.). Al subclasificar `ResourceHandler` obtienes control total sobre el flujo que respalda cada activo. + +```csharp +// 2️⃣ Define your own handler (optional but powerful) +public class MyResourceHandler : ResourceHandler +{ + // Called for each external resource the document needs + public override Stream HandleResource(ResourceInfo info) + { + // Here you could download the file, cache it, or rewrite it. + // For this demo we simply return an empty stream – Aspose will + // still create the entry in the ZIP, keeping the folder structure. + return new MemoryStream(); + } +} +``` + +> **Consejo profesional:** En un escenario de producción podrías querer descargar los bytes reales (`HttpClient.GetStreamAsync(info.Uri)`) y devolver ese flujo. Esto asegura que el ZIP guardado contenga las imágenes reales en lugar de marcadores de posición vacíos. + +## Paso 3: Configurar opciones de guardado y adjuntar el handler + +Con el handler listo, indicamos a Aspose.HTML cómo empaquetar todo. La clase `HtmlSaveOptions` permite activar la opción `SaveToZipArchive` y conectar tu `MyResourceHandler`. + +```csharp +// 3️⃣ Set up saving options – this is where we **save webpage as zip** +HtmlSaveOptions saveOptions = new HtmlSaveOptions +{ + // Attach our custom handler – new API as of v22.10 + OutputStorage = new MyResourceHandler(), + + // Instruct Aspose to bundle HTML + resources into a single ZIP file + SaveToZipArchive = true +}; +``` + +> **Explicación:** `OutputStorage` es la propiedad que recibe la instancia del handler. Cuando el guardador recorre el DOM llama a `HandleResource` para cada enlace externo. Como `SaveToZipArchive` es true, el guardador escribe cada flujo devuelto en una entrada ZIP que coincide con la ruta original. + +## Paso 4: Guardar el documento en un MemoryStream + +Podríamos escribir directamente en disco, pero mantener todo en memoria hace que el código sea utilizable en ASP.NET, Azure Functions o cualquier lugar donde no quieras un archivo temporal. Aquí está el paso final que **creates zip from html**. + +```csharp +// 4️⃣ Save everything – HTML + resources – into a MemoryStream +using (MemoryStream outputStream = new MemoryStream()) +{ + htmlDoc.Save(outputStream, saveOptions); + + // At this point outputStream holds a valid ZIP archive. + // For demo purposes we write it to the file system: + File.WriteAllBytes("example_page.zip", outputStream.ToArray()); +} +``` + +### Resultado esperado + +- `example_page.zip` aparece en la carpeta de tu proyecto. +- Dentro del ZIP encontrarás `index.html` más una estructura de carpetas (`images/`, `css/`, etc.). +- Aunque nuestro handler de demostración devolvió flujos vacíos, la estructura del ZIP refleja la página original—perfecto para reemplazarlo con un descargador real más adelante. + +## Variaciones comunes y casos límite + +### Cargar un archivo local en lugar de una URL +Si necesitas **load html from url**‑like paths en disco, simplemente reemplaza `htmlDoc.Open("https://example.com")` con `htmlDoc.Open(@"C:\path\to\file.html")`. El resto del flujo permanece idéntico. + +### Persistir recursos reales +Para incrustar realmente imágenes, modifica `HandleResource`: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Download the resource using HttpClient + HttpClient client = new HttpClient(); + var data = client.GetByteArrayAsync(info.Uri).Result; + return new MemoryStream(data); +} +``` + +> **Precaución:** Las llamadas de red dentro del handler bloquean el hilo de guardado; para páginas grandes considera hacer el handler asincrónico (disponible en versiones más recientes de Aspose). + +### Cambiar los nombres de las entradas ZIP +`ResourceInfo` contiene `FileName` y `Path`. Puedes reescribirlos para aplanar la jerarquía o añadir un prefijo: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Example: prepend "assets/" to every entry + info.Path = Path.Combine("assets", info.Path); + return base.HandleResource(info); +} +``` + +### Usar un almacenamiento de salida diferente +`OutputStorage` también puede ser un `FileSystemStorage` si prefieres una carpeta en lugar de un ZIP. Simplemente establece `SaveToZipArchive = false` y apunta `OutputStorage` a una ruta de directorio. + +## Consejos profesionales y trampas + +- **No olvides disponer** del `HtmlDocument` si abres muchas páginas en un bucle; de lo contrario podrías filtrar recursos nativos. +- **Uso de memoria:** Guardar páginas enormes en un `MemoryStream` puede inflar la RAM. Para archivos de varios megabytes, transmite directamente a un archivo (`FileStream`). +- **Codificación de caracteres:** Aspose.HTML respeta la etiqueta ``. Si la página fuente usa una codificación poco común, verifica que el HTML resultante se renderice correctamente después de la extracción. +- **Pruebas:** Abre el ZIP generado en un navegador (arrastra `index.html` fuera) para asegurarte de que todos los recursos se resuelvan. Si faltan imágenes, probablemente tu `HandleResource` devolvió un flujo vacío. + +## Recapitulación + +Hemos cubierto **how to use handler** para interceptar recursos externos, demostrado **load html from url**, creado un **custom resource handler**, y finalmente **save webpage as zip**—efectivamente **create zip from html** con unas pocas líneas de C#. El patrón escala: sustituye el `MemoryStream` vacío por un descargador real, cambia el objetivo de salida, o incrusta la lógica en una API web que devuelva el ZIP bajo demanda. + +### ¿Qué sigue? + +- **Procesamiento por lotes:** Recorrer una lista de URLs y generar un ZIP por página. +- **Ajustes de compresión:** Usa `ZipSaveOptions` para ajustar el nivel de compresión y obtener descargas más rápidas. +- **Integración con ASP.NET Core:** Devuelve el `MemoryStream` como un `FileResult` para que los usuarios puedan descargar el archivo directamente desde un endpoint web. +- **Explora otras funcionalidades de Aspose.HTML:** conversión a PDF, manipulación del DOM o renderizado sin cabeza. + +¿Tienes preguntas sobre un caso de uso específico—quizá necesites preservar JavaScript o manejar páginas protegidas por autenticación? Deja un comentario abajo; estaré encantado de profundizar. ¡Feliz codificación! + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/spanish/net/rendering-html-documents/_index.md b/html/spanish/net/rendering-html-documents/_index.md index d6572af0db..feade5235b 100644 --- a/html/spanish/net/rendering-html-documents/_index.md +++ b/html/spanish/net/rendering-html-documents/_index.md @@ -46,6 +46,7 @@ Aprenda a trabajar con Aspose.HTML para .NET: manipule HTML, convierta a varios Aprenda a convertir HTML a PNG en C# con Aspose.HTML, siguiendo una guía paso a paso con ejemplos claros. ### [Cómo usar Aspose para renderizar HTML a PNG – Guía paso a paso](./how-to-use-aspose-to-render-html-to-png-step-by-step-guide/) Aprenda paso a paso a convertir HTML a PNG usando Aspose.HTML para .NET. Siga el tutorial completo y obtenga resultados de alta calidad. + ### [Crear PNG a partir de HTML – Guía completa de renderizado en C#](./create-png-from-html-full-c-rendering-guide/) Aprenda a generar imágenes PNG desde HTML usando Aspose.HTML para .NET con ejemplos completos en C#. ### [Cómo renderizar HTML a PNG – Guía completa en C#](./how-to-render-html-to-png-complete-c-guide/) @@ -78,6 +79,10 @@ Aprenda a renderizar HTML usando un manejador de recursos personalizado para un Aprenda a convertir HTML a PNG con Aspose.HTML para .NET siguiendo una guía detallada paso a paso. ### [Cómo renderizar HTML como PNG con Aspose.HTML – Guía completa en C#](./how-to-render-html-as-png-complete-c-guide/) Aprenda paso a paso a convertir HTML a PNG usando C# y Aspose.HTML. Guía completa con ejemplos claros. + +### [Cómo renderizar HTML como PNG en C# – Guía paso a paso](./how-to-render-html-as-png-in-c-step-by-step-guide/) +Aprenda paso a paso a convertir HTML a PNG usando C# y Aspose.HTML con ejemplos claros y fáciles de seguir. + ### [Cómo renderizar HTML a PNG con Aspose – Guía completa](./how-to-render-html-to-png-with-aspose-complete-guide/) Aprenda a convertir HTML a PNG usando Aspose.HTML para .NET con esta guía completa paso a paso. ### [Cómo renderizar HTML a una imagen con C# – Guía completa](./how-to-render-html-to-an-image-with-c-complete-guide/) diff --git a/html/spanish/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md b/html/spanish/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..b21edcb22e --- /dev/null +++ b/html/spanish/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md @@ -0,0 +1,222 @@ +--- +category: general +date: 2026-02-25 +description: Cómo renderizar HTML como PNG en C# usando Aspose.HTML. Aprende a convertir + HTML a imagen, guardar HTML como PNG y crear PNG a partir de HTML rápidamente. +draft: false +keywords: +- how to render html +- convert html to image +- save html as png +- create png from html +- generate png from html +language: es +og_description: Cómo renderizar HTML como PNG en C# con Aspose.HTML. Sigue este tutorial + para convertir HTML a imagen, guardar HTML como PNG y generar PNG a partir de HTML. +og_title: Cómo renderizar HTML como PNG en C# – Guía completa +tags: +- C# +- Aspose.HTML +- Image Rendering +title: Cómo renderizar HTML como PNG en C# – Guía paso a paso +url: /es/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Cómo renderizar HTML como PNG en C# – Guía paso a paso + +¿Alguna vez te has preguntado **cómo renderizar HTML** directamente a un archivo PNG sin tener que manejar un navegador? Tal vez necesites incrustar una pequeña captura de una página web en un correo electrónico, o estés construyendo un servicio de miniaturas para un CMS. En cualquier caso, el problema se reduce a convertir el marcado en un mapa de bits que puedas almacenar o servir. + +En este tutorial verás una solución completa, lista para ejecutar, que **convierte HTML a imagen** usando Aspose.HTML para .NET. También abordaremos cómo **guardar HTML como PNG**, **crear PNG a partir de HTML**, e incluso **generar PNG desde HTML** con fuentes y dimensiones personalizadas. Sin referencias vagas—solo el código que puedes copiar y pegar, más explicaciones de por qué cada línea es importante. + +## Lo que necesitarás + +- .NET 6 (o cualquier runtime reciente de .NET) – la API funciona igual en .NET Framework 4.6+. +- Visual Studio 2022 o VS Code – lo que prefieras. +- El paquete NuGet **Aspose.HTML** (`Aspose.HTML.NET`) – instálalo una vez y listo. +- Una carpeta con permisos de escritura para el PNG de salida (p. ej., `C:\Temp\Images`). + +Eso es todo. Sin binarios extra, sin servicios web externos, y sin archivos de configuración ocultos. + +## Paso 1: Instalar Aspose.HTML vía NuGet + +Primero, agrega la biblioteca a tu proyecto. Abre la terminal en la carpeta de tu solución y ejecuta: + +```bash +dotnet add package Aspose.HTML.NET +``` + +*Consejo:* Si estás en Visual Studio, haz clic derecho en **Dependencies → Manage NuGet Packages**, busca “Aspose.HTML” y haz clic en **Install**. Esto te da acceso a `HtmlDocument`, `ImageRenderingOptions` y otras clases que utilizaremos. + +## Paso 2: Configurar opciones de renderizado (tamaño, estilo y fuentes) + +Antes de pasar cualquier marcado al renderizador, decidimos cuán grande debe ser la imagen y qué estilos de fuente queremos conservar. El objeto `ImageRenderingOptions` te permite ajustar el ancho, la altura e incluso forzar la renderización en negrita/cursiva. + +```csharp +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +// Configure image rendering options – width, height, and font style +ImageRenderingOptions renderingOptions = new ImageRenderingOptions +{ + Width = 800, // Desired image width in pixels + Height = 600, // Desired image height in pixels + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic // Preserve bold & italic +}; +``` + +**Por qué es importante:** +- **Width/Height** determinan las dimensiones finales en píxeles; si los omites, el motor adivina basándose en el diseño HTML, lo que puede provocar recortes inesperados. +- **FontStyle** garantiza que cualquier etiqueta `` o `` mantenga su énfasis visual al rasterizarse. + +## Paso 3: Cargar tu marcado HTML + +Puedes cargar HTML desde una cadena, un archivo o una URL. Por simplicidad, incrustaremos un pequeño fragmento directamente en el código. Observa el CSS en línea que establece la familia tipográfica – Aspose.HTML respeta el CSS web estándar, por lo que obtienes una renderización fiel. + +```csharp +using Aspose.Html; + +// Create an empty HTML document +HtmlDocument htmlDoc = new HtmlDocument(); + +// Load simple markup – you could also use htmlDoc.Open("path/to/file.html") +htmlDoc.Open("Hello, world!
"); +``` + +**Consejo para casos límite:** Si tu marcado hace referencia a recursos externos (imágenes, archivos CSS), asegúrate de que esas URLs sean accesibles desde la máquina que ejecuta el código, o incrústalos como data‑URIs para evitar enlaces rotos. + +## Paso 4: Renderizar el HTML a un flujo PNG + +Ahora llega el núcleo de **cómo renderizar HTML** – llamamos a `RenderToStream`, pasando el flujo de salida y las opciones que configuramos antes. El método realiza todo el trabajo pesado: diseño, cascada CSS, sustitución de fuentes y rasterización. + +```csharp +using System.IO; + +// Choose an output path – replace with your own directory +string outputPath = @"C:\Temp\Images\output.png"; + +using (FileStream outputStream = File.OpenWrite(outputPath)) +{ + // Render the HTML document into the PNG file + htmlDoc.RenderToStream(outputStream, renderingOptions); +} +``` + +Después de que finalice el bloque `using`, `output.png` contendrá una imagen de 800 × 600 píxeles del párrafo que cargamos. Ábrela con cualquier visor de imágenes para verificar el resultado. + +### Resultado esperado + +Deberías ver un lienzo blanco limpio con el texto **“Hello, world!”** renderizado en Arial, negrita y cursiva, exactamente de 24 pt de tamaño. Las dimensiones de la imagen coinciden con los valores 800 × 600 que establecimos. + +## Paso 5: Verificar y manejar problemas comunes + +### 5.1 Verificar que el archivo exista + +Una rápida verificación de sanidad evita fallos silenciosos: + +```csharp +if (File.Exists(outputPath)) +{ + Console.WriteLine($"✅ PNG created successfully at {outputPath}"); +} +else +{ + Console.WriteLine("❌ Something went wrong – PNG not found."); +} +``` + +### 5.2 Manejar fuentes faltantes + +Si la máquina de destino no tiene la fuente solicitada, Aspose.HTML recurre a una fuente genérica sans‑serif. Para garantizar consistencia, puedes: + +- Incrustar el archivo de fuente usando una regla `@font-face` en tu HTML, **o** +- Registrar la fuente programáticamente antes de renderizar. + +```csharp +// Example of registering a custom TrueType font +htmlDoc.Fonts.AddFontFile(@"C:\Fonts\OpenSans-Regular.ttf"); +``` + +### 5.3 Renderizar páginas grandes + +Al crear miniaturas para capturas de pantalla de página completa, vigila el uso de memoria. Puedes reducir la escala después del renderizado, o establecer `renderingOptions.Width`/`Height` a un tamaño menor y dejar que Aspose.HTML maneje el escalado. + +## Ejemplo completo funcional + +A continuación tienes el programa completo que puedes colocar en una aplicación de consola y ejecutar de inmediato. + +```csharp +// ----------------------------------------------------------- +// How to render HTML as PNG – Complete, runnable example +// ----------------------------------------------------------- +using System; +using System.IO; +using Aspose.Html; +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +class Program +{ + static void Main() + { + // 1️⃣ Configure rendering options + ImageRenderingOptions renderingOptions = new ImageRenderingOptions + { + Width = 800, + Height = 600, + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic + }; + + // 2️⃣ Load HTML markup + HtmlDocument htmlDoc = new HtmlDocument(); + htmlDoc.Open("Hello, world!
"); + + // 3️⃣ Define output path + string outputPath = @"C:\Temp\Images\output.png"; + + // 4️⃣ Render to PNG + using (FileStream outputStream = File.OpenWrite(outputPath)) + { + htmlDoc.RenderToStream(outputStream, renderingOptions); + } + + // 5️⃣ Verify the result + Console.WriteLine(File.Exists(outputPath) + ? $"✅ PNG saved at {outputPath}" + : "❌ Failed to create PNG"); + } +} +``` + +Ejecuta el programa (`dotnet run`), luego abre `C:\Temp\Images\output.png`. Si todo salió bien, acabas de **convertir HTML a imagen** y **guardar HTML como PNG** usando código puro de C#. + +## Preguntas frecuentes + +| Pregunta | Respuesta | +|----------|-----------| +| **¿Puedo renderizar una página completa con CSS/JS externos?** | Sí – simplemente llama a `htmlDoc.Open("https://example.com")`. El motor descargará los recursos vinculados, pero necesitas acceso a la red. | +| **¿Qué formatos se admiten además de PNG?** | `ImageRenderingOptions` funciona con JPEG, BMP, GIF y TIFF. Cambia la extensión del archivo y establece `ImageFormat` si es necesario. | +| **¿Existe un límite de tamaño de imagen?** | Técnicamente puedes llegar a varios miles de píxeles, pero dimensiones muy grandes pueden agotar la memoria. Considera renderizar en mosaicos para salidas ultra‑alta resolución. | +| **¿Cómo manejo el DPI para imágenes de calidad de impresión?** | Establece `renderingOptions.DpiX` y `renderingOptions.DpiY` (el valor predeterminado es 96). Un DPI más alto produce una salida más nítida para impresión. | +| **¿Necesito una licencia para Aspose.HTML?** | Una evaluación gratuita funciona con una marca de agua. Para producción, compra una licencia para eliminarla y desbloquear todas las funciones. | + +## Próximos pasos y temas relacionados + +- **Convertir HTML a JPEG** – cambia la extensión del archivo y opcionalmente establece `renderingOptions.ImageFormat = ImageFormat.Jpeg`. +- **Procesamiento por lotes** – recorre una lista de URLs y genera miniaturas para cada una. +- **Incrustar fuentes** – aprende a usar `@font-face` dentro de tu marcado para una tipografía perfecta. +- **Diseño avanzado** – experimenta con las opciones `PageSize`, `Margin` y `BackgroundColor` para apariencias personalizadas. + +Siéntete libre de ajustar las dimensiones, probar diferentes fragmentos HTML, o integrar este fragmento en una API web que sirva vistas previas PNG al instante. El cielo es el límite cuando sabes **cómo renderizar HTML** programáticamente. + +--- + + + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/swedish/net/html-extensions-and-conversions/_index.md b/html/swedish/net/html-extensions-and-conversions/_index.md index 68e7d1c797..8480927a66 100644 --- a/html/swedish/net/html-extensions-and-conversions/_index.md +++ b/html/swedish/net/html-extensions-and-conversions/_index.md @@ -111,6 +111,8 @@ Lär dig hur du sparar en hel webbsida som en enda HTML-fil med C# och Aspose.HT En komplett steg‑för‑steg‑guide för att konvertera HTML till PDF i C# med Aspose.HTML. ### [Aspose HTML-sparalternativ: Spara HTML till ström i C#](./aspose-html-save-options-save-html-to-stream-in-c/) Lär dig hur du sparar HTML direkt till en ström med Aspose.HTML för .NET i C# med hjälp av sparalternativ. +### [Hur man använder handler i Aspose.HTML – Ladda HTML, spara som ZIP](./how-to-use-handler-in-aspose-html-load-html-save-as-zip/) +Lär dig hur du använder en handler i Aspose.HTML för att ladda HTML och spara den som en ZIP-fil med C#. ## Slutsats diff --git a/html/swedish/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md b/html/swedish/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md new file mode 100644 index 0000000000..13b6e4d013 --- /dev/null +++ b/html/swedish/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md @@ -0,0 +1,182 @@ +--- +category: general +date: 2026-02-25 +description: hur man använder en handler för att ladda HTML från URL och spara webbsidan + som zip med Aspose.HTML – en komplett C# steg‑för‑steg‑guide +draft: false +keywords: +- how to use handler +- load html from url +- custom resource handler +- save webpage as zip +- create zip from html +language: sv +og_description: hur man använder en handler för att ladda HTML från en URL och spara + webbsidan som zip med Aspose.HTML. lär dig hela C#‑arbetsflödet på några minuter. +og_title: Hur man använder handler i Aspose.HTML – Ladda HTML, spara som ZIP +tags: +- Aspose.HTML +- C# +- Web Scraping +title: Hur man använder handler i Aspose.HTML – Ladda HTML, spara som ZIP +url: /sv/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# hur man använder handler i Aspose.HTML – Ladda HTML, Spara som ZIP + +Har du någonsin funderat **hur man använder handler** när du hämtar en webbsida till din .NET‑app? Kanske har du provat `HtmlDocument.Open` och fått HTML‑koden, men bilder, CSS och typsnitt försvann i tomma intet. Det är ett vanligt problem – resurser går förlorade om du inte talar om för Aspose.HTML vad som ska göras med dem. + +I den här handledningen går vi igenom hur du laddar HTML från en URL, kopplar in en **anpassad resurs‑handler**, och slutligen **sparar webbsidan som zip** så att du får ett enda portabelt arkiv. När du är klar har du ett färdigt C#‑exempel som du kan klistra in i vilket projekt som helst, plus ett antal tips som sparar dig huvudvärk längre fram. + +## Vad du behöver + +- .NET 6+ (API‑et fungerar även på .NET Core och .NET Framework) +- Aspose.HTML för .NET (NuGet‑paket `Aspose.HTML`) +- En grundläggande kunskap i C# (du klarar det om du någonsin har skrivit en `Console.WriteLine`) + +Inga extra verktyg, inga externa tjänster – bara biblioteket och en URL du vill arkivera. + + + +## Steg 1: Ladda HTML från URL + +Det första i alla web‑scraping‑flöden är att hämta sidans källkod. Aspose.HTML gör detta med en enda rad, men kom ihåg att vi **laddar html från url** med den inbyggda nätverks‑stacken. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +// 1️⃣ Load the page you want to archive +HtmlDocument htmlDoc = new HtmlDocument(); +htmlDoc.Open("https://example.com"); // replace with any public URL +``` + +> **Varför detta är viktigt:** `HtmlDocument.Open` parsar markupen *och* löser relativa URL:er internt, men den sparar inte automatiskt de externa resurserna. Därför behöver vi en handler senare. + +## Steg 2: Skapa en anpassad resurs‑handler + +Nu kommer kärnan – **hur man använder handler** för att avlyssna varje extern resursförfrågan (bilder, CSS, typsnitt osv.). Genom att ärva från `ResourceHandler` får du full kontroll över den ström som backar varje tillgång. + +```csharp +// 2️⃣ Define your own handler (optional but powerful) +public class MyResourceHandler : ResourceHandler +{ + // Called for each external resource the document needs + public override Stream HandleResource(ResourceInfo info) + { + // Here you could download the file, cache it, or rewrite it. + // For this demo we simply return an empty stream – Aspose will + // still create the entry in the ZIP, keeping the folder structure. + return new MemoryStream(); + } +} +``` + +> **Pro‑tips:** I ett produktionsscenario vill du kanske ladda ner de faktiska byten (`HttpClient.GetStreamAsync(info.Uri)`) och returnera den strömmen. Det säkerställer att den sparade ZIP‑filen innehåller riktiga bilder istället för tomma platshållare. + +## Steg 3: Konfigurera sparalternativ och anslut handlern + +När handlern är klar talar vi om för Aspose.HTML hur allt ska paketeras. Klassen `HtmlSaveOptions` låter dig slå på `SaveToZipArchive`‑flaggan och koppla in din `MyResourceHandler`. + +```csharp +// 3️⃣ Set up saving options – this is where we **save webpage as zip** +HtmlSaveOptions saveOptions = new HtmlSaveOptions +{ + // Attach our custom handler – new API as of v22.10 + OutputStorage = new MyResourceHandler(), + + // Instruct Aspose to bundle HTML + resources into a single ZIP file + SaveToZipArchive = true +}; +``` + +> **Förklaring:** `OutputStorage` är egenskapen som tar emot handler‑instansen. När spararen går igenom DOM‑en anropar den `HandleResource` för varje extern länk. Eftersom `SaveToZipArchive` är true skriver spararen varje returnerad ström till en ZIP‑post som matchar den ursprungliga sökvägen. + +## Steg 4: Spara dokumentet i ett minnes‑flöde + +Vi skulle kunna skriva direkt till disk, men att hålla allt i minnet gör koden användbar i ASP.NET, Azure Functions eller någon annan plats där du inte vill ha en temporär fil. Här är sista steget som **skapar zip från html**. + +```csharp +// 4️⃣ Save everything – HTML + resources – into a MemoryStream +using (MemoryStream outputStream = new MemoryStream()) +{ + htmlDoc.Save(outputStream, saveOptions); + + // At this point outputStream holds a valid ZIP archive. + // For demo purposes we write it to the file system: + File.WriteAllBytes("example_page.zip", outputStream.ToArray()); +} +``` + +### Förväntat resultat + +- `example_page.zip` dyker upp i din projektmapp. +- Inuti ZIP‑filen hittar du `index.html` plus en mappstruktur (`images/`, `css/`, osv.). +- Även om vår demo‑handler returnerade tomma strömmar så speglar ZIP‑layouten den ursprungliga sidan – perfekt för att byta in en riktig nedladdare senare. + +## Vanliga varianter & kantfall + +### Ladda en lokal fil istället för en URL +Om du behöver **ladda html från url**‑liknande sökvägar på disk, byt helt enkelt ut `htmlDoc.Open("https://example.com")` mot `htmlDoc.Open(@"C:\path\to\file.html")`. Resten av flödet förblir identiskt. + +### Spara riktiga resurser +För att faktiskt bädda in bilder, ändra `HandleResource`: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Download the resource using HttpClient + HttpClient client = new HttpClient(); + var data = client.GetByteArrayAsync(info.Uri).Result; + return new MemoryStream(data); +} +``` + +> **Varning:** Nätverksanrop inuti handlern blockerar spar‑tråden; för stora sidor bör du överväga att göra handlern asynkron (tillgänglig i nyare Aspose‑utgåvor). + +### Ändra ZIP‑posternas namn +`ResourceInfo` innehåller `FileName` och `Path`. Du kan skriva om dem för att platta ut hierarkin eller lägga till ett prefix: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Example: prepend "assets/" to every entry + info.Path = Path.Combine("assets", info.Path); + return base.HandleResource(info); +} +``` + +### Använd ett annat Output‑lagringsalternativ +`OutputStorage` kan också vara ett `FileSystemStorage` om du föredrar en mapp istället för en ZIP. Sätt bara `SaveToZipArchive = false` och peka `OutputStorage` mot en katalogsökväg. + +## Pro‑tips & fallgropar + +- **Glöm inte att disponera** `HtmlDocument` om du öppnar många sidor i en loop; annars kan du läcka inhemska resurser. +- **Minnesanvändning:** Att spara enorma sidor i ett `MemoryStream` kan blåsa upp RAM‑användningen. För multi‑megabyte‑arkiv, streama direkt till en fil (`FileStream`) istället. +- **Teckenkodning:** Aspose.HTML respekterar ``‑taggen. Om källsidan använder en ovanlig kodning, verifiera att den resulterande HTML‑en renderas korrekt efter extraktion. +- **Testning:** Öppna den genererade ZIP‑filen i en webbläsare (dra ut `index.html`) för att säkerställa att alla resurser löser sig. Om bilder saknas har ditt `HandleResource` troligen returnerat en tom ström. + +## Sammanfattning + +Vi har gått igenom **hur man använder handler** för att avlyssna externa resurser, demonstrerat **ladda html från url**, byggt en **anpassad resurs‑handler**, och slutligen **sparat webbsidan som zip** – i praktiken **skapat zip från html** med några få rader C#. Mönstret skalar: byt ut den tomma `MemoryStream` mot en riktig nedladdare, ändra mål för utskrift, eller bädda in logiken i ett web‑API som returnerar ZIP‑filen på begäran. + +--- + +### Vad blir nästa steg? + +- **Batch‑bearbetning:** Loop över en lista med URL:er och generera en ZIP per sida. +- **Komprimeringsinställningar:** Använd `ZipSaveOptions` för att justera komprimeringsnivån för snabbare nedladdningar. +- **Integration med ASP.NET Core:** Returnera `MemoryStream` som ett `FileResult` så att användare kan ladda ner arkivet direkt från en web‑endpoint. +- **Utforska andra Aspose.HTML‑funktioner:** PDF‑konvertering, DOM‑manipulering eller headless rendering. + +Har du frågor om ett specifikt användningsfall – kanske du behöver bevara JavaScript eller hantera autentiserade sidor? Lägg en kommentar nedan; jag hjälper gärna till att gräva djupare. Lycka till med kodandet! + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/swedish/net/rendering-html-documents/_index.md b/html/swedish/net/rendering-html-documents/_index.md index 8eb74e4377..2508bfe38b 100644 --- a/html/swedish/net/rendering-html-documents/_index.md +++ b/html/swedish/net/rendering-html-documents/_index.md @@ -77,6 +77,8 @@ Lär dig hur du konverterar HTML till PNG i C# med en komplett steg‑för‑ste Lär dig att rendera HTML med en anpassad resurs‑hanterare i Aspose.HTML för .NET. Steg‑för‑steg‑exempel och bästa praxis. ### [Hur man använder Aspose för att rendera HTML till PNG – Steg‑för‑steg‑guide](./how-to-use-aspose-to-render-html-to-png-step-by-step-guide/) Lär dig hur du med Aspose.HTML för .NET konverterar HTML till PNG i en detaljerad steg‑för‑steg‑handledning. +### [Hur man renderar HTML som PNG i C# – Steg‑för‑steg‑guide](./how-to-render-html-as-png-in-c-step-by-step-guide/) +Lär dig steg för steg hur du med Aspose.HTML för .NET konverterar HTML till PNG i C#. ### [Hur man renderar HTML till PNG med Aspose – Komplett guide](./how-to-render-html-to-png-with-aspose-complete-guide/) Lär dig hur du med Aspose.HTML för .NET konverterar HTML till PNG i en komplett guide. ### [Skapa HTML-dokument i C# – Rendera till PNG med fet kursiv teckensnitt](./create-html-document-c-render-to-png-with-bold-italic-font/) diff --git a/html/swedish/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md b/html/swedish/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..362ba7fa87 --- /dev/null +++ b/html/swedish/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md @@ -0,0 +1,222 @@ +--- +category: general +date: 2026-02-25 +description: Hur man renderar HTML som PNG i C# med Aspose.HTML. Lär dig konvertera + HTML till bild, spara HTML som PNG och skapa PNG från HTML snabbt. +draft: false +keywords: +- how to render html +- convert html to image +- save html as png +- create png from html +- generate png from html +language: sv +og_description: Hur man renderar HTML som PNG i C# med Aspose.HTML. Följ den här handledningen + för att konvertera HTML till bild, spara HTML som PNG och generera PNG från HTML. +og_title: Hur man renderar HTML som PNG i C# – Komplett guide +tags: +- C# +- Aspose.HTML +- Image Rendering +title: Hur man renderar HTML till PNG i C# – Steg‑för‑steg‑guide +url: /sv/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Så renderar du HTML som PNG i C# – Steg‑för‑steg guide + +Har du någonsin funderat **hur man renderar HTML** direkt till en PNG‑fil utan att behöva en webbläsare? Kanske behöver du bädda in en liten ögonblicksbild av en webbsida i ett e‑postmeddelande, eller så bygger du en miniatyrtjänst för ett CMS. Oavsett så handlar problemet om att omvandla markup till en bitmap som du kan lagra eller leverera. + +I den här handledningen får du se en komplett, färdig‑att‑köra lösning som **konverterar HTML till bild** med Aspose.HTML för .NET. Vi kommer också att beröra hur man **sparar HTML som PNG**, **skapar PNG från HTML**, och till och med **genererar PNG från HTML** med anpassade typsnitt och dimensioner. Inga vaga referenser – bara koden du kan kopiera‑klistra in, samt förklaringar till varför varje rad är viktig. + +## Vad du behöver + +- .NET 6 (eller någon nyare .NET‑runtime) – API‑et fungerar likadant på .NET Framework 4.6+. +- Visual Studio 2022 eller VS Code – vad du än föredrar. +- NuGet‑paketet **Aspose.HTML** (`Aspose.HTML.NET`) – installera det en gång så är du klar. +- Skriv‑bar mapp för den genererade PNG‑filen (t.ex. `C:\Temp\Images`). + +Det är allt. Inga extra binärer, inga externa webbtjänster och inga dolda konfigurationsfiler. + +## Steg 1: Installera Aspose.HTML via NuGet + +Först, lägg till biblioteket i ditt projekt. Öppna terminalen i din lösningsmapp och kör: + +```bash +dotnet add package Aspose.HTML.NET +``` + +*Pro tip:* Om du använder Visual Studio, högerklicka på **Dependencies → Manage NuGet Packages**, sök efter “Aspose.HTML” och klicka på **Install**. Detta ger dig tillgång till `HtmlDocument`, `ImageRenderingOptions` och andra klasser vi kommer att använda. + +## Steg 2: Ställ in renderingsalternativ (storlek, stil och typsnitt) + +Innan vi matar någon markup till renderaren bestämmer vi hur stor bilden ska vara och vilka typsnittsstilar vi vill bevara. Objektet `ImageRenderingOptions` låter dig justera bredd, höjd och till och med tvinga fet/kursiv rendering. + +```csharp +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +// Configure image rendering options – width, height, and font style +ImageRenderingOptions renderingOptions = new ImageRenderingOptions +{ + Width = 800, // Desired image width in pixels + Height = 600, // Desired image height in pixels + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic // Preserve bold & italic +}; +``` + +**Varför detta är viktigt:** +- **Width/Height** bestämmer de slutgiltiga pixelmåtten; om du utelämnar dem gissar motorn baserat på HTML‑layouten, vilket kan leda till oväntad beskärning. +- **FontStyle** säkerställer att ``‑ eller ``‑taggar behåller sin visuella betoning när de rasteriseras. + +## Steg 3: Ladda din HTML‑markup + +Du kan ladda HTML från en sträng, en fil eller en URL. För enkelhetens skull kommer vi att bädda in ett litet kodsnutt direkt i koden. Lägg märke till den inbäddade CSS‑en som sätter teckensnittsfamiljen – Aspose.HTML respekterar standard‑webb‑CSS, så du får en trogen rendering. + +```csharp +using Aspose.Html; + +// Create an empty HTML document +HtmlDocument htmlDoc = new HtmlDocument(); + +// Load simple markup – you could also use htmlDoc.Open("path/to/file.html") +htmlDoc.Open("Hello, world!
"); +``` + +**Tips för kantfall:** Om din markup refererar till externa resurser (bilder, CSS‑filer), se till att dessa URL:er är åtkomliga från maskinen som kör koden, eller bädda in dem som data‑URI:er för att undvika brutna länkar. + +## Steg 4: Rendera HTML till en PNG‑ström + +Nu kommer kärnan i **hur man renderar HTML** – vi anropar `RenderToStream`, och skickar med utdata‑strömmen samt de alternativ vi konfigurerade tidigare. Metoden sköter allt tungt arbete: layout, CSS‑kaskad, typsnittssubstitution och rasterisering. + +```csharp +using System.IO; + +// Choose an output path – replace with your own directory +string outputPath = @"C:\Temp\Images\output.png"; + +using (FileStream outputStream = File.OpenWrite(outputPath)) +{ + // Render the HTML document into the PNG file + htmlDoc.RenderToStream(outputStream, renderingOptions); +} +``` + +När `using`‑blocket avslutas kommer `output.png` att innehålla en 800 × 600‑pixel bild av paragrafen vi laddade. Öppna den med någon bildvisare för att verifiera resultatet. + +### Förväntat resultat + +Du bör se en ren vit duk med texten **“Hello, world!”** renderad i Arial, fet och kursiv, exakt 24 pt i storlek. Bildens dimensioner matchar de 800 × 600‑värden vi angav. + +## Steg 5: Verifiera och hantera vanliga fallgropar + +### 5.1 Kontrollera att filen finns + +Ett snabbt kontrolltest förhindrar tysta fel: + +```csharp +if (File.Exists(outputPath)) +{ + Console.WriteLine($"✅ PNG created successfully at {outputPath}"); +} +else +{ + Console.WriteLine("❌ Something went wrong – PNG not found."); +} +``` + +### 5.2 Hantera saknade typsnitt + +Om målmaskinen saknar det begärda typsnittet, faller Aspose.HTML tillbaka på ett generiskt sans‑serif. För att garantera konsistens, antingen: + +- Bädda in typsnittsfilen med en `@font-face`‑regel i din HTML, **eller** +- Registrera typsnittet programatiskt innan rendering. + +```csharp +// Example of registering a custom TrueType font +htmlDoc.Fonts.AddFontFile(@"C:\Fonts\OpenSans-Regular.ttf"); +``` + +### 5.3 Rendera stora sidor + +När du skapar miniatyrer för helsidsskärmbilder, håll koll på minnesanvändningen. Du kan nedskala efter rendering, eller sätta `renderingOptions.Width`/`Height` till en mindre storlek och låta Aspose.HTML hantera skalningen. + +## Fullt fungerande exempel + +Nedan är det kompletta programmet som du kan klistra in i en konsolapplikation och köra direkt. + +```csharp +// ----------------------------------------------------------- +// How to render HTML as PNG – Complete, runnable example +// ----------------------------------------------------------- +using System; +using System.IO; +using Aspose.Html; +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +class Program +{ + static void Main() + { + // 1️⃣ Configure rendering options + ImageRenderingOptions renderingOptions = new ImageRenderingOptions + { + Width = 800, + Height = 600, + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic + }; + + // 2️⃣ Load HTML markup + HtmlDocument htmlDoc = new HtmlDocument(); + htmlDoc.Open("Hello, world!
"); + + // 3️⃣ Define output path + string outputPath = @"C:\Temp\Images\output.png"; + + // 4️⃣ Render to PNG + using (FileStream outputStream = File.OpenWrite(outputPath)) + { + htmlDoc.RenderToStream(outputStream, renderingOptions); + } + + // 5️⃣ Verify the result + Console.WriteLine(File.Exists(outputPath) + ? $"✅ PNG saved at {outputPath}" + : "❌ Failed to create PNG"); + } +} +``` + +Kör programmet (`dotnet run`), och öppna sedan `C:\Temp\Images\output.png`. Om allt gick smidigt har du just **konverterat HTML till bild** och **sparat HTML som PNG** med ren C#‑kod. + +## Vanliga frågor + +| Fråga | Svar | +|----------|--------| +| **Kan jag rendera en hel webbsida med extern CSS/JS?** | Ja – anropa bara `htmlDoc.Open("https://example.com")`. Motorn laddar ner länkade resurser, men du behöver nätverksåtkomst. | +| **Vilka format stöds förutom PNG?** | `ImageRenderingOptions` fungerar med JPEG, BMP, GIF och TIFF. Ändra filändelsen och sätt `ImageFormat` om det behövs. | +| **Finns det en gräns för bildstorlek?** | Tekniskt sett kan du gå upp till flera tusen pixlar, men mycket stora dimensioner kan tömma minnet. Överväg att rendera i tiles för ultra‑högupplöst output. | +| **Hur hanterar jag DPI för utskriftskvalitet?** | Sätt `renderingOptions.DpiX` och `renderingOptions.DpiY` (standard är 96). Högre DPI ger skarpare resultat för utskrift. | +| **Behöver jag en licens för Aspose.HTML?** | En gratis utvärdering fungerar med ett vattenmärke. För produktion, köp en licens för att ta bort det och låsa upp alla funktioner. | + +## Nästa steg och relaterade ämnen + +- **Konvertera HTML till JPEG** – byt filändelsen och sätt eventuellt `renderingOptions.ImageFormat = ImageFormat.Jpeg`. +- **Batch‑bearbetning** – loopa över en lista med URL:er och generera miniatyrer för var och en. +- **Bädda in typsnitt** – lär dig hur du använder `@font-face` i din markup för perfekt typografi. +- **Avancerad layout** – experimentera med `PageSize`, `Margin` och `BackgroundColor`‑alternativ för anpassade utseenden. + +Känn dig fri att justera dimensionerna, prova olika HTML‑snuttar, eller integrera detta kodexempel i ett web‑API som levererar PNG‑förhandsvisningar i realtid. Himlen är gränsen när du vet **hur man renderar HTML** programatiskt. + +--- + + + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/thai/net/html-extensions-and-conversions/_index.md b/html/thai/net/html-extensions-and-conversions/_index.md index 4e86f4f8b6..0162b9265d 100644 --- a/html/thai/net/html-extensions-and-conversions/_index.md +++ b/html/thai/net/html-extensions-and-conversions/_index.md @@ -114,6 +114,8 @@ Aspose.HTML สำหรับ .NET ไม่ใช่แค่ไลบรา เรียนรู้วิธีบีบอัดไฟล์ HTML เป็น Zip ด้วย C# โดยใช้ตัวจัดการทรัพยากรแบบกำหนดเองใน Aspose.HTML สำหรับ .NET ### [Aspose HTML Save Options: บันทึก HTML ไปยังสตรีมใน C#](./aspose-html-save-options-save-html-to-stream-in-c/) เรียนรู้วิธีบันทึก HTML ไปยังสตรีมใน C# ด้วย Aspose.HTML สำหรับ .NET อย่างละเอียดและง่ายดาย +### [วิธีใช้ handler ใน Aspose.HTML – โหลด HTML, บันทึกเป็น ZIP](./how-to-use-handler-in-aspose-html-load-html-save-as-zip/) +เรียนรู้วิธีใช้ handler เพื่อโหลดไฟล์ HTML และบันทึกเป็นไฟล์ ZIP ด้วย Aspose.HTML สำหรับ .NET ## บทสรุป diff --git a/html/thai/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md b/html/thai/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md new file mode 100644 index 0000000000..068a952e03 --- /dev/null +++ b/html/thai/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md @@ -0,0 +1,182 @@ +--- +category: general +date: 2026-02-25 +description: วิธีใช้ handler เพื่อโหลด HTML จาก URL และบันทึกหน้าเว็บเป็นไฟล์ zip + ด้วย Aspose.HTML – คู่มือ C# ขั้นตอนโดยละเอียด +draft: false +keywords: +- how to use handler +- load html from url +- custom resource handler +- save webpage as zip +- create zip from html +language: th +og_description: วิธีใช้ handler เพื่อโหลด HTML จาก URL และบันทึกหน้าเว็บเป็นไฟล์ zip + ด้วย Aspose.HTML. เรียนรู้กระบวนการทำงาน C# อย่างครบถ้วนในไม่กี่นาที. +og_title: วิธีใช้ handler ใน Aspose.HTML – โหลด HTML, บันทึกเป็น ZIP +tags: +- Aspose.HTML +- C# +- Web Scraping +title: วิธีใช้ handler ใน Aspose.HTML – โหลด HTML, บันทึกเป็น ZIP +url: /th/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# วิธีใช้ handler ใน Aspose.HTML – โหลด HTML, บันทึกเป็น ZIP + +เคยสงสัย **วิธีใช้ handler** เมื่อนำหน้าเว็บเข้ามาในแอป .NET ของคุณหรือไม่? บางทีคุณอาจลองใช้ `HtmlDocument.Open` แล้วได้ HTML มา แต่รูปภาพ, CSS, และฟอนต์ก็หายไปเหมือนหายลับในอากาศ นั่นเป็นปัญหาที่พบบ่อย—ทรัพยากรจะหายไปหากไม่ได้บอก Aspose.HTML ว่าจะทำอย่างไรกับมัน + +ในบทแนะนำนี้เราจะอธิบายขั้นตอนการโหลด HTML จาก URL, การเชื่อมต่อ **custom resource handler**, และสุดท้าย **save webpage as zip** เพื่อให้คุณได้ไฟล์เก็บข้อมูลแบบพกพาเดียวกัน เมื่อเสร็จแล้วคุณจะมีโค้ดสั้น ๆ ของ C# ที่พร้อมใช้งานและสามารถใส่ลงในโปรเจกต์ใดก็ได้ พร้อมกับเคล็ดลับหลายอย่างที่จะช่วยลดปัญหาในภายหลัง + +## สิ่งที่คุณต้องมี + +- .NET 6+ (API ทำงานบน .NET Core และ .NET Framework ด้วย) +- Aspose.HTML for .NET (แพ็กเกจ NuGet `Aspose.HTML`) +- ประสบการณ์ C# พอสมควร (คุณจะโอเคถ้าเคยเขียน `Console.WriteLine` มาก่อน) + +ไม่ต้องใช้เครื่องมือเพิ่มเติม ไม่ต้องพึ่งบริการภายนอก—แค่ไลบรารีและ URL ที่คุณต้องการเก็บ + + + +## ขั้นตอนที่ 1: โหลด HTML จาก URL + +สิ่งแรกในกระบวนการดึงข้อมูลเว็บคือการดึงซอร์สของหน้า Aspose.HTML ทำให้ขั้นตอนนี้เป็นบรรทัดเดียว แต่จำไว้ว่าเรากำลัง **loading html from url** ด้วยสแตกเครือข่ายในตัว + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +// 1️⃣ Load the page you want to archive +HtmlDocument htmlDoc = new HtmlDocument(); +htmlDoc.Open("https://example.com"); // replace with any public URL +``` + +> **ทำไมสิ่งนี้ถึงสำคัญ:** `HtmlDocument.Open` จะทำการพาร์สมาร์กอัป *และ* แก้ไข URL แบบ relative ภายในโดยอัตโนมัติ แต่จะไม่บันทึกทรัพยากรภายนอกโดยอัตโนมัติ นั่นคือเหตุผลที่เราต้องใช้ handler ต่อไป + +## ขั้นตอนที่ 2: สร้าง Custom Resource Handler + +ต่อมาคือหัวใจของเรื่อง—**วิธีใช้ handler** เพื่อดักจับทุกคำขอทรัพยากรภายนอก (รูปภาพ, CSS, ฟอนต์ ฯลฯ) โดยการสืบทอด `ResourceHandler` คุณจะได้การควบคุมเต็มรูปแบบต่อสตรีมของแต่ละแอสเซ็ต + +```csharp +// 2️⃣ Define your own handler (optional but powerful) +public class MyResourceHandler : ResourceHandler +{ + // Called for each external resource the document needs + public override Stream HandleResource(ResourceInfo info) + { + // Here you could download the file, cache it, or rewrite it. + // For this demo we simply return an empty stream – Aspose will + // still create the entry in the ZIP, keeping the folder structure. + return new MemoryStream(); + } +} +``` + +> **Pro tip:** ในสภาพแวดล้อมการผลิตคุณอาจต้องการดาวน์โหลดไบต์จริง (`HttpClient.GetStreamAsync(info.Uri)`) แล้วคืนสตรีมนั้น ซึ่งจะทำให้ ZIP ที่บันทึกมีรูปภาพจริงแทนที่เป็นเพียงตัวแทนเปล่า + +## ขั้นตอนที่ 3: ตั้งค่า Save Options และเชื่อมต่อ Handler + +เมื่อ handler พร้อม เราบอก Aspose.HTML ว่าจะบรรจุทุกอย่างอย่างไร คลาส `HtmlSaveOptions` ให้คุณสลับสวิตช์ `SaveToZipArchive` และใส่ `MyResourceHandler` ของคุณเข้าไป + +```csharp +// 3️⃣ Set up saving options – this is where we **save webpage as zip** +HtmlSaveOptions saveOptions = new HtmlSaveOptions +{ + // Attach our custom handler – new API as of v22.10 + OutputStorage = new MyResourceHandler(), + + // Instruct Aspose to bundle HTML + resources into a single ZIP file + SaveToZipArchive = true +}; +``` + +> **Explanation:** `OutputStorage` คือพร็อพเพอร์ตี้ที่รับอินสแตนซ์ของ handler เมื่อตัวบันทึกเดินผ่าน DOM มันจะเรียก `HandleResource` สำหรับแต่ละลิงก์ภายนอก เนื่องจาก `SaveToZipArchive` เป็น true ตัวบันทึกจะเขียนสตรีมที่คืนค่ามาแต่ละอันเป็นรายการใน ZIP ที่มีพาธเดิม + +## ขั้นตอนที่ 4: บันทึก Document ลงใน Memory Stream + +เราสามารถเขียนตรงลงดิสก์ได้ แต่การเก็บทุกอย่างในหน่วยความจำทำให้โค้ดใช้งานได้ใน ASP.NET, Azure Functions หรือที่ใดก็ตามที่ไม่ต้องการไฟล์ชั่วคราว นี่คือขั้นตอนสุดท้ายที่ **creates zip from html** + +```csharp +// 4️⃣ Save everything – HTML + resources – into a MemoryStream +using (MemoryStream outputStream = new MemoryStream()) +{ + htmlDoc.Save(outputStream, saveOptions); + + // At this point outputStream holds a valid ZIP archive. + // For demo purposes we write it to the file system: + File.WriteAllBytes("example_page.zip", outputStream.ToArray()); +} +``` + +### ผลลัพธ์ที่คาดหวัง + +- `example_page.zip` ปรากฏในโฟลเดอร์โปรเจกต์ของคุณ +- ภายใน ZIP จะมี `index.html` พร้อมโครงสร้างโฟลเดอร์ (`images/`, `css/`, ฯลฯ) +- แม้ว่า handler ตัวอย่างของเราจะคืนสตรีมเปล่า แต่โครงสร้าง ZIP จะสะท้อนหน้าเว็บต้นฉบับ—พร้อมสำหรับการแทนที่ด้วยตัวดาวน์โหลดจริงในภายหลัง + +## ความแปรผันทั่วไป & กรณีขอบเขต + +### โหลดไฟล์ในเครื่องแทน URL +หากคุณต้องการ **load html from url**‑like paths บนดิสก์ เพียงเปลี่ยน `htmlDoc.Open("https://example.com")` เป็น `htmlDoc.Open(@"C:\path\to\file.html")` ส่วนที่เหลือของกระบวนการยังคงเหมือนเดิม + +### บันทึกทรัพยากรจริง +เพื่อฝังรูปภาพจริง ให้แก้ไข `HandleResource`: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Download the resource using HttpClient + HttpClient client = new HttpClient(); + var data = client.GetByteArrayAsync(info.Uri).Result; + return new MemoryStream(data); +} +``` + +> **Caution:** การเรียกเครือข่ายภายใน handler จะบล็อกเธรดการบันทึก; สำหรับหน้าใหญ่ควรทำให้ handler เป็นแบบอะซิงโครนัส (พร้อมใช้งานในเวอร์ชัน Aspose ใหม่) + +### เปลี่ยนชื่อรายการใน ZIP +`ResourceInfo` มี `FileName` และ `Path` คุณสามารถเขียนทับเพื่อทำให้โครงสร้างแบนลงหรือเพิ่มคำนำหน้า: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Example: prepend "assets/" to every entry + info.Path = Path.Combine("assets", info.Path); + return base.HandleResource(info); +} +``` + +### ใช้ Output Storage แบบอื่น +`OutputStorage` สามารถเป็น `FileSystemStorage` หากคุณต้องการบันทึกเป็นโฟลเดอร์แทน ZIP เพียงตั้งค่า `SaveToZipArchive = false` แล้วชี้ `OutputStorage` ไปยังพาธไดเรกทอรี + +## เคล็ดลับระดับมืออาชีพ & สิ่งที่ควรระวัง + +- **อย่าลืม dispose** `HtmlDocument` หากคุณเปิดหลายหน้าในลูป; มิฉะนั้นอาจเกิดการรั่วของทรัพยากรเนทีฟ +- **การใช้หน่วยความจำ:** การบันทึกหน้าขนาดใหญ่ลง `MemoryStream` อาจทำให้ RAM พุ่งสูง สำหรับอาร์ไคฟ์หลายเมกะไบต์ ควรสตรีมโดยตรงไปยังไฟล์ (`FileStream`) แทน +- **การเข้ารหัสอักขระ:** Aspose.HTML เคารพแท็ก `` หากหน้าแหล่งใช้การเข้ารหัสที่ไม่ทั่วไป ให้ตรวจสอบว่า HTML ที่ได้แสดงผลถูกต้องหลังการสกัด +- **การทดสอบ:** เปิด ZIP ที่สร้างขึ้นในเบราว์เซอร์ (ลาก `index.html` ออก) เพื่อตรวจสอบว่าทรัพยากรทั้งหมดโหลดได้ หากรูปหายไป แสดงว่า `HandleResource` ของคุณอาจคืนสตรีมเปล่า + +## สรุป + +เราได้อธิบาย **วิธีใช้ handler** เพื่อดักจับทรัพยากรภายนอก, แสดง **load html from url**, สร้าง **custom resource handler**, และสุดท้าย **save webpage as zip**—ซึ่งเทียบเท่ากับ **create zip from html** ด้วยไม่กี่บรรทัดของ C# รูปแบบนี้สามารถขยายได้: แทนที่ `MemoryStream` เปล่าด้วยตัวดาวน์โหลดจริง, เปลี่ยนเป้าหมายการบันทึก, หรือฝังตรรกะนี้ใน Web API ที่ส่ง ZIP ตามคำขอ + +--- + +### ต่อไปคืออะไร? + +- **การประมวลผลเป็นชุด:** วนลูปรายการ URL และสร้าง ZIP แยกตามหน้า +- **การปรับแต่งการบีบอัด:** ใช้ `ZipSaveOptions` เพื่อกำหนดระดับการบีบอัดสำหรับการดาวน์โหลดที่เร็วขึ้น +- **การรวมกับ ASP.NET Core:** ส่ง `MemoryStream` กลับเป็น `FileResult` เพื่อให้ผู้ใช้ดาวน์โหลดอาร์ไคฟ์โดยตรงจาก endpoint +- **สำรวจฟีเจอร์อื่นของ Aspose.HTML:** การแปลงเป็น PDF, การจัดการ DOM, หรือการเรนเดอร์แบบ headless + +มีคำถามเกี่ยวกับกรณีการใช้งานเฉพาะ—เช่นต้องการเก็บ JavaScript หรือจัดการหน้าที่ต้องการการยืนยันตัวตน? แสดงความคิดเห็นด้านล่างได้เลย; ยินดีช่วยเจาะลึกเพิ่มเติม ขอให้สนุกกับการเขียนโค้ด! + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/thai/net/rendering-html-documents/_index.md b/html/thai/net/rendering-html-documents/_index.md index 8c40fdd0fd..ecc52947ef 100644 --- a/html/thai/net/rendering-html-documents/_index.md +++ b/html/thai/net/rendering-html-documents/_index.md @@ -96,6 +96,9 @@ Aspose.HTML สำหรับ .NET ถือเป็นตัวเลือ ### [เรนเดอร์ HTML เป็น PDF ด้วย Aspose.HTML – คู่มือแบบขั้นตอน](./render-html-to-pdf-with-aspose-html-step-by-step-guide/) เรียนรู้วิธีการเรนเดอร์ไฟล์ HTML เป็น PDF ด้วย Aspose.HTML สำหรับ .NET อย่างละเอียดในคู่มือขั้นตอนนี้! +### [วิธีเรนเดอร์ HTML เป็น PNG ใน C# – คู่มือแบบขั้นตอน](./how-to-render-html-as-png-in-c-step-by-step-guide/) +เรียนรู้ขั้นตอนการเรนเดอร์ไฟล์ HTML เป็น PNG ด้วย C# อย่างละเอียดในคู่มือแบบขั้นตอนนี้! + {{< /blocks/products/pf/tutorial-page-section >}} {{< /blocks/products/pf/main-container >}} diff --git a/html/thai/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md b/html/thai/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..50dcd00c06 --- /dev/null +++ b/html/thai/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md @@ -0,0 +1,222 @@ +--- +category: general +date: 2026-02-25 +description: วิธีแปลง HTML เป็น PNG ใน C# ด้วย Aspose.HTML. เรียนรู้การแปลง HTML เป็นภาพ, + บันทึก HTML เป็น PNG, และสร้าง PNG จาก HTML อย่างรวดเร็ว. +draft: false +keywords: +- how to render html +- convert html to image +- save html as png +- create png from html +- generate png from html +language: th +og_description: วิธีแปลง HTML เป็น PNG ใน C# ด้วย Aspose.HTML. ทำตามบทเรียนนี้เพื่อแปลง + HTML เป็นภาพ, บันทึก HTML เป็น PNG, และสร้าง PNG จาก HTML. +og_title: วิธีแปลง HTML เป็น PNG ใน C# – คู่มือฉบับสมบูรณ์ +tags: +- C# +- Aspose.HTML +- Image Rendering +title: วิธีเรนเดอร์ HTML เป็น PNG ใน C# – คู่มือแบบขั้นตอนต่อขั้นตอน +url: /th/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# วิธีแปลง HTML เป็น PNG ใน C# – คู่มือขั้นตอนโดยละเอียด + +เคยสงสัย **วิธีแปลง HTML** ให้เป็นไฟล์ PNG โดยตรงโดยไม่ต้องเปิดเบราว์เซอร์หรือไม่? บางทีคุณอาจต้องการฝังภาพย่อของหน้าเว็บในอีเมล, หรือกำลังสร้างบริการสร้างภาพย่อสำหรับ CMS. ไม่ว่ากรณีใด ปัญหาก็สรุปได้ว่าเป็นการแปลง markup ให้เป็น bitmap ที่คุณสามารถจัดเก็บหรือให้บริการได้ + +ในบทเรียนนี้คุณจะได้เห็นโซลูชันที่พร้อมใช้งานและรันได้ทันทีที่ **แปลง HTML เป็นภาพ** ด้วย Aspose.HTML for .NET. เราจะพูดถึงวิธี **บันทึก HTML เป็น PNG**, **สร้าง PNG จาก HTML**, และแม้กระทั่ง **สร้าง PNG จาก HTML** พร้อมฟอนต์และขนาดที่กำหนดเอง. ไม่มีการอ้างอิงที่คลุมเครือ—เพียงโค้ดที่คุณคัดลอก‑วางได้, พร้อมคำอธิบายว่าทำไมบรรทัดนั้นสำคัญ. + +## สิ่งที่คุณต้องเตรียม + +- .NET 6 (หรือ .NET runtime เวอร์ชันใหม่ใดก็ได้) – API ทำงานเดียวกันบน .NET Framework 4.6+ +- Visual Studio 2022 หรือ VS Code – ตามที่คุณถนัด +- แพ็กเกจ NuGet **Aspose.HTML** (`Aspose.HTML.NET`) – ติดตั้งครั้งเดียวแล้วพร้อมใช้งาน +- โฟลเดอร์ที่สามารถเขียนไฟล์ PNG ได้ (เช่น `C:\Temp\Images`) + +เท่านี้แค่นั้น. ไม่ต้องมีไบนารีเพิ่มเติม, ไม่ต้องใช้เว็บเซอร์วิสภายนอก, และไม่มีไฟล์กำหนดค่าที่ซ่อนอยู่. + +## ขั้นตอนที่ 1: ติดตั้ง Aspose.HTML ผ่าน NuGet + +แรกสุดให้เพิ่มไลบรารีเข้าไปในโปรเจกต์ของคุณ. เปิดเทอร์มินัลในโฟลเดอร์โซลูชันและรัน: + +```bash +dotnet add package Aspose.HTML.NET +``` + +*เคล็ดลับ:* หากคุณใช้ Visual Studio, คลิกขวาที่ **Dependencies → Manage NuGet Packages**, ค้นหา “Aspose.HTML”, แล้วคลิก **Install**. วิธีนี้จะทำให้คุณเข้าถึงคลาส `HtmlDocument`, `ImageRenderingOptions`, และคลาสอื่น ๆ ที่เราจะใช้. + +## ขั้นตอนที่ 2: ตั้งค่าตัวเลือกการเรนเดอร์ (ขนาด, สไตล์, และฟอนต์) + +ก่อนที่เราจะส่ง markup ใด ๆ ให้กับ renderer, เราต้องกำหนดว่าภาพควรมีขนาดเท่าไหร่และต้องการรักษา style ของฟอนต์แบบใด. อ็อบเจ็กต์ `ImageRenderingOptions` ให้คุณปรับความกว้าง, ความสูง, และแม้กระทั่งบังคับให้เรนเดอร์แบบ bold/italic. + +```csharp +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +// Configure image rendering options – width, height, and font style +ImageRenderingOptions renderingOptions = new ImageRenderingOptions +{ + Width = 800, // Desired image width in pixels + Height = 600, // Desired image height in pixels + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic // Preserve bold & italic +}; +``` + +**ทำไมจึงสำคัญ:** +- **Width/Height** กำหนดมิติพิกเซลสุดท้าย; หากละเว้นค่าเหล่านี้เอนจินจะคาดเดาจากโครงสร้าง HTML ซึ่งอาจทำให้ภาพถูกตัดส่วนที่ไม่คาดคิด. +- **FontStyle** ทำให้แท็ก `` หรือ `` คงความเน้นเมื่อแปลงเป็น raster. + +## ขั้นตอนที่ 3: โหลด HTML Markup ของคุณ + +คุณสามารถโหลด HTML จากสตริง, ไฟล์, หรือ URL. เพื่อความง่าย เราจะฝังโค้ดสั้น ๆ ลงในโปรแกรมโดยตรง. สังเกต CSS แบบอินไลน์ที่กำหนดฟอนต์‑แฟมิลี – Aspose.HTML เคารพมาตรฐาน CSS ของเว็บ, ดังนั้นคุณจะได้ผลลัพธ์ที่ตรงตามที่คาด. + +```csharp +using Aspose.Html; + +// Create an empty HTML document +HtmlDocument htmlDoc = new HtmlDocument(); + +// Load simple markup – you could also use htmlDoc.Open("path/to/file.html") +htmlDoc.Open("Hello, world!
"); +``` + +**เคล็ดลับกรณีขอบ:** หาก markup ของคุณอ้างอิงทรัพยากรภายนอก (รูปภาพ, ไฟล์ CSS) ให้แน่ใจว่า URL เหล่านั้นเข้าถึงได้จากเครื่องที่รันโค้ด, หรือฝังเป็น data‑URI เพื่อหลีกเลี่ยงลิงก์เสีย. + +## ขั้นตอนที่ 4: เรนเดอร์ HTML ไปเป็นสตรีม PNG + +นี่คือหัวใจของ **วิธีแปลง HTML** – เราเรียก `RenderToStream`, ส่งสตรีมผลลัพธ์และตัวเลือกที่กำหนดไว้ก่อนหน้า. เมธอดนี้ทำงานหนักทั้งหมด: layout, CSS cascade, การแทนที่ฟอนต์, และการ rasterization. + +```csharp +using System.IO; + +// Choose an output path – replace with your own directory +string outputPath = @"C:\Temp\Images\output.png"; + +using (FileStream outputStream = File.OpenWrite(outputPath)) +{ + // Render the HTML document into the PNG file + htmlDoc.RenderToStream(outputStream, renderingOptions); +} +``` + +หลังจากบล็อก `using` สิ้นสุด, `output.png` จะมีภาพขนาด 800 × 600 พิกเซลของย่อหน้าที่เราโหลด. เปิดไฟล์ด้วยโปรแกรมดูภาพใดก็ได้เพื่อยืนยันผลลัพธ์. + +### ผลลัพธ์ที่คาดหวัง + +คุณควรเห็นแคนวาสสีขาวสะอาดพร้อมข้อความ **“Hello, world!”** ที่เรนเดอร์ด้วยฟอนต์ Arial, ตัวหนาและตัวเอียง, ขนาด 24 pt. มิติของภาพตรงกับค่า 800 × 600 ที่เราตั้งไว้. + +## ขั้นตอนที่ 5: ตรวจสอบและจัดการกับปัญหาที่พบบ่อย + +### 5.1 ตรวจสอบว่าไฟล์มีอยู่จริง + +การตรวจสอบอย่างรวดเร็วช่วยป้องกันความล้มเหลวแบบเงียบ: + +```csharp +if (File.Exists(outputPath)) +{ + Console.WriteLine($"✅ PNG created successfully at {outputPath}"); +} +else +{ + Console.WriteLine("❌ Something went wrong – PNG not found."); +} +``` + +### 5.2 จัดการกับฟอนต์ที่หายไป + +หากเครื่องเป้าหมายไม่มีฟอนต์ที่ร้องขอ, Aspose.HTML จะใช้ฟอนต์ sans‑serif ทั่วไปแทน. เพื่อความสม่ำเสมอ, คุณสามารถ: + +- ฝังไฟล์ฟอนต์ด้วยกฎ `@font-face` ใน HTML, **หรือ** +- ลงทะเบียนฟอนต์ผ่านโค้ดก่อนทำการเรนเดอร์. + +```csharp +// Example of registering a custom TrueType font +htmlDoc.Fonts.AddFontFile(@"C:\Fonts\OpenSans-Regular.ttf"); +``` + +### 5.3 เรนเดอร์หน้าใหญ่ + +เมื่อสร้างภาพย่อสำหรับสกรีนช็อตเต็มหน้า, ควรใส่ใจการใช้หน่วยความจำ. คุณสามารถลดขนาดหลังจากเรนเดอร์, หรือกำหนด `renderingOptions.Width`/`Height` ให้เป็นขนาดเล็กลงและให้ Aspose.HTML จัดการสเกลให้. + +## ตัวอย่างโปรแกรมเต็มรูปแบบ + +ด้านล่างเป็นโปรแกรมสมบูรณ์ที่คุณสามารถวางลงในแอปพลิเคชันคอนโซลและรันได้ทันที. + +```csharp +// ----------------------------------------------------------- +// How to render HTML as PNG – Complete, runnable example +// ----------------------------------------------------------- +using System; +using System.IO; +using Aspose.Html; +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +class Program +{ + static void Main() + { + // 1️⃣ Configure rendering options + ImageRenderingOptions renderingOptions = new ImageRenderingOptions + { + Width = 800, + Height = 600, + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic + }; + + // 2️⃣ Load HTML markup + HtmlDocument htmlDoc = new HtmlDocument(); + htmlDoc.Open("Hello, world!
"); + + // 3️⃣ Define output path + string outputPath = @"C:\Temp\Images\output.png"; + + // 4️⃣ Render to PNG + using (FileStream outputStream = File.OpenWrite(outputPath)) + { + htmlDoc.RenderToStream(outputStream, renderingOptions); + } + + // 5️⃣ Verify the result + Console.WriteLine(File.Exists(outputPath) + ? $"✅ PNG saved at {outputPath}" + : "❌ Failed to create PNG"); + } +} +``` + +รันโปรแกรม (`dotnet run`), แล้วเปิด `C:\Temp\Images\output.png`. หากทุกอย่างทำงานเรียบร้อย, คุณเพิ่ง **แปลง HTML เป็นภาพ** และ **บันทึก HTML เป็น PNG** ด้วยโค้ด C# เพียว ๆ. + +## คำถามที่พบบ่อย + +| คำถาม | คำตอบ | +|----------|--------| +| **ฉันสามารถเรนเดอร์หน้าเว็บเต็มพร้อม CSS/JS ภายนอกได้หรือไม่?** | ได้ – เพียงเรียก `htmlDoc.Open("https://example.com")`. เอนจินจะดาวน์โหลดทรัพยากรที่เชื่อมโยง, แต่คุณต้องมีการเชื่อมต่ออินเทอร์เน็ต. | +| **ฟอร์แมตอื่น ๆ ที่รองรับนอกจาก PNG มีอะไรบ้าง?** | `ImageRenderingOptions` รองรับ JPEG, BMP, GIF, และ TIFF. เปลี่ยนนามสกุลไฟล์และตั้งค่า `ImageFormat` ตามต้องการ. | +| **มีขีดจำกัดขนาดภาพหรือไม่?** | โดยเทคนิคคุณสามารถทำได้หลายพันพิกเซล, แต่ขนาดใหญ่มากอาจทำให้หน่วยความจำเต็ม. พิจารณาเรนเดอร์เป็นส่วนย่อย (tiles) สำหรับผลลัพธ์ความละเอียดสูงมาก. | +| **จะจัดการ DPI สำหรับภาพคุณภาพพิมพ์อย่างไร?** | ตั้งค่า `renderingOptions.DpiX` และ `renderingOptions.DpiY` (ค่าเริ่มต้นคือ 96). DPI สูงจะให้ผลลัพธ์คมชัดขึ้นสำหรับการพิมพ์. | +| **ต้องซื้อไลเซนส์สำหรับ Aspose.HTML หรือไม่?** | รุ่นประเมินผลฟรีทำงานพร้อมลายน้ำ. สำหรับการใช้งานจริง, ควรซื้อไลเซนส์เพื่อเอาลายน้ำออกและเปิดฟีเจอร์เต็ม. | + +## ขั้นตอนต่อไปและหัวข้อที่เกี่ยวข้อง + +- **แปลง HTML เป็น JPEG** – เปลี่ยนนามสกุลไฟล์และตั้งค่า `renderingOptions.ImageFormat = ImageFormat.Jpeg` เพิ่มเติม. +- **การประมวลผลแบบแบตช์** – วนลูปรายการ URL และสร้างภาพย่อสำหรับแต่ละรายการ. +- **การฝังฟอนต์** – เรียนรู้วิธีใช้ `@font-face` ใน markup เพื่อให้ได้ไทโปกราฟีที่สมบูรณ์. +- **การจัดวางขั้นสูง** – ทดลองใช้ `PageSize`, `Margin`, และ `BackgroundColor` เพื่อสร้างลุคที่กำหนดเอง. + +อย่าลังเลที่จะปรับขนาด, ทดลอง snippet HTML ต่าง ๆ, หรือรวมโค้ดนี้เข้าไปใน Web API ที่ให้บริการพรีวิว PNG แบบเรียลไทม์. ท้องฟ้าคือขอบเขตเมื่อคุณรู้ **วิธีแปลง HTML** ด้วยโปรแกรม. + +--- + + + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/turkish/net/html-extensions-and-conversions/_index.md b/html/turkish/net/html-extensions-and-conversions/_index.md index acb3bd2f63..ec88820d3a 100644 --- a/html/turkish/net/html-extensions-and-conversions/_index.md +++ b/html/turkish/net/html-extensions-and-conversions/_index.md @@ -87,6 +87,8 @@ Aspose.HTML for .NET kullanarak HTML dosyasını ZIP arşivine kaydetmeyi adım Aspose.HTML for .NET ile C#'ta bir web sayfasını tek HTML dosyası olarak kaydedin. Adım adım kılavuz ve örnek kodlar. ### [Aspose HTML Kaydetme Seçenekleri: C#'ta HTML'yi Akışa Kaydet](./aspose-html-save-options-save-html-to-stream-in-c/) Aspose.HTML for .NET kullanarak C# ile HTML'yi akışa kaydetmeyi adım adım öğrenin. +### [Aspose.HTML'de Handler Kullanımı – HTML Yükle ve ZIP Olarak Kaydet](./how-to-use-handler-in-aspose-html-load-html-save-as-zip/) +Aspose.HTML for .NET ile bir handler aracılığıyla HTML dosyasını yükleyin ve ZIP arşivine kaydedin. Adım adım rehber. {{< /blocks/products/pf/tutorial-page-section >}} diff --git a/html/turkish/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md b/html/turkish/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md new file mode 100644 index 0000000000..bc881d7156 --- /dev/null +++ b/html/turkish/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md @@ -0,0 +1,182 @@ +--- +category: general +date: 2026-02-25 +description: Handler'ı kullanarak URL'den HTML yükleme ve Aspose.HTML ile web sayfasını + zip olarak kaydetme – eksiksiz bir C# adım adım rehberi. +draft: false +keywords: +- how to use handler +- load html from url +- custom resource handler +- save webpage as zip +- create zip from html +language: tr +og_description: Handler'ı kullanarak URL'den HTML yükleme ve Aspose.HTML ile web sayfasını + zip olarak kaydetme. Tam C# iş akışını dakikalar içinde öğrenin. +og_title: Aspose.HTML'de işleyiciyi nasıl kullanılır – HTML'i yükle, ZIP olarak kaydet +tags: +- Aspose.HTML +- C# +- Web Scraping +title: Aspose.HTML'de işleyiciyi nasıl kullanılır – HTML'yi yükle, ZIP olarak kaydet +url: /tr/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Aspose.HTML'de Handler Nasıl Kullanılır – HTML'i Yükle, ZIP Olarak Kaydet + +Bir .NET uygulamasında bir web sayfasını çekerken **handler nasıl kullanılır** diye merak ettiniz mi? Belki `HtmlDocument.Open` ile HTML'i aldınız, ama resimler, CSS ve fontlar bir anda kayboldu. Bu yaygın bir sorun—kaynaklar, Aspose.HTML'e ne yapması gerektiğini söylemediğiniz sürece kaybolur. + +Bu öğreticide bir URL'den HTML yüklemeyi, **özel bir kaynak handler'ı** bağlamayı ve sonunda **web sayfasını zip olarak kaydetmeyi** adım adım göstereceğiz, böylece tek bir taşınabilir arşiv elde edeceksiniz. Sonunda, herhangi bir projeye ekleyebileceğiniz çalışır bir C# kod parçacığı ve ileride baş ağrısı yaşamamanız için birkaç ipucu sahibi olacaksınız. + +## Gereksinimler + +- .NET 6+ (API .NET Core ve .NET Framework'te de çalışır) +- Aspose.HTML for .NET (NuGet paketi `Aspose.HTML`) +- Biraz C# deneyimi (daha önce `Console.WriteLine` yazdıysanız sorun yok) + +Ekstra araç, dış hizmet gerekmez—sadece kütüphane ve arşivlemek istediğiniz bir URL. + + + +## Adım 1: URL'den HTML Yükle + +Her web‑scraping akışının ilk adımı sayfa kaynağını almaktır. Aspose.HTML bunu tek satırda yapar, ancak **url'den html yükleme** işlemini yerleşik ağ yığınıyla yaptığımızı unutmayın. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +// 1️⃣ Load the page you want to archive +HtmlDocument htmlDoc = new HtmlDocument(); +htmlDoc.Open("https://example.com"); // replace with any public URL +``` + +> **Neden önemli:** `HtmlDocument.Open` işaretlemeyi *ve* göreli URL'leri dahili olarak çözer, fakat dış varlıkları otomatik olarak saklamaz. Bu yüzden daha sonra bir handler'a ihtiyacımız var. + +## Adım 2: Özel Bir Kaynak Handler'ı Oluştur + +Şimdi işin özü—**handler nasıl kullanılır** sorusunun cevabı: her dış kaynak isteğini (resimler, CSS, fontlar vb.) yakalamak. `ResourceHandler` sınıfını alt sınıf olarak genişlettiğinizde her varlık için geri dönen akış üzerinde tam kontrol elde edersiniz. + +```csharp +// 2️⃣ Define your own handler (optional but powerful) +public class MyResourceHandler : ResourceHandler +{ + // Called for each external resource the document needs + public override Stream HandleResource(ResourceInfo info) + { + // Here you could download the file, cache it, or rewrite it. + // For this demo we simply return an empty stream – Aspose will + // still create the entry in the ZIP, keeping the folder structure. + return new MemoryStream(); + } +} +``` + +> **Pro ipucu:** Gerçek byte'ları (`HttpClient.GetStreamAsync(info.Uri)`) indirip o akışı döndürmek isteyebilirsiniz. Bu sayede kaydedilen ZIP, boş yer tutucular yerine gerçek resimleri içerir. + +## Adım 3: Kaydetme Seçeneklerini Yapılandır ve Handler'ı Bağla + +Handler hazır olduğunda, Aspose.HTML'e her şeyi nasıl paketleyeceğini söyleriz. `HtmlSaveOptions` sınıfı `SaveToZipArchive` anahtarını açmanıza ve `MyResourceHandler`'ınızı eklemenize olanak tanır. + +```csharp +// 3️⃣ Set up saving options – this is where we **save webpage as zip** +HtmlSaveOptions saveOptions = new HtmlSaveOptions +{ + // Attach our custom handler – new API as of v22.10 + OutputStorage = new MyResourceHandler(), + + // Instruct Aspose to bundle HTML + resources into a single ZIP file + SaveToZipArchive = true +}; +``` + +> **Açıklama:** `OutputStorage` handler örneğini alan özelliktir. Kaydedici DOM'u dolaşırken her dış bağlantı için `HandleResource` metodunu çağırır. `SaveToZipArchive` true olduğunda, kaydedici her döndürülen akışı orijinal yola karşılık gelen bir ZIP girdisine yazar. + +## Adım 4: Belgeyi Memory Stream'e Kaydet + +Doğrudan diske yazabiliriz, ancak her şeyi bellek içinde tutmak kodu ASP.NET, Azure Functions veya geçici dosya istemediğiniz her yerde kullanılabilir kılar. İşte **html'den zip oluşturma** adımı. + +```csharp +// 4️⃣ Save everything – HTML + resources – into a MemoryStream +using (MemoryStream outputStream = new MemoryStream()) +{ + htmlDoc.Save(outputStream, saveOptions); + + // At this point outputStream holds a valid ZIP archive. + // For demo purposes we write it to the file system: + File.WriteAllBytes("example_page.zip", outputStream.ToArray()); +} +``` + +### Beklenen Sonuç + +- `example_page.zip` projenizin klasöründe oluşur. +- ZIP içinde `index.html` ve bir klasör yapısı (`images/`, `css/`, vb.) bulunur. +- Demo handler'ımız boş akışlar döndürse de ZIP yapısı orijinal sayfayı yansıtır—gerçek bir indirici eklemek için mükemmeldir. + +## Yaygın Varyasyonlar ve Kenar Durumları + +### URL Yerine Yerel Dosya Yükleme +**url'den html yükleme** benzeri bir yol kullanarak diskteki dosyaları da açabilirsiniz; sadece `htmlDoc.Open("https://example.com")` yerine `htmlDoc.Open(@"C:\path\to\file.html")` yazın. Geri kalan akış aynı kalır. + +### Gerçek Kaynakları Saklama +Resimleri gerçekten eklemek için `HandleResource` metodunu şu şekilde değiştirin: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Download the resource using HttpClient + HttpClient client = new HttpClient(); + var data = client.GetByteArrayAsync(info.Uri).Result; + return new MemoryStream(data); +} +``` + +> **Uyarı:** Handler içindeki ağ çağrıları kaydetme iş parçacığını engeller; büyük sayfalar için handler'ı asenkron hâle getirmeyi (yeni Aspose sürümlerinde mevcut) düşünün. + +### ZIP Girdi İsimlerini Değiştirme +`ResourceInfo` içinde `FileName` ve `Path` bulunur. Hiyerarşiyi düzleştirmek veya bir önek eklemek için bunları yeniden yazabilirsiniz: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Example: prepend "assets/" to every entry + info.Path = Path.Combine("assets", info.Path); + return base.HandleResource(info); +} +``` + +### Farklı Bir Output Storage Kullanma +`OutputStorage` aynı zamanda bir `FileSystemStorage` olabilir; bu sayede ZIP yerine bir klasör oluşturursunuz. `SaveToZipArchive = false` yapın ve `OutputStorage`'ı bir dizin yoluna yönlendirin. + +## Pro İpuçları ve Tuzaklar + +- **Dispose etmeyi unutmayın**; döngü içinde çok sayıda sayfa açıyorsanız `HtmlDocument` nesnesini serbest bırakmazsanız yerel kaynak sızıntısı oluşur. +- **Bellek kullanımı:** Büyük sayfaları `MemoryStream`'e kaydetmek RAM'i şişirebilir. Çok megabaytlık arşivler için doğrudan bir dosyaya (`FileStream`) akış yapın. +- **Karakter kodlaması:** Aspose.HTML `` etiketine saygı gösterir. Kaynak sayfa nadir bir kodlama kullanıyorsa, çıkarılan HTML'nin doğru render edildiğini doğrulayın. +- **Test:** Oluşturulan ZIP'i bir tarayıcıda açın ( `index.html` dosyasını sürükleyin) ve tüm kaynakların çözüldüğünden emin olun. Resimler eksikse, `HandleResource` muhtemelen boş bir akış döndürdü demektir. + +## Özet + +**handler nasıl kullanılır** sorusunu dış kaynakları yakalamak için ele aldık, **url'den html yükleme** gösterdik, **özel bir kaynak handler'ı** oluşturduk ve sonunda **web sayfasını zip olarak kaydetme** işlemini yaptık—yani birkaç satır C# ile **html'den zip oluşturma** gerçekleştirdik. Bu desen ölçeklenebilir: boş `MemoryStream` yerine gerçek bir indirici koyabilir, çıkış hedefini değiştirebilir veya mantığı bir web API'sine entegre ederek ZIP'i isteğe bağlı olarak döndürebilirsiniz. + +--- + +### Sıradaki Adımlar? + +- **Toplu işleme:** URL listesi üzerinde döngü kurup her sayfa için bir ZIP üretin. +- **Sıkıştırma ayarları:** `ZipSaveOptions` ile sıkıştırma seviyesini ayarlayarak daha hızlı indirmeler elde edin. +- **ASP.NET Core entegrasyonu:** `MemoryStream`'i bir `FileResult` olarak döndürün, böylece kullanıcılar arşivi doğrudan bir web uç noktasından indirebilir. +- **Diğer Aspose.HTML özelliklerini keşfedin:** PDF dönüşümü, DOM manipülasyonu veya başsız render. + +Belirli bir kullanım senaryosu hakkında sorularınız mı var—örneğin JavaScript'i korumak ya da kimlik doğrulamalı sayfaları işlemek? Aşağıya yorum bırakın; daha derine inmeye hazırım. İyi kodlamalar! + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/turkish/net/rendering-html-documents/_index.md b/html/turkish/net/rendering-html-documents/_index.md index d90f5dbf69..140e766cb9 100644 --- a/html/turkish/net/rendering-html-documents/_index.md +++ b/html/turkish/net/rendering-html-documents/_index.md @@ -84,6 +84,8 @@ C# ve Aspose.HTML kullanarak HTML içeriğini görüntü formatına dönüştür Aspose.HTML for .NET ile C# kullanarak HTML'den görüntü oluşturmayı adım adım öğrenin. ### [Aspose.HTML ile HTML'yi PDF'ye Dönüştürme – Adım Adım Kılavuz](./render-html-to-pdf-with-aspose-html-step-by-step-guide/) Aspose.HTML for .NET kullanarak HTML dosyalarını PDF formatına dönüştürmeyi adım adım öğrenin. +### [C#'ta HTML'yi PNG Olarak İşleme – Adım Adım Kılavuz](./how-to-render-html-as-png-in-c-step-by-step-guide/) +C# kullanarak HTML'yi PNG'ye dönüştürmeyi adım adım öğrenin. Örnek kodlar ve pratik ipuçlarıyla rehberiniz burada. {{< /blocks/products/pf/tutorial-page-section >}} diff --git a/html/turkish/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md b/html/turkish/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..225b46a1c1 --- /dev/null +++ b/html/turkish/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md @@ -0,0 +1,222 @@ +--- +category: general +date: 2026-02-25 +description: Aspose.HTML kullanarak C#'de HTML'yi PNG olarak nasıl render edersiniz. + HTML'yi görüntüye dönüştürmeyi, HTML'yi PNG olarak kaydetmeyi ve HTML'den hızlıca + PNG oluşturmayı öğrenin. +draft: false +keywords: +- how to render html +- convert html to image +- save html as png +- create png from html +- generate png from html +language: tr +og_description: C#'ta Aspose.HTML ile HTML'yi PNG olarak nasıl render edebileceğinizi + öğrenin. HTML'yi görüntüye dönüştürmek, HTML'yi PNG olarak kaydetmek ve HTML'den + PNG oluşturmak için bu öğreticiyi izleyin. +og_title: C#'ta HTML'yi PNG olarak nasıl işlersiniz – Tam Kılavuz +tags: +- C# +- Aspose.HTML +- Image Rendering +title: C#'ta HTML'yi PNG olarak nasıl render'layabilirsiniz – Adım Adım Rehber +url: /tr/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# HTML'yi PNG olarak C#'de nasıl render'lamak – Adım Adım Kılavuz + +Hiç **HTML'yi nasıl render'layacağınızı** bir tarayıcıyla uğraşmadan doğrudan bir PNG dosyasına dönüştürmeyi merak ettiniz mi? Belki bir e-postada bir web sayfasının küçük bir anlık görüntüsünü eklemeniz gerekiyor ya da bir CMS için bir küçük resim hizmeti oluşturuyorsunuz. Her iki durumda da sorun, işaretlemeyi saklayabileceğiniz veya sunabileceğiniz bir bitmap'e dönüştürmek üzerine. + +Bu öğreticide, Aspose.HTML for .NET kullanarak **HTML'yi görüntüye dönüştürür** eksiksiz, hemen çalıştırılabilir bir çözüm göreceksiniz. Ayrıca **HTML'yi PNG olarak kaydet**, **HTML'den PNG oluştur** ve hatta özel yazı tipleri ve boyutlarla **HTML'den PNG üret** konularına da değineceğiz. Belirsiz referanslar yok—sadece kopyalayıp yapıştırabileceğiniz kod ve her satırın neden önemli olduğuna dair açıklamalar. + +## Gereksinimler + +- .NET 6 (veya herhangi bir güncel .NET çalışma zamanı) – API, .NET Framework 4.6+ üzerinde aynı şekilde çalışır. +- Visual Studio 2022 veya VS Code – hangisini tercih ederseniz. +- **Aspose.HTML** NuGet paketi (`Aspose.HTML.NET`) – bir kez kurun, hazırsınız. +- Çıktı PNG'si için yazılabilir bir klasör (ör. `C:\Temp\Images`). + +## Adım 1: Aspose.HTML'i NuGet üzerinden kurun + +İlk olarak, kütüphaneyi projenize ekleyin. Çözüm klasörünüzde terminali açın ve şu komutu çalıştırın: + +```bash +dotnet add package Aspose.HTML.NET +``` + +*Pro tip:* Visual Studio'daysanız, **Dependencies → Manage NuGet Packages** üzerine sağ tıklayın, “Aspose.HTML” için arama yapın ve **Install**'a tıklayın. Bu, `HtmlDocument`, `ImageRenderingOptions` ve kullanacağımız diğer sınıflara erişmenizi sağlar. + +## Adım 2: Rendering Seçeneklerini Ayarlama (boyut, stil ve yazı tipleri) + +Renderlayıcıya herhangi bir işaretleme göndermeden önce, resmin ne kadar büyük olacağını ve hangi yazı tipi stillerini korumak istediğimizi belirleriz. `ImageRenderingOptions` nesnesi, genişlik, yükseklik ayarlamanıza ve hatta kalın/eğik renderlamayı zorlamanıza olanak tanır. + +```csharp +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +// Configure image rendering options – width, height, and font style +ImageRenderingOptions renderingOptions = new ImageRenderingOptions +{ + Width = 800, // Desired image width in pixels + Height = 600, // Desired image height in pixels + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic // Preserve bold & italic +}; +``` + +**Neden önemli:** +- **Width/Height** son piksel boyutlarını belirler; bunları atladığınızda motor HTML düzenine göre tahmin yapar ve bu beklenmedik kırpmalara yol açabilir. +- **FontStyle**, rasterleştirildiğinde `` veya `` etiketlerinin görsel vurgusunu korumasını sağlar. + +## Adım 3: HTML İşaretlemenizi Yükleyin + +HTML'yi bir dizeden, dosyadan veya URL'den yükleyebilirsiniz. Basitlik açısından, kod içinde doğrudan küçük bir snippet gömeceğiz. Yazı tipi ailesini ayarlayan satır içi CSS'ye dikkat edin – Aspose.HTML standart web CSS'ine uyar, böylece doğru bir render alırsınız. + +```csharp +using Aspose.Html; + +// Create an empty HTML document +HtmlDocument htmlDoc = new HtmlDocument(); + +// Load simple markup – you could also use htmlDoc.Open("path/to/file.html") +htmlDoc.Open("Hello, world!
"); +``` + +**Köşe durumları ipucu:** İşaretlemeniz dış kaynaklara (görseller, CSS dosyaları) referans veriyorsa, bu URL'lerin kodu çalıştıran makineden erişilebilir olduğundan emin olun veya kırık bağlantıları önlemek için veri‑URI'lar olarak gömün. + +## Adım 4: HTML'yi PNG Akışına Renderlayın + +Şimdi **HTML'yi nasıl render'layacağınızın** özü geliyor – `RenderToStream` metodunu çağırıyoruz, çıktı akışını ve önceden yapılandırdığımız seçenekleri geçiriyoruz. Metod, yerleşim, CSS kademesi, yazı tipi ikamesi ve rasterleştirme gibi tüm ağır işleri yapar. + +```csharp +using System.IO; + +// Choose an output path – replace with your own directory +string outputPath = @"C:\Temp\Images\output.png"; + +using (FileStream outputStream = File.OpenWrite(outputPath)) +{ + // Render the HTML document into the PNG file + htmlDoc.RenderToStream(outputStream, renderingOptions); +} +``` + +`using` bloğu bittiğinde, `output.png` yüklediğimiz paragrafın 800 × 600 piksel görüntüsünü içerecek. Sonucu doğrulamak için herhangi bir görüntü görüntüleyiciyle açın. + +### Beklenen Sonuç + +Arial, kalın ve eğik olarak, tam 24 pt boyutunda **“Hello, world!”** metniyle temiz beyaz bir tuval görmelisiniz. Görüntü boyutları, ayarladığımız 800 × 600 değerleriyle eşleşir. + +## Adım 5: Doğrulama ve Yaygın Tuzakları Ele Alma + +### 5.1 Dosyanın Var Olup Olmadığını Kontrol Etme + +Hızlı bir mantık kontrolü sessiz hataları önler: + +```csharp +if (File.Exists(outputPath)) +{ + Console.WriteLine($"✅ PNG created successfully at {outputPath}"); +} +else +{ + Console.WriteLine("❌ Something went wrong – PNG not found."); +} +``` + +### 5.2 Eksik Yazı Tipleriyle Baş Etme + +Hedef makinede istenen yazı tipi yoksa, Aspose.HTML genel bir sans‑serif'e geri döner. Tutarlılığı sağlamak için ya: + +- HTML'nizde bir `@font-face` kuralı kullanarak yazı tipi dosyasını gömün, **veya** +- Renderlamadan önce programatik olarak yazı tipini kaydedin. + +```csharp +// Example of registering a custom TrueType font +htmlDoc.Fonts.AddFontFile(@"C:\Fonts\OpenSans-Regular.ttf"); +``` + +### 5.3 Büyük Sayfaları Renderlamak + +Tam sayfa ekran görüntüleri için küçük resimler oluştururken bellek kullanımına dikkat edin. Renderlamadan sonra küçültebilir ya da `renderingOptions.Width`/`Height`'ı daha küçük bir boyuta ayarlayıp Aspose.HTML'in ölçeklendirmesini sağlayabilirsiniz. + +## Tam Çalışan Örnek + +Aşağıda, bir konsol uygulamasına ekleyip hemen çalıştırabileceğiniz eksiksiz program yer alıyor. + +```csharp +// ----------------------------------------------------------- +// How to render HTML as PNG – Complete, runnable example +// ----------------------------------------------------------- +using System; +using System.IO; +using Aspose.Html; +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +class Program +{ + static void Main() + { + // 1️⃣ Configure rendering options + ImageRenderingOptions renderingOptions = new ImageRenderingOptions + { + Width = 800, + Height = 600, + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic + }; + + // 2️⃣ Load HTML markup + HtmlDocument htmlDoc = new HtmlDocument(); + htmlDoc.Open("Hello, world!
"); + + // 3️⃣ Define output path + string outputPath = @"C:\Temp\Images\output.png"; + + // 4️⃣ Render to PNG + using (FileStream outputStream = File.OpenWrite(outputPath)) + { + htmlDoc.RenderToStream(outputStream, renderingOptions); + } + + // 5️⃣ Verify the result + Console.WriteLine(File.Exists(outputPath) + ? $"✅ PNG saved at {outputPath}" + : "❌ Failed to create PNG"); + } +} +``` + +Programı çalıştırın (`dotnet run`), ardından `C:\Temp\Images\output.png` dosyasını açın. Her şey sorunsuz ilerlediyse, saf C# kodu kullanarak **HTML'yi görüntüye dönüştürdünüz** ve **HTML'yi PNG olarak kaydettiniz**. + +## Sıkça Sorulan Sorular + +| Soru | Cevap | +|----------|--------| +| **Harici CSS/JS ile tam bir web sayfasını renderlayabilir miyim?** | Evet – sadece `htmlDoc.Open("https://example.com")` çağırın. Motor, bağlı kaynakları indirir, ancak ağ erişimine ihtiyacınız var. | +| **PNG dışındaki hangi formatlar destekleniyor?** | `ImageRenderingOptions` JPEG, BMP, GIF ve TIFF ile çalışır. Gerekirse dosya uzantısını değiştirin ve `ImageFormat`'ı ayarlayın. | +| **Görüntü boyutu için bir limit var mı?** | Teknik olarak birkaç bin piksele kadar çıkabilirsiniz, ancak çok büyük boyutlar belleği tüketebilir. Ultra‑yüksek çözünürlük çıktısı için parçalar halinde renderlamayı düşünün. | +| **Baskı kalitesinde görüntüler için DPI nasıl ayarlanır?** | `renderingOptions.DpiX` ve `renderingOptions.DpiY`'yi (varsayılan 96) ayarlayın. Daha yüksek DPI, baskı için daha keskin bir çıktı verir. | +| **Aspose.HTML için lisansa ihtiyacım var mı?** | Ücretsiz değerlendirme su işaretiyle çalışır. Üretim için lisans satın alarak işaretlemeyi kaldırıp tam özellikleri açabilirsiniz. | + +## Sonraki Adımlar ve İlgili Konular + +- **HTML'yi JPEG'e dönüştür** – dosya uzantısını değiştirin ve isteğe bağlı olarak `renderingOptions.ImageFormat = ImageFormat.Jpeg` ayarlayın. +- **Toplu işleme** – bir URL listesi üzerinde döngü kurarak her biri için küçük resimler oluşturun. +- **Yazı tiplerini gömme** – mükemmel tipografi için işaretlemenizde `@font-face` kullanımını öğrenin. +- **Gelişmiş yerleşim** – özel görünümler için `PageSize`, `Margin` ve `BackgroundColor` seçenekleriyle deney yapın. + +Boyutları istediğiniz gibi ayarlamaktan, farklı HTML snippet'leri denemekten veya bu snippet'i anlık PNG önizlemeleri sunan bir web API'sine entegre etmekten çekinmeyin. **HTML'yi programlı olarak nasıl render'layacağınızı** bildiğinizde sınır yoktur. + +--- + + + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/vietnamese/net/html-extensions-and-conversions/_index.md b/html/vietnamese/net/html-extensions-and-conversions/_index.md index 11dc3c7427..e5ead3fc66 100644 --- a/html/vietnamese/net/html-extensions-and-conversions/_index.md +++ b/html/vietnamese/net/html-extensions-and-conversions/_index.md @@ -111,6 +111,8 @@ Lưu một trang web thành một tệp HTML duy nhất bằng C# và Aspose.HTM Hướng dẫn chi tiết cách lưu tài liệu HTML vào tệp ZIP trong C# bằng Aspose.HTML, bao gồm ví dụ mã và tùy chọn cấu hình. ### [Aspose HTML Save Options: Lưu HTML vào Stream trong C#](./aspose-html-save-options-save-html-to-stream-in-c/) Hướng dẫn cách sử dụng Aspose.HTML để lưu HTML trực tiếp vào stream trong C#. +### [Cách sử dụng handler trong Aspose.HTML – Tải HTML, Lưu dưới dạng ZIP](./how-to-use-handler-in-aspose-html-load-html-save-as-zip/) +Hướng dẫn chi tiết cách sử dụng handler trong Aspose.HTML để tải tài liệu HTML và lưu lại dưới dạng tệp ZIP. ## Phần kết luận diff --git a/html/vietnamese/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md b/html/vietnamese/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md new file mode 100644 index 0000000000..eb36dab27b --- /dev/null +++ b/html/vietnamese/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/_index.md @@ -0,0 +1,182 @@ +--- +category: general +date: 2026-02-25 +description: cách sử dụng handler để tải HTML từ URL và lưu trang web dưới dạng zip + với Aspose.HTML – hướng dẫn chi tiết từng bước bằng C# +draft: false +keywords: +- how to use handler +- load html from url +- custom resource handler +- save webpage as zip +- create zip from html +language: vi +og_description: Cách sử dụng handler để tải HTML từ URL và lưu trang web dưới dạng + ZIP với Aspose.HTML. Tìm hiểu quy trình C# hoàn chỉnh trong vài phút. +og_title: cách sử dụng handler trong Aspose.HTML – Tải HTML, Lưu dưới dạng ZIP +tags: +- Aspose.HTML +- C# +- Web Scraping +title: Cách sử dụng handler trong Aspose.HTML – Tải HTML, Lưu dưới dạng ZIP +url: /vi/net/html-extensions-and-conversions/how-to-use-handler-in-aspose-html-load-html-save-as-zip/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# cách sử dụng handler trong Aspose.HTML – Tải HTML, Lưu dưới dạng ZIP + +Bạn đã bao giờ tự hỏi **cách sử dụng handler** khi kéo một trang web vào ứng dụng .NET của mình chưa? Có thể bạn đã thử `HtmlDocument.Open` và nhận được HTML, nhưng các hình ảnh, CSS và phông chữ lại biến mất. Đó là một vấn đề phổ biến—các tài nguyên sẽ bị mất nếu bạn không chỉ định cho Aspose.HTML cách xử lý chúng. + +Trong hướng dẫn này, chúng ta sẽ đi qua quy trình tải HTML từ một URL, thiết lập **handler tài nguyên tùy chỉnh**, và cuối cùng **lưu trang web dưới dạng zip** để bạn có được một kho lưu trữ di động duy nhất. Khi hoàn thành, bạn sẽ có một đoạn mã C# sẵn sàng chạy mà có thể chèn vào bất kỳ dự án nào, cùng với một vài mẹo giúp bạn tránh những rắc rối sau này. + +## Những gì bạn cần + +- .NET 6+ (API cũng hoạt động trên .NET Core và .NET Framework) +- Aspose.HTML for .NET (gói NuGet `Aspose.HTML`) +- Một chút kinh nghiệm với C# (bạn sẽ ổn nếu đã viết một `Console.WriteLine` trước đây) + +Không cần công cụ bổ sung, không cần dịch vụ bên ngoài—chỉ cần thư viện và một URL bạn muốn lưu trữ. + + + +## Bước 1: Tải HTML từ URL + +Điều đầu tiên trong bất kỳ luồng thu thập web nào là lấy nguồn trang. Aspose.HTML làm việc này chỉ với một dòng lệnh, nhưng nhớ rằng chúng ta **đang tải html từ url** bằng stack mạng tích hợp. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +// 1️⃣ Load the page you want to archive +HtmlDocument htmlDoc = new HtmlDocument(); +htmlDoc.Open("https://example.com"); // replace with any public URL +``` + +> **Tại sao điều này quan trọng:** `HtmlDocument.Open` phân tích cú pháp markup *và* giải quyết các URL tương đối nội bộ, nhưng nó không tự động lưu lại các tài nguyên bên ngoài. Đó là lý do chúng ta cần một handler sau này. + +## Bước 2: Tạo Custom Resource Handler + +Bây giờ là phần cốt lõi—**cách sử dụng handler** để chặn mọi yêu cầu tài nguyên bên ngoài (hình ảnh, CSS, phông chữ, v.v.). Bằng cách kế thừa `ResourceHandler` bạn sẽ có toàn quyền kiểm soát luồng dữ liệu cho mỗi tài sản. + +```csharp +// 2️⃣ Define your own handler (optional but powerful) +public class MyResourceHandler : ResourceHandler +{ + // Called for each external resource the document needs + public override Stream HandleResource(ResourceInfo info) + { + // Here you could download the file, cache it, or rewrite it. + // For this demo we simply return an empty stream – Aspose will + // still create the entry in the ZIP, keeping the folder structure. + return new MemoryStream(); + } +} +``` + +> **Mẹo chuyên nghiệp:** Trong môi trường production, bạn có thể muốn tải xuống các byte thực tế (`HttpClient.GetStreamAsync(info.Uri)`) và trả về luồng đó. Điều này đảm bảo ZIP được lưu chứa các hình ảnh thực thay vì các placeholder rỗng. + +## Bước 3: Cấu hình Save Options và Gắn Handler + +Khi handler đã sẵn sàng, chúng ta chỉ định cho Aspose.HTML cách đóng gói mọi thứ. Lớp `HtmlSaveOptions` cho phép bật công tắc `SaveToZipArchive` và gắn `MyResourceHandler` của bạn. + +```csharp +// 3️⃣ Set up saving options – this is where we **save webpage as zip** +HtmlSaveOptions saveOptions = new HtmlSaveOptions +{ + // Attach our custom handler – new API as of v22.10 + OutputStorage = new MyResourceHandler(), + + // Instruct Aspose to bundle HTML + resources into a single ZIP file + SaveToZipArchive = true +}; +``` + +> **Giải thích:** `OutputStorage` là thuộc tính nhận đối tượng handler. Khi trình lưu duyệt DOM, nó sẽ gọi `HandleResource` cho mỗi liên kết bên ngoài. Vì `SaveToZipArchive` được đặt là true, trình lưu sẽ ghi mỗi luồng trả về vào một mục ZIP có đường dẫn tương ứng với đường dẫn gốc. + +## Bước 4: Lưu Document vào Memory Stream + +Chúng ta có thể ghi trực tiếp ra đĩa, nhưng giữ mọi thứ trong bộ nhớ giúp mã có thể dùng trong ASP.NET, Azure Functions, hoặc bất kỳ nơi nào bạn không muốn tạo file tạm. Đây là bước cuối cùng **tạo zip từ html**. + +```csharp +// 4️⃣ Save everything – HTML + resources – into a MemoryStream +using (MemoryStream outputStream = new MemoryStream()) +{ + htmlDoc.Save(outputStream, saveOptions); + + // At this point outputStream holds a valid ZIP archive. + // For demo purposes we write it to the file system: + File.WriteAllBytes("example_page.zip", outputStream.ToArray()); +} +``` + +### Kết quả mong đợi + +- `example_page.zip` xuất hiện trong thư mục dự án của bạn. +- Bên trong ZIP sẽ có `index.html` cùng cấu trúc thư mục (`images/`, `css/`, v.v.). +- Mặc dù handler demo của chúng ta trả về các stream rỗng, bố cục ZIP vẫn phản ánh trang gốc—hoàn hảo để thay thế bằng một downloader thực tế sau này. + +## Các biến thể thường gặp & Trường hợp góc cạnh + +### Tải tệp cục bộ thay vì URL +Nếu bạn cần **tải html từ url**‑giống các đường dẫn trên đĩa, chỉ cần thay `htmlDoc.Open("https://example.com")` bằng `htmlDoc.Open(@"C:\path\to\file.html")`. Phần còn lại của quy trình vẫn giống y hệt. + +### Lưu trữ tài nguyên thực +Để thực sự nhúng hình ảnh, sửa đổi `HandleResource`: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Download the resource using HttpClient + HttpClient client = new HttpClient(); + var data = client.GetByteArrayAsync(info.Uri).Result; + return new MemoryStream(data); +} +``` + +> **Cảnh báo:** Các cuộc gọi mạng bên trong handler sẽ chặn luồng lưu; đối với các trang lớn, hãy cân nhắc làm handler bất đồng bộ (có sẵn trong các phiên bản Aspose mới hơn). + +### Thay đổi tên mục ZIP +`ResourceInfo` chứa `FileName` và `Path`. Bạn có thể ghi lại chúng để làm phẳng cấu trúc hoặc thêm tiền tố: + +```csharp +public override Stream HandleResource(ResourceInfo info) +{ + // Example: prepend "assets/" to every entry + info.Path = Path.Combine("assets", info.Path); + return base.HandleResource(info); +} +``` + +### Sử dụng Output Storage khác +`OutputStorage` cũng có thể là một `FileSystemStorage` nếu bạn muốn lưu vào thư mục thay vì ZIP. Chỉ cần đặt `SaveToZipArchive = false` và chỉ định `OutputStorage` tới đường dẫn thư mục. + +## Mẹo chuyên nghiệp & Những bẫy cần tránh + +- **Đừng quên dispose** `HtmlDocument` nếu bạn mở nhiều trang trong một vòng lặp; nếu không sẽ rò rỉ tài nguyên gốc. +- **Tiêu thụ bộ nhớ:** Lưu các trang lớn vào `MemoryStream` có thể làm tăng RAM đáng kể. Đối với các kho lưu trữ đa megabyte, hãy stream trực tiếp tới file (`FileStream`) thay vì giữ trong bộ nhớ. +- **Mã hoá ký tự:** Aspose.HTML tôn trọng thẻ ``. Nếu trang nguồn dùng mã hoá không phổ biến, hãy kiểm tra HTML kết quả có hiển thị đúng sau khi trích xuất không. +- **Kiểm thử:** Mở ZIP đã tạo trong trình duyệt (kéo `index.html` ra) để xác nhận mọi tài nguyên được giải quyết. Nếu thiếu hình ảnh, `HandleResource` của bạn có thể đã trả về stream rỗng. + +## Tóm tắt + +Chúng ta đã tìm hiểu **cách sử dụng handler** để chặn tài nguyên bên ngoài, trình bày **tải html từ url**, xây dựng **handler tài nguyên tùy chỉnh**, và cuối cùng **lưu trang web dưới dạng zip**—tức là **tạo zip từ html** chỉ với vài dòng C#. Mô hình này có thể mở rộng: thay `MemoryStream` rỗng bằng một downloader thực, thay đổi đích xuất, hoặc nhúng logic vào một Web API trả về ZIP theo yêu cầu. + +--- + +### Tiếp theo? + +- **Xử lý hàng loạt:** Lặp qua danh sách URL và tạo một ZIP cho mỗi trang. +- **Tinh chỉnh nén:** Sử dụng `ZipSaveOptions` để điều chỉnh mức nén, giúp tải nhanh hơn. +- **Tích hợp với ASP.NET Core:** Trả về `MemoryStream` dưới dạng `FileResult` để người dùng có thể tải kho lưu trữ trực tiếp từ endpoint web. +- **Khám phá các tính năng khác của Aspose.HTML:** Chuyển đổi PDF, thao tác DOM, hoặc render không giao diện. + +Có câu hỏi về trường hợp sử dụng cụ thể—có thể bạn cần giữ JavaScript hoặc xử lý các trang yêu cầu xác thực? Hãy để lại bình luận bên dưới; mình sẽ sẵn sàng giải đáp sâu hơn. Chúc lập trình vui vẻ! + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file diff --git a/html/vietnamese/net/rendering-html-documents/_index.md b/html/vietnamese/net/rendering-html-documents/_index.md index 0ba8686fde..e85efdbe86 100644 --- a/html/vietnamese/net/rendering-html-documents/_index.md +++ b/html/vietnamese/net/rendering-html-documents/_index.md @@ -89,6 +89,8 @@ Học cách chuyển đổi HTML sang PNG và nén thành tệp ZIP bằng C# v Học cách chuyển đổi HTML thành ảnh bằng C# với Aspose.HTML, bao gồm các bước chi tiết và hướng dẫn từng bước. ### [Kết xuất HTML sang PDF với Aspose.HTML – Hướng dẫn từng bước](./render-html-to-pdf-with-aspose-html-step-by-step-guide/) Học cách chuyển đổi HTML sang PDF bằng Aspose.HTML cho .NET qua hướng dẫn chi tiết từng bước. Nắm vững quy trình render PDF nhanh chóng. +### [Cách render HTML thành PNG trong C# – Hướng dẫn từng bước](./how-to-render-html-as-png-in-c-step-by-step-guide/) +Học cách chuyển đổi HTML sang PNG bằng C# với Aspose.HTML, bao gồm các bước chi tiết và mẹo thực tiễn. {{< /blocks/products/pf/tutorial-page-section >}} diff --git a/html/vietnamese/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md b/html/vietnamese/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..c1209af522 --- /dev/null +++ b/html/vietnamese/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/_index.md @@ -0,0 +1,223 @@ +--- +category: general +date: 2026-02-25 +description: Cách chuyển đổi HTML thành PNG trong C# bằng Aspose.HTML. Tìm hiểu cách + chuyển HTML sang hình ảnh, lưu HTML dưới dạng PNG và tạo PNG từ HTML nhanh chóng. +draft: false +keywords: +- how to render html +- convert html to image +- save html as png +- create png from html +- generate png from html +language: vi +og_description: Cách chuyển đổi HTML thành PNG trong C# với Aspose.HTML. Hãy theo + dõi hướng dẫn này để chuyển đổi HTML sang hình ảnh, lưu HTML dưới dạng PNG và tạo + PNG từ HTML. +og_title: Cách chuyển đổi HTML thành PNG trong C# – Hướng dẫn đầy đủ +tags: +- C# +- Aspose.HTML +- Image Rendering +title: Cách chuyển đổi HTML thành PNG trong C# – Hướng dẫn từng bước +url: /vi/net/rendering-html-documents/how-to-render-html-as-png-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Cách render HTML thành PNG trong C# – Hướng dẫn từng bước + +Bạn đã bao giờ tự hỏi **cách render HTML** trực tiếp thành tệp PNG mà không cần mở trình duyệt chưa? Có thể bạn cần nhúng một ảnh chụp nhanh của một trang web vào email, hoặc bạn đang xây dựng dịch vụ tạo thumbnail cho CMS. Dù sao, vấn đề về cơ bản là chuyển markup thành bitmap mà bạn có thể lưu hoặc phục vụ. + +Trong tutorial này bạn sẽ thấy một giải pháp hoàn chỉnh, sẵn sàng chạy mà **chuyển đổi HTML sang hình ảnh** bằng cách sử dụng Aspose.HTML cho .NET. Chúng tôi cũng sẽ đề cập đến cách **lưu HTML dưới dạng PNG**, **tạo PNG từ HTML**, và thậm chí **tạo PNG từ HTML** với phông chữ và kích thước tùy chỉnh. Không có tham chiếu mơ hồ—chỉ có mã bạn có thể sao chép‑dán, cùng với giải thích tại sao mỗi dòng lại quan trọng. + +## Những gì bạn cần + +- .NET 6 (hoặc bất kỳ runtime .NET hiện đại nào) – API hoạt động tương tự trên .NET Framework 4.6+. +- Visual Studio 2022 hoặc VS Code – tùy bạn thích. +- Gói NuGet **Aspose.HTML** (`Aspose.HTML.NET`) – cài đặt một lần là xong. +- Thư mục có quyền ghi cho PNG đầu ra (ví dụ: `C:\Temp\Images`). + +Đó là tất cả. Không cần binary bổ sung, không dịch vụ web bên ngoài, và không có tệp cấu hình ẩn. + +## Bước 1: Cài đặt Aspose.HTML qua NuGet + +Đầu tiên, thêm thư viện vào dự án của bạn. Mở terminal trong thư mục solution và chạy: + +```bash +dotnet add package Aspose.HTML.NET +``` + +*Pro tip:* Nếu bạn đang dùng Visual Studio, chuột phải vào **Dependencies → Manage NuGet Packages**, tìm “Aspose.HTML”, và nhấn **Install**. Điều này sẽ cung cấp cho bạn các lớp `HtmlDocument`, `ImageRenderingOptions`, và các lớp khác mà chúng ta sẽ dùng. + +## Bước 2: Cấu hình tùy chọn render (kích thước, kiểu, và phông chữ) + +Trước khi đưa bất kỳ markup nào vào renderer, chúng ta quyết định kích thước ảnh và kiểu phông chữ cần giữ lại. Đối tượng `ImageRenderingOptions` cho phép bạn điều chỉnh chiều rộng, chiều cao, và thậm chí buộc render in đậm/nghiêng. + +```csharp +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +// Configure image rendering options – width, height, and font style +ImageRenderingOptions renderingOptions = new ImageRenderingOptions +{ + Width = 800, // Desired image width in pixels + Height = 600, // Desired image height in pixels + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic // Preserve bold & italic +}; +``` + +**Tại sao điều này quan trọng:** +- **Width/Height** xác định kích thước pixel cuối cùng; nếu bỏ qua, engine sẽ đoán dựa trên bố cục HTML, có thể gây cắt ảnh không mong muốn. +- **FontStyle** đảm bảo bất kỳ thẻ `` hoặc `` nào vẫn giữ được nhấn mạnh trực quan khi raster hoá. + +## Bước 3: Tải markup HTML của bạn + +Bạn có thể tải HTML từ chuỗi, tệp, hoặc URL. Để đơn giản, chúng ta sẽ nhúng một đoạn mã nhỏ trực tiếp trong code. Lưu ý CSS nội tuyến đặt family phông – Aspose.HTML tôn trọng CSS web chuẩn, vì vậy bạn sẽ nhận được bản render trung thực. + +```csharp +using Aspose.Html; + +// Create an empty HTML document +HtmlDocument htmlDoc = new HtmlDocument(); + +// Load simple markup – you could also use htmlDoc.Open("path/to/file.html") +htmlDoc.Open("Hello, world!
"); +``` + +**Mẹo trường hợp đặc biệt:** Nếu markup của bạn tham chiếu tới tài nguyên bên ngoài (hình ảnh, file CSS), hãy chắc chắn các URL đó có thể truy cập được từ máy chạy code, hoặc nhúng chúng dưới dạng data‑URI để tránh liên kết bị hỏng. + +## Bước 4: Render HTML thành stream PNG + +Bây giờ là phần cốt lõi của **cách render HTML** – chúng ta gọi `RenderToStream`, truyền stream đầu ra và các tùy chọn đã cấu hình trước đó. Phương thức này thực hiện toàn bộ công việc nặng: layout, cascade CSS, thay thế phông, và raster hoá. + +```csharp +using System.IO; + +// Choose an output path – replace with your own directory +string outputPath = @"C:\Temp\Images\output.png"; + +using (FileStream outputStream = File.OpenWrite(outputPath)) +{ + // Render the HTML document into the PNG file + htmlDoc.RenderToStream(outputStream, renderingOptions); +} +``` + +Sau khi khối `using` kết thúc, `output.png` sẽ chứa ảnh 800 × 600 pixel của đoạn văn chúng ta đã tải. Mở nó bằng bất kỳ trình xem ảnh nào để xác nhận kết quả. + +### Kết quả mong đợi + +Bạn sẽ thấy một nền trắng sạch với văn bản **“Hello, world!”** được render bằng Arial, in đậm và nghiêng, kích thước chính xác 24 pt. Kích thước ảnh khớp với giá trị 800 × 600 mà chúng ta đã đặt. + +## Bước 5: Kiểm tra và xử lý các vấn đề thường gặp + +### 5.1 Kiểm tra file tồn tại + +Một kiểm tra nhanh giúp tránh lỗi im lặng: + +```csharp +if (File.Exists(outputPath)) +{ + Console.WriteLine($"✅ PNG created successfully at {outputPath}"); +} +else +{ + Console.WriteLine("❌ Something went wrong – PNG not found."); +} +``` + +### 5.2 Xử lý phông chữ thiếu + +Nếu máy mục tiêu không có phông chữ yêu cầu, Aspose.HTML sẽ chuyển sang phông sans‑serif chung. Để đảm bảo tính nhất quán, bạn có thể: + +- Nhúng file phông bằng quy tắc `@font-face` trong HTML, **hoặc** +- Đăng ký phông lập trình trước khi render. + +```csharp +// Example of registering a custom TrueType font +htmlDoc.Fonts.AddFontFile(@"C:\Fonts\OpenSans-Regular.ttf"); +``` + +### 5.3 Render các trang lớn + +Khi tạo thumbnail cho ảnh chụp toàn trang, hãy chú ý đến việc sử dụng bộ nhớ. Bạn có thể giảm kích thước sau khi render, hoặc đặt `renderingOptions.Width`/`Height` thành kích thước nhỏ hơn và để Aspose.HTML tự thực hiện scaling. + +## Ví dụ hoàn chỉnh hoạt động + +Dưới đây là chương trình đầy đủ mà bạn có thể sao chép vào một ứng dụng console và chạy ngay lập tức. + +```csharp +// ----------------------------------------------------------- +// How to render HTML as PNG – Complete, runnable example +// ----------------------------------------------------------- +using System; +using System.IO; +using Aspose.Html; +using Aspose.Html.Drawing; +using Aspose.Html.Rendering.Image; + +class Program +{ + static void Main() + { + // 1️⃣ Configure rendering options + ImageRenderingOptions renderingOptions = new ImageRenderingOptions + { + Width = 800, + Height = 600, + FontStyle = WebFontStyle.Bold | WebFontStyle.Italic + }; + + // 2️⃣ Load HTML markup + HtmlDocument htmlDoc = new HtmlDocument(); + htmlDoc.Open("Hello, world!
"); + + // 3️⃣ Define output path + string outputPath = @"C:\Temp\Images\output.png"; + + // 4️⃣ Render to PNG + using (FileStream outputStream = File.OpenWrite(outputPath)) + { + htmlDoc.RenderToStream(outputStream, renderingOptions); + } + + // 5️⃣ Verify the result + Console.WriteLine(File.Exists(outputPath) + ? $"✅ PNG saved at {outputPath}" + : "❌ Failed to create PNG"); + } +} +``` + +Chạy chương trình (`dotnet run`), sau đó mở `C:\Temp\Images\output.png`. Nếu mọi thứ diễn ra suôn sẻ, bạn vừa **chuyển đổi HTML sang hình ảnh** và **lưu HTML dưới dạng PNG** bằng mã C# thuần. + +## Câu hỏi thường gặp + +| Câu hỏi | Trả lời | +|----------|--------| +| **Tôi có thể render toàn bộ trang web với CSS/JS bên ngoài không?** | Có – chỉ cần gọi `htmlDoc.Open("https://example.com")`. Engine sẽ tải các tài nguyên liên kết, nhưng bạn cần có kết nối mạng. | +| **Những định dạng nào được hỗ trợ ngoài PNG?** | `ImageRenderingOptions` hỗ trợ JPEG, BMP, GIF và TIFF. Thay đổi phần mở rộng file và đặt `ImageFormat` nếu cần. | +| **Có giới hạn kích thước ảnh không?** | Kỹ thuật bạn có thể lên tới vài nghìn pixel, nhưng kích thước quá lớn có thể làm hết bộ nhớ. Xem xét render theo từng tile cho output siêu‑độ phân giải. | +| **Làm sao xử lý DPI cho ảnh chất lượng in?** | Đặt `renderingOptions.DpiX` và `renderingOptions.DpiY` (mặc định là 96). DPI cao hơn cho kết quả sắc nét hơn khi in. | +| **Tôi có cần mua license cho Aspose.HTML không?** | Bản đánh giá miễn phí hoạt động với watermark. Đối với môi trường production, mua license để loại bỏ watermark và mở toàn bộ tính năng. | + +## Các bước tiếp theo và chủ đề liên quan + +- **Chuyển HTML sang JPEG** – đổi phần mở rộng file và tùy chọn `renderingOptions.ImageFormat = ImageFormat.Jpeg`. +- **Xử lý batch** – lặp qua danh sách URL và tạo thumbnail cho mỗi URL. +- **Nhúng phông chữ** – tìm hiểu cách dùng `@font-face` trong markup để đạt được typography hoàn hảo. +- **Layout nâng cao** – thử nghiệm các tùy chọn `PageSize`, `Margin`, và `BackgroundColor` để tạo kiểu dáng tùy chỉnh. + +Bạn có thể tự do thay đổi kích thước, thử các đoạn HTML khác nhau, hoặc tích hợp đoạn mã này vào một Web API trả về preview PNG ngay lập tức. Khi bạn đã biết **cách render HTML** bằng lập trình, không gì là không thể. + +--- + + + +{{< /blocks/products/pf/tutorial-page-section >}} +{{< /blocks/products/pf/main-container >}} +{{< /blocks/products/pf/main-wrap-class >}} +{{< blocks/products/products-backtop-button >}} \ No newline at end of file