Hello, world!
+
+
+";
+
+// Create a new document instance.
+HtmlDocument document = new HtmlDocument();
+
+// Load the HTML markup.
+document.Open(htmlContent);
+```
+
+**لماذا هذه الخطوة مهمة:**
+إمكانية **تحميل سلسلة HTML** مفيدة عندما يتم توليد HTML ديناميكيًا (مثلًا من محرك القوالب) أو استلامه من API. إنها تتجنب الاعتماد على نظام الملفات وتعمل في بيئات معزولة.
+
+## الخطوة 3: تكوين خيارات الحفظ لاستخدام المعالج
+
+تتيح لك `HtmlSaveOptions` الخاصة بـ Aspose.HTML تحديد آلية التخزين للمخرجات. قم بتعيين المعالج المخصص إلى خاصية `OutputStorage`، واضبط علامة `Compress` لإنتاج أرشيف ZIP.
+
+```csharp
+// Instantiate the custom handler.
+var resourceHandler = new InMemoryResourceHandler();
+
+// Prepare save options.
+HtmlSaveOptions saveOptions = new HtmlSaveOptions
+{
+ // Use the handler for all external resources.
+ OutputStorage = resourceHandler,
+
+ // Enable ZIP compression.
+ Compress = true
+};
+```
+
+**لماذا هذه الخطوة مهمة:**
+`Compress = true` يخبر Aspose.HTML بدمج ملف HTML وجميع الموارد المجمعة في حزمة ZIP واحدة. يضمن `OutputStorage` أن تُلتقط الموارد في الذاكرة بدلاً من كتابتها إلى مواقع مؤقتة.
+
+## الخطوة 4: حفظ المستند كأرشيف ZIP
+
+الآن استدعِ `HtmlDocument.Save`، مع تمرير مسار الوجهة والخيارات المكوَّنة. بعد الحفظ، يحتوي ملف ZIP على `index.html` بالإضافة إلى أي موارد تم التقاطها بواسطة المعالج.
+
+```csharp
+// Define the output path (you can change this to a response stream for web APIs).
+string outputPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+
+// Save the document; Aspose.HTML creates the ZIP automatically.
+document.Save(outputPath, saveOptions);
+
+// Optional: Verify the resources that were stored.
+foreach (var entry in resourceHandler.Resources)
+{
+ Console.WriteLine($"Resource: {entry.Key}, Size: {entry.Value.Length} bytes");
+}
+```
+
+**النتيجة المتوقعة:**
+تشغيل البرنامج ينشئ `output.zip` في الدليل الحالي. استخراج الأرشيف يكشف عن:
+
+```
+index.html
+styles.css
+logo.png
+```
+
+كل ملف يتطابق مع مراجع العلامات، وHTML داخل `index.html` يشير إلى الموارد المجمعة.
+
+## الخطوة 5: تعديل المعالج لبيانات الموارد الحقيقية (متقدم)
+
+المعالج الأساسي أعلاه ينشئ تدفقات فارغة. في بيئة الإنتاج غالبًا ما تحتاج إلى كتابة المحتوى الفعلي (مثل بايتات `styles.css` أو `logo.png`). قم بتمديد `HandleResource` لجلب البيانات من قاعدة بيانات، أو دلو سحابي، أو مورد مدمج.
+
+```csharp
+public override Stream HandleResource(ResourceInfo info)
+{
+ // Example: Load resource from an embedded folder.
+ string resourcePath = Path.Combine("EmbeddedResources", info.Path);
+ byte[] data = File.ReadAllBytes(resourcePath);
+
+ // Write data into a memory stream.
+ var stream = new MemoryStream(data);
+ _resources[info.Path] = stream;
+
+ // Return the populated stream.
+ return stream;
+}
+```
+
+**لماذا هذا الاختلاف مهم:**
+توفير محتوى حقيقي يضمن أن يكون أرشيف ZIP فعالًا عند فتحه في المتصفح. يمكن للمعالج أيضًا تطبيق تحويلات (مثل تصغير CSS) قبل الكتابة إلى التدفق.
+
+## الخطوة 6: استخدام أرشيف ZIP في واجهة برمجة تطبيقات ويب (اختياري)
+
+إذا قمت بتوفير الوظيفة عبر ASP.NET Core، أعد ملف ZIP كنتيجة ملف:
+
+```csharp
+[HttpGet("download")]
+public IActionResult DownloadZip()
+{
+ // Reuse the same logic from steps 1‑4.
+ // ...
+
+ // Read the generated ZIP into a byte array.
+ byte[] zipBytes = System.IO.File.ReadAllBytes(outputPath);
+
+ // Return the file with the appropriate content type.
+ return File(zipBytes, "application/zip", "document.zip");
+}
+```
+
+**لماذا هذه الخطوة مهمة:**
+يمكن للعملاء تنزيل HTML المعبأ دون التعامل مع ملفات مؤقتة على الخادم. يعمل النهج مع الدوال الخالية من الخوادم حيث يكون الوصول إلى القرص محدودًا.
+
+## الأخطاء الشائعة وكيفية تجنبها
+
+| المشكلة | السبب | الحل |
+|---------|--------|-----|
+| موارد فارغة في ملف ZIP | المعالج يُعيد `MemoryStream` جديد دون كتابة البيانات | املأ التدفق بالبايتات الفعلية قبل الإرجاع |
+| غياب إدخال `index.html` | علامة `Compress` غير مفعلة أو لم يتم تعيين `OutputStorage` | تأكد من `saveOptions.Compress = true` و `saveOptions.OutputStorage = handler` |
+| HTML كبير يسبب ضغطًا على الذاكرة | جميع الموارد تُحفظ في الذاكرة | التبديل إلى تنفيذ `FileStorage` يكتب إلى مجلد مؤقت |
+| روابط URL نسبية تتعطل بعد الاستخراج | الموارد مُشار إليها بروابط URL مطلقة غير مخزنة | أعد كتابة الروابط إلى مسارات نسبية داخل المعالج أو أثناء المعالجة اللاحقة |
+
+## مثال كامل قابل للتنفيذ
+
+```csharp
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Saving;
+
+class InMemoryResourceHandler : ResourceHandler
+{
+ private readonly DictionaryHello, world!
+
+
+ ";
+
+ HtmlDocument doc = new HtmlDocument();
+ doc.Open(html);
+
+ // Step 1 & 3: Create handler and configure save options.
+ var handler = new InMemoryResourceHandler();
+ HtmlSaveOptions options = new HtmlSaveOptions
+ {
+ OutputStorage = handler,
+ Compress = true
+ };
+
+ // Step 4: Save as ZIP.
+ string zipPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+ doc.Save(zipPath, options);
+ Console.WriteLine($"ZIP file created at: {zipPath}");
+
+ // Optional verification.
+ foreach (var kvp in handler.Resources)
+ {
+ Console.WriteLine($"Resource {kvp.Key} captured, length {kvp.Value.Length} bytes");
+ }
+ }
+}
+```
+
+تشغيل البرنامج ينتج `output.zip` بجوار الملف التنفيذي. استخراج الأرشيف يظهر `index.html`، `styles.css`، و `logo.png` (نواقل فارغة في هذا المثال البسيط).
+
+## الخلاصة
+
+أصبح لديك الآن طريقة موثوقة لـ **حفظ HTML كملف ZIP** باستخدام Aspose.HTML في C#. غطى الدرس تحميل سلسلة HTML، تنفيذ **معالج موارد مخصص**، تكوين خيارات الحفظ، وإنشاء أرشيف ZIP جاهز للتوزيع أو التنزيل.
+
+من هنا يمكنك:
+- استبدال تدفقات النواقل الفارغة بمحتوى حقيقي (مثل القراءة من قاعدة بيانات)
+- التبديل إلى معالج تخزين يعتمد على الملفات للمستندات الكبيرة جدًا
+- دمج المنطق في نقاط النهاية ASP.NET Core لتنزيلات عند الطلب
+- استكشاف ميزات إضافية في Aspose.HTML مثل تحويل PDF أو عرض الصور
+
+جرّب مصادر موارد مختلفة وإعدادات ضغط مختلفة لتكييف الحل مع متطلبات الأداء والحجم الخاصة بك. برمجة سعيدة!
+
+## ما الذي يجب أن تتعلمه بعد ذلك؟
+
+الدروس التالية تغطي مواضيع ذات صلة وثيقة تبني على التقنيات التي تم توضيحها في هذا الدليل. كل مصدر يتضمن أمثلة شاملة من الكود مع شروحات خطوة بخطوة لمساعدتك على إتقان ميزات API إضافية واستكشاف أساليب تنفيذ بديلة في مشاريعك.
+
+- [حفظ HTML كملف ZIP – دليل C# كامل](/html/english/net/html-extensions-and-conversions/save-html-as-zip-complete-c-tutorial/)
+- [كيفية حفظ HTML في C# – دليل كامل باستخدام معالج موارد مخصص](/html/english/net/working-with-html-documents/how-to-save-html-in-c-complete-guide-using-a-custom-resource/)
+- [إنشاء HTML من سلسلة في C# – دليل معالج موارد مخصص](/html/english/net/html-document-manipulation/create-html-from-string-in-c-custom-resource-handler-guide/)
+
+{{< /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/generate-jpg-and-png-images/_index.md b/html/chinese/net/generate-jpg-and-png-images/_index.md
index 3a7bc53dc3..fe1018914d 100644
--- a/html/chinese/net/generate-jpg-and-png-images/_index.md
+++ b/html/chinese/net/generate-jpg-and-png-images/_index.md
@@ -45,6 +45,8 @@ Aspose.HTML for .NET 提供了一种将 HTML 转换为图像的简单方法。
了解如何在使用 Aspose.HTML for .NET 将 DOCX 文档转换为 PNG 或 JPG 图像时启用抗锯齿，以提升图像质量。
### [使用 C# 将 docx 转换为 png 并创建 zip 存档教程](./convert-docx-to-png-create-zip-archive-c-tutorial/)
学习如何使用 C# 将 DOCX 文档转换为 PNG 图像并打包为 ZIP 文件的完整步骤。
+### [使用 Aspose.HTML 在 C# 中从 HTML 创建 PNG](./create-png-from-html-in-c-using-aspose-html/)
+了解如何使用 Aspose.HTML for .NET 将 HTML 内容转换为 PNG 图像的步骤。
## 结论
diff --git a/html/chinese/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md b/html/chinese/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
new file mode 100644
index 0000000000..55f3c4e9eb
--- /dev/null
+++ b/html/chinese/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
@@ -0,0 +1,288 @@
+---
+category: general
+date: 2026-08-12
+description: 使用 Aspose.HTML 在 C# 中将 HTML 生成 PNG。了解如何将 HTML 转换为 PNG，并仅用几行代码将 HTML 渲染为图像。
+draft: false
+images:
+- PLACEHOLDER_URL/og-image.png
+keywords:
+- create png from html
+- convert html to png
+- render html as image
+- how to render html to image
+language: zh
+lastmod: 2026-08-12
+og_description: 使用 Aspose.HTML 在 C# 中将 HTML 转换为 PNG。本指南快速展示如何将 HTML 渲染为图像，涵盖转换选项、代码设置和故障排除。
+og_image_alt: Screenshot of a C# program converting HTML to a PNG image
+og_title: 使用 C# 从 HTML 创建 PNG – 步骤指南
+schemas:
+- author: Aspose
+ dateModified: '2026-08-12'
+ description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ headline: Create PNG from HTML in C# using Aspose.HTML
+ type: TechArticle
+- description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ name: Create PNG from HTML in C# using Aspose.HTML
+ steps:
+ - name: Why this works
+ text: '- **`HtmlDocument.Open`** parses the HTML string into a DOM that Aspose.HTML
+ can render. - **`ImageRenderingOptions`** lets you control anti‑aliasing, text
+ hinting, and font handling, which are essential when you **render HTML as image**
+ to avoid blurry text. - **`ImageConverter.ConvertHtmlToImage`*'
+ - name: 1. Preparing the HTML source
+ text: You can load HTML from a string (as shown), a local file, or a remote URL.
+ - name: 2. Fine‑tuning rendering options
+ text: '| Option | Effect | When to adjust | |--------|--------|----------------|
+ | `UseAntialiasing` | Reduces jagged edges on vector graphics | Always enable
+ for high‑quality output | | `TextOptions.UseHinting` | Sharpens glyph edges
+ | Important for small font sizes | | `FontOptions.WebFontStyle` | Choose'
+ - name: 3. Performing the conversion
+ text: The `ImageConverter` overload you used writes a single PNG file. If you
+ need multiple pages (e.g., a multi‑page HTML document), use the overload that
+ returns a collection of images.
+ - name: a. Missing fonts
+ text: If the HTML references a custom web font that isn’t installed on the server,
+ the rendered text falls back to a default font, which may affect layout.
+ - name: b. Large pages and memory consumption
+ text: Rendering a very tall page can consume a lot of RAM.
+ - name: c. Transparent backgrounds
+ text: PNG supports transparency, but the default background is white.
+ type: HowTo
+tags:
+- Aspose.HTML
+- C#
+- image rendering
+- HTML conversion
+title: 使用 Aspose.HTML 在 C# 中将 HTML 转换为 PNG
+url: /zh/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/
+---
+
+{{< blocks/products/pf/main-wrap-class >}}
+{{< blocks/products/pf/main-container >}}
+{{< blocks/products/pf/tutorial-page-section >}}
+
+# 使用 Aspose.HTML 在 C# 中从 HTML 创建 PNG
+
+如果您需要在 .NET 应用程序中 **从 HTML 创建 PNG**，本指南将带您完整了解整个过程。您只需几行 C# 代码，即可使用 Aspose.HTML 强大的渲染引擎 **将 HTML 转换为 PNG**。
+
+将 HTML 渲染为图像是生成缩略图、电子邮件预览或必须嵌入 PDF 的报告时的常见需求。接下来的章节中，您将学习具体步骤，查看完整可运行示例，并了解每个设置背后的原因。
+
+## 您将学到的内容
+
+- 如何从字符串或文件构建 `HtmlDocument`。
+- 如何配置 `ImageRenderingOptions` 以提升质量。
+- 如何 **将 HTML 转换为 PNG** 并将结果保存到磁盘。
+- 处理字体、大页面以及自定义输出路径的技巧。
+
+**先决条件**
+- 已安装 .NET 6.0 SDK（或更高版本）。
+- 有效的 Aspose.HTML for .NET 许可证（或临时评估密钥）。
+- 对 C# 和 Visual Studio 或任意 .NET 兼容 IDE 有基本了解。
+
+---
+
+## 使用 Aspose.HTML 将 HTML 创建为 PNG
+
+第一步是设置环境并引用所需的 Aspose.HTML 命名空间。
+
+```csharp
+using System;
+using Aspose.Html;
+using Aspose.Html.Rendering.Image;
+using Aspose.Html.Drawing;
+using Aspose.Html.Converters;
+
+namespace HtmlToPngDemo
+{
+ class Program
+ {
+ static void Main()
+ {
+ // 1️⃣ Build the HTML document from a raw string.
+ var html = "Bold text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // 2️⃣ Configure rendering options for best visual fidelity. + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, // Smooths edges of drawn shapes + TextOptions = { UseHinting = true }, // Improves glyph clarity + FontOptions = { WebFontStyle = WebFontStyle.Normal } // Uses standard web‑font style + }; + + // 3️⃣ Convert the HTML document to a PNG file. + string outputPath = @"output.png"; + ImageConverter.ConvertHtmlToImage(document, outputPath, renderOptions); + + Console.WriteLine($"PNG image created at: {outputPath}"); + } + } +} +``` + +### 为什么这样可行 + +- **`HtmlDocument.Open`** 将 HTML 字符串解析为 DOM，供 Aspose.HTML 渲染。 +- **`ImageRenderingOptions`** 让您控制抗锯齿、文本提示和字体处理，这在 **将 HTML 渲染为图像** 时避免文字模糊至关重要。 +- **`ImageConverter.ConvertHtmlToImage`** 完成核心工作：将 DOM 光栅化到位图并写入 PNG 文件。 + +运行程序后会生成 `output.png`，其中包含与 HTML 源码中定义完全相同的粗体段落。 + +--- + +## 分步将 HTML 转换为 PNG + +下面提供更详细的每个阶段的讲解。了解每行代码的作用有助于您在处理更大或更复杂的页面时进行调整。 + +### 1. 准备 HTML 源 + +您可以从字符串（如示例所示）、本地文件或远程 URL 加载 HTML。 + +```csharp +// Load from a file +var document = new HtmlDocument(); +document.Open(@"C:\templates\invoice.html"); + +// Load from a URL (requires internet access) +document.Open("https://example.com/report.html"); +``` + +**提示：** 加载外部资源（CSS、图片）时，请确保 `BaseUrl` 属性指向正确的文件夹，以便相对链接能够正确解析。 + +### 2. 微调渲染选项 + +| 选项 | 效果 | 何时调整 | +|--------|--------|----------------| +| `UseAntialiasing` | 减少矢量图形的锯齿边缘 | 始终启用以获得高质量输出 | +| `TextOptions.UseHinting` | 锐化字形边缘 | 对小字号尤为重要 | +| `FontOptions.WebFontStyle` | 选择普通、斜体或倾斜的网络字体渲染方式 | 对倾斜字体使用 `WebFontStyle.Oblique` | +| `ResolutionX` / `ResolutionY` | 输出图像的 DPI | 为打印级 PNG（如 300 DPI）提升分辨率时使用 | + +提升 DPI 的示例： + +```csharp +renderOptions.ResolutionX = 300; +renderOptions.ResolutionY = 300; +``` + +### 3. 执行转换 + +您使用的 `ImageConverter` 重载会写入单个 PNG 文件。如果需要多页（例如多页 HTML 文档），请使用返回图像集合的重载。 + +```csharp +ImageConverter.ConvertHtmlToImages(document, "output_folder", renderOptions); +``` + +每页将生成 `output_folder/page_0.png`、`page_1.png` 等文件。 + +--- + +## 将 HTML 渲染为图像 – 常见坑点处理 + +### a. 缺失字体 + +如果 HTML 引用了服务器上未安装的自定义网络字体，渲染的文字会回退为默认字体，可能导致布局变化。 + +**解决方案：** 在 CSS 中使用 `@font-face` 规则嵌入字体，或通过 `FontOptions` 提供本地字体文件夹。 + +```csharp +renderOptions.FontOptions.FontFolder = @"C:\fonts"; +``` + +### b. 大页面与内存消耗 + +渲染非常高的页面会占用大量 RAM。 + +**解决方案：** 设置最大高度或在转换前将文档拆分为多个章节。 + +```csharp +renderOptions.PageHeight = 2000; // pixels +``` + +### c. 透明背景 + +PNG 支持透明，但默认背景为白色。 + +**解决方案：** 将背景颜色改为透明。 + +```csharp +renderOptions.BackgroundColor = System.Drawing.Color.Transparent; +``` + +--- + +## 完整示例回顾 – 将 HTML 渲染为图像 + +将上述所有内容整合，下面是一段面向生产环境的代码片段，涵盖最常见的需求： + +```csharp +using System; +using Aspose.Html; +using Aspose.Html.Rendering.Image; +using Aspose.Html.Drawing; +using Aspose.Html.Converters; + +namespace HtmlToPngDemo +{ + class Program + { + static void Main() + { + // Load HTML (string, file, or URL) + string html = "" + + "Bold blue text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // Configure rendering for high quality and transparency + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, + TextOptions = { UseHinting = true }, + FontOptions = { WebFontStyle = WebFontStyle.Normal, FontFolder = @"C:\fonts" }, + BackgroundColor = System.Drawing.Color.Transparent, + ResolutionX = 150, + ResolutionY = 150 + }; + + // Convert and save + string outPath = @"C:\temp\html_snapshot.png"; + ImageConverter.ConvertHtmlToImage(document, outPath, renderOptions); + + Console.WriteLine($"Image saved to {outPath}"); + } + } +} +``` + +**预期输出：** 一个 `html_snapshot.png` 文件，包含在透明画布上呈现的粗体蓝色段落。图像经过抗锯齿处理，文本因提示而清晰锐利。 + +--- + +## 结论 + +现在，您已经掌握了如何使用 Aspose.HTML 在 C# 中 **从 HTML 创建 PNG**。通过构建 `HtmlDocument`、配置 `ImageRenderingOptions`，并调用 `ImageConverter.ConvertHtmlToImage`，您可以可靠地 **将 HTML 转换为 PNG**，并在任何自动化场景中 **将 HTML 渲染为图像**。 + +接下来您可以进一步探索： + +- 为动态网页生成缩略图。 +- 使用 Aspose.PDF 将 PNG 嵌入 PDF。 +- 将文件扩展名改为 JPEG 或 BMP，以相同方式生成其他格式。 + +欢迎尝试不同的 DPI、背景颜色以及多页渲染，以满足项目的精确需求。祝编码愉快！ + +## 接下来您可以学习什么？ + +以下教程涵盖与本指南技术紧密相关的主题，帮助您进一步掌握 API 功能并在项目中探索替代实现方式。每篇资源均提供完整可运行的代码示例和逐步解释。 + +- [Render HTML as PNG in .NET with Aspose.HTML](/html/english/net/rendering-html-documents/render-html-as-png/) +- [How to Render HTML as PNG – Complete C# Guide](/html/english/net/rendering-html-documents/how-to-render-html-as-png-complete-c-guide/) +- [Create PNG from HTML – Full C# Rendering Guide](/html/english/net/rendering-html-documents/create-png-from-html-full-c-rendering-guide/) + +{{< /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 a6c24babf2..133d30adfa 100644 --- a/html/chinese/net/html-extensions-and-conversions/_index.md +++ b/html/chinese/net/html-extensions-and-conversions/_index.md @@ -75,6 +75,9 @@ Aspose.HTML for .NET 不仅仅是一个库；它是 Web 开发领域的变革者 ### [在 C# 中将 HTML 保存为 ZIP – 完整内存示例](./save-html-to-zip-in-c-complete-in-memory-example/) 演示如何使用 Aspose.HTML for .NET 在 C# 中将 HTML 内容压缩为 ZIP 文件，完整的内存操作示例。 +### [在 C# 中将 HTML 保存为 ZIP – 步骤指南](./save-html-as-zip-in-c-step-by-step-guide/) +使用 Aspose.HTML for .NET 在 C# 中将 HTML 打包为 ZIP，提供完整的分步示例。 + ## 结论 总之，HTML 扩展和转换是现代 Web 开发的基本要素。Aspose.HTML for .NET 简化了该过程，使各个级别的开发人员都可以使用它。通过学习我们的教程，您将成为一名拥有广泛技能的熟练 Web 开发人员。 diff --git a/html/chinese/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md b/html/chinese/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..3e160b6c9d --- /dev/null +++ b/html/chinese/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md @@ -0,0 +1,319 @@ +--- +category: general +date: 2026-08-12 +description: 使用 Aspose.HTML 将 HTML 保存为 ZIP。学习加载 HTML 字符串、创建自定义资源处理程序，并高效生成 ZIP 压缩包。 +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save html as zip +- load html string +- custom resource handler +language: zh +lastmod: 2026-08-12 +og_description: 使用 Aspose.HTML 在 C# 中将 HTML 保存为 ZIP。本教程展示了如何加载 HTML 字符串、创建自定义资源处理程序，并在几个步骤中生成 + ZIP 压缩包。 +og_image_alt: Diagram showing save html as zip process with custom resource handler +og_title: 使用 Aspose.HTML 将 HTML 保存为 ZIP – 完整 C# 指南 +schemas: +- author: Aspose + dateModified: '2026-08-12' + description: Save HTML as ZIP using Aspose.HTML. Learn to load HTML string, create + a custom resource handler, and generate a ZIP archive efficiently. + headline: Save HTML as ZIP in C# – step‑by‑step guide + type: TechArticle +tags: +- Aspose.HTML +- C# +- ZIP archive +title: 在 C# 中将 HTML 保存为 ZIP – 步骤指南 +url: /zh/net/html-extensions-and-conversions/save-html-as-zip-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 保存为 ZIP – 步骤指南 + +如果您需要在 .NET 应用程序中 **将 HTML 保存为 ZIP**，本指南展示完整的工作流程。您将学习如何 **加载 HTML 字符串**、实现 **自定义资源处理程序**，以及在不将中间文件写入磁盘的情况下生成 ZIP 存档。 + +该方法使用 Aspose.HTML 5.x，提供高性能渲染引擎和灵活的保存选项。教程结束时，您将拥有一个可复用的处理程序，可集成到 Web 服务、后台任务或桌面工具中。 + +## 您将构建的内容 + +最终代码会创建一个基于 `MemoryStream` 的 ZIP 文件，包含 HTML 文档以及所有引用的资源（图片、CSS、字体）。ZIP 文件会写入目标文件夹，您也可以将目标改为 HTTP API 的响应流。 + +## 前置条件 + +- .NET 6.0 或更高版本（示例针对 .NET 6） +- Aspose.HTML for .NET（NuGet 包 `Aspose.HTML`） +- 对 C# 异步模式有基本了解（可选，但有帮助） + +> **专业提示：** 在开始之前使用 `dotnet add package Aspose.HTML` 安装该包。 + +## 步骤 1：定义自定义资源处理程序 + +**自定义资源处理程序**会拦截 HTML 渲染器发出的每个外部资源请求。通过返回流，您可以控制资源数据的存储位置。示例将所有内容存储在内存中，非常适合即时创建 ZIP 存档。 + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +///Hello, world!
+
+
+";
+
+// Create a new document instance.
+HtmlDocument document = new HtmlDocument();
+
+// Load the HTML markup.
+document.Open(htmlContent);
+```
+
+**此步骤的重要性：**
+**加载 HTML 字符串**的能力在 HTML 动态生成（例如模板引擎）或从 API 获取时非常有用。它避免了文件系统依赖，并可在沙箱环境中运行。
+
+## 步骤 3：配置保存选项以使用处理程序
+
+Aspose.HTML 的 `HtmlSaveOptions` 允许您指定输出的存储机制。将自定义处理程序分配给 `OutputStorage` 属性，并将 `Compress` 标志设为 true，以生成 ZIP 存档。
+
+```csharp
+// Instantiate the custom handler.
+var resourceHandler = new InMemoryResourceHandler();
+
+// Prepare save options.
+HtmlSaveOptions saveOptions = new HtmlSaveOptions
+{
+ // Use the handler for all external resources.
+ OutputStorage = resourceHandler,
+
+ // Enable ZIP compression.
+ Compress = true
+};
+```
+
+**此步骤的重要性：**
+`Compress = true` 告诉 Aspose.HTML 将 HTML 文件及所有收集的资源打包成单个 ZIP 包。`OutputStorage` 确保资源被捕获在内存中，而不是写入临时位置。
+
+## 步骤 4：将文档保存为 ZIP 存档
+
+现在调用 `HtmlDocument.Save`，传入目标路径和已配置的选项。保存后，ZIP 文件将包含 `index.html` 以及处理程序捕获的所有资源。
+
+```csharp
+// Define the output path (you can change this to a response stream for web APIs).
+string outputPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+
+// Save the document; Aspose.HTML creates the ZIP automatically.
+document.Save(outputPath, saveOptions);
+
+// Optional: Verify the resources that were stored.
+foreach (var entry in resourceHandler.Resources)
+{
+ Console.WriteLine($"Resource: {entry.Key}, Size: {entry.Value.Length} bytes");
+}
+```
+
+**预期结果：**
+运行程序会在当前目录生成 `output.zip`。解压该压缩包后会看到：
+
+```
+index.html
+styles.css
+logo.png
+```
+
+每个文件都对应标记中的引用，`index.html` 中的 HTML 指向已打包的资源。
+
+## 步骤 5：为真实资源数据适配处理程序（高级）
+
+上述基础处理程序会创建空流。在生产环境中，您通常需要写入实际内容（例如 `styles.css` 或 `logo.png` 的字节）。扩展 `HandleResource` 以从数据库、云存储或嵌入资源中获取数据。
+
+```csharp
+public override Stream HandleResource(ResourceInfo info)
+{
+ // Example: Load resource from an embedded folder.
+ string resourcePath = Path.Combine("EmbeddedResources", info.Path);
+ byte[] data = File.ReadAllBytes(resourcePath);
+
+ // Write data into a memory stream.
+ var stream = new MemoryStream(data);
+ _resources[info.Path] = stream;
+
+ // Return the populated stream.
+ return stream;
+}
+```
+
+**此变体的重要性：**
+提供真实内容可确保 ZIP 存档在浏览器中打开时能够正常工作。处理程序还可以在写入流之前进行转换（例如压缩 CSS）。
+
+## 步骤 6：在 Web API 中使用 ZIP 存档（可选）
+
+如果通过 ASP.NET Core 暴露此功能，可将 ZIP 文件作为文件结果返回：
+
+```csharp
+[HttpGet("download")]
+public IActionResult DownloadZip()
+{
+ // Reuse the same logic from steps 1‑4.
+ // ...
+
+ // Read the generated ZIP into a byte array.
+ byte[] zipBytes = System.IO.File.ReadAllBytes(outputPath);
+
+ // Return the file with the appropriate content type.
+ return File(zipBytes, "application/zip", "document.zip");
+}
+```
+
+**此步骤的重要性：**
+客户端可以直接下载打包好的 HTML，而无需处理服务器上的临时文件。该方法同样适用于磁盘访问受限的无服务器函数。
+
+## 常见陷阱及规避方法
+
+| 陷阱 | 原因 | 解决方案 |
+|------|------|----------|
+| ZIP 中资源为空 | 处理程序返回了未写入数据的全新 `MemoryStream` | 在返回前用实际字节填充流 |
+| 缺少 `index.html` 条目 | 未设置 `Compress` 标志或未分配 `OutputStorage` | 确保 `saveOptions.Compress = true` 且 `saveOptions.OutputStorage = handler` |
+| 大型 HTML 导致内存压力 | 所有资源都保存在内存中 | 切换到写入临时文件夹的 `FileStorage` 实现 |
+| 解压后相对 URL 失效 | 资源使用了未存储的绝对 URL | 在处理程序内部或后处理阶段将 URL 重写为相对路径 |
+
+## 完整可运行示例
+
+```csharp
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Saving;
+
+class InMemoryResourceHandler : ResourceHandler
+{
+ private readonly DictionaryHello, world!
+
+
+ ";
+
+ HtmlDocument doc = new HtmlDocument();
+ doc.Open(html);
+
+ // Step 1 & 3: Create handler and configure save options.
+ var handler = new InMemoryResourceHandler();
+ HtmlSaveOptions options = new HtmlSaveOptions
+ {
+ OutputStorage = handler,
+ Compress = true
+ };
+
+ // Step 4: Save as ZIP.
+ string zipPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+ doc.Save(zipPath, options);
+ Console.WriteLine($"ZIP file created at: {zipPath}");
+
+ // Optional verification.
+ foreach (var kvp in handler.Resources)
+ {
+ Console.WriteLine($"Resource {kvp.Key} captured, length {kvp.Value.Length} bytes");
+ }
+ }
+}
+```
+
+运行程序会在可执行文件旁生成 `output.zip`。解压后会看到 `index.html`、`styles.css` 和 `logo.png`（本最小示例中为占位空文件）。
+
+## 结论
+
+您现在掌握了使用 Aspose.HTML 在 C# 中 **将 HTML 保存为 ZIP** 的可靠方法。教程涵盖了加载 HTML 字符串、实现 **自定义资源处理程序**、配置保存选项以及生成可分发或下载的 ZIP 存档。
+
+接下来您可以：
+
+- 用真实内容替换占位流（例如从数据库读取）
+- 对于超大文档切换到基于文件的存储处理程序
+- 将逻辑集成到 ASP.NET Core 端点，实现按需下载
+- 探索 Aspose.HTML 的其他功能，如 PDF 转换或图像渲染
+
+尝试不同的资源来源和压缩设置，以满足性能和体积需求。祝编码愉快！
+
+## 接下来您可以学习什么？
+
+以下教程与本指南的技术紧密相关，帮助您进一步掌握 API 功能并探索替代实现方案：
+
+- [Save HTML as ZIP – Complete C# Tutorial](/html/english/net/html-extensions-and-conversions/save-html-as-zip-complete-c-tutorial/)
+- [How to Save HTML in C# – Complete Guide Using a Custom Resource Handler](/html/english/net/working-with-html-documents/how-to-save-html-in-c-complete-guide-using-a-custom-resource/)
+- [Create HTML from String in C# – Custom Resource Handler Guide](/html/english/net/html-document-manipulation/create-html-from-string-in-c-custom-resource-handler-guide/)
+
+{{< /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/generate-jpg-and-png-images/_index.md b/html/czech/net/generate-jpg-and-png-images/_index.md
index 11b9c84651..83a1747c92 100644
--- a/html/czech/net/generate-jpg-and-png-images/_index.md
+++ b/html/czech/net/generate-jpg-and-png-images/_index.md
@@ -45,6 +45,8 @@ Naučte se používat Aspose.HTML pro .NET k manipulaci s dokumenty HTML, převo
Naučte se, jak při převodu dokumentů DOCX na PNG nebo JPG povolit antialiasing pro hladší výstup.
### [Převod docx na png – vytvoření zip archivu C# tutoriál](./convert-docx-to-png-create-zip-archive-c-tutorial/)
Naučte se převést soubory DOCX na PNG a zabalit je do ZIP archivu pomocí C# a Aspose.HTML.
+### [Vytvořte PNG z HTML v C# pomocí Aspose.HTML](./create-png-from-html-in-c-using-aspose-html/)
+Naučte se převést HTML na PNG pomocí Aspose.HTML v jazyce C#.
## Závěr
diff --git a/html/czech/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md b/html/czech/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
new file mode 100644
index 0000000000..c0af5d11f3
--- /dev/null
+++ b/html/czech/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
@@ -0,0 +1,291 @@
+---
+category: general
+date: 2026-08-12
+description: Vytvořte PNG z HTML v C# pomocí Aspose.HTML. Naučte se, jak převést HTML
+ na PNG a vykreslit HTML jako obrázek pomocí několika řádků kódu.
+draft: false
+images:
+- PLACEHOLDER_URL/og-image.png
+keywords:
+- create png from html
+- convert html to png
+- render html as image
+- how to render html to image
+language: cs
+lastmod: 2026-08-12
+og_description: Vytvořte PNG z HTML v C# pomocí Aspose.HTML. Tento průvodce ukazuje,
+ jak rychle převést HTML na obrázek, zahrnuje možnosti konverze, nastavení kódu a
+ řešení problémů.
+og_image_alt: Screenshot of a C# program converting HTML to a PNG image
+og_title: Vytvořte PNG z HTML v C# – průvodce krok za krokem
+schemas:
+- author: Aspose
+ dateModified: '2026-08-12'
+ description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ headline: Create PNG from HTML in C# using Aspose.HTML
+ type: TechArticle
+- description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ name: Create PNG from HTML in C# using Aspose.HTML
+ steps:
+ - name: Why this works
+ text: '- **`HtmlDocument.Open`** parses the HTML string into a DOM that Aspose.HTML
+ can render. - **`ImageRenderingOptions`** lets you control anti‑aliasing, text
+ hinting, and font handling, which are essential when you **render HTML as image**
+ to avoid blurry text. - **`ImageConverter.ConvertHtmlToImage`*'
+ - name: 1. Preparing the HTML source
+ text: You can load HTML from a string (as shown), a local file, or a remote URL.
+ - name: 2. Fine‑tuning rendering options
+ text: '| Option | Effect | When to adjust | |--------|--------|----------------|
+ | `UseAntialiasing` | Reduces jagged edges on vector graphics | Always enable
+ for high‑quality output | | `TextOptions.UseHinting` | Sharpens glyph edges
+ | Important for small font sizes | | `FontOptions.WebFontStyle` | Choose'
+ - name: 3. Performing the conversion
+ text: The `ImageConverter` overload you used writes a single PNG file. If you
+ need multiple pages (e.g., a multi‑page HTML document), use the overload that
+ returns a collection of images.
+ - name: a. Missing fonts
+ text: If the HTML references a custom web font that isn’t installed on the server,
+ the rendered text falls back to a default font, which may affect layout.
+ - name: b. Large pages and memory consumption
+ text: Rendering a very tall page can consume a lot of RAM.
+ - name: c. Transparent backgrounds
+ text: PNG supports transparency, but the default background is white.
+ type: HowTo
+tags:
+- Aspose.HTML
+- C#
+- image rendering
+- HTML conversion
+title: Vytvořte PNG z HTML v C# pomocí Aspose.HTML
+url: /cs/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/
+---
+
+{{< blocks/products/pf/main-wrap-class >}}
+{{< blocks/products/pf/main-container >}}
+{{< blocks/products/pf/tutorial-page-section >}}
+
+# Vytvoření PNG z HTML v C# pomocí Aspose.HTML
+
+Pokud potřebujete **vytvořit PNG z HTML** v .NET aplikaci, tento průvodce vás provede kompletním procesem. Ukážeme vám, jak **převést HTML na PNG** pomocí několika řádků C# kódu, využívajíc výkonný renderovací engine Aspose.HTML.
+
+Renderování HTML jako obrázku je častý požadavek při generování náhledových obrázků, náhledů e‑mailů nebo reportů, které musí být vloženy do PDF. V následujících sekcích se naučíte přesné kroky, uvidíte kompletní funkční příklad a pochopíte, proč je každé nastavení důležité.
+
+## Co se naučíte
+
+- Jak vytvořit `HtmlDocument` ze řetězce nebo souboru.
+- Jak nakonfigurovat `ImageRenderingOptions` pro zlepšení kvality.
+- Jak **převést HTML na PNG** a uložit výsledek na disk.
+- Tipy pro práci s fonty, velkými stránkami a vlastními výstupními cestami.
+
+**Požadavky**
+- .NET 6.0 SDK (nebo novější) nainstalovaný.
+- Platná licence Aspose.HTML pro .NET (nebo dočasný evaluační klíč).
+- Základní znalost C# a Visual Studio nebo jakéhokoli .NET‑kompatibilního IDE.
+
+---
+
+## Vytvoření PNG z HTML pomocí Aspose.HTML
+
+Prvním krokem je nastavit prostředí a odkazovat na požadované jmenné prostory Aspose.HTML.
+
+```csharp
+using System;
+using Aspose.Html;
+using Aspose.Html.Rendering.Image;
+using Aspose.Html.Drawing;
+using Aspose.Html.Converters;
+
+namespace HtmlToPngDemo
+{
+ class Program
+ {
+ static void Main()
+ {
+ // 1️⃣ Build the HTML document from a raw string.
+ var html = "Bold text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // 2️⃣ Configure rendering options for best visual fidelity. + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, // Smooths edges of drawn shapes + TextOptions = { UseHinting = true }, // Improves glyph clarity + FontOptions = { WebFontStyle = WebFontStyle.Normal } // Uses standard web‑font style + }; + + // 3️⃣ Convert the HTML document to a PNG file. + string outputPath = @"output.png"; + ImageConverter.ConvertHtmlToImage(document, outputPath, renderOptions); + + Console.WriteLine($"PNG image created at: {outputPath}"); + } + } +} +``` + +### Proč to funguje + +- **`HtmlDocument.Open`** parsuje HTML řetězec do DOM, který může Aspose.HTML renderovat. +- **`ImageRenderingOptions`** vám umožňuje řídit anti‑aliasing, hintování textu a správu fontů, což je nezbytné při **renderování HTML jako obrázku**, aby nedocházelo k rozmazanému textu. +- **`ImageConverter.ConvertHtmlToImage`** provádí těžkou práci: rasterizuje DOM na bitmapu a zapíše PNG soubor. + +Spuštěním programu se vygeneruje `output.png`, který obsahuje tučný odstavec přesně tak, jak je definován ve zdrojovém HTML. + +--- + +## Převod HTML na PNG krok za krokem + +Níže je podrobnější průchod každou fází. Pochopení účelu každého řádku vám pomůže přizpůsobit kód pro větší nebo složitější stránky. + +### 1. Příprava HTML zdroje + +HTML můžete načíst ze řetězce (jak je ukázáno), lokálního souboru nebo vzdálené URL. + +```csharp +// Load from a file +var document = new HtmlDocument(); +document.Open(@"C:\templates\invoice.html"); + +// Load from a URL (requires internet access) +document.Open("https://example.com/report.html"); +``` + +**Tip:** Při načítání externích zdrojů (CSS, obrázky) se ujistěte, že vlastnost `BaseUrl` ukazuje na správnou složku, aby se relativní odkazy správně vyřešily. + +### 2. Jemné ladění renderovacích možností + +| Option | Effect | When to adjust | +|--------|--------|----------------| +| `UseAntialiasing` | Snižuje zubaté hrany na vektorové grafice | Vždy povoleno pro výstup vysoké kvality | +| `TextOptions.UseHinting` | Zostřuje hrany glifů | Důležité pro malé velikosti fontů | +| `FontOptions.WebFontStyle` | Volí normální, kurzívu nebo šikmý rendering web‑fontu | Použijte `WebFontStyle.Oblique` pro šikmé fonty | +| `ResolutionX` / `ResolutionY` | DPI výstupního obrázku | Zvyšte pro tiskové PNG (např. 300 DPI) | + +Příklad zvýšení DPI: + +```csharp +renderOptions.ResolutionX = 300; +renderOptions.ResolutionY = 300; +``` + +### 3. Provádění konverze + +`ImageConverter` přetížení, které jste použili, zapisuje jeden PNG soubor. Pokud potřebujete více stránek (např. vícestránkový HTML dokument), použijte přetížení, které vrací kolekci obrázků. + +```csharp +ImageConverter.ConvertHtmlToImages(document, "output_folder", renderOptions); +``` + +Každá stránka se uloží jako `output_folder/page_0.png`, `page_1.png` atd. + +--- + +## Renderování HTML jako obrázku – řešení běžných problémů + +### a. Chybějící fonty + +Pokud HTML odkazuje na vlastní web‑font, který není nainstalován na serveru, vykreslený text se vrátí k výchozímu fontu, což může ovlivnit rozvržení. + +**Řešení:** Vložte font pomocí pravidla `@font-face` ve vašem CSS nebo poskytněte lokální složku s fonty pomocí `FontOptions`. + +```csharp +renderOptions.FontOptions.FontFolder = @"C:\fonts"; +``` + +### b. Velké stránky a spotřeba paměti + +Renderování velmi vysoké stránky může spotřebovat hodně RAM. + +**Řešení:** Nastavte maximální výšku nebo rozdělte dokument na sekce před konverzí. + +```csharp +renderOptions.PageHeight = 2000; // pixels +``` + +### c. Průhledná pozadí + +PNG podporuje průhlednost, ale výchozí pozadí je bílé. + +**Řešení:** Změňte barvu pozadí na průhlednou. + +```csharp +renderOptions.BackgroundColor = System.Drawing.Color.Transparent; +``` + +--- + +## Jak renderovat HTML do obrázku – kompletní rekapitulace příkladu + +Spojením všeho dohromady získáte produkčně připravený úryvek, který pokrývá nejčastější požadavky: + +```csharp +using System; +using Aspose.Html; +using Aspose.Html.Rendering.Image; +using Aspose.Html.Drawing; +using Aspose.Html.Converters; + +namespace HtmlToPngDemo +{ + class Program + { + static void Main() + { + // Load HTML (string, file, or URL) + string html = "" + + "Bold blue text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // Configure rendering for high quality and transparency + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, + TextOptions = { UseHinting = true }, + FontOptions = { WebFontStyle = WebFontStyle.Normal, FontFolder = @"C:\fonts" }, + BackgroundColor = System.Drawing.Color.Transparent, + ResolutionX = 150, + ResolutionY = 150 + }; + + // Convert and save + string outPath = @"C:\temp\html_snapshot.png"; + ImageConverter.ConvertHtmlToImage(document, outPath, renderOptions); + + Console.WriteLine($"Image saved to {outPath}"); + } + } +} +``` + +**Očekávaný výstup:** Soubor `html_snapshot.png` obsahující tučný, modrý odstavec na průhledném plátně. Obrázek bude anti‑aliased, s ostrým textem díky hintingu. + +--- + +## Závěr + +Nyní víte, jak **vytvořit PNG z HTML** v C# pomocí Aspose.HTML. Vytvořením `HtmlDocument`, nastavením `ImageRenderingOptions` a voláním `ImageConverter.ConvertHtmlToImage` můžete spolehlivě **převést HTML na PNG** a **renderovat HTML jako obrázek** pro jakýkoli automatizační scénář. + +Odtud můžete dále zkoumat: + +- Generování náhledových obrázků pro dynamické webové stránky. +- Vkládání PNG do PDF pomocí Aspose.PDF. +- Použití stejného přístupu k vytvoření JPEG nebo BMP změnou přípony souboru. + +Neváhejte experimentovat s DPI, barvami pozadí a vícestránkovým renderováním, aby vyhovovaly přesným potřebám vašeho projektu. Šťastné kódování! + +## Co byste se měli naučit dál? + +Následující tutoriály pokrývají úzce související témata, která staví na technikách předvedených v tomto průvodci. Každý zdroj obsahuje kompletní funkční ukázky kódu s podrobnými vysvětleními, aby vám pomohl zvládnout další funkce API a prozkoumat alternativní přístupy ve vašich vlastních projektech. + +- [Renderování HTML jako PNG v .NET s Aspose.HTML](/html/english/net/rendering-html-documents/render-html-as-png/) +- [Jak renderovat HTML jako PNG – Kompletní průvodce v C#](/html/english/net/rendering-html-documents/how-to-render-html-as-png-complete-c-guide/) +- [Vytvoření PNG z HTML – Kompletní průvodce renderováním v C#](/html/english/net/rendering-html-documents/create-png-from-html-full-c-rendering-guide/) + +{{< /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 dc8f6f072d..214494bdf3 100644 --- a/html/czech/net/html-extensions-and-conversions/_index.md +++ b/html/czech/net/html-extensions-and-conversions/_index.md @@ -73,6 +73,8 @@ Naučte se vytvořit HTML dokument se stylovaným textem a převést jej do PDF Naučte se, jak uložit HTML soubor jako ZIP archiv pomocí Aspose.HTML pro .NET v kompletním C# tutoriálu. ### [Uložte HTML do ZIP v C# – Kompletní příklad v paměti](./save-html-to-zip-in-c-complete-in-memory-example/) Naučte se, jak uložit HTML soubor do ZIP archivu v paměti pomocí Aspose.HTML pro .NET v C#. +### [Uložte HTML jako ZIP v C# – krok za krokem](./save-html-as-zip-in-c-step-by-step-guide/) +Naučte se, jak v C# krok po kroku uložit HTML soubor do ZIP archivu pomocí Aspose.HTML pro .NET. ## Závěr diff --git a/html/czech/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md b/html/czech/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..8ac2967fad --- /dev/null +++ b/html/czech/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md @@ -0,0 +1,319 @@ +--- +category: general +date: 2026-08-12 +description: Uložte HTML jako ZIP pomocí Aspose.HTML. Naučte se načíst HTML řetězec, + vytvořit vlastní obslužný program zdrojů a efektivně vygenerovat ZIP archiv. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save html as zip +- load html string +- custom resource handler +language: cs +lastmod: 2026-08-12 +og_description: Uložte HTML jako ZIP pomocí Aspose.HTML v C#. Tento tutoriál ukazuje, + jak načíst řetězec HTML, vytvořit vlastní manipulátor zdrojů a v několika krocích + vygenerovat ZIP archiv. +og_image_alt: Diagram showing save html as zip process with custom resource handler +og_title: Uložte HTML jako ZIP s Aspose.HTML – kompletní průvodce C# +schemas: +- author: Aspose + dateModified: '2026-08-12' + description: Save HTML as ZIP using Aspose.HTML. Learn to load HTML string, create + a custom resource handler, and generate a ZIP archive efficiently. + headline: Save HTML as ZIP in C# – step‑by‑step guide + type: TechArticle +tags: +- Aspose.HTML +- C# +- ZIP archive +title: Uložení HTML jako ZIP v C# – průvodce krok za krokem +url: /cs/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Uložení HTML jako ZIP v C# – krok za krokem průvodce + +Pokud potřebujete **uložit HTML jako ZIP** v .NET aplikaci, tento průvodce ukazuje kompletní pracovní postup. Naučíte se, jak **načíst HTML řetězec**, implementovat **vlastní manipulátor zdrojů** a vytvořit ZIP archiv, aniž byste zapisovali mezilehlé soubory na disk. + +Přístup používá Aspose.HTML 5.x, který poskytuje vysoce výkonný renderovací engine a flexibilní možnosti ukládání. Na konci tutoriálu budete mít znovupoužitelný manipulátor, který lze integrovat do webových služeb, background jobů nebo desktopových nástrojů. + +## Co vytvoříte + +Konečný kód vytvoří ZIP soubor založený na `MemoryStream`, který obsahuje HTML dokument a všechny odkazované zdroje (obrázky, CSS, fonty). ZIP soubor je zapsán do cílové složky, ale můžete změnit destinaci na response stream pro HTTP API. + +## Prerequisites + +- .NET 6.0 nebo novější (ukázka cílí na .NET 6) +- Aspose.HTML pro .NET (NuGet balíček `Aspose.HTML`) +- Základní znalost asynchronních vzorů v C# (volitelné, ale užitečné) + +> **Tip:** Nainstalujte balíček pomocí `dotnet add package Aspose.HTML` před zahájením. + +## Krok 1: Definujte vlastní manipulátor zdrojů + +**Vlastní manipulátor zdrojů** zachytává každý požadavek na externí zdroj, který renderér HTML provádí. Vrácením streamu řídíte, kde jsou data zdroje uložena. Příklad ukládá vše do paměti, což je ideální pro tvorbu ZIP archivu za běhu. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +///Hello, world!
+
+
+";
+
+// Create a new document instance.
+HtmlDocument document = new HtmlDocument();
+
+// Load the HTML markup.
+document.Open(htmlContent);
+```
+
+**Proč je tento krok důležitý:**
+Schopnost **load html string** je užitečná, když je HTML generováno dynamicky (např. z templating engine) nebo přijímáno z API. Vyhýbá se závislostem na souborovém systému a funguje v sandboxovaných prostředích.
+
+## Krok 3: Nakonfigurujte možnosti ukládání pro použití manipulátoru
+
+`HtmlSaveOptions` v Aspose.HTML umožňují specifikovat úložný mechanismus pro výstup. Přiřaďte vlastní manipulátor k vlastnosti `OutputStorage` a nastavte příznak `Compress`, aby se vytvořil ZIP archiv.
+
+```csharp
+// Instantiate the custom handler.
+var resourceHandler = new InMemoryResourceHandler();
+
+// Prepare save options.
+HtmlSaveOptions saveOptions = new HtmlSaveOptions
+{
+ // Use the handler for all external resources.
+ OutputStorage = resourceHandler,
+
+ // Enable ZIP compression.
+ Compress = true
+};
+```
+
+**Proč je tento krok důležitý:**
+`Compress = true` říká Aspose.HTML, aby zabalil HTML soubor a všechny nasbírané zdroje do jednoho ZIP balíčku. `OutputStorage` zajišťuje, že zdroje jsou zachyceny v paměti místo zápisu do dočasných umístění.
+
+## Krok 4: Uložte dokument jako ZIP archiv
+
+Nyní zavolejte `HtmlDocument.Save`, předáte cestu k cíli a nakonfigurované možnosti. Po uložení ZIP soubor obsahuje `index.html` plus všechny zdroje zachycené manipulátorem.
+
+```csharp
+// Define the output path (you can change this to a response stream for web APIs).
+string outputPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+
+// Save the document; Aspose.HTML creates the ZIP automatically.
+document.Save(outputPath, saveOptions);
+
+// Optional: Verify the resources that were stored.
+foreach (var entry in resourceHandler.Resources)
+{
+ Console.WriteLine($"Resource: {entry.Key}, Size: {entry.Value.Length} bytes");
+}
+```
+
+**Očekávaný výsledek:**
+Spuštěním programu se vytvoří `output.zip` v aktuálním adresáři. Rozbalení archivu odhalí:
+
+```
+index.html
+styles.css
+logo.png
+```
+
+Každý soubor odpovídá odkazům v markupu a HTML v `index.html` ukazuje na zabalené zdroje.
+
+## Krok 5: Přizpůsobte manipulátor pro skutečná data zdrojů (pokročilé)
+
+Základní manipulátor výše vytváří prázdné streamy. V produkci často potřebujete zapsat skutečný obsah (např. bajty `styles.css` nebo `logo.png`). Rozšiřte `HandleResource`, aby načítal data z databáze, cloudového bucketu nebo vloženého zdroje.
+
+```csharp
+public override Stream HandleResource(ResourceInfo info)
+{
+ // Example: Load resource from an embedded folder.
+ string resourcePath = Path.Combine("EmbeddedResources", info.Path);
+ byte[] data = File.ReadAllBytes(resourcePath);
+
+ // Write data into a memory stream.
+ var stream = new MemoryStream(data);
+ _resources[info.Path] = stream;
+
+ // Return the populated stream.
+ return stream;
+}
+```
+
+**Proč je tato varianta důležitá:**
+Poskytnutí reálného obsahu zajišťuje, že ZIP archiv bude funkční při otevření v prohlížeči. Manipulátor může také aplikovat transformace (např. minifikaci CSS) před zápisem do streamu.
+
+## Krok 6: Použijte ZIP archiv ve webovém API (volitelné)
+
+Pokud exponujete funkčnost přes ASP.NET Core, vraťte ZIP soubor jako výsledek souboru:
+
+```csharp
+[HttpGet("download")]
+public IActionResult DownloadZip()
+{
+ // Reuse the same logic from steps 1‑4.
+ // ...
+
+ // Read the generated ZIP into a byte array.
+ byte[] zipBytes = System.IO.File.ReadAllBytes(outputPath);
+
+ // Return the file with the appropriate content type.
+ return File(zipBytes, "application/zip", "document.zip");
+}
+```
+
+**Proč je tento krok důležitý:**
+Klienti mohou stáhnout zabalené HTML bez nutnosti pracovat s dočasnými soubory na serveru. Přístup funguje i v serverless funkcích, kde je přístup na disk omezený.
+
+## Časté úskalí a jak se jim vyhnout
+
+| Problém | Důvod | Řešení |
+|---------|--------|-----|
+| Prázdné zdroje v ZIP | Manipulátor vrací nový `MemoryStream` bez zápisu dat | Naplňte stream skutečnými bajty před jeho vrácením |
+| Chybějící položka `index.html` | `Compress` příznak není nastaven nebo `OutputStorage` není přiřazen | Ujistěte se, že `saveOptions.Compress = true` a `saveOptions.OutputStorage = handler` |
+| Velké HTML způsobující tlak na paměť | Všechny zdroje jsou uchovávány v paměti | Přepněte na implementaci `FileStorage`, která zapisuje do dočasné složky |
+| Relativní URL se po rozbalení porouchají | Zdroje odkazované pomocí absolutních URL, které nejsou uloženy | Přepište URL na relativní cesty uvnitř manipulátoru nebo během post‑processingu |
+
+## Kompletní, spustitelný příklad
+
+```csharp
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Saving;
+
+class InMemoryResourceHandler : ResourceHandler
+{
+ private readonly DictionaryHello, world!
+
+
+ ";
+
+ HtmlDocument doc = new HtmlDocument();
+ doc.Open(html);
+
+ // Step 1 & 3: Create handler and configure save options.
+ var handler = new InMemoryResourceHandler();
+ HtmlSaveOptions options = new HtmlSaveOptions
+ {
+ OutputStorage = handler,
+ Compress = true
+ };
+
+ // Step 4: Save as ZIP.
+ string zipPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+ doc.Save(zipPath, options);
+ Console.WriteLine($"ZIP file created at: {zipPath}");
+
+ // Optional verification.
+ foreach (var kvp in handler.Resources)
+ {
+ Console.WriteLine($"Resource {kvp.Key} captured, length {kvp.Value.Length} bytes");
+ }
+ }
+}
+```
+
+Spuštěním programu se vytvoří `output.zip` vedle spustitelného souboru. Rozbalení archivu ukáže `index.html`, `styles.css` a `logo.png` (prázdné placeholdery v tomto minimálním příkladu).
+
+## Závěr
+
+Nyní máte spolehlivou metodu k **uložení HTML jako ZIP** pomocí Aspose.HTML v C#. Tutoriál pokryl načítání HTML řetězce, implementaci **vlastního manipulátoru zdrojů**, konfiguraci možností ukládání a generování ZIP archivu připraveného k distribuci nebo stažení.
+
+- Nahraďte placeholderové streamy skutečným obsahem (např. načtením z databáze)
+- Přepněte na manipulátor úložiště založený na souborech pro velmi velké dokumenty
+- Integrovat logiku do endpointů ASP.NET Core pro stahování na vyžádání
+- Prozkoumejte další funkce Aspose.HTML, jako je konverze do PDF nebo vykreslování obrázků
+
+Experimentujte s různými zdroji zdrojů a nastaveními komprese, abyste řešení přizpůsobili svým požadavkům na výkon a velikost. Šťastné kódování!
+
+## Co byste se měli naučit dál?
+
+Následující tutoriály pokrývají úzce související témata, která staví na technikách předvedených v tomto průvodci. Každý zdroj obsahuje kompletní funkční ukázky kódu s krok‑za‑krokem vysvětleními, která vám pomohou zvládnout další funkce API a prozkoumat alternativní implementační přístupy ve vašich projektech.
+
+- [Uložení HTML jako ZIP – kompletní C# tutoriál](/html/english/net/html-extensions-and-conversions/save-html-as-zip-complete-c-tutorial/)
+- [Jak uložit HTML v C# – kompletní průvodce s použitím vlastního manipulátoru zdrojů](/html/english/net/working-with-html-documents/how-to-save-html-in-c-complete-guide-using-a-custom-resource/)
+- [Vytvoření HTML ze řetězce v C# – průvodce vlastním manipulátorem zdrojů](/html/english/net/html-document-manipulation/create-html-from-string-in-c-custom-resource-handler-guide/)
+
+{{< /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/generate-jpg-and-png-images/_index.md b/html/dutch/net/generate-jpg-and-png-images/_index.md
index e05f0c0a7d..edca25f454 100644
--- a/html/dutch/net/generate-jpg-and-png-images/_index.md
+++ b/html/dutch/net/generate-jpg-and-png-images/_index.md
@@ -45,6 +45,8 @@ Leer hoe u Aspose.HTML voor .NET kunt gebruiken om HTML-documenten te bewerken,
Leer hoe u antialiasing inschakelt bij het omzetten van DOCX-bestanden naar PNG- of JPG-afbeeldingen met Aspose.HTML.
### [docx naar png converteren – zip-archief maken C#-tutorial](./convert-docx-to-png-create-zip-archive-c-tutorial/)
Leer hoe u een DOCX-bestand naar PNG converteert en de resultaten in een zip-archief opslaat met C# en Aspose.HTML.
+### [PNG maken vanuit HTML in C# met Aspose.HTML](./create-png-from-html-in-c-using-aspose-html/)
+Leer hoe u met Aspose.HTML voor .NET PNG-afbeeldingen genereert vanuit HTML in C#.
## Conclusie
diff --git a/html/dutch/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md b/html/dutch/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
new file mode 100644
index 0000000000..ae58706255
--- /dev/null
+++ b/html/dutch/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
@@ -0,0 +1,290 @@
+---
+category: general
+date: 2026-08-12
+description: Maak PNG van HTML in C# met Aspose.HTML. Leer hoe je HTML naar PNG kunt
+ converteren en HTML als afbeelding kunt renderen in slechts een paar regels code.
+draft: false
+images:
+- PLACEHOLDER_URL/og-image.png
+keywords:
+- create png from html
+- convert html to png
+- render html as image
+- how to render html to image
+language: nl
+lastmod: 2026-08-12
+og_description: Maak PNG van HTML in C# met Aspose.HTML. Deze gids laat zien hoe je
+ HTML snel als afbeelding rendert, met conversie‑opties, code‑instelling en probleemoplossing.
+og_image_alt: Screenshot of a C# program converting HTML to a PNG image
+og_title: PNG maken van HTML in C# – stapsgewijze handleiding
+schemas:
+- author: Aspose
+ dateModified: '2026-08-12'
+ description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ headline: Create PNG from HTML in C# using Aspose.HTML
+ type: TechArticle
+- description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ name: Create PNG from HTML in C# using Aspose.HTML
+ steps:
+ - name: Why this works
+ text: '- **`HtmlDocument.Open`** parses the HTML string into a DOM that Aspose.HTML
+ can render. - **`ImageRenderingOptions`** lets you control anti‑aliasing, text
+ hinting, and font handling, which are essential when you **render HTML as image**
+ to avoid blurry text. - **`ImageConverter.ConvertHtmlToImage`*'
+ - name: 1. Preparing the HTML source
+ text: You can load HTML from a string (as shown), a local file, or a remote URL.
+ - name: 2. Fine‑tuning rendering options
+ text: '| Option | Effect | When to adjust | |--------|--------|----------------|
+ | `UseAntialiasing` | Reduces jagged edges on vector graphics | Always enable
+ for high‑quality output | | `TextOptions.UseHinting` | Sharpens glyph edges
+ | Important for small font sizes | | `FontOptions.WebFontStyle` | Choose'
+ - name: 3. Performing the conversion
+ text: The `ImageConverter` overload you used writes a single PNG file. If you
+ need multiple pages (e.g., a multi‑page HTML document), use the overload that
+ returns a collection of images.
+ - name: a. Missing fonts
+ text: If the HTML references a custom web font that isn’t installed on the server,
+ the rendered text falls back to a default font, which may affect layout.
+ - name: b. Large pages and memory consumption
+ text: Rendering a very tall page can consume a lot of RAM.
+ - name: c. Transparent backgrounds
+ text: PNG supports transparency, but the default background is white.
+ type: HowTo
+tags:
+- Aspose.HTML
+- C#
+- image rendering
+- HTML conversion
+title: PNG maken van HTML in C# met Aspose.HTML
+url: /nl/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/
+---
+
+{{< blocks/products/pf/main-wrap-class >}}
+{{< blocks/products/pf/main-container >}}
+{{< blocks/products/pf/tutorial-page-section >}}
+
+# PNG maken vanuit HTML in C# met Aspose.HTML
+
+Als je **PNG wilt maken vanuit HTML** in een .NET‑applicatie, leidt deze gids je stap voor stap door het volledige proces. Je ziet hoe je **HTML naar PNG converteert** met slechts een paar regels C#‑code, met behulp van de krachtige renderengine van Aspose.HTML.
+
+HTML renderen als afbeelding is een veelvoorkomende behoefte bij het genereren van thumbnails, e‑mail‑voorbeelden of rapporten die in PDF’s moeten worden ingebed. In de volgende secties leer je de exacte stappen, zie je een volledig werkend voorbeeld en begrijp je waarom elke instelling belangrijk is.
+
+## Wat je zult leren
+
+- Hoe je een `HtmlDocument` bouwt vanuit een string of bestand.
+- Hoe je `ImageRenderingOptions` configureert om de kwaliteit te verbeteren.
+- Hoe je **HTML naar PNG converteert** en het resultaat opslaat op schijf.
+- Tips voor het omgaan met lettertypen, grote pagina’s en aangepaste output‑paden.
+
+**Prerequisites**
+- .NET 6.0 SDK (of later) geïnstalleerd.
+- Een geldige Aspose.HTML for .NET‑licentie (of een tijdelijke evaluatiesleutel).
+- Basiskennis van C# en Visual Studio of een andere .NET‑compatibele IDE.
+
+---
+
+## PNG maken vanuit HTML met Aspose.HTML
+
+De eerste stap is het opzetten van de omgeving en het refereren van de benodigde Aspose.HTML‑namespaces.
+
+```csharp
+using System;
+using Aspose.Html;
+using Aspose.Html.Rendering.Image;
+using Aspose.Html.Drawing;
+using Aspose.Html.Converters;
+
+namespace HtmlToPngDemo
+{
+ class Program
+ {
+ static void Main()
+ {
+ // 1️⃣ Build the HTML document from a raw string.
+ var html = "Bold text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // 2️⃣ Configure rendering options for best visual fidelity. + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, // Smooths edges of drawn shapes + TextOptions = { UseHinting = true }, // Improves glyph clarity + FontOptions = { WebFontStyle = WebFontStyle.Normal } // Uses standard web‑font style + }; + + // 3️⃣ Convert the HTML document to a PNG file. + string outputPath = @"output.png"; + ImageConverter.ConvertHtmlToImage(document, outputPath, renderOptions); + + Console.WriteLine($"PNG image created at: {outputPath}"); + } + } +} +``` + +### Waarom dit werkt + +- **`HtmlDocument.Open`** parseert de HTML‑string naar een DOM die Aspose.HTML kan renderen. +- **`ImageRenderingOptions`** stelt je in staat anti‑aliasing, tekst‑hinting en lettertype‑beheer te regelen, wat essentieel is wanneer je **HTML als afbeelding rendert** om onscherpe tekst te voorkomen. +- **`ImageConverter.ConvertHtmlToImage`** doet het zware werk: het rastert de DOM op een bitmap en schrijft het PNG‑bestand. + +Het uitvoeren van het programma genereert `output.png` met de vetgedrukte alinea precies zoals gedefinieerd in de HTML‑bron. + +--- + +## HTML naar PNG stap voor stap + +Hieronder volgt een meer gedetailleerde walkthrough van elke fase. Het begrijpen van het doel van elke regel helpt je de code aan te passen voor grotere of complexere pagina’s. + +### 1. De HTML‑bron voorbereiden + +Je kunt HTML laden vanuit een string (zoals getoond), een lokaal bestand of een externe URL. + +```csharp +// Load from a file +var document = new HtmlDocument(); +document.Open(@"C:\templates\invoice.html"); + +// Load from a URL (requires internet access) +document.Open("https://example.com/report.html"); +``` + +**Tip:** Wanneer je externe bronnen (CSS, afbeeldingen) laadt, zorg er dan voor dat de eigenschap `BaseUrl` naar de juiste map wijst zodat relatieve links correct worden opgelost. + +### 2. Rendering‑opties fijn afstellen + +| Optie | Effect | Wanneer aan te passen | +|--------|--------|------------------------| +| `UseAntialiasing` | Vermindert gekartelde randen op vector‑graphics | Altijd inschakelen voor hoge kwaliteit | +| `TextOptions.UseHinting` | Verscherpt de glyph‑randen | Belangrijk voor kleine lettergroottes | +| `FontOptions.WebFontStyle` | Bepaalt normale, cursieve of schuine weergave van web‑fonts | Gebruik `WebFontStyle.Oblique` voor schuine fonts | +| `ResolutionX` / `ResolutionY` | DPI van de output‑afbeelding | Verhogen voor print‑klare PNG’s (bijv. 300 DPI) | + +Voorbeeld van DPI verhogen: + +```csharp +renderOptions.ResolutionX = 300; +renderOptions.ResolutionY = 300; +``` + +### 3. De conversie uitvoeren + +De `ImageConverter`‑overload die je gebruikte schrijft één PNG‑bestand. Als je meerdere pagina’s nodig hebt (bijv. een meer‑pagina HTML‑document), gebruik dan de overload die een collectie afbeeldingen retourneert. + +```csharp +ImageConverter.ConvertHtmlToImages(document, "output_folder", renderOptions); +``` + +Elke pagina wordt `output_folder/page_0.png`, `page_1.png`, enzovoort. + +--- + +## HTML renderen als afbeelding – veelvoorkomende valkuilen + +### a. Ontbrekende lettertypen + +Als de HTML een aangepast web‑font verwijst dat niet op de server is geïnstalleerd, valt de gerenderde tekst terug op een standaardlettertype, wat de lay‑out kan beïnvloeden. + +**Oplossing:** Embed het font met een `@font-face`‑regel in je CSS of lever een lokale lettertype‑map via `FontOptions`. + +```csharp +renderOptions.FontOptions.FontFolder = @"C:\fonts"; +``` + +### b. Grote pagina’s en geheugenverbruik + +Het renderen van een zeer lange pagina kan veel RAM verbruiken. + +**Oplossing:** Stel een maximale hoogte in of splits het document in secties vóór conversie. + +```csharp +renderOptions.PageHeight = 2000; // pixels +``` + +### c. Transparante achtergronden + +PNG ondersteunt transparantie, maar de standaardachtergrond is wit. + +**Oplossing:** Verander de achtergrondkleur naar transparant. + +```csharp +renderOptions.BackgroundColor = System.Drawing.Color.Transparent; +``` + +--- + +## Hoe HTML naar afbeelding te renderen – volledige voorbeeld‑samenvatting + +Alles bij elkaar, hier is een productie‑klaar fragment dat de meest voorkomende eisen dekt: + +```csharp +using System; +using Aspose.Html; +using Aspose.Html.Rendering.Image; +using Aspose.Html.Drawing; +using Aspose.Html.Converters; + +namespace HtmlToPngDemo +{ + class Program + { + static void Main() + { + // Load HTML (string, file, or URL) + string html = "" + + "Bold blue text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // Configure rendering for high quality and transparency + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, + TextOptions = { UseHinting = true }, + FontOptions = { WebFontStyle = WebFontStyle.Normal, FontFolder = @"C:\fonts" }, + BackgroundColor = System.Drawing.Color.Transparent, + ResolutionX = 150, + ResolutionY = 150 + }; + + // Convert and save + string outPath = @"C:\temp\html_snapshot.png"; + ImageConverter.ConvertHtmlToImage(document, outPath, renderOptions); + + Console.WriteLine($"Image saved to {outPath}"); + } + } +} +``` + +**Verwachte output:** Een `html_snapshot.png`‑bestand met een vetgedrukte, blauwe alinea op een transparante canvas. De afbeelding wordt anti‑aliased, met scherpe tekst dankzij hinting. + +--- + +## Conclusie + +Je weet nu hoe je **PNG maakt vanuit HTML** in C# met Aspose.HTML. Door een `HtmlDocument` te construeren, `ImageRenderingOptions` te configureren en `ImageConverter.ConvertHtmlToImage` aan te roepen, kun je betrouwbaar **HTML naar PNG converteren** en **HTML als afbeelding renderen** voor elk automatiseringsscenario. + +Vanaf hier kun je verder verkennen: + +- Thumbnails genereren voor dynamische webpagina’s. +- De PNG in PDF’s embedden met Aspose.PDF. +- Dezelfde aanpak gebruiken om JPEG of BMP te produceren door de bestandsextensie te wijzigen. + +Voel je vrij om te experimenteren met DPI, achtergrondkleuren en multi‑page rendering om precies aan de behoeften van je project te voldoen. Veel programmeerplezier! + +## Wat moet je hierna leren? + +De volgende tutorials behandelen nauw verwante onderwerpen die voortbouwen op de technieken die in deze gids worden getoond. Elke bron bevat volledige werkende code‑voorbeelden met stap‑voor‑stap uitleg om je te helpen extra API‑functies onder de knie te krijgen en alternatieve implementatie‑benaderingen in je eigen projecten te verkennen. + +- [Render HTML as PNG in .NET with Aspose.HTML](/html/english/net/rendering-html-documents/render-html-as-png/) +- [How to Render HTML as PNG – Complete C# Guide](/html/english/net/rendering-html-documents/how-to-render-html-as-png-complete-c-guide/) +- [Create PNG from HTML – Full C# Rendering Guide](/html/english/net/rendering-html-documents/create-png-from-html-full-c-rendering-guide/) + +{{< /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 fd924a78c2..d2436cd242 100644 --- a/html/dutch/net/html-extensions-and-conversions/_index.md +++ b/html/dutch/net/html-extensions-and-conversions/_index.md @@ -72,6 +72,8 @@ Leer hoe u met Aspose.HTML voor .NET PDF's genereert vanuit HTML met een duideli ### [HTML opslaan als ZIP – Complete C#-tutorial](./save-html-as-zip-complete-c-tutorial/) ### [HTML opslaan naar ZIP in C# – Volledig In‑Memory voorbeeld](./save-html-to-zip-in-c-complete-in-memory-example/) Leer hoe u HTML-inhoud in het geheugen comprimeert en opslaat als ZIP-bestand met Aspose.HTML voor .NET in C#. +### [HTML opslaan als ZIP in C# – stapsgewijze handleiding](./save-html-as-zip-in-c-step-by-step-guide/) +Leer hoe u HTML opslaat als ZIP in C# met een stapsgewijze handleiding. ## Conclusie diff --git a/html/dutch/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md b/html/dutch/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..d777b31090 --- /dev/null +++ b/html/dutch/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md @@ -0,0 +1,319 @@ +--- +category: general +date: 2026-08-12 +description: HTML opslaan als ZIP met Aspose.HTML. Leer hoe je een HTML‑string laadt, + een aangepaste resource‑handler maakt en efficiënt een ZIP‑archief genereert. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save html as zip +- load html string +- custom resource handler +language: nl +lastmod: 2026-08-12 +og_description: HTML opslaan als ZIP met Aspose.HTML in C#. Deze tutorial laat zien + hoe je een HTML‑string laadt, een aangepaste resource‑handler maakt en in enkele + stappen een ZIP‑archief genereert. +og_image_alt: Diagram showing save html as zip process with custom resource handler +og_title: HTML opslaan als ZIP met Aspose.HTML – volledige C#‑gids +schemas: +- author: Aspose + dateModified: '2026-08-12' + description: Save HTML as ZIP using Aspose.HTML. Learn to load HTML string, create + a custom resource handler, and generate a ZIP archive efficiently. + headline: Save HTML as ZIP in C# – step‑by‑step guide + type: TechArticle +tags: +- Aspose.HTML +- C# +- ZIP archive +title: HTML opslaan als ZIP in C# – stapsgewijze handleiding +url: /nl/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# HTML opslaan als ZIP in C# – stapsgewijze handleiding + +Als je **HTML als ZIP wilt opslaan** in een .NET‑applicatie, laat deze handleiding de volledige workflow zien. Je leert hoe je een **HTML‑string laadt**, een **aangepaste resource‑handler** implementeert en een ZIP‑archief maakt zonder tussentijdse bestanden naar schijf te schrijven. + +De aanpak maakt gebruik van Aspose.HTML 5.x, die een high‑performance renderengine en flexibele opslaan‑opties biedt. Aan het einde van de tutorial heb je een herbruikbare handler die kan worden geïntegreerd in webservices, achtergrondtaken of desktop‑tools. + +## Wat je gaat bouwen + +De uiteindelijke code maakt een op `MemoryStream` gebaseerd ZIP‑bestand dat het HTML‑document en alle verwezen bronnen (afbeeldingen, CSS, fonts) bevat. Het ZIP‑bestand wordt naar een doelmap geschreven, maar je kunt de bestemming wijzigen naar een response‑stream voor HTTP‑API's. + +## Vereisten + +- .NET 6.0 of later (het voorbeeld richt zich op .NET 6) +- Aspose.HTML voor .NET (NuGet‑pakket `Aspose.HTML`) +- Basiskennis van C# async‑patronen (optioneel maar nuttig) + +> **Pro tip:** Installeer het pakket met `dotnet add package Aspose.HTML` voordat je begint. + +## Stap 1: Definieer een aangepaste resource‑handler + +Een **aangepaste resource‑handler** onderschept elk extern resource‑verzoek dat de HTML‑renderer maakt. Door een stream te retourneren, bepaal je waar de resource‑data wordt opgeslagen. Het voorbeeld slaat alles in het geheugen op, wat ideaal is voor het on‑the‑fly maken van een ZIP‑archief. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +///Hello, world!
+
+
+";
+
+// Create a new document instance.
+HtmlDocument document = new HtmlDocument();
+
+// Load the HTML markup.
+document.Open(htmlContent);
+```
+
+**Waarom deze stap belangrijk is:**
+De mogelijkheid om **HTML‑string te laden** is handig wanneer HTML dynamisch wordt gegenereerd (bijv. vanuit een template‑engine) of ontvangen van een API. Het vermijdt afhankelijkheden van het bestandssysteem en werkt in sandbox‑omgevingen.
+
+## Stap 3: Configureer opslaan‑opties om de handler te gebruiken
+
+Met `HtmlSaveOptions` van Aspose.HTML kun je het opslagmechanisme voor de output opgeven. Wijs de aangepaste handler toe aan de eigenschap `OutputStorage` en stel de vlag `Compress` in om een ZIP‑archief te produceren.
+
+```csharp
+// Instantiate the custom handler.
+var resourceHandler = new InMemoryResourceHandler();
+
+// Prepare save options.
+HtmlSaveOptions saveOptions = new HtmlSaveOptions
+{
+ // Use the handler for all external resources.
+ OutputStorage = resourceHandler,
+
+ // Enable ZIP compression.
+ Compress = true
+};
+```
+
+**Waarom deze stap belangrijk is:**
+`Compress = true` vertelt Aspose.HTML om het HTML‑bestand en alle verzamelde resources in één ZIP‑pakket te bundelen. De `OutputStorage` zorgt ervoor dat resources in het geheugen worden vastgelegd in plaats van naar tijdelijke locaties te worden geschreven.
+
+## Stap 4: Sla het document op als een ZIP‑archief
+
+Roep nu `HtmlDocument.Save` aan, met het bestemmingspad en de geconfigureerde opties. Na het opslaan bevat het ZIP‑bestand `index.html` plus alle resources die door de handler zijn vastgelegd.
+
+```csharp
+// Define the output path (you can change this to a response stream for web APIs).
+string outputPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+
+// Save the document; Aspose.HTML creates the ZIP automatically.
+document.Save(outputPath, saveOptions);
+
+// Optional: Verify the resources that were stored.
+foreach (var entry in resourceHandler.Resources)
+{
+ Console.WriteLine($"Resource: {entry.Key}, Size: {entry.Value.Length} bytes");
+}
+```
+
+**Verwacht resultaat:**
+Het uitvoeren van het programma maakt `output.zip` aan in de huidige map. Het uitpakken van het archief toont:
+
+```
+index.html
+styles.css
+logo.png
+```
+
+Elk bestand komt overeen met de markup‑referenties, en de HTML in `index.html` verwijst naar de gebundelde resources.
+
+## Stap 5: Pas de handler aan voor echte resource‑data (geavanceerd)
+
+De bovenstaande basis‑handler maakt lege streams aan. In productie moet je vaak de daadwerkelijke inhoud schrijven (bijv. de bytes van `styles.css` of `logo.png`). Breid `HandleResource` uit om data op te halen uit een database, een cloud‑bucket of een ingebedde resource.
+
+```csharp
+public override Stream HandleResource(ResourceInfo info)
+{
+ // Example: Load resource from an embedded folder.
+ string resourcePath = Path.Combine("EmbeddedResources", info.Path);
+ byte[] data = File.ReadAllBytes(resourcePath);
+
+ // Write data into a memory stream.
+ var stream = new MemoryStream(data);
+ _resources[info.Path] = stream;
+
+ // Return the populated stream.
+ return stream;
+}
+```
+
+**Waarom deze variatie belangrijk is:**
+Het leveren van echte inhoud zorgt ervoor dat het ZIP‑archief functioneel is wanneer het in een browser wordt geopend. De handler kan ook transformaties toepassen (bijv. CSS minify) voordat het naar de stream wordt geschreven.
+
+## Stap 6: Gebruik het ZIP‑archief in een web‑API (optioneel)
+
+Als je de functionaliteit via ASP.NET Core beschikbaar maakt, retourneer dan het ZIP‑bestand als een file‑resultaat:
+
+```csharp
+[HttpGet("download")]
+public IActionResult DownloadZip()
+{
+ // Reuse the same logic from steps 1‑4.
+ // ...
+
+ // Read the generated ZIP into a byte array.
+ byte[] zipBytes = System.IO.File.ReadAllBytes(outputPath);
+
+ // Return the file with the appropriate content type.
+ return File(zipBytes, "application/zip", "document.zip");
+}
+```
+
+**Waarom deze stap belangrijk is:**
+Clients kunnen de verpakte HTML downloaden zonder tijdelijke bestanden op de server te hoeven behandelen. De aanpak werkt met serverless‑functies waar schijftoegang beperkt is.
+
+## Veelvoorkomende valkuilen en hoe ze te vermijden
+
+| Valkuil | Reden | Oplossing |
+|---------|--------|-----|
+| Lege resources in de ZIP | Handler retourneert een nieuwe `MemoryStream` zonder data te schrijven | Vul de stream met daadwerkelijke bytes voordat je retourneert |
+| Ontbrekende `index.html`‑vermelding | `Compress`‑vlag niet ingesteld of `OutputStorage` niet toegewezen | Zorg ervoor dat `saveOptions.Compress = true` en `saveOptions.OutputStorage = handler` |
+| Grote HTML veroorzaakt geheugenbelasting | Alle resources worden in het geheugen gehouden | Schakel over naar een `FileStorage`‑implementatie die naar een tijdelijke map schrijft |
+| Relatieve URL's breken na uitpakken | Resources worden verwezen met absolute URL's die niet worden opgeslagen | Herschrijf URL's naar relatieve paden binnen de handler of tijdens post‑processing |
+
+## Volledig, uitvoerbaar voorbeeld
+
+```csharp
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Saving;
+
+class InMemoryResourceHandler : ResourceHandler
+{
+ private readonly DictionaryHello, world!
+
+
+ ";
+
+ HtmlDocument doc = new HtmlDocument();
+ doc.Open(html);
+
+ // Step 1 & 3: Create handler and configure save options.
+ var handler = new InMemoryResourceHandler();
+ HtmlSaveOptions options = new HtmlSaveOptions
+ {
+ OutputStorage = handler,
+ Compress = true
+ };
+
+ // Step 4: Save as ZIP.
+ string zipPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+ doc.Save(zipPath, options);
+ Console.WriteLine($"ZIP file created at: {zipPath}");
+
+ // Optional verification.
+ foreach (var kvp in handler.Resources)
+ {
+ Console.WriteLine($"Resource {kvp.Key} captured, length {kvp.Value.Length} bytes");
+ }
+ }
+}
+```
+
+Het uitvoeren van het programma produceert `output.zip` naast het uitvoerbare bestand. Het uitpakken van het archief toont `index.html`, `styles.css` en `logo.png` (lege tijdelijke bestanden in dit minimale voorbeeld).
+
+## Conclusie
+
+Je hebt nu een betrouwbare methode om **HTML als ZIP op te slaan** met Aspose.HTML in C#. De tutorial behandelde het laden van een HTML‑string, het implementeren van een **aangepaste resource‑handler**, het configureren van opslaan‑opties en het genereren van een ZIP‑archief klaar voor distributie of download.
+
+- Vervang de placeholder‑streams door echte content (bijv. lezen uit een database)
+- Schakel over naar een bestandsgebaseerde opslag‑handler voor zeer grote documenten
+- Integreer de logica in ASP.NET Core‑endpoints voor on‑demand downloads
+- Verken extra Aspose.HTML‑functies zoals PDF‑conversie of afbeeldingsrendering
+
+Experimenteer met verschillende resource‑bronnen en compressie‑instellingen om de oplossing af te stemmen op je prestatie‑ en grootte‑eisen. Veel programmeerplezier!
+
+## Wat moet je hierna leren?
+
+De volgende tutorials behandelen nauw verwante onderwerpen die voortbouwen op de technieken die in deze handleiding worden getoond. Elke bron bevat volledige werkende code‑voorbeelden met stapsgewijze uitleg om je te helpen extra API‑functies onder de knie te krijgen en alternatieve implementatie‑benaderingen in je eigen projecten te verkennen.
+
+- [HTML opslaan als ZIP – Complete C# Tutorial](/html/english/net/html-extensions-and-conversions/save-html-as-zip-complete-c-tutorial/)
+- [Hoe HTML op te slaan in C# – Complete gids met een aangepaste resource‑handler](/html/english/net/working-with-html-documents/how-to-save-html-in-c-complete-guide-using-a-custom-resource/)
+- [HTML maken vanuit een string in C# – Gids voor aangepaste resource‑handler](/html/english/net/html-document-manipulation/create-html-from-string-in-c-custom-resource-handler-guide/)
+
+{{< /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/generate-jpg-and-png-images/_index.md b/html/english/net/generate-jpg-and-png-images/_index.md
index 3cc4b6acdf..86088c39b9 100644
--- a/html/english/net/generate-jpg-and-png-images/_index.md
+++ b/html/english/net/generate-jpg-and-png-images/_index.md
@@ -45,6 +45,7 @@ Learn to use Aspose.HTML for .NET to manipulate HTML documents, convert HTML to
Learn how to enable antialiasing for sharper PNG/JPG output when converting DOCX files using Aspose.HTML for .NET.
### [convert docx to png – create zip archive c# tutorial](./convert-docx-to-png-create-zip-archive-c-tutorial/)
Learn how to convert DOCX files to PNG images and package them into a ZIP archive using C# and Aspose.HTML.
+### [Create PNG from HTML in C# using Aspose.HTML](./create-png-from-html-in-c-using-aspose-html/)
## Conclusion
diff --git a/html/english/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md b/html/english/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
new file mode 100644
index 0000000000..b093e9d548
--- /dev/null
+++ b/html/english/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
@@ -0,0 +1,292 @@
+---
+category: general
+date: 2026-08-12
+description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+draft: false
+images:
+- PLACEHOLDER_URL/og-image.png
+keywords:
+- create png from html
+- convert html to png
+- render html as image
+- how to render html to image
+language: en
+lastmod: 2026-08-12
+og_description: Create PNG from HTML in C# using Aspose.HTML. This guide shows how
+ to render HTML as image quickly, covering conversion options, code setup, and troubleshooting.
+og_image_alt: Screenshot of a C# program converting HTML to a PNG image
+og_title: Create PNG from HTML in C# – step‑by‑step guide
+schemas:
+- author: Aspose
+ dateModified: '2026-08-12'
+ description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ headline: Create PNG from HTML in C# using Aspose.HTML
+ type: TechArticle
+- description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ name: Create PNG from HTML in C# using Aspose.HTML
+ steps:
+ - name: Why this works
+ text: '- **`HtmlDocument.Open`** parses the HTML string into a DOM that Aspose.HTML
+ can render. - **`ImageRenderingOptions`** lets you control anti‑aliasing, text
+ hinting, and font handling, which are essential when you **render HTML as image**
+ to avoid blurry text. - **`ImageConverter.ConvertHtmlToImage`*'
+ - name: 1. Preparing the HTML source
+ text: You can load HTML from a string (as shown), a local file, or a remote URL.
+ - name: 2. Fine‑tuning rendering options
+ text: '| Option | Effect | When to adjust | |--------|--------|----------------|
+ | `UseAntialiasing` | Reduces jagged edges on vector graphics | Always enable
+ for high‑quality output | | `TextOptions.UseHinting` | Sharpens glyph edges
+ | Important for small font sizes | | `FontOptions.WebFontStyle` | Choose'
+ - name: 3. Performing the conversion
+ text: The `ImageConverter` overload you used writes a single PNG file. If you
+ need multiple pages (e.g., a multi‑page HTML document), use the overload that
+ returns a collection of images.
+ - name: a. Missing fonts
+ text: If the HTML references a custom web font that isn’t installed on the server,
+ the rendered text falls back to a default font, which may affect layout.
+ - name: b. Large pages and memory consumption
+ text: Rendering a very tall page can consume a lot of RAM.
+ - name: c. Transparent backgrounds
+ text: PNG supports transparency, but the default background is white.
+ type: HowTo
+tags:
+- Aspose.HTML
+- C#
+- image rendering
+- HTML conversion
+title: Create PNG from HTML in C# using Aspose.HTML
+url: /net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/
+---
+
+{{< blocks/products/pf/main-wrap-class >}}
+{{< blocks/products/pf/main-container >}}
+{{< blocks/products/pf/tutorial-page-section >}}
+
+# Create PNG from HTML in C# using Aspose.HTML
+
+If you need to **create PNG from HTML** in a .NET application, this guide walks you through the complete process. You’ll see how to **convert HTML to PNG** with just a few lines of C# code, using Aspose.HTML’s powerful rendering engine.
+
+Rendering HTML as an image is a common requirement when generating thumbnails, email previews, or reports that must be embedded in PDFs. In the sections that follow, you’ll learn the exact steps, see a full working example, and understand why each setting matters.
+
+## What you’ll learn
+
+- How to build an `HtmlDocument` from a string or file.
+- How to configure `ImageRenderingOptions` to improve quality.
+- How to **convert HTML to PNG** and save the result to disk.
+- Tips for handling fonts, large pages, and custom output paths.
+
+**Prerequisites**
+- .NET 6.0 SDK (or later) installed.
+- A valid Aspose.HTML for .NET license (or a temporary evaluation key).
+- Basic familiarity with C# and Visual Studio or any .NET‑compatible IDE.
+
+---
+
+## Create PNG from HTML with Aspose.HTML
+
+The first step is to set up the environment and reference the required Aspose.HTML namespaces.
+
+```csharp
+using System;
+using Aspose.Html;
+using Aspose.Html.Rendering.Image;
+using Aspose.Html.Drawing;
+using Aspose.Html.Converters;
+
+namespace HtmlToPngDemo
+{
+ class Program
+ {
+ static void Main()
+ {
+ // 1️⃣ Build the HTML document from a raw string.
+ var html = "Bold text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // 2️⃣ Configure rendering options for best visual fidelity. + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, // Smooths edges of drawn shapes + TextOptions = { UseHinting = true }, // Improves glyph clarity + FontOptions = { WebFontStyle = WebFontStyle.Normal } // Uses standard web‑font style + }; + + // 3️⃣ Convert the HTML document to a PNG file. + string outputPath = @"output.png"; + ImageConverter.ConvertHtmlToImage(document, outputPath, renderOptions); + + Console.WriteLine($"PNG image created at: {outputPath}"); + } + } +} +``` + +### Why this works + +- **`HtmlDocument.Open`** parses the HTML string into a DOM that Aspose.HTML can render. +- **`ImageRenderingOptions`** lets you control anti‑aliasing, text hinting, and font handling, which are essential when you **render HTML as image** to avoid blurry text. +- **`ImageConverter.ConvertHtmlToImage`** performs the heavy lifting: it rasterizes the DOM onto a bitmap and writes the PNG file. + +Running the program generates `output.png` that contains the bold paragraph exactly as defined in the HTML source. + +--- + +## Convert HTML to PNG step by step + +Below is a more detailed walk‑through of each phase. Understanding the purpose of each line helps you adapt the code for larger or more complex pages. + +### 1. Preparing the HTML source + +You can load HTML from a string (as shown), a local file, or a remote URL. + +```csharp +// Load from a file +var document = new HtmlDocument(); +document.Open(@"C:\templates\invoice.html"); + +// Load from a URL (requires internet access) +document.Open("https://example.com/report.html"); +``` + +**Tip:** When loading external resources (CSS, images), make sure the `BaseUrl` property points to the correct folder so relative links resolve correctly. + +### 2. Fine‑tuning rendering options + +| Option | Effect | When to adjust | +|--------|--------|----------------| +| `UseAntialiasing` | Reduces jagged edges on vector graphics | Always enable for high‑quality output | +| `TextOptions.UseHinting` | Sharpens glyph edges | Important for small font sizes | +| `FontOptions.WebFontStyle` | Chooses normal, italic, or oblique web‑font rendering | Use `WebFontStyle.Oblique` for slanted fonts | +| `ResolutionX` / `ResolutionY` | DPI of the output image | Increase for print‑ready PNGs (e.g., 300 DPI) | + +Example of increasing DPI: + +```csharp +renderOptions.ResolutionX = 300; +renderOptions.ResolutionY = 300; +``` + +### 3. Performing the conversion + +The `ImageConverter` overload you used writes a single PNG file. If you need multiple pages (e.g., a multi‑page HTML document), use the overload that returns a collection of images. + +```csharp +ImageConverter.ConvertHtmlToImages(document, "output_folder", renderOptions); +``` + +Each page becomes `output_folder/page_0.png`, `page_1.png`, etc. + +--- + +## Render HTML as image – handling common pitfalls + +### a. Missing fonts + +If the HTML references a custom web font that isn’t installed on the server, the rendered text falls back to a default font, which may affect layout. + +**Solution:** Embed the font using a `@font-face` rule in your CSS or supply a local font folder via `FontOptions`. + +```csharp +renderOptions.FontOptions.FontFolder = @"C:\fonts"; +``` + +### b. Large pages and memory consumption + +Rendering a very tall page can consume a lot of RAM. + +**Solution:** Set a maximum height or split the document into sections before conversion. + +```csharp +renderOptions.PageHeight = 2000; // pixels +``` + +### c. Transparent backgrounds + +PNG supports transparency, but the default background is white. + +**Solution:** Change the background color to transparent. + +```csharp +renderOptions.BackgroundColor = System.Drawing.Color.Transparent; +``` + +--- + +## How to render HTML to image – full example recap + +Putting everything together, here’s a production‑ready snippet that covers the most frequent requirements: + +```csharp +using System; +using Aspose.Html; +using Aspose.Html.Rendering.Image; +using Aspose.Html.Drawing; +using Aspose.Html.Converters; + +namespace HtmlToPngDemo +{ + class Program + { + static void Main() + { + // Load HTML (string, file, or URL) + string html = "" + + "Bold blue text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // Configure rendering for high quality and transparency + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, + TextOptions = { UseHinting = true }, + FontOptions = { WebFontStyle = WebFontStyle.Normal, FontFolder = @"C:\fonts" }, + BackgroundColor = System.Drawing.Color.Transparent, + ResolutionX = 150, + ResolutionY = 150 + }; + + // Convert and save + string outPath = @"C:\temp\html_snapshot.png"; + ImageConverter.ConvertHtmlToImage(document, outPath, renderOptions); + + Console.WriteLine($"Image saved to {outPath}"); + } + } +} +``` + +**Expected output:** A `html_snapshot.png` file containing a bold, blue paragraph on a transparent canvas. The image will be anti‑aliased, with crisp text thanks to hinting. + +--- + +## Conclusion + +You now know how to **create PNG from HTML** in C# using Aspose.HTML. By constructing an `HtmlDocument`, configuring `ImageRenderingOptions`, and calling `ImageConverter.ConvertHtmlToImage`, you can reliably **convert HTML to PNG** and **render HTML as image** for any automation scenario. + +From here you might explore: + +- Generating thumbnails for dynamic web pages. +- Embedding the PNG into PDFs with Aspose.PDF. +- Using the same approach to produce JPEG or BMP by changing the file extension. + +Feel free to experiment with DPI, background colors, and multi‑page rendering to fit your project’s exact needs. Happy coding! + + +## What Should You Learn Next? + + +The following tutorials cover closely related topics that build on the techniques demonstrated in this guide. Each resource includes complete working code examples with step-by-step explanations to help you master additional API features and explore alternative implementation approaches in your own projects. + +- [Render HTML as PNG in .NET with Aspose.HTML](/html/english/net/rendering-html-documents/render-html-as-png/) +- [How to Render HTML as PNG – Complete C# Guide](/html/english/net/rendering-html-documents/how-to-render-html-as-png-complete-c-guide/) +- [Create PNG from HTML – Full C# Rendering Guide](/html/english/net/rendering-html-documents/create-png-from-html-full-c-rendering-guide/) + +{{< /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/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/og-image.png b/html/english/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/og-image.png new file mode 100644 index 0000000000..84c50dea28 Binary files /dev/null and b/html/english/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/og-image.png differ diff --git a/html/english/net/html-extensions-and-conversions/_index.md b/html/english/net/html-extensions-and-conversions/_index.md index a50bc9ccba..cf2bbf3e12 100644 --- a/html/english/net/html-extensions-and-conversions/_index.md +++ b/html/english/net/html-extensions-and-conversions/_index.md @@ -71,6 +71,8 @@ Learn how to zip HTML files in C# using Aspose.HTML, saving HTML content to a ZI Learn how to create an HTML document with styled text and export it to PDF using Aspose.HTML for .NET in this comprehensive guide. ### [Save HTML as ZIP – Complete C# Tutorial](./save-html-as-zip-complete-c-tutorial/) Learn how to save HTML files as a ZIP archive using Aspose.HTML for .NET with a complete C# example. +### [Save HTML as ZIP in C# – step‑by‑step guide](./save-html-as-zip-in-c-step-by-step-guide/) +Step-by-step guide to saving HTML content as a ZIP archive in C# using Aspose.HTML for .NET. ### [Convert EPUB to Image in .NET with Aspose.HTML](./convert-epub-to-image/) Learn how to convert EPUB to images using Aspose.HTML for .NET. Step-by-step tutorial with code examples and customizable options. ### [Convert EPUB to PDF in .NET with Aspose.HTML](./convert-epub-to-pdf/) diff --git a/html/english/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md b/html/english/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..dde9cc8728 --- /dev/null +++ b/html/english/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md @@ -0,0 +1,323 @@ +--- +category: general +date: 2026-08-12 +description: Save HTML as ZIP using Aspose.HTML. Learn to load HTML string, create + a custom resource handler, and generate a ZIP archive efficiently. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save html as zip +- load html string +- custom resource handler +language: en +lastmod: 2026-08-12 +og_description: Save HTML as ZIP using Aspose.HTML in C#. This tutorial shows how + to load an HTML string, create a custom resource handler, and generate a ZIP archive + in a few steps. +og_image_alt: Diagram showing save html as zip process with custom resource handler +og_title: Save HTML as ZIP with Aspose.HTML – complete C# guide +schemas: +- author: Aspose + dateModified: '2026-08-12' + description: Save HTML as ZIP using Aspose.HTML. Learn to load HTML string, create + a custom resource handler, and generate a ZIP archive efficiently. + headline: Save HTML as ZIP in C# – step‑by‑step guide + type: TechArticle +tags: +- Aspose.HTML +- C# +- ZIP archive +title: Save HTML as ZIP in C# – step‑by‑step guide +url: /net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Save HTML as ZIP in C# – step‑by‑step guide + +If you need to **save HTML as ZIP** in a .NET application, this guide shows the complete workflow. You will learn how to **load HTML string**, implement a **custom resource handler**, and produce a ZIP archive without writing intermediate files to disk. + +The approach uses Aspose.HTML 5.x, which provides a high‑performance rendering engine and flexible saving options. By the end of the tutorial you have a reusable handler that can be integrated into web services, background jobs, or desktop tools. + +## What you will build + +The final code creates a `MemoryStream`‑based ZIP file that contains the HTML document and any referenced resources (images, CSS, fonts). The ZIP file is written to a target folder, but you can change the destination to a response stream for HTTP APIs. + +## Prerequisites + +- .NET 6.0 or later (the sample targets .NET 6) +- Aspose.HTML for .NET (NuGet package `Aspose.HTML`) +- Basic familiarity with C# async patterns (optional but helpful) + +> **Pro tip:** Install the package with `dotnet add package Aspose.HTML` before starting. + +## Step 1: Define a custom resource handler + +A **custom resource handler** intercepts every external resource request that the HTML renderer makes. By returning a stream, you control where the resource data is stored. The example stores everything in memory, which is ideal for creating a ZIP archive on the fly. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +///Hello, world!
+
+
+";
+
+// Create a new document instance.
+HtmlDocument document = new HtmlDocument();
+
+// Load the HTML markup.
+document.Open(htmlContent);
+```
+
+**Why this step matters:**
+The **load html string** capability is useful when HTML is generated dynamically (e.g., from a template engine) or received from an API. It avoids file‑system dependencies and works in sandboxed environments.
+
+## Step 3: Configure save options to use the handler
+
+Aspose.HTML’s `HtmlSaveOptions` let you specify the storage mechanism for the output. Assign the custom handler to the `OutputStorage` property, and set the `Compress` flag to produce a ZIP archive.
+
+```csharp
+// Instantiate the custom handler.
+var resourceHandler = new InMemoryResourceHandler();
+
+// Prepare save options.
+HtmlSaveOptions saveOptions = new HtmlSaveOptions
+{
+ // Use the handler for all external resources.
+ OutputStorage = resourceHandler,
+
+ // Enable ZIP compression.
+ Compress = true
+};
+```
+
+**Why this step matters:**
+`Compress = true` tells Aspose.HTML to bundle the HTML file and all collected resources into a single ZIP package. The `OutputStorage` ensures that resources are captured in memory rather than written to temporary locations.
+
+## Step 4: Save the document as a ZIP archive
+
+Now invoke `HtmlDocument.Save`, passing the destination path and the configured options. After saving, the ZIP file contains `index.html` plus any resources captured by the handler.
+
+```csharp
+// Define the output path (you can change this to a response stream for web APIs).
+string outputPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+
+// Save the document; Aspose.HTML creates the ZIP automatically.
+document.Save(outputPath, saveOptions);
+
+// Optional: Verify the resources that were stored.
+foreach (var entry in resourceHandler.Resources)
+{
+ Console.WriteLine($"Resource: {entry.Key}, Size: {entry.Value.Length} bytes");
+}
+```
+
+**Expected result:**
+Running the program creates `output.zip` in the current directory. Extracting the archive reveals:
+
+```
+index.html
+styles.css
+logo.png
+```
+
+Each file matches the markup references, and the HTML inside `index.html` points to the bundled resources.
+
+## Step 5: Adapt the handler for real resource data (advanced)
+
+The basic handler above creates empty streams. In production you often need to write the actual content (e.g., the bytes of `styles.css` or `logo.png`). Extend `HandleResource` to fetch data from a database, a cloud bucket, or an embedded resource.
+
+```csharp
+public override Stream HandleResource(ResourceInfo info)
+{
+ // Example: Load resource from an embedded folder.
+ string resourcePath = Path.Combine("EmbeddedResources", info.Path);
+ byte[] data = File.ReadAllBytes(resourcePath);
+
+ // Write data into a memory stream.
+ var stream = new MemoryStream(data);
+ _resources[info.Path] = stream;
+
+ // Return the populated stream.
+ return stream;
+}
+```
+
+**Why this variation matters:**
+Providing real content ensures that the ZIP archive is functional when opened in a browser. The handler can also apply transformations (e.g., minify CSS) before writing to the stream.
+
+## Step 6: Use the ZIP archive in a web API (optional)
+
+If you expose the functionality through ASP.NET Core, return the ZIP file as a file result:
+
+```csharp
+[HttpGet("download")]
+public IActionResult DownloadZip()
+{
+ // Reuse the same logic from steps 1‑4.
+ // ...
+
+ // Read the generated ZIP into a byte array.
+ byte[] zipBytes = System.IO.File.ReadAllBytes(outputPath);
+
+ // Return the file with the appropriate content type.
+ return File(zipBytes, "application/zip", "document.zip");
+}
+```
+
+**Why this step matters:**
+Clients can download the packaged HTML without dealing with temporary files on the server. The approach works with serverless functions where disk access is limited.
+
+## Common pitfalls and how to avoid them
+
+| Pitfall | Reason | Fix |
+|---------|--------|-----|
+| Empty resources in the ZIP | Handler returns a fresh `MemoryStream` without writing data | Populate the stream with actual bytes before returning |
+| Missing `index.html` entry | `Compress` flag not set or `OutputStorage` not assigned | Ensure `saveOptions.Compress = true` and `saveOptions.OutputStorage = handler` |
+| Large HTML causing memory pressure | All resources are kept in memory | Switch to a `FileStorage` implementation that writes to a temporary folder |
+| Relative URLs breaking after extraction | Resources referenced with absolute URLs that are not stored | Rewrite URLs to relative paths inside the handler or during post‑processing |
+
+## Full, runnable example
+
+```csharp
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Saving;
+
+class InMemoryResourceHandler : ResourceHandler
+{
+ private readonly DictionaryHello, world!
+
+
+ ";
+
+ HtmlDocument doc = new HtmlDocument();
+ doc.Open(html);
+
+ // Step 1 & 3: Create handler and configure save options.
+ var handler = new InMemoryResourceHandler();
+ HtmlSaveOptions options = new HtmlSaveOptions
+ {
+ OutputStorage = handler,
+ Compress = true
+ };
+
+ // Step 4: Save as ZIP.
+ string zipPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+ doc.Save(zipPath, options);
+ Console.WriteLine($"ZIP file created at: {zipPath}");
+
+ // Optional verification.
+ foreach (var kvp in handler.Resources)
+ {
+ Console.WriteLine($"Resource {kvp.Key} captured, length {kvp.Value.Length} bytes");
+ }
+ }
+}
+```
+
+Running the program produces `output.zip` next to the executable. Extracting the archive shows `index.html`, `styles.css`, and `logo.png` (empty placeholders in this minimal example).
+
+## Conclusion
+
+You now have a reliable method to **save HTML as ZIP** using Aspose.HTML in C#. The tutorial covered loading an HTML string, implementing a **custom resource handler**, configuring save options, and generating a ZIP archive ready for distribution or download.
+
+From here you can:
+
+- Replace the placeholder streams with real content (e.g., read from a database)
+- Switch to a file‑based storage handler for very large documents
+- Integrate the logic into ASP.NET Core endpoints for on‑demand downloads
+- Explore additional Aspose.HTML features such as PDF conversion or image rendering
+
+Experiment with different resource sources and compression settings to tailor the solution to your performance and size requirements. Happy coding!
+
+
+## What Should You Learn Next?
+
+
+The following tutorials cover closely related topics that build on the techniques demonstrated in this guide. Each resource includes complete working code examples with step-by-step explanations to help you master additional API features and explore alternative implementation approaches in your own projects.
+
+- [Save HTML as ZIP – Complete C# Tutorial](/html/english/net/html-extensions-and-conversions/save-html-as-zip-complete-c-tutorial/)
+- [How to Save HTML in C# – Complete Guide Using a Custom Resource Handler](/html/english/net/working-with-html-documents/how-to-save-html-in-c-complete-guide-using-a-custom-resource/)
+- [Create HTML from String in C# – Custom Resource Handler Guide](/html/english/net/html-document-manipulation/create-html-from-string-in-c-custom-resource-handler-guide/)
+
+{{< /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/save-html-as-zip-in-c-step-by-step-guide/og-image.png b/html/english/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/og-image.png
new file mode 100644
index 0000000000..68574eaf8a
Binary files /dev/null and b/html/english/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/og-image.png differ
diff --git a/html/french/net/generate-jpg-and-png-images/_index.md b/html/french/net/generate-jpg-and-png-images/_index.md
index 59ca2dad12..5210eacc84 100644
--- a/html/french/net/generate-jpg-and-png-images/_index.md
+++ b/html/french/net/generate-jpg-and-png-images/_index.md
@@ -45,6 +45,8 @@ Apprenez à utiliser Aspose.HTML pour .NET pour manipuler des documents HTML, co
Apprenez à activer l'anticrénelage pour améliorer la qualité des images PNG/JPG générées à partir de documents DOCX avec Aspose.HTML.
### [Convertir docx en png – créer une archive zip tutoriel C#](./convert-docx-to-png-create-zip-archive-c-tutorial/)
Apprenez à convertir des fichiers DOCX en images PNG et à les compresser dans une archive ZIP avec C#.
+### [Créer un PNG à partir de HTML en C# avec Aspose.HTML](./create-png-from-html-in-c-using-aspose-html/)
+Apprenez à générer des images PNG à partir de code HTML en C# en utilisant Aspose.HTML.
## Conclusion
diff --git a/html/french/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md b/html/french/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
new file mode 100644
index 0000000000..7f8e20cd8f
--- /dev/null
+++ b/html/french/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
@@ -0,0 +1,292 @@
+---
+category: general
+date: 2026-08-12
+description: Créer un PNG à partir de HTML en C# avec Aspose.HTML. Apprenez comment
+ convertir du HTML en PNG et rendre le HTML sous forme d'image en quelques lignes
+ de code.
+draft: false
+images:
+- PLACEHOLDER_URL/og-image.png
+keywords:
+- create png from html
+- convert html to png
+- render html as image
+- how to render html to image
+language: fr
+lastmod: 2026-08-12
+og_description: Créer un PNG à partir de HTML en C# avec Aspose.HTML. Ce guide montre
+ comment rendre le HTML en image rapidement, en couvrant les options de conversion,
+ la configuration du code et le dépannage.
+og_image_alt: Screenshot of a C# program converting HTML to a PNG image
+og_title: Créer un PNG à partir de HTML en C# – guide étape par étape
+schemas:
+- author: Aspose
+ dateModified: '2026-08-12'
+ description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ headline: Create PNG from HTML in C# using Aspose.HTML
+ type: TechArticle
+- description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ name: Create PNG from HTML in C# using Aspose.HTML
+ steps:
+ - name: Why this works
+ text: '- **`HtmlDocument.Open`** parses the HTML string into a DOM that Aspose.HTML
+ can render. - **`ImageRenderingOptions`** lets you control anti‑aliasing, text
+ hinting, and font handling, which are essential when you **render HTML as image**
+ to avoid blurry text. - **`ImageConverter.ConvertHtmlToImage`*'
+ - name: 1. Preparing the HTML source
+ text: You can load HTML from a string (as shown), a local file, or a remote URL.
+ - name: 2. Fine‑tuning rendering options
+ text: '| Option | Effect | When to adjust | |--------|--------|----------------|
+ | `UseAntialiasing` | Reduces jagged edges on vector graphics | Always enable
+ for high‑quality output | | `TextOptions.UseHinting` | Sharpens glyph edges
+ | Important for small font sizes | | `FontOptions.WebFontStyle` | Choose'
+ - name: 3. Performing the conversion
+ text: The `ImageConverter` overload you used writes a single PNG file. If you
+ need multiple pages (e.g., a multi‑page HTML document), use the overload that
+ returns a collection of images.
+ - name: a. Missing fonts
+ text: If the HTML references a custom web font that isn’t installed on the server,
+ the rendered text falls back to a default font, which may affect layout.
+ - name: b. Large pages and memory consumption
+ text: Rendering a very tall page can consume a lot of RAM.
+ - name: c. Transparent backgrounds
+ text: PNG supports transparency, but the default background is white.
+ type: HowTo
+tags:
+- Aspose.HTML
+- C#
+- image rendering
+- HTML conversion
+title: Créer un PNG à partir de HTML en C# avec Aspose.HTML
+url: /fr/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/
+---
+
+{{< blocks/products/pf/main-wrap-class >}}
+{{< blocks/products/pf/main-container >}}
+{{< blocks/products/pf/tutorial-page-section >}}
+
+# Créer un PNG à partir de HTML en C# avec Aspose.HTML
+
+Si vous devez **créer un PNG à partir de HTML** dans une application .NET, ce guide vous accompagne tout au long du processus complet. Vous verrez comment **convertir du HTML en PNG** en quelques lignes de code C#, en utilisant le puissant moteur de rendu d’Aspose.HTML.
+
+Rendre du HTML en image est une exigence courante lors de la génération de miniatures, d’aperçus d’e‑mails ou de rapports qui doivent être intégrés dans des PDF. Dans les sections qui suivent, vous apprendrez les étapes exactes, verrez un exemple complet fonctionnel et comprendrez pourquoi chaque paramètre est important.
+
+## Ce que vous apprendrez
+
+- Comment créer un `HtmlDocument` à partir d’une chaîne ou d’un fichier.
+- Comment configurer `ImageRenderingOptions` pour améliorer la qualité.
+- Comment **convertir du HTML en PNG** et enregistrer le résultat sur le disque.
+- Conseils pour gérer les polices, les pages volumineuses et les chemins de sortie personnalisés.
+
+**Pré‑requis**
+- SDK .NET 6.0 (ou ultérieur) installé.
+- Une licence valide d’Aspose.HTML pour .NET (ou une clé d’évaluation temporaire).
+- Une connaissance de base du C# et de Visual Studio ou de tout IDE compatible .NET.
+
+---
+
+## Créer un PNG à partir de HTML avec Aspose.HTML
+
+La première étape consiste à configurer l’environnement et à référencer les espaces de noms Aspose.HTML requis.
+
+```csharp
+using System;
+using Aspose.Html;
+using Aspose.Html.Rendering.Image;
+using Aspose.Html.Drawing;
+using Aspose.Html.Converters;
+
+namespace HtmlToPngDemo
+{
+ class Program
+ {
+ static void Main()
+ {
+ // 1️⃣ Build the HTML document from a raw string.
+ var html = "Bold text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // 2️⃣ Configure rendering options for best visual fidelity. + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, // Smooths edges of drawn shapes + TextOptions = { UseHinting = true }, // Improves glyph clarity + FontOptions = { WebFontStyle = WebFontStyle.Normal } // Uses standard web‑font style + }; + + // 3️⃣ Convert the HTML document to a PNG file. + string outputPath = @"output.png"; + ImageConverter.ConvertHtmlToImage(document, outputPath, renderOptions); + + Console.WriteLine($"PNG image created at: {outputPath}"); + } + } +} +``` + +### Pourquoi cela fonctionne + +- `HtmlDocument.Open` analyse la chaîne HTML en un DOM que Aspose.HTML peut rendre. +- `ImageRenderingOptions` vous permet de contrôler l'anti‑aliasing, le hinting du texte et la gestion des polices, ce qui est essentiel lorsque vous **rendez du HTML en image** pour éviter un texte flou. +- `ImageConverter.ConvertHtmlToImage` effectue le travail lourd : il rasterise le DOM sur un bitmap et écrit le fichier PNG. + +L’exécution du programme génère `output.png` contenant le paragraphe en gras exactement comme défini dans le source HTML. + +--- + +## Convertir du HTML en PNG étape par étape + +Voici une explication plus détaillée de chaque phase. Comprendre le rôle de chaque ligne vous aide à adapter le code pour des pages plus grandes ou plus complexes. + +### 1. Préparer la source HTML + +Vous pouvez charger le HTML depuis une chaîne (comme montré), un fichier local ou une URL distante. + +```csharp +// Load from a file +var document = new HtmlDocument(); +document.Open(@"C:\templates\invoice.html"); + +// Load from a URL (requires internet access) +document.Open("https://example.com/report.html"); +``` + +**Conseil :** Lors du chargement de ressources externes (CSS, images), assurez‑vous que la propriété `BaseUrl` pointe vers le dossier correct afin que les liens relatifs soient résolus correctement. + +### 2. Affiner les options de rendu + +| Option | Effet | Quand ajuster | +|--------|-------|----------------| +| `UseAntialiasing` | Réduit les bords irréguliers sur les graphiques vectoriels | Toujours activer pour une sortie de haute qualité | +| `TextOptions.UseHinting` | Affûte les bords des glyphes | Important pour les petites tailles de police | +| `FontOptions.WebFontStyle` | Choisit le rendu normal, italique ou oblique des polices web | Utilisez `WebFontStyle.Oblique` pour les polices inclinées | +| `ResolutionX` / `ResolutionY` | DPI de l’image de sortie | Augmentez pour des PNG prêts à l’impression (par ex., 300 DPI) | + +Exemple d’augmentation du DPI : + +```csharp +renderOptions.ResolutionX = 300; +renderOptions.ResolutionY = 300; +``` + +### 3. Effectuer la conversion + +La surcharge `ImageConverter` que vous avez utilisée écrit un seul fichier PNG. Si vous avez besoin de plusieurs pages (par ex., un document HTML multipage), utilisez la surcharge qui renvoie une collection d’images. + +```csharp +ImageConverter.ConvertHtmlToImages(document, "output_folder", renderOptions); +``` + +Chaque page devient `output_folder/page_0.png`, `page_1.png`, etc. + +--- + +## Rendre du HTML en image – gérer les problèmes courants + +### a. Polices manquantes + +Si le HTML fait référence à une police web personnalisée qui n’est pas installée sur le serveur, le texte rendu revient à une police par défaut, ce qui peut affecter la mise en page. + +**Solution :** Intégrez la police à l’aide d’une règle `@font-face` dans votre CSS ou fournissez un dossier de polices local via `FontOptions`. + +```csharp +renderOptions.FontOptions.FontFolder = @"C:\fonts"; +``` + +### b. Pages volumineuses et consommation de mémoire + +Rendre une page très haute peut consommer beaucoup de RAM. + +**Solution :** Définissez une hauteur maximale ou divisez le document en sections avant la conversion. + +```csharp +renderOptions.PageHeight = 2000; // pixels +``` + +### c. Fonds transparents + +Le PNG prend en charge la transparence, mais le fond par défaut est blanc. + +**Solution :** Changez la couleur de fond en transparent. + +```csharp +renderOptions.BackgroundColor = System.Drawing.Color.Transparent; +``` + +--- + +## Comment rendre du HTML en image – récapitulatif complet de l’exemple + +En réunissant tous les éléments, voici un extrait prêt pour la production qui couvre les exigences les plus fréquentes : + +```csharp +using System; +using Aspose.Html; +using Aspose.Html.Rendering.Image; +using Aspose.Html.Drawing; +using Aspose.Html.Converters; + +namespace HtmlToPngDemo +{ + class Program + { + static void Main() + { + // Load HTML (string, file, or URL) + string html = "" + + "Bold blue text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // Configure rendering for high quality and transparency + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, + TextOptions = { UseHinting = true }, + FontOptions = { WebFontStyle = WebFontStyle.Normal, FontFolder = @"C:\fonts" }, + BackgroundColor = System.Drawing.Color.Transparent, + ResolutionX = 150, + ResolutionY = 150 + }; + + // Convert and save + string outPath = @"C:\temp\html_snapshot.png"; + ImageConverter.ConvertHtmlToImage(document, outPath, renderOptions); + + Console.WriteLine($"Image saved to {outPath}"); + } + } +} +``` + +**Résultat attendu :** Un fichier `html_snapshot.png` contenant un paragraphe gras et bleu sur un canevas transparent. L’image sera anti‑aliasée, avec un texte net grâce au hinting. + +--- + +## Conclusion + +Vous savez maintenant comment **créer un PNG à partir de HTML** en C# avec Aspose.HTML. En construisant un `HtmlDocument`, en configurant `ImageRenderingOptions` et en appelant `ImageConverter.ConvertHtmlToImage`, vous pouvez de façon fiable **convertir du HTML en PNG** et **rendre du HTML en image** pour tout scénario d’automatisation. + +À partir d’ici, vous pourriez explorer : + +- Générer des miniatures pour des pages web dynamiques. +- Intégrer le PNG dans des PDF avec Aspose.PDF. +- Utiliser la même approche pour produire du JPEG ou BMP en changeant l’extension du fichier. + +N’hésitez pas à expérimenter avec le DPI, les couleurs de fond et le rendu multipage afin d’adapter exactement à vos besoins de projet. Bon codage ! + +## Que devriez‑vous apprendre ensuite ? + +Les tutoriels suivants couvrent des sujets étroitement liés qui s’appuient sur les techniques démontrées dans ce guide. Chaque ressource comprend des exemples de code complets et fonctionnels avec des explications étape par étape pour vous aider à maîtriser des fonctionnalités API supplémentaires et explorer des approches d’implémentation alternatives dans vos propres projets. + +- [Rendre du HTML en PNG dans .NET avec Aspose.HTML](/html/english/net/rendering-html-documents/render-html-as-png/) +- [Comment rendre du HTML en PNG – Guide complet C#](/html/english/net/rendering-html-documents/how-to-render-html-as-png-complete-c-guide/) +- [Créer un PNG à partir de HTML – Guide complet de rendu C#](/html/english/net/rendering-html-documents/create-png-from-html-full-c-rendering-guide/) + +{{< /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 f4e02735c9..9b7108cbb6 100644 --- a/html/french/net/html-extensions-and-conversions/_index.md +++ b/html/french/net/html-extensions-and-conversions/_index.md @@ -30,7 +30,7 @@ Le développement Web implique souvent la conversion de documents HTML en diffé ## Démarrer avec Aspose.HTML -Êtes-vous prêt à commencer ? Les tutoriels Aspose.HTML pour .NET s'adressent aussi bien aux débutants qu'aux développeurs expérimentés. Que vous soyez novice en matière d'extensions et de conversions HTML ou que vous recherchiez des conseils avancés, nos guides étape par étape sont conçus pour répondre à vos besoins. +Êtes-vous prêt à commencer ? Les tutoriels Aspose.HTML pour .NET s'adressent aussi bien aux débutants qu'aux développeurs expérimentés. Que vous soyez novice en matière d'extensions et de conversions HTML ou que vous recherchiez des conseils avancés, nos guides étape par étape sont conçés pour répondre à vos besoins. ## Pourquoi Aspose.HTML pour .NET ? @@ -72,6 +72,8 @@ Découvrez la puissance d'Aspose.HTML pour .NET : convertissez facilement du HT Apprenez à compresser du HTML en un fichier zip avec C# grâce à notre guide détaillé. ### [Enregistrer le HTML en ZIP – Tutoriel complet C#](./save-html-as-zip-complete-c-tutorial/) Apprenez à enregistrer un document HTML dans un fichier ZIP en C# avec Aspose.HTML pour .NET. Guide complet étape par étape. +### [Enregistrer le HTML en ZIP en C# – guide étape par étape](./save-html-as-zip-in-c-step-by-step-guide/) +Apprenez à enregistrer du HTML dans un fichier ZIP en C# grâce à un guide détaillé étape par étape. ### [Enregistrer HTML en ZIP en C# – Exemple complet en mémoire](./save-html-to-zip-in-c-complete-in-memory-example/) Enregistrez du HTML dans un fichier ZIP en mémoire avec Aspose.HTML pour .NET. diff --git a/html/french/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md b/html/french/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..36a2352376 --- /dev/null +++ b/html/french/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md @@ -0,0 +1,322 @@ +--- +category: general +date: 2026-08-12 +description: Enregistrez le HTML au format ZIP avec Aspose.HTML. Apprenez à charger + une chaîne HTML, créer un gestionnaire de ressources personnalisé et générer efficacement + une archive ZIP. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save html as zip +- load html string +- custom resource handler +language: fr +lastmod: 2026-08-12 +og_description: Enregistrez le HTML au format ZIP avec Aspose.HTML en C#. Ce tutoriel + montre comment charger une chaîne HTML, créer un gestionnaire de ressources personnalisé + et générer une archive ZIP en quelques étapes. +og_image_alt: Diagram showing save html as zip process with custom resource handler +og_title: Enregistrer le HTML en ZIP avec Aspose.HTML – guide complet C# +schemas: +- author: Aspose + dateModified: '2026-08-12' + description: Save HTML as ZIP using Aspose.HTML. Learn to load HTML string, create + a custom resource handler, and generate a ZIP archive efficiently. + headline: Save HTML as ZIP in C# – step‑by‑step guide + type: TechArticle +tags: +- Aspose.HTML +- C# +- ZIP archive +title: Enregistrer le HTML en ZIP en C# – guide étape par étape +url: /fr/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Enregistrer du HTML en ZIP en C# – guide étape par étape + +Si vous devez **enregistrer du HTML en ZIP** dans une application .NET, ce guide montre le flux de travail complet. Vous apprendrez comment **charger une chaîne HTML**, implémenter un **gestionnaire de ressources personnalisé**, et produire une archive ZIP sans écrire de fichiers intermédiaires sur le disque. + +L'approche utilise Aspose.HTML 5.x, qui fournit un moteur de rendu haute performance et des options d'enregistrement flexibles. À la fin du tutoriel, vous disposez d'un gestionnaire réutilisable qui peut être intégré aux services web, aux tâches en arrière-plan ou aux outils de bureau. + +## Ce que vous allez créer + +Le code final crée un fichier ZIP basé sur `MemoryStream` qui contient le document HTML et toutes les ressources référencées (images, CSS, polices). Le fichier ZIP est écrit dans un dossier cible, mais vous pouvez changer la destination vers un flux de réponse pour les API HTTP. + +## Prérequis + +- .NET 6.0 ou ultérieur (l'exemple cible .NET 6) +- Aspose.HTML pour .NET (package NuGet `Aspose.HTML`) +- Familiarité de base avec les modèles async de C# (optionnel mais utile) + +> **Astuce :** Installez le package avec `dotnet add package Aspose.HTML` avant de commencer. + +## Étape 1 : Définir un gestionnaire de ressources personnalisé + +Un **gestionnaire de ressources personnalisé** intercepte chaque requête de ressource externe que le moteur de rendu HTML effectue. En renvoyant un flux, vous contrôlez où les données de la ressource sont stockées. L'exemple stocke tout en mémoire, ce qui est idéal pour créer une archive ZIP à la volée. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +///Hello, world!
+
+
+";
+
+// Create a new document instance.
+HtmlDocument document = new HtmlDocument();
+
+// Load the HTML markup.
+document.Open(htmlContent);
+```
+
+**Pourquoi cette étape est importante :**
+La capacité **load html string** est utile lorsque le HTML est généré dynamiquement (par ex., à partir d'un moteur de templates) ou reçu d'une API. Elle évite les dépendances au système de fichiers et fonctionne dans des environnements sandbox.
+
+## Étape 3 : Configurer les options d'enregistrement pour utiliser le gestionnaire
+
+Les `HtmlSaveOptions` d’Aspose.HTML vous permettent de spécifier le mécanisme de stockage pour la sortie. Assignez le gestionnaire personnalisé à la propriété `OutputStorage`, et définissez le drapeau `Compress` pour produire une archive ZIP.
+
+```csharp
+// Instantiate the custom handler.
+var resourceHandler = new InMemoryResourceHandler();
+
+// Prepare save options.
+HtmlSaveOptions saveOptions = new HtmlSaveOptions
+{
+ // Use the handler for all external resources.
+ OutputStorage = resourceHandler,
+
+ // Enable ZIP compression.
+ Compress = true
+};
+```
+
+**Pourquoi cette étape est importante :**
+`Compress = true` indique à Aspose.HTML de regrouper le fichier HTML et toutes les ressources collectées dans un seul package ZIP. Le `OutputStorage` garantit que les ressources sont capturées en mémoire plutôt qu'écrites dans des emplacements temporaires.
+
+## Étape 4 : Enregistrer le document en tant qu'archive ZIP
+
+Appelez maintenant `HtmlDocument.Save`, en passant le chemin de destination et les options configurées. Après l'enregistrement, le fichier ZIP contient `index.html` ainsi que toutes les ressources capturées par le gestionnaire.
+
+```csharp
+// Define the output path (you can change this to a response stream for web APIs).
+string outputPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+
+// Save the document; Aspose.HTML creates the ZIP automatically.
+document.Save(outputPath, saveOptions);
+
+// Optional: Verify the resources that were stored.
+foreach (var entry in resourceHandler.Resources)
+{
+ Console.WriteLine($"Resource: {entry.Key}, Size: {entry.Value.Length} bytes");
+}
+```
+
+**Résultat attendu :**
+L'exécution du programme crée `output.zip` dans le répertoire courant. L'extraction de l'archive révèle :
+
+```
+index.html
+styles.css
+logo.png
+```
+
+Chaque fichier correspond aux références du balisage, et le HTML dans `index.html` pointe vers les ressources empaquetées.
+
+## Étape 5 : Adapter le gestionnaire pour des données de ressources réelles (avancé)
+
+Le gestionnaire de base ci‑dessus crée des flux vides. En production, vous devez souvent écrire le contenu réel (par ex., les octets de `styles.css` ou `logo.png`). Étendez `HandleResource` pour récupérer les données depuis une base de données, un bucket cloud ou une ressource embarquée.
+
+```csharp
+public override Stream HandleResource(ResourceInfo info)
+{
+ // Example: Load resource from an embedded folder.
+ string resourcePath = Path.Combine("EmbeddedResources", info.Path);
+ byte[] data = File.ReadAllBytes(resourcePath);
+
+ // Write data into a memory stream.
+ var stream = new MemoryStream(data);
+ _resources[info.Path] = stream;
+
+ // Return the populated stream.
+ return stream;
+}
+```
+
+**Pourquoi cette variante est importante :**
+Fournir du contenu réel garantit que l'archive ZIP est fonctionnelle lorsqu'elle est ouverte dans un navigateur. Le gestionnaire peut également appliquer des transformations (par ex., minifier le CSS) avant d'écrire dans le flux.
+
+## Étape 6 : Utiliser l'archive ZIP dans une API web (optionnel)
+
+Si vous exposez la fonctionnalité via ASP.NET Core, renvoyez le fichier ZIP comme résultat de fichier :
+
+```csharp
+[HttpGet("download")]
+public IActionResult DownloadZip()
+{
+ // Reuse the same logic from steps 1‑4.
+ // ...
+
+ // Read the generated ZIP into a byte array.
+ byte[] zipBytes = System.IO.File.ReadAllBytes(outputPath);
+
+ // Return the file with the appropriate content type.
+ return File(zipBytes, "application/zip", "document.zip");
+}
+```
+
+**Pourquoi cette étape est importante :**
+Les clients peuvent télécharger le HTML empaqueté sans gérer de fichiers temporaires sur le serveur. L'approche fonctionne avec les fonctions serverless où l'accès au disque est limité.
+
+## Pièges courants et comment les éviter
+
+| Piège | Raison | Solution |
+|-------|--------|----------|
+| Ressources vides dans le ZIP | Le gestionnaire renvoie un nouveau `MemoryStream` sans écrire de données | Remplissez le flux avec les octets réels avant de le renvoyer |
+| Entrée `index.html` manquante | Le drapeau `Compress` n'est pas défini ou `OutputStorage` n'est pas assigné | Assurez‑vous que `saveOptions.Compress = true` et `saveOptions.OutputStorage = handler` |
+| HTML volumineux provoquant une pression mémoire | Toutes les ressources sont conservées en mémoire | Passez à une implémentation `FileStorage` qui écrit dans un dossier temporaire |
+| Les URL relatives se cassent après extraction | Ressources référencées avec des URL absolues qui ne sont pas stockées | Réécrivez les URL en chemins relatifs dans le gestionnaire ou lors du post‑traitement |
+
+## Exemple complet et exécutable
+
+```csharp
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Saving;
+
+class InMemoryResourceHandler : ResourceHandler
+{
+ private readonly DictionaryHello, world!
+
+
+ ";
+
+ HtmlDocument doc = new HtmlDocument();
+ doc.Open(html);
+
+ // Step 1 & 3: Create handler and configure save options.
+ var handler = new InMemoryResourceHandler();
+ HtmlSaveOptions options = new HtmlSaveOptions
+ {
+ OutputStorage = handler,
+ Compress = true
+ };
+
+ // Step 4: Save as ZIP.
+ string zipPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+ doc.Save(zipPath, options);
+ Console.WriteLine($"ZIP file created at: {zipPath}");
+
+ // Optional verification.
+ foreach (var kvp in handler.Resources)
+ {
+ Console.WriteLine($"Resource {kvp.Key} captured, length {kvp.Value.Length} bytes");
+ }
+ }
+}
+```
+
+L'exécution du programme produit `output.zip` à côté de l'exécutable. L'extraction de l'archive montre `index.html`, `styles.css` et `logo.png` (espaces réservés vides dans cet exemple minimal).
+
+## Conclusion
+
+Vous disposez maintenant d'une méthode fiable pour **enregistrer du HTML en ZIP** en utilisant Aspose.HTML en C#. Le tutoriel a couvert le chargement d'une chaîne HTML, l'implémentation d'un **gestionnaire de ressources personnalisé**, la configuration des options d'enregistrement, et la génération d'une archive ZIP prête à être distribuée ou téléchargée.
+
+À partir d'ici, vous pouvez :
+
+- Remplacer les flux d'espace réservé par du contenu réel (par ex., lire depuis une base de données)
+- Passer à un gestionnaire de stockage basé sur fichier pour des documents très volumineux
+- Intégrer la logique dans les points de terminaison ASP.NET Core pour des téléchargements à la demande
+- Explorer d'autres fonctionnalités d'Aspose.HTML comme la conversion PDF ou le rendu d'images
+
+Expérimentez avec différentes sources de ressources et paramètres de compression pour adapter la solution à vos exigences de performance et de taille. Bon codage !
+
+## Que devriez‑vous apprendre ensuite ?
+
+Les tutoriels suivants couvrent des sujets étroitement liés qui s'appuient sur les techniques démontrées dans ce guide. Chaque ressource comprend des exemples de code complets et fonctionnels avec des explications étape par étape pour vous aider à maîtriser des fonctionnalités d'API supplémentaires et explorer des approches d'implémentation alternatives dans vos propres projets.
+
+- [Enregistrer du HTML en ZIP – Tutoriel complet C#](/html/english/net/html-extensions-and-conversions/save-html-as-zip-complete-c-tutorial/)
+- [Comment enregistrer du HTML en C# – Guide complet avec un gestionnaire de ressources personnalisé](/html/english/net/working-with-html-documents/how-to-save-html-in-c-complete-guide-using-a-custom-resource/)
+- [Créer du HTML à partir d'une chaîne en C# – Guide du gestionnaire de ressources personnalisé](/html/english/net/html-document-manipulation/create-html-from-string-in-c-custom-resource-handler-guide/)
+
+{{< /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/generate-jpg-and-png-images/_index.md b/html/german/net/generate-jpg-and-png-images/_index.md
index 8c24c45378..8bcb3db0b0 100644
--- a/html/german/net/generate-jpg-and-png-images/_index.md
+++ b/html/german/net/generate-jpg-and-png-images/_index.md
@@ -45,6 +45,8 @@ Erfahren Sie, wie Sie mit Aspose.HTML für .NET HTML-Dokumente bearbeiten, HTML
Erfahren Sie, wie Sie beim Konvertieren von DOCX-Dokumenten in PNG oder JPG Antialiasing aktivieren, um hochwertige Bilder zu erhalten.
### [DOCX in PNG konvertieren – ZIP-Archiv erstellen C#‑Tutorial](./convert-docx-to-png-create-zip-archive-c-tutorial/)
Erfahren Sie, wie Sie DOCX‑Dateien in PNG‑Bilder umwandeln und diese in ein ZIP‑Archiv packen – Schritt‑für‑Schritt‑Anleitung in C#.
+### [PNG aus HTML in C# mit Aspose.HTML erstellen](./create-png-from-html-in-c-using-aspose-html/)
+Erfahren Sie, wie Sie mit Aspose.HTML für .NET HTML in PNG-Bilder konvertieren und dabei Parameter wie Auflösung und Qualität steuern.
## Abschluss
diff --git a/html/german/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md b/html/german/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
new file mode 100644
index 0000000000..4e03d172d3
--- /dev/null
+++ b/html/german/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
@@ -0,0 +1,292 @@
+---
+category: general
+date: 2026-08-12
+description: Erstellen Sie PNG aus HTML in C# mit Aspose.HTML. Erfahren Sie, wie Sie
+ HTML in PNG konvertieren und HTML als Bild rendern – in nur wenigen Codezeilen.
+draft: false
+images:
+- PLACEHOLDER_URL/og-image.png
+keywords:
+- create png from html
+- convert html to png
+- render html as image
+- how to render html to image
+language: de
+lastmod: 2026-08-12
+og_description: PNG aus HTML in C# mit Aspose.HTML erstellen. Dieser Leitfaden zeigt,
+ wie man HTML schnell als Bild rendert, und behandelt Konvertierungsoptionen, Codeeinrichtung
+ und Fehlersuche.
+og_image_alt: Screenshot of a C# program converting HTML to a PNG image
+og_title: PNG aus HTML in C# erstellen – Schritt‑für‑Schritt‑Anleitung
+schemas:
+- author: Aspose
+ dateModified: '2026-08-12'
+ description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ headline: Create PNG from HTML in C# using Aspose.HTML
+ type: TechArticle
+- description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ name: Create PNG from HTML in C# using Aspose.HTML
+ steps:
+ - name: Why this works
+ text: '- **`HtmlDocument.Open`** parses the HTML string into a DOM that Aspose.HTML
+ can render. - **`ImageRenderingOptions`** lets you control anti‑aliasing, text
+ hinting, and font handling, which are essential when you **render HTML as image**
+ to avoid blurry text. - **`ImageConverter.ConvertHtmlToImage`*'
+ - name: 1. Preparing the HTML source
+ text: You can load HTML from a string (as shown), a local file, or a remote URL.
+ - name: 2. Fine‑tuning rendering options
+ text: '| Option | Effect | When to adjust | |--------|--------|----------------|
+ | `UseAntialiasing` | Reduces jagged edges on vector graphics | Always enable
+ for high‑quality output | | `TextOptions.UseHinting` | Sharpens glyph edges
+ | Important for small font sizes | | `FontOptions.WebFontStyle` | Choose'
+ - name: 3. Performing the conversion
+ text: The `ImageConverter` overload you used writes a single PNG file. If you
+ need multiple pages (e.g., a multi‑page HTML document), use the overload that
+ returns a collection of images.
+ - name: a. Missing fonts
+ text: If the HTML references a custom web font that isn’t installed on the server,
+ the rendered text falls back to a default font, which may affect layout.
+ - name: b. Large pages and memory consumption
+ text: Rendering a very tall page can consume a lot of RAM.
+ - name: c. Transparent backgrounds
+ text: PNG supports transparency, but the default background is white.
+ type: HowTo
+tags:
+- Aspose.HTML
+- C#
+- image rendering
+- HTML conversion
+title: PNG aus HTML in C# mit Aspose.HTML erstellen
+url: /de/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/
+---
+
+{{< blocks/products/pf/main-wrap-class >}}
+{{< blocks/products/pf/main-container >}}
+{{< blocks/products/pf/tutorial-page-section >}}
+
+# PNG aus HTML in C# mit Aspose.HTML erstellen
+
+Wenn Sie **PNG aus HTML** in einer .NET‑Anwendung erstellen müssen, führt Sie diese Anleitung durch den gesamten Prozess. Sie sehen, wie Sie **HTML zu PNG** mit nur wenigen Zeilen C#‑Code konvertieren, wobei Sie die leistungsstarke Rendering‑Engine von Aspose.HTML nutzen.
+
+HTML als Bild zu rendern ist ein häufiges Bedürfnis, etwa beim Erzeugen von Thumbnails, E‑Mail‑Vorschauen oder Berichten, die in PDFs eingebettet werden müssen. In den folgenden Abschnitten lernen Sie die genauen Schritte, sehen ein vollständiges Beispiel und verstehen, warum jede Einstellung wichtig ist.
+
+## Was Sie lernen werden
+
+- Wie man ein `HtmlDocument` aus einem String oder einer Datei erstellt.
+- Wie man `ImageRenderingOptions` konfiguriert, um die Qualität zu verbessern.
+- Wie man **HTML zu PNG** konvertiert und das Ergebnis auf die Festplatte speichert.
+- Tipps zum Umgang mit Schriftarten, großen Seiten und benutzerdefinierten Ausgabepfaden.
+
+**Voraussetzungen**
+- .NET 6.0 SDK (oder neuer) installiert.
+- Eine gültige Aspose.HTML‑für‑.NET‑Lizenz (oder ein temporärer Evaluierungsschlüssel).
+- Grundlegende Kenntnisse in C# und Visual Studio bzw. einer .NET‑kompatiblen IDE.
+
+---
+
+## PNG aus HTML mit Aspose.HTML erstellen
+
+Der erste Schritt besteht darin, die Umgebung einzurichten und die erforderlichen Aspose.HTML‑Namespaces zu referenzieren.
+
+```csharp
+using System;
+using Aspose.Html;
+using Aspose.Html.Rendering.Image;
+using Aspose.Html.Drawing;
+using Aspose.Html.Converters;
+
+namespace HtmlToPngDemo
+{
+ class Program
+ {
+ static void Main()
+ {
+ // 1️⃣ Build the HTML document from a raw string.
+ var html = "Bold text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // 2️⃣ Configure rendering options for best visual fidelity. + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, // Smooths edges of drawn shapes + TextOptions = { UseHinting = true }, // Improves glyph clarity + FontOptions = { WebFontStyle = WebFontStyle.Normal } // Uses standard web‑font style + }; + + // 3️⃣ Convert the HTML document to a PNG file. + string outputPath = @"output.png"; + ImageConverter.ConvertHtmlToImage(document, outputPath, renderOptions); + + Console.WriteLine($"PNG image created at: {outputPath}"); + } + } +} +``` + +### Warum das funktioniert + +- **`HtmlDocument.Open`** parsed den HTML‑String in ein DOM, das Aspose.HTML rendern kann. +- **`ImageRenderingOptions`** ermöglicht die Steuerung von Anti‑Aliasing, Text‑Hinting und Schriftarten‑Handling, was entscheidend ist, wenn Sie **HTML als Bild rendern** und unscharfen Text vermeiden wollen. +- **`ImageConverter.ConvertHtmlToImage`** übernimmt die eigentliche Arbeit: Es rastert das DOM auf ein Bitmap und schreibt die PNG‑Datei. + +Das Ausführen des Programms erzeugt `output.png`, das den fett formatierten Absatz exakt wie im HTML‑Quellcode definiert enthält. + +--- + +## HTML zu PNG Schritt für Schritt + +Im Folgenden finden Sie eine detailliertere Durchsicht jeder Phase. Das Verständnis des Zwecks jeder Zeile hilft Ihnen, den Code für größere oder komplexere Seiten anzupassen. + +### 1. Vorbereitung der HTML‑Quelle + +Sie können HTML aus einem String (wie gezeigt), einer lokalen Datei oder einer Remote‑URL laden. + +```csharp +// Load from a file +var document = new HtmlDocument(); +document.Open(@"C:\templates\invoice.html"); + +// Load from a URL (requires internet access) +document.Open("https://example.com/report.html"); +``` + +**Tipp:** Wenn Sie externe Ressourcen (CSS, Bilder) laden, stellen Sie sicher, dass die Eigenschaft `BaseUrl` auf den richtigen Ordner zeigt, sodass relative Links korrekt aufgelöst werden. + +### 2. Feinabstimmung der Rendering‑Optionen + +| Option | Auswirkung | Wann anpassen | +|--------|------------|----------------| +| `UseAntialiasing` | Reduziert gezackte Kanten bei Vektorgrafiken | Immer aktivieren für hochwertige Ausgabe | +| `TextOptions.UseHinting` | Schärft Glyphen‑Kanten | Wichtig bei kleinen Schriftgrößen | +| `FontOptions.WebFontStyle` | Wählt normales, kursives oder schräges Web‑Font‑Rendering | Verwenden Sie `WebFontStyle.Oblique` für schräg gestellte Schriften | +| `ResolutionX` / `ResolutionY` | DPI des Ausgabebildes | Erhöhen für druckfertige PNGs (z. B. 300 DPI) | + +Beispiel zum Erhöhen der DPI: + +```csharp +renderOptions.ResolutionX = 300; +renderOptions.ResolutionY = 300; +``` + +### 3. Durchführung der Konvertierung + +Die von Ihnen verwendete `ImageConverter`‑Überladung schreibt eine einzelne PNG‑Datei. Wenn Sie mehrere Seiten benötigen (z. B. ein mehrseitiges HTML‑Dokument), verwenden Sie die Überladung, die eine Sammlung von Bildern zurückgibt. + +```csharp +ImageConverter.ConvertHtmlToImages(document, "output_folder", renderOptions); +``` + +Jede Seite wird zu `output_folder/page_0.png`, `page_1.png` usw. + +--- + +## HTML als Bild rendern – häufige Stolperfallen + +### a. Fehlende Schriftarten + +Wenn das HTML eine benutzerdefinierte Web‑Font referenziert, die auf dem Server nicht installiert ist, fällt der gerenderte Text auf eine Standardschrift zurück, was das Layout beeinflussen kann. + +**Lösung:** Betten Sie die Schriftart über eine `@font-face`‑Regel in Ihr CSS ein oder stellen Sie einen lokalen Schriftordner über `FontOptions` bereit. + +```csharp +renderOptions.FontOptions.FontFolder = @"C:\fonts"; +``` + +### b. Große Seiten und Speicherverbrauch + +Das Rendern einer sehr langen Seite kann viel RAM beanspruchen. + +**Lösung:** Setzen Sie eine maximale Höhe oder teilen Sie das Dokument vor der Konvertierung in Abschnitte. + +```csharp +renderOptions.PageHeight = 2000; // pixels +``` + +### c. Transparente Hintergründe + +PNG unterstützt Transparenz, aber der Standard‑Hintergrund ist weiß. + +**Lösung:** Ändern Sie die Hintergrundfarbe zu transparent. + +```csharp +renderOptions.BackgroundColor = System.Drawing.Color.Transparent; +``` + +--- + +## Wie man HTML zu Bild rendert – vollständiges Beispiel + +Alles zusammengeführt, hier ein produktionsreifes Snippet, das die häufigsten Anforderungen abdeckt: + +```csharp +using System; +using Aspose.Html; +using Aspose.Html.Rendering.Image; +using Aspose.Html.Drawing; +using Aspose.Html.Converters; + +namespace HtmlToPngDemo +{ + class Program + { + static void Main() + { + // Load HTML (string, file, or URL) + string html = "" + + "Bold blue text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // Configure rendering for high quality and transparency + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, + TextOptions = { UseHinting = true }, + FontOptions = { WebFontStyle = WebFontStyle.Normal, FontFolder = @"C:\fonts" }, + BackgroundColor = System.Drawing.Color.Transparent, + ResolutionX = 150, + ResolutionY = 150 + }; + + // Convert and save + string outPath = @"C:\temp\html_snapshot.png"; + ImageConverter.ConvertHtmlToImage(document, outPath, renderOptions); + + Console.WriteLine($"Image saved to {outPath}"); + } + } +} +``` + +**Erwartetes Ergebnis:** Eine `html_snapshot.png`‑Datei, die einen fettgedruckten, blauen Absatz auf einer transparenten Leinwand enthält. Das Bild ist anti‑aliased, mit klaren Texten dank Hinting. + +--- + +## Fazit + +Sie wissen jetzt, wie Sie **PNG aus HTML** in C# mit Aspose.HTML erstellen. Durch das Erzeugen eines `HtmlDocument`, das Konfigurieren von `ImageRenderingOptions` und das Aufrufen von `ImageConverter.ConvertHtmlToImage` können Sie zuverlässig **HTML zu PNG** konvertieren und **HTML als Bild rendern** für jedes Automatisierungsszenario. + +Von hier aus können Sie Folgendes erkunden: + +- Thumbnails für dynamische Webseiten erzeugen. +- Das PNG mit Aspose.PDF in PDFs einbetten. +- Den gleichen Ansatz verwenden, um JPEG oder BMP zu erzeugen, indem Sie die Dateierweiterung ändern. + +Experimentieren Sie gern mit DPI, Hintergrundfarben und Mehrseiten‑Rendering, um die genauen Anforderungen Ihres Projekts zu erfüllen. Viel Spaß beim Coden! + +## Was Sie als Nächstes lernen sollten + + +Die folgenden Tutorials behandeln eng verwandte Themen, die auf den in diesem Leitfaden gezeigten Techniken aufbauen. Jede Ressource enthält vollständige, funktionierende Code‑Beispiele mit Schritt‑für‑Schritt‑Erklärungen, damit Sie weitere API‑Funktionen meistern und alternative Implementierungsansätze in Ihren eigenen Projekten erkunden können. + +- [Render HTML as PNG in .NET with Aspose.HTML](/html/english/net/rendering-html-documents/render-html-as-png/) +- [How to Render HTML as PNG – Complete C# Guide](/html/english/net/rendering-html-documents/how-to-render-html-as-png-complete-c-guide/) +- [Create PNG from HTML – Full C# Rendering Guide](/html/english/net/rendering-html-documents/create-png-from-html-full-c-rendering-guide/) + +{{< /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 607896d28b..ae069b882c 100644 --- a/html/german/net/html-extensions-and-conversions/_index.md +++ b/html/german/net/html-extensions-and-conversions/_index.md @@ -71,6 +71,8 @@ Erfahren Sie, wie Sie ein HTML-Dokument mit formatiertem Text erstellen und es m Erstellen Sie PDF aus HTML mit C# – eine detaillierte Schritt‑für‑Schritt‑Anleitung mit Aspose.HTML für .NET. ### [HTML als ZIP speichern – Komplettes C#‑Tutorial](./save-html-as-zip-complete-c-tutorial/) 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# – Schritt‑für‑Schritt‑Anleitung](./save-html-as-zip-in-c-step-by-step-guide/) +Erfahren Sie, wie Sie HTML-Inhalte mit Aspose.HTML für .NET in ein ZIP-Archiv speichern – detaillierte 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. diff --git a/html/german/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md b/html/german/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..381fc5f949 --- /dev/null +++ b/html/german/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md @@ -0,0 +1,320 @@ +--- +category: general +date: 2026-08-12 +description: Speichern Sie HTML als ZIP mit Aspose.HTML. Erfahren Sie, wie Sie einen + HTML-String laden, einen benutzerdefinierten Ressourcen‑Handler erstellen und effizient + ein ZIP‑Archiv erzeugen. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save html as zip +- load html string +- custom resource handler +language: de +lastmod: 2026-08-12 +og_description: HTML als ZIP mit Aspose.HTML in C# speichern. Dieses Tutorial zeigt, + wie man einen HTML-String lädt, einen benutzerdefinierten Ressourcen‑Handler erstellt + und in wenigen Schritten ein ZIP‑Archiv erzeugt. +og_image_alt: Diagram showing save html as zip process with custom resource handler +og_title: HTML als ZIP mit Aspose.HTML speichern – vollständiger C#‑Leitfaden +schemas: +- author: Aspose + dateModified: '2026-08-12' + description: Save HTML as ZIP using Aspose.HTML. Learn to load HTML string, create + a custom resource handler, and generate a ZIP archive efficiently. + headline: Save HTML as ZIP in C# – step‑by‑step guide + type: TechArticle +tags: +- Aspose.HTML +- C# +- ZIP archive +title: HTML als ZIP in C# speichern – Schritt‑für‑Schritt‑Anleitung +url: /de/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# HTML als ZIP speichern in C# – Schritt‑für‑Schritt-Anleitung + +Wenn Sie **HTML als ZIP speichern** in einer .NET-Anwendung müssen, zeigt Ihnen dieser Leitfaden den kompletten Workflow. Sie lernen, wie man **HTML‑String lädt**, einen **benutzerdefinierten Ressourcen‑Handler** implementiert und ein ZIP‑Archiv erzeugt, ohne Zwischendateien auf die Festplatte zu schreiben. + +Der Ansatz verwendet Aspose.HTML 5.x, das eine Hochleistungs‑Rendering‑Engine und flexible Speicheroptionen bietet. Am Ende des Tutorials besitzen Sie einen wiederverwendbaren Handler, der in Web‑Services, Hintergrund‑Jobs oder Desktop‑Tools integriert werden kann. + +## Was Sie erstellen werden + +Der finale Code erzeugt eine `MemoryStream`‑basierte ZIP‑Datei, die das HTML‑Dokument und alle referenzierten Ressourcen (Bilder, CSS, Schriften) enthält. Die ZIP‑Datei wird in einen Zielordner geschrieben, Sie können das Ziel jedoch zu einem Response‑Stream für HTTP‑APIs ändern. + +## Voraussetzungen + +- .NET 6.0 oder höher (das Beispiel zielt auf .NET 6) +- Aspose.HTML für .NET (NuGet‑Paket `Aspose.HTML`) +- Grundlegende Kenntnisse der C#‑Async‑Muster (optional, aber hilfreich) + +> **Pro‑Tipp:** Installieren Sie das Paket mit `dotnet add package Aspose.HTML`, bevor Sie beginnen. + +## Schritt 1: Definieren eines benutzerdefinierten Ressourcen‑Handlers + +Ein **benutzerdefinierter Ressourcen‑Handler** fängt jede externe Ressourcenanforderung ab, die der HTML‑Renderer stellt. Durch Rückgabe eines Streams bestimmen Sie, wo die Ressourcendaten gespeichert werden. Das Beispiel speichert alles im Speicher, was sich ideal eignet, um ein ZIP‑Archiv on‑the‑fly zu erstellen. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +///Hello, world!
+
+
+";
+
+// Create a new document instance.
+HtmlDocument document = new HtmlDocument();
+
+// Load the HTML markup.
+document.Open(htmlContent);
+```
+
+**Warum dieser Schritt wichtig ist:**
+Die Fähigkeit, **HTML‑String zu laden**, ist nützlich, wenn HTML dynamisch erzeugt wird (z. B. von einer Template‑Engine) oder von einer API empfangen wird. Sie vermeidet Dateisystem‑Abhängigkeiten und funktioniert in sandbox‑Umgebungen.
+
+## Schritt 3: Speicheroptionen konfigurieren, um den Handler zu verwenden
+
+Mit `HtmlSaveOptions` von Aspose.HTML können Sie den Speichermechanismus für die Ausgabe festlegen. Weisen Sie den benutzerdefinierten Handler der Eigenschaft `OutputStorage` zu und setzen Sie das Flag `Compress`, um ein ZIP‑Archiv zu erzeugen.
+
+```csharp
+// Instantiate the custom handler.
+var resourceHandler = new InMemoryResourceHandler();
+
+// Prepare save options.
+HtmlSaveOptions saveOptions = new HtmlSaveOptions
+{
+ // Use the handler for all external resources.
+ OutputStorage = resourceHandler,
+
+ // Enable ZIP compression.
+ Compress = true
+};
+```
+
+**Warum dieser Schritt wichtig ist:**
+`Compress = true` weist Aspose.HTML an, die HTML‑Datei und alle gesammelten Ressourcen in ein einziges ZIP‑Paket zu bündeln. `OutputStorage` stellt sicher, dass Ressourcen im Speicher erfasst werden, anstatt in temporäre Orte geschrieben zu werden.
+
+## Schritt 4: Das Dokument als ZIP‑Archiv speichern
+
+Rufen Sie nun `HtmlDocument.Save` auf, übergeben Sie den Zielpfad und die konfigurierten Optionen. Nach dem Speichern enthält die ZIP‑Datei `index.html` plus alle vom Handler erfassten Ressourcen.
+
+```csharp
+// Define the output path (you can change this to a response stream for web APIs).
+string outputPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+
+// Save the document; Aspose.HTML creates the ZIP automatically.
+document.Save(outputPath, saveOptions);
+
+// Optional: Verify the resources that were stored.
+foreach (var entry in resourceHandler.Resources)
+{
+ Console.WriteLine($"Resource: {entry.Key}, Size: {entry.Value.Length} bytes");
+}
+```
+
+**Erwartetes Ergebnis:**
+Das Ausführen des Programms erzeugt `output.zip` im aktuellen Verzeichnis. Das Entpacken des Archivs zeigt:
+
+```
+index.html
+styles.css
+logo.png
+```
+
+Jede Datei entspricht den Markup‑Referenzen, und das HTML in `index.html` verweist auf die gebündelten Ressourcen.
+
+## Schritt 5: Den Handler für echte Ressourcendaten anpassen (fortgeschritten)
+
+Der obige einfache Handler erzeugt leere Streams. In der Produktion müssen Sie häufig den tatsächlichen Inhalt schreiben (z. B. die Bytes von `styles.css` oder `logo.png`). Erweitern Sie `HandleResource`, um Daten aus einer Datenbank, einem Cloud‑Bucket oder einer eingebetteten Ressource zu holen.
+
+```csharp
+public override Stream HandleResource(ResourceInfo info)
+{
+ // Example: Load resource from an embedded folder.
+ string resourcePath = Path.Combine("EmbeddedResources", info.Path);
+ byte[] data = File.ReadAllBytes(resourcePath);
+
+ // Write data into a memory stream.
+ var stream = new MemoryStream(data);
+ _resources[info.Path] = stream;
+
+ // Return the populated stream.
+ return stream;
+}
+```
+
+**Warum diese Variante wichtig ist:**
+Das Bereitstellen echter Inhalte stellt sicher, dass das ZIP‑Archiv beim Öffnen im Browser funktionsfähig ist. Der Handler kann zudem Transformationen (z. B. CSS‑Minifizierung) vor dem Schreiben in den Stream anwenden.
+
+## Schritt 6: Das ZIP‑Archiv in einer Web‑API verwenden (optional)
+
+Wenn Sie die Funktionalität über ASP.NET Core bereitstellen, geben Sie die ZIP‑Datei als File‑Result zurück:
+
+```csharp
+[HttpGet("download")]
+public IActionResult DownloadZip()
+{
+ // Reuse the same logic from steps 1‑4.
+ // ...
+
+ // Read the generated ZIP into a byte array.
+ byte[] zipBytes = System.IO.File.ReadAllBytes(outputPath);
+
+ // Return the file with the appropriate content type.
+ return File(zipBytes, "application/zip", "document.zip");
+}
+```
+
+**Warum dieser Schritt wichtig ist:**
+Clients können das verpackte HTML herunterladen, ohne sich mit temporären Dateien auf dem Server befassen zu müssen. Der Ansatz funktioniert mit serverlosen Funktionen, bei denen der Festplattenzugriff eingeschränkt ist.
+
+## Häufige Stolperfallen und wie man sie vermeidet
+
+| Problem | Grund | Lösung |
+|---------|--------|--------|
+| Leere Ressourcen im ZIP | Handler gibt einen frischen `MemoryStream` zurück, ohne Daten zu schreiben | Stream mit tatsächlichen Bytes füllen, bevor er zurückgegeben wird |
+| Fehlender `index.html`‑Eintrag | `Compress`‑Flag nicht gesetzt oder `OutputStorage` nicht zugewiesen | Sicherstellen, dass `saveOptions.Compress = true` und `saveOptions.OutputStorage = handler` |
+| Großes HTML verursacht Speicherbelastung | Alle Ressourcen werden im Speicher gehalten | Auf eine `FileStorage`‑Implementierung umsteigen, die in einen temporären Ordner schreibt |
+| Relative URLs brechen nach dem Entpacken | Ressourcen werden mit absoluten URLs referenziert, die nicht gespeichert werden | URLs im Handler oder während der Nachbearbeitung in relative Pfade umschreiben |
+
+## Vollständiges, ausführbares Beispiel
+
+```csharp
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Saving;
+
+class InMemoryResourceHandler : ResourceHandler
+{
+ private readonly DictionaryHello, world!
+
+
+ ";
+
+ HtmlDocument doc = new HtmlDocument();
+ doc.Open(html);
+
+ // Step 1 & 3: Create handler and configure save options.
+ var handler = new InMemoryResourceHandler();
+ HtmlSaveOptions options = new HtmlSaveOptions
+ {
+ OutputStorage = handler,
+ Compress = true
+ };
+
+ // Step 4: Save as ZIP.
+ string zipPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+ doc.Save(zipPath, options);
+ Console.WriteLine($"ZIP file created at: {zipPath}");
+
+ // Optional verification.
+ foreach (var kvp in handler.Resources)
+ {
+ Console.WriteLine($"Resource {kvp.Key} captured, length {kvp.Value.Length} bytes");
+ }
+ }
+}
+```
+
+Das Ausführen des Programms erzeugt `output.zip` neben der ausführbaren Datei. Das Entpacken des Archivs zeigt `index.html`, `styles.css` und `logo.png` (leere Platzhalter in diesem Minimalbeispiel).
+
+## Fazit
+
+Sie haben nun eine zuverlässige Methode, **HTML als ZIP zu speichern** mit Aspose.HTML in C#. Das Tutorial behandelte das Laden eines HTML‑Strings, die Implementierung eines **benutzerdefinierten Ressourcen‑Handlers**, das Konfigurieren von Speicheroptionen und das Erzeugen eines ZIP‑Archivs, das bereit für die Verteilung oder den Download ist.
+
+- Ersetzen Sie die Platzhalter‑Streams durch echte Inhalte (z. B. aus einer Datenbank lesen)
+- Wechseln Sie zu einem dateibasierten Speicher‑Handler für sehr große Dokumente
+- Integrieren Sie die Logik in ASP.NET‑Core‑Endpoints für On‑Demand‑Downloads
+- Erkunden Sie weitere Aspose.HTML‑Funktionen wie PDF‑Konvertierung oder Bild‑Rendering
+
+Experimentieren Sie mit verschiedenen Ressourcenquellen und Komprimierungseinstellungen, um die Lösung an Ihre Leistungs‑ und Größenanforderungen anzupassen. Viel Spaß beim Coden!
+
+## Was sollten Sie als Nächstes lernen?
+
+Die folgenden Tutorials behandeln eng verwandte Themen, die auf den in diesem Leitfaden gezeigten Techniken aufbauen. Jede Ressource enthält vollständige, funktionierende Code‑Beispiele mit Schritt‑für‑Schritt‑Erklärungen, um Ihnen zu helfen, zusätzliche API‑Funktionen zu meistern und alternative Implementierungsansätze in Ihren eigenen Projekten zu erkunden.
+
+- [HTML als ZIP speichern – Komplettes C#‑Tutorial](/html/english/net/html-extensions-and-conversions/save-html-as-zip-complete-c-tutorial/)
+- [Wie man HTML in C# speichert – Vollständiger Leitfaden mit benutzerdefiniertem Ressourcen‑Handler](/html/english/net/working-with-html-documents/how-to-save-html-in-c-complete-guide-using-a-custom-resource/)
+- [HTML aus String in C# erstellen – Leitfaden für benutzerdefinierten Ressourcen‑Handler](/html/english/net/html-document-manipulation/create-html-from-string-in-c-custom-resource-handler-guide/)
+
+{{< /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/generate-jpg-and-png-images/_index.md b/html/greek/net/generate-jpg-and-png-images/_index.md
index 5fd47cce36..0a2375f3a6 100644
--- a/html/greek/net/generate-jpg-and-png-images/_index.md
+++ b/html/greek/net/generate-jpg-and-png-images/_index.md
@@ -45,6 +45,8 @@ url: /el/net/generate-jpg-and-png-images/
Μάθετε πώς να βελτιώσετε την ποιότητα των εικόνων ενεργοποιώντας το antialiasing κατά τη μετατροπή αρχείων DOCX σε PNG ή JPG.
### [Μετατροπή docx σε png – δημιουργία αρχείου zip με C# σεμινάριο](./convert-docx-to-png-create-zip-archive-c-tutorial/)
Μάθετε πώς να μετατρέψετε αρχεία DOCX σε PNG και να δημιουργήσετε αρχείο ZIP χρησιμοποιώντας C#.
+### [Δημιουργήστε PNG από HTML σε C# χρησιμοποιώντας Aspose.HTML](./create-png-from-html-in-c-using-aspose-html/)
+Μάθετε πώς να δημιουργήσετε PNG από HTML σε C# με τη βιβλιοθήκη Aspose.HTML.
## Σύναψη
diff --git a/html/greek/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md b/html/greek/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
new file mode 100644
index 0000000000..52c0c95a84
--- /dev/null
+++ b/html/greek/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
@@ -0,0 +1,287 @@
+---
+category: general
+date: 2026-08-12
+description: Δημιουργήστε PNG από HTML σε C# με το Aspose.HTML. Μάθετε πώς να μετατρέψετε
+ HTML σε PNG και να αποδώσετε το HTML ως εικόνα με λίγες μόνο γραμμές κώδικα.
+draft: false
+images:
+- PLACEHOLDER_URL/og-image.png
+keywords:
+- create png from html
+- convert html to png
+- render html as image
+- how to render html to image
+language: el
+lastmod: 2026-08-12
+og_description: Δημιουργήστε PNG από HTML σε C# χρησιμοποιώντας το Aspose.HTML. Αυτός
+ ο οδηγός δείχνει πώς να αποδώσετε το HTML ως εικόνα γρήγορα, καλύπτοντας τις επιλογές
+ μετατροπής, τη ρύθμιση του κώδικα και την αντιμετώπιση προβλημάτων.
+og_image_alt: Screenshot of a C# program converting HTML to a PNG image
+og_title: Δημιουργία PNG από HTML σε C# – βήμα‑βήμα οδηγός
+schemas:
+- author: Aspose
+ dateModified: '2026-08-12'
+ description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ headline: Create PNG from HTML in C# using Aspose.HTML
+ type: TechArticle
+- description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ name: Create PNG from HTML in C# using Aspose.HTML
+ steps:
+ - name: Why this works
+ text: '- **`HtmlDocument.Open`** parses the HTML string into a DOM that Aspose.HTML
+ can render. - **`ImageRenderingOptions`** lets you control anti‑aliasing, text
+ hinting, and font handling, which are essential when you **render HTML as image**
+ to avoid blurry text. - **`ImageConverter.ConvertHtmlToImage`*'
+ - name: 1. Preparing the HTML source
+ text: You can load HTML from a string (as shown), a local file, or a remote URL.
+ - name: 2. Fine‑tuning rendering options
+ text: '| Option | Effect | When to adjust | |--------|--------|----------------|
+ | `UseAntialiasing` | Reduces jagged edges on vector graphics | Always enable
+ for high‑quality output | | `TextOptions.UseHinting` | Sharpens glyph edges
+ | Important for small font sizes | | `FontOptions.WebFontStyle` | Choose'
+ - name: 3. Performing the conversion
+ text: The `ImageConverter` overload you used writes a single PNG file. If you
+ need multiple pages (e.g., a multi‑page HTML document), use the overload that
+ returns a collection of images.
+ - name: a. Missing fonts
+ text: If the HTML references a custom web font that isn’t installed on the server,
+ the rendered text falls back to a default font, which may affect layout.
+ - name: b. Large pages and memory consumption
+ text: Rendering a very tall page can consume a lot of RAM.
+ - name: c. Transparent backgrounds
+ text: PNG supports transparency, but the default background is white.
+ type: HowTo
+tags:
+- Aspose.HTML
+- C#
+- image rendering
+- HTML conversion
+title: Δημιουργία PNG από HTML σε C# χρησιμοποιώντας το Aspose.HTML
+url: /el/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/
+---
+
+{{< blocks/products/pf/main-wrap-class >}}
+{{< blocks/products/pf/main-container >}}
+{{< blocks/products/pf/tutorial-page-section >}}
+
+# Δημιουργία PNG από HTML σε C# με χρήση Aspose.HTML
+
+Αν χρειάζεστε **δημιουργία PNG από HTML** σε μια εφαρμογή .NET, αυτός ο οδηγός σας καθοδηγεί μέσα από τη διαδικασία. Θα δείτε πώς να **μετατρέψετε HTML σε PNG** με λίγες μόνο γραμμές κώδικα C#, χρησιμοποιώντας τη δυνατότητα απόδοσης του Aspose.HTML.
+
+Η απόδοση του HTML ως εικόνα είναι συχνή απαίτηση όταν δημιουργούνται μικρογραφίες, προεπισκοπήσεις email ή αναφορές που πρέπει να ενσωματωθούν σε PDF. Στις επόμενες ενότητες, θα μάθετε τα ακριβή βήματα, θα δείτε ένα πλήρες λειτουργικό παράδειγμα και θα κατανοήσετε γιατί κάθε ρύθμιση είναι σημαντική.
+
+## Τι θα μάθετε
+
+- Πώς να δημιουργήσετε ένα `HtmlDocument` από μια συμβολοσειρά ή αρχείο.
+- Πώς να ρυθμίσετε το `ImageRenderingOptions` για βελτίωση της ποιότητας.
+- Πώς να **μετατρέψετε HTML σε PNG** και να αποθηκεύσετε το αποτέλεσμα στο δίσκο.
+- Συμβουλές για διαχείριση γραμματοσειρών, μεγάλων σελίδων και προσαρμοσμένων διαδρομών εξόδου.
+
+**Προαπαιτούμενα**
+- .NET 6.0 SDK (ή νεότερο) εγκατεστημένο.
+- Έγκυρη άδεια Aspose.HTML για .NET (ή προσωρινό κλειδί αξιολόγησης).
+- Βασική εξοικείωση με C# και Visual Studio ή οποιοδήποτε IDE συμβατό με .NET.
+
+---
+
+## Δημιουργία PNG από HTML με Aspose.HTML
+
+Το πρώτο βήμα είναι να ρυθμίσετε το περιβάλλον και να αναφέρετε τους απαιτούμενους χώρους ονομάτων του Aspose.HTML.
+
+```csharp
+using System;
+using Aspose.Html;
+using Aspose.Html.Rendering.Image;
+using Aspose.Html.Drawing;
+using Aspose.Html.Converters;
+
+namespace HtmlToPngDemo
+{
+ class Program
+ {
+ static void Main()
+ {
+ // 1️⃣ Build the HTML document from a raw string.
+ var html = "Bold text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // 2️⃣ Configure rendering options for best visual fidelity. + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, // Smooths edges of drawn shapes + TextOptions = { UseHinting = true }, // Improves glyph clarity + FontOptions = { WebFontStyle = WebFontStyle.Normal } // Uses standard web‑font style + }; + + // 3️⃣ Convert the HTML document to a PNG file. + string outputPath = @"output.png"; + ImageConverter.ConvertHtmlToImage(document, outputPath, renderOptions); + + Console.WriteLine($"PNG image created at: {outputPath}"); + } + } +} +``` + +### Γιατί λειτουργεί αυτό + +- **`HtmlDocument.Open`** αναλύει τη συμβολοσειρά HTML σε ένα DOM που μπορεί να αποδώσει το Aspose.HTML. +- **`ImageRenderingOptions`** σας επιτρέπει να ελέγχετε το anti‑aliasing, το text hinting και τη διαχείριση γραμματοσειρών, που είναι απαραίτητα όταν **αποδίδετε HTML ως εικόνα** για να αποφύγετε θολό κείμενο. +- **`ImageConverter.ConvertHtmlToImage`** εκτελεί τη βαριά δουλειά: ραστεροποιεί το DOM σε bitmap και γράφει το αρχείο PNG. + +Η εκτέλεση του προγράμματος δημιουργεί το `output.png` που περιέχει την έντονη παράγραφο ακριβώς όπως ορίζεται στην πηγή HTML. + +--- + +## Μετατροπή HTML σε PNG βήμα προς βήμα + +Παρακάτω υπάρχει μια πιο λεπτομερής περιήγηση σε κάθε φάση. Η κατανόηση του σκοπού κάθε γραμμής σας βοηθά να προσαρμόσετε τον κώδικα για μεγαλύτερες ή πιο σύνθετες σελίδες. + +### 1. Προετοιμασία της πηγής HTML + +Μπορείτε να φορτώσετε HTML από μια συμβολοσειρά (όπως φαίνεται), ένα τοπικό αρχείο ή μια απομακρυσμένη διεύθυνση URL. + +```csharp +// Load from a file +var document = new HtmlDocument(); +document.Open(@"C:\templates\invoice.html"); + +// Load from a URL (requires internet access) +document.Open("https://example.com/report.html"); +``` + +**Συμβουλή:** Κατά τη φόρτωση εξωτερικών πόρων (CSS, εικόνες), βεβαιωθείτε ότι η ιδιότητα `BaseUrl` δείχνει στο σωστό φάκελο ώστε οι σχετικές συνδέσεις να επιλύονται σωστά. + +### 2. Λεπτομερής ρύθμιση επιλογών απόδοσης + +| Επιλογή | Επίδραση | Πότε να προσαρμόσετε | +|--------|----------|----------------------| +| `UseAntialiasing` | Μειώνει τις ακρότητες στις διανυσματικές γραφικές παραστάσεις | Πάντα ενεργοποιήστε για υψηλής ποιότητας έξοδο | +| `TextOptions.UseHinting` | Αυξάνει την ευκρίνεια των άκρων των γλυφών | Σημαντικό για μικρά μεγέθη γραμματοσειράς | +| `FontOptions.WebFontStyle` | Επιλέγει κανονική, πλάγια ή λοξή απόδοση web‑font | Χρησιμοποιήστε `WebFontStyle.Oblique` για λοξές γραμματοσειρές | +| `ResolutionX` / `ResolutionY` | DPI της εικόνας εξόδου | Αυξήστε για PNG έτοιμα για εκτύπωση (π.χ., 300 DPI) | + +Παράδειγμα αύξησης DPI: + +```csharp +renderOptions.ResolutionX = 300; +renderOptions.ResolutionY = 300; +``` + +### 3. Εκτέλεση της μετατροπής + +Η υπερφόρτωση `ImageConverter` που χρησιμοποιήσατε γράφει ένα μόνο αρχείο PNG. Εάν χρειάζεστε πολλαπλές σελίδες (π.χ., ένα πολυσελιδικό έγγραφο HTML), χρησιμοποιήστε την υπερφόρτωση που επιστρέφει μια συλλογή εικόνων. + +```csharp +ImageConverter.ConvertHtmlToImages(document, "output_folder", renderOptions); +``` + +Κάθε σελίδα γίνεται `output_folder/page_0.png`, `page_1.png`, κ.λπ. + +--- + +## Απόδοση HTML ως εικόνα – αντιμετώπιση κοινών προβλημάτων + +### α. Ελλιπείς γραμματοσειρές + +Εάν το HTML αναφέρει μια προσαρμοσμένη web γραμματοσειρά που δεν είναι εγκατεστημένη στον διακομιστή, το κείμενο που αποδίδεται επιστρέφει σε προεπιλεγμένη γραμματοσειρά, κάτι που μπορεί να επηρεάσει τη διάταξη. + +**Λύση:** Ενσωματώστε τη γραμματοσειρά χρησιμοποιώντας έναν κανόνα `@font-face` στο CSS σας ή παρέχετε έναν τοπικό φάκελο γραμματοσειρών μέσω `FontOptions`. + +```csharp +renderOptions.FontOptions.FontFolder = @"C:\fonts"; +``` + +### β. Μεγάλες σελίδες και κατανάλωση μνήμης + +Η απόδοση μιας πολύ ψηλής σελίδας μπορεί να καταναλώσει πολύ RAM. + +**Λύση:** Ορίστε μέγιστο ύψος ή χωρίστε το έγγραφο σε ενότητες πριν από τη μετατροπή. + +```csharp +renderOptions.PageHeight = 2000; // pixels +``` + +### γ. Διαφάνεια φόντου + +Το PNG υποστηρίζει διαφάνεια, αλλά το προεπιλεγμένο φόντο είναι λευκό. + +**Λύση:** Αλλάξτε το χρώμα φόντου σε διαφανές. + +```csharp +renderOptions.BackgroundColor = System.Drawing.Color.Transparent; +``` + +## Πώς να αποδώσετε HTML ως εικόνα – πλήρη ανασκόπηση παραδείγματος + +Συνδυάζοντας όλα, εδώ είναι ένα έτοιμο για παραγωγή απόσπασμα που καλύπτει τις πιο συχνές απαιτήσεις: + +```csharp +using System; +using Aspose.Html; +using Aspose.Html.Rendering.Image; +using Aspose.Html.Drawing; +using Aspose.Html.Converters; + +namespace HtmlToPngDemo +{ + class Program + { + static void Main() + { + // Load HTML (string, file, or URL) + string html = "" + + "Bold blue text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // Configure rendering for high quality and transparency + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, + TextOptions = { UseHinting = true }, + FontOptions = { WebFontStyle = WebFontStyle.Normal, FontFolder = @"C:\fonts" }, + BackgroundColor = System.Drawing.Color.Transparent, + ResolutionX = 150, + ResolutionY = 150 + }; + + // Convert and save + string outPath = @"C:\temp\html_snapshot.png"; + ImageConverter.ConvertHtmlToImage(document, outPath, renderOptions); + + Console.WriteLine($"Image saved to {outPath}"); + } + } +} +``` + +**Αναμενόμενο αποτέλεσμα:** Ένα αρχείο `html_snapshot.png` που περιέχει μια έντονη, μπλε παράγραφο σε διαφανές καμβά. Η εικόνα θα είναι anti‑aliased, με καθαρό κείμενο χάρη στο hinting. + +## Συμπέρασμα + +Τώρα ξέρετε πώς να **δημιουργήσετε PNG από HTML** σε C# χρησιμοποιώντας το Aspose.HTML. Με τη δημιουργία ενός `HtmlDocument`, τη ρύθμιση του `ImageRenderingOptions` και την κλήση του `ImageConverter.ConvertHtmlToImage`, μπορείτε αξιόπιστα να **μετατρέψετε HTML σε PNG** και να **αποδώσετε HTML ως εικόνα** για οποιοδήποτε σενάριο αυτοματοποίησης. + +Από εδώ μπορείτε να εξερευνήσετε: + +- Δημιουργία μικρογραφιών για δυναμικές ιστοσελίδες. +- Ενσωμάτωση του PNG σε PDF με το Aspose.PDF. +- Χρήση της ίδιας προσέγγισης για παραγωγή JPEG ή BMP αλλάζοντας την επέκταση του αρχείου. + +Μη διστάσετε να πειραματιστείτε με DPI, χρώματα φόντου και πολυσελιδική απόδοση ώστε να ταιριάζει ακριβώς στις ανάγκες του έργου σας. Καλή προγραμματιστική! + +## Τι Θα Μάθετε Στη Συνέχεια; + +Τα παρακάτω tutorials καλύπτουν στενά σχετικές θεματικές που βασίζονται στις τεχνικές που παρουσιάζονται σε αυτόν τον οδηγό. Κάθε πόρος περιλαμβάνει πλήρη λειτουργικά παραδείγματα κώδικα με βήμα‑βήμα εξηγήσεις για να σας βοηθήσει να κατακτήσετε πρόσθετες δυνατότητες του API και να εξερευνήσετε εναλλακτικές προσεγγίσεις υλοποίησης στα δικά σας έργα. + +- [Απόδοση HTML ως PNG σε .NET με Aspose.HTML](/html/english/net/rendering-html-documents/render-html-as-png/) +- [Πώς να Αποδώσετε HTML ως PNG – Πλήρης Οδηγός C#](/html/english/net/rendering-html-documents/how-to-render-html-as-png-complete-c-guide/) +- [Δημιουργία PNG από HTML – Πλήρης Οδηγός Απόδοσης C#](/html/english/net/rendering-html-documents/create-png-from-html-full-c-rendering-guide/) + +{{< /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 013b0ec4b6..60eb7c81c6 100644 --- a/html/greek/net/html-extensions-and-conversions/_index.md +++ b/html/greek/net/html-extensions-and-conversions/_index.md @@ -73,6 +73,8 @@ url: /el/net/html-extensions-and-conversions/ Μάθετε πώς να αποθηκεύετε HTML σε αρχείο ZIP με C# και Aspose.HTML. ### [Αποθήκευση HTML σε ZIP σε C# – Πλήρες Παράδειγμα Εντός Μνήμης](./save-html-to-zip-in-c-complete-in-memory-example/) Μάθετε πώς να αποθηκεύετε HTML σε αρχείο ZIP με C# χρησιμοποιώντας πλήρες παράδειγμα εντός μνήμης. +### [Αποθήκευση HTML ως ZIP σε C# – βήμα‑βήμα οδηγός](./save-html-as-zip-in-c-step-by-step-guide/) +Μάθετε πώς να αποθηκεύετε αρχεία HTML σε αρχείο ZIP χρησιμοποιώντας C# και Aspose.HTML, βήμα‑βήμα. ## Σύναψη diff --git a/html/greek/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md b/html/greek/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..cb524f03e5 --- /dev/null +++ b/html/greek/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md @@ -0,0 +1,322 @@ +--- +category: general +date: 2026-08-12 +description: Αποθηκεύστε HTML ως ZIP χρησιμοποιώντας το Aspose.HTML. Μάθετε πώς να + φορτώνετε μια συμβολοσειρά HTML, να δημιουργείτε έναν προσαρμοσμένο διαχειριστή + πόρων και να δημιουργείτε ένα αρχείο ZIP αποδοτικά. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save html as zip +- load html string +- custom resource handler +language: el +lastmod: 2026-08-12 +og_description: Αποθήκευση HTML ως ZIP χρησιμοποιώντας το Aspose.HTML σε C#. Αυτό + το σεμινάριο δείχνει πώς να φορτώσετε μια συμβολοσειρά HTML, να δημιουργήσετε έναν + προσαρμοσμένο διαχειριστή πόρων και να δημιουργήσετε ένα αρχείο ZIP σε λίγα βήματα. +og_image_alt: Diagram showing save html as zip process with custom resource handler +og_title: Αποθήκευση HTML ως ZIP με το Aspose.HTML – πλήρης οδηγός C# +schemas: +- author: Aspose + dateModified: '2026-08-12' + description: Save HTML as ZIP using Aspose.HTML. Learn to load HTML string, create + a custom resource handler, and generate a ZIP archive efficiently. + headline: Save HTML as ZIP in C# – step‑by‑step guide + type: TechArticle +tags: +- Aspose.HTML +- C# +- ZIP archive +title: Αποθήκευση HTML ως ZIP σε C# – βήμα‑βήμα οδηγός +url: /el/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Αποθήκευση HTML ως ZIP σε C# – οδηγός βήμα‑βήμα + +Αν χρειάζεστε **αποθήκευση HTML ως ZIP** σε εφαρμογή .NET, αυτός ο οδηγός παρουσιάζει τη πλήρη ροή εργασίας. Θα μάθετε πώς να **φορτώνετε μια συμβολοσειρά HTML**, να υλοποιήσετε έναν **προσαρμοσμένο διαχειριστή πόρων** και να δημιουργήσετε ένα αρχείο ZIP χωρίς να γράψετε ενδιάμεσα αρχεία στο δίσκο. + +Η προσέγγιση χρησιμοποιεί το Aspose.HTML 5.x, το οποίο παρέχει έναν υψηλής απόδοσης μηχανισμό απόδοσης και ευέλικτες επιλογές αποθήκευσης. Στο τέλος του tutorial θα έχετε έναν επαναχρησιμοποιήσιμο διαχειριστή που μπορεί να ενσωματωθεί σε web services, background jobs ή desktop εργαλεία. + +## Τι θα δημιουργήσετε + +Ο τελικός κώδικας δημιουργεί ένα αρχείο ZIP βασισμένο σε `MemoryStream` που περιέχει το έγγραφο HTML και όλους τους αναφερόμενους πόρους (εικόνες, CSS, γραμματοσειρές). Το αρχείο ZIP γράφεται σε έναν προορισμό φακέλου, αλλά μπορείτε να αλλάξετε τον προορισμό σε ροή απόκρισης για HTTP APIs. + +## Προαπαιτούμενα + +- .NET 6.0 ή νεότερο (το δείγμα στοχεύει στο .NET 6) +- Aspose.HTML for .NET (πακέτο NuGet `Aspose.HTML`) +- Βασική εξοικείωση με τα async patterns του C# (προαιρετικό αλλά χρήσιμο) + +> **Pro tip:** Εγκαταστήστε το πακέτο με `dotnet add package Aspose.HTML` πριν ξεκινήσετε. + +## Βήμα 1: Ορισμός προσαρμοσμένου διαχειριστή πόρων + +Ένας **προσαρμοσμένος διαχειριστής πόρων** παρεμβάλλεται σε κάθε εξωτερικό αίτημα πόρου που κάνει ο renderer HTML. Επιστρέφοντας μια ροή, ελέγχετε πού αποθηκεύονται τα δεδομένα του πόρου. Το παράδειγμα αποθηκεύει τα πάντα στη μνήμη, κάτι ιδανικό για δημιουργία ZIP αρχείου «on‑the‑fly». + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +///Hello, world!
+
+
+";
+
+// Create a new document instance.
+HtmlDocument document = new HtmlDocument();
+
+// Load the HTML markup.
+document.Open(htmlContent);
+```
+
+**Γιατί είναι σημαντικό αυτό το βήμα:**
+Η δυνατότητα **load html string** είναι χρήσιμη όταν το HTML δημιουργείται δυναμικά (π.χ. από μηχανή προτύπων) ή λαμβάνεται από API. Αποφεύγει εξαρτήσεις από το σύστημα αρχείων και λειτουργεί σε περιβάλλοντα sandbox.
+
+## Βήμα 3: Διαμόρφωση επιλογών αποθήκευσης για χρήση του διαχειριστή
+
+Το `HtmlSaveOptions` του Aspose.HTML σας επιτρέπει να καθορίσετε τον μηχανισμό αποθήκευσης για το αποτέλεσμα. Αναθέστε τον προσαρμοσμένο διαχειριστή στην ιδιότητα `OutputStorage` και ορίστε τη σημαία `Compress` για παραγωγή αρχείου ZIP.
+
+```csharp
+// Instantiate the custom handler.
+var resourceHandler = new InMemoryResourceHandler();
+
+// Prepare save options.
+HtmlSaveOptions saveOptions = new HtmlSaveOptions
+{
+ // Use the handler for all external resources.
+ OutputStorage = resourceHandler,
+
+ // Enable ZIP compression.
+ Compress = true
+};
+```
+
+**Γιατί είναι σημαντικό αυτό το βήμα:**
+`Compress = true` λέει στο Aspose.HTML να συγκεντρώσει το αρχείο HTML και όλους τους συλλεγμένους πόρους σε ένα ενιαίο πακέτο ZIP. Το `OutputStorage` εξασφαλίζει ότι οι πόροι καταγράφονται στη μνήμη αντί να γράφονται σε προσωρινές τοποθεσίες.
+
+## Βήμα 4: Αποθήκευση του εγγράφου ως αρχείο ZIP
+
+Τώρα καλέστε το `HtmlDocument.Save`, περνώντας τη διαδρομή προορισμού και τις διαμορφωμένες επιλογές. Μετά την αποθήκευση, το αρχείο ZIP περιέχει το `index.html` συν όλους τους πόρους που έπιασε ο διαχειριστής.
+
+```csharp
+// Define the output path (you can change this to a response stream for web APIs).
+string outputPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+
+// Save the document; Aspose.HTML creates the ZIP automatically.
+document.Save(outputPath, saveOptions);
+
+// Optional: Verify the resources that were stored.
+foreach (var entry in resourceHandler.Resources)
+{
+ Console.WriteLine($"Resource: {entry.Key}, Size: {entry.Value.Length} bytes");
+}
+```
+
+**Αναμενόμενο αποτέλεσμα:**
+Η εκτέλεση του προγράμματος δημιουργεί το `output.zip` στον τρέχοντα φάκελο. Η εξαγωγή του αρχείου αποκαλύπτει:
+
+```
+index.html
+styles.css
+logo.png
+```
+
+Κάθε αρχείο ταιριάζει με τις αναφορές στο markup, και το HTML μέσα στο `index.html` δείχνει στους ενσωματωμένους πόρους.
+
+## Βήμα 5: Προσαρμογή του διαχειριστή για πραγματικά δεδομένα πόρων (προχωρημένο)
+
+Ο βασικός διαχειριστής παραπάνω δημιουργεί κενές ροές. Σε παραγωγή συχνά χρειάζεται να γράψετε το πραγματικό περιεχόμενο (π.χ. τα bytes του `styles.css` ή του `logo.png`). Επεκτείνετε το `HandleResource` ώστε να ανακτά δεδομένα από βάση, cloud bucket ή ενσωματωμένο πόρο.
+
+```csharp
+public override Stream HandleResource(ResourceInfo info)
+{
+ // Example: Load resource from an embedded folder.
+ string resourcePath = Path.Combine("EmbeddedResources", info.Path);
+ byte[] data = File.ReadAllBytes(resourcePath);
+
+ // Write data into a memory stream.
+ var stream = new MemoryStream(data);
+ _resources[info.Path] = stream;
+
+ // Return the populated stream.
+ return stream;
+}
+```
+
+**Γιατί είναι σημαντική αυτή η παραλλαγή:**
+Η παροχή πραγματικού περιεχομένου εξασφαλίζει ότι το αρχείο ZIP είναι λειτουργικό όταν ανοίξει σε φυλλομετρητή. Ο διαχειριστής μπορεί επίσης να εφαρμόσει μετασχηματισμούς (π.χ. minify CSS) πριν γράψει στη ροή.
+
+## Βήμα 6: Χρήση του αρχείου ZIP σε web API (προαιρετικό)
+
+Αν εκθέσετε τη λειτουργικότητα μέσω ASP.NET Core, επιστρέψτε το αρχείο ZIP ως αποτέλεσμα αρχείου:
+
+```csharp
+[HttpGet("download")]
+public IActionResult DownloadZip()
+{
+ // Reuse the same logic from steps 1‑4.
+ // ...
+
+ // Read the generated ZIP into a byte array.
+ byte[] zipBytes = System.IO.File.ReadAllBytes(outputPath);
+
+ // Return the file with the appropriate content type.
+ return File(zipBytes, "application/zip", "document.zip");
+}
+```
+
+**Γιατί είναι σημαντικό αυτό το βήμα:**
+Οι πελάτες μπορούν να κατεβάσουν το πακεταρισμένο HTML χωρίς να ασχοληθούν με προσωρινά αρχεία στον server. Η προσέγγιση λειτουργεί και σε serverless functions όπου η πρόσβαση στο δίσκο είναι περιορισμένη.
+
+## Συνηθισμένα προβλήματα και πώς να τα αποφύγετε
+
+| Πρόβλημα | Αιτία | Διόρθωση |
+|----------|-------|----------|
+| Κενά πόροι στο ZIP | Ο διαχειριστής επιστρέφει νέο `MemoryStream` χωρίς να γράφει δεδομένα | Συμπληρώστε τη ροή με πραγματικά bytes πριν την επιστρέψετε |
+| Λείπει η καταχώρηση `index.html` | Η σημαία `Compress` δεν έχει οριστεί ή το `OutputStorage` δεν έχει ανατεθεί | Βεβαιωθείτε ότι `saveOptions.Compress = true` και `saveOptions.OutputStorage = handler` |
+| Μεγάλο HTML που προκαλεί πίεση μνήμης | Όλοι οι πόροι κρατούνται στη μνήμη | Μεταβείτε σε υλοποίηση `FileStorage` που γράφει σε προσωρινό φάκελο |
+| Σχετικές URL που σπάζουν μετά την εξαγωγή | Πόροι που αναφέρονται με απόλυτες URL που δεν αποθηκεύονται | Ξαναγράψτε τις URL σε σχετικές διαδρομές μέσα στον διαχειριστή ή κατά την μετα-επεξεργασία |
+
+## Πλήρες, εκτελέσιμο παράδειγμα
+
+```csharp
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Saving;
+
+class InMemoryResourceHandler : ResourceHandler
+{
+ private readonly DictionaryHello, world!
+
+
+ ";
+
+ HtmlDocument doc = new HtmlDocument();
+ doc.Open(html);
+
+ // Step 1 & 3: Create handler and configure save options.
+ var handler = new InMemoryResourceHandler();
+ HtmlSaveOptions options = new HtmlSaveOptions
+ {
+ OutputStorage = handler,
+ Compress = true
+ };
+
+ // Step 4: Save as ZIP.
+ string zipPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+ doc.Save(zipPath, options);
+ Console.WriteLine($"ZIP file created at: {zipPath}");
+
+ // Optional verification.
+ foreach (var kvp in handler.Resources)
+ {
+ Console.WriteLine($"Resource {kvp.Key} captured, length {kvp.Value.Length} bytes");
+ }
+ }
+}
+```
+
+Η εκτέλεση του προγράμματος παράγει το `output.zip` δίπλα στο εκτελέσιμο. Η εξαγωγή του αρχείου δείχνει `index.html`, `styles.css` και `logo.png` (κενά placeholders σε αυτό το ελάχιστο παράδειγμα).
+
+## Συμπέρασμα
+
+Τώρα διαθέτετε μια αξιόπιστη μέθοδο για **αποθήκευση HTML ως ZIP** χρησιμοποιώντας το Aspose.HTML σε C#. Ο οδηγός κάλυψε τη φόρτωση συμβολοσειράς HTML, την υλοποίηση **προσαρμοσμένου διαχειριστή πόρων**, τη διαμόρφωση επιλογών αποθήκευσης και τη δημιουργία αρχείου ZIP έτοιμου για διανομή ή λήψη.
+
+Από εδώ μπορείτε:
+
+- Να αντικαταστήσετε τις placeholder ροές με πραγματικό περιεχόμενο (π.χ. ανάγνωση από βάση)
+- Να μεταβείτε σε διαχειριστή αποθήκευσης βασισμένο σε αρχείο για πολύ μεγάλα έγγραφα
+- Να ενσωματώσετε τη λογική σε endpoints ASP.NET Core για λήψεις κατά απαίτηση
+- Να εξερευνήσετε πρόσθετες δυνατότητες του Aspose.HTML όπως μετατροπή σε PDF ή απόδοση εικόνας
+
+Δοκιμάστε διαφορετικές πηγές πόρων και ρυθμίσεις συμπίεσης για να προσαρμόσετε τη λύση στις απαιτήσεις απόδοσης και μεγέθους σας. Καλή προγραμματιστική διασκέδαση!
+
+## Τι πρέπει να μάθετε στη συνέχεια;
+
+Τα παρακάτω tutorials καλύπτουν στενά συναφή θέματα που επεκτείνουν τις τεχνικές που παρουσιάστηκαν σε αυτόν τον οδηγό. Κάθε πόρος περιλαμβάνει πλήρη λειτουργικό κώδικα με βήμα‑βήμα εξηγήσεις για να κατακτήσετε επιπλέον δυνατότητες API και να εξερευνήσετε εναλλακτικές προσεγγίσεις στα δικά σας έργα.
+
+- [Save HTML as ZIP – Complete C# Tutorial](/html/english/net/html-extensions-and-conversions/save-html-as-zip-complete-c-tutorial/)
+- [How to Save HTML in C# – Complete Guide Using a Custom Resource Handler](/html/english/net/working-with-html-documents/how-to-save-html-in-c-complete-guide-using-a-custom-resource/)
+- [Create HTML from String in C# – Custom Resource Handler Guide](/html/english/net/html-document-manipulation/create-html-from-string-in-c-custom-resource-handler-guide/)
+
+{{< /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/generate-jpg-and-png-images/_index.md b/html/hindi/net/generate-jpg-and-png-images/_index.md
index b35cbb62e1..a49d2c51f1 100644
--- a/html/hindi/net/generate-jpg-and-png-images/_index.md
+++ b/html/hindi/net/generate-jpg-and-png-images/_index.md
@@ -44,7 +44,8 @@ HTML दस्तावेज़ों में हेरफेर करने
### [DOCX को PNG/JPG में बदलते समय एंटीएलियासिंग कैसे सक्षम करें](./how-to-enable-antialiasing-when-converting-docx-to-png-jpg/)
DOCX फ़ाइलों को PNG या JPG में परिवर्तित करते समय एंटीएलियासिंग को सक्षम करने के चरणों को जानें।
### [DOCX को PNG में परिवर्तित करें – ZIP आर्काइव बनाएं C# ट्यूटोरियल](./convert-docx-to-png-create-zip-archive-c-tutorial/)
-C# में DOCX फ़ाइलों को PNG छवियों में बदलें और उन्हें ZIP आर्काइव में संकलित करना सीखें। चरण-दर-चरण मार्गदर्शिका।
+C# में DOCX फ़ाइलों को PNG छवियों में बदलें और उन्हें ZIP आर्काइव में संकलित करना सीखें। चरण-दर-श्रेणी मार्गदर्शिका।
+### [Aspose.HTML का उपयोग करके C# में HTML से PNG बनाएं](./create-png-from-html-in-c-using-aspose-html/)
## निष्कर्ष
diff --git a/html/hindi/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md b/html/hindi/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
new file mode 100644
index 0000000000..c8b99df7f9
--- /dev/null
+++ b/html/hindi/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
@@ -0,0 +1,291 @@
+---
+category: general
+date: 2026-08-12
+description: C# में Aspose.HTML के साथ HTML से PNG बनाएं। सीखें कि कैसे HTML को PNG
+ में बदलें और केवल कुछ लाइनों के कोड से HTML को इमेज के रूप में रेंडर करें।
+draft: false
+images:
+- PLACEHOLDER_URL/og-image.png
+keywords:
+- create png from html
+- convert html to png
+- render html as image
+- how to render html to image
+language: hi
+lastmod: 2026-08-12
+og_description: Aspose.HTML का उपयोग करके C# में HTML से PNG बनाएं। यह गाइड दिखाता
+ है कि कैसे HTML को जल्दी से इमेज में रेंडर किया जाए, जिसमें रूपांतरण विकल्प, कोड
+ सेटअप और समस्या निवारण शामिल हैं।
+og_image_alt: Screenshot of a C# program converting HTML to a PNG image
+og_title: C# में HTML से PNG बनाएं – चरण-दर-चरण गाइड
+schemas:
+- author: Aspose
+ dateModified: '2026-08-12'
+ description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ headline: Create PNG from HTML in C# using Aspose.HTML
+ type: TechArticle
+- description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ name: Create PNG from HTML in C# using Aspose.HTML
+ steps:
+ - name: Why this works
+ text: '- **`HtmlDocument.Open`** parses the HTML string into a DOM that Aspose.HTML
+ can render. - **`ImageRenderingOptions`** lets you control anti‑aliasing, text
+ hinting, and font handling, which are essential when you **render HTML as image**
+ to avoid blurry text. - **`ImageConverter.ConvertHtmlToImage`*'
+ - name: 1. Preparing the HTML source
+ text: You can load HTML from a string (as shown), a local file, or a remote URL.
+ - name: 2. Fine‑tuning rendering options
+ text: '| Option | Effect | When to adjust | |--------|--------|----------------|
+ | `UseAntialiasing` | Reduces jagged edges on vector graphics | Always enable
+ for high‑quality output | | `TextOptions.UseHinting` | Sharpens glyph edges
+ | Important for small font sizes | | `FontOptions.WebFontStyle` | Choose'
+ - name: 3. Performing the conversion
+ text: The `ImageConverter` overload you used writes a single PNG file. If you
+ need multiple pages (e.g., a multi‑page HTML document), use the overload that
+ returns a collection of images.
+ - name: a. Missing fonts
+ text: If the HTML references a custom web font that isn’t installed on the server,
+ the rendered text falls back to a default font, which may affect layout.
+ - name: b. Large pages and memory consumption
+ text: Rendering a very tall page can consume a lot of RAM.
+ - name: c. Transparent backgrounds
+ text: PNG supports transparency, but the default background is white.
+ type: HowTo
+tags:
+- Aspose.HTML
+- C#
+- image rendering
+- HTML conversion
+title: Aspose.HTML का उपयोग करके C# में HTML से PNG बनाएं
+url: /hi/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/
+---
+
+{{< blocks/products/pf/main-wrap-class >}}
+{{< blocks/products/pf/main-container >}}
+{{< blocks/products/pf/tutorial-page-section >}}
+
+# C# में Aspose.HTML का उपयोग करके HTML से PNG बनाएं
+
+यदि आपको .NET एप्लिकेशन में **HTML से PNG बनाना** है, तो यह गाइड पूरी प्रक्रिया को चरण‑दर‑चरण दिखाता है। आप देखेंगे कि कैसे कुछ ही लाइनों के C# कोड से **HTML को PNG में बदलें**, Aspose.HTML के शक्तिशाली रेंडरिंग इंजन का उपयोग करके।
+
+HTML को इमेज के रूप में रेंडर करना थंबनेल, ईमेल प्रीव्यू या ऐसे रिपोर्ट बनाने के लिए सामान्य आवश्यकता है जिन्हें PDF में एम्बेड करना होता है। आगे के सेक्शन में आप सटीक कदम सीखेंगे, एक पूर्ण कार्यशील उदाहरण देखेंगे, और समझेंगे कि प्रत्येक सेटिंग क्यों महत्वपूर्ण है।
+
+## आप क्या सीखेंगे
+
+- स्ट्रिंग या फ़ाइल से `HtmlDocument` बनाना।
+- `ImageRenderingOptions` को कॉन्फ़िगर करके क्वालिटी सुधारना।
+- **HTML को PNG में बदलें** और परिणाम को डिस्क पर सहेजें।
+- फ़ॉन्ट, बड़े पेज और कस्टम आउटपुट पाथ को संभालने के टिप्स।
+
+**पूर्वापेक्षाएँ**
+- .NET 6.0 SDK (या बाद का) स्थापित हो।
+- वैध Aspose.HTML for .NET लाइसेंस (या अस्थायी इवैल्यूएशन की)।
+- C# और Visual Studio या किसी भी .NET‑संगत IDE की बुनियादी जानकारी।
+
+---
+
+## Aspose.HTML के साथ HTML से PNG बनाएं
+
+पहला कदम है पर्यावरण सेट अप करना और आवश्यक Aspose.HTML नेमस्पेस को रेफ़रेंस करना।
+
+```csharp
+using System;
+using Aspose.Html;
+using Aspose.Html.Rendering.Image;
+using Aspose.Html.Drawing;
+using Aspose.Html.Converters;
+
+namespace HtmlToPngDemo
+{
+ class Program
+ {
+ static void Main()
+ {
+ // 1️⃣ Build the HTML document from a raw string.
+ var html = "Bold text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // 2️⃣ Configure rendering options for best visual fidelity. + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, // Smooths edges of drawn shapes + TextOptions = { UseHinting = true }, // Improves glyph clarity + FontOptions = { WebFontStyle = WebFontStyle.Normal } // Uses standard web‑font style + }; + + // 3️⃣ Convert the HTML document to a PNG file. + string outputPath = @"output.png"; + ImageConverter.ConvertHtmlToImage(document, outputPath, renderOptions); + + Console.WriteLine($"PNG image created at: {outputPath}"); + } + } +} +``` + +### यह क्यों काम करता है + +- **`HtmlDocument.Open`** HTML स्ट्रिंग को DOM में पार्स करता है जिसे Aspose.HTML रेंडर कर सकता है। +- **`ImageRenderingOptions`** आपको एंटी‑एलियासिंग, टेक्स्ट हिन्टिंग और फ़ॉन्ट हैंडलिंग को नियंत्रित करने देता है, जो **HTML को इमेज के रूप में रेंडर** करते समय ब्लरी टेक्स्ट से बचने के लिए आवश्यक है। +- **`ImageConverter.ConvertHtmlToImage`** भारी काम करता है: यह DOM को बिटमैप पर रास्टराइज़ करता है और PNG फ़ाइल लिखता है। + +प्रोग्राम चलाने पर `output.png` बनता है जिसमें बॉल्ड पैराग्राफ ठीक उसी तरह होता है जैसा HTML स्रोत में परिभाषित है। + +--- + +## चरण‑दर‑चरण HTML को PNG में बदलें + +नीचे प्रत्येक चरण का विस्तृत विवरण दिया गया है। प्रत्येक लाइन के उद्देश्य को समझने से आप बड़े या जटिल पेजों के लिए कोड को आसानी से अनुकूलित कर सकते हैं। + +### 1. HTML स्रोत तैयार करना + +आप स्ट्रिंग (जैसा दिखाया गया है), स्थानीय फ़ाइल या रिमोट URL से HTML लोड कर सकते हैं। + +```csharp +// Load from a file +var document = new HtmlDocument(); +document.Open(@"C:\templates\invoice.html"); + +// Load from a URL (requires internet access) +document.Open("https://example.com/report.html"); +``` + +**टिप:** बाहरी संसाधन (CSS, इमेज) लोड करते समय सुनिश्चित करें कि `BaseUrl` प्रॉपर्टी सही फ़ोल्डर की ओर इशारा कर रही हो ताकि रिलेटिव लिंक सही ढंग से रिजॉल्व हो सकें। + +### 2. रेंडरिंग विकल्पों को फाइन‑ट्यून करना + +| विकल्प | प्रभाव | कब समायोजित करें | +|--------|--------|----------------| +| `UseAntialiasing` | वेक्टर ग्राफ़िक्स पर जैग्ड एजेज़ को कम करता है | हमेशा हाई‑क्वालिटी आउटपुट के लिए सक्षम रखें | +| `TextOptions.UseHinting` | ग्लिफ़ एजेज़ को शार्प बनाता है | छोटे फ़ॉन्ट साइज के लिए महत्वपूर्ण | +| `FontOptions.WebFontStyle` | सामान्य, इटैलिक या ऑब्लीक वेब‑फ़ॉन्ट रेंडरिंग चुनता है | स्लैंटेड फ़ॉन्ट के लिए `WebFontStyle.Oblique` उपयोग करें | +| `ResolutionX` / `ResolutionY` | आउटपुट इमेज की DPI | प्रिंट‑रेडी PNG के लिए बढ़ाएँ (उदा., 300 DPI) | + +DPI बढ़ाने का उदाहरण: + +```csharp +renderOptions.ResolutionX = 300; +renderOptions.ResolutionY = 300; +``` + +### 3. रूपांतरण करना + +आपके द्वारा उपयोग किया गया `ImageConverter` ओवरलोड एक ही PNG फ़ाइल लिखता है। यदि आपको कई पेज (जैसे मल्टी‑पेज HTML डॉक्यूमेंट) चाहिए, तो वह ओवरलोड उपयोग करें जो इमेजेज़ का कलेक्शन रिटर्न करता है। + +```csharp +ImageConverter.ConvertHtmlToImages(document, "output_folder", renderOptions); +``` + +प्रत्येक पेज `output_folder/page_0.png`, `page_1.png`, आदि बन जाता है। + +--- + +## HTML को इमेज के रूप में रेंडर करना – सामान्य समस्याओं का समाधान + +### a. फ़ॉन्ट नहीं मिल रहे हैं + +यदि HTML में कोई कस्टम वेब फ़ॉन्ट रेफ़रेंस है जो सर्वर पर इंस्टॉल नहीं है, तो रेंडर किया गया टेक्स्ट डिफ़ॉल्ट फ़ॉन्ट पर फ़ॉल्बैक हो जाता है, जिससे लेआउट प्रभावित हो सकता है। + +**समाधान:** अपने CSS में `@font-face` नियम के साथ फ़ॉन्ट एम्बेड करें या `FontOptions` के माध्यम से स्थानीय फ़ॉन्ट फ़ोल्डर प्रदान करें। + +```csharp +renderOptions.FontOptions.FontFolder = @"C:\fonts"; +``` + +### b. बड़े पेज और मेमोरी खपत + +बहुत लंबा पेज रेंडर करने से बड़ी मात्रा में RAM उपयोग हो सकता है। + +**समाधान:** अधिकतम ऊँचाई सेट करें या रूपांतरण से पहले डॉक्यूमेंट को सेक्शन में विभाजित करें। + +```csharp +renderOptions.PageHeight = 2000; // pixels +``` + +### c. ट्रांसपेरेंट बैकग्राउंड + +PNG ट्रांसपेरेंसी सपोर्ट करता है, लेकिन डिफ़ॉल्ट बैकग्राउंड सफ़ेद होता है। + +**समाधान:** बैकग्राउंड रंग को ट्रांसपेरेंट में बदलें। + +```csharp +renderOptions.BackgroundColor = System.Drawing.Color.Transparent; +``` + +--- + +## HTML को इमेज में रेंडर करना – पूर्ण उदाहरण सारांश + +सब कुछ एक साथ मिलाकर, यहाँ एक प्रोडक्शन‑रेडी स्निपेट है जो सबसे सामान्य आवश्यकताओं को कवर करता है: + +```csharp +using System; +using Aspose.Html; +using Aspose.Html.Rendering.Image; +using Aspose.Html.Drawing; +using Aspose.Html.Converters; + +namespace HtmlToPngDemo +{ + class Program + { + static void Main() + { + // Load HTML (string, file, or URL) + string html = "" + + "Bold blue text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // Configure rendering for high quality and transparency + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, + TextOptions = { UseHinting = true }, + FontOptions = { WebFontStyle = WebFontStyle.Normal, FontFolder = @"C:\fonts" }, + BackgroundColor = System.Drawing.Color.Transparent, + ResolutionX = 150, + ResolutionY = 150 + }; + + // Convert and save + string outPath = @"C:\temp\html_snapshot.png"; + ImageConverter.ConvertHtmlToImage(document, outPath, renderOptions); + + Console.WriteLine($"Image saved to {outPath}"); + } + } +} +``` + +**अपेक्षित आउटपुट:** एक `html_snapshot.png` फ़ाइल जिसमें पारदर्शी कैनवास पर बॉल्ड, ब्लू पैराग्राफ हो। इमेज एंटी‑एलियास्ड होगी, और हिन्टिंग के कारण टेक्स्ट स्पष्ट रहेगा। + +--- + +## निष्कर्ष + +अब आप जानते हैं कि C# में Aspose.HTML का उपयोग करके **HTML से PNG कैसे बनाएं**। `HtmlDocument` बनाकर, `ImageRenderingOptions` को कॉन्फ़िगर करके, और `ImageConverter.ConvertHtmlToImage` को कॉल करके आप भरोसेमंद रूप से **HTML को PNG में बदल सकते** हैं और **HTML को इमेज के रूप में रेंडर** कर सकते हैं, चाहे कोई भी ऑटोमेशन परिदृश्य हो। + +अब आप आगे खोज सकते हैं: + +- डायनामिक वेब पेज के थंबनेल बनाना। +- PNG को Aspose.PDF के साथ PDF में एम्बेड करना। +- फ़ाइल एक्सटेंशन बदलकर JPEG या BMP बनाना। + +DPI, बैकग्राउंड रंग और मल्टी‑पेज रेंडरिंग को अपने प्रोजेक्ट की सटीक जरूरतों के अनुसार प्रयोग करें। हैप्पी कोडिंग! + +## आगे आप क्या सीखें? + +निम्नलिखित ट्यूटोरियल्स उन विषयों को कवर करते हैं जो इस गाइड में दिखाए गए तकनीकों पर आधारित हैं। प्रत्येक संसाधन में पूर्ण कार्यशील कोड उदाहरण और चरण‑दर‑चरण व्याख्याएँ हैं, जिससे आप अतिरिक्त API फीचर्स में महारत हासिल कर सकें और अपने प्रोजेक्ट्स में वैकल्पिक इम्प्लीमेंटेशन अप्रोचेज़ को एक्सप्लोर कर सकें। + +- [Render HTML as PNG in .NET with Aspose.HTML](/html/english/net/rendering-html-documents/render-html-as-png/) +- [How to Render HTML as PNG – Complete C# Guide](/html/english/net/rendering-html-documents/how-to-render-html-as-png-complete-c-guide/) +- [Create PNG from HTML – Full C# Rendering Guide](/html/english/net/rendering-html-documents/create-png-from-html-full-c-rendering-guide/) + +{{< /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 45408d5a1f..5645ee3419 100644 --- a/html/hindi/net/html-extensions-and-conversions/_index.md +++ b/html/hindi/net/html-extensions-and-conversions/_index.md @@ -81,6 +81,9 @@ Aspose.HTML के साथ .NET में HTML को MHTML में बद ### [HTML को ZIP के रूप में सहेजें – पूर्ण C# ट्यूटोरियल](./save-html-as-zip-complete-c-tutorial/) HTML को ZIP फ़ाइल में सहेजने के चरण-दर-चरण मार्गदर्शन, C# कोड उदाहरण और अनुकूलन विकल्प। +### [C# में HTML को ZIP के रूप में सहेजें – चरण‑दर‑चरण गाइड](./save-html-as-zip-in-c-step-by-step-guide/) +C# में Aspose.HTML का उपयोग करके HTML को ZIP फ़ाइल में सहेजने के चरण‑दर‑चरण मार्गदर्शन। + ### [C# में HTML को ज़िप कैसे करें – HTML को ज़िप में सहेजें](./how-to-zip-html-in-c-save-html-to-zip/) .NET के लिए Aspose.HTML का उपयोग करके C# में HTML को ज़िप फ़ाइल में सहेजने का तरीका सीखें। diff --git a/html/hindi/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md b/html/hindi/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..e02334f28a --- /dev/null +++ b/html/hindi/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md @@ -0,0 +1,322 @@ +--- +category: general +date: 2026-08-12 +description: Aspose.HTML का उपयोग करके HTML को ZIP के रूप में सहेजें। HTML स्ट्रिंग + लोड करना, एक कस्टम रिसोर्स हैंडलर बनाना, और कुशलतापूर्वक ZIP आर्काइव जेनरेट करना + सीखें। +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save html as zip +- load html string +- custom resource handler +language: hi +lastmod: 2026-08-12 +og_description: C# में Aspose.HTML का उपयोग करके HTML को ZIP के रूप में सहेजें। यह + ट्यूटोरियल दिखाता है कि कैसे एक HTML स्ट्रिंग लोड करें, एक कस्टम रिसोर्स हैंडलर + बनाएं, और कुछ चरणों में ZIP आर्काइव जनरेट करें। +og_image_alt: Diagram showing save html as zip process with custom resource handler +og_title: Aspose.HTML के साथ HTML को ZIP के रूप में सहेजें – पूर्ण C# गाइड +schemas: +- author: Aspose + dateModified: '2026-08-12' + description: Save HTML as ZIP using Aspose.HTML. Learn to load HTML string, create + a custom resource handler, and generate a ZIP archive efficiently. + headline: Save HTML as ZIP in C# – step‑by‑step guide + type: TechArticle +tags: +- Aspose.HTML +- C# +- ZIP archive +title: C# में HTML को ZIP के रूप में सहेजें – चरण‑दर‑चरण मार्गदर्शिका +url: /hi/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Save HTML as ZIP in C# – चरण‑दर‑चरण गाइड + +यदि आपको **HTML को ZIP के रूप में सहेजना** है किसी .NET एप्लिकेशन में, तो यह गाइड पूरी कार्यप्रणाली दिखाता है। आप सीखेंगे **HTML स्ट्रिंग लोड करना**, **कस्टम रिसोर्स हैंडलर** लागू करना, और बिना किसी मध्यवर्ती फ़ाइल को डिस्क पर लिखे ZIP आर्काइव बनाना। + +यह तरीका Aspose.HTML 5.x का उपयोग करता है, जो उच्च‑प्रदर्शन रेंडरिंग इंजन और लचीले सहेजने के विकल्प प्रदान करता है। ट्यूटोरियल के अंत तक आपके पास एक पुन: उपयोग योग्य हैंडलर होगा जिसे वेब सर्विसेज, बैकग्राउंड जॉब्स, या डेस्कटॉप टूल्स में एकीकृत किया जा सकता है। + +## आप क्या बनाएँगे + +अंतिम कोड एक `MemoryStream`‑आधारित ZIP फ़ाइल बनाता है जिसमें HTML दस्तावेज़ और सभी संदर्भित संसाधन (इमेज, CSS, फ़ॉन्ट) शामिल होते हैं। ZIP फ़ाइल को लक्ष्य फ़ोल्डर में लिखा जाता है, लेकिन आप इसे HTTP API के लिए रिस्पॉन्स स्ट्रीम में बदल सकते हैं। + +## पूर्वापेक्षाएँ + +- .NET 6.0 या बाद का (उदाहरण .NET 6 को टार्गेट करता है) +- Aspose.HTML for .NET (NuGet पैकेज `Aspose.HTML`) +- C# async पैटर्न की बुनियादी समझ (वैकल्पिक लेकिन उपयोगी) + +> **प्रो टिप:** शुरू करने से पहले `dotnet add package Aspose.HTML` कमांड से पैकेज इंस्टॉल करें। + +## चरण 1: कस्टम रिसोर्स हैंडलर परिभाषित करें + +एक **कस्टम रिसोर्स हैंडलर** HTML रेंडरर द्वारा किए गए प्रत्येक बाहरी संसाधन अनुरोध को इंटरसेप्ट करता है। एक स्ट्रीम लौटाकर आप नियंत्रित करते हैं कि संसाधन डेटा कहाँ संग्रहीत हो। यह उदाहरण सब कुछ मेमोरी में रखता है, जो ऑन‑द‑फ़्लाई ZIP आर्काइव बनाने के लिए आदर्श है। + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +///Hello, world!
+
+
+";
+
+// Create a new document instance.
+HtmlDocument document = new HtmlDocument();
+
+// Load the HTML markup.
+document.Open(htmlContent);
+```
+
+**यह चरण क्यों महत्वपूर्ण है:**
+**load html string** क्षमता तब उपयोगी होती है जब HTML डायनामिक रूप से जेनरेट किया जाता है (जैसे टेम्पलेट इंजन से) या API से प्राप्त होता है। यह फ़ाइल‑सिस्टम निर्भरताओं से बचाता है और सैंडबॉक्स्ड वातावरण में काम करता है।
+
+## चरण 3: हैंडलर का उपयोग करने के लिए सेव ऑप्शन कॉन्फ़िगर करें
+
+Aspose.HTML का `HtmlSaveOptions` आपको आउटपुट के स्टोरेज मैकेनिज़्म को निर्दिष्ट करने देता है। कस्टम हैंडलर को `OutputStorage` प्रॉपर्टी में असाइन करें, और `Compress` फ़्लैग को `true` सेट करके ZIP आर्काइव बनाएं।
+
+```csharp
+// Instantiate the custom handler.
+var resourceHandler = new InMemoryResourceHandler();
+
+// Prepare save options.
+HtmlSaveOptions saveOptions = new HtmlSaveOptions
+{
+ // Use the handler for all external resources.
+ OutputStorage = resourceHandler,
+
+ // Enable ZIP compression.
+ Compress = true
+};
+```
+
+**यह चरण क्यों महत्वपूर्ण है:**
+`Compress = true` Aspose.HTML को HTML फ़ाइल और सभी एकत्रित संसाधनों को एकल ZIP पैकेज में बंडल करने को बताता है। `OutputStorage` सुनिश्चित करता है कि संसाधन मेमोरी में कैप्चर हों, न कि अस्थायी स्थानों पर लिखे जाएँ।
+
+## चरण 4: दस्तावेज़ को ZIP आर्काइव के रूप में सहेजें
+
+अब `HtmlDocument.Save` को कॉल करें, लक्ष्य पथ और कॉन्फ़िगर किए गए विकल्प पास करें। सहेजने के बाद ZIP फ़ाइल में `index.html` के साथ हैंडलर द्वारा कैप्चर किए गए सभी संसाधन होते हैं।
+
+```csharp
+// Define the output path (you can change this to a response stream for web APIs).
+string outputPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+
+// Save the document; Aspose.HTML creates the ZIP automatically.
+document.Save(outputPath, saveOptions);
+
+// Optional: Verify the resources that were stored.
+foreach (var entry in resourceHandler.Resources)
+{
+ Console.WriteLine($"Resource: {entry.Key}, Size: {entry.Value.Length} bytes");
+}
+```
+
+**अपेक्षित परिणाम:**
+प्रोग्राम चलाने पर वर्तमान डायरेक्टरी में `output.zip` बनता है। आर्काइव को एक्सट्रैक्ट करने पर मिलेगा:
+
+```
+index.html
+styles.css
+logo.png
+```
+
+प्रत्येक फ़ाइल मार्कअप रेफ़रेंसेज़ से मेल खाती है, और `index.html` के भीतर HTML बंडल्ड संसाधनों की ओर इशारा करता है।
+
+## चरण 5: वास्तविक संसाधन डेटा के लिए हैंडलर को अनुकूलित करें (उन्नत)
+
+ऊपर दिया गया बेसिक हैंडलर खाली स्ट्रीम बनाता है। प्रोडक्शन में अक्सर आपको वास्तविक कंटेंट (जैसे `styles.css` या `logo.png` के बाइट्स) लिखना पड़ता है। `HandleResource` को विस्तारित करके डेटा को डेटाबेस, क्लाउड बकेट, या एम्बेडेड रिसोर्स से प्राप्त करें।
+
+```csharp
+public override Stream HandleResource(ResourceInfo info)
+{
+ // Example: Load resource from an embedded folder.
+ string resourcePath = Path.Combine("EmbeddedResources", info.Path);
+ byte[] data = File.ReadAllBytes(resourcePath);
+
+ // Write data into a memory stream.
+ var stream = new MemoryStream(data);
+ _resources[info.Path] = stream;
+
+ // Return the populated stream.
+ return stream;
+}
+```
+
+**यह विविधता क्यों महत्वपूर्ण है:**
+वास्तविक कंटेंट प्रदान करने से ZIP आर्काइव ब्राउज़र में खुलने पर कार्यात्मक बनता है। हैंडलर ट्रांसफ़ॉर्मेशन (जैसे CSS को मिनिफ़ाई) भी लागू कर सकता है इससे पहले कि स्ट्रीम में लिखा जाए।
+
+## चरण 6: वेब API में ZIP आर्काइव का उपयोग करें (वैकल्पिक)
+
+यदि आप इस फ़ंक्शनैलिटी को ASP.NET Core के माध्यम से एक्सपोज़ करते हैं, तो ZIP फ़ाइल को फ़ाइल रिज़ल्ट के रूप में रिटर्न करें:
+
+```csharp
+[HttpGet("download")]
+public IActionResult DownloadZip()
+{
+ // Reuse the same logic from steps 1‑4.
+ // ...
+
+ // Read the generated ZIP into a byte array.
+ byte[] zipBytes = System.IO.File.ReadAllBytes(outputPath);
+
+ // Return the file with the appropriate content type.
+ return File(zipBytes, "application/zip", "document.zip");
+}
+```
+
+**यह चरण क्यों महत्वपूर्ण है:**
+क्लाइंट्स सर्वर पर अस्थायी फ़ाइलों से निपटे बिना पैकेज्ड HTML डाउनलोड कर सकते हैं। यह तरीका सर्वरलेस फ़ंक्शन्स में भी काम करता है जहाँ डिस्क एक्सेस सीमित होता है।
+
+## सामान्य समस्याएँ और उनके समाधान
+
+| समस्या | कारण | समाधान |
+|---------|--------|-----|
+| ZIP में खाली संसाधन | हैंडलर बिना डेटा लिखे नया `MemoryStream` रिटर्न करता है | स्ट्रीम को वास्तविक बाइट्स से भरें और फिर रिटर्न करें |
+| `index.html` एंट्री नहीं मिल रही | `Compress` फ़्लैग सेट नहीं है या `OutputStorage` असाइन नहीं किया गया | सुनिश्चित करें `saveOptions.Compress = true` और `saveOptions.OutputStorage = handler` |
+| बड़े HTML से मेमोरी प्रेशर | सभी संसाधन मेमोरी में रखे जाते हैं | `FileStorage` इम्प्लीमेंटेशन का उपयोग करें जो अस्थायी फ़ोल्डर में लिखे |
+| एक्सट्रैक्शन के बाद रिलेटिव URLs टूट रहे हैं | रिसोर्सेज को एब्सोल्यूट URLs से रेफ़र किया गया जो स्टोर नहीं हुए | हैंडलर में या पोस्ट‑प्रोसेसिंग के दौरान URLs को रिलेटिव पाथ में बदलें |
+
+## पूर्ण, चलाने योग्य उदाहरण
+
+```csharp
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Saving;
+
+class InMemoryResourceHandler : ResourceHandler
+{
+ private readonly DictionaryHello, world!
+
+
+ ";
+
+ HtmlDocument doc = new HtmlDocument();
+ doc.Open(html);
+
+ // Step 1 & 3: Create handler and configure save options.
+ var handler = new InMemoryResourceHandler();
+ HtmlSaveOptions options = new HtmlSaveOptions
+ {
+ OutputStorage = handler,
+ Compress = true
+ };
+
+ // Step 4: Save as ZIP.
+ string zipPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+ doc.Save(zipPath, options);
+ Console.WriteLine($"ZIP file created at: {zipPath}");
+
+ // Optional verification.
+ foreach (var kvp in handler.Resources)
+ {
+ Console.WriteLine($"Resource {kvp.Key} captured, length {kvp.Value.Length} bytes");
+ }
+ }
+}
+```
+
+प्रोग्राम चलाने पर एक्सिक्यूटेबल के बगल में `output.zip` बनता है। आर्काइव को एक्सट्रैक्ट करने पर `index.html`, `styles.css`, और `logo.png` (इस न्यूनतम उदाहरण में खाली प्लेसहोल्डर) दिखेंगे।
+
+## निष्कर्ष
+
+अब आपके पास Aspose.HTML का उपयोग करके C# में **HTML को ZIP के रूप में सहेजने** की एक भरोसेमंद विधि है। ट्यूटोरियल ने HTML स्ट्रिंग लोड करना, **कस्टम रिसोर्स हैंडलर** लागू करना, सेव ऑप्शन कॉन्फ़िगर करना, और वितरण या डाउनलोड के लिए तैयार ZIP आर्काइव जेनरेट करना कवर किया।
+
+अब आप कर सकते हैं:
+
+- प्लेसहोल्डर स्ट्रीम को वास्तविक कंटेंट से बदलें (जैसे डेटाबेस से पढ़ना)
+- बहुत बड़े दस्तावेज़ों के लिए फ़ाइल‑आधारित स्टोरेज हैंडलर पर स्विच करें
+- ऑन‑डिमांड डाउनलोड के लिए ASP.NET Core एंडपॉइंट में लॉजिक इंटीग्रेट करें
+- अतिरिक्त Aspose.HTML फीचर्स जैसे PDF कन्वर्ज़न या इमेज रेंडरिंग का अन्वेषण करें
+
+विभिन्न रिसोर्स स्रोतों और कॉम्प्रेशन सेटिंग्स के साथ प्रयोग करें ताकि समाधान को अपने प्रदर्शन और आकार आवश्यकताओं के अनुसार ट्यून कर सकें। Happy coding!
+
+## आगे आप क्या सीखें?
+
+निम्नलिखित ट्यूटोरियल्स उन विषयों को कवर करते हैं जो इस गाइड में दिखाए गए तकनीकों पर आधारित हैं। प्रत्येक संसाधन में पूर्ण कार्यशील कोड उदाहरण और चरण‑दर‑चरण व्याख्याएँ शामिल हैं, जिससे आप अतिरिक्त API फीचर्स में महारत हासिल कर सकें और अपने प्रोजेक्ट्स में वैकल्पिक इम्प्लीमेंटेशन एप्रोच को एक्सप्लोर कर सकें।
+
+- [HTML को ZIP के रूप में सहेजें – पूर्ण C# ट्यूटोरियल](/html/english/net/html-extensions-and-conversions/save-html-as-zip-complete-c-tutorial/)
+- [C# में HTML को सहेजने का तरीका – कस्टम रिसोर्स हैंडलर के साथ पूर्ण गाइड](/html/english/net/working-with-html-documents/how-to-save-html-in-c-complete-guide-using-a-custom-resource/)
+- [C# में स्ट्रिंग से HTML बनाएं – कस्टम रिसोर्स हैंडलर गाइड](/html/english/net/html-document-manipulation/create-html-from-string-in-c-custom-resource-handler-guide/)
+
+{{< /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/generate-jpg-and-png-images/_index.md b/html/hongkong/net/generate-jpg-and-png-images/_index.md
index 33103bd045..4eae8bb7d2 100644
--- a/html/hongkong/net/generate-jpg-and-png-images/_index.md
+++ b/html/hongkong/net/generate-jpg-and-png-images/_index.md
@@ -45,6 +45,8 @@ Aspose.HTML for .NET 提供了一種將 HTML 轉換為映像的簡單方法。
了解如何在使用 Aspose.HTML for .NET 將 DOCX 轉換為 PNG 或 JPG 時啟用抗鋸齒，以提升圖像品質。
### [使用 Aspose.HTML 在 .NET 中將 docx 轉換為 png 並建立 zip 壓縮檔 C# 教學](./convert-docx-to-png-create-zip-archive-c-tutorial/)
學習如何使用 Aspose.HTML for .NET 將 docx 轉換為 png，並將圖像打包成 zip 壓縮檔的完整步驟。
+### [使用 Aspose.HTML 在 C# 中從 HTML 產生 PNG](./create-png-from-html-in-c-using-aspose-html/)
+了解如何使用 Aspose.HTML for .NET 將 HTML 轉換為 PNG 圖像的步驟。
## 結論
diff --git a/html/hongkong/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md b/html/hongkong/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
new file mode 100644
index 0000000000..c0c16e8953
--- /dev/null
+++ b/html/hongkong/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
@@ -0,0 +1,289 @@
+---
+category: general
+date: 2026-08-12
+description: 使用 Aspose.HTML 在 C# 中將 HTML 轉換為 PNG。了解如何將 HTML 轉為 PNG，並僅用幾行程式碼即可將 HTML
+ 渲染為圖像。
+draft: false
+images:
+- PLACEHOLDER_URL/og-image.png
+keywords:
+- create png from html
+- convert html to png
+- render html as image
+- how to render html to image
+language: zh-hant
+lastmod: 2026-08-12
+og_description: 使用 Aspose.HTML 在 C# 中將 HTML 轉換為 PNG。此指南快速說明如何將 HTML 渲染為圖像，涵蓋轉換選項、程式碼設定與故障排除。
+og_image_alt: Screenshot of a C# program converting HTML to a PNG image
+og_title: 在 C# 中從 HTML 產生 PNG – 逐步指南
+schemas:
+- author: Aspose
+ dateModified: '2026-08-12'
+ description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ headline: Create PNG from HTML in C# using Aspose.HTML
+ type: TechArticle
+- description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ name: Create PNG from HTML in C# using Aspose.HTML
+ steps:
+ - name: Why this works
+ text: '- **`HtmlDocument.Open`** parses the HTML string into a DOM that Aspose.HTML
+ can render. - **`ImageRenderingOptions`** lets you control anti‑aliasing, text
+ hinting, and font handling, which are essential when you **render HTML as image**
+ to avoid blurry text. - **`ImageConverter.ConvertHtmlToImage`*'
+ - name: 1. Preparing the HTML source
+ text: You can load HTML from a string (as shown), a local file, or a remote URL.
+ - name: 2. Fine‑tuning rendering options
+ text: '| Option | Effect | When to adjust | |--------|--------|----------------|
+ | `UseAntialiasing` | Reduces jagged edges on vector graphics | Always enable
+ for high‑quality output | | `TextOptions.UseHinting` | Sharpens glyph edges
+ | Important for small font sizes | | `FontOptions.WebFontStyle` | Choose'
+ - name: 3. Performing the conversion
+ text: The `ImageConverter` overload you used writes a single PNG file. If you
+ need multiple pages (e.g., a multi‑page HTML document), use the overload that
+ returns a collection of images.
+ - name: a. Missing fonts
+ text: If the HTML references a custom web font that isn’t installed on the server,
+ the rendered text falls back to a default font, which may affect layout.
+ - name: b. Large pages and memory consumption
+ text: Rendering a very tall page can consume a lot of RAM.
+ - name: c. Transparent backgrounds
+ text: PNG supports transparency, but the default background is white.
+ type: HowTo
+tags:
+- Aspose.HTML
+- C#
+- image rendering
+- HTML conversion
+title: 使用 Aspose.HTML 在 C# 中從 HTML 產生 PNG
+url: /zh-hant/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/
+---
+
+{{< blocks/products/pf/main-wrap-class >}}
+{{< blocks/products/pf/main-container >}}
+{{< blocks/products/pf/tutorial-page-section >}}
+
+# 使用 Aspose.HTML 在 C# 中從 HTML 建立 PNG
+
+如果您需要在 .NET 應用程式中 **從 HTML 建立 PNG**，本指南將帶您完整了解整個流程。您將看到如何僅透過幾行 C# 程式碼 **將 HTML 轉換為 PNG**，使用 Aspose.HTML 強大的渲染引擎。
+
+將 HTML 渲染為影像是產生縮圖、電子郵件預覽或必須嵌入 PDF 的報表時的常見需求。接下來的章節中，您將學習確切步驟、查看完整可執行範例，並了解每個設定的意義。
+
+## 您將學習到
+
+- 如何從字串或檔案建立 `HtmlDocument`。
+- 如何設定 `ImageRenderingOptions` 以提升品質。
+- 如何 **將 HTML 轉換為 PNG** 並將結果儲存至磁碟。
+- 處理字型、大型頁面與自訂輸出路徑的技巧。
+
+**先決條件**
+- .NET 6.0 SDK（或更新版本）已安裝。
+- 有效的 Aspose.HTML for .NET 授權（或臨時評估金鑰）。
+- 具備 C# 及 Visual Studio 或任何相容 .NET 的 IDE 基本知識。
+
+---
+
+## 使用 Aspose.HTML 建立 PNG 從 HTML
+
+第一步是設定環境並參考所需的 Aspose.HTML 命名空間。
+
+```csharp
+using System;
+using Aspose.Html;
+using Aspose.Html.Rendering.Image;
+using Aspose.Html.Drawing;
+using Aspose.Html.Converters;
+
+namespace HtmlToPngDemo
+{
+ class Program
+ {
+ static void Main()
+ {
+ // 1️⃣ Build the HTML document from a raw string.
+ var html = "Bold text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // 2️⃣ Configure rendering options for best visual fidelity. + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, // Smooths edges of drawn shapes + TextOptions = { UseHinting = true }, // Improves glyph clarity + FontOptions = { WebFontStyle = WebFontStyle.Normal } // Uses standard web‑font style + }; + + // 3️⃣ Convert the HTML document to a PNG file. + string outputPath = @"output.png"; + ImageConverter.ConvertHtmlToImage(document, outputPath, renderOptions); + + Console.WriteLine($"PNG image created at: {outputPath}"); + } + } +} +``` + +### 為什麼這樣做有效 + +- **`HtmlDocument.Open`** 會將 HTML 字串解析成 Aspose.HTML 能夠渲染的 DOM。 +- **`ImageRenderingOptions`** 讓您控制抗鋸齒、文字 hinting 與字型處理，這在 **將 HTML 渲染為影像** 時避免文字模糊是必須的。 +- **`ImageConverter.ConvertHtmlToImage`** 承擔主要工作：將 DOM 光柵化至位圖並寫入 PNG 檔案。 + +執行程式後會產生 `output.png`，其中包含與 HTML 原始碼中定義完全相同的粗體段落。 + +--- + +## 逐步將 HTML 轉換為 PNG + +以下提供更詳細的每個階段說明。了解每行程式碼的目的，可協助您在處理較大或較複雜的頁面時進行調整。 + +### 1. 準備 HTML 來源 + +您可以從字串（如範例所示）、本機檔案或遠端 URL 載入 HTML。 + +```csharp +// Load from a file +var document = new HtmlDocument(); +document.Open(@"C:\templates\invoice.html"); + +// Load from a URL (requires internet access) +document.Open("https://example.com/report.html"); +``` + +**提示：** 載入外部資源（CSS、圖片）時，請確保 `BaseUrl` 屬性指向正確的資料夾，以便正確解析相對連結。 + +### 2. 微調渲染選項 + +| 選項 | 效果 | 何時調整 | +|--------|--------|----------------| +| `UseAntialiasing` | 減少向量圖形的鋸齒邊緣 | 始終啟用以獲得高品質輸出 | +| `TextOptions.UseHinting` | 提升字形邊緣銳利度 | 對小字體尺寸尤為重要 | +| `FontOptions.WebFontStyle` | 選擇正常、斜體或傾斜的網路字型渲染方式 | 對於斜體字型使用 `WebFontStyle.Oblique` | +| `ResolutionX` / `ResolutionY` | 輸出影像的 DPI | 為列印品質的 PNG 提高解析度（例如 300 DPI） | + +提高 DPI 的範例： + +```csharp +renderOptions.ResolutionX = 300; +renderOptions.ResolutionY = 300; +``` + +### 3. 執行轉換 + +您使用的 `ImageConverter` 多載會寫入單一 PNG 檔案。若需要多頁（例如多頁 HTML 文件），請使用回傳影像集合的多載。 + +```csharp +ImageConverter.ConvertHtmlToImages(document, "output_folder", renderOptions); +``` + +每一頁會產生 `output_folder/page_0.png`、`page_1.png` 等檔案。 + +--- + +## 將 HTML 渲染為影像 – 處理常見問題 + +### a. 缺少字型 + +如果 HTML 參考了未安裝在伺服器上的自訂網路字型，渲染出的文字會退回預設字型，可能影響版面配置。 + +**解決方案：** 使用 CSS 中的 `@font-face` 規則嵌入字型，或透過 `FontOptions` 提供本機字型資料夾。 + +```csharp +renderOptions.FontOptions.FontFolder = @"C:\fonts"; +``` + +### b. 大型頁面與記憶體消耗 + +渲染非常長的頁面可能會消耗大量記憶體。 + +**解決方案：** 設定最大高度或在轉換前將文件切分為多個區段。 + +```csharp +renderOptions.PageHeight = 2000; // pixels +``` + +### c. 透明背景 + +PNG 支援透明度，但預設背景為白色。 + +**解決方案：** 將背景顏色改為透明。 + +```csharp +renderOptions.BackgroundColor = System.Drawing.Color.Transparent; +``` + +--- + +## 如何將 HTML 渲染為影像 – 完整範例回顧 + +將所有步驟整合起來，以下是一段適合正式環境使用的程式碼，涵蓋最常見的需求： + +```csharp +using System; +using Aspose.Html; +using Aspose.Html.Rendering.Image; +using Aspose.Html.Drawing; +using Aspose.Html.Converters; + +namespace HtmlToPngDemo +{ + class Program + { + static void Main() + { + // Load HTML (string, file, or URL) + string html = "" + + "Bold blue text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // Configure rendering for high quality and transparency + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, + TextOptions = { UseHinting = true }, + FontOptions = { WebFontStyle = WebFontStyle.Normal, FontFolder = @"C:\fonts" }, + BackgroundColor = System.Drawing.Color.Transparent, + ResolutionX = 150, + ResolutionY = 150 + }; + + // Convert and save + string outPath = @"C:\temp\html_snapshot.png"; + ImageConverter.ConvertHtmlToImage(document, outPath, renderOptions); + + Console.WriteLine($"Image saved to {outPath}"); + } + } +} +``` + +**預期輸出：** 一個 `html_snapshot.png` 檔案，包含在透明畫布上的粗體藍色段落。影像將具備抗鋸齒效果，文字因 hinting 而清晰銳利。 + +--- + +## 結論 + +您現在已掌握如何使用 Aspose.HTML 在 C# 中 **從 HTML 建立 PNG**。透過建立 `HtmlDocument`、設定 `ImageRenderingOptions`，再呼叫 `ImageConverter.ConvertHtmlToImage`，即可可靠地 **將 HTML 轉換為 PNG** 並 **將 HTML 渲染為影像**，滿足各種自動化情境的需求。 + +接下來您可以探索： + +- 為動態網頁產生縮圖。 +- 使用 Aspose.PDF 將 PNG 嵌入 PDF。 +- 透過更改檔案副檔名，使用相同方法產生 JPEG 或 BMP。 + +歡迎自行嘗試 DPI、背景顏色與多頁渲染，以符合專案的精確需求。祝開發愉快！ + +## 接下來該學什麼？ + +以下教學與本指南所示技術緊密相關，能進一步擴充您的能力。每篇資源皆提供完整可執行的程式碼範例與逐步說明，協助您掌握更多 API 功能，並在專案中探索其他實作方式。 + +- [Render HTML as PNG in .NET with Aspose.HTML](/html/english/net/rendering-html-documents/render-html-as-png/) +- [How to Render HTML as PNG – Complete C# Guide](/html/english/net/rendering-html-documents/how-to-render-html-as-png-complete-c-guide/) +- [Create PNG from HTML – Full C# Rendering Guide](/html/english/net/rendering-html-documents/create-png-from-html-full-c-rendering-guide/) + +{{< /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 3d146ada27..962f63ecdd 100644 --- a/html/hongkong/net/html-extensions-and-conversions/_index.md +++ b/html/hongkong/net/html-extensions-and-conversions/_index.md @@ -71,7 +71,9 @@ Aspose.HTML for .NET 不只是一個函式庫；它還是一個函式庫。它 使用 Aspose.HTML for .NET 建立帶樣式文字的 HTML 文件，並將其匯出為 PDF 的完整步驟指南。 ### [使用 Aspose.HTML 將 HTML 儲存為 ZIP – 完整 C# 教學](./save-html-as-zip-complete-c-tutorial/) 使用 Aspose.HTML for .NET 將 HTML 文件壓縮為 ZIP 檔案，提供完整的 C# 範例與步驟說明。 -### [在 C# 中將 HTML 儲存為 ZIP – 完整的記憶體內示例](./save-html-to-zip-in-c-complete-in-memory-example/) +### [在 C# 中將 HTML 儲存為 ZIP – 完整步驟指南](./save-html-as-zip-in-c-step-by-step-guide/) +使用 Aspose.HTML for .NET 在 C# 中將 HTML 壓縮為 ZIP，提供完整的步驟說明與範例。 +### [在 C# 中將 HTML 儲存為 ZIP – 完整記憶體內示例](./save-html-to-zip-in-c-complete-in-memory-example/) 示範如何在 C# 中使用 Aspose.HTML 將 HTML 內容直接壓縮成 ZIP 檔案，全部在記憶體中完成。 ## 結論 diff --git a/html/hongkong/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md b/html/hongkong/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..d380591dfe --- /dev/null +++ b/html/hongkong/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md @@ -0,0 +1,317 @@ +--- +category: general +date: 2026-08-12 +description: 使用 Aspose.HTML 將 HTML 儲存為 ZIP。學習載入 HTML 字串、建立自訂資源處理程式，並高效產生 ZIP 壓縮檔。 +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save html as zip +- load html string +- custom resource handler +language: zh-hant +lastmod: 2026-08-12 +og_description: 使用 Aspose.HTML 在 C# 中將 HTML 保存為 ZIP。本教程展示如何載入 HTML 字串、建立自訂資源處理程式，並在幾個步驟內產生 + ZIP 壓縮檔。 +og_image_alt: Diagram showing save html as zip process with custom resource handler +og_title: 使用 Aspose.HTML 將 HTML 儲存為 ZIP – 完整 C# 指南 +schemas: +- author: Aspose + dateModified: '2026-08-12' + description: Save HTML as ZIP using Aspose.HTML. Learn to load HTML string, create + a custom resource handler, and generate a ZIP archive efficiently. + headline: Save HTML as ZIP in C# – step‑by‑step guide + type: TechArticle +tags: +- Aspose.HTML +- C# +- ZIP archive +title: 在 C# 中將 HTML 儲存為 ZIP – 步驟教學 +url: /zh-hant/net/html-extensions-and-conversions/save-html-as-zip-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 儲存為 ZIP – 步驟指南 + +如果您需要在 .NET 應用程式中 **將 HTML 儲存為 ZIP**，本指南將展示完整的工作流程。您將學習如何 **載入 HTML 字串**、實作 **自訂資源處理程式**，以及在不寫入中間檔案到磁碟的情況下產生 ZIP 壓縮檔。 + +此方法使用 Aspose.HTML 5.x，提供高效能的渲染引擎與彈性的儲存選項。完成本教學後，您將擁有可重複使用的處理程式，可整合至 Web 服務、背景工作或桌面工具中。 + +## 您將建立的內容 + +最終程式碼會建立一個基於 `MemoryStream` 的 ZIP 檔案，內含 HTML 文件以及所有參考的資源（圖片、CSS、字型）。ZIP 檔案會寫入目標資料夾，但您也可以將目的地改為 HTTP API 的回應串流。 + +## 前置條件 + +- .NET 6.0 或更新版本（範例目標為 .NET 6） +- Aspose.HTML for .NET（NuGet 套件 `Aspose.HTML`） +- 基本了解 C# 非同步模式（可選，但有助於理解） + +> **專業提示：** 在開始之前，使用 `dotnet add package Aspose.HTML` 安裝套件。 + +## 步驟 1：定義自訂資源處理程式 + +**自訂資源處理程式** 會攔截 HTML 渲染器發出的每一個外部資源請求。透過回傳串流，您可以控制資源資料的儲存位置。此範例將所有內容儲存於記憶體中，非常適合即時建立 ZIP 壓縮檔。 + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +///Hello, world!
+
+
+";
+
+// Create a new document instance.
+HtmlDocument document = new HtmlDocument();
+
+// Load the HTML markup.
+document.Open(htmlContent);
+```
+
+**此步驟的重要性：**
+**載入 HTML 字串** 的功能在 HTML 動態產生（例如來自模板引擎）或從 API 取得時非常有用。它避免了檔案系統的相依，亦可在受限環境中運作。
+
+## 步驟 3：設定儲存選項以使用處理程式
+
+Aspose.HTML 的 `HtmlSaveOptions` 讓您指定輸出的儲存機制。將自訂處理程式指派給 `OutputStorage` 屬性，並設定 `Compress` 旗標以產生 ZIP 壓縮檔。
+
+```csharp
+// Instantiate the custom handler.
+var resourceHandler = new InMemoryResourceHandler();
+
+// Prepare save options.
+HtmlSaveOptions saveOptions = new HtmlSaveOptions
+{
+ // Use the handler for all external resources.
+ OutputStorage = resourceHandler,
+
+ // Enable ZIP compression.
+ Compress = true
+};
+```
+
+**此步驟的重要性：**
+`Compress = true` 告訴 Aspose.HTML 將 HTML 檔案與所有收集的資源打包成單一 ZIP 檔案。`OutputStorage` 確保資源被捕獲於記憶體中，而非寫入暫存位置。
+
+## 步驟 4：將文件儲存為 ZIP 壓縮檔
+
+現在呼叫 `HtmlDocument.Save`，傳入目標路徑與先前設定的選項。儲存完成後，ZIP 檔案會包含 `index.html` 以及處理程式捕獲的所有資源。
+
+```csharp
+// Define the output path (you can change this to a response stream for web APIs).
+string outputPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+
+// Save the document; Aspose.HTML creates the ZIP automatically.
+document.Save(outputPath, saveOptions);
+
+// Optional: Verify the resources that were stored.
+foreach (var entry in resourceHandler.Resources)
+{
+ Console.WriteLine($"Resource: {entry.Key}, Size: {entry.Value.Length} bytes");
+}
+```
+
+**預期結果：**
+執行程式會在目前目錄產生 `output.zip`。解壓縮後會看到：
+
+```
+index.html
+styles.css
+logo.png
+```
+
+每個檔案皆符合標記中的引用，且 `index.html` 內的 HTML 會指向已打包的資源。
+
+## 步驟 5：為真實資源資料調整處理程式（進階）
+
+上述基本處理程式會產生空的串流。實務上通常需要寫入實際內容（例如 `styles.css` 或 `logo.png` 的位元組）。可擴充 `HandleResource`，從資料庫、雲端儲存桶或嵌入式資源取得資料。
+
+```csharp
+public override Stream HandleResource(ResourceInfo info)
+{
+ // Example: Load resource from an embedded folder.
+ string resourcePath = Path.Combine("EmbeddedResources", info.Path);
+ byte[] data = File.ReadAllBytes(resourcePath);
+
+ // Write data into a memory stream.
+ var stream = new MemoryStream(data);
+ _resources[info.Path] = stream;
+
+ // Return the populated stream.
+ return stream;
+}
+```
+
+**此變化的重要性：**
+提供真實內容可確保 ZIP 壓縮檔在瀏覽器開啟時可正常運作。處理程式亦可在寫入串流前套用轉換（例如壓縮 CSS）。
+
+## 步驟 6：在 Web API 中使用 ZIP 壓縮檔（可選）
+
+若透過 ASP.NET Core 將功能公開，可將 ZIP 檔案作為檔案結果回傳：
+
+```csharp
+[HttpGet("download")]
+public IActionResult DownloadZip()
+{
+ // Reuse the same logic from steps 1‑4.
+ // ...
+
+ // Read the generated ZIP into a byte array.
+ byte[] zipBytes = System.IO.File.ReadAllBytes(outputPath);
+
+ // Return the file with the appropriate content type.
+ return File(zipBytes, "application/zip", "document.zip");
+}
+```
+
+**此步驟的重要性：**
+客戶端可直接下載已打包的 HTML，無需處理伺服器上的暫存檔案。此方法亦適用於磁碟存取受限的無伺服器函式。
+
+## 常見陷阱與避免方法
+
+| Pitfall | Reason | Fix |
+|---------|--------|-----|
+| ZIP 中的空資源 | 處理程式回傳全新的 `MemoryStream`，但未寫入資料 | 在回傳前以實際位元組填充串流 |
+| 缺少 `index.html` 條目 | `Compress` 旗標未設定或未指派 `OutputStorage` | 確保 `saveOptions.Compress = true` 且 `saveOptions.OutputStorage = handler` |
+| 大型 HTML 造成記憶體壓力 | 所有資源都保留在記憶體中 | 改用寫入暫存資料夾的 `FileStorage` 實作 |
+| 解壓後相對 URL 失效 | 資源以未儲存的絕對 URL 參照 | 在處理程式內或後處理時將 URL 重寫為相對路徑 |
+
+## 完整、可執行範例
+
+```csharp
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Saving;
+
+class InMemoryResourceHandler : ResourceHandler
+{
+ private readonly DictionaryHello, world!
+
+
+ ";
+
+ HtmlDocument doc = new HtmlDocument();
+ doc.Open(html);
+
+ // Step 1 & 3: Create handler and configure save options.
+ var handler = new InMemoryResourceHandler();
+ HtmlSaveOptions options = new HtmlSaveOptions
+ {
+ OutputStorage = handler,
+ Compress = true
+ };
+
+ // Step 4: Save as ZIP.
+ string zipPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+ doc.Save(zipPath, options);
+ Console.WriteLine($"ZIP file created at: {zipPath}");
+
+ // Optional verification.
+ foreach (var kvp in handler.Resources)
+ {
+ Console.WriteLine($"Resource {kvp.Key} captured, length {kvp.Value.Length} bytes");
+ }
+ }
+}
+```
+
+執行程式會在可執行檔旁產生 `output.zip`。解壓縮後會看到 `index.html`、`styles.css` 與 `logo.png`（此最小範例中的佔位檔案為空）。
+
+## 結論
+
+您現在已掌握使用 Aspose.HTML 在 C# 中 **將 HTML 儲存為 ZIP** 的可靠方法。本教學涵蓋了載入 HTML 字串、實作 **自訂資源處理程式**、設定儲存選項，以及產生可供分發或下載的 ZIP 壓縮檔。
+
+接下來您可以：
+
+- 用真實內容取代佔位串流（例如從資料庫讀取）
+- 針對超大型文件改用基於檔案的儲存處理程式
+- 將此邏輯整合至 ASP.NET Core 端點，以即時下載
+- 探索 Aspose.HTML 的其他功能，如 PDF 轉換或影像渲染
+
+## 接下來您可以學習什麼？
+
+以下教學涵蓋與本指南密切相關的主題，並在此基礎上延伸技術。每個資源皆提供完整可執行的程式碼範例與逐步說明，協助您精通其他 API 功能，並在專案中探索替代實作方式。
+
+- [將 HTML 儲存為 ZIP – 完整 C# 教學](/html/english/net/html-extensions-and-conversions/save-html-as-zip-complete-c-tutorial/)
+- [如何在 C# 中儲存 HTML – 使用自訂資源處理程式的完整指南](/html/english/net/working-with-html-documents/how-to-save-html-in-c-complete-guide-using-a-custom-resource/)
+- [從字串建立 HTML（C#） – 自訂資源處理程式指南](/html/english/net/html-document-manipulation/create-html-from-string-in-c-custom-resource-handler-guide/)
+
+{{< /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/generate-jpg-and-png-images/_index.md b/html/hungarian/net/generate-jpg-and-png-images/_index.md
index dc2c2b0acd..aa8e36072a 100644
--- a/html/hungarian/net/generate-jpg-and-png-images/_index.md
+++ b/html/hungarian/net/generate-jpg-and-png-images/_index.md
@@ -45,6 +45,8 @@ Tanulja meg az Aspose.HTML for .NET használatát HTML-dokumentumok kezeléséhe
Ismerje meg, hogyan állíthatja be az antialiasingot a DOCX dokumentumok PNG vagy JPG képekké konvertálásakor az Aspose.HTML for .NET használatával.
### [docx konvertálása png-re – zip archívum létrehozása C# oktatóanyag](./convert-docx-to-png-create-zip-archive-c-tutorial/)
Ismerje meg, hogyan konvertálhat docx fájlokat png képekké, majd csomagolhatja őket zip archívumba C#-ban az Aspose.HTML segítségével.
+### [PNG létrehozása HTML-ből C#-ban az Aspose.HTML használatával](./create-png-from-html-in-c-using-aspose-html/)
+Ismerje meg, hogyan konvertálhat HTML-t PNG képpé C#-ban az Aspose.HTML segítségével.
## Következtetés
diff --git a/html/hungarian/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md b/html/hungarian/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
new file mode 100644
index 0000000000..d5df0b5673
--- /dev/null
+++ b/html/hungarian/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
@@ -0,0 +1,292 @@
+---
+category: general
+date: 2026-08-12
+description: Készíts PNG-t HTML-ből C#-ban az Aspose.HTML segítségével. Tanulja meg,
+ hogyan konvertálhat HTML-t PNG-re, és hogyan renderelhet HTML-t képként néhány sor
+ kóddal.
+draft: false
+images:
+- PLACEHOLDER_URL/og-image.png
+keywords:
+- create png from html
+- convert html to png
+- render html as image
+- how to render html to image
+language: hu
+lastmod: 2026-08-12
+og_description: PNG létrehozása HTML‑ből C#‑ban az Aspose.HTML használatával. Ez az
+ útmutató bemutatja, hogyan lehet gyorsan HTML‑t képként renderelni, lefedve a konverziós
+ lehetőségeket, a kód beállítását és a hibakeresést.
+og_image_alt: Screenshot of a C# program converting HTML to a PNG image
+og_title: PNG készítése HTML‑ből C#‑ban – lépésről‑lépésre útmutató
+schemas:
+- author: Aspose
+ dateModified: '2026-08-12'
+ description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ headline: Create PNG from HTML in C# using Aspose.HTML
+ type: TechArticle
+- description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ name: Create PNG from HTML in C# using Aspose.HTML
+ steps:
+ - name: Why this works
+ text: '- **`HtmlDocument.Open`** parses the HTML string into a DOM that Aspose.HTML
+ can render. - **`ImageRenderingOptions`** lets you control anti‑aliasing, text
+ hinting, and font handling, which are essential when you **render HTML as image**
+ to avoid blurry text. - **`ImageConverter.ConvertHtmlToImage`*'
+ - name: 1. Preparing the HTML source
+ text: You can load HTML from a string (as shown), a local file, or a remote URL.
+ - name: 2. Fine‑tuning rendering options
+ text: '| Option | Effect | When to adjust | |--------|--------|----------------|
+ | `UseAntialiasing` | Reduces jagged edges on vector graphics | Always enable
+ for high‑quality output | | `TextOptions.UseHinting` | Sharpens glyph edges
+ | Important for small font sizes | | `FontOptions.WebFontStyle` | Choose'
+ - name: 3. Performing the conversion
+ text: The `ImageConverter` overload you used writes a single PNG file. If you
+ need multiple pages (e.g., a multi‑page HTML document), use the overload that
+ returns a collection of images.
+ - name: a. Missing fonts
+ text: If the HTML references a custom web font that isn’t installed on the server,
+ the rendered text falls back to a default font, which may affect layout.
+ - name: b. Large pages and memory consumption
+ text: Rendering a very tall page can consume a lot of RAM.
+ - name: c. Transparent backgrounds
+ text: PNG supports transparency, but the default background is white.
+ type: HowTo
+tags:
+- Aspose.HTML
+- C#
+- image rendering
+- HTML conversion
+title: PNG létrehozása HTML-ből C#-ban az Aspose.HTML segítségével
+url: /hu/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/
+---
+
+{{< blocks/products/pf/main-wrap-class >}}
+{{< blocks/products/pf/main-container >}}
+{{< blocks/products/pf/tutorial-page-section >}}
+
+# PNG létrehozása HTML‑ből C#‑ban az Aspose.HTML segítségével
+
+Ha **PNG‑t szeretne létrehozni HTML‑ből** egy .NET alkalmazásban, ez az útmutató végigvezeti a teljes folyamaton. Megmutatjuk, hogyan **konvertálhat HTML‑t PNG‑re** néhány C# sorral, az Aspose.HTML erőteljes renderelő motorjával.
+
+A HTML képként való renderelése gyakori igény, amikor bélyegképeket, e‑mail előnézeteket vagy jelentéseket kell PDF‑ekbe beágyazni. A következő szakaszokban megismeri a pontos lépéseket, egy teljes működő példát lát, és megérti, miért fontos minden beállítás.
+
+## Mit fog megtanulni
+
+- Hogyan építsen fel egy `HtmlDocument`‑et karakterláncból vagy fájlból.
+- Hogyan konfigurálja a `ImageRenderingOptions`‑t a minőség javításához.
+- Hogyan **konvertálja a HTML‑t PNG‑re** és mentse az eredményt lemezre.
+- Tippek betűtípusok, nagy oldalak és egyedi kimeneti útvonalak kezeléséhez.
+
+**Előfeltételek**
+- .NET 6.0 SDK (vagy újabb) telepítve.
+- Érvényes Aspose.HTML for .NET licenc (vagy ideiglenes értékelő kulcs).
+- Alapvető ismeretek C#‑ról és a Visual Studio‑ról vagy bármely .NET‑kompatibilis IDE‑ről.
+
+---
+
+## PNG létrehozása HTML‑ből az Aspose.HTML‑el
+
+Az első lépés a környezet beállítása és a szükséges Aspose.HTML névterek hivatkozása.
+
+```csharp
+using System;
+using Aspose.Html;
+using Aspose.Html.Rendering.Image;
+using Aspose.Html.Drawing;
+using Aspose.Html.Converters;
+
+namespace HtmlToPngDemo
+{
+ class Program
+ {
+ static void Main()
+ {
+ // 1️⃣ Build the HTML document from a raw string.
+ var html = "Bold text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // 2️⃣ Configure rendering options for best visual fidelity. + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, // Smooths edges of drawn shapes + TextOptions = { UseHinting = true }, // Improves glyph clarity + FontOptions = { WebFontStyle = WebFontStyle.Normal } // Uses standard web‑font style + }; + + // 3️⃣ Convert the HTML document to a PNG file. + string outputPath = @"output.png"; + ImageConverter.ConvertHtmlToImage(document, outputPath, renderOptions); + + Console.WriteLine($"PNG image created at: {outputPath}"); + } + } +} +``` + +### Miért működik ez + +- **`HtmlDocument.Open`** beolvassa a HTML karakterláncot egy DOM‑ba, amelyet az Aspose.HTML renderelni tud. +- **`ImageRenderingOptions`** lehetővé teszi az anti‑aliasing, a szöveg‑hinting és a betűtípus‑kezelés szabályozását, ami elengedhetetlen a **HTML képként való rendereléséhez**, hogy elkerüljük a elmosódott szöveget. +- **`ImageConverter.ConvertHtmlToImage`** végzi a nehéz munkát: rasterizálja a DOM‑ot egy bitmapre, és kiírja a PNG fájlt. + +A program futtatása egy `output.png` fájlt hoz létre, amely a HTML forrásban definiált félkövér bekezdést tartalmazza. + +--- + +## HTML‑t PNG‑re konvertálása lépésről lépésre + +Az alábbiakban részletesen bemutatjuk az egyes fázisokat. A sorok céljának megértése segít a kód nagyobb vagy összetettebb oldalakhoz való adaptálásában. + +### 1. A HTML forrás előkészítése + +HTML‑t betölthet karakterláncból (ahogy itt látható), helyi fájlból vagy távoli URL‑ről. + +```csharp +// Load from a file +var document = new HtmlDocument(); +document.Open(@"C:\templates\invoice.html"); + +// Load from a URL (requires internet access) +document.Open("https://example.com/report.html"); +``` + +**Tipp:** Külső erőforrások (CSS, képek) betöltésekor győződjön meg róla, hogy a `BaseUrl` tulajdonság a megfelelő mappára mutat, hogy a relatív hivatkozások helyesen feloldódjanak. + +### 2. Renderelési beállítások finomhangolása + +| Beállítás | Hatás | Mikor érdemes módosítani | +|-----------|-------|--------------------------| +| `UseAntialiasing` | Csökkenti a vektoros grafikák lépcsőzetes széleit | Mindig engedélyezze a magas minőségű kimenethez | +| `TextOptions.UseHinting` | Élesíti a glifek széleit | Fontos kis betűméretek esetén | +| `FontOptions.WebFontStyle` | Normál, dőlt vagy oblik web‑font renderelés | Használja a `WebFontStyle.Oblique`‑t ferde betűkhez | +| `ResolutionX` / `ResolutionY` | A kimeneti kép DPI‑je | Növelje nyomtatásra kész PNG‑khez (pl. 300 DPI) | + +Példa a DPI növelésére: + +```csharp +renderOptions.ResolutionX = 300; +renderOptions.ResolutionY = 300; +``` + +### 3. A konverzió végrehajtása + +Az Ön által használt `ImageConverter` túlterhelés egyetlen PNG fájlt ír ki. Ha több oldalt kell kezelni (pl. többoldalas HTML dokumentum), használja azt a túlterhelést, amely képek gyűjteményét adja vissza. + +```csharp +ImageConverter.ConvertHtmlToImages(document, "output_folder", renderOptions); +``` + +Minden oldal `output_folder/page_0.png`, `page_1.png`, stb. néven jön létre. + +--- + +## HTML renderelése képként – gyakori buktatók kezelése + +### a. Hiányzó betűtípusok + +Ha a HTML egy olyan egyedi web‑fontot hivatkozik, amely nincs telepítve a szerveren, a renderelt szöveg alapértelmezett betűtípusra vált, ami befolyásolhatja a megjelenést. + +**Megoldás:** Ágyazza be a betűtípust egy `@font-face` szabállyal a CSS‑ben, vagy adjon meg egy helyi betűtípus‑mappát a `FontOptions`‑on keresztül. + +```csharp +renderOptions.FontOptions.FontFolder = @"C:\fonts"; +``` + +### b. Nagy oldalak és memóriahasználat + +Egy nagyon magas oldal sok RAM‑ot fogyaszthat. + +**Megoldás:** Állítson be maximális magasságot, vagy bontsa a dokumentumot szakaszokra a konverzió előtt. + +```csharp +renderOptions.PageHeight = 2000; // pixels +``` + +### c. Átlátszó háttér + +A PNG támogatja az átlátszóságot, de az alapértelmezett háttér fehér. + +**Megoldás:** Állítsa a háttérszínt átlátszóra. + +```csharp +renderOptions.BackgroundColor = System.Drawing.Color.Transparent; +``` + +--- + +## Hogyan rendereljük a HTML‑t képként – teljes példa összefoglaló + +Mindent egy helyen, itt egy termelés‑kész kódrészlet, amely lefedi a leggyakoribb igényeket: + +```csharp +using System; +using Aspose.Html; +using Aspose.Html.Rendering.Image; +using Aspose.Html.Drawing; +using Aspose.Html.Converters; + +namespace HtmlToPngDemo +{ + class Program + { + static void Main() + { + // Load HTML (string, file, or URL) + string html = "" + + "Bold blue text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // Configure rendering for high quality and transparency + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, + TextOptions = { UseHinting = true }, + FontOptions = { WebFontStyle = WebFontStyle.Normal, FontFolder = @"C:\fonts" }, + BackgroundColor = System.Drawing.Color.Transparent, + ResolutionX = 150, + ResolutionY = 150 + }; + + // Convert and save + string outPath = @"C:\temp\html_snapshot.png"; + ImageConverter.ConvertHtmlToImage(document, outPath, renderOptions); + + Console.WriteLine($"Image saved to {outPath}"); + } + } +} +``` + +**Várható kimenet:** Egy `html_snapshot.png` fájl, amely egy félkövér, kék bekezdést tartalmaz átlátszó vásznon. A kép anti‑aliasing‑os, a szöveg pedig a hintingnek köszönhetően éles. + +--- + +## Összegzés + +Most már tudja, hogyan **hozzon létre PNG‑t HTML‑ből** C#‑ban az Aspose.HTML segítségével. Egy `HtmlDocument` felépítésével, a `ImageRenderingOptions` konfigurálásával és az `ImageConverter.ConvertHtmlToImage` meghívásával megbízhatóan **konvertálhat HTML‑t PNG‑re** és **renderelhet HTML‑t képként** bármilyen automatizálási szcenárióhoz. + +Innen tovább felfedezheti: + +- Dinamikus weboldalak bélyegképének generálása. +- A PNG beágyazása PDF‑ekbe az Aspose.PDF‑el. +- Ugyanazon megközelítés használata JPEG vagy BMP előállításához a fájlkiterjesztés módosításával. + +Kísérletezzen a DPI‑val, háttérszínekkel és többoldalas rendereléssel, hogy pontosan megfeleljen projektje igényeinek. Boldog kódolást! + +## Mit érdemes még megtanulni? + +A következő oktatóanyagok szorosan kapcsolódó témákat fednek le, amelyek a jelen útmutatóban bemutatott technikákra épülnek. Minden forrás teljes működő kódrészleteket és lépésről‑lépésre magyarázatokat tartalmaz, hogy segítsen elsajátítani további API‑funkciókat és alternatív megvalósítási módokat saját projektjeiben. + +- [Render HTML as PNG in .NET with Aspose.HTML](/html/english/net/rendering-html-documents/render-html-as-png/) +- [How to Render HTML as PNG – Complete C# Guide](/html/english/net/rendering-html-documents/how-to-render-html-as-png-complete-c-guide/) +- [Create PNG from HTML – Full C# Rendering Guide](/html/english/net/rendering-html-documents/create-png-from-html-full-c-rendering-guide/) + +{{< /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 53dd8b575e..657b2c56d0 100644 --- a/html/hungarian/net/html-extensions-and-conversions/_index.md +++ b/html/hungarian/net/html-extensions-and-conversions/_index.md @@ -52,11 +52,9 @@ Az Aspose.HTML for .NET nem csak egy könyvtár; ez egy változás a webfejleszt ### [Konvertálja a HTML-t XPS-re .NET-ben az Aspose.HTML-lel](./convert-html-to-xps/) Fedezze fel az Aspose.HTML erejét .NET-hez: A HTML-t könnyedén konvertálja XPS-re. Előfeltételek, lépésenkénti útmutató és GYIK mellékelve. ### [HTML zip-elése C#-ban – HTML mentése zip-be](./how-to-zip-html-in-c-save-html-to-zip/) -Ismerje meg, hogyan csomagolhatja be a HTML-fájlokat zip-archívumba C#-ban az Aspose.HTML for .NET segítségével. +### [HTML mentése ZIP-be C#‑ban – lépésről‑lépésre útmutató](./save-html-as-zip-in-c-step-by-step-guide/) ### [HTML-dokumentum létrehozása formázott szöveggel és exportálása PDF-be – Teljes útmutató](./create-html-document-with-styled-text-and-export-to-pdf-full/) -Hozzon létre HTML-dokumentumot formázott szöveggel, majd exportálja PDF-be az Aspose.HTML for .NET segítségével. Lépésről lépésre útmutató. ### [PDF létrehozása HTML-ből – C# lépésről‑lépésre útmutató](./create-pdf-from-html-c-step-by-step-guide/) -Ismerje meg, hogyan hozhat létre PDF-et HTML-ből C#‑ban az Aspose.HTML for .NET segítségével, részletes lépésről‑lépésre útmutatóval. ### [HTML mentése ZIP-ként – Teljes C# oktatóanyag](./save-html-as-zip-complete-c-tutorial/) ### [HTML mentése ZIP-be C#‑ban – Teljes memória‑beli példa](./save-html-to-zip-in-c-complete-in-memory-example/) Mentse a HTML-t közvetlenül memóriában ZIP-archívumba az Aspose.HTML for .NET C#‑ban. diff --git a/html/hungarian/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md b/html/hungarian/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..f3a1a1972d --- /dev/null +++ b/html/hungarian/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md @@ -0,0 +1,322 @@ +--- +category: general +date: 2026-08-12 +description: HTML mentése ZIP-ként az Aspose.HTML használatával. Tanulja meg, hogyan + töltsön be HTML-karakterláncot, hozzon létre egy egyéni erőforráskezelőt, és generáljon + hatékonyan ZIP-archívumot. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save html as zip +- load html string +- custom resource handler +language: hu +lastmod: 2026-08-12 +og_description: HTML mentése ZIP-ként az Aspose.HTML használatával C#-ban. Ez az útmutató + bemutatja, hogyan töltsünk be egy HTML karakterláncot, hozzunk létre egy egyéni + erőforráskezelőt, és néhány lépésben generáljunk ZIP-archívumot. +og_image_alt: Diagram showing save html as zip process with custom resource handler +og_title: HTML mentése ZIP-ként az Aspose.HTML segítségével – teljes C# útmutató +schemas: +- author: Aspose + dateModified: '2026-08-12' + description: Save HTML as ZIP using Aspose.HTML. Learn to load HTML string, create + a custom resource handler, and generate a ZIP archive efficiently. + headline: Save HTML as ZIP in C# – step‑by‑step guide + type: TechArticle +tags: +- Aspose.HTML +- C# +- ZIP archive +title: HTML mentése ZIP-ként C#-ban – lépésről lépésre útmutató +url: /hu/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# HTML mentése ZIP‑ként C#‑ban – lépésről‑lépésre útmutató + +Ha **HTML-t ZIP‑ként kell menteni** egy .NET alkalmazásban, ez az útmutató bemutatja a teljes munkafolyamatot. Megtanulja, hogyan **töltsön be HTML karakterláncot**, hogyan valósítson meg egy **egyéni erőforrás kezelőt**, és hogyan állítson elő ZIP‑archívumot anélkül, hogy köztes fájlokat írna a lemezre. + +A megközelítés az Aspose.HTML 5.x‑et használja, amely nagy teljesítményű renderelő motorral és rugalmas mentési lehetőségekkel rendelkezik. A tutorial végére egy újrahasználható kezelővel rendelkezik, amely beépíthető webszolgáltatásokba, háttérfeladatokba vagy asztali eszközökbe. + +## Mit fog építeni + +A végső kód egy `MemoryStream`‑alapú ZIP-fájlt hoz létre, amely tartalmazza a HTML-dokumentumot és minden hivatkozott erőforrást (képek, CSS, betűkészletek). A ZIP-fájl egy célmappába kerül, de a célpontot megváltoztathatja egy válaszfolyamra HTTP API‑khoz. + +## Előfeltételek + +- .NET 6.0 vagy újabb (a minta a .NET 6‑ra céloz) +- Aspose.HTML for .NET (NuGet csomag `Aspose.HTML`) +- Alapvető ismeretek a C# aszinkron mintákról (opcionális, de hasznos) + +> **Pro tipp:** Telepítse a csomagot a `dotnet add package Aspose.HTML` paranccsal a kezdés előtt. + +## 1. lépés: Egyéni erőforrás kezelő definiálása + +Egy **egyéni erőforrás kezelő** elfogja a HTML renderelő által végzett minden külső erőforrás kérést. Egy adatfolyam visszaadásával szabályozhatja, hogy hol tárolódik az erőforrás adat. A példa mindent memóriában tárol, ami ideális a ZIP-archívum valós időben történő létrehozásához. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +///Hello, world!
+
+
+";
+
+// Create a new document instance.
+HtmlDocument document = new HtmlDocument();
+
+// Load the HTML markup.
+document.Open(htmlContent);
+```
+
+**Miért fontos ez a lépés:**
+A **load html string** képesség hasznos, ha a HTML dinamikusan generálódik (pl. egy sablonmotorból) vagy egy API‑ból érkezik. Elkerüli a fájlrendszer függőségeket, és működik elszigetelt környezetekben.
+
+## 3. lépés: Mentési beállítások konfigurálása a kezelő használatához
+
+Az Aspose.HTML `HtmlSaveOptions` lehetővé teszi a kimenet tárolási módjának megadását. Rendelje hozzá az egyéni kezelőt az `OutputStorage` tulajdonsághoz, és állítsa be a `Compress` jelzőt ZIP-archívum létrehozásához.
+
+```csharp
+// Instantiate the custom handler.
+var resourceHandler = new InMemoryResourceHandler();
+
+// Prepare save options.
+HtmlSaveOptions saveOptions = new HtmlSaveOptions
+{
+ // Use the handler for all external resources.
+ OutputStorage = resourceHandler,
+
+ // Enable ZIP compression.
+ Compress = true
+};
+```
+
+**Miért fontos ez a lépés:**
+A `Compress = true` azt mondja az Aspose.HTML‑nek, hogy a HTML-fájlt és az összegyűjtött erőforrásokat egyetlen ZIP-csomagba csomagolja. Az `OutputStorage` biztosítja, hogy az erőforrások memóriában legyenek rögzítve, ne ideiglenes helyekre íródjanak.
+
+## 4. lépés: Dokumentum mentése ZIP-archívumként
+
+Most hívja meg a `HtmlDocument.Save` metódust, megadva a célútvonalat és a konfigurált beállításokat. Mentés után a ZIP-fájl tartalmazza az `index.html`‑t és a kezelő által rögzített erőforrásokat.
+
+```csharp
+// Define the output path (you can change this to a response stream for web APIs).
+string outputPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+
+// Save the document; Aspose.HTML creates the ZIP automatically.
+document.Save(outputPath, saveOptions);
+
+// Optional: Verify the resources that were stored.
+foreach (var entry in resourceHandler.Resources)
+{
+ Console.WriteLine($"Resource: {entry.Key}, Size: {entry.Value.Length} bytes");
+}
+```
+
+**Várható eredmény:**
+A program futtatása létrehozza az `output.zip`‑t az aktuális könyvtárban. Az archívum kibontása a következőt mutatja:
+
+```
+index.html
+styles.css
+logo.png
+```
+
+Minden fájl megfelel a jelölőnyelvi hivatkozásoknak, és az `index.html`‑ben lévő HTML a csomagolt erőforrásokra mutat.
+
+## 5. lépés: A kezelő adaptálása valós erőforrás adatokhoz (haladó)
+
+A fenti alapkezelő üres adatfolyamokat hoz létre. Éles környezetben gyakran a tényleges tartalmat kell írni (pl. a `styles.css` vagy `logo.png` bájtjait). Bővítse a `HandleResource` metódust, hogy adatokat nyerjen egy adatbázisból, felhő tárolóból vagy beágyazott erőforrásból.
+
+```csharp
+public override Stream HandleResource(ResourceInfo info)
+{
+ // Example: Load resource from an embedded folder.
+ string resourcePath = Path.Combine("EmbeddedResources", info.Path);
+ byte[] data = File.ReadAllBytes(resourcePath);
+
+ // Write data into a memory stream.
+ var stream = new MemoryStream(data);
+ _resources[info.Path] = stream;
+
+ // Return the populated stream.
+ return stream;
+}
+```
+
+**Miért fontos ez a változat:**
+A valós tartalom biztosítja, hogy a ZIP-archívum működőképes legyen böngészőben megnyitva. A kezelő alkalmazhat átalakításokat (pl. CSS minifikálás) az adatfolyamba írás előtt.
+
+## 6. lépés: ZIP-archívum használata web API‑ban (opcionális)
+
+Ha a funkciót ASP.NET Core‑on keresztül teszi elérhetővé, adja vissza a ZIP-fájlt fájl eredményként:
+
+```csharp
+[HttpGet("download")]
+public IActionResult DownloadZip()
+{
+ // Reuse the same logic from steps 1‑4.
+ // ...
+
+ // Read the generated ZIP into a byte array.
+ byte[] zipBytes = System.IO.File.ReadAllBytes(outputPath);
+
+ // Return the file with the appropriate content type.
+ return File(zipBytes, "application/zip", "document.zip");
+}
+```
+
+**Miért fontos ez a lépés:**
+Az ügyfelek letölthetik a csomagolt HTML-t anélkül, hogy a szerveren ideiglenes fájlokkal kellene foglalkozniuk. A megközelítés serverless függvényeknél is működik, ahol a lemezhozzáférés korlátozott.
+
+## Gyakori buktatók és elkerülésük módjai
+
+| Buktató | Ok | Megoldás |
+|---------|----|----------|
+| Üres erőforrások a ZIP-ben | A kezelő friss `MemoryStream`‑et ad vissza adat írása nélkül | Töltse fel az adatfolyamot valós bájtokkal a visszaadás előtt |
+| Hiányzó `index.html` bejegyzés | `Compress` jelző nincs beállítva vagy az `OutputStorage` nincs hozzárendelve | Győződjön meg arról, hogy `saveOptions.Compress = true` és `saveOptions.OutputStorage = handler` |
+| Nagy HTML memória nyomást okoz | Minden erőforrás memóriában van tárolva | Váltson `FileStorage` implementációra, amely egy ideiglenes mappába ír |
+| Relatív URL-ek hibásak a kibontás után | Az erőforrások abszolút URL-ekkel vannak hivatkozva, amelyek nincsenek tárolva | Írja át az URL-eket relatív útvonalakra a kezelőben vagy a post‑processing során |
+
+## Teljes, futtatható példa
+
+```csharp
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Saving;
+
+class InMemoryResourceHandler : ResourceHandler
+{
+ private readonly DictionaryHello, world!
+
+
+ ";
+
+ HtmlDocument doc = new HtmlDocument();
+ doc.Open(html);
+
+ // Step 1 & 3: Create handler and configure save options.
+ var handler = new InMemoryResourceHandler();
+ HtmlSaveOptions options = new HtmlSaveOptions
+ {
+ OutputStorage = handler,
+ Compress = true
+ };
+
+ // Step 4: Save as ZIP.
+ string zipPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+ doc.Save(zipPath, options);
+ Console.WriteLine($"ZIP file created at: {zipPath}");
+
+ // Optional verification.
+ foreach (var kvp in handler.Resources)
+ {
+ Console.WriteLine($"Resource {kvp.Key} captured, length {kvp.Value.Length} bytes");
+ }
+ }
+}
+```
+
+A program futtatása létrehozza az `output.zip`‑t a futtatható fájl mellett. Az archívum kibontása megjeleníti az `index.html`, `styles.css` és `logo.png` fájlokat (ebben a minimális példában üres helykitöltők).
+
+## Következtetés
+
+Most már rendelkezik egy megbízható módszerrel a **HTML ZIP‑ként mentésére** az Aspose.HTML használatával C#‑ban. A tutorial bemutatta a HTML karakterlánc betöltését, egy **egyéni erőforrás kezelő** megvalósítását, a mentési beállítások konfigurálását és egy terjesztésre vagy letöltésre készen álló ZIP-archívum generálását.
+
+Innen tovább:
+
+- Cserélje le a helykitöltő adatfolyamokat valós tartalomra (pl. adatbázisból olvasva)
+- Váltson fájl‑alapú tároló kezelőre nagyon nagy dokumentumok esetén
+- Integrálja a logikát ASP.NET Core végpontokba igény szerinti letöltésekhez
+- Fedezze fel az Aspose.HTML további funkcióit, mint a PDF konverzió vagy képrenderelés
+
+Kísérletezzen különböző erőforrás forrásokkal és tömörítési beállításokkal, hogy a megoldást a teljesítmény- és méretigényeihez igazítsa. Boldog kódolást!
+
+## Mit érdemes következőként tanulni?
+
+A következő tutorialok szorosan kapcsolódó témákat fednek le, amelyek a jelen útmutatóban bemutatott technikákra épülnek. Minden forrás teljes, működő kódrészleteket tartalmaz lépésről‑lépésre magyarázatokkal, hogy segítsen elsajátítani további API‑funkciókat és alternatív megvalósítási megközelítéseket saját projektjeiben.
+
+- [HTML mentése ZIP‑ként – Teljes C# tutorial](/html/english/net/html-extensions-and-conversions/save-html-as-zip-complete-c-tutorial/)
+- [Hogyan mentse a HTML-t C#‑ban – Teljes útmutató egyedi erőforrás kezelő használatával](/html/english/net/working-with-html-documents/how-to-save-html-in-c-complete-guide-using-a-custom-resource/)
+- [HTML létrehozása karakterláncból C#‑ban – Egyéni erőforrás kezelő útmutató](/html/english/net/html-document-manipulation/create-html-from-string-in-c-custom-resource-handler-guide/)
+
+{{< /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/generate-jpg-and-png-images/_index.md b/html/indonesian/net/generate-jpg-and-png-images/_index.md
index 4e885ce325..bafa33139b 100644
--- a/html/indonesian/net/generate-jpg-and-png-images/_index.md
+++ b/html/indonesian/net/generate-jpg-and-png-images/_index.md
@@ -41,6 +41,8 @@ Mengintegrasikan Aspose.HTML untuk .NET ke dalam proyek .NET Anda tidak akan mer
Pelajari cara membuat halaman web dinamis menggunakan Aspose.HTML untuk .NET. Tutorial langkah demi langkah ini mencakup prasyarat, namespace, dan rendering HTML ke gambar.
### [Hasilkan Gambar PNG dengan ImageDevice di .NET dengan Aspose.HTML](./generate-png-images-by-imagedevice/)
Pelajari cara menggunakan Aspose.HTML untuk .NET guna memanipulasi dokumen HTML, mengonversi HTML menjadi gambar, dan banyak lagi. Tutorial langkah demi langkah dengan Tanya Jawab Umum.
+### [Buat PNG dari HTML di C# menggunakan Aspose.HTML](./create-png-from-html-in-c-using-aspose-html/)
+Pelajari cara mengonversi HTML menjadi gambar PNG menggunakan Aspose.HTML dengan C# dalam tutorial langkah demi langkah.
### [Cara Mengaktifkan Antialiasing Saat Mengonversi DOCX ke PNG/JPG](./how-to-enable-antialiasing-when-converting-docx-to-png-jpg/)
Pelajari cara mengaktifkan antialiasing untuk meningkatkan kualitas gambar PNG atau JPG saat mengonversi dokumen DOCX menggunakan Aspose.HTML.
### [Konversi DOCX ke PNG – Membuat Arsip ZIP dengan C# Tutorial](./convert-docx-to-png-create-zip-archive-c-tutorial/)
diff --git a/html/indonesian/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md b/html/indonesian/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
new file mode 100644
index 0000000000..f66ad34d87
--- /dev/null
+++ b/html/indonesian/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
@@ -0,0 +1,291 @@
+---
+category: general
+date: 2026-08-12
+description: Buat PNG dari HTML di C# dengan Aspose.HTML. Pelajari cara mengonversi
+ HTML ke PNG dan merender HTML sebagai gambar hanya dengan beberapa baris kode.
+draft: false
+images:
+- PLACEHOLDER_URL/og-image.png
+keywords:
+- create png from html
+- convert html to png
+- render html as image
+- how to render html to image
+language: id
+lastmod: 2026-08-12
+og_description: Buat PNG dari HTML di C# menggunakan Aspose.HTML. Panduan ini menunjukkan
+ cara merender HTML menjadi gambar dengan cepat, mencakup opsi konversi, pengaturan
+ kode, dan pemecahan masalah.
+og_image_alt: Screenshot of a C# program converting HTML to a PNG image
+og_title: Buat PNG dari HTML di C# – panduan langkah demi langkah
+schemas:
+- author: Aspose
+ dateModified: '2026-08-12'
+ description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ headline: Create PNG from HTML in C# using Aspose.HTML
+ type: TechArticle
+- description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ name: Create PNG from HTML in C# using Aspose.HTML
+ steps:
+ - name: Why this works
+ text: '- **`HtmlDocument.Open`** parses the HTML string into a DOM that Aspose.HTML
+ can render. - **`ImageRenderingOptions`** lets you control anti‑aliasing, text
+ hinting, and font handling, which are essential when you **render HTML as image**
+ to avoid blurry text. - **`ImageConverter.ConvertHtmlToImage`*'
+ - name: 1. Preparing the HTML source
+ text: You can load HTML from a string (as shown), a local file, or a remote URL.
+ - name: 2. Fine‑tuning rendering options
+ text: '| Option | Effect | When to adjust | |--------|--------|----------------|
+ | `UseAntialiasing` | Reduces jagged edges on vector graphics | Always enable
+ for high‑quality output | | `TextOptions.UseHinting` | Sharpens glyph edges
+ | Important for small font sizes | | `FontOptions.WebFontStyle` | Choose'
+ - name: 3. Performing the conversion
+ text: The `ImageConverter` overload you used writes a single PNG file. If you
+ need multiple pages (e.g., a multi‑page HTML document), use the overload that
+ returns a collection of images.
+ - name: a. Missing fonts
+ text: If the HTML references a custom web font that isn’t installed on the server,
+ the rendered text falls back to a default font, which may affect layout.
+ - name: b. Large pages and memory consumption
+ text: Rendering a very tall page can consume a lot of RAM.
+ - name: c. Transparent backgrounds
+ text: PNG supports transparency, but the default background is white.
+ type: HowTo
+tags:
+- Aspose.HTML
+- C#
+- image rendering
+- HTML conversion
+title: Buat PNG dari HTML di C# menggunakan Aspose.HTML
+url: /id/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/
+---
+
+{{< blocks/products/pf/main-wrap-class >}}
+{{< blocks/products/pf/main-container >}}
+{{< blocks/products/pf/tutorial-page-section >}}
+
+# Buat PNG dari HTML di C# menggunakan Aspose.HTML
+
+Jika Anda perlu **membuat PNG dari HTML** dalam aplikasi .NET, panduan ini akan memandu Anda melalui proses lengkap. Anda akan melihat cara **mengonversi HTML ke PNG** dengan hanya beberapa baris kode C#, menggunakan mesin rendering kuat Aspose.HTML.
+
+Merender HTML sebagai gambar adalah kebutuhan umum saat membuat thumbnail, pratinjau email, atau laporan yang harus disematkan dalam PDF. Pada bagian-bagian berikut, Anda akan mempelajari langkah‑langkah tepat, melihat contoh lengkap yang berfungsi, dan memahami mengapa setiap pengaturan penting.
+
+## Apa yang akan Anda pelajari
+
+- Cara membuat `HtmlDocument` dari string atau file.
+- Cara mengonfigurasi `ImageRenderingOptions` untuk meningkatkan kualitas.
+- Cara **mengonversi HTML ke PNG** dan menyimpan hasilnya ke disk.
+- Tips untuk menangani font, halaman besar, dan jalur output khusus.
+
+**Prasyarat**
+- .NET 6.0 SDK (atau yang lebih baru) terpasang.
+- Lisensi Aspose.HTML untuk .NET yang valid (atau kunci evaluasi sementara).
+- Familiaritas dasar dengan C# dan Visual Studio atau IDE kompatibel .NET apa pun.
+
+---
+
+## Buat PNG dari HTML dengan Aspose.HTML
+
+Langkah pertama adalah menyiapkan lingkungan dan merujuk namespace Aspose.HTML yang diperlukan.
+
+```csharp
+using System;
+using Aspose.Html;
+using Aspose.Html.Rendering.Image;
+using Aspose.Html.Drawing;
+using Aspose.Html.Converters;
+
+namespace HtmlToPngDemo
+{
+ class Program
+ {
+ static void Main()
+ {
+ // 1️⃣ Build the HTML document from a raw string.
+ var html = "Bold text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // 2️⃣ Configure rendering options for best visual fidelity. + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, // Smooths edges of drawn shapes + TextOptions = { UseHinting = true }, // Improves glyph clarity + FontOptions = { WebFontStyle = WebFontStyle.Normal } // Uses standard web‑font style + }; + + // 3️⃣ Convert the HTML document to a PNG file. + string outputPath = @"output.png"; + ImageConverter.ConvertHtmlToImage(document, outputPath, renderOptions); + + Console.WriteLine($"PNG image created at: {outputPath}"); + } + } +} +``` + +### Mengapa ini berhasil + +- **`HtmlDocument.Open`** mengurai string HTML menjadi DOM yang dapat dirender oleh Aspose.HTML. +- **`ImageRenderingOptions`** memungkinkan Anda mengontrol anti‑aliasing, hinting teks, dan penanganan font, yang penting saat Anda **merender HTML sebagai gambar** untuk menghindari teks yang buram. +- **`ImageConverter.ConvertHtmlToImage`** melakukan pekerjaan berat: ia merasterisasi DOM ke bitmap dan menulis file PNG. + +Menjalankan program menghasilkan `output.png` yang berisi paragraf tebal persis seperti yang didefinisikan dalam sumber HTML. + +--- + +## Mengonversi HTML ke PNG langkah demi langkah + +Berikut ini penjelasan lebih detail tentang setiap fase. Memahami tujuan setiap baris membantu Anda menyesuaikan kode untuk halaman yang lebih besar atau lebih kompleks. + +### 1. Menyiapkan sumber HTML + +Anda dapat memuat HTML dari string (seperti yang ditampilkan), file lokal, atau URL remote. + +```csharp +// Load from a file +var document = new HtmlDocument(); +document.Open(@"C:\templates\invoice.html"); + +// Load from a URL (requires internet access) +document.Open("https://example.com/report.html"); +``` + +**Tip:** Saat memuat sumber daya eksternal (CSS, gambar), pastikan properti `BaseUrl` mengarah ke folder yang tepat sehingga tautan relatif dapat diselesaikan dengan benar. + +### 2. Menyetel opsi rendering secara halus + +| Opsi | Efek | Kapan disesuaikan | +|------|------|-------------------| +| `UseAntialiasing` | Mengurangi tepi bergerigi pada grafik vektor | Selalu aktifkan untuk output berkualitas tinggi | +| `TextOptions.UseHinting` | Menajamkan tepi glif | Penting untuk ukuran font kecil | +| `FontOptions.WebFontStyle` | Memilih rendering web‑font normal, italic, atau oblique | Gunakan `WebFontStyle.Oblique` untuk font miring | +| `ResolutionX` / `ResolutionY` | DPI gambar output | Tingkatkan untuk PNG siap cetak (mis., 300 DPI) | + +Contoh meningkatkan DPI: + +```csharp +renderOptions.ResolutionX = 300; +renderOptions.ResolutionY = 300; +``` + +### 3. Melakukan konversi + +`ImageConverter` overload yang Anda gunakan menulis satu file PNG. Jika Anda memerlukan beberapa halaman (mis., dokumen HTML multi‑halaman), gunakan overload yang mengembalikan koleksi gambar. + +```csharp +ImageConverter.ConvertHtmlToImages(document, "output_folder", renderOptions); +``` + +Setiap halaman menjadi `output_folder/page_0.png`, `page_1.png`, dll. + +--- + +## Merender HTML sebagai gambar – menangani jebakan umum + +### a. Font yang hilang + +Jika HTML merujuk ke web‑font khusus yang tidak terpasang di server, teks yang dirender akan kembali ke font default, yang dapat memengaruhi tata letak. + +**Solusi:** Sematkan font menggunakan aturan `@font-face` di CSS Anda atau sediakan folder font lokal melalui `FontOptions`. + +```csharp +renderOptions.FontOptions.FontFolder = @"C:\fonts"; +``` + +### b. Halaman besar dan konsumsi memori + +Merender halaman yang sangat tinggi dapat mengonsumsi banyak RAM. + +**Solusi:** Tetapkan tinggi maksimum atau bagi dokumen menjadi beberapa bagian sebelum konversi. + +```csharp +renderOptions.PageHeight = 2000; // pixels +``` + +### c. Latar belakang transparan + +PNG mendukung transparansi, tetapi latar belakang default adalah putih. + +**Solusi:** Ubah warna latar belakang menjadi transparan. + +```csharp +renderOptions.BackgroundColor = System.Drawing.Color.Transparent; +``` + +--- + +## Cara merender HTML ke gambar – rangkuman contoh lengkap + +Menggabungkan semuanya, berikut cuplikan siap produksi yang mencakup kebutuhan paling umum: + +```csharp +using System; +using Aspose.Html; +using Aspose.Html.Rendering.Image; +using Aspose.Html.Drawing; +using Aspose.Html.Converters; + +namespace HtmlToPngDemo +{ + class Program + { + static void Main() + { + // Load HTML (string, file, or URL) + string html = "" + + "Bold blue text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // Configure rendering for high quality and transparency + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, + TextOptions = { UseHinting = true }, + FontOptions = { WebFontStyle = WebFontStyle.Normal, FontFolder = @"C:\fonts" }, + BackgroundColor = System.Drawing.Color.Transparent, + ResolutionX = 150, + ResolutionY = 150 + }; + + // Convert and save + string outPath = @"C:\temp\html_snapshot.png"; + ImageConverter.ConvertHtmlToImage(document, outPath, renderOptions); + + Console.WriteLine($"Image saved to {outPath}"); + } + } +} +``` + +**Output yang diharapkan:** File `html_snapshot.png` yang berisi paragraf tebal berwarna biru pada kanvas transparan. Gambar akan anti‑aliased, dengan teks tajam berkat hinting. + +--- + +## Kesimpulan + +Anda sekarang tahu cara **membuat PNG dari HTML** di C# menggunakan Aspose.HTML. Dengan membangun `HtmlDocument`, mengonfigurasi `ImageRenderingOptions`, dan memanggil `ImageConverter.ConvertHtmlToImage`, Anda dapat secara andal **mengonversi HTML ke PNG** dan **merender HTML sebagai gambar** untuk skenario otomatisasi apa pun. + +Dari sini Anda dapat menjelajahi: + +- Membuat thumbnail untuk halaman web dinamis. +- Menyematkan PNG ke dalam PDF dengan Aspose.PDF. +- Menggunakan pendekatan yang sama untuk menghasilkan JPEG atau BMP dengan mengubah ekstensi file. + +Silakan bereksperimen dengan DPI, warna latar belakang, dan rendering multi‑halaman untuk menyesuaikan kebutuhan proyek Anda secara tepat. Selamat coding! + +## Apa yang Harus Anda Pelajari Selanjutnya? + +Tutorial berikut mencakup topik yang sangat terkait yang membangun teknik yang ditunjukkan dalam panduan ini. Setiap sumber menyertakan contoh kode lengkap yang berfungsi dengan penjelasan langkah demi langkah untuk membantu Anda menguasai fitur API tambahan dan menjelajahi pendekatan implementasi alternatif dalam proyek Anda. + +- [Render HTML as PNG in .NET with Aspose.HTML](/html/english/net/rendering-html-documents/render-html-as-png/) +- [How to Render HTML as PNG – Complete C# Guide](/html/english/net/rendering-html-documents/how-to-render-html-as-png-complete-c-guide/) +- [Create PNG from HTML – Full C# Rendering Guide](/html/english/net/rendering-html-documents/create-png-from-html-full-c-rendering-guide/) + +{{< /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 6ac5368fff..5899974864 100644 --- a/html/indonesian/net/html-extensions-and-conversions/_index.md +++ b/html/indonesian/net/html-extensions-and-conversions/_index.md @@ -71,6 +71,8 @@ Pelajari cara mengompres file HTML menjadi arsip ZIP menggunakan C# dan Aspose.H Pelajari cara membuat dokumen HTML dengan teks berformat dan mengekspornya ke PDF menggunakan Aspose.HTML untuk .NET. ### [Simpan HTML sebagai ZIP – Tutorial Lengkap C#](./save-html-as-zip-complete-c-tutorial/) Pelajari cara menyimpan file HTML sebagai arsip ZIP menggunakan Aspose.HTML untuk .NET dengan contoh kode C# lengkap. +### [Simpan HTML sebagai ZIP di C# – panduan langkah‑demi‑langkah](./save-html-as-zip-in-c-step-by-step-guide/) +Pelajari cara menyimpan file HTML ke arsip ZIP secara bertahap menggunakan C# dan Aspose.HTML. ### [Simpan HTML ke ZIP di C# – Contoh In‑Memory Lengkap](./save-html-to-zip-in-c-complete-in-memory-example/) Pelajari cara menyimpan file HTML ke dalam arsip ZIP secara langsung di memori menggunakan C# dan Aspose.HTML. diff --git a/html/indonesian/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md b/html/indonesian/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..0e94ebd1f2 --- /dev/null +++ b/html/indonesian/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md @@ -0,0 +1,322 @@ +--- +category: general +date: 2026-08-12 +description: Simpan HTML sebagai ZIP menggunakan Aspose.HTML. Pelajari cara memuat + string HTML, membuat penangan sumber daya khusus, dan menghasilkan arsip ZIP secara + efisien. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save html as zip +- load html string +- custom resource handler +language: id +lastmod: 2026-08-12 +og_description: Simpan HTML sebagai ZIP menggunakan Aspose.HTML di C#. Tutorial ini + menunjukkan cara memuat string HTML, membuat penangan sumber daya khusus, dan menghasilkan + arsip ZIP dalam beberapa langkah. +og_image_alt: Diagram showing save html as zip process with custom resource handler +og_title: Simpan HTML sebagai ZIP dengan Aspose.HTML – panduan lengkap C# +schemas: +- author: Aspose + dateModified: '2026-08-12' + description: Save HTML as ZIP using Aspose.HTML. Learn to load HTML string, create + a custom resource handler, and generate a ZIP archive efficiently. + headline: Save HTML as ZIP in C# – step‑by‑step guide + type: TechArticle +tags: +- Aspose.HTML +- C# +- ZIP archive +title: Simpan HTML sebagai ZIP di C# – panduan langkah demi langkah +url: /id/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Simpan HTML sebagai ZIP di C# – panduan langkah demi langkah + +Jika Anda perlu **menyimpan HTML sebagai ZIP** dalam aplikasi .NET, panduan ini menunjukkan alur kerja lengkap. Anda akan belajar cara **memuat string HTML**, mengimplementasikan **penangkap sumber daya khusus**, dan menghasilkan arsip ZIP tanpa menulis file perantara ke disk. + +Pendekatan ini menggunakan Aspose.HTML 5.x, yang menyediakan mesin rendering berperforma tinggi dan opsi penyimpanan yang fleksibel. Pada akhir tutorial Anda akan memiliki penangkap yang dapat digunakan kembali dan dapat diintegrasikan ke layanan web, pekerjaan latar belakang, atau alat desktop. + +## Apa yang akan Anda bangun + +Kode akhir membuat file ZIP berbasis `MemoryStream` yang berisi dokumen HTML dan semua sumber daya yang direferensikan (gambar, CSS, font). File ZIP ditulis ke folder tujuan, tetapi Anda dapat mengubah tujuan menjadi aliran respons untuk API HTTP. + +## Prasyarat + +- .NET 6.0 atau lebih baru (contoh menargetkan .NET 6) +- Aspose.HTML untuk .NET (paket NuGet `Aspose.HTML`) +- Pemahaman dasar tentang pola async C# (opsional tetapi membantu) + +> **Pro tip:** Instal paket dengan `dotnet add package Aspose.HTML` sebelum memulai. + +## Langkah 1: Definisikan penangkap sumber daya khusus + +Sebuah **penangkap sumber daya khusus** menyela setiap permintaan sumber daya eksternal yang dibuat oleh renderer HTML. Dengan mengembalikan aliran, Anda mengontrol di mana data sumber daya disimpan. Contoh ini menyimpan semuanya di memori, yang ideal untuk membuat arsip ZIP secara langsung. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +///Hello, world!
+
+
+";
+
+// Create a new document instance.
+HtmlDocument document = new HtmlDocument();
+
+// Load the HTML markup.
+document.Open(htmlContent);
+```
+
+**Mengapa langkah ini penting:**
+Kemampuan **memuat string html** berguna ketika HTML dihasilkan secara dinamis (mis., dari mesin templat) atau diterima dari API. Ini menghindari ketergantungan sistem file dan berfungsi di lingkungan sandbox.
+
+## Langkah 3: Konfigurasikan opsi penyimpanan untuk menggunakan penangkap
+
+`HtmlSaveOptions` milik Aspose.HTML memungkinkan Anda menentukan mekanisme penyimpanan untuk output. Tetapkan penangkap khusus ke properti `OutputStorage`, dan atur flag `Compress` untuk menghasilkan arsip ZIP.
+
+```csharp
+// Instantiate the custom handler.
+var resourceHandler = new InMemoryResourceHandler();
+
+// Prepare save options.
+HtmlSaveOptions saveOptions = new HtmlSaveOptions
+{
+ // Use the handler for all external resources.
+ OutputStorage = resourceHandler,
+
+ // Enable ZIP compression.
+ Compress = true
+};
+```
+
+**Mengapa langkah ini penting:**
+`Compress = true` memberi tahu Aspose.HTML untuk menggabungkan file HTML dan semua sumber daya yang dikumpulkan ke dalam satu paket ZIP. `OutputStorage` memastikan bahwa sumber daya ditangkap di memori bukan ditulis ke lokasi sementara.
+
+## Langkah 4: Simpan dokumen sebagai arsip ZIP
+
+Sekarang panggil `HtmlDocument.Save`, dengan memberikan jalur tujuan dan opsi yang telah dikonfigurasi. Setelah disimpan, file ZIP berisi `index.html` serta semua sumber daya yang ditangkap oleh penangkap.
+
+```csharp
+// Define the output path (you can change this to a response stream for web APIs).
+string outputPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+
+// Save the document; Aspose.HTML creates the ZIP automatically.
+document.Save(outputPath, saveOptions);
+
+// Optional: Verify the resources that were stored.
+foreach (var entry in resourceHandler.Resources)
+{
+ Console.WriteLine($"Resource: {entry.Key}, Size: {entry.Value.Length} bytes");
+}
+```
+
+**Hasil yang diharapkan:**
+Menjalankan program membuat `output.zip` di direktori saat ini. Mengekstrak arsip menampilkan:
+
+```
+index.html
+styles.css
+logo.png
+```
+
+Setiap file cocok dengan referensi markup, dan HTML di dalam `index.html` mengarah ke sumber daya yang dibundel.
+
+## Langkah 5: Sesuaikan penangkap untuk data sumber daya nyata (lanjutan)
+
+Penangkap dasar di atas membuat aliran kosong. Dalam produksi Anda sering perlu menulis konten sebenarnya (mis., byte dari `styles.css` atau `logo.png`). Perluas `HandleResource` untuk mengambil data dari basis data, bucket cloud, atau sumber daya tersemat.
+
+```csharp
+public override Stream HandleResource(ResourceInfo info)
+{
+ // Example: Load resource from an embedded folder.
+ string resourcePath = Path.Combine("EmbeddedResources", info.Path);
+ byte[] data = File.ReadAllBytes(resourcePath);
+
+ // Write data into a memory stream.
+ var stream = new MemoryStream(data);
+ _resources[info.Path] = stream;
+
+ // Return the populated stream.
+ return stream;
+}
+```
+
+**Mengapa variasi ini penting:**
+Menyediakan konten nyata memastikan arsip ZIP berfungsi saat dibuka di peramban. Penangkap juga dapat menerapkan transformasi (mis., meminifikasi CSS) sebelum menulis ke aliran.
+
+## Langkah 6: Gunakan arsip ZIP dalam API web (opsional)
+
+Jika Anda mengekspos fungsionalitas melalui ASP.NET Core, kembalikan file ZIP sebagai hasil file:
+
+```csharp
+[HttpGet("download")]
+public IActionResult DownloadZip()
+{
+ // Reuse the same logic from steps 1‑4.
+ // ...
+
+ // Read the generated ZIP into a byte array.
+ byte[] zipBytes = System.IO.File.ReadAllBytes(outputPath);
+
+ // Return the file with the appropriate content type.
+ return File(zipBytes, "application/zip", "document.zip");
+}
+```
+
+**Mengapa langkah ini penting:**
+Klien dapat mengunduh HTML yang dibundel tanpa harus berurusan dengan file sementara di server. Pendekatan ini bekerja dengan fungsi serverless di mana akses disk terbatas.
+
+## Kesalahan umum dan cara menghindarinya
+
+| Pitfall | Reason | Fix |
+|---------|--------|-----|
+| Sumber daya kosong dalam ZIP | Penangkap mengembalikan `MemoryStream` baru tanpa menulis data | Isi aliran dengan byte aktual sebelum mengembalikannya |
+| Entri `index.html` hilang | Flag `Compress` tidak diatur atau `OutputStorage` tidak ditetapkan | Pastikan `saveOptions.Compress = true` dan `saveOptions.OutputStorage = handler` |
+| HTML besar menyebabkan tekanan memori | Semua sumber daya disimpan di memori | Beralih ke implementasi `FileStorage` yang menulis ke folder sementara |
+| URL relatif rusak setelah ekstraksi | Sumber daya direferensikan dengan URL absolut yang tidak disimpan | Ubah URL menjadi jalur relatif di dalam penangkap atau selama pasca‑pemrosesan |
+
+## Contoh lengkap yang dapat dijalankan
+
+```csharp
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Saving;
+
+class InMemoryResourceHandler : ResourceHandler
+{
+ private readonly DictionaryHello, world!
+
+
+ ";
+
+ HtmlDocument doc = new HtmlDocument();
+ doc.Open(html);
+
+ // Step 1 & 3: Create handler and configure save options.
+ var handler = new InMemoryResourceHandler();
+ HtmlSaveOptions options = new HtmlSaveOptions
+ {
+ OutputStorage = handler,
+ Compress = true
+ };
+
+ // Step 4: Save as ZIP.
+ string zipPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+ doc.Save(zipPath, options);
+ Console.WriteLine($"ZIP file created at: {zipPath}");
+
+ // Optional verification.
+ foreach (var kvp in handler.Resources)
+ {
+ Console.WriteLine($"Resource {kvp.Key} captured, length {kvp.Value.Length} bytes");
+ }
+ }
+}
+```
+
+Menjalankan program menghasilkan `output.zip` di samping executable. Mengekstrak arsip menampilkan `index.html`, `styles.css`, dan `logo.png` (placeholder kosong dalam contoh minimal ini).
+
+## Kesimpulan
+
+Anda kini memiliki metode yang handal untuk **menyimpan HTML sebagai ZIP** menggunakan Aspose.HTML di C#. Tutorial ini mencakup memuat string HTML, mengimplementasikan **penangkap sumber daya khusus**, mengkonfigurasi opsi penyimpanan, dan menghasilkan arsip ZIP siap untuk distribusi atau unduhan.
+
+Dari sini Anda dapat:
+
+- Mengganti aliran placeholder dengan konten nyata (mis., membaca dari basis data)
+- Beralih ke penangkap penyimpanan berbasis file untuk dokumen yang sangat besar
+- Mengintegrasikan logika ke endpoint ASP.NET Core untuk unduhan sesuai permintaan
+- Mengeksplorasi fitur tambahan Aspose.HTML seperti konversi PDF atau rendering gambar
+
+Bereksperimenlah dengan berbagai sumber daya dan pengaturan kompresi untuk menyesuaikan solusi dengan kebutuhan kinerja dan ukuran Anda. Selamat coding!
+
+## Apa yang Harus Anda Pelajari Selanjutnya?
+
+Tutorial berikut mencakup topik yang sangat terkait yang membangun teknik yang ditunjukkan dalam panduan ini. Setiap sumber daya menyertakan contoh kode lengkap yang berfungsi dengan penjelasan langkah demi langkah untuk membantu Anda menguasai fitur API tambahan dan mengeksplorasi pendekatan implementasi alternatif dalam proyek Anda.
+
+- [Simpan HTML sebagai ZIP – Tutorial C# Lengkap](/html/english/net/html-extensions-and-conversions/save-html-as-zip-complete-c-tutorial/)
+- [Cara Menyimpan HTML di C# – Panduan Lengkap Menggunakan Penangkap Sumber Daya Khusus](/html/english/net/working-with-html-documents/how-to-save-html-in-c-complete-guide-using-a-custom-resource/)
+- [Buat HTML dari String di C# – Panduan Penangkap Sumber Daya Khusus](/html/english/net/html-document-manipulation/create-html-from-string-in-c-custom-resource-handler-guide/)
+
+{{< /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/generate-jpg-and-png-images/_index.md b/html/italian/net/generate-jpg-and-png-images/_index.md
index f6e8b2d8a7..e913353d88 100644
--- a/html/italian/net/generate-jpg-and-png-images/_index.md
+++ b/html/italian/net/generate-jpg-and-png-images/_index.md
@@ -41,6 +41,8 @@ Integrare Aspose.HTML per .NET nei tuoi progetti .NET è semplice. La libreria
Scopri come creare pagine web dinamiche usando Aspose.HTML per .NET. Questo tutorial passo dopo passo riguarda i prerequisiti, gli spazi dei nomi e il rendering di HTML in immagini.
### [Genera immagini PNG tramite ImageDevice in .NET con Aspose.HTML](./generate-png-images-by-imagedevice/)
Impara a usare Aspose.HTML per .NET per manipolare documenti HTML, convertire HTML in immagini e altro ancora. Tutorial passo dopo passo con FAQ.
+### [Crea PNG da HTML in C# usando Aspose.HTML](./create-png-from-html-in-c-using-aspose-html/)
+Impara a generare file PNG a partire da contenuti HTML in C# con Aspose.HTML, passo dopo passo.
### [Come abilitare l'antialiasing durante la conversione di DOCX in PNG/JPG](./how-to-enable-antialiasing-when-converting-docx-to-png-jpg/)
Scopri come abilitare l'antialiasing durante la conversione di documenti DOCX in immagini PNG o JPG con Aspose.HTML per .NET.
### [Converti docx in PNG – crea archivio zip C# tutorial](./convert-docx-to-png-create-zip-archive-c-tutorial/)
diff --git a/html/italian/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md b/html/italian/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
new file mode 100644
index 0000000000..32540509bd
--- /dev/null
+++ b/html/italian/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
@@ -0,0 +1,291 @@
+---
+category: general
+date: 2026-08-12
+description: Crea PNG da HTML in C# con Aspose.HTML. Scopri come convertire HTML in
+ PNG e renderizzare HTML come immagine in poche righe di codice.
+draft: false
+images:
+- PLACEHOLDER_URL/og-image.png
+keywords:
+- create png from html
+- convert html to png
+- render html as image
+- how to render html to image
+language: it
+lastmod: 2026-08-12
+og_description: Crea PNG da HTML in C# usando Aspose.HTML. Questa guida mostra come
+ renderizzare rapidamente HTML come immagine, coprendo le opzioni di conversione,
+ la configurazione del codice e la risoluzione dei problemi.
+og_image_alt: Screenshot of a C# program converting HTML to a PNG image
+og_title: Crea PNG da HTML in C# – guida passo passo
+schemas:
+- author: Aspose
+ dateModified: '2026-08-12'
+ description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ headline: Create PNG from HTML in C# using Aspose.HTML
+ type: TechArticle
+- description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ name: Create PNG from HTML in C# using Aspose.HTML
+ steps:
+ - name: Why this works
+ text: '- **`HtmlDocument.Open`** parses the HTML string into a DOM that Aspose.HTML
+ can render. - **`ImageRenderingOptions`** lets you control anti‑aliasing, text
+ hinting, and font handling, which are essential when you **render HTML as image**
+ to avoid blurry text. - **`ImageConverter.ConvertHtmlToImage`*'
+ - name: 1. Preparing the HTML source
+ text: You can load HTML from a string (as shown), a local file, or a remote URL.
+ - name: 2. Fine‑tuning rendering options
+ text: '| Option | Effect | When to adjust | |--------|--------|----------------|
+ | `UseAntialiasing` | Reduces jagged edges on vector graphics | Always enable
+ for high‑quality output | | `TextOptions.UseHinting` | Sharpens glyph edges
+ | Important for small font sizes | | `FontOptions.WebFontStyle` | Choose'
+ - name: 3. Performing the conversion
+ text: The `ImageConverter` overload you used writes a single PNG file. If you
+ need multiple pages (e.g., a multi‑page HTML document), use the overload that
+ returns a collection of images.
+ - name: a. Missing fonts
+ text: If the HTML references a custom web font that isn’t installed on the server,
+ the rendered text falls back to a default font, which may affect layout.
+ - name: b. Large pages and memory consumption
+ text: Rendering a very tall page can consume a lot of RAM.
+ - name: c. Transparent backgrounds
+ text: PNG supports transparency, but the default background is white.
+ type: HowTo
+tags:
+- Aspose.HTML
+- C#
+- image rendering
+- HTML conversion
+title: Crea PNG da HTML in C# usando Aspose.HTML
+url: /it/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/
+---
+
+{{< blocks/products/pf/main-wrap-class >}}
+{{< blocks/products/pf/main-container >}}
+{{< blocks/products/pf/tutorial-page-section >}}
+
+# Crea PNG da HTML in C# usando Aspose.HTML
+
+Se hai bisogno di **creare PNG da HTML** in un'applicazione .NET, questa guida ti accompagna attraverso l'intero processo. Vedrai come **convertire HTML in PNG** con poche righe di codice C#, usando il potente motore di rendering di Aspose.HTML.
+
+Il rendering di HTML come immagine è una necessità comune quando si generano miniature, anteprime email o report che devono essere incorporati nei PDF. Nelle sezioni successive, imparerai i passaggi esatti, vedrai un esempio completo funzionante e comprenderai perché ogni impostazione è importante.
+
+## Cosa imparerai
+
+- Come creare un `HtmlDocument` da una stringa o da un file.
+- Come configurare `ImageRenderingOptions` per migliorare la qualità.
+- Come **convertire HTML in PNG** e salvare il risultato su disco.
+- Suggerimenti per gestire i font, pagine grandi e percorsi di output personalizzati.
+
+**Prerequisiti**
+- .NET 6.0 SDK (o successivo) installato.
+- Una licenza valida di Aspose.HTML per .NET (o una chiave di valutazione temporanea).
+- Familiarità di base con C# e Visual Studio o qualsiasi IDE compatibile con .NET.
+
+---
+
+## Crea PNG da HTML con Aspose.HTML
+
+Il primo passo è configurare l'ambiente e fare riferimento agli spazi dei nomi Aspose.HTML necessari.
+
+```csharp
+using System;
+using Aspose.Html;
+using Aspose.Html.Rendering.Image;
+using Aspose.Html.Drawing;
+using Aspose.Html.Converters;
+
+namespace HtmlToPngDemo
+{
+ class Program
+ {
+ static void Main()
+ {
+ // 1️⃣ Build the HTML document from a raw string.
+ var html = "Bold text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // 2️⃣ Configure rendering options for best visual fidelity. + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, // Smooths edges of drawn shapes + TextOptions = { UseHinting = true }, // Improves glyph clarity + FontOptions = { WebFontStyle = WebFontStyle.Normal } // Uses standard web‑font style + }; + + // 3️⃣ Convert the HTML document to a PNG file. + string outputPath = @"output.png"; + ImageConverter.ConvertHtmlToImage(document, outputPath, renderOptions); + + Console.WriteLine($"PNG image created at: {outputPath}"); + } + } +} +``` + +### Perché funziona + +- **`HtmlDocument.Open`** analizza la stringa HTML in un DOM che Aspose.HTML può renderizzare. +- **`ImageRenderingOptions`** ti consente di controllare l'anti‑aliasing, il hinting del testo e la gestione dei font, elementi essenziali quando **renderizzi HTML come immagine** per evitare testo sfocato. +- **`ImageConverter.ConvertHtmlToImage`** esegue il lavoro pesante: rasterizza il DOM su una bitmap e scrive il file PNG. + +Eseguendo il programma si genera `output.png` che contiene il paragrafo in grassetto esattamente come definito nel sorgente HTML. + +--- + +## Converti HTML in PNG passo dopo passo + +Di seguito trovi una spiegazione più dettagliata di ogni fase. Comprendere lo scopo di ogni riga ti aiuta ad adattare il codice per pagine più grandi o più complesse. + +### 1. Preparazione della sorgente HTML + +Puoi caricare l'HTML da una stringa (come mostrato), da un file locale o da un URL remoto. + +```csharp +// Load from a file +var document = new HtmlDocument(); +document.Open(@"C:\templates\invoice.html"); + +// Load from a URL (requires internet access) +document.Open("https://example.com/report.html"); +``` + +**Suggerimento:** Quando carichi risorse esterne (CSS, immagini), assicurati che la proprietà `BaseUrl` punti alla cartella corretta affinché i collegamenti relativi vengano risolti correttamente. + +### 2. Ottimizzazione delle opzioni di rendering + +| Opzione | Effetto | Quando regolare | +|--------|--------|----------------| +| `UseAntialiasing` | Riduce i bordi frastagliati nella grafica vettoriale | Sempre attivare per output di alta qualità | +| `TextOptions.UseHinting` | Affina i bordi dei glifi | Importante per dimensioni di font piccole | +| `FontOptions.WebFontStyle` | Sceglie il rendering del web‑font normale, italic o oblique | Usa `WebFontStyle.Oblique` per font inclinati | +| `ResolutionX` / `ResolutionY` | DPI dell'immagine di output | Aumentare per PNG pronti per la stampa (es., 300 DPI) | + +Esempio di aumento DPI: + +```csharp +renderOptions.ResolutionX = 300; +renderOptions.ResolutionY = 300; +``` + +### 3. Esecuzione della conversione + +L'overload di `ImageConverter` che hai usato scrive un singolo file PNG. Se ti servono più pagine (es., un documento HTML multi‑pagina), usa l'overload che restituisce una collezione di immagini. + +```csharp +ImageConverter.ConvertHtmlToImages(document, "output_folder", renderOptions); +``` + +Ogni pagina diventa `output_folder/page_0.png`, `page_1.png`, ecc. + +--- + +## Renderizza HTML come immagine – gestione delle problematiche comuni + +### a. Font mancanti + +Se l'HTML fa riferimento a un web‑font personalizzato che non è installato sul server, il testo renderizzato ricade su un font predefinito, il che può influire sul layout. + +**Soluzione:** Includi il font usando una regola `@font-face` nel tuo CSS o fornisci una cartella di font locale tramite `FontOptions`. + +```csharp +renderOptions.FontOptions.FontFolder = @"C:\fonts"; +``` + +### b. Pagine grandi e consumo di memoria + +Renderizzare una pagina molto alta può consumare molta RAM. + +**Soluzione:** Imposta un'altezza massima o dividi il documento in sezioni prima della conversione. + +```csharp +renderOptions.PageHeight = 2000; // pixels +``` + +### c. Sfondi trasparenti + +PNG supporta la trasparenza, ma lo sfondo predefinito è bianco. + +**Soluzione:** Cambia il colore di sfondo a trasparente. + +```csharp +renderOptions.BackgroundColor = System.Drawing.Color.Transparent; +``` + +--- + +## Come renderizzare HTML in immagine – riepilogo esempio completo + +Mettendo tutto insieme, ecco uno snippet pronto per la produzione che copre i requisiti più frequenti: + +```csharp +using System; +using Aspose.Html; +using Aspose.Html.Rendering.Image; +using Aspose.Html.Drawing; +using Aspose.Html.Converters; + +namespace HtmlToPngDemo +{ + class Program + { + static void Main() + { + // Load HTML (string, file, or URL) + string html = "" + + "Bold blue text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // Configure rendering for high quality and transparency + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, + TextOptions = { UseHinting = true }, + FontOptions = { WebFontStyle = WebFontStyle.Normal, FontFolder = @"C:\fonts" }, + BackgroundColor = System.Drawing.Color.Transparent, + ResolutionX = 150, + ResolutionY = 150 + }; + + // Convert and save + string outPath = @"C:\temp\html_snapshot.png"; + ImageConverter.ConvertHtmlToImage(document, outPath, renderOptions); + + Console.WriteLine($"Image saved to {outPath}"); + } + } +} +``` + +**Output previsto:** Un file `html_snapshot.png` contenente un paragrafo in grassetto e blu su una tela trasparente. L'immagine sarà anti‑aliasata, con testo nitido grazie al hinting. + +--- + +## Conclusione + +Ora sai come **creare PNG da HTML** in C# usando Aspose.HTML. Costruendo un `HtmlDocument`, configurando `ImageRenderingOptions` e chiamando `ImageConverter.ConvertHtmlToImage`, puoi in modo affidabile **convertire HTML in PNG** e **renderizzare HTML come immagine** per qualsiasi scenario di automazione. + +Da qui potresti esplorare: + +- Generare miniature per pagine web dinamiche. +- Incorporare il PNG nei PDF con Aspose.PDF. +- Usare lo stesso approccio per produrre JPEG o BMP cambiando l'estensione del file. + +Sentiti libero di sperimentare con DPI, colori di sfondo e rendering multi‑pagina per adattare alle esigenze esatte del tuo progetto. Buon coding! + +## Cosa dovresti imparare dopo? + +I seguenti tutorial coprono argomenti strettamente correlati che si basano sulle tecniche dimostrate in questa guida. Ogni risorsa include esempi di codice completi e funzionanti con spiegazioni passo‑passo per aiutarti a padroneggiare funzionalità API aggiuntive ed esplorare approcci di implementazione alternativi nei tuoi progetti. + +- [Render HTML as PNG in .NET with Aspose.HTML](/html/english/net/rendering-html-documents/render-html-as-png/) +- [How to Render HTML as PNG – Complete C# Guide](/html/english/net/rendering-html-documents/how-to-render-html-as-png-complete-c-guide/) +- [Create PNG from HTML – Full C# Rendering Guide](/html/english/net/rendering-html-documents/create-png-from-html-full-c-rendering-guide/) + +{{< /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 fcf4daa304..4eeb98083f 100644 --- a/html/italian/net/html-extensions-and-conversions/_index.md +++ b/html/italian/net/html-extensions-and-conversions/_index.md @@ -71,6 +71,8 @@ Scopri come comprimere un documento HTML in un file ZIP usando Aspose.HTML per . Crea un PDF da HTML in C# con Aspose.HTML per .NET. Segui la nostra guida passo passo per una conversione semplice ed efficace. ### [Salva HTML come ZIP – Tutorial completo C#](./save-html-as-zip-complete-c-tutorial/) Salva HTML come archivio ZIP con Aspose.HTML per .NET. Guida passo passo per creare file ZIP contenenti HTML in C#. +### [Salva HTML in ZIP in C# – Guida passo‑a‑passo](./save-html-as-zip-in-c-step-by-step-guide/) +Scopri come comprimere un documento HTML in un archivio ZIP usando Aspose.HTML per .NET in C#. ### [Salva HTML in ZIP in C# – Esempio completo in memoria](./save-html-to-zip-in-c-complete-in-memory-example/) Scopri come salvare un documento HTML in un archivio ZIP interamente in memoria usando Aspose.HTML per .NET. diff --git a/html/italian/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md b/html/italian/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..793f1aba80 --- /dev/null +++ b/html/italian/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md @@ -0,0 +1,320 @@ +--- +category: general +date: 2026-08-12 +description: Salva HTML come ZIP usando Aspose.HTML. Impara a caricare una stringa + HTML, creare un gestore di risorse personalizzato e generare un archivio ZIP in + modo efficiente. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save html as zip +- load html string +- custom resource handler +language: it +lastmod: 2026-08-12 +og_description: Salva HTML come ZIP usando Aspose.HTML in C#. Questo tutorial mostra + come caricare una stringa HTML, creare un gestore di risorse personalizzato e generare + un archivio ZIP in pochi passaggi. +og_image_alt: Diagram showing save html as zip process with custom resource handler +og_title: Salva HTML come ZIP con Aspose.HTML – guida completa C# +schemas: +- author: Aspose + dateModified: '2026-08-12' + description: Save HTML as ZIP using Aspose.HTML. Learn to load HTML string, create + a custom resource handler, and generate a ZIP archive efficiently. + headline: Save HTML as ZIP in C# – step‑by‑step guide + type: TechArticle +tags: +- Aspose.HTML +- C# +- ZIP archive +title: Salva HTML come ZIP in C# – guida passo‑passo +url: /it/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Salva HTML come ZIP in C# – guida passo‑passo + +Se hai bisogno di **salvare HTML come ZIP** in un'applicazione .NET, questa guida mostra l'intero flusso di lavoro. Imparerai come **caricare una stringa HTML**, implementare un **gestore di risorse personalizzato** e generare un archivio ZIP senza scrivere file intermedi su disco. + +L'approccio utilizza Aspose.HTML 5.x, che fornisce un motore di rendering ad alte prestazioni e opzioni di salvataggio flessibili. Alla fine della tutorial avrai un gestore riutilizzabile che può essere integrato in servizi web, processi in background o strumenti desktop. + +## Cosa costruirai + +Il codice finale crea un file ZIP basato su `MemoryStream` che contiene il documento HTML e tutte le risorse referenziate (immagini, CSS, font). Il file ZIP viene scritto in una cartella di destinazione, ma è possibile cambiare la destinazione in uno stream di risposta per le API HTTP. + +## Prerequisiti + +- .NET 6.0 o successivo (l'esempio è destinato a .NET 6) +- Aspose.HTML per .NET (pacchetto NuGet `Aspose.HTML`) +- Familiarità di base con i pattern async di C# (opzionale ma utile) + +> **Consiglio professionale:** Installa il pacchetto con `dotnet add package Aspose.HTML` prima di iniziare. + +## Passo 1: Definisci un gestore di risorse personalizzato + +Un **gestore di risorse personalizzato** intercetta ogni richiesta di risorsa esterna che il renderer HTML effettua. Restituendo uno stream, controlli dove vengono memorizzati i dati della risorsa. L'esempio memorizza tutto in memoria, il che è ideale per creare un archivio ZIP al volo. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +///Hello, world!
+
+
+";
+
+// Create a new document instance.
+HtmlDocument document = new HtmlDocument();
+
+// Load the HTML markup.
+document.Open(htmlContent);
+```
+
+**Perché questo passo è importante:**
+La capacità di **caricare una stringa HTML** è utile quando l'HTML è generato dinamicamente (ad esempio da un motore di template) o ricevuto da un'API. Evita dipendenze dal file system e funziona in ambienti sandbox.
+
+## Passo 3: Configura le opzioni di salvataggio per utilizzare il gestore
+
+Le `HtmlSaveOptions` di Aspose.HTML ti permettono di specificare il meccanismo di archiviazione per l'output. Assegna il gestore personalizzato alla proprietà `OutputStorage` e imposta il flag `Compress` per produrre un archivio ZIP.
+
+```csharp
+// Instantiate the custom handler.
+var resourceHandler = new InMemoryResourceHandler();
+
+// Prepare save options.
+HtmlSaveOptions saveOptions = new HtmlSaveOptions
+{
+ // Use the handler for all external resources.
+ OutputStorage = resourceHandler,
+
+ // Enable ZIP compression.
+ Compress = true
+};
+```
+
+**Perché questo passo è importante:**
+`Compress = true` indica ad Aspose.HTML di raggruppare il file HTML e tutte le risorse raccolte in un unico pacchetto ZIP. `OutputStorage` garantisce che le risorse siano catturate in memoria anziché scritte in posizioni temporanee.
+
+## Passo 4: Salva il documento come archivio ZIP
+
+Ora invoca `HtmlDocument.Save`, passando il percorso di destinazione e le opzioni configurate. Dopo il salvataggio, il file ZIP contiene `index.html` più tutte le risorse catturate dal gestore.
+
+```csharp
+// Define the output path (you can change this to a response stream for web APIs).
+string outputPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+
+// Save the document; Aspose.HTML creates the ZIP automatically.
+document.Save(outputPath, saveOptions);
+
+// Optional: Verify the resources that were stored.
+foreach (var entry in resourceHandler.Resources)
+{
+ Console.WriteLine($"Resource: {entry.Key}, Size: {entry.Value.Length} bytes");
+}
+```
+
+**Risultato atteso:**
+L'esecuzione del programma crea `output.zip` nella directory corrente. L'estrazione dell'archivio mostra:
+
+```
+index.html
+styles.css
+logo.png
+```
+
+Ogni file corrisponde ai riferimenti del markup, e l'HTML all'interno di `index.html` punta alle risorse incluse.
+
+## Passo 5: Adatta il gestore per dati di risorse reali (avanzato)
+
+Il gestore di base sopra crea stream vuoti. In produzione è spesso necessario scrivere il contenuto reale (ad esempio i byte di `styles.css` o `logo.png`). Estendi `HandleResource` per recuperare i dati da un database, un bucket cloud o una risorsa incorporata.
+
+```csharp
+public override Stream HandleResource(ResourceInfo info)
+{
+ // Example: Load resource from an embedded folder.
+ string resourcePath = Path.Combine("EmbeddedResources", info.Path);
+ byte[] data = File.ReadAllBytes(resourcePath);
+
+ // Write data into a memory stream.
+ var stream = new MemoryStream(data);
+ _resources[info.Path] = stream;
+
+ // Return the populated stream.
+ return stream;
+}
+```
+
+**Perché questa variante è importante:**
+Fornire contenuto reale garantisce che l'archivio ZIP sia funzionale quando aperto in un browser. Il gestore può anche applicare trasformazioni (ad esempio minificare CSS) prima di scrivere nello stream.
+
+## Passo 6: Usa l'archivio ZIP in una Web API (opzionale)
+
+Se esponi la funzionalità tramite ASP.NET Core, restituisci il file ZIP come risultato file:
+
+```csharp
+[HttpGet("download")]
+public IActionResult DownloadZip()
+{
+ // Reuse the same logic from steps 1‑4.
+ // ...
+
+ // Read the generated ZIP into a byte array.
+ byte[] zipBytes = System.IO.File.ReadAllBytes(outputPath);
+
+ // Return the file with the appropriate content type.
+ return File(zipBytes, "application/zip", "document.zip");
+}
+```
+
+**Perché questo passo è importante:**
+I client possono scaricare l'HTML confezionato senza gestire file temporanei sul server. L'approccio funziona con funzioni serverless dove l'accesso al disco è limitato.
+
+## Problemi comuni e come evitarli
+
+| Pitfall | Reason | Fix |
+|---------|--------|-----|
+| Risorse vuote nello ZIP | Il gestore restituisce un nuovo `MemoryStream` senza scrivere dati | Popola lo stream con i byte reali prima di restituirlo |
+| Manca la voce `index.html` | Flag `Compress` non impostato o `OutputStorage` non assegnato | Assicurati che `saveOptions.Compress = true` e `saveOptions.OutputStorage = handler` |
+| HTML di grandi dimensioni che causa pressione sulla memoria | Tutte le risorse sono mantenute in memoria | Passa a un'implementazione `FileStorage` che scrive in una cartella temporanea |
+| URL relativi che si rompono dopo l'estrazione | Risorse referenziate con URL assoluti che non sono memorizzate | Riscrivi gli URL in percorsi relativi all'interno del gestore o durante il post‑processing |
+
+## Esempio completo, eseguibile
+
+```csharp
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Saving;
+
+class InMemoryResourceHandler : ResourceHandler
+{
+ private readonly DictionaryHello, world!
+
+
+ ";
+
+ HtmlDocument doc = new HtmlDocument();
+ doc.Open(html);
+
+ // Step 1 & 3: Create handler and configure save options.
+ var handler = new InMemoryResourceHandler();
+ HtmlSaveOptions options = new HtmlSaveOptions
+ {
+ OutputStorage = handler,
+ Compress = true
+ };
+
+ // Step 4: Save as ZIP.
+ string zipPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+ doc.Save(zipPath, options);
+ Console.WriteLine($"ZIP file created at: {zipPath}");
+
+ // Optional verification.
+ foreach (var kvp in handler.Resources)
+ {
+ Console.WriteLine($"Resource {kvp.Key} captured, length {kvp.Value.Length} bytes");
+ }
+ }
+}
+```
+
+L'esecuzione del programma produce `output.zip` accanto all'eseguibile. L'estrazione dell'archivio mostra `index.html`, `styles.css` e `logo.png` (segnaposti vuoti in questo esempio minimale).
+
+## Conclusione
+
+Hai ora un metodo affidabile per **salvare HTML come ZIP** usando Aspose.HTML in C#. Il tutorial ha coperto il caricamento di una stringa HTML, l'implementazione di un **gestore di risorse personalizzato**, la configurazione delle opzioni di salvataggio e la generazione di un archivio ZIP pronto per la distribuzione o il download.
+
+Da qui puoi:
+
+- Sostituire gli stream segnaposto con contenuto reale (ad esempio, leggere da un database)
+- Passare a un gestore di archiviazione basato su file per documenti molto grandi
+- Integrare la logica negli endpoint ASP.NET Core per download su richiesta
+- Esplorare funzionalità aggiuntive di Aspose.HTML come la conversione PDF o il rendering di immagini
+
+## Cosa dovresti imparare dopo?
+
+I seguenti tutorial coprono argomenti strettamente correlati che si basano sulle tecniche dimostrate in questa guida. Ogni risorsa include esempi di codice completi e funzionanti con spiegazioni passo‑passo per aiutarti a padroneggiare funzionalità API aggiuntive ed esplorare approcci di implementazione alternativi nei tuoi progetti.
+
+- [Salva HTML come ZIP – Tutorial completo C#](/html/english/net/html-extensions-and-conversions/save-html-as-zip-complete-c-tutorial/)
+- [Come salvare HTML in C# – Guida completa usando un gestore di risorse personalizzato](/html/english/net/working-with-html-documents/how-to-save-html-in-c-complete-guide-using-a-custom-resource/)
+- [Crea HTML da stringa in C# – Guida al gestore di risorse personalizzato](/html/english/net/html-document-manipulation/create-html-from-string-in-c-custom-resource-handler-guide/)
+
+{{< /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/generate-jpg-and-png-images/_index.md b/html/japanese/net/generate-jpg-and-png-images/_index.md
index 57de57175f..aa712bf1cc 100644
--- a/html/japanese/net/generate-jpg-and-png-images/_index.md
+++ b/html/japanese/net/generate-jpg-and-png-images/_index.md
@@ -45,6 +45,8 @@ Aspose.HTML for .NET を使用して HTML ドキュメントを操作したり
DOCX 文書を PNG または JPG 画像に変換する際に、アンチエイリアシングを有効にして高品質な出力を得る手順を解説します。
### [DOCX を PNG に変換 – ZIP アーカイブを作成する C# チュートリアル](./convert-docx-to-png-create-zip-archive-c-tutorial/)
C# で DOCX を PNG に変換し、ZIP アーカイブを作成する方法を学びます。
+### [Aspose.HTML を使用して C# で HTML から PNG を作成する](./create-png-from-html-in-c-using-aspose-html/)
+Aspose.HTML for .NET を使用して C# で HTML を PNG 画像に変換する方法を学びます。
## 結論
diff --git a/html/japanese/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md b/html/japanese/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
new file mode 100644
index 0000000000..2bf4f8374a
--- /dev/null
+++ b/html/japanese/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
@@ -0,0 +1,289 @@
+---
+category: general
+date: 2026-08-12
+description: C# と Aspose.HTML を使用して HTML から PNG を作成します。HTML を PNG に変換し、数行のコードで HTML
+ を画像としてレンダリングする方法を学びましょう。
+draft: false
+images:
+- PLACEHOLDER_URL/og-image.png
+keywords:
+- create png from html
+- convert html to png
+- render html as image
+- how to render html to image
+language: ja
+lastmod: 2026-08-12
+og_description: Aspose.HTML を使用して C# で HTML から PNG を作成します。このガイドでは、HTML を画像として迅速にレンダリングする方法を示し、変換オプション、コード設定、トラブルシューティングについて解説します。
+og_image_alt: Screenshot of a C# program converting HTML to a PNG image
+og_title: C#でHTMLからPNGを作成する – ステップバイステップガイド
+schemas:
+- author: Aspose
+ dateModified: '2026-08-12'
+ description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ headline: Create PNG from HTML in C# using Aspose.HTML
+ type: TechArticle
+- description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ name: Create PNG from HTML in C# using Aspose.HTML
+ steps:
+ - name: Why this works
+ text: '- **`HtmlDocument.Open`** parses the HTML string into a DOM that Aspose.HTML
+ can render. - **`ImageRenderingOptions`** lets you control anti‑aliasing, text
+ hinting, and font handling, which are essential when you **render HTML as image**
+ to avoid blurry text. - **`ImageConverter.ConvertHtmlToImage`*'
+ - name: 1. Preparing the HTML source
+ text: You can load HTML from a string (as shown), a local file, or a remote URL.
+ - name: 2. Fine‑tuning rendering options
+ text: '| Option | Effect | When to adjust | |--------|--------|----------------|
+ | `UseAntialiasing` | Reduces jagged edges on vector graphics | Always enable
+ for high‑quality output | | `TextOptions.UseHinting` | Sharpens glyph edges
+ | Important for small font sizes | | `FontOptions.WebFontStyle` | Choose'
+ - name: 3. Performing the conversion
+ text: The `ImageConverter` overload you used writes a single PNG file. If you
+ need multiple pages (e.g., a multi‑page HTML document), use the overload that
+ returns a collection of images.
+ - name: a. Missing fonts
+ text: If the HTML references a custom web font that isn’t installed on the server,
+ the rendered text falls back to a default font, which may affect layout.
+ - name: b. Large pages and memory consumption
+ text: Rendering a very tall page can consume a lot of RAM.
+ - name: c. Transparent backgrounds
+ text: PNG supports transparency, but the default background is white.
+ type: HowTo
+tags:
+- Aspose.HTML
+- C#
+- image rendering
+- HTML conversion
+title: Aspose.HTML を使用して C# で HTML から PNG を作成する
+url: /ja/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/
+---
+
+{{< blocks/products/pf/main-wrap-class >}}
+{{< blocks/products/pf/main-container >}}
+{{< blocks/products/pf/tutorial-page-section >}}
+
+# C#でAspose.HTMLを使用してHTMLからPNGを作成する
+
+.NET アプリケーションで **HTML から PNG を作成** する必要がある場合、このガイドでは全工程を説明します。Aspose.HTML の強力なレンダリングエンジンを使用して、数行の C# コードで **HTML を PNG に変換** する方法が分かります。
+
+HTML を画像としてレンダリングすることは、サムネイルやメールプレビュー、PDF に埋め込む必要があるレポートを生成する際によくある要件です。以下のセクションでは、正確な手順を学び、完全な動作例を確認し、各設定が重要な理由を理解できます。
+
+## 学べること
+
+- 文字列またはファイルから `HtmlDocument` を作成する方法。
+- `ImageRenderingOptions` を設定して品質を向上させる方法。
+- **HTML を PNG に変換**し、結果をディスクに保存する方法。
+- フォント、巨大ページ、カスタム出力パスの取り扱いに関するヒント。
+
+**前提条件**
+- .NET 6.0 SDK（またはそれ以降）がインストールされていること。
+- 有効な Aspose.HTML for .NET ライセンス（または一時評価キー）。
+- C# と Visual Studio、または任意の .NET 対応 IDE の基本的な知識。
+
+---
+
+## Aspose.HTML を使用して HTML から PNG を作成する
+
+最初のステップは環境を設定し、必要な Aspose.HTML 名前空間を参照することです。
+
+```csharp
+using System;
+using Aspose.Html;
+using Aspose.Html.Rendering.Image;
+using Aspose.Html.Drawing;
+using Aspose.Html.Converters;
+
+namespace HtmlToPngDemo
+{
+ class Program
+ {
+ static void Main()
+ {
+ // 1️⃣ Build the HTML document from a raw string.
+ var html = "Bold text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // 2️⃣ Configure rendering options for best visual fidelity. + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, // Smooths edges of drawn shapes + TextOptions = { UseHinting = true }, // Improves glyph clarity + FontOptions = { WebFontStyle = WebFontStyle.Normal } // Uses standard web‑font style + }; + + // 3️⃣ Convert the HTML document to a PNG file. + string outputPath = @"output.png"; + ImageConverter.ConvertHtmlToImage(document, outputPath, renderOptions); + + Console.WriteLine($"PNG image created at: {outputPath}"); + } + } +} +``` + +### なぜこれが機能するのか + +- **`HtmlDocument.Open`** は HTML 文字列を解析し、Aspose.HTML がレンダリングできる DOM に変換します。 +- **`ImageRenderingOptions`** はアンチエイリアス、テキストヒンティング、フォント処理を制御でき、**HTML を画像としてレンダリング** する際に文字がぼやけるのを防ぐために重要です。 +- **`ImageConverter.ConvertHtmlToImage`** は実際の処理を行い、DOM をビットマップにラスタライズして PNG ファイルを書き出します。 + +プログラムを実行すると、HTML ソースで定義された太字の段落がそのまま含まれる `output.png` が生成されます。 + +--- + +## HTML を PNG に変換するステップバイステップ + +以下は各フェーズの詳細な手順です。各行の目的を理解することで、より大きなページや複雑なページにコードを適応させやすくなります。 + +### 1. HTML ソースの準備 + +HTML は文字列（上記参照）、ローカルファイル、またはリモート URL からロードできます。 + +```csharp +// Load from a file +var document = new HtmlDocument(); +document.Open(@"C:\templates\invoice.html"); + +// Load from a URL (requires internet access) +document.Open("https://example.com/report.html"); +``` + +**ヒント:** 外部リソース（CSS、画像）をロードする際は、`BaseUrl` プロパティが正しいフォルダーを指していることを確認し、相対リンクが正しく解決されるようにしてください。 + +### 2. レンダリングオプションの微調整 + +| オプション | 効果 | 調整するタイミング | +|--------|--------|----------------| +| `UseAntialiasing` | ベクターグラフィックのギザギザを減らす | 高品質出力のため常に有効にする | +| `TextOptions.UseHinting` | グリフのエッジを鮮明にする | 小さいフォントサイズで重要 | +| `FontOptions.WebFontStyle` | 通常、イタリック、またはオブリークのウェブフォント描画を選択する | `WebFontStyle.Oblique` を使用すると斜体フォントになる | +| `ResolutionX` / `ResolutionY` | 出力画像の DPI | 印刷用 PNG（例: 300 DPI）にするために増やす | + +DPI を上げる例: + +```csharp +renderOptions.ResolutionX = 300; +renderOptions.ResolutionY = 300; +``` + +### 3. 変換の実行 + +使用した `ImageConverter` のオーバーロードは単一の PNG ファイルを書き出します。複数ページ（例: マルチページ HTML ドキュメント）が必要な場合は、画像コレクションを返すオーバーロードを使用してください。 + +```csharp +ImageConverter.ConvertHtmlToImages(document, "output_folder", renderOptions); +``` + +各ページは `output_folder/page_0.png`、`page_1.png` などのファイルになります。 + +--- + +## HTML を画像としてレンダリング – よくある落とし穴の対処 + +### a. フォントが見つからない場合 + +HTML がサーバーにインストールされていないカスタムウェブフォントを参照している場合、レンダリングされたテキストはデフォルトフォントにフォールバックし、レイアウトに影響を与える可能性があります。 + +**解決策:** CSS の `@font-face` ルールでフォントを埋め込むか、`FontOptions` でローカルフォントフォルダーを指定してください。 + +```csharp +renderOptions.FontOptions.FontFolder = @"C:\fonts"; +``` + +### b. 大きなページとメモリ消費 + +非常に長いページをレンダリングすると、かなりの RAM を消費することがあります。 + +**解決策:** 最大高さを設定するか、変換前にドキュメントをセクションに分割してください。 + +```csharp +renderOptions.PageHeight = 2000; // pixels +``` + +### c. 透明な背景 + +PNG は透過をサポートしていますが、デフォルトの背景色は白です。 + +**解決策:** 背景色を透明に変更してください。 + +```csharp +renderOptions.BackgroundColor = System.Drawing.Color.Transparent; +``` + +--- + +## HTML を画像としてレンダリングする方法 – 完全例のまとめ + +すべてを組み合わせると、最も一般的な要件をカバーする本番環境向けスニペットが以下になります： + +```csharp +using System; +using Aspose.Html; +using Aspose.Html.Rendering.Image; +using Aspose.Html.Drawing; +using Aspose.Html.Converters; + +namespace HtmlToPngDemo +{ + class Program + { + static void Main() + { + // Load HTML (string, file, or URL) + string html = "" + + "Bold blue text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // Configure rendering for high quality and transparency + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, + TextOptions = { UseHinting = true }, + FontOptions = { WebFontStyle = WebFontStyle.Normal, FontFolder = @"C:\fonts" }, + BackgroundColor = System.Drawing.Color.Transparent, + ResolutionX = 150, + ResolutionY = 150 + }; + + // Convert and save + string outPath = @"C:\temp\html_snapshot.png"; + ImageConverter.ConvertHtmlToImage(document, outPath, renderOptions); + + Console.WriteLine($"Image saved to {outPath}"); + } + } +} +``` + +**期待される出力:** 透明なキャンバス上に太字で青い段落が描かれた `html_snapshot.png` ファイルです。画像はアンチエイリアスが適用され、ヒンティングによりテキストが鮮明になります。 + +--- + +## 結論 + +これで、C# で Aspose.HTML を使用して **HTML から PNG を作成** する方法が分かりました。`HtmlDocument` を構築し、`ImageRenderingOptions` を設定し、`ImageConverter.ConvertHtmlToImage` を呼び出すことで、あらゆる自動化シナリオで確実に **HTML を PNG に変換** し、**HTML を画像としてレンダリング** できます。 + +ここからは以下を検討してみてください： + +- 動的なウェブページのサムネイル生成。 +- Aspose.PDF を使用して PNG を PDF に埋め込む。 +- 同じ手法でファイル拡張子を変更すれば JPEG や BMP を生成できる。 + +DPI、背景色、マルチページレンダリングなどを自由に試して、プロジェクトの正確な要件に合わせてください。コーディングを楽しんでください！ + +## 次に学ぶべきことは？ + +以下のチュートリアルは、本ガイドで示した手法に基づく密接に関連するトピックをカバーしています。各リソースには、ステップバイステップの解説付きの完全な動作コード例が含まれており、追加の API 機能を習得し、プロジェクトで代替実装アプローチを検討するのに役立ちます。 + +- [Render HTML as PNG in .NET with Aspose.HTML](/html/english/net/rendering-html-documents/render-html-as-png/) +- [How to Render HTML as PNG – Complete C# Guide](/html/english/net/rendering-html-documents/how-to-render-html-as-png-complete-c-guide/) +- [Create PNG from HTML – Full C# Rendering Guide](/html/english/net/rendering-html-documents/create-png-from-html-full-c-rendering-guide/) + +{{< /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 4110fd8e86..24fbc14ef8 100644 --- a/html/japanese/net/html-extensions-and-conversions/_index.md +++ b/html/japanese/net/html-extensions-and-conversions/_index.md @@ -78,6 +78,8 @@ C# と Aspose.HTML を使用して、HTML コンテンツを Zip アーカイブ ### [C# で HTML を ZIP に保存 – 完全インメモリ例](./save-html-to-zip-in-c-complete-in-memory-example/) Aspose.HTML for .NET を使用して、HTML をメモリ内で ZIP アーカイブに保存する手順をステップバイステップで解説します。 +### [C# で HTML を ZIP に保存する – ステップバイステップ ガイド](./save-html-as-zip-in-c-step-by-step-guide/) + ## 結論 結論として、HTML の拡張と変換は、現代の Web 開発に不可欠な要素です。Aspose.HTML for .NET はプロセスを簡素化し、あらゆるレベルの開発者が利用できるようにします。当社のチュートリアルに従うことで、幅広いスキルを備えた熟練した Web 開発者になるための道を順調に進むことができます。 diff --git a/html/japanese/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md b/html/japanese/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..e336054bb6 --- /dev/null +++ b/html/japanese/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md @@ -0,0 +1,320 @@ +--- +category: general +date: 2026-08-12 +description: Aspose.HTML を使用して HTML を ZIP として保存します。HTML 文字列の読み込み、カスタム リソース ハンドラの作成、そして + ZIP アーカイブを効率的に生成する方法を学びましょう。 +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save html as zip +- load html string +- custom resource handler +language: ja +lastmod: 2026-08-12 +og_description: C# で Aspose.HTML を使用して HTML を ZIP として保存する。このチュートリアルでは、HTML 文字列を読み込み、カスタム + リソース ハンドラを作成し、数ステップで ZIP アーカイブを生成する方法を示します。 +og_image_alt: Diagram showing save html as zip process with custom resource handler +og_title: Aspose.HTMLでHTMLをZIPとして保存 – 完全なC#ガイド +schemas: +- author: Aspose + dateModified: '2026-08-12' + description: Save HTML as ZIP using Aspose.HTML. Learn to load HTML string, create + a custom resource handler, and generate a ZIP archive efficiently. + headline: Save HTML as ZIP in C# – step‑by‑step guide + type: TechArticle +tags: +- Aspose.HTML +- C# +- ZIP archive +title: C#でHTMLをZIP形式で保存する – ステップバイステップガイド +url: /ja/net/html-extensions-and-conversions/save-html-as-zip-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 を ZIP として保存する – ステップバイステップ ガイド + +.NET アプリケーションで **HTML を ZIP として保存** する必要がある場合、このガイドでは完全なワークフローを示します。**HTML 文字列のロード** 方法、**カスタム リソース ハンドラ** の実装、そして中間ファイルをディスクに書き込まずに ZIP アーカイブを生成する方法を学びます。 + +このアプローチは Aspose.HTML 5.x を使用します。高性能なレンダリングエンジンと柔軟な保存オプションを提供します。チュートリアルの最後までに、Web サービス、バックグラウンド ジョブ、またはデスクトップ ツールに統合できる再利用可能なハンドラが手に入ります。 + +## 作成するもの + +最終的なコードは `MemoryStream` ベースの ZIP ファイルを作成し、HTML ドキュメントと参照されたリソース（画像、CSS、フォント）を含みます。ZIP ファイルは対象フォルダーに書き込まれますが、宛先を HTTP API 用のレスポンスストリームに変更することも可能です。 + +## 前提条件 + +- .NET 6.0 以降（サンプルは .NET 6 を対象） +- Aspose.HTML for .NET（NuGet パッケージ `Aspose.HTML`） +- C# の非同期パターンに関する基本的な知識（任意だが役立つ） + +> **プロのコツ:** 開始前に `dotnet add package Aspose.HTML` でパッケージをインストールしてください。 + +## 手順 1: カスタム リソース ハンドラの定義 + +**カスタム リソース ハンドラ** は、HTML レンダラが行うすべての外部リソース要求をインターセプトします。ストリームを返すことで、リソースデータの保存先を制御できます。この例ではすべてメモリに保存し、オンザフライで ZIP アーカイブを作成するのに最適です。 + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +///Hello, world!
+
+
+";
+
+// Create a new document instance.
+HtmlDocument document = new HtmlDocument();
+
+// Load the HTML markup.
+document.Open(htmlContent);
+```
+
+**この手順が重要な理由:**
+**HTML 文字列のロード** 機能は、HTML が動的に生成される場合（例: テンプレートエンジンから）や API から受け取る場合に便利です。ファイルシステムへの依存を回避し、サンドボックス環境でも動作します。
+
+## 手順 3: ハンドラを使用するように保存オプションを構成
+
+Aspose.HTML の `HtmlSaveOptions` を使用すると、出力の保存メカニズムを指定できます。カスタムハンドラを `OutputStorage` プロパティに割り当て、`Compress` フラグを設定して ZIP アーカイブを生成します。
+
+```csharp
+// Instantiate the custom handler.
+var resourceHandler = new InMemoryResourceHandler();
+
+// Prepare save options.
+HtmlSaveOptions saveOptions = new HtmlSaveOptions
+{
+ // Use the handler for all external resources.
+ OutputStorage = resourceHandler,
+
+ // Enable ZIP compression.
+ Compress = true
+};
+```
+
+**この手順が重要な理由:**
+`Compress = true` に設定すると、Aspose.HTML は HTML ファイルとすべての収集されたリソースを単一の ZIP パッケージにまとめます。`OutputStorage` により、リソースは一時的な場所に書き込まれるのではなくメモリ内に保持されます。
+
+## 手順 4: ドキュメントを ZIP アーカイブとして保存
+
+ここで `HtmlDocument.Save` を呼び出し、保存先パスと構成したオプションを渡します。保存後、ZIP ファイルには `index.html` とハンドラが取得したすべてのリソースが含まれます。
+
+```csharp
+// Define the output path (you can change this to a response stream for web APIs).
+string outputPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+
+// Save the document; Aspose.HTML creates the ZIP automatically.
+document.Save(outputPath, saveOptions);
+
+// Optional: Verify the resources that were stored.
+foreach (var entry in resourceHandler.Resources)
+{
+ Console.WriteLine($"Resource: {entry.Key}, Size: {entry.Value.Length} bytes");
+}
+```
+
+**期待される結果:**
+プログラムを実行すると、現在のディレクトリに `output.zip` が作成されます。アーカイブを展開すると以下が表示されます:
+
+```
+index.html
+styles.css
+logo.png
+```
+
+各ファイルはマークアップの参照と一致し、`index.html` 内の HTML はバンドルされたリソースを指しています。
+
+## 手順 5: 実際のリソース データ用にハンドラを適応（上級）
+
+上記の基本ハンドラは空のストリームを作成します。本番環境では実際のコンテンツ（例: `styles.css` や `logo.png` のバイト）を書き込む必要があります。`HandleResource` を拡張して、データベース、クラウドバケット、または埋め込みリソースからデータを取得できるようにします。
+
+```csharp
+public override Stream HandleResource(ResourceInfo info)
+{
+ // Example: Load resource from an embedded folder.
+ string resourcePath = Path.Combine("EmbeddedResources", info.Path);
+ byte[] data = File.ReadAllBytes(resourcePath);
+
+ // Write data into a memory stream.
+ var stream = new MemoryStream(data);
+ _resources[info.Path] = stream;
+
+ // Return the populated stream.
+ return stream;
+}
+```
+
+**このバリエーションが重要な理由:**
+実際のコンテンツを提供することで、ブラウザで開いたときに ZIP アーカイブが正しく機能します。ハンドラはストリームに書き込む前に変換（例: CSS の縮小）を適用することもできます。
+
+## 手順 6: Web API で ZIP アーカイブを使用（オプション）
+
+ASP.NET Core で機能を公開する場合、ZIP ファイルをファイル結果として返します:
+
+```csharp
+[HttpGet("download")]
+public IActionResult DownloadZip()
+{
+ // Reuse the same logic from steps 1‑4.
+ // ...
+
+ // Read the generated ZIP into a byte array.
+ byte[] zipBytes = System.IO.File.ReadAllBytes(outputPath);
+
+ // Return the file with the appropriate content type.
+ return File(zipBytes, "application/zip", "document.zip");
+}
+```
+
+**この手順が重要な理由:**
+クライアントはサーバー上の一時ファイルを扱うことなく、パッケージ化された HTML をダウンロードできます。このアプローチはディスクアクセスが制限されたサーバーレス関数でも機能します。
+
+## よくある落とし穴と回避策
+
+| Pitfall | Reason | Fix |
+|---------|--------|-----|
+| ZIP 内の空リソース | ハンドラがデータを書き込まずに新しい `MemoryStream` を返す | 返す前にストリームに実際のバイトを入力する |
+| `index.html` エントリが欠如 | `Compress` フラグが設定されていない、または `OutputStorage` が割り当てられていない | `saveOptions.Compress = true` と `saveOptions.OutputStorage = handler` を確実に設定する |
+| 大きな HTML によるメモリ圧迫 | すべてのリソースがメモリに保持される | 一時フォルダーに書き込む `FileStorage` 実装に切り替える |
+| 抽出後に相対 URL が壊れる | 絶対 URL が参照され、保存されていない | ハンドラ内またはポストプロセス時に URL を相対パスに書き換える |
+
+## 完全な実行可能サンプル
+
+```csharp
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Saving;
+
+class InMemoryResourceHandler : ResourceHandler
+{
+ private readonly DictionaryHello, world!
+
+
+ ";
+
+ HtmlDocument doc = new HtmlDocument();
+ doc.Open(html);
+
+ // Step 1 & 3: Create handler and configure save options.
+ var handler = new InMemoryResourceHandler();
+ HtmlSaveOptions options = new HtmlSaveOptions
+ {
+ OutputStorage = handler,
+ Compress = true
+ };
+
+ // Step 4: Save as ZIP.
+ string zipPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+ doc.Save(zipPath, options);
+ Console.WriteLine($"ZIP file created at: {zipPath}");
+
+ // Optional verification.
+ foreach (var kvp in handler.Resources)
+ {
+ Console.WriteLine($"Resource {kvp.Key} captured, length {kvp.Value.Length} bytes");
+ }
+ }
+}
+```
+
+プログラムを実行すると、実行ファイルの隣に `output.zip` が生成されます。アーカイブを展開すると `index.html`、`styles.css`、`logo.png`（この最小例では空のプレースホルダー）が表示されます。
+
+## 結論
+
+これで、C# で Aspose.HTML を使用して **HTML を ZIP として保存** する信頼できる方法が手に入りました。このチュートリアルでは、HTML 文字列のロード、**カスタム リソース ハンドラ** の実装、保存オプションの構成、配布やダウンロード用の ZIP アーカイブ生成について解説しました。
+
+ここからは以下が可能です:
+
+- プレースホルダーのストリームを実際のコンテンツに置き換える（例: データベースから読み込む）
+- 非常に大きなドキュメント向けにファイルベースのストレージハンドラに切り替える
+- ロジックを ASP.NET Core エンドポイントに統合し、オンデマンドでダウンロードできるようにする
+- PDF 変換や画像レンダリングなど、Aspose.HTML の追加機能を探求する
+
+さまざまなリソースソースや圧縮設定を試して、パフォーマンスとサイズ要件に合わせてソリューションを調整してください。コーディングを楽しんでください！
+
+## 次に学ぶべきことは？
+
+以下のチュートリアルは、本ガイドで示した手法を基にした密接に関連するトピックを取り上げています。各リソースには、ステップバイステップの解説と完全な動作コード例が含まれており、追加の API 機能を習得し、独自プロジェクトで代替実装アプローチを検討するのに役立ちます。
+
+- [HTML を ZIP として保存 – 完全な C# チュートリアル](/html/english/net/html-extensions-and-conversions/save-html-as-zip-complete-c-tutorial/)
+- [C# で HTML を保存する方法 – カスタム リソース ハンドラを使用した完全ガイド](/html/english/net/working-with-html-documents/how-to-save-html-in-c-complete-guide-using-a-custom-resource/)
+- [C# で文字列から HTML を作成 – カスタム リソース ハンドラ ガイド](/html/english/net/html-document-manipulation/create-html-from-string-in-c-custom-resource-handler-guide/)
+
+{{< /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/generate-jpg-and-png-images/_index.md b/html/korean/net/generate-jpg-and-png-images/_index.md
index 2f2fd11d08..e6f04ceea4 100644
--- a/html/korean/net/generate-jpg-and-png-images/_index.md
+++ b/html/korean/net/generate-jpg-and-png-images/_index.md
@@ -45,6 +45,7 @@ Aspose.HTML for .NET을 .NET 프로젝트에 통합하는 것은 번거롭지
DOCX 문서를 PNG 또는 JPG 이미지로 변환할 때 안티앨리어싱을 적용하는 방법을 단계별로 안내합니다.
### [DOCX를 PNG로 변환하고 ZIP 아카이브 만들기 C# 튜토리얼](./convert-docx-to-png-create-zip-archive-c-tutorial/)
C#을 사용해 DOCX 파일을 PNG 이미지로 변환하고, 결과를 ZIP 파일로 압축하는 방법을 단계별로 안내합니다.
+### [Aspose.HTML을 사용하여 C#에서 HTML을 PNG로 생성](./create-png-from-html-in-c-using-aspose-html/)
## 결론
diff --git a/html/korean/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md b/html/korean/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
new file mode 100644
index 0000000000..bbbd3f14f3
--- /dev/null
+++ b/html/korean/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
@@ -0,0 +1,290 @@
+---
+category: general
+date: 2026-08-12
+description: Aspose.HTML을 사용하여 C#에서 HTML을 PNG로 만들기. HTML을 PNG로 변환하고 몇 줄의 코드만으로 HTML을
+ 이미지로 렌더링하는 방법을 배워보세요.
+draft: false
+images:
+- PLACEHOLDER_URL/og-image.png
+keywords:
+- create png from html
+- convert html to png
+- render html as image
+- how to render html to image
+language: ko
+lastmod: 2026-08-12
+og_description: C#에서 Aspose.HTML을 사용하여 HTML을 PNG로 만들기. 이 가이드는 HTML을 이미지로 빠르게 렌더링하는
+ 방법을 보여주며, 변환 옵션, 코드 설정 및 문제 해결을 다룹니다.
+og_image_alt: Screenshot of a C# program converting HTML to a PNG image
+og_title: C#에서 HTML을 PNG로 만들기 – 단계별 가이드
+schemas:
+- author: Aspose
+ dateModified: '2026-08-12'
+ description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ headline: Create PNG from HTML in C# using Aspose.HTML
+ type: TechArticle
+- description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ name: Create PNG from HTML in C# using Aspose.HTML
+ steps:
+ - name: Why this works
+ text: '- **`HtmlDocument.Open`** parses the HTML string into a DOM that Aspose.HTML
+ can render. - **`ImageRenderingOptions`** lets you control anti‑aliasing, text
+ hinting, and font handling, which are essential when you **render HTML as image**
+ to avoid blurry text. - **`ImageConverter.ConvertHtmlToImage`*'
+ - name: 1. Preparing the HTML source
+ text: You can load HTML from a string (as shown), a local file, or a remote URL.
+ - name: 2. Fine‑tuning rendering options
+ text: '| Option | Effect | When to adjust | |--------|--------|----------------|
+ | `UseAntialiasing` | Reduces jagged edges on vector graphics | Always enable
+ for high‑quality output | | `TextOptions.UseHinting` | Sharpens glyph edges
+ | Important for small font sizes | | `FontOptions.WebFontStyle` | Choose'
+ - name: 3. Performing the conversion
+ text: The `ImageConverter` overload you used writes a single PNG file. If you
+ need multiple pages (e.g., a multi‑page HTML document), use the overload that
+ returns a collection of images.
+ - name: a. Missing fonts
+ text: If the HTML references a custom web font that isn’t installed on the server,
+ the rendered text falls back to a default font, which may affect layout.
+ - name: b. Large pages and memory consumption
+ text: Rendering a very tall page can consume a lot of RAM.
+ - name: c. Transparent backgrounds
+ text: PNG supports transparency, but the default background is white.
+ type: HowTo
+tags:
+- Aspose.HTML
+- C#
+- image rendering
+- HTML conversion
+title: Aspose.HTML을 사용하여 C#에서 HTML을 PNG로 만들기
+url: /ko/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/
+---
+
+{{< blocks/products/pf/main-wrap-class >}}
+{{< blocks/products/pf/main-container >}}
+{{< blocks/products/pf/tutorial-page-section >}}
+
+# Aspose.HTML을 사용한 C#에서 HTML을 PNG로 만들기
+
+.NET 애플리케이션에서 **HTML을 PNG로 만들** 필요가 있다면, 이 가이드는 전체 과정을 안내합니다. Aspose.HTML의 강력한 렌더링 엔진을 사용하여 몇 줄의 C# 코드만으로 **HTML을 PNG로 변환**하는 방법을 확인할 수 있습니다.
+
+HTML을 이미지로 렌더링하는 것은 썸네일, 이메일 미리보기, 또는 PDF에 삽입해야 하는 보고서를 생성할 때 흔히 필요한 작업입니다. 다음 섹션에서는 정확한 단계들을 배우고, 전체 작업 예제를 확인하며, 각 설정이 왜 중요한지 이해하게 됩니다.
+
+## 배울 내용
+
+- 문자열이나 파일에서 `HtmlDocument`를 만드는 방법.
+- `ImageRenderingOptions`를 구성하여 품질을 향상시키는 방법.
+- **HTML을 PNG로 변환**하고 결과를 디스크에 저장하는 방법.
+- 폰트, 큰 페이지, 사용자 지정 출력 경로를 처리하기 위한 팁.
+
+**전제 조건**
+- .NET 6.0 SDK(또는 그 이후 버전) 설치.
+- 유효한 Aspose.HTML for .NET 라이선스(또는 임시 평가 키).
+- C# 및 Visual Studio 또는 .NET 호환 IDE에 대한 기본 지식.
+
+---
+
+## Aspose.HTML을 사용한 HTML에서 PNG 만들기
+
+첫 번째 단계는 환경을 설정하고 필요한 Aspose.HTML 네임스페이스를 참조하는 것입니다.
+
+```csharp
+using System;
+using Aspose.Html;
+using Aspose.Html.Rendering.Image;
+using Aspose.Html.Drawing;
+using Aspose.Html.Converters;
+
+namespace HtmlToPngDemo
+{
+ class Program
+ {
+ static void Main()
+ {
+ // 1️⃣ Build the HTML document from a raw string.
+ var html = "Bold text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // 2️⃣ Configure rendering options for best visual fidelity. + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, // Smooths edges of drawn shapes + TextOptions = { UseHinting = true }, // Improves glyph clarity + FontOptions = { WebFontStyle = WebFontStyle.Normal } // Uses standard web‑font style + }; + + // 3️⃣ Convert the HTML document to a PNG file. + string outputPath = @"output.png"; + ImageConverter.ConvertHtmlToImage(document, outputPath, renderOptions); + + Console.WriteLine($"PNG image created at: {outputPath}"); + } + } +} +``` + +### 왜 이렇게 동작하는가 + +- `HtmlDocument.Open`은 HTML 문자열을 Aspose.HTML이 렌더링할 수 있는 DOM으로 파싱합니다. +- `ImageRenderingOptions`를 사용하면 안티앨리어싱, 텍스트 힌팅, 폰트 처리를 제어할 수 있으며, 이는 **HTML을 이미지로 렌더링**할 때 흐릿한 텍스트를 방지하는 데 필수적입니다. +- `ImageConverter.ConvertHtmlToImage`는 핵심 작업을 수행합니다: DOM을 비트맵으로 래스터화하고 PNG 파일을 작성합니다. + +프로그램을 실행하면 HTML 소스에 정의된 대로 굵은 단락을 포함한 `output.png`가 생성됩니다. + +--- + +## HTML을 PNG로 변환 단계별 가이드 + +아래는 각 단계에 대한 자세한 설명입니다. 각 줄의 목적을 이해하면 더 크거나 복잡한 페이지에 코드를 적용하는 데 도움이 됩니다. + +### 1. HTML 소스 준비 + +HTML을 문자열(예시와 같이), 로컬 파일 또는 원격 URL에서 로드할 수 있습니다. + +```csharp +// Load from a file +var document = new HtmlDocument(); +document.Open(@"C:\templates\invoice.html"); + +// Load from a URL (requires internet access) +document.Open("https://example.com/report.html"); +``` + +**팁:** 외부 리소스(CSS, 이미지)를 로드할 때 `BaseUrl` 속성이 올바른 폴더를 가리키도록 하여 상대 링크가 올바르게 해석되도록 합니다. + +### 2. 렌더링 옵션 미세 조정 + +| 옵션 | 효과 | 조정 시점 | +|--------|--------|----------------| +| `UseAntialiasing` | 벡터 그래픽의 톱니 모양 가장자리를 감소시킴 | 고품질 출력 시 항상 활성화 | +| `TextOptions.UseHinting` | 글리프 가장자리를 선명하게 함 | 작은 폰트 크기에서 중요 | +| `FontOptions.WebFontStyle` | 일반, 이탤릭, 또는 기울임 웹 폰트 렌더링 선택 | `WebFontStyle.Oblique`를 사용하면 기울어진 폰트에 적용 | +| `ResolutionX` / `ResolutionY` | 출력 이미지의 DPI | 인쇄용 PNG(예: 300 DPI) 필요 시 증가 | + +DPI를 증가시키는 예시: + +```csharp +renderOptions.ResolutionX = 300; +renderOptions.ResolutionY = 300; +``` + +### 3. 변환 수행 + +`ImageConverter` 오버로드를 사용하면 단일 PNG 파일을 작성합니다. 여러 페이지(예: 다중 페이지 HTML 문서)가 필요하면 이미지 컬렉션을 반환하는 오버로드를 사용하십시오. + +```csharp +ImageConverter.ConvertHtmlToImages(document, "output_folder", renderOptions); +``` + +각 페이지는 `output_folder/page_0.png`, `page_1.png` 등으로 저장됩니다. + +--- + +## HTML을 이미지로 렌더링 – 일반적인 함정 처리 + +### a. 폰트 누락 + +HTML이 서버에 설치되지 않은 사용자 정의 웹 폰트를 참조하면, 렌더링된 텍스트가 기본 폰트로 대체되어 레이아웃에 영향을 줄 수 있습니다. + +**Solution:** `@font-face` 규칙을 CSS에 삽입하거나 `FontOptions`를 통해 로컬 폰트 폴더를 제공하여 폰트를 포함시킵니다. + +```csharp +renderOptions.FontOptions.FontFolder = @"C:\fonts"; +``` + +### b. 큰 페이지와 메모리 사용량 + +매우 긴 페이지를 렌더링하면 많은 RAM을 사용할 수 있습니다. + +**Solution:** 최대 높이를 설정하거나 변환 전에 문서를 섹션으로 나누세요. + +```csharp +renderOptions.PageHeight = 2000; // pixels +``` + +### c. 투명 배경 + +PNG는 투명성을 지원하지만 기본 배경은 흰색입니다. + +**Solution:** 배경 색상을 투명으로 변경합니다. + +```csharp +renderOptions.BackgroundColor = System.Drawing.Color.Transparent; +``` + +--- + +## HTML을 이미지로 렌더링 – 전체 예제 요약 + +모든 것을 합치면, 가장 일반적인 요구 사항을 다루는 프로덕션 수준의 코드 스니펫은 다음과 같습니다: + +```csharp +using System; +using Aspose.Html; +using Aspose.Html.Rendering.Image; +using Aspose.Html.Drawing; +using Aspose.Html.Converters; + +namespace HtmlToPngDemo +{ + class Program + { + static void Main() + { + // Load HTML (string, file, or URL) + string html = "" + + "Bold blue text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // Configure rendering for high quality and transparency + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, + TextOptions = { UseHinting = true }, + FontOptions = { WebFontStyle = WebFontStyle.Normal, FontFolder = @"C:\fonts" }, + BackgroundColor = System.Drawing.Color.Transparent, + ResolutionX = 150, + ResolutionY = 150 + }; + + // Convert and save + string outPath = @"C:\temp\html_snapshot.png"; + ImageConverter.ConvertHtmlToImage(document, outPath, renderOptions); + + Console.WriteLine($"Image saved to {outPath}"); + } + } +} +``` + +**예상 출력:** 투명 캔버스에 굵고 파란색 단락이 포함된 `html_snapshot.png` 파일입니다. 이미지가 안티앨리어싱되고 힌팅 덕분에 선명한 텍스트를 가집니다. + +--- + +## 결론 + +이제 Aspose.HTML을 사용하여 C#에서 **HTML을 PNG로 만들** 수 있는 방법을 알게 되었습니다. `HtmlDocument`를 구성하고 `ImageRenderingOptions`를 설정한 뒤 `ImageConverter.ConvertHtmlToImage`를 호출하면, 어떤 자동화 시나리오에서도 **HTML을 PNG로 변환**하고 **HTML을 이미지로 렌더링**할 수 있습니다. + +다음과 같은 주제를 탐색해 볼 수 있습니다: + +- 동적 웹 페이지에 대한 썸네일 생성. +- Aspose.PDF를 사용해 PNG를 PDF에 삽입. +- 파일 확장자를 변경하여 JPEG 또는 BMP를 생성하는 동일한 방법 사용. + +프로젝트의 정확한 요구에 맞게 DPI, 배경 색상, 다중 페이지 렌더링을 자유롭게 실험해 보세요. 즐거운 코딩 되세요! + +## 다음에 배울 내용은? + +다음 튜토리얼은 이 가이드에서 보여준 기술을 기반으로 하는 밀접한 관련 주제를 다룹니다. 각 자료에는 단계별 설명과 함께 완전한 코드 예제가 포함되어 있어 추가 API 기능을 마스터하고 프로젝트에서 대체 구현 방식을 탐색하는 데 도움이 됩니다. + +- [Aspose.HTML을 사용한 .NET에서 HTML을 PNG로 렌더링](/html/english/net/rendering-html-documents/render-html-as-png/) +- [HTML을 PNG로 렌더링하는 방법 – 완전한 C# 가이드](/html/english/net/rendering-html-documents/how-to-render-html-as-png-complete-c-guide/) +- [HTML에서 PNG 만들기 – 전체 C# 렌더링 가이드](/html/english/net/rendering-html-documents/create-png-from-html-full-c-rendering-guide/) + +{{< /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 38fc3bd7e6..8a57bc3747 100644 --- a/html/korean/net/html-extensions-and-conversions/_index.md +++ b/html/korean/net/html-extensions-and-conversions/_index.md @@ -67,6 +67,8 @@ Aspose.HTML for .NET을 사용하여 HTML을 TIFF로 변환하는 방법을 알 .NET용 Aspose.HTML의 힘을 알아보세요: HTML을 XPS로 손쉽게 변환하세요. 필수 조건, 단계별 가이드, FAQ가 포함되어 있습니다. ### [C#에서 HTML을 Zip으로 압축하는 방법 – HTML을 Zip으로 저장](./how-to-zip-html-in-c-save-html-to-zip/) C#과 Aspose.HTML을 사용해 HTML 파일을 ZIP 압축 파일로 저장하는 단계별 가이드를 제공합니다. +### [C#에서 HTML을 ZIP으로 저장하는 단계별 가이드](./save-html-as-zip-in-c-step-by-step-guide/) +C#과 Aspose.HTML을 활용해 HTML을 ZIP 파일로 저장하는 자세한 단계별 가이드를 제공합니다. ### [스타일이 적용된 텍스트로 HTML 문서 만들기 및 PDF로 내보내기 – 전체 가이드](./create-html-document-with-styled-text-and-export-to-pdf-full/) Aspose.HTML for .NET을 사용하여 스타일이 적용된 텍스트가 포함된 HTML 문서를 만들고 PDF로 내보내는 전체 가이드를 확인하세요. ### [HTML을 ZIP으로 저장 – 전체 C# 튜토리얼](./save-html-as-zip-complete-c-tutorial/) diff --git a/html/korean/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md b/html/korean/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..33d6f893b2 --- /dev/null +++ b/html/korean/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md @@ -0,0 +1,320 @@ +--- +category: general +date: 2026-08-12 +description: Aspose.HTML을 사용하여 HTML을 ZIP으로 저장합니다. HTML 문자열을 로드하고, 사용자 정의 리소스 핸들러를 + 생성하며, ZIP 아카이브를 효율적으로 생성하는 방법을 배웁니다. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save html as zip +- load html string +- custom resource handler +language: ko +lastmod: 2026-08-12 +og_description: C#에서 Aspose.HTML을 사용해 HTML을 ZIP으로 저장합니다. 이 튜토리얼에서는 HTML 문자열을 로드하고, + 사용자 지정 리소스 핸들러를 만든 뒤, 몇 단계만에 ZIP 아카이브를 생성하는 방법을 보여줍니다. +og_image_alt: Diagram showing save html as zip process with custom resource handler +og_title: Aspose.HTML로 HTML을 ZIP으로 저장 – 완전한 C# 가이드 +schemas: +- author: Aspose + dateModified: '2026-08-12' + description: Save HTML as ZIP using Aspose.HTML. Learn to load HTML string, create + a custom resource handler, and generate a ZIP archive efficiently. + headline: Save HTML as ZIP in C# – step‑by‑step guide + type: TechArticle +tags: +- Aspose.HTML +- C# +- ZIP archive +title: C#에서 HTML을 ZIP으로 저장하기 – 단계별 가이드 +url: /ko/net/html-extensions-and-conversions/save-html-as-zip-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을 ZIP으로 저장하기 – 단계별 가이드 + +.NET 애플리케이션에서 **HTML을 ZIP으로 저장**해야 할 경우, 이 가이드는 전체 워크플로를 보여줍니다. **HTML 문자열 로드**, **커스텀 리소스 핸들러** 구현, 그리고 중간 파일을 디스크에 쓰지 않고 ZIP 아카이브를 생성하는 방법을 배울 수 있습니다. + +이 접근 방식은 고성능 렌더링 엔진과 유연한 저장 옵션을 제공하는 Aspose.HTML 5.x를 사용합니다. 튜토리얼을 마치면 웹 서비스, 백그라운드 작업, 데스크톱 도구 등에 통합할 수 있는 재사용 가능한 핸들러를 얻게 됩니다. + +## 만들게 될 내용 + +최종 코드는 `MemoryStream` 기반 ZIP 파일을 생성합니다. 이 파일에는 HTML 문서와 참조된 모든 리소스(이미지, CSS, 폰트)가 포함됩니다. ZIP 파일은 대상 폴더에 기록되지만, HTTP API용 응답 스트림으로 변경할 수도 있습니다. + +## 사전 요구 사항 + +- .NET 6.0 이상 (.NET 6을 목표로 함) +- Aspose.HTML for .NET (NuGet 패키지 `Aspose.HTML`) +- C# 비동기 패턴에 대한 기본 지식 (선택 사항이지만 도움이 됨) + +> **전문가 팁:** 시작하기 전에 `dotnet add package Aspose.HTML` 명령으로 패키지를 설치하세요. + +## 1단계: 커스텀 리소스 핸들러 정의 + +**커스텀 리소스 핸들러**는 HTML 렌더러가 외부 리소스를 요청할 때마다 이를 가로챕니다. 스트림을 반환함으로써 리소스 데이터가 저장되는 위치를 제어할 수 있습니다. 예제에서는 모든 데이터를 메모리에 저장하므로, 즉시 ZIP 아카이브를 만들기에 이상적입니다. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +///Hello, world!
+
+
+";
+
+// Create a new document instance.
+HtmlDocument document = new HtmlDocument();
+
+// Load the HTML markup.
+document.Open(htmlContent);
+```
+
+**이 단계가 중요한 이유:**
+**load html string** 기능은 HTML이 템플릿 엔진에서 동적으로 생성되거나 API에서 전달될 때 유용합니다. 파일 시스템 의존성을 없애고 샌드박스 환경에서도 동작합니다.
+
+## 3단계: 핸들러를 사용하도록 저장 옵션 구성
+
+Aspose.HTML의 `HtmlSaveOptions`를 사용하면 출력에 대한 저장 메커니즘을 지정할 수 있습니다. 커스텀 핸들러를 `OutputStorage` 속성에 할당하고, `Compress` 플래그를 설정해 ZIP 아카이브를 생성합니다.
+
+```csharp
+// Instantiate the custom handler.
+var resourceHandler = new InMemoryResourceHandler();
+
+// Prepare save options.
+HtmlSaveOptions saveOptions = new HtmlSaveOptions
+{
+ // Use the handler for all external resources.
+ OutputStorage = resourceHandler,
+
+ // Enable ZIP compression.
+ Compress = true
+};
+```
+
+**이 단계가 중요한 이유:**
+`Compress = true`는 Aspose.HTML에게 HTML 파일과 수집된 모든 리소스를 하나의 ZIP 패키지로 묶으라고 지시합니다. `OutputStorage`는 리소스가 임시 위치가 아니라 메모리 안에 캡처되도록 보장합니다.
+
+## 4단계: 문서를 ZIP 아카이브로 저장
+
+이제 `HtmlDocument.Save`를 호출하고 대상 경로와 구성된 옵션을 전달합니다. 저장이 완료되면 ZIP 파일에는 `index.html`과 핸들러가 캡처한 모든 리소스가 들어 있습니다.
+
+```csharp
+// Define the output path (you can change this to a response stream for web APIs).
+string outputPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+
+// Save the document; Aspose.HTML creates the ZIP automatically.
+document.Save(outputPath, saveOptions);
+
+// Optional: Verify the resources that were stored.
+foreach (var entry in resourceHandler.Resources)
+{
+ Console.WriteLine($"Resource: {entry.Key}, Size: {entry.Value.Length} bytes");
+}
+```
+
+**예상 결과:**
+프로그램을 실행하면 현재 디렉터리에 `output.zip`이 생성됩니다. 아카이브를 풀면 다음과 같은 구조가 나타납니다.
+
+```
+index.html
+styles.css
+logo.png
+```
+
+각 파일은 마크업에서 참조된 리소스와 일치하며, `index.html` 내부의 HTML은 번들된 리소스를 가리킵니다.
+
+## 5단계: 실제 리소스 데이터를 위한 핸들러 확장 (고급)
+
+위의 기본 핸들러는 빈 스트림을 생성합니다. 실제 환경에서는 `styles.css`나 `logo.png`와 같은 실제 콘텐츠를 기록해야 합니다. `HandleResource`를 확장해 데이터베이스, 클라우드 버킷, 임베디드 리소스 등에서 데이터를 가져오도록 구현하세요.
+
+```csharp
+public override Stream HandleResource(ResourceInfo info)
+{
+ // Example: Load resource from an embedded folder.
+ string resourcePath = Path.Combine("EmbeddedResources", info.Path);
+ byte[] data = File.ReadAllBytes(resourcePath);
+
+ // Write data into a memory stream.
+ var stream = new MemoryStream(data);
+ _resources[info.Path] = stream;
+
+ // Return the populated stream.
+ return stream;
+}
+```
+
+**이 변형이 중요한 이유:**
+실제 콘텐츠를 제공하면 ZIP 아카이브를 브라우저에서 열었을 때 정상적으로 동작합니다. 핸들러에서 CSS 압축(minify) 등 변환 작업을 수행할 수도 있습니다.
+
+## 6단계: 웹 API에서 ZIP 아카이브 사용 (선택)
+
+ASP.NET Core를 통해 기능을 노출한다면, ZIP 파일을 파일 결과로 반환할 수 있습니다.
+
+```csharp
+[HttpGet("download")]
+public IActionResult DownloadZip()
+{
+ // Reuse the same logic from steps 1‑4.
+ // ...
+
+ // Read the generated ZIP into a byte array.
+ byte[] zipBytes = System.IO.File.ReadAllBytes(outputPath);
+
+ // Return the file with the appropriate content type.
+ return File(zipBytes, "application/zip", "document.zip");
+}
+```
+
+**이 단계가 중요한 이유:**
+클라이언트는 서버의 임시 파일을 다루지 않고도 패키징된 HTML을 다운로드할 수 있습니다. 디스크 접근이 제한된 서버리스 함수에서도 이 접근 방식이 유용합니다.
+
+## 흔히 겪는 문제와 해결 방법
+
+| 문제 | 원인 | 해결 방법 |
+|------|------|-----------|
+| ZIP에 리소스가 비어 있음 | 핸들러가 데이터를 쓰지 않은 새 `MemoryStream`을 반환 | 스트림에 실제 바이트를 채운 후 반환 |
+| `index.html` 항목이 없음 | `Compress` 플래그가 설정되지 않았거나 `OutputStorage`가 할당되지 않음 | `saveOptions.Compress = true`와 `saveOptions.OutputStorage = handler`를 확인 |
+| 큰 HTML로 인한 메모리 압박 | 모든 리소스를 메모리에 보관 | 임시 폴더에 쓰는 `FileStorage` 구현으로 전환 |
+| 추출 후 상대 URL이 깨짐 | 절대 URL을 사용해 저장되지 않은 리소스 | 핸들러에서 URL을 상대 경로로 변환하거나 후처리 단계에서 수정 |
+
+## 전체 실행 가능한 예제
+
+```csharp
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Saving;
+
+class InMemoryResourceHandler : ResourceHandler
+{
+ private readonly DictionaryHello, world!
+
+
+ ";
+
+ HtmlDocument doc = new HtmlDocument();
+ doc.Open(html);
+
+ // Step 1 & 3: Create handler and configure save options.
+ var handler = new InMemoryResourceHandler();
+ HtmlSaveOptions options = new HtmlSaveOptions
+ {
+ OutputStorage = handler,
+ Compress = true
+ };
+
+ // Step 4: Save as ZIP.
+ string zipPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+ doc.Save(zipPath, options);
+ Console.WriteLine($"ZIP file created at: {zipPath}");
+
+ // Optional verification.
+ foreach (var kvp in handler.Resources)
+ {
+ Console.WriteLine($"Resource {kvp.Key} captured, length {kvp.Value.Length} bytes");
+ }
+ }
+}
+```
+
+프로그램을 실행하면 실행 파일 옆에 `output.zip`이 생성됩니다. 아카이브를 풀면 `index.html`, `styles.css`, `logo.png`(이 최소 예제에서는 빈 플레이스홀더)가 포함됩니다.
+
+## 결론
+
+이제 Aspose.HTML을 사용해 C#에서 **HTML을 ZIP으로 저장**하는 신뢰할 수 있는 방법을 익혔습니다. 튜토리얼에서는 HTML 문자열 로드, **커스텀 리소스 핸들러** 구현, 저장 옵션 구성, 그리고 배포 또는 다운로드용 ZIP 아카이브 생성까지 다루었습니다.
+
+다음 단계로 할 수 있는 일:
+
+- 플레이스홀더 스트림을 실제 콘텐츠(예: 데이터베이스에서 읽기)로 교체
+- 매우 큰 문서의 경우 파일 기반 스토리지 핸들러로 전환
+- ASP.NET Core 엔드포인트에 로직을 통합해 필요 시 다운로드 제공
+- PDF 변환이나 이미지 렌더링 등 추가 Aspose.HTML 기능 탐색
+
+다양한 리소스 소스와 압축 설정을 실험해 성능 및 크기 요구사항에 맞게 솔루션을 조정해 보세요. 즐거운 코딩 되세요!
+
+## 다음에 배워야 할 내용
+
+다음 튜토리얼은 이 가이드에서 다룬 기술을 기반으로 하며, 추가 API 기능을 마스터하고 프로젝트에 다양한 구현 방식을 적용하는 데 도움이 됩니다.
+
+- [Save HTML as ZIP – Complete C# Tutorial](/html/english/net/html-extensions-and-conversions/save-html-as-zip-complete-c-tutorial/)
+- [How to Save HTML in C# – Complete Guide Using a Custom Resource Handler](/html/english/net/working-with-html-documents/how-to-save-html-in-c-complete-guide-using-a-custom-resource/)
+- [Create HTML from String in C# – Custom Resource Handler Guide](/html/english/net/html-document-manipulation/create-html-from-string-in-c-custom-resource-handler-guide/)
+
+{{< /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/generate-jpg-and-png-images/_index.md b/html/polish/net/generate-jpg-and-png-images/_index.md
index fff5f7a92b..75dba9e78d 100644
--- a/html/polish/net/generate-jpg-and-png-images/_index.md
+++ b/html/polish/net/generate-jpg-and-png-images/_index.md
@@ -45,6 +45,8 @@ Naucz się używać Aspose.HTML dla .NET do manipulowania dokumentami HTML, konw
Dowiedz się, jak włączyć antyaliasing przy konwersji dokumentów DOCX do formatów PNG i JPG przy użyciu Aspose.HTML.
### [Konwertuj docx do png – utwórz archiwum zip w C# – samouczek](./convert-docx-to-png-create-zip-archive-c-tutorial/)
Dowiedz się, jak konwertować pliki DOCX na obrazy PNG i spakować je do archiwum ZIP przy użyciu C# i Aspose.HTML.
+### [Utwórz PNG z HTML w C# przy użyciu Aspose.HTML](./create-png-from-html-in-c-using-aspose-html/)
+Dowiedz się, jak wygenerować plik PNG z kodu HTML w C# przy użyciu biblioteki Aspose.HTML.
## Wniosek
diff --git a/html/polish/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md b/html/polish/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
new file mode 100644
index 0000000000..10919c9378
--- /dev/null
+++ b/html/polish/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
@@ -0,0 +1,291 @@
+---
+category: general
+date: 2026-08-12
+description: Utwórz PNG z HTML w C# przy użyciu Aspose.HTML. Dowiedz się, jak przekonwertować
+ HTML na PNG i renderować HTML jako obraz w zaledwie kilku linijkach kodu.
+draft: false
+images:
+- PLACEHOLDER_URL/og-image.png
+keywords:
+- create png from html
+- convert html to png
+- render html as image
+- how to render html to image
+language: pl
+lastmod: 2026-08-12
+og_description: Utwórz PNG z HTML w C# przy użyciu Aspose.HTML. Ten przewodnik pokazuje,
+ jak szybko renderować HTML jako obraz, obejmując opcje konwersji, konfigurację kodu
+ i rozwiązywanie problemów.
+og_image_alt: Screenshot of a C# program converting HTML to a PNG image
+og_title: Tworzenie PNG z HTML w C# – przewodnik krok po kroku
+schemas:
+- author: Aspose
+ dateModified: '2026-08-12'
+ description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ headline: Create PNG from HTML in C# using Aspose.HTML
+ type: TechArticle
+- description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ name: Create PNG from HTML in C# using Aspose.HTML
+ steps:
+ - name: Why this works
+ text: '- **`HtmlDocument.Open`** parses the HTML string into a DOM that Aspose.HTML
+ can render. - **`ImageRenderingOptions`** lets you control anti‑aliasing, text
+ hinting, and font handling, which are essential when you **render HTML as image**
+ to avoid blurry text. - **`ImageConverter.ConvertHtmlToImage`*'
+ - name: 1. Preparing the HTML source
+ text: You can load HTML from a string (as shown), a local file, or a remote URL.
+ - name: 2. Fine‑tuning rendering options
+ text: '| Option | Effect | When to adjust | |--------|--------|----------------|
+ | `UseAntialiasing` | Reduces jagged edges on vector graphics | Always enable
+ for high‑quality output | | `TextOptions.UseHinting` | Sharpens glyph edges
+ | Important for small font sizes | | `FontOptions.WebFontStyle` | Choose'
+ - name: 3. Performing the conversion
+ text: The `ImageConverter` overload you used writes a single PNG file. If you
+ need multiple pages (e.g., a multi‑page HTML document), use the overload that
+ returns a collection of images.
+ - name: a. Missing fonts
+ text: If the HTML references a custom web font that isn’t installed on the server,
+ the rendered text falls back to a default font, which may affect layout.
+ - name: b. Large pages and memory consumption
+ text: Rendering a very tall page can consume a lot of RAM.
+ - name: c. Transparent backgrounds
+ text: PNG supports transparency, but the default background is white.
+ type: HowTo
+tags:
+- Aspose.HTML
+- C#
+- image rendering
+- HTML conversion
+title: Utwórz PNG z HTML w C# przy użyciu Aspose.HTML
+url: /pl/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/
+---
+
+{{< blocks/products/pf/main-wrap-class >}}
+{{< blocks/products/pf/main-container >}}
+{{< blocks/products/pf/tutorial-page-section >}}
+
+# Tworzenie PNG z HTML w C# przy użyciu Aspose.HTML
+
+Jeśli potrzebujesz **utworzyć PNG z HTML** w aplikacji .NET, ten przewodnik przeprowadzi Cię przez cały proces. Zobaczysz, jak **konwertować HTML na PNG** przy użyciu kilku linii kodu C#, korzystając z potężnego silnika renderującego Aspose.HTML.
+
+Renderowanie HTML jako obrazu jest częstym wymogiem przy generowaniu miniatur, podglądów e‑maili lub raportów, które muszą być osadzone w plikach PDF. W kolejnych sekcjach poznasz dokładne kroki, zobaczysz w pełni działający przykład i zrozumiesz, dlaczego każde ustawienie ma znaczenie.
+
+## Czego się nauczysz
+
+- Jak zbudować `HtmlDocument` z łańcucha znaków lub pliku.
+- Jak skonfigurować `ImageRenderingOptions`, aby poprawić jakość.
+- Jak **konwertować HTML na PNG** i zapisać wynik na dysku.
+- Wskazówki dotyczące obsługi czcionek, dużych stron i własnych ścieżek wyjściowych.
+
+**Wymagania wstępne**
+- .NET 6.0 SDK (lub nowszy) zainstalowany.
+- Ważna licencja Aspose.HTML for .NET (lub tymczasowy klucz ewaluacyjny).
+- Podstawowa znajomość C# oraz Visual Studio lub dowolnego IDE zgodnego z .NET.
+
+---
+
+## Tworzenie PNG z HTML przy użyciu Aspose.HTML
+
+Pierwszym krokiem jest przygotowanie środowiska i odwołanie do wymaganych przestrzeni nazw Aspose.HTML.
+
+```csharp
+using System;
+using Aspose.Html;
+using Aspose.Html.Rendering.Image;
+using Aspose.Html.Drawing;
+using Aspose.Html.Converters;
+
+namespace HtmlToPngDemo
+{
+ class Program
+ {
+ static void Main()
+ {
+ // 1️⃣ Build the HTML document from a raw string.
+ var html = "Bold text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // 2️⃣ Configure rendering options for best visual fidelity. + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, // Smooths edges of drawn shapes + TextOptions = { UseHinting = true }, // Improves glyph clarity + FontOptions = { WebFontStyle = WebFontStyle.Normal } // Uses standard web‑font style + }; + + // 3️⃣ Convert the HTML document to a PNG file. + string outputPath = @"output.png"; + ImageConverter.ConvertHtmlToImage(document, outputPath, renderOptions); + + Console.WriteLine($"PNG image created at: {outputPath}"); + } + } +} +``` + +### Dlaczego to działa + +- **`HtmlDocument.Open`** parsuje łańcuch HTML do DOM, który Aspose.HTML może renderować. +- **`ImageRenderingOptions`** pozwala kontrolować antyaliasing, hinting tekstu i obsługę czcionek, co jest niezbędne przy **renderowaniu HTML jako obrazu**, aby uniknąć rozmytego tekstu. +- **`ImageConverter.ConvertHtmlToImage`** wykonuje najcięższą pracę: rasteryzuje DOM na bitmapę i zapisuje plik PNG. + +Uruchomienie programu generuje `output.png`, który zawiera pogrubiony akapit dokładnie tak, jak zdefiniowano w źródle HTML. + +--- + +## Konwertowanie HTML do PNG krok po kroku + +Poniżej znajduje się bardziej szczegółowy opis każdego etapu. Zrozumienie celu każdej linii pomaga dostosować kod do większych lub bardziej złożonych stron. + +### 1. Przygotowanie źródła HTML + +Możesz wczytać HTML z łańcucha (jak pokazano), lokalnego pliku lub zdalnego URL. + +```csharp +// Load from a file +var document = new HtmlDocument(); +document.Open(@"C:\templates\invoice.html"); + +// Load from a URL (requires internet access) +document.Open("https://example.com/report.html"); +``` + +**Wskazówka:** Podczas ładowania zasobów zewnętrznych (CSS, obrazy) upewnij się, że właściwość `BaseUrl` wskazuje na właściwy folder, aby względne odnośniki były prawidłowo rozwiązywane. + +### 2. Dostosowywanie opcji renderowania + +| Opcja | Efekt | Kiedy dostosować | +|--------|--------|----------------| +| `UseAntialiasing` | Redukuje ząbkowane krawędzie grafiki wektorowej | Zawsze włączaj dla wysokiej jakości wyjścia | +| `TextOptions.UseHinting` | Wyostrza krawędzie glifów | Ważne przy małych rozmiarach czcionki | +| `FontOptions.WebFontStyle` | Wybiera normalne, kursywne lub pochyłe renderowanie czcionek webowych | Użyj `WebFontStyle.Oblique` dla pochyłych czcionek | +| `ResolutionX` / `ResolutionY` | DPI wyjściowego obrazu | Zwiększ dla PNG gotowych do druku (np. 300 DPI) | + +Przykład zwiększenia DPI: + +```csharp +renderOptions.ResolutionX = 300; +renderOptions.ResolutionY = 300; +``` + +### 3. Przeprowadzanie konwersji + +Przeciążenie `ImageConverter`, którego użyłeś, zapisuje pojedynczy plik PNG. Jeśli potrzebujesz wielu stron (np. dokumentu HTML wielostronicowego), użyj przeciążenia zwracającego kolekcję obrazów. + +```csharp +ImageConverter.ConvertHtmlToImages(document, "output_folder", renderOptions); +``` + +Każda strona zostanie zapisana jako `output_folder/page_0.png`, `page_1.png` itd. + +--- + +## Renderowanie HTML jako obrazu – radzenie sobie z typowymi problemami + +### a. Brakujące czcionki + +Jeśli HTML odwołuje się do niestandardowej czcionki internetowej, której nie ma na serwerze, renderowany tekst przechodzi na domyślną czcionkę, co może wpłynąć na układ. + +**Rozwiązanie:** Osadź czcionkę przy użyciu reguły `@font-face` w CSS lub podaj lokalny folder czcionek za pomocą `FontOptions`. + +```csharp +renderOptions.FontOptions.FontFolder = @"C:\fonts"; +``` + +### b. Duże strony i zużycie pamięci + +Renderowanie bardzo wysokiej strony może pochłaniać dużo RAMu. + +**Rozwiązanie:** Ustaw maksymalną wysokość lub podziel dokument na sekcje przed konwersją. + +```csharp +renderOptions.PageHeight = 2000; // pixels +``` + +### c. Przezroczyste tło + +PNG obsługuje przezroczystość, ale domyślne tło jest białe. + +**Rozwiązanie:** Zmień kolor tła na przezroczysty. + +```csharp +renderOptions.BackgroundColor = System.Drawing.Color.Transparent; +``` + +--- + +## Jak renderować HTML do obrazu – pełny przykład podsumowujący + +Łącząc wszystkie elementy, oto gotowy fragment kodu gotowy do produkcji, który obejmuje najczęstsze wymagania: + +```csharp +using System; +using Aspose.Html; +using Aspose.Html.Rendering.Image; +using Aspose.Html.Drawing; +using Aspose.Html.Converters; + +namespace HtmlToPngDemo +{ + class Program + { + static void Main() + { + // Load HTML (string, file, or URL) + string html = "" + + "Bold blue text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // Configure rendering for high quality and transparency + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, + TextOptions = { UseHinting = true }, + FontOptions = { WebFontStyle = WebFontStyle.Normal, FontFolder = @"C:\fonts" }, + BackgroundColor = System.Drawing.Color.Transparent, + ResolutionX = 150, + ResolutionY = 150 + }; + + // Convert and save + string outPath = @"C:\temp\html_snapshot.png"; + ImageConverter.ConvertHtmlToImage(document, outPath, renderOptions); + + Console.WriteLine($"Image saved to {outPath}"); + } + } +} +``` + +**Oczekiwany wynik:** Plik `html_snapshot.png` zawierający pogrubiony, niebieski akapit na przezroczystym tle. Obraz będzie antyaliasowany, a tekst wyraźny dzięki hintingowi. + +--- + +## Zakończenie + +Teraz wiesz, jak **utworzyć PNG z HTML** w C# przy użyciu Aspose.HTML. Tworząc `HtmlDocument`, konfigurując `ImageRenderingOptions` i wywołując `ImageConverter.ConvertHtmlToImage`, możesz niezawodnie **konwertować HTML na PNG** i **renderować HTML jako obraz** w dowolnym scenariuszu automatyzacji. + +Od tego momentu możesz eksplorować: + +- Generowanie miniatur dla dynamicznych stron internetowych. +- Osadzanie PNG w plikach PDF przy użyciu Aspose.PDF. +- Użycie tego samego podejścia do tworzenia JPEG lub BMP poprzez zmianę rozszerzenia pliku. + +Śmiało eksperymentuj z DPI, kolorami tła i renderowaniem wielostronicowym, aby dopasować rozwiązanie do dokładnych potrzeb Twojego projektu. Powodzenia w kodowaniu! + +## Co powinieneś nauczyć się dalej? + +Poniższe samouczki dotyczą ściśle powiązanych tematów, które rozwijają techniki przedstawione w tym przewodniku. Każdy zasób zawiera kompletne działające przykłady kodu z wyjaśnieniami krok po kroku, aby pomóc Ci opanować dodatkowe funkcje API i odkrywać alternatywne podejścia w własnych projektach. + +- [Renderuj HTML jako PNG w .NET przy użyciu Aspose.HTML](/html/english/net/rendering-html-documents/render-html-as-png/) +- [Jak renderować HTML jako PNG – Kompletny przewodnik C#](/html/english/net/rendering-html-documents/how-to-render-html-as-png-complete-c-guide/) +- [Utwórz PNG z HTML – Pełny przewodnik renderowania C#](/html/english/net/rendering-html-documents/create-png-from-html-full-c-rendering-guide/) + +{{< /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 5b553b0026..e417455fd3 100644 --- a/html/polish/net/html-extensions-and-conversions/_index.md +++ b/html/polish/net/html-extensions-and-conversions/_index.md @@ -73,6 +73,8 @@ Dowiedz się, jak stworzyć dokument HTML z formatowanym tekstem i wyeksportowa Zapisz dokument HTML jako archiwum ZIP w C# przy użyciu Aspose.HTML – kompletny przewodnik krok po kroku. ### [Zapisz HTML do ZIP w C# – Kompletny przykład w pamięci](./save-html-to-zip-in-c-complete-in-memory-example/) Zapisz dokument HTML do archiwum ZIP w pamięci przy użyciu Aspose.HTML w C#. +### [Zapisz HTML jako ZIP w C# – przewodnik krok po kroku](./save-html-as-zip-in-c-step-by-step-guide/) +Zobacz, jak spakować plik HTML do archiwum ZIP w C# przy użyciu Aspose.HTML. ## Wniosek diff --git a/html/polish/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md b/html/polish/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..333eca9ced --- /dev/null +++ b/html/polish/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md @@ -0,0 +1,322 @@ +--- +category: general +date: 2026-08-12 +description: Zapisz HTML jako ZIP przy użyciu Aspose.HTML. Dowiedz się, jak wczytać + ciąg HTML, utworzyć własny obsługujący zasoby i efektywnie wygenerować archiwum + ZIP. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save html as zip +- load html string +- custom resource handler +language: pl +lastmod: 2026-08-12 +og_description: Zapisz HTML jako ZIP przy użyciu Aspose.HTML w C#. Ten samouczek pokazuje, + jak wczytać ciąg HTML, utworzyć własny obsługujący zasoby i wygenerować archiwum + ZIP w kilku krokach. +og_image_alt: Diagram showing save html as zip process with custom resource handler +og_title: Zapisz HTML jako ZIP z Aspose.HTML – kompletny przewodnik C# +schemas: +- author: Aspose + dateModified: '2026-08-12' + description: Save HTML as ZIP using Aspose.HTML. Learn to load HTML string, create + a custom resource handler, and generate a ZIP archive efficiently. + headline: Save HTML as ZIP in C# – step‑by‑step guide + type: TechArticle +tags: +- Aspose.HTML +- C# +- ZIP archive +title: Zapisz HTML jako ZIP w C# – przewodnik krok po kroku +url: /pl/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Zapisz HTML jako ZIP w C# – przewodnik krok po kroku + +Jeśli potrzebujesz **zapisz HTML jako ZIP** w aplikacji .NET, ten przewodnik pokazuje kompletny przepływ pracy. Nauczysz się jak **wczytać ciąg HTML**, zaimplementować **niestandardowy obsługujący zasoby** i wygenerować archiwum ZIP bez zapisywania plików pośrednich na dysku. + +Podejście wykorzystuje Aspose.HTML 5.x, które zapewnia wysokowydajny silnik renderujący oraz elastyczne opcje zapisu. Po zakończeniu samouczka będziesz mieć wielokrotnego użytku handler, który można zintegrować z usługami sieciowymi, zadaniami w tle lub narzędziami desktopowymi. + +## Co zbudujesz + +Końcowy kod tworzy plik ZIP oparty na `MemoryStream`, który zawiera dokument HTML oraz wszystkie odwołane zasoby (obrazy, CSS, czcionki). Plik ZIP jest zapisywany do docelowego folderu, ale możesz zmienić miejsce docelowe na strumień odpowiedzi dla API HTTP. + +## Wymagania wstępne + +- .NET 6.0 lub nowszy (przykład celuje w .NET 6) +- Aspose.HTML dla .NET (pakiet NuGet `Aspose.HTML`) +- Podstawowa znajomość wzorców asynchronicznych w C# (opcjonalnie, ale pomocna) + +> **Pro tip:** Zainstaluj pakiet poleceniem `dotnet add package Aspose.HTML` przed rozpoczęciem. + +## Krok 1: Zdefiniuj niestandardowy obsługujący zasoby + +**Niestandardowy obsługujący zasoby** przechwytuje każde żądanie zewnętrznego zasobu, które wykonuje renderer HTML. Zwracając strumień, kontrolujesz, gdzie przechowywane są dane zasobu. Przykład przechowuje wszystko w pamięci, co jest idealne do tworzenia archiwum ZIP w locie. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +///Hello, world!
+
+
+";
+
+// Create a new document instance.
+HtmlDocument document = new HtmlDocument();
+
+// Load the HTML markup.
+document.Open(htmlContent);
+```
+
+**Dlaczego ten krok ma znaczenie:**
+Możliwość **load html string** jest przydatna, gdy HTML jest generowany dynamicznie (np. z silnika szablonów) lub otrzymywany z API. Unika zależności od systemu plików i działa w środowiskach sandbox.
+
+## Krok 3: Skonfiguruj opcje zapisu, aby używać obsługującego zasoby
+
+`HtmlSaveOptions` z Aspose.HTML pozwalają określić mechanizm przechowywania wyjścia. Przypisz niestandardowy handler do właściwości `OutputStorage` i ustaw flagę `Compress`, aby wygenerować archiwum ZIP.
+
+```csharp
+// Instantiate the custom handler.
+var resourceHandler = new InMemoryResourceHandler();
+
+// Prepare save options.
+HtmlSaveOptions saveOptions = new HtmlSaveOptions
+{
+ // Use the handler for all external resources.
+ OutputStorage = resourceHandler,
+
+ // Enable ZIP compression.
+ Compress = true
+};
+```
+
+**Dlaczego ten krok ma znaczenie:**
+`Compress = true` instruuje Aspose.HTML, aby spakował plik HTML i wszystkie zebrane zasoby w jedną paczkę ZIP. `OutputStorage` zapewnia, że zasoby są przechwytywane w pamięci, a nie zapisywane w tymczasowych lokalizacjach.
+
+## Krok 4: Zapisz dokument jako archiwum ZIP
+
+Teraz wywołaj `HtmlDocument.Save`, podając ścieżkę docelową oraz skonfigurowane opcje. Po zapisaniu plik ZIP zawiera `index.html` oraz wszystkie zasoby przechwycone przez handler.
+
+```csharp
+// Define the output path (you can change this to a response stream for web APIs).
+string outputPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+
+// Save the document; Aspose.HTML creates the ZIP automatically.
+document.Save(outputPath, saveOptions);
+
+// Optional: Verify the resources that were stored.
+foreach (var entry in resourceHandler.Resources)
+{
+ Console.WriteLine($"Resource: {entry.Key}, Size: {entry.Value.Length} bytes");
+}
+```
+
+**Oczekiwany wynik:**
+Uruchomienie programu tworzy `output.zip` w bieżącym katalogu. Rozpakowanie archiwum ujawnia:
+
+```
+index.html
+styles.css
+logo.png
+```
+
+Każdy plik odpowiada odwołaniom w markupzie, a HTML w `index.html` wskazuje na zasoby zawarte w paczce.
+
+## Krok 5: Dostosuj obsługującego zasoby do rzeczywistych danych (zaawansowane)
+
+Podstawowy handler powyżej tworzy puste strumienie. W produkcji często trzeba zapisać rzeczywistą zawartość (np. bajty `styles.css` lub `logo.png`). Rozszerz `HandleResource`, aby pobierać dane z bazy danych, chmury lub zasobu osadzonego.
+
+```csharp
+public override Stream HandleResource(ResourceInfo info)
+{
+ // Example: Load resource from an embedded folder.
+ string resourcePath = Path.Combine("EmbeddedResources", info.Path);
+ byte[] data = File.ReadAllBytes(resourcePath);
+
+ // Write data into a memory stream.
+ var stream = new MemoryStream(data);
+ _resources[info.Path] = stream;
+
+ // Return the populated stream.
+ return stream;
+}
+```
+
+**Dlaczego ta wariacja ma znaczenie:**
+Dostarczanie prawdziwej treści zapewnia, że archiwum ZIP będzie funkcjonalne po otwarciu w przeglądarce. Handler może także zastosować transformacje (np. minifikację CSS) przed zapisaniem do strumienia.
+
+## Krok 6: Użyj archiwum ZIP w API internetowym (opcjonalnie)
+
+Jeśli udostępniasz funkcjonalność przez ASP.NET Core, zwróć plik ZIP jako wynik pliku:
+
+```csharp
+[HttpGet("download")]
+public IActionResult DownloadZip()
+{
+ // Reuse the same logic from steps 1‑4.
+ // ...
+
+ // Read the generated ZIP into a byte array.
+ byte[] zipBytes = System.IO.File.ReadAllBytes(outputPath);
+
+ // Return the file with the appropriate content type.
+ return File(zipBytes, "application/zip", "document.zip");
+}
+```
+
+**Dlaczego ten krok ma znaczenie:**
+Klienci mogą pobrać spakowany HTML bez konieczności obsługi tymczasowych plików na serwerze. Podejście działa również w funkcjach serverless, gdzie dostęp do dysku jest ograniczony.
+
+## Typowe pułapki i jak ich unikać
+
+| Pułapka | Powód | Rozwiązanie |
+|---------|--------|-----|
+| Puste zasoby w ZIP | Handler zwraca nowy `MemoryStream` bez zapisu danych | Wypełnij strumień rzeczywistymi bajtami przed zwróceniem |
+| Brak wpisu `index.html` | Flaga `Compress` nie jest ustawiona lub `OutputStorage` nie przypisany | Upewnij się, że `saveOptions.Compress = true` i `saveOptions.OutputStorage = handler` |
+| Duży HTML powodujący obciążenie pamięci | Wszystkie zasoby są trzymane w pamięci | Przejdź na implementację `FileStorage`, która zapisuje do tymczasowego folderu |
+| Relatywne URL-e psujące się po rozpakowaniu | Zasoby odwołane za pomocą bezwzględnych URL-i, które nie są przechowywane | Przepisz URL-e na ścieżki względne w handlerze lub podczas post‑processingu |
+
+## Pełny, działający przykład
+
+```csharp
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Saving;
+
+class InMemoryResourceHandler : ResourceHandler
+{
+ private readonly DictionaryHello, world!
+
+
+ ";
+
+ HtmlDocument doc = new HtmlDocument();
+ doc.Open(html);
+
+ // Step 1 & 3: Create handler and configure save options.
+ var handler = new InMemoryResourceHandler();
+ HtmlSaveOptions options = new HtmlSaveOptions
+ {
+ OutputStorage = handler,
+ Compress = true
+ };
+
+ // Step 4: Save as ZIP.
+ string zipPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+ doc.Save(zipPath, options);
+ Console.WriteLine($"ZIP file created at: {zipPath}");
+
+ // Optional verification.
+ foreach (var kvp in handler.Resources)
+ {
+ Console.WriteLine($"Resource {kvp.Key} captured, length {kvp.Value.Length} bytes");
+ }
+ }
+}
+```
+
+Uruchomienie programu generuje `output.zip` obok pliku wykonywalnego. Rozpakowanie archiwum pokazuje `index.html`, `styles.css` i `logo.png` (puste zastępniki w tym minimalnym przykładzie).
+
+## Zakończenie
+
+Masz teraz niezawodną metodę **zapisz HTML jako ZIP** przy użyciu Aspose.HTML w C#. Samouczek obejmował wczytywanie ciągu HTML, implementację **niestandardowego obsługującego zasoby**, konfigurację opcji zapisu oraz generowanie archiwum ZIP gotowego do dystrybucji lub pobrania.
+
+Od tego momentu możesz:
+
+- Zamienić strumienie zastępcze na rzeczywistą zawartość (np. odczyt z bazy danych)
+- Przejść na handler oparty na plikach dla bardzo dużych dokumentów
+- Zintegrować logikę z endpointami ASP.NET Core dla pobrań na żądanie
+- Eksplorować dodatkowe funkcje Aspose.HTML, takie jak konwersja do PDF czy renderowanie obrazów
+
+Eksperymentuj z różnymi źródłami zasobów i ustawieniami kompresji, aby dopasować rozwiązanie do wymagań wydajnościowych i rozmiarowych. Szczęśliwego kodowania!
+
+## Co powinieneś nauczyć się dalej?
+
+Poniższe samouczki obejmują tematy ściśle powiązane, które rozwijają techniki przedstawione w tym przewodniku. Każdy zasób zawiera kompletne działające przykłady kodu z wyjaśnieniami krok po kroku, aby pomóc Ci opanować dodatkowe funkcje API i odkrywać alternatywne podejścia w własnych projektach.
+
+- [Zapisz HTML jako ZIP – Kompletny samouczek C#](/html/english/net/html-extensions-and-conversions/save-html-as-zip-complete-c-tutorial/)
+- [Jak zapisać HTML w C# – Kompletny przewodnik z użyciem niestandardowego obsługującego zasoby](/html/english/net/working-with-html-documents/how-to-save-html-in-c-complete-guide-using-a-custom-resource/)
+- [Utwórz HTML z ciągu znaków w C# – Przewodnik po niestandardowym obsługującym zasoby](/html/english/net/html-document-manipulation/create-html-from-string-in-c-custom-resource-handler-guide/)
+
+{{< /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/generate-jpg-and-png-images/_index.md b/html/portuguese/net/generate-jpg-and-png-images/_index.md
index 25a4d8da7a..5d6338bf4c 100644
--- a/html/portuguese/net/generate-jpg-and-png-images/_index.md
+++ b/html/portuguese/net/generate-jpg-and-png-images/_index.md
@@ -45,6 +45,7 @@ Aprenda a usar Aspose.HTML para .NET para manipular documentos HTML, converter H
Aprenda a ativar antialiasing ao converter documentos DOCX em imagens PNG ou JPG usando Aspose.HTML para .NET.
### [Converter docx para png – criar arquivo zip em C# tutorial](./convert-docx-to-png-create-zip-archive-c-tutorial/)
Aprenda a converter documentos DOCX em imagens PNG e compactá-los em um arquivo ZIP usando C# e Aspose.HTML.
+### [Criar PNG a partir de HTML em C# usando Aspose.HTML](./create-png-from-html-in-c-using-aspose-html/)
## Conclusão
diff --git a/html/portuguese/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md b/html/portuguese/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
new file mode 100644
index 0000000000..0498c03672
--- /dev/null
+++ b/html/portuguese/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
@@ -0,0 +1,291 @@
+---
+category: general
+date: 2026-08-12
+description: Crie PNG a partir de HTML em C# com Aspose.HTML. Aprenda como converter
+ HTML para PNG e renderizar HTML como imagem em apenas algumas linhas de código.
+draft: false
+images:
+- PLACEHOLDER_URL/og-image.png
+keywords:
+- create png from html
+- convert html to png
+- render html as image
+- how to render html to image
+language: pt
+lastmod: 2026-08-12
+og_description: Crie PNG a partir de HTML em C# usando Aspose.HTML. Este guia mostra
+ como renderizar HTML como imagem rapidamente, abordando opções de conversão, configuração
+ de código e solução de problemas.
+og_image_alt: Screenshot of a C# program converting HTML to a PNG image
+og_title: Criar PNG a partir de HTML em C# – guia passo a passo
+schemas:
+- author: Aspose
+ dateModified: '2026-08-12'
+ description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ headline: Create PNG from HTML in C# using Aspose.HTML
+ type: TechArticle
+- description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ name: Create PNG from HTML in C# using Aspose.HTML
+ steps:
+ - name: Why this works
+ text: '- **`HtmlDocument.Open`** parses the HTML string into a DOM that Aspose.HTML
+ can render. - **`ImageRenderingOptions`** lets you control anti‑aliasing, text
+ hinting, and font handling, which are essential when you **render HTML as image**
+ to avoid blurry text. - **`ImageConverter.ConvertHtmlToImage`*'
+ - name: 1. Preparing the HTML source
+ text: You can load HTML from a string (as shown), a local file, or a remote URL.
+ - name: 2. Fine‑tuning rendering options
+ text: '| Option | Effect | When to adjust | |--------|--------|----------------|
+ | `UseAntialiasing` | Reduces jagged edges on vector graphics | Always enable
+ for high‑quality output | | `TextOptions.UseHinting` | Sharpens glyph edges
+ | Important for small font sizes | | `FontOptions.WebFontStyle` | Choose'
+ - name: 3. Performing the conversion
+ text: The `ImageConverter` overload you used writes a single PNG file. If you
+ need multiple pages (e.g., a multi‑page HTML document), use the overload that
+ returns a collection of images.
+ - name: a. Missing fonts
+ text: If the HTML references a custom web font that isn’t installed on the server,
+ the rendered text falls back to a default font, which may affect layout.
+ - name: b. Large pages and memory consumption
+ text: Rendering a very tall page can consume a lot of RAM.
+ - name: c. Transparent backgrounds
+ text: PNG supports transparency, but the default background is white.
+ type: HowTo
+tags:
+- Aspose.HTML
+- C#
+- image rendering
+- HTML conversion
+title: Criar PNG a partir de HTML em C# usando Aspose.HTML
+url: /pt/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/
+---
+
+{{< blocks/products/pf/main-wrap-class >}}
+{{< blocks/products/pf/main-container >}}
+{{< blocks/products/pf/tutorial-page-section >}}
+
+# Criar PNG a partir de HTML em C# usando Aspose.HTML
+
+Se você precisa **criar PNG a partir de HTML** em uma aplicação .NET, este guia mostra todo o processo. Você verá como **converter HTML para PNG** com apenas algumas linhas de código C#, usando o poderoso mecanismo de renderização do Aspose.HTML.
+
+Renderizar HTML como imagem é uma necessidade comum ao gerar miniaturas, pré‑visualizações de e‑mail ou relatórios que precisam ser incorporados em PDFs. Nas seções a seguir, você aprenderá os passos exatos, verá um exemplo completo em funcionamento e entenderá por que cada configuração é importante.
+
+## O que você vai aprender
+
+- Como criar um `HtmlDocument` a partir de uma string ou arquivo.
+- Como configurar `ImageRenderingOptions` para melhorar a qualidade.
+- Como **converter HTML para PNG** e salvar o resultado no disco.
+- Dicas para lidar com fontes, páginas grandes e caminhos de saída personalizados.
+
+**Pré‑requisitos**
+- .NET 6.0 SDK (ou superior) instalado.
+- Uma licença válida do Aspose.HTML for .NET (ou uma chave de avaliação temporária).
+- Familiaridade básica com C# e Visual Studio ou qualquer IDE compatível com .NET.
+
+---
+
+## Criar PNG a partir de HTML com Aspose.HTML
+
+O primeiro passo é configurar o ambiente e referenciar os namespaces necessários do Aspose.HTML.
+
+```csharp
+using System;
+using Aspose.Html;
+using Aspose.Html.Rendering.Image;
+using Aspose.Html.Drawing;
+using Aspose.Html.Converters;
+
+namespace HtmlToPngDemo
+{
+ class Program
+ {
+ static void Main()
+ {
+ // 1️⃣ Build the HTML document from a raw string.
+ var html = "Bold text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // 2️⃣ Configure rendering options for best visual fidelity. + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, // Smooths edges of drawn shapes + TextOptions = { UseHinting = true }, // Improves glyph clarity + FontOptions = { WebFontStyle = WebFontStyle.Normal } // Uses standard web‑font style + }; + + // 3️⃣ Convert the HTML document to a PNG file. + string outputPath = @"output.png"; + ImageConverter.ConvertHtmlToImage(document, outputPath, renderOptions); + + Console.WriteLine($"PNG image created at: {outputPath}"); + } + } +} +``` + +### Por que isso funciona + +- **`HtmlDocument.Open`** analisa a string HTML em um DOM que o Aspose.HTML pode renderizar. +- **`ImageRenderingOptions`** permite controlar anti‑aliasing, hinting de texto e tratamento de fontes, essenciais ao **renderizar HTML como imagem** para evitar texto borrado. +- **`ImageConverter.ConvertHtmlToImage`** faz o trabalho pesado: rasteriza o DOM em um bitmap e grava o arquivo PNG. + +Executar o programa gera `output.png` que contém o parágrafo em negrito exatamente como definido na fonte HTML. + +--- + +## Converter HTML para PNG passo a passo + +A seguir, um detalhamento mais aprofundado de cada fase. Entender o propósito de cada linha ajuda a adaptar o código para páginas maiores ou mais complexas. + +### 1. Preparando a fonte HTML + +Você pode carregar HTML a partir de uma string (como mostrado), de um arquivo local ou de uma URL remota. + +```csharp +// Load from a file +var document = new HtmlDocument(); +document.Open(@"C:\templates\invoice.html"); + +// Load from a URL (requires internet access) +document.Open("https://example.com/report.html"); +``` + +**Dica:** Ao carregar recursos externos (CSS, imagens), certifique‑se de que a propriedade `BaseUrl` aponta para a pasta correta, de modo que links relativos sejam resolvidos adequadamente. + +### 2. Ajustando finamente as opções de renderização + +| Opção | Efeito | Quando ajustar | +|--------|--------|----------------| +| `UseAntialiasing` | Reduz bordas serrilhadas em gráficos vetoriais | Sempre habilite para saída de alta qualidade | +| `TextOptions.UseHinting` | Aguça as bordas dos glifos | Importante para tamanhos de fonte pequenos | +| `FontOptions.WebFontStyle` | Escolhe a renderização normal, itálica ou oblíqua de web‑fonts | Use `WebFontStyle.Oblique` para fontes inclinadas | +| `ResolutionX` / `ResolutionY` | DPI da imagem de saída | Aumente para PNGs prontos para impressão (ex.: 300 DPI) | + +Exemplo de aumento de DPI: + +```csharp +renderOptions.ResolutionX = 300; +renderOptions.ResolutionY = 300; +``` + +### 3. Executando a conversão + +A sobrecarga do `ImageConverter` que você usou grava um único arquivo PNG. Se precisar de várias páginas (ex.: um documento HTML multipágina), use a sobrecarga que retorna uma coleção de imagens. + +```csharp +ImageConverter.ConvertHtmlToImages(document, "output_folder", renderOptions); +``` + +Cada página torna‑se `output_folder/page_0.png`, `page_1.png`, etc. + +--- + +## Renderizar HTML como imagem – lidando com armadilhas comuns + +### a. Fontes ausentes + +Se o HTML referencia uma web‑font personalizada que não está instalada no servidor, o texto renderizado recai para uma fonte padrão, o que pode afetar o layout. + +**Solução:** Incorpore a fonte usando uma regra `@font-face` no seu CSS ou forneça uma pasta de fontes local via `FontOptions`. + +```csharp +renderOptions.FontOptions.FontFolder = @"C:\fonts"; +``` + +### b. Páginas grandes e consumo de memória + +Renderizar uma página muito alta pode consumir muita RAM. + +**Solução:** Defina uma altura máxima ou divida o documento em seções antes da conversão. + +```csharp +renderOptions.PageHeight = 2000; // pixels +``` + +### c. Fundos transparentes + +PNG suporta transparência, mas o fundo padrão é branco. + +**Solução:** Altere a cor de fundo para transparente. + +```csharp +renderOptions.BackgroundColor = System.Drawing.Color.Transparent; +``` + +--- + +## Como renderizar HTML para imagem – recapitulação do exemplo completo + +Juntando tudo, aqui está um trecho pronto para produção que cobre os requisitos mais frequentes: + +```csharp +using System; +using Aspose.Html; +using Aspose.Html.Rendering.Image; +using Aspose.Html.Drawing; +using Aspose.Html.Converters; + +namespace HtmlToPngDemo +{ + class Program + { + static void Main() + { + // Load HTML (string, file, or URL) + string html = "" + + "Bold blue text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // Configure rendering for high quality and transparency + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, + TextOptions = { UseHinting = true }, + FontOptions = { WebFontStyle = WebFontStyle.Normal, FontFolder = @"C:\fonts" }, + BackgroundColor = System.Drawing.Color.Transparent, + ResolutionX = 150, + ResolutionY = 150 + }; + + // Convert and save + string outPath = @"C:\temp\html_snapshot.png"; + ImageConverter.ConvertHtmlToImage(document, outPath, renderOptions); + + Console.WriteLine($"Image saved to {outPath}"); + } + } +} +``` + +**Saída esperada:** Um arquivo `html_snapshot.png` contendo um parágrafo em negrito e azul sobre um canvas transparente. A imagem será anti‑aliased, com texto nítido graças ao hinting. + +--- + +## Conclusão + +Agora você sabe como **criar PNG a partir de HTML** em C# usando Aspose.HTML. Ao construir um `HtmlDocument`, configurar `ImageRenderingOptions` e chamar `ImageConverter.ConvertHtmlToImage`, você pode converter HTML para PNG de forma confiável e **renderizar HTML como imagem** para qualquer cenário de automação. + +A partir daqui, você pode explorar: + +- Gerar miniaturas para páginas web dinâmicas. +- Incorporar o PNG em PDFs com Aspose.PDF. +- Usar a mesma abordagem para produzir JPEG ou BMP alterando a extensão do arquivo. + +Sinta‑se à vontade para experimentar DPI, cores de fundo e renderização multipágina para atender exatamente às necessidades do seu projeto. Boa codificação! + +## O que você deve aprender a seguir? + +Os tutoriais a seguir abordam tópicos intimamente relacionados que ampliam as técnicas demonstradas neste guia. Cada recurso inclui código completo e exemplos passo a passo para ajudá‑lo a dominar recursos adicionais da API e explorar abordagens alternativas em seus próprios projetos. + +- [Renderizar HTML como PNG em .NET com Aspose.HTML](/html/english/net/rendering-html-documents/render-html-as-png/) +- [Como Renderizar HTML como PNG – Guia Completo em C#](/html/english/net/rendering-html-documents/how-to-render-html-as-png-complete-c-guide/) +- [Criar PNG a partir de HTML – Guia Completo de Renderização em C#](/html/english/net/rendering-html-documents/create-png-from-html-full-c-rendering-guide/) + +{{< /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 8971d46a58..d7e47df242 100644 --- a/html/portuguese/net/html-extensions-and-conversions/_index.md +++ b/html/portuguese/net/html-extensions-and-conversions/_index.md @@ -78,6 +78,9 @@ Aprenda a criar um arquivo ZIP contendo arquivos HTML usando Aspose.HTML para .N ### [Salvar HTML em ZIP em C# – Exemplo Completo em Memória](./save-html-to-zip-in-c-complete-in-memory-example/) Aprenda a salvar arquivos HTML em um arquivo ZIP usando C# com um exemplo completo totalmente em memória. +### [Salvar HTML como ZIP em C# – guia passo a passo](./save-html-as-zip-in-c-step-by-step-guide/) +Aprenda a salvar documentos HTML em arquivos ZIP usando Aspose.HTML para .NET com um tutorial passo a passo 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/save-html-as-zip-in-c-step-by-step-guide/_index.md b/html/portuguese/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..ab03010153 --- /dev/null +++ b/html/portuguese/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md @@ -0,0 +1,322 @@ +--- +category: general +date: 2026-08-12 +description: Salve HTML como ZIP usando Aspose.HTML. Aprenda a carregar uma string + HTML, criar um manipulador de recursos personalizado e gerar um arquivo ZIP de forma + eficiente. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save html as zip +- load html string +- custom resource handler +language: pt +lastmod: 2026-08-12 +og_description: Salve HTML como ZIP usando Aspose.HTML em C#. Este tutorial mostra + como carregar uma string HTML, criar um manipulador de recursos personalizado e + gerar um arquivo ZIP em poucos passos. +og_image_alt: Diagram showing save html as zip process with custom resource handler +og_title: Salvar HTML como ZIP com Aspose.HTML – guia completo em C# +schemas: +- author: Aspose + dateModified: '2026-08-12' + description: Save HTML as ZIP using Aspose.HTML. Learn to load HTML string, create + a custom resource handler, and generate a ZIP archive efficiently. + headline: Save HTML as ZIP in C# – step‑by‑step guide + type: TechArticle +tags: +- Aspose.HTML +- C# +- ZIP archive +title: Salvar HTML como ZIP em C# – guia passo a passo +url: /pt/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Salvar HTML como ZIP em C# – guia passo a passo + +Se você precisa **salvar HTML como ZIP** em uma aplicação .NET, este guia mostra o fluxo completo de trabalho. Você aprenderá como **carregar uma string HTML**, implementar um **manipulador de recursos personalizado** e gerar um arquivo ZIP sem gravar arquivos intermediários no disco. + +A abordagem usa Aspose.HTML 5.x, que fornece um motor de renderização de alto desempenho e opções flexíveis de salvamento. Ao final do tutorial você terá um manipulador reutilizável que pode ser integrado a serviços web, jobs em background ou ferramentas desktop. + +## O que você vai construir + +O código final cria um arquivo ZIP baseado em `MemoryStream` que contém o documento HTML e quaisquer recursos referenciados (imagens, CSS, fontes). O arquivo ZIP é gravado em uma pasta de destino, mas você pode mudar o destino para um fluxo de resposta em APIs HTTP. + +## Pré‑requisitos + +- .NET 6.0 ou superior (o exemplo tem como alvo .NET 6) +- Aspose.HTML para .NET (pacote NuGet `Aspose.HTML`) +- Familiaridade básica com padrões assíncronos de C# (opcional, mas útil) + +> **Dica profissional:** Instale o pacote com `dotnet add package Aspose.HTML` antes de começar. + +## Etapa 1: Definir um manipulador de recursos personalizado + +Um **manipulador de recursos personalizado** intercepta cada solicitação de recurso externo que o renderizador HTML faz. Ao retornar um stream, você controla onde os dados do recurso são armazenados. O exemplo armazena tudo na memória, o que é ideal para criar um arquivo ZIP sobre a marcha. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +///Hello, world!
+
+
+";
+
+// Create a new document instance.
+HtmlDocument document = new HtmlDocument();
+
+// Load the HTML markup.
+document.Open(htmlContent);
+```
+
+**Por que esta etapa importa:**
+A capacidade de **carregar string HTML** é útil quando o HTML é gerado dinamicamente (por exemplo, a partir de um motor de templates) ou recebido de uma API. Ela evita dependências do sistema de arquivos e funciona em ambientes sandbox.
+
+## Etapa 3: Configurar opções de salvamento para usar o manipulador
+
+As `HtmlSaveOptions` do Aspose.HTML permitem especificar o mecanismo de armazenamento para a saída. Atribua o manipulador personalizado à propriedade `OutputStorage` e defina o sinalizador `Compress` para produzir um arquivo ZIP.
+
+```csharp
+// Instantiate the custom handler.
+var resourceHandler = new InMemoryResourceHandler();
+
+// Prepare save options.
+HtmlSaveOptions saveOptions = new HtmlSaveOptions
+{
+ // Use the handler for all external resources.
+ OutputStorage = resourceHandler,
+
+ // Enable ZIP compression.
+ Compress = true
+};
+```
+
+**Por que esta etapa importa:**
+`Compress = true` indica ao Aspose.HTML que agrupe o arquivo HTML e todos os recursos coletados em um único pacote ZIP. O `OutputStorage` garante que os recursos sejam capturados na memória em vez de serem gravados em locais temporários.
+
+## Etapa 4: Salvar o documento como um arquivo ZIP
+
+Agora invoque `HtmlDocument.Save`, passando o caminho de destino e as opções configuradas. Após a gravação, o arquivo ZIP contém `index.html` mais quaisquer recursos capturados pelo manipulador.
+
+```csharp
+// Define the output path (you can change this to a response stream for web APIs).
+string outputPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+
+// Save the document; Aspose.HTML creates the ZIP automatically.
+document.Save(outputPath, saveOptions);
+
+// Optional: Verify the resources that were stored.
+foreach (var entry in resourceHandler.Resources)
+{
+ Console.WriteLine($"Resource: {entry.Key}, Size: {entry.Value.Length} bytes");
+}
+```
+
+**Resultado esperado:**
+Executar o programa cria `output.zip` no diretório atual. Ao extrair o arquivo, você verá:
+
+```
+index.html
+styles.css
+logo.png
+```
+
+Cada arquivo corresponde às referências da marcação, e o HTML dentro de `index.html` aponta para os recursos incluídos.
+
+## Etapa 5: Adaptar o manipulador para dados reais de recursos (avançado)
+
+O manipulador básico acima cria streams vazios. Em produção você costuma precisar gravar o conteúdo real (por exemplo, os bytes de `styles.css` ou `logo.png`). Amplie `HandleResource` para buscar dados de um banco de dados, um bucket na nuvem ou um recurso incorporado.
+
+```csharp
+public override Stream HandleResource(ResourceInfo info)
+{
+ // Example: Load resource from an embedded folder.
+ string resourcePath = Path.Combine("EmbeddedResources", info.Path);
+ byte[] data = File.ReadAllBytes(resourcePath);
+
+ // Write data into a memory stream.
+ var stream = new MemoryStream(data);
+ _resources[info.Path] = stream;
+
+ // Return the populated stream.
+ return stream;
+}
+```
+
+**Por que esta variação importa:**
+Fornecer conteúdo real garante que o arquivo ZIP seja funcional ao ser aberto em um navegador. O manipulador também pode aplicar transformações (por exemplo, minificar CSS) antes de gravar no stream.
+
+## Etapa 6: Usar o arquivo ZIP em uma Web API (opcional)
+
+Se você expõe a funcionalidade através do ASP.NET Core, retorne o arquivo ZIP como um resultado de arquivo:
+
+```csharp
+[HttpGet("download")]
+public IActionResult DownloadZip()
+{
+ // Reuse the same logic from steps 1‑4.
+ // ...
+
+ // Read the generated ZIP into a byte array.
+ byte[] zipBytes = System.IO.File.ReadAllBytes(outputPath);
+
+ // Return the file with the appropriate content type.
+ return File(zipBytes, "application/zip", "document.zip");
+}
+```
+
+**Por que esta etapa importa:**
+Os clientes podem baixar o HTML empacotado sem lidar com arquivos temporários no servidor. A abordagem funciona com funções serverless onde o acesso ao disco é limitado.
+
+## Armadilhas comuns e como evitá‑las
+
+| Armadilha | Motivo | Solução |
+|-----------|--------|---------|
+| Recursos vazios no ZIP | O manipulador retorna um `MemoryStream` novo sem gravar dados | Preencha o stream com os bytes reais antes de retorná‑lo |
+| Entrada `index.html` ausente | Sinalizador `Compress` não definido ou `OutputStorage` não atribuído | Garanta `saveOptions.Compress = true` e `saveOptions.OutputStorage = handler` |
+| HTML grande causando pressão de memória | Todos os recursos são mantidos na memória | Troque para uma implementação `FileStorage` que grava em uma pasta temporária |
+| URLs relativas quebrando após extração | Recursos referenciados com URLs absolutas que não são armazenados | Reescreva URLs para caminhos relativos dentro do manipulador ou durante o pós‑processamento |
+
+## Exemplo completo, executável
+
+```csharp
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Saving;
+
+class InMemoryResourceHandler : ResourceHandler
+{
+ private readonly DictionaryHello, world!
+
+
+ ";
+
+ HtmlDocument doc = new HtmlDocument();
+ doc.Open(html);
+
+ // Step 1 & 3: Create handler and configure save options.
+ var handler = new InMemoryResourceHandler();
+ HtmlSaveOptions options = new HtmlSaveOptions
+ {
+ OutputStorage = handler,
+ Compress = true
+ };
+
+ // Step 4: Save as ZIP.
+ string zipPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+ doc.Save(zipPath, options);
+ Console.WriteLine($"ZIP file created at: {zipPath}");
+
+ // Optional verification.
+ foreach (var kvp in handler.Resources)
+ {
+ Console.WriteLine($"Resource {kvp.Key} captured, length {kvp.Value.Length} bytes");
+ }
+ }
+}
+```
+
+Executar o programa produz `output.zip` ao lado do executável. Ao extrair o arquivo, você verá `index.html`, `styles.css` e `logo.png` (marcadores vazios neste exemplo mínimo).
+
+## Conclusão
+
+Agora você tem um método confiável para **salvar HTML como ZIP** usando Aspose.HTML em C#. O tutorial abordou o carregamento de uma string HTML, a implementação de um **manipulador de recursos personalizado**, a configuração das opções de salvamento e a geração de um arquivo ZIP pronto para distribuição ou download.
+
+A partir daqui você pode:
+
+- Substituir os streams de espaço reservado por conteúdo real (por exemplo, ler de um banco de dados)
+- Trocar para um manipulador baseado em arquivos para documentos muito grandes
+- Integrar a lógica em endpoints ASP.NET Core para downloads sob demanda
+- Explorar recursos adicionais do Aspose.HTML, como conversão para PDF ou renderização de imagens
+
+Experimente diferentes fontes de recursos e configurações de compressão para adaptar a solução aos seus requisitos de desempenho e tamanho. Boa codificação!
+
+## O que você deve aprender a seguir?
+
+Os tutoriais a seguir cobrem tópicos intimamente relacionados que ampliam as técnicas demonstradas neste guia. Cada recurso inclui exemplos de código completos e funcionais com explicações passo a passo para ajudá‑lo a dominar recursos adicionais da API e explorar abordagens alternativas em seus próprios projetos.
+
+- [Save HTML as ZIP – Complete C# Tutorial](/html/english/net/html-extensions-and-conversions/save-html-as-zip-complete-c-tutorial/)
+- [How to Save HTML in C# – Complete Guide Using a Custom Resource Handler](/html/english/net/working-with-html-documents/how-to-save-html-in-c-complete-guide-using-a-custom-resource/)
+- [Create HTML from String in C# – Custom Resource Handler Guide](/html/english/net/html-document-manipulation/create-html-from-string-in-c-custom-resource-handler-guide/)
+
+{{< /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/generate-jpg-and-png-images/_index.md b/html/russian/net/generate-jpg-and-png-images/_index.md
index 74f0059491..70b9390cbb 100644
--- a/html/russian/net/generate-jpg-and-png-images/_index.md
+++ b/html/russian/net/generate-jpg-and-png-images/_index.md
@@ -45,6 +45,8 @@ Aspose.HTML для .NET предлагает простой метод прео
Узнайте, как включить сглаживание при преобразовании DOCX в PNG или JPG с помощью Aspose.HTML для .NET.
### [Конвертация DOCX в PNG – создание ZIP-архива на C#](./convert-docx-to-png-create-zip-archive-c-tutorial/)
Узнайте, как преобразовать файлы DOCX в PNG и упаковать их в ZIP-архив с помощью C# и Aspose.HTML.
+### [Создание PNG из HTML на C# с использованием Aspose.HTML](./create-png-from-html-in-c-using-aspose-html/)
+Узнайте, как генерировать PNG‑изображения из HTML с помощью Aspose.HTML в C#.
## Заключение
diff --git a/html/russian/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md b/html/russian/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
new file mode 100644
index 0000000000..e465f28345
--- /dev/null
+++ b/html/russian/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
@@ -0,0 +1,291 @@
+---
+category: general
+date: 2026-08-12
+description: Создайте PNG из HTML на C# с помощью Aspose.HTML. Узнайте, как преобразовать
+ HTML в PNG и отобразить HTML как изображение всего за несколько строк кода.
+draft: false
+images:
+- PLACEHOLDER_URL/og-image.png
+keywords:
+- create png from html
+- convert html to png
+- render html as image
+- how to render html to image
+language: ru
+lastmod: 2026-08-12
+og_description: Создайте PNG из HTML в C# с помощью Aspose.HTML. Это руководство показывает,
+ как быстро отобразить HTML в виде изображения, охватывая варианты конвертации, настройку
+ кода и устранение неполадок.
+og_image_alt: Screenshot of a C# program converting HTML to a PNG image
+og_title: Создание PNG из HTML в C# – пошаговое руководство
+schemas:
+- author: Aspose
+ dateModified: '2026-08-12'
+ description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ headline: Create PNG from HTML in C# using Aspose.HTML
+ type: TechArticle
+- description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ name: Create PNG from HTML in C# using Aspose.HTML
+ steps:
+ - name: Why this works
+ text: '- **`HtmlDocument.Open`** parses the HTML string into a DOM that Aspose.HTML
+ can render. - **`ImageRenderingOptions`** lets you control anti‑aliasing, text
+ hinting, and font handling, which are essential when you **render HTML as image**
+ to avoid blurry text. - **`ImageConverter.ConvertHtmlToImage`*'
+ - name: 1. Preparing the HTML source
+ text: You can load HTML from a string (as shown), a local file, or a remote URL.
+ - name: 2. Fine‑tuning rendering options
+ text: '| Option | Effect | When to adjust | |--------|--------|----------------|
+ | `UseAntialiasing` | Reduces jagged edges on vector graphics | Always enable
+ for high‑quality output | | `TextOptions.UseHinting` | Sharpens glyph edges
+ | Important for small font sizes | | `FontOptions.WebFontStyle` | Choose'
+ - name: 3. Performing the conversion
+ text: The `ImageConverter` overload you used writes a single PNG file. If you
+ need multiple pages (e.g., a multi‑page HTML document), use the overload that
+ returns a collection of images.
+ - name: a. Missing fonts
+ text: If the HTML references a custom web font that isn’t installed on the server,
+ the rendered text falls back to a default font, which may affect layout.
+ - name: b. Large pages and memory consumption
+ text: Rendering a very tall page can consume a lot of RAM.
+ - name: c. Transparent backgrounds
+ text: PNG supports transparency, but the default background is white.
+ type: HowTo
+tags:
+- Aspose.HTML
+- C#
+- image rendering
+- HTML conversion
+title: Создание PNG из HTML в C# с использованием Aspose.HTML
+url: /ru/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/
+---
+
+{{< blocks/products/pf/main-wrap-class >}}
+{{< blocks/products/pf/main-container >}}
+{{< blocks/products/pf/tutorial-page-section >}}
+
+# Создание PNG из HTML в C# с использованием Aspose.HTML
+
+Если вам нужно **создать PNG из HTML** в приложении .NET, это руководство проведёт вас через весь процесс. Вы увидите, как **конвертировать HTML в PNG** всего несколькими строками кода C#, используя мощный движок рендеринга Aspose.HTML.
+
+Рендеринг HTML в виде изображения — распространённая задача при генерации миниатюр, превью писем или отчётов, которые должны быть встроены в PDF. В последующих разделах вы узнаете точные шаги, увидите полностью рабочий пример и поймёте, почему каждый параметр важен.
+
+## Что вы узнаете
+
+- Как построить `HtmlDocument` из строки или файла.
+- Как настроить `ImageRenderingOptions` для повышения качества.
+- Как **конвертировать HTML в PNG** и сохранить результат на диск.
+- Советы по работе со шрифтами, большими страницами и пользовательскими путями вывода.
+
+**Предварительные требования**
+- .NET 6.0 SDK (или новее) установлен.
+- Действительная лицензия Aspose.HTML for .NET (или временный оценочный ключ).
+- Базовые знания C# и Visual Studio или любой совместимой с .NET IDE.
+
+---
+
+## Создание PNG из HTML с помощью Aspose.HTML
+
+Первый шаг — подготовить окружение и добавить ссылки на необходимые пространства имён Aspose.HTML.
+
+```csharp
+using System;
+using Aspose.Html;
+using Aspose.Html.Rendering.Image;
+using Aspose.Html.Drawing;
+using Aspose.Html.Converters;
+
+namespace HtmlToPngDemo
+{
+ class Program
+ {
+ static void Main()
+ {
+ // 1️⃣ Build the HTML document from a raw string.
+ var html = "Bold text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // 2️⃣ Configure rendering options for best visual fidelity. + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, // Smooths edges of drawn shapes + TextOptions = { UseHinting = true }, // Improves glyph clarity + FontOptions = { WebFontStyle = WebFontStyle.Normal } // Uses standard web‑font style + }; + + // 3️⃣ Convert the HTML document to a PNG file. + string outputPath = @"output.png"; + ImageConverter.ConvertHtmlToImage(document, outputPath, renderOptions); + + Console.WriteLine($"PNG image created at: {outputPath}"); + } + } +} +``` + +### Почему это работает + +- **`HtmlDocument.Open`** разбирает строку HTML в DOM, который может рендерить Aspose.HTML. +- **`ImageRenderingOptions`** позволяет управлять анти‑алиасингом, подсказками текста и обработкой шрифтов, что необходимо при **рендеринге HTML в изображение**, чтобы избежать размытых символов. +- **`ImageConverter.ConvertHtmlToImage`** выполняет основную работу: растеризует DOM в bitmap и записывает файл PNG. + +Запуск программы генерирует `output.png`, содержащий жирный абзац точно так же, как в исходном HTML. + +--- + +## Пошаговое преобразование HTML в PNG + +Ниже более детальный разбор каждой фазы. Понимание назначения каждой строки поможет адаптировать код для более крупных или сложных страниц. + +### 1. Подготовка источника HTML + +HTML можно загрузить из строки (как показано), локального файла или удалённого URL. + +```csharp +// Load from a file +var document = new HtmlDocument(); +document.Open(@"C:\templates\invoice.html"); + +// Load from a URL (requires internet access) +document.Open("https://example.com/report.html"); +``` + +**Подсказка:** При загрузке внешних ресурсов (CSS, изображения) убедитесь, что свойство `BaseUrl` указывает на правильную папку, чтобы относительные ссылки корректно разрешались. + +### 2. Тонкая настройка параметров рендеринга + +| Параметр | Эффект | Когда менять | +|----------|--------|--------------| +| `UseAntialiasing` | Снижает «зубчатость» векторной графики | Всегда включать для высокого качества | +| `TextOptions.UseHinting` | Делает контуры глифов более чёткими | Важно для небольших размеров шрифта | +| `FontOptions.WebFontStyle` | Выбирает обычный, курсивный или наклонный рендеринг веб‑шрифтов | Используйте `WebFontStyle.Oblique` для наклонных шрифтов | +| `ResolutionX` / `ResolutionY` | DPI выходного изображения | Увеличьте для печатных PNG (например, 300 DPI) | + +Пример увеличения DPI: + +```csharp +renderOptions.ResolutionX = 300; +renderOptions.ResolutionY = 300; +``` + +### 3. Выполнение конвертации + +Перегрузка `ImageConverter`, которую вы использовали, записывает один файл PNG. Если нужны несколько страниц (например, многостраничный HTML‑документ), используйте перегрузку, возвращающую коллекцию изображений. + +```csharp +ImageConverter.ConvertHtmlToImages(document, "output_folder", renderOptions); +``` + +Каждая страница будет сохранена как `output_folder/page_0.png`, `page_1.png` и т.д. + +--- + +## Рендеринг HTML в изображение — типичные подводные камни + +### a. Отсутствие шрифтов + +Если HTML ссылается на пользовательский веб‑шрифт, который не установлен на сервере, отрендеренный текст будет заменён шрифтом по умолчанию, что может изменить макет. + +**Решение:** Встроить шрифт с помощью правила `@font-face` в вашем CSS или указать локальную папку шрифтов через `FontOptions`. + +```csharp +renderOptions.FontOptions.FontFolder = @"C:\fonts"; +``` + +### b. Большие страницы и потребление памяти + +Рендеринг очень высокой страницы может потреблять значительный объём ОЗУ. + +**Решение:** Установить максимальную высоту или разбить документ на секции перед конвертацией. + +```csharp +renderOptions.PageHeight = 2000; // pixels +``` + +### c. Прозрачные фоны + +PNG поддерживает прозрачность, но фон по умолчанию — белый. + +**Решение:** Изменить цвет фона на прозрачный. + +```csharp +renderOptions.BackgroundColor = System.Drawing.Color.Transparent; +``` + +--- + +## Как рендерить HTML в изображение — полный пример + +Объединив всё вместе, получаем готовый для продакшна фрагмент, покрывающий самые частые требования: + +```csharp +using System; +using Aspose.Html; +using Aspose.Html.Rendering.Image; +using Aspose.Html.Drawing; +using Aspose.Html.Converters; + +namespace HtmlToPngDemo +{ + class Program + { + static void Main() + { + // Load HTML (string, file, or URL) + string html = "" + + "Bold blue text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // Configure rendering for high quality and transparency + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, + TextOptions = { UseHinting = true }, + FontOptions = { WebFontStyle = WebFontStyle.Normal, FontFolder = @"C:\fonts" }, + BackgroundColor = System.Drawing.Color.Transparent, + ResolutionX = 150, + ResolutionY = 150 + }; + + // Convert and save + string outPath = @"C:\temp\html_snapshot.png"; + ImageConverter.ConvertHtmlToImage(document, outPath, renderOptions); + + Console.WriteLine($"Image saved to {outPath}"); + } + } +} +``` + +**Ожидаемый результат:** Файл `html_snapshot.png`, содержащий жирный синий абзац на прозрачном холсте. Изображение будет анти‑алиасировано, а текст — чётким благодаря подсказкам. + +--- + +## Заключение + +Теперь вы знаете, как **создать PNG из HTML** в C# с помощью Aspose.HTML. Создавая `HtmlDocument`, настраивая `ImageRenderingOptions` и вызывая `ImageConverter.ConvertHtmlToImage`, вы надёжно **конвертируете HTML в PNG** и **рендерите HTML как изображение** для любых сценариев автоматизации. + +Дальше вы можете исследовать: + +- Генерацию миниатюр для динамических веб‑страниц. +- Встраивание PNG в PDF с помощью Aspose.PDF. +- Использование того же подхода для создания JPEG или BMP, изменив расширение файла. + +Экспериментируйте с DPI, цветами фона и многостраничным рендерингом, чтобы точно соответствовать потребностям вашего проекта. Приятного кодинга! + +## Что вам стоит изучить дальше? + +Следующие руководства охватывают тесно связанные темы, расширяющие техники, продемонстрированные в этом руководстве. Каждый ресурс содержит полностью рабочие примеры кода с пошаговыми объяснениями, помогающими освоить дополнительные возможности API и исследовать альтернативные подходы в ваших проектах. + +- [Render HTML as PNG in .NET with Aspose.HTML](/html/english/net/rendering-html-documents/render-html-as-png/) +- [How to Render HTML as PNG – Complete C# Guide](/html/english/net/rendering-html-documents/how-to-render-html-as-png-complete-c-guide/) +- [Create PNG from HTML – Full C# Rendering Guide](/html/english/net/rendering-html-documents/create-png-from-html-full-c-rendering-guide/) + +{{< /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 00354e6733..6fa2fe40e9 100644 --- a/html/russian/net/html-extensions-and-conversions/_index.md +++ b/html/russian/net/html-extensions-and-conversions/_index.md @@ -67,6 +67,8 @@ Aspose.HTML для .NET — это не просто библиотека; эт Откройте для себя мощь Aspose.HTML для .NET: конвертируйте HTML в XPS без усилий. Предварительные условия, пошаговое руководство и часто задаваемые вопросы включены. ### [Как заархивировать HTML в C# – Сохранить HTML в Zip](./how-to-zip-html-in-c-save-html-to-zip/) Узнайте, как упаковать HTML‑файлы в архив ZIP с помощью C# и Aspose.HTML, используя простой пошаговый пример. +### [Сохранить HTML в ZIP в C# – пошаговое руководство](./save-html-as-zip-in-c-step-by-step-guide/) +Пошаговое руководство по сохранению HTML‑страницы в архив ZIP с помощью C# и Aspose.HTML. ### [Создайте HTML‑документ со стилизованным текстом и экспортируйте в PDF – Полное руководство](./create-html-document-with-styled-text-and-export-to-pdf-full/) Пошаговое руководство по созданию HTML‑документа со стилизованным текстом и его конвертации в PDF с помощью Aspose.HTML для .NET. ### [Сохраните HTML в ZIP – Полный учебник C#](./save-html-as-zip-complete-c-tutorial/) diff --git a/html/russian/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md b/html/russian/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..e08e53c84c --- /dev/null +++ b/html/russian/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md @@ -0,0 +1,321 @@ +--- +category: general +date: 2026-08-12 +description: Сохраните HTML в виде ZIP с помощью Aspose.HTML. Узнайте, как загрузить + строку HTML, создать пользовательский обработчик ресурсов и эффективно создать ZIP‑архив. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save html as zip +- load html string +- custom resource handler +language: ru +lastmod: 2026-08-12 +og_description: Сохранить HTML в виде ZIP с помощью Aspose.HTML в C#. Этот учебник + показывает, как загрузить строку HTML, создать пользовательский обработчик ресурсов + и создать ZIP‑архив за несколько шагов. +og_image_alt: Diagram showing save html as zip process with custom resource handler +og_title: Сохранение HTML в ZIP с помощью Aspose.HTML – полное руководство по C# +schemas: +- author: Aspose + dateModified: '2026-08-12' + description: Save HTML as ZIP using Aspose.HTML. Learn to load HTML string, create + a custom resource handler, and generate a ZIP archive efficiently. + headline: Save HTML as ZIP in C# – step‑by‑step guide + type: TechArticle +tags: +- Aspose.HTML +- C# +- ZIP archive +title: Сохранение HTML в ZIP в C# — пошаговое руководство +url: /ru/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Сохранить HTML как ZIP в C# – пошаговое руководство + +Если вам нужно **сохранить HTML как ZIP** в приложении .NET, это руководство показывает полный рабочий процесс. Вы узнаете, как **загрузить строку HTML**, реализовать **пользовательский обработчик ресурсов** и создать ZIP‑архив без записи промежуточных файлов на диск. + +Подход использует Aspose.HTML 5.x, который предоставляет высокопроизводительный движок рендеринга и гибкие параметры сохранения. К концу руководства у вас будет переиспользуемый обработчик, который можно интегрировать в веб‑сервисы, фоновые задачи или настольные инструменты. + +## Что вы создадите + +Конечный код создает ZIP‑файл на основе `MemoryStream`, который содержит документ HTML и все связанные ресурсы (изображения, CSS, шрифты). ZIP‑файл записывается в целевую папку, но вы можете изменить назначение на поток ответа для HTTP‑API. + +## Требования + +- .NET 6.0 или новее (пример ориентирован на .NET 6) +- Aspose.HTML для .NET (NuGet‑пакет `Aspose.HTML`) +- Базовое знакомство с асинхронными паттернами C# (необязательно, но полезно) + +> **Совет:** Установите пакет с помощью `dotnet add package Aspose.HTML` перед началом. + +## Шаг 1: Определите пользовательский обработчик ресурсов + +**Пользовательский обработчик ресурсов** перехватывает каждый внешний запрос ресурса, который делает рендерер HTML. Возвращая поток, вы контролируете, где хранятся данные ресурса. В примере всё сохраняется в памяти, что идеально подходит для создания ZIP‑архива «на лету». + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +///Hello, world!
+
+
+";
+
+// Create a new document instance.
+HtmlDocument document = new HtmlDocument();
+
+// Load the HTML markup.
+document.Open(htmlContent);
+```
+
+**Почему этот шаг важен:**
+Возможность **загрузить строку HTML** полезна, когда HTML генерируется динамически (например, движком шаблонов) или получен из API. Это избавляет от зависимостей от файловой системы и работает в изолированных средах.
+
+## Шаг 3: Настройте параметры сохранения для использования обработчика
+
+`HtmlSaveOptions` из Aspose.HTML позволяют указать механизм хранения вывода. Присвойте пользовательский обработчик свойству `OutputStorage` и установите флаг `Compress`, чтобы создать ZIP‑архив.
+
+```csharp
+// Instantiate the custom handler.
+var resourceHandler = new InMemoryResourceHandler();
+
+// Prepare save options.
+HtmlSaveOptions saveOptions = new HtmlSaveOptions
+{
+ // Use the handler for all external resources.
+ OutputStorage = resourceHandler,
+
+ // Enable ZIP compression.
+ Compress = true
+};
+```
+
+**Почему этот шаг важен:**
+`Compress = true` указывает Aspose.HTML собрать файл HTML и все собранные ресурсы в один ZIP‑пакет. `OutputStorage` гарантирует, что ресурсы захватываются в памяти, а не записываются во временные места.
+
+## Шаг 4: Сохраните документ как ZIP‑архив
+
+Теперь вызовите `HtmlDocument.Save`, передав путь назначения и настроенные параметры. После сохранения ZIP‑файл будет содержать `index.html` и все ресурсы, захваченные обработчиком.
+
+```csharp
+// Define the output path (you can change this to a response stream for web APIs).
+string outputPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+
+// Save the document; Aspose.HTML creates the ZIP automatically.
+document.Save(outputPath, saveOptions);
+
+// Optional: Verify the resources that were stored.
+foreach (var entry in resourceHandler.Resources)
+{
+ Console.WriteLine($"Resource: {entry.Key}, Size: {entry.Value.Length} bytes");
+}
+```
+
+**Ожидаемый результат:**
+Запуск программы создаёт `output.zip` в текущем каталоге. Распаковка архива показывает:
+
+```
+index.html
+styles.css
+logo.png
+```
+
+Каждый файл соответствует ссылкам в разметке, а HTML внутри `index.html` указывает на упакованные ресурсы.
+
+## Шаг 5: Адаптируйте обработчик для реальных данных ресурсов (продвинутый уровень)
+
+Базовый обработчик выше создаёт пустые потоки. В продакшене часто требуется записать реальное содержимое (например, байты `styles.css` или `logo.png`). Расширьте `HandleResource`, чтобы получать данные из базы данных, облачного хранилища или встроенного ресурса.
+
+```csharp
+public override Stream HandleResource(ResourceInfo info)
+{
+ // Example: Load resource from an embedded folder.
+ string resourcePath = Path.Combine("EmbeddedResources", info.Path);
+ byte[] data = File.ReadAllBytes(resourcePath);
+
+ // Write data into a memory stream.
+ var stream = new MemoryStream(data);
+ _resources[info.Path] = stream;
+
+ // Return the populated stream.
+ return stream;
+}
+```
+
+**Почему это важно:**
+Предоставление реального контента гарантирует, что ZIP‑архив будет работать при открытии в браузере. Обработчик также может применять преобразования (например, минификацию CSS) перед записью в поток.
+
+## Шаг 6: Используйте ZIP‑архив в веб‑API (опционально)
+
+Если вы предоставляете функциональность через ASP.NET Core, верните ZIP‑файл как результат файла:
+
+```csharp
+[HttpGet("download")]
+public IActionResult DownloadZip()
+{
+ // Reuse the same logic from steps 1‑4.
+ // ...
+
+ // Read the generated ZIP into a byte array.
+ byte[] zipBytes = System.IO.File.ReadAllBytes(outputPath);
+
+ // Return the file with the appropriate content type.
+ return File(zipBytes, "application/zip", "document.zip");
+}
+```
+
+**Почему этот шаг важен:**
+Клиенты могут скачать упакованный HTML без работы с временными файлами на сервере. Подход работает с безсерверными функциями, где доступ к диску ограничен.
+
+## Распространённые подводные камни и как их избежать
+
+| Проблема | Причина | Решение |
+|----------|---------|---------|
+| Пустые ресурсы в ZIP | Обработчик возвращает новый `MemoryStream` без записи данных | Заполните поток реальными байтами перед возвратом |
+| Отсутствует запись `index.html` | Флаг `Compress` не установлен или `OutputStorage` не назначен | Убедитесь, что `saveOptions.Compress = true` и `saveOptions.OutputStorage = handler` |
+| Большой HTML вызывает нагрузку на память | Все ресурсы хранятся в памяти | Перейдите на реализацию `FileStorage`, которая пишет во временную папку |
+| Относительные URL ломаются после извлечения | Ресурсы указаны абсолютными URL, которые не сохраняются | Перепишите URL в относительные пути внутри обработчика или во время пост‑обработки |
+
+## Полный, исполняемый пример
+
+```csharp
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Saving;
+
+class InMemoryResourceHandler : ResourceHandler
+{
+ private readonly DictionaryHello, world!
+
+
+ ";
+
+ HtmlDocument doc = new HtmlDocument();
+ doc.Open(html);
+
+ // Step 1 & 3: Create handler and configure save options.
+ var handler = new InMemoryResourceHandler();
+ HtmlSaveOptions options = new HtmlSaveOptions
+ {
+ OutputStorage = handler,
+ Compress = true
+ };
+
+ // Step 4: Save as ZIP.
+ string zipPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+ doc.Save(zipPath, options);
+ Console.WriteLine($"ZIP file created at: {zipPath}");
+
+ // Optional verification.
+ foreach (var kvp in handler.Resources)
+ {
+ Console.WriteLine($"Resource {kvp.Key} captured, length {kvp.Value.Length} bytes");
+ }
+ }
+}
+```
+
+Запуск программы создаёт `output.zip` рядом с исполняемым файлом. Распаковка архива показывает `index.html`, `styles.css` и `logo.png` (пустые заглушки в этом минимальном примере).
+
+## Заключение
+
+Теперь у вас есть надёжный метод **сохранить HTML как ZIP** с помощью Aspose.HTML в C#. В руководстве рассмотрены загрузка строки HTML, реализация **пользовательского обработчика ресурсов**, настройка параметров сохранения и генерация ZIP‑архива, готового к распространению или загрузке.
+
+Отсюда вы можете:
+
+- Заменить потоки‑заполнители реальным содержимым (например, читать из базы данных)
+- Перейти на файловый обработчик хранения для очень больших документов
+- Интегрировать логику в конечные точки ASP.NET Core для загрузки по запросу
+- Изучить дополнительные возможности Aspose.HTML, такие как конвертация в PDF или рендеринг изображений
+
+Экспериментируйте с различными источниками ресурсов и настройками сжатия, чтобы адаптировать решение под ваши требования к производительности и размеру. Приятного кодинга!
+
+## Что вам стоит изучить дальше?
+
+Следующие руководства охватывают тесно связанные темы, которые опираются на техники, продемонстрированные в этом руководстве. Каждый ресурс включает полностью работающие примеры кода с пошаговыми объяснениями, чтобы помочь вам освоить дополнительные возможности API и исследовать альтернативные подходы к реализации в ваших проектах.
+
+- [Save HTML as ZIP – Complete C# Tutorial](/html/english/net/html-extensions-and-conversions/save-html-as-zip-complete-c-tutorial/)
+- [How to Save HTML in C# – Complete Guide Using a Custom Resource Handler](/html/english/net/working-with-html-documents/how-to-save-html-in-c-complete-guide-using-a-custom-resource/)
+- [Create HTML from String in C# – Custom Resource Handler Guide](/html/english/net/html-document-manipulation/create-html-from-string-in-c-custom-resource-handler-guide/)
+
+{{< /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/generate-jpg-and-png-images/_index.md b/html/spanish/net/generate-jpg-and-png-images/_index.md
index 4323c45918..c7e28648d8 100644
--- a/html/spanish/net/generate-jpg-and-png-images/_index.md
+++ b/html/spanish/net/generate-jpg-and-png-images/_index.md
@@ -45,6 +45,8 @@ Aprenda a utilizar Aspose.HTML para .NET para manipular documentos HTML, convert
Aprenda a activar el antialiasing al convertir documentos DOCX a imágenes PNG o JPG usando Aspose.HTML para .NET.
### [Convertir docx a PNG – crear archivo ZIP con C# tutorial](./convert-docx-to-png-create-zip-archive-c-tutorial/)
Aprenda a convertir documentos DOCX a imágenes PNG y empaquetarlos en un archivo ZIP usando C#.
+### [Crear PNG a partir de HTML en C# usando Aspose.HTML](./create-png-from-html-in-c-using-aspose-html/)
+Aprenda a generar imágenes PNG desde código HTML usando C# y Aspose.HTML.
## Conclusión
diff --git a/html/spanish/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md b/html/spanish/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
new file mode 100644
index 0000000000..556a7a9269
--- /dev/null
+++ b/html/spanish/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
@@ -0,0 +1,291 @@
+---
+category: general
+date: 2026-08-12
+description: Crear PNG a partir de HTML en C# con Aspose.HTML. Aprende cómo convertir
+ HTML a PNG y renderizar HTML como imagen en solo unas pocas líneas de código.
+draft: false
+images:
+- PLACEHOLDER_URL/og-image.png
+keywords:
+- create png from html
+- convert html to png
+- render html as image
+- how to render html to image
+language: es
+lastmod: 2026-08-12
+og_description: Crear PNG a partir de HTML en C# usando Aspose.HTML. Esta guía muestra
+ cómo renderizar HTML como imagen rápidamente, cubriendo opciones de conversión,
+ configuración del código y solución de problemas.
+og_image_alt: Screenshot of a C# program converting HTML to a PNG image
+og_title: Crear PNG a partir de HTML en C# – guía paso a paso
+schemas:
+- author: Aspose
+ dateModified: '2026-08-12'
+ description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ headline: Create PNG from HTML in C# using Aspose.HTML
+ type: TechArticle
+- description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ name: Create PNG from HTML in C# using Aspose.HTML
+ steps:
+ - name: Why this works
+ text: '- **`HtmlDocument.Open`** parses the HTML string into a DOM that Aspose.HTML
+ can render. - **`ImageRenderingOptions`** lets you control anti‑aliasing, text
+ hinting, and font handling, which are essential when you **render HTML as image**
+ to avoid blurry text. - **`ImageConverter.ConvertHtmlToImage`*'
+ - name: 1. Preparing the HTML source
+ text: You can load HTML from a string (as shown), a local file, or a remote URL.
+ - name: 2. Fine‑tuning rendering options
+ text: '| Option | Effect | When to adjust | |--------|--------|----------------|
+ | `UseAntialiasing` | Reduces jagged edges on vector graphics | Always enable
+ for high‑quality output | | `TextOptions.UseHinting` | Sharpens glyph edges
+ | Important for small font sizes | | `FontOptions.WebFontStyle` | Choose'
+ - name: 3. Performing the conversion
+ text: The `ImageConverter` overload you used writes a single PNG file. If you
+ need multiple pages (e.g., a multi‑page HTML document), use the overload that
+ returns a collection of images.
+ - name: a. Missing fonts
+ text: If the HTML references a custom web font that isn’t installed on the server,
+ the rendered text falls back to a default font, which may affect layout.
+ - name: b. Large pages and memory consumption
+ text: Rendering a very tall page can consume a lot of RAM.
+ - name: c. Transparent backgrounds
+ text: PNG supports transparency, but the default background is white.
+ type: HowTo
+tags:
+- Aspose.HTML
+- C#
+- image rendering
+- HTML conversion
+title: Crear PNG a partir de HTML en C# usando Aspose.HTML
+url: /es/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/
+---
+
+{{< blocks/products/pf/main-wrap-class >}}
+{{< blocks/products/pf/main-container >}}
+{{< blocks/products/pf/tutorial-page-section >}}
+
+# Crear PNG a partir de HTML en C# usando Aspose.HTML
+
+Si necesitas **crear PNG a partir de HTML** en una aplicación .NET, esta guía te lleva paso a paso por todo el proceso. Verás cómo **convertir HTML a PNG** con solo unas pocas líneas de código C#, usando el potente motor de renderizado de Aspose.HTML.
+
+Renderizar HTML como una imagen es un requisito común al generar miniaturas, vistas previas de correos electrónicos o informes que deben incrustarse en PDFs. En las secciones siguientes, aprenderás los pasos exactos, verás un ejemplo completo y entenderás por qué cada configuración es importante.
+
+## Lo que aprenderás
+
+- Cómo crear un `HtmlDocument` a partir de una cadena o archivo.
+- Cómo configurar `ImageRenderingOptions` para mejorar la calidad.
+- Cómo **convertir HTML a PNG** y guardar el resultado en disco.
+- Consejos para manejar fuentes, páginas grandes y rutas de salida personalizadas.
+
+**Requisitos previos**
+- .NET 6.0 SDK (o posterior) instalado.
+- Una licencia válida de Aspose.HTML para .NET (o una clave de evaluación temporal).
+- Familiaridad básica con C# y Visual Studio o cualquier IDE compatible con .NET.
+
+---
+
+## Crear PNG a partir de HTML con Aspose.HTML
+
+El primer paso es configurar el entorno y referenciar los espacios de nombres de Aspose.HTML necesarios.
+
+```csharp
+using System;
+using Aspose.Html;
+using Aspose.Html.Rendering.Image;
+using Aspose.Html.Drawing;
+using Aspose.Html.Converters;
+
+namespace HtmlToPngDemo
+{
+ class Program
+ {
+ static void Main()
+ {
+ // 1️⃣ Build the HTML document from a raw string.
+ var html = "Bold text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // 2️⃣ Configure rendering options for best visual fidelity. + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, // Smooths edges of drawn shapes + TextOptions = { UseHinting = true }, // Improves glyph clarity + FontOptions = { WebFontStyle = WebFontStyle.Normal } // Uses standard web‑font style + }; + + // 3️⃣ Convert the HTML document to a PNG file. + string outputPath = @"output.png"; + ImageConverter.ConvertHtmlToImage(document, outputPath, renderOptions); + + Console.WriteLine($"PNG image created at: {outputPath}"); + } + } +} +``` + +### Por qué funciona esto + +- **`HtmlDocument.Open`** analiza la cadena HTML en un DOM que Aspose.HTML puede renderizar. +- **`ImageRenderingOptions`** te permite controlar el anti‑aliasing, el hinting de texto y el manejo de fuentes, esenciales al **renderizar HTML como imagen** para evitar texto borroso. +- **`ImageConverter.ConvertHtmlToImage`** realiza el trabajo pesado: rasteriza el DOM sobre un bitmap y escribe el archivo PNG. + +Ejecutar el programa genera `output.png` que contiene el párrafo en negrita exactamente como se define en el código HTML. + +--- + +## Convertir HTML a PNG paso a paso + +A continuación se muestra una guía más detallada de cada fase. Entender el propósito de cada línea te ayuda a adaptar el código para páginas más grandes o complejas. + +### 1. Preparando la fuente HTML + +Puedes cargar HTML desde una cadena (como se muestra), un archivo local o una URL remota. + +```csharp +// Load from a file +var document = new HtmlDocument(); +document.Open(@"C:\templates\invoice.html"); + +// Load from a URL (requires internet access) +document.Open("https://example.com/report.html"); +``` + +**Consejo:** Al cargar recursos externos (CSS, imágenes), asegúrate de que la propiedad `BaseUrl` apunte a la carpeta correcta para que los enlaces relativos se resuelvan adecuadamente. + +### 2. Ajuste fino de las opciones de renderizado + +| Opción | Efecto | Cuándo ajustar | +|--------|--------|----------------| +| `UseAntialiasing` | Reduce los bordes irregulares en gráficos vectoriales | Siempre habilitar para salida de alta calidad | +| `TextOptions.UseHinting` | Agudiza los bordes de los glifos | Importante para tamaños de fuente pequeños | +| `FontOptions.WebFontStyle` | Elige renderizado normal, italic o oblique de fuentes web | Usa `WebFontStyle.Oblique` para fuentes inclinadas | +| `ResolutionX` / `ResolutionY` | DPI de la imagen de salida | Incrementar para PNGs listos para impresión (p. ej., 300 DPI) | + +Ejemplo de aumento de DPI: + +```csharp +renderOptions.ResolutionX = 300; +renderOptions.ResolutionY = 300; +``` + +### 3. Realizando la conversión + +La sobrecarga de `ImageConverter` que usaste escribe un solo archivo PNG. Si necesitas varias páginas (p. ej., un documento HTML multipágina), usa la sobrecarga que devuelve una colección de imágenes. + +```csharp +ImageConverter.ConvertHtmlToImages(document, "output_folder", renderOptions); +``` + +Cada página se convierte en `output_folder/page_0.png`, `page_1.png`, etc. + +--- + +## Renderizar HTML como imagen – manejo de problemas comunes + +### a. Fuentes faltantes + +Si el HTML hace referencia a una fuente web personalizada que no está instalada en el servidor, el texto renderizado recurre a una fuente predeterminada, lo que puede afectar el diseño. + +**Solución:** Incruste la fuente usando una regla `@font-face` en su CSS o proporcione una carpeta de fuentes local mediante `FontOptions`. + +```csharp +renderOptions.FontOptions.FontFolder = @"C:\fonts"; +``` + +### b. Páginas grandes y consumo de memoria + +Renderizar una página muy alta puede consumir mucha RAM. + +**Solución:** Establezca una altura máxima o divida el documento en secciones antes de la conversión. + +```csharp +renderOptions.PageHeight = 2000; // pixels +``` + +### c. Fondos transparentes + +PNG admite transparencia, pero el fondo predeterminado es blanco. + +**Solución:** Cambie el color de fondo a transparente. + +```csharp +renderOptions.BackgroundColor = System.Drawing.Color.Transparent; +``` + +--- + +## Cómo renderizar HTML a imagen – resumen del ejemplo completo + +Juntando todo, aquí tienes un fragmento listo para producción que cubre los requisitos más frecuentes: + +```csharp +using System; +using Aspose.Html; +using Aspose.Html.Rendering.Image; +using Aspose.Html.Drawing; +using Aspose.Html.Converters; + +namespace HtmlToPngDemo +{ + class Program + { + static void Main() + { + // Load HTML (string, file, or URL) + string html = "" + + "Bold blue text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // Configure rendering for high quality and transparency + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, + TextOptions = { UseHinting = true }, + FontOptions = { WebFontStyle = WebFontStyle.Normal, FontFolder = @"C:\fonts" }, + BackgroundColor = System.Drawing.Color.Transparent, + ResolutionX = 150, + ResolutionY = 150 + }; + + // Convert and save + string outPath = @"C:\temp\html_snapshot.png"; + ImageConverter.ConvertHtmlToImage(document, outPath, renderOptions); + + Console.WriteLine($"Image saved to {outPath}"); + } + } +} +``` + +**Salida esperada:** Un archivo `html_snapshot.png` que contiene un párrafo en negrita y azul sobre un lienzo transparente. La imagen será anti‑alias, con texto nítido gracias al hinting. + +--- + +## Conclusión + +Ahora sabes cómo **crear PNG a partir de HTML** en C# usando Aspose.HTML. Al construir un `HtmlDocument`, configurar `ImageRenderingOptions` y llamar a `ImageConverter.ConvertHtmlToImage`, puedes convertir de forma fiable **HTML a PNG** y **renderizar HTML como imagen** para cualquier escenario de automatización. + +A partir de aquí podrías explorar: + +- Generar miniaturas para páginas web dinámicas. +- Incrustar el PNG en PDFs con Aspose.PDF. +- Usar el mismo enfoque para producir JPEG o BMP cambiando la extensión del archivo. + +¡Siéntete libre de experimentar con DPI, colores de fondo y renderizado multipágina para adaptarlo a las necesidades exactas de tu proyecto. ¡Feliz codificación! + +## ¿Qué deberías aprender a continuación? + +Los siguientes tutoriales cubren temas estrechamente relacionados que se basan en las técnicas demostradas en esta guía. Cada recurso incluye ejemplos de código completos y funcionales con explicaciones paso a paso para ayudarle a dominar características adicionales de la API y explorar enfoques de implementación alternativos en sus propios proyectos. + +- [Renderizar HTML como PNG en .NET con Aspose.HTML](/html/english/net/rendering-html-documents/render-html-as-png/) +- [Cómo renderizar HTML como PNG – Guía completa en C#](/html/english/net/rendering-html-documents/how-to-render-html-as-png-complete-c-guide/) +- [Crear PNG a partir de HTML – Guía completa de renderizado en C#](/html/english/net/rendering-html-documents/create-png-from-html-full-c-rendering-guide/) + +{{< /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 58e38eec45..ada2480e16 100644 --- a/html/spanish/net/html-extensions-and-conversions/_index.md +++ b/html/spanish/net/html-extensions-and-conversions/_index.md @@ -65,6 +65,8 @@ Convierta HTML a MHTML en .NET con Aspose.HTML: una guía paso a paso para archi Descubra cómo utilizar Aspose.HTML para .NET para manipular y convertir documentos HTML. Guía paso a paso para un desarrollo .NET eficaz. ### [Guardar HTML como ZIP – Tutorial completo en C#](./save-html-as-zip-complete-c-tutorial/) Aprenda a guardar documentos HTML como archivos ZIP usando Aspose.HTML para .NET con este tutorial paso a paso en C#. +### [Guardar HTML como ZIP en C# – guía paso a paso](./save-html-as-zip-in-c-step-by-step-guide/) +Aprenda a guardar documentos HTML en un archivo ZIP usando C# y Aspose.HTML con esta guía paso a paso. ### [Convierte HTML a TIFF en .NET con Aspose.HTML](./convert-html-to-tiff/) Aprenda a convertir HTML a TIFF con Aspose.HTML para .NET. Siga nuestra guía paso a paso para optimizar eficazmente el contenido web. ### [Convierta HTML a XPS en .NET con Aspose.HTML](./convert-html-to-xps/) diff --git a/html/spanish/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md b/html/spanish/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..9bd7bbd59b --- /dev/null +++ b/html/spanish/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md @@ -0,0 +1,322 @@ +--- +category: general +date: 2026-08-12 +description: Guardar HTML como ZIP usando Aspose.HTML. Aprende a cargar una cadena + HTML, crear un controlador de recursos personalizado y generar un archivo ZIP de + manera eficiente. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save html as zip +- load html string +- custom resource handler +language: es +lastmod: 2026-08-12 +og_description: Guardar HTML como ZIP usando Aspose.HTML en C#. Este tutorial muestra + cómo cargar una cadena HTML, crear un controlador de recursos personalizado y generar + un archivo ZIP en unos pocos pasos. +og_image_alt: Diagram showing save html as zip process with custom resource handler +og_title: Guardar HTML como ZIP con Aspose.HTML – guía completa de C# +schemas: +- author: Aspose + dateModified: '2026-08-12' + description: Save HTML as ZIP using Aspose.HTML. Learn to load HTML string, create + a custom resource handler, and generate a ZIP archive efficiently. + headline: Save HTML as ZIP in C# – step‑by‑step guide + type: TechArticle +tags: +- Aspose.HTML +- C# +- ZIP archive +title: Guardar HTML como ZIP en C# – guía paso a paso +url: /es/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Guardar HTML como ZIP en C# – guía paso a paso + +Si necesitas **guardar HTML como ZIP** en una aplicación .NET, esta guía muestra el flujo de trabajo completo. Aprenderás cómo **cargar una cadena HTML**, implementar un **manejador de recursos personalizado** y generar un archivo ZIP sin escribir archivos intermedios en disco. + +El enfoque utiliza Aspose.HTML 5.x, que ofrece un motor de renderizado de alto rendimiento y opciones flexibles de guardado. Al final del tutorial tendrás un manejador reutilizable que puede integrarse en servicios web, trabajos en segundo plano o herramientas de escritorio. + +## Lo que vas a construir + +El código final crea un archivo ZIP basado en `MemoryStream` que contiene el documento HTML y cualquier recurso referenciado (imágenes, CSS, fuentes). El archivo ZIP se escribe en una carpeta de destino, pero puedes cambiar la ubicación a un flujo de respuesta para APIs HTTP. + +## Requisitos previos + +- .NET 6.0 o superior (el ejemplo está dirigido a .NET 6) +- Aspose.HTML para .NET (paquete NuGet `Aspose.HTML`) +- Familiaridad básica con los patrones async de C# (opcional pero útil) + +> **Consejo profesional:** Instala el paquete con `dotnet add package Aspose.HTML` antes de comenzar. + +## Paso 1: Definir un manejador de recursos personalizado + +Un **manejador de recursos personalizado** intercepta cada solicitud de recurso externo que hace el motor de renderizado HTML. Al devolver un flujo, controlas dónde se almacena la información del recurso. El ejemplo almacena todo en memoria, lo que es ideal para crear un archivo ZIP sobre la marcha. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +///Hello, world!
+
+
+";
+
+// Create a new document instance.
+HtmlDocument document = new HtmlDocument();
+
+// Load the HTML markup.
+document.Open(htmlContent);
+```
+
+**Por qué este paso es importante:**
+La capacidad de **cargar cadena HTML** es útil cuando el HTML se genera dinámicamente (p. ej., desde un motor de plantillas) o se recibe de una API. Evita dependencias del sistema de archivos y funciona en entornos aislados.
+
+## Paso 3: Configurar opciones de guardado para usar el manejador
+
+`HtmlSaveOptions` de Aspose.HTML te permite especificar el mecanismo de almacenamiento para la salida. Asigna el manejador personalizado a la propiedad `OutputStorage` y establece la bandera `Compress` para producir un archivo ZIP.
+
+```csharp
+// Instantiate the custom handler.
+var resourceHandler = new InMemoryResourceHandler();
+
+// Prepare save options.
+HtmlSaveOptions saveOptions = new HtmlSaveOptions
+{
+ // Use the handler for all external resources.
+ OutputStorage = resourceHandler,
+
+ // Enable ZIP compression.
+ Compress = true
+};
+```
+
+**Por qué este paso es importante:**
+`Compress = true` indica a Aspose.HTML que agrupe el archivo HTML y todos los recursos recopilados en un único paquete ZIP. `OutputStorage` garantiza que los recursos se capturen en memoria en lugar de escribirse en ubicaciones temporales.
+
+## Paso 4: Guardar el documento como archivo ZIP
+
+Ahora invoca `HtmlDocument.Save`, pasando la ruta de destino y las opciones configuradas. Después de guardar, el archivo ZIP contiene `index.html` más cualquier recurso capturado por el manejador.
+
+```csharp
+// Define the output path (you can change this to a response stream for web APIs).
+string outputPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+
+// Save the document; Aspose.HTML creates the ZIP automatically.
+document.Save(outputPath, saveOptions);
+
+// Optional: Verify the resources that were stored.
+foreach (var entry in resourceHandler.Resources)
+{
+ Console.WriteLine($"Resource: {entry.Key}, Size: {entry.Value.Length} bytes");
+}
+```
+
+**Resultado esperado:**
+Ejecutar el programa crea `output.zip` en el directorio actual. Al extraer el archivo se muestra:
+
+```
+index.html
+styles.css
+logo.png
+```
+
+Cada archivo coincide con las referencias del marcado, y el HTML dentro de `index.html` apunta a los recursos empaquetados.
+
+## Paso 5: Adaptar el manejador para datos reales de recursos (avanzado)
+
+El manejador básico anterior crea flujos vacíos. En producción a menudo necesitas escribir el contenido real (p. ej., los bytes de `styles.css` o `logo.png`). Extiende `HandleResource` para obtener datos de una base de datos, un bucket en la nube o un recurso incrustado.
+
+```csharp
+public override Stream HandleResource(ResourceInfo info)
+{
+ // Example: Load resource from an embedded folder.
+ string resourcePath = Path.Combine("EmbeddedResources", info.Path);
+ byte[] data = File.ReadAllBytes(resourcePath);
+
+ // Write data into a memory stream.
+ var stream = new MemoryStream(data);
+ _resources[info.Path] = stream;
+
+ // Return the populated stream.
+ return stream;
+}
+```
+
+**Por qué esta variación es importante:**
+Proporcionar contenido real asegura que el archivo ZIP sea funcional al abrirse en un navegador. El manejador también puede aplicar transformaciones (p. ej., minificar CSS) antes de escribir en el flujo.
+
+## Paso 6: Usar el archivo ZIP en una API web (opcional)
+
+Si expones la funcionalidad a través de ASP.NET Core, devuelve el archivo ZIP como un resultado de archivo:
+
+```csharp
+[HttpGet("download")]
+public IActionResult DownloadZip()
+{
+ // Reuse the same logic from steps 1‑4.
+ // ...
+
+ // Read the generated ZIP into a byte array.
+ byte[] zipBytes = System.IO.File.ReadAllBytes(outputPath);
+
+ // Return the file with the appropriate content type.
+ return File(zipBytes, "application/zip", "document.zip");
+}
+```
+
+**Por qué este paso es importante:**
+Los clientes pueden descargar el HTML empaquetado sin lidiar con archivos temporales en el servidor. El enfoque funciona con funciones sin servidor donde el acceso a disco es limitado.
+
+## Problemas comunes y cómo evitarlos
+
+| Problema | Razón | Solución |
+|----------|-------|----------|
+| Recursos vacíos en el ZIP | El manejador devuelve un `MemoryStream` nuevo sin escribir datos | Poblar el flujo con los bytes reales antes de devolverlo |
+| Falta la entrada `index.html` | La bandera `Compress` no está activada o `OutputStorage` no está asignado | Asegurarse de que `saveOptions.Compress = true` y `saveOptions.OutputStorage = handler` |
+| HTML grande que genera presión de memoria | Todos los recursos se mantienen en memoria | Cambiar a una implementación `FileStorage` que escriba en una carpeta temporal |
+| URLs relativas se rompen tras la extracción | Recursos referenciados con URLs absolutas que no se almacenan | Reescribir URLs a rutas relativas dentro del manejador o durante el post‑procesamiento |
+
+## Ejemplo completo y ejecutable
+
+```csharp
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Saving;
+
+class InMemoryResourceHandler : ResourceHandler
+{
+ private readonly DictionaryHello, world!
+
+
+ ";
+
+ HtmlDocument doc = new HtmlDocument();
+ doc.Open(html);
+
+ // Step 1 & 3: Create handler and configure save options.
+ var handler = new InMemoryResourceHandler();
+ HtmlSaveOptions options = new HtmlSaveOptions
+ {
+ OutputStorage = handler,
+ Compress = true
+ };
+
+ // Step 4: Save as ZIP.
+ string zipPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+ doc.Save(zipPath, options);
+ Console.WriteLine($"ZIP file created at: {zipPath}");
+
+ // Optional verification.
+ foreach (var kvp in handler.Resources)
+ {
+ Console.WriteLine($"Resource {kvp.Key} captured, length {kvp.Value.Length} bytes");
+ }
+ }
+}
+```
+
+Ejecutar el programa produce `output.zip` junto al ejecutable. Al extraer el archivo se muestra `index.html`, `styles.css` y `logo.png` (marcadores de posición vacíos en este ejemplo mínimo).
+
+## Conclusión
+
+Ahora dispones de un método fiable para **guardar HTML como ZIP** usando Aspose.HTML en C#. El tutorial cubrió la carga de una cadena HTML, la implementación de un **manejador de recursos personalizado**, la configuración de opciones de guardado y la generación de un archivo ZIP listo para distribución o descarga.
+
+A partir de aquí puedes:
+
+- Reemplazar los flujos de marcador de posición con contenido real (p. ej., leer de una base de datos)
+- Cambiar a un manejador de almacenamiento basado en archivos para documentos muy grandes
+- Integrar la lógica en endpoints de ASP.NET Core para descargas bajo demanda
+- Explorar características adicionales de Aspose.HTML como conversión a PDF o renderizado de imágenes
+
+Experimenta con diferentes fuentes de recursos y configuraciones de compresión para adaptar la solución a tus requisitos de rendimiento y tamaño. ¡Feliz codificación!
+
+## ¿Qué deberías aprender a continuación?
+
+Los siguientes tutoriales cubren temas estrechamente relacionados que amplían las técnicas demostradas en esta guía. Cada recurso incluye ejemplos de código completos y funcionales con explicaciones paso a paso para ayudarte a dominar características adicionales de la API y explorar enfoques de implementación alternativos en tus propios proyectos.
+
+- [Save HTML as ZIP – Complete C# Tutorial](/html/english/net/html-extensions-and-conversions/save-html-as-zip-complete-c-tutorial/)
+- [How to Save HTML in C# – Complete Guide Using a Custom Resource Handler](/html/english/net/working-with-html-documents/how-to-save-html-in-c-complete-guide-using-a-custom-resource/)
+- [Create HTML from String in C# – Custom Resource Handler Guide](/html/english/net/html-document-manipulation/create-html-from-string-in-c-custom-resource-handler-guide/)
+
+{{< /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/generate-jpg-and-png-images/_index.md b/html/swedish/net/generate-jpg-and-png-images/_index.md
index 39785fb465..255656b27d 100644
--- a/html/swedish/net/generate-jpg-and-png-images/_index.md
+++ b/html/swedish/net/generate-jpg-and-png-images/_index.md
@@ -45,6 +45,8 @@ Lär dig att använda Aspose.HTML för .NET för att manipulera HTML-dokument, k
Lär dig hur du aktiverar kantutjämning för att förbättra bildkvaliteten när du konverterar DOCX-dokument till PNG eller JPG med Aspose.HTML.
### [Konvertera DOCX till PNG – skapa zip‑arkiv C#‑handledning](./convert-docx-to-png-create-zip-archive-c-tutorial/)
Lär dig hur du konverterar DOCX-filer till PNG-bilder och packar dem i ett zip‑arkiv med C# och Aspose.HTML.
+### [Skapa PNG från HTML i C# med Aspose.HTML](./create-png-from-html-in-c-using-aspose-html/)
+Lär dig hur du skapar PNG-bilder från HTML med Aspose.HTML i C#.
## Slutsats
diff --git a/html/swedish/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md b/html/swedish/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
new file mode 100644
index 0000000000..72a9d29e7c
--- /dev/null
+++ b/html/swedish/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
@@ -0,0 +1,291 @@
+---
+category: general
+date: 2026-08-12
+description: Skapa PNG från HTML i C# med Aspose.HTML. Lär dig hur du konverterar
+ HTML till PNG och renderar HTML som bild med bara några rader kod.
+draft: false
+images:
+- PLACEHOLDER_URL/og-image.png
+keywords:
+- create png from html
+- convert html to png
+- render html as image
+- how to render html to image
+language: sv
+lastmod: 2026-08-12
+og_description: Skapa PNG från HTML i C# med Aspose.HTML. Denna guide visar hur du
+ snabbt renderar HTML som bild, och täcker konverteringsalternativ, kodinställning
+ och felsökning.
+og_image_alt: Screenshot of a C# program converting HTML to a PNG image
+og_title: Skapa PNG från HTML i C# – steg‑för‑steg guide
+schemas:
+- author: Aspose
+ dateModified: '2026-08-12'
+ description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ headline: Create PNG from HTML in C# using Aspose.HTML
+ type: TechArticle
+- description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ name: Create PNG from HTML in C# using Aspose.HTML
+ steps:
+ - name: Why this works
+ text: '- **`HtmlDocument.Open`** parses the HTML string into a DOM that Aspose.HTML
+ can render. - **`ImageRenderingOptions`** lets you control anti‑aliasing, text
+ hinting, and font handling, which are essential when you **render HTML as image**
+ to avoid blurry text. - **`ImageConverter.ConvertHtmlToImage`*'
+ - name: 1. Preparing the HTML source
+ text: You can load HTML from a string (as shown), a local file, or a remote URL.
+ - name: 2. Fine‑tuning rendering options
+ text: '| Option | Effect | When to adjust | |--------|--------|----------------|
+ | `UseAntialiasing` | Reduces jagged edges on vector graphics | Always enable
+ for high‑quality output | | `TextOptions.UseHinting` | Sharpens glyph edges
+ | Important for small font sizes | | `FontOptions.WebFontStyle` | Choose'
+ - name: 3. Performing the conversion
+ text: The `ImageConverter` overload you used writes a single PNG file. If you
+ need multiple pages (e.g., a multi‑page HTML document), use the overload that
+ returns a collection of images.
+ - name: a. Missing fonts
+ text: If the HTML references a custom web font that isn’t installed on the server,
+ the rendered text falls back to a default font, which may affect layout.
+ - name: b. Large pages and memory consumption
+ text: Rendering a very tall page can consume a lot of RAM.
+ - name: c. Transparent backgrounds
+ text: PNG supports transparency, but the default background is white.
+ type: HowTo
+tags:
+- Aspose.HTML
+- C#
+- image rendering
+- HTML conversion
+title: Skapa PNG från HTML i C# med Aspose.HTML
+url: /sv/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/
+---
+
+{{< blocks/products/pf/main-wrap-class >}}
+{{< blocks/products/pf/main-container >}}
+{{< blocks/products/pf/tutorial-page-section >}}
+
+# Skapa PNG från HTML i C# med Aspose.HTML
+
+Om du behöver **skapa PNG från HTML** i en .NET-applikation, guidar den här guiden dig genom hela processen. Du kommer att se hur du **konverterar HTML till PNG** med bara några rader C#-kod, med hjälp av Aspose.HTML:s kraftfulla renderingsmotor.
+
+Att rendera HTML som en bild är ett vanligt krav när man genererar miniatyrbilder, e‑postförhandsgranskningar eller rapporter som måste bäddas in i PDF-filer. I avsnitten som följer kommer du att lära dig de exakta stegen, se ett komplett fungerande exempel och förstå varför varje inställning är viktig.
+
+## Vad du kommer att lära dig
+
+- Hur man bygger ett `HtmlDocument` från en sträng eller fil.
+- Hur man konfigurerar `ImageRenderingOptions` för att förbättra kvaliteten.
+- Hur man **konverterar HTML till PNG** och sparar resultatet till disk.
+- Tips för att hantera teckensnitt, stora sidor och anpassade utskriftsvägar.
+
+**Förutsättningar**
+- .NET 6.0 SDK (eller senare) installerat.
+- En giltig Aspose.HTML för .NET-licens (eller en tillfällig utvärderingsnyckel).
+- Grundläggande kunskap om C# och Visual Studio eller någon .NET‑kompatibel IDE.
+
+---
+
+## Skapa PNG från HTML med Aspose.HTML
+
+Det första steget är att konfigurera miljön och referera de nödvändiga Aspose.HTML-namespace‑erna.
+
+```csharp
+using System;
+using Aspose.Html;
+using Aspose.Html.Rendering.Image;
+using Aspose.Html.Drawing;
+using Aspose.Html.Converters;
+
+namespace HtmlToPngDemo
+{
+ class Program
+ {
+ static void Main()
+ {
+ // 1️⃣ Build the HTML document from a raw string.
+ var html = "Bold text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // 2️⃣ Configure rendering options for best visual fidelity. + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, // Smooths edges of drawn shapes + TextOptions = { UseHinting = true }, // Improves glyph clarity + FontOptions = { WebFontStyle = WebFontStyle.Normal } // Uses standard web‑font style + }; + + // 3️⃣ Convert the HTML document to a PNG file. + string outputPath = @"output.png"; + ImageConverter.ConvertHtmlToImage(document, outputPath, renderOptions); + + Console.WriteLine($"PNG image created at: {outputPath}"); + } + } +} +``` + +### Varför detta fungerar + +- **`HtmlDocument.Open`** parsar HTML‑strängen till ett DOM som Aspose.HTML kan rendera. +- **`ImageRenderingOptions`** låter dig kontrollera anti‑aliasing, text‑hinting och teckensnittshantering, vilket är viktigt när du **renderar HTML som bild** för att undvika suddig text. +- **`ImageConverter.ConvertHtmlToImage`** utför det tunga arbetet: den rasteriserar DOM‑en till en bitmap och skriver PNG‑filen. + +När programmet körs genereras `output.png` som innehåller det fetstilta stycket exakt som definierat i HTML‑källan. + +--- + +## Konvertera HTML till PNG steg för steg + +Nedan följer en mer detaljerad genomgång av varje fas. Att förstå syftet med varje rad hjälper dig att anpassa koden för större eller mer komplexa sidor. + +### 1. Förbereda HTML‑källan + +Du kan ladda HTML från en sträng (som visas), en lokal fil eller en fjärr‑URL. + +```csharp +// Load from a file +var document = new HtmlDocument(); +document.Open(@"C:\templates\invoice.html"); + +// Load from a URL (requires internet access) +document.Open("https://example.com/report.html"); +``` + +**Tips:** När du laddar externa resurser (CSS, bilder), se till att `BaseUrl`‑egenskapen pekar på rätt mapp så att relativa länkar löses korrekt. + +### 2. Finjustera renderingsalternativ + +| Option | Effect | When to adjust | +|--------|--------|----------------| +| `UseAntialiasing` | Minskar hackiga kanter på vektorgrafik | Aktivera alltid för högkvalitativ output | +| `TextOptions.UseHinting` | Skärper glyfkanter | Viktigt för små teckensnittsstorlekar | +| `FontOptions.WebFontStyle` | Väljer normal, kursiv eller sned web‑fontrendering | Använd `WebFontStyle.Oblique` för snedställda teckensnitt | +| `ResolutionX` / `ResolutionY` | DPI för utdata‑bilden | Öka för utskriftsklara PNG‑filer (t.ex. 300 DPI) | + +Exempel på att öka DPI: + +```csharp +renderOptions.ResolutionX = 300; +renderOptions.ResolutionY = 300; +``` + +### 3. Utföra konverteringen + +`ImageConverter`‑överladdningen du använde skriver en enskild PNG‑fil. Om du behöver flera sidor (t.ex. ett flersidigt HTML‑dokument), använd den overload som returnerar en samling bilder. + +```csharp +ImageConverter.ConvertHtmlToImages(document, "output_folder", renderOptions); +``` + +Varje sida blir `output_folder/page_0.png`, `page_1.png`, osv. + +--- + +## Rendera HTML som bild – hantera vanliga fallgropar + +### a. Saknade teckensnitt + +Om HTML‑koden refererar till ett anpassat web‑font som inte är installerat på servern, faller den renderade texten tillbaka till ett standardteckensnitt, vilket kan påverka layouten. + +**Lösning:** Bädda in teckensnittet med en `@font-face`‑regel i din CSS eller ange en lokal teckensnittsmapp via `FontOptions`. + +```csharp +renderOptions.FontOptions.FontFolder = @"C:\fonts"; +``` + +### b. Stora sidor och minnesförbrukning + +Att rendera en mycket hög sida kan förbruka mycket RAM. + +**Lösning:** Sätt en maximal höjd eller dela upp dokumentet i sektioner innan konvertering. + +```csharp +renderOptions.PageHeight = 2000; // pixels +``` + +### c. Transparenta bakgrunder + +PNG stödjer transparens, men standardbakgrunden är vit. + +**Lösning:** Ändra bakgrundsfärgen till transparent. + +```csharp +renderOptions.BackgroundColor = System.Drawing.Color.Transparent; +``` + +--- + +## Så renderar du HTML till bild – komplett exempelöversikt + +När allt sätts ihop, här är ett produktionsklart kodsnutt som täcker de vanligaste kraven: + +```csharp +using System; +using Aspose.Html; +using Aspose.Html.Rendering.Image; +using Aspose.Html.Drawing; +using Aspose.Html.Converters; + +namespace HtmlToPngDemo +{ + class Program + { + static void Main() + { + // Load HTML (string, file, or URL) + string html = "" + + "Bold blue text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // Configure rendering for high quality and transparency + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, + TextOptions = { UseHinting = true }, + FontOptions = { WebFontStyle = WebFontStyle.Normal, FontFolder = @"C:\fonts" }, + BackgroundColor = System.Drawing.Color.Transparent, + ResolutionX = 150, + ResolutionY = 150 + }; + + // Convert and save + string outPath = @"C:\temp\html_snapshot.png"; + ImageConverter.ConvertHtmlToImage(document, outPath, renderOptions); + + Console.WriteLine($"Image saved to {outPath}"); + } + } +} +``` + +**Förväntad output:** En `html_snapshot.png`‑fil som innehåller ett fetstilt, blått stycke på en transparent canvas. Bilden kommer att vara anti‑aliasad, med skarp text tack vare hinting. + +--- + +## Slutsats + +Du vet nu hur du **skapar PNG från HTML** i C# med Aspose.HTML. Genom att konstruera ett `HtmlDocument`, konfigurera `ImageRenderingOptions` och anropa `ImageConverter.ConvertHtmlToImage` kan du på ett pålitligt sätt **konvertera HTML till PNG** och **rendera HTML som bild** för alla automatiseringsscenarier. + +Från och med nu kan du utforska: + +- Generera miniatyrbilder för dynamiska webbsidor. +- Bädda in PNG‑filen i PDF‑filer med Aspose.PDF. +- Använd samma metod för att producera JPEG eller BMP genom att ändra filändelsen. + +Känn dig fri att experimentera med DPI, bakgrundsfärger och flersidig rendering för att passa ditt projekts exakta behov. Lycka till med kodningen! + +## Vad bör du lära dig härnäst? + +Följande handledningar täcker närbesläktade ämnen som bygger på teknikerna som demonstrerats i den här guiden. Varje resurs innehåller kompletta fungerande kodexempel med steg‑för‑steg‑förklaringar för att hjälpa dig bemästra ytterligare API‑funktioner och utforska alternativa implementationsmetoder i dina egna projekt. + +- [Rendera HTML som PNG i .NET med Aspose.HTML](/html/english/net/rendering-html-documents/render-html-as-png/) +- [Hur man renderar HTML som PNG – Komplett C#‑guide](/html/english/net/rendering-html-documents/how-to-render-html-as-png-complete-c-guide/) +- [Skapa PNG från HTML – Fullständig C#‑renderingsguide](/html/english/net/rendering-html-documents/create-png-from-html-full-c-rendering-guide/) + +{{< /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 6d01c9b961..334b59e49f 100644 --- a/html/swedish/net/html-extensions-and-conversions/_index.md +++ b/html/swedish/net/html-extensions-and-conversions/_index.md @@ -73,6 +73,8 @@ Skapa PDF från HTML med C# och Aspose.HTML för .NET. Följ vår steg‑för‑ Lär dig hur du sparar HTML som en ZIP-fil med en komplett C#-kodexempel och steg-för-steg-instruktioner. ### [Spara HTML till ZIP i C# – Komplett minnesexempel](./save-html-to-zip-in-c-complete-in-memory-example/) Lär dig hur du sparar HTML-filer i ett ZIP‑arkiv i minnet med C# och Aspose.HTML. +### [Spara HTML som ZIP i C# – steg‑för‑steg‑guide](./save-html-as-zip-in-c-step-by-step-guide/) +Lär dig hur du sparar HTML-filer i ett ZIP‑arkiv med C# och Aspose.HTML i en detaljerad steg‑för‑steg‑guide. ## Slutsats diff --git a/html/swedish/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md b/html/swedish/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..fa71b10703 --- /dev/null +++ b/html/swedish/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md @@ -0,0 +1,321 @@ +--- +category: general +date: 2026-08-12 +description: Spara HTML som ZIP med Aspose.HTML. Lär dig att läsa in en HTML-sträng, + skapa en anpassad resurs‑hanterare och generera ett ZIP‑arkiv effektivt. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save html as zip +- load html string +- custom resource handler +language: sv +lastmod: 2026-08-12 +og_description: Spara HTML som ZIP med Aspose.HTML i C#. Denna handledning visar hur + du laddar en HTML-sträng, skapar en anpassad resurs‑hanterare och genererar ett + ZIP‑arkiv i några steg. +og_image_alt: Diagram showing save html as zip process with custom resource handler +og_title: Spara HTML som ZIP med Aspose.HTML – komplett C#‑guide +schemas: +- author: Aspose + dateModified: '2026-08-12' + description: Save HTML as ZIP using Aspose.HTML. Learn to load HTML string, create + a custom resource handler, and generate a ZIP archive efficiently. + headline: Save HTML as ZIP in C# – step‑by‑step guide + type: TechArticle +tags: +- Aspose.HTML +- C# +- ZIP archive +title: Spara HTML som ZIP i C# – steg‑för‑steg guide +url: /sv/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Spara HTML som ZIP i C# – steg‑för‑steg guide + +Om du behöver **spara HTML som ZIP** i en .NET‑applikation visar den här guiden hela arbetsflödet. Du kommer att lära dig hur du **läser in HTML‑sträng**, implementerar en **anpassad resurs‑hanterare** och skapar ett ZIP‑arkiv utan att skriva mellanfiler till disk. + +Metoden använder Aspose.HTML 5.x, som erbjuder en högpresterande renderingsmotor och flexibla sparalternativ. I slutet av tutorialen har du en återanvändbar hanterare som kan integreras i webbtjänster, bakgrundsjobb eller skrivbordsverktyg. + +## Vad du kommer att bygga + +Den färdiga koden skapar en `MemoryStream`‑baserad ZIP‑fil som innehåller HTML‑dokumentet och alla refererade resurser (bilder, CSS, teckensnitt). ZIP‑filen skrivs till en mål‑mapp, men du kan ändra destinationen till en svarström för HTTP‑API:er. + +## Förutsättningar + +- .NET 6.0 eller senare (exemplet riktar sig mot .NET 6) +- Aspose.HTML för .NET (NuGet‑paketet `Aspose.HTML`) +- Grundläggande kunskap om C#‑asynkrona mönster (valfritt men hjälpsamt) + +> **Proffstips:** Installera paketet med `dotnet add package Aspose.HTML` innan du börjar. + +## Steg 1: Definiera en anpassad resurs‑hanterare + +En **anpassad resurs‑hanterare** avbryter varje extern resursförfrågan som HTML‑renderaren gör. Genom att returnera en ström styr du var resursdata lagras. Exemplet lagrar allt i minnet, vilket är idealiskt för att skapa ett ZIP‑arkiv i farten. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +///Hello, world!
+
+
+";
+
+// Create a new document instance.
+HtmlDocument document = new HtmlDocument();
+
+// Load the HTML markup.
+document.Open(htmlContent);
+```
+
+**Varför detta steg är viktigt:**
+Funktionen **load html string** är användbar när HTML genereras dynamiskt (t.ex. från en mallmotor) eller tas emot från ett API. Den undviker filsystem‑beroenden och fungerar i sandbox‑miljöer.
+
+## Steg 3: Konfigurera sparalternativ för att använda hanteraren
+
+Aspose.HTML:s `HtmlSaveOptions` låter dig ange lagringsmekanismen för utdata. Tilldela den anpassade hanteraren till egenskapen `OutputStorage` och sätt `Compress`‑flaggan för att producera ett ZIP‑arkiv.
+
+```csharp
+// Instantiate the custom handler.
+var resourceHandler = new InMemoryResourceHandler();
+
+// Prepare save options.
+HtmlSaveOptions saveOptions = new HtmlSaveOptions
+{
+ // Use the handler for all external resources.
+ OutputStorage = resourceHandler,
+
+ // Enable ZIP compression.
+ Compress = true
+};
+```
+
+**Varför detta steg är viktigt:**
+`Compress = true` instruerar Aspose.HTML att paketera HTML‑filen och alla insamlade resurser i ett enda ZIP‑paket. `OutputStorage` säkerställer att resurser fångas i minnet istället för att skrivas till temporära platser.
+
+## Steg 4: Spara dokumentet som ett ZIP‑arkiv
+
+Anropa nu `HtmlDocument.Save`, med destinationssökvägen och de konfigurerade alternativen. Efter sparandet innehåller ZIP‑filen `index.html` samt alla resurser som fångats av hanteraren.
+
+```csharp
+// Define the output path (you can change this to a response stream for web APIs).
+string outputPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+
+// Save the document; Aspose.HTML creates the ZIP automatically.
+document.Save(outputPath, saveOptions);
+
+// Optional: Verify the resources that were stored.
+foreach (var entry in resourceHandler.Resources)
+{
+ Console.WriteLine($"Resource: {entry.Key}, Size: {entry.Value.Length} bytes");
+}
+```
+
+**Förväntat resultat:**
+När programmet körs skapas `output.zip` i den aktuella katalogen. Extrahering av arkivet visar:
+
+```
+index.html
+styles.css
+logo.png
+```
+
+Varje fil matchar markup‑referenserna, och HTML‑innehållet i `index.html` pekar på de inbundna resurserna.
+
+## Steg 5: Anpassa hanteraren för verklig resursdata (avancerat)
+
+Den grundläggande hanteraren ovan skapar tomma strömmar. I produktion behöver du ofta skriva det faktiska innehållet (t.ex. byte‑sekvensen för `styles.css` eller `logo.png`). Utöka `HandleResource` för att hämta data från en databas, en molnbucket eller en inbäddad resurs.
+
+```csharp
+public override Stream HandleResource(ResourceInfo info)
+{
+ // Example: Load resource from an embedded folder.
+ string resourcePath = Path.Combine("EmbeddedResources", info.Path);
+ byte[] data = File.ReadAllBytes(resourcePath);
+
+ // Write data into a memory stream.
+ var stream = new MemoryStream(data);
+ _resources[info.Path] = stream;
+
+ // Return the populated stream.
+ return stream;
+}
+```
+
+**Varför denna variation är viktig:**
+Att tillhandahålla verkligt innehåll säkerställer att ZIP‑arkivet fungerar när det öppnas i en webbläsare. Hanteraren kan också tillämpa transformationer (t.ex. minifiera CSS) innan den skrivs till strömmen.
+
+## Steg 6: Använd ZIP‑arkivet i ett web‑API (valfritt)
+
+Om du exponerar funktionaliteten via ASP.NET Core, returnera ZIP‑filen som ett filresultat:
+
+```csharp
+[HttpGet("download")]
+public IActionResult DownloadZip()
+{
+ // Reuse the same logic from steps 1‑4.
+ // ...
+
+ // Read the generated ZIP into a byte array.
+ byte[] zipBytes = System.IO.File.ReadAllBytes(outputPath);
+
+ // Return the file with the appropriate content type.
+ return File(zipBytes, "application/zip", "document.zip");
+}
+```
+
+**Varför detta steg är viktigt:**
+Klienter kan ladda ner den paketerade HTML:n utan att hantera temporära filer på servern. Metoden fungerar med serverlösa funktioner där diskåtkomst är begränsad.
+
+## Vanliga fallgropar och hur du undviker dem
+
+| Fallgrop | Orsak | Lösning |
+|----------|-------|---------|
+| Tomma resurser i ZIP‑filen | Hantera returnerar en ny `MemoryStream` utan att skriva data | Fyll strömmen med faktiska byte innan den returneras |
+| Saknad `index.html`‑post | `Compress`‑flaggan är inte satt eller `OutputStorage` är inte tilldelad | Säkerställ att `saveOptions.Compress = true` och `saveOptions.OutputStorage = handler` |
+| Stor HTML orsakar minnespress | Alla resurser hålls i minnet | Byt till en `FileStorage`‑implementation som skriver till en temporär mapp |
+| Relativa URL:er går sönder efter extrahering | Resurser refererade med absoluta URL:er som inte lagras | Skriv om URL:er till relativa sökvägar i hanteraren eller under efterbehandling |
+
+## Fullt, körbart exempel
+
+```csharp
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Saving;
+
+class InMemoryResourceHandler : ResourceHandler
+{
+ private readonly DictionaryHello, world!
+
+
+ ";
+
+ HtmlDocument doc = new HtmlDocument();
+ doc.Open(html);
+
+ // Step 1 & 3: Create handler and configure save options.
+ var handler = new InMemoryResourceHandler();
+ HtmlSaveOptions options = new HtmlSaveOptions
+ {
+ OutputStorage = handler,
+ Compress = true
+ };
+
+ // Step 4: Save as ZIP.
+ string zipPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+ doc.Save(zipPath, options);
+ Console.WriteLine($"ZIP file created at: {zipPath}");
+
+ // Optional verification.
+ foreach (var kvp in handler.Resources)
+ {
+ Console.WriteLine($"Resource {kvp.Key} captured, length {kvp.Value.Length} bytes");
+ }
+ }
+}
+```
+
+När programmet körs skapas `output.zip` bredvid den körbara filen. Extrahering av arkivet visar `index.html`, `styles.css` och `logo.png` (tomma platshållare i detta minimala exempel).
+
+## Slutsats
+
+Du har nu en pålitlig metod för att **spara HTML som ZIP** med Aspose.HTML i C#. Tutorialen täckte inläsning av en HTML‑sträng, implementering av en **anpassad resurs‑hanterare**, konfiguration av sparalternativ och generering av ett ZIP‑arkiv redo för distribution eller nedladdning.
+
+Från detta kan du:
+
+- Ersätta platshållar‑strömmarna med verkligt innehåll (t.ex. läsa från en databas)
+- Byta till en fil‑baserad lagringshanterare för mycket stora dokument
+- Integrera logiken i ASP.NET Core‑endpoints för nedladdning på begäran
+- Utforska ytterligare Aspose.HTML‑funktioner såsom PDF‑konvertering eller bildrendering
+
+Experimentera med olika resurskällor och komprimeringsinställningar för att anpassa lösningen efter dina prestanda‑ och storlekskrav. Lycka till med kodandet!
+
+## Vad bör du lära dig härnäst?
+
+Följande tutorials täcker närbesläktade ämnen som bygger på teknikerna som demonstrerats i denna guide. Varje resurs innehåller kompletta fungerande kodexempel med steg‑för‑steg‑förklaringar för att hjälpa dig bemästra ytterligare API‑funktioner och utforska alternativa implementationsmetoder i dina egna projekt.
+
+- [Spara HTML som ZIP – Komplett C#‑tutorial](/html/english/net/html-extensions-and-conversions/save-html-as-zip-complete-c-tutorial/)
+- [Hur man sparar HTML i C# – Komplett guide med en anpassad resurs‑hanterare](/html/english/net/working-with-html-documents/how-to-save-html-in-c-complete-guide-using-a-custom-resource/)
+- [Skapa HTML från sträng i C# – Guide för anpassad resurs‑hanterare](/html/english/net/html-document-manipulation/create-html-from-string-in-c-custom-resource-handler-guide/)
+
+{{< /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/generate-jpg-and-png-images/_index.md b/html/thai/net/generate-jpg-and-png-images/_index.md
index bb3254275c..a881279c66 100644
--- a/html/thai/net/generate-jpg-and-png-images/_index.md
+++ b/html/thai/net/generate-jpg-and-png-images/_index.md
@@ -45,6 +45,8 @@ Aspose.HTML สำหรับ .NET นำเสนอวิธีการง
เรียนรู้วิธีเปิดใช้งาน Antialiasing เพื่อให้ภาพ PNG/JPG ที่แปลงจาก DOCX มีความคมชัดและลื่นไหล
### [แปลง DOCX เป็น PNG – สร้างไฟล์ ZIP ด้วย C#](./convert-docx-to-png-create-zip-archive-c-tutorial/)
เรียนรู้วิธีแปลงไฟล์ DOCX เป็น PNG แล้วบีบอัดเป็นไฟล์ ZIP ด้วย C# โดยใช้ Aspose.HTML
+### [สร้าง PNG จาก HTML ด้วย C# โดยใช้ Aspose.HTML](./create-png-from-html-in-c-using-aspose-html/)
+เรียนรู้วิธีสร้างไฟล์ PNG จาก HTML ด้วย C# โดยใช้ Aspose.HTML
## บทสรุป
diff --git a/html/thai/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md b/html/thai/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
new file mode 100644
index 0000000000..ac5a8a2c15
--- /dev/null
+++ b/html/thai/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
@@ -0,0 +1,290 @@
+---
+category: general
+date: 2026-08-12
+description: สร้าง PNG จาก HTML ด้วย C# และ Aspose.HTML. เรียนรู้วิธีแปลง HTML เป็น
+ PNG และเรนเดอร์ HTML เป็นภาพด้วยเพียงไม่กี่บรรทัดของโค้ด.
+draft: false
+images:
+- PLACEHOLDER_URL/og-image.png
+keywords:
+- create png from html
+- convert html to png
+- render html as image
+- how to render html to image
+language: th
+lastmod: 2026-08-12
+og_description: สร้าง PNG จาก HTML ใน C# ด้วย Aspose.HTML คู่มือนี้แสดงวิธีเรนเดอร์
+ HTML เป็นภาพอย่างรวดเร็ว รวมถึงตัวเลือกการแปลง การตั้งค่าโค้ด และการแก้ไขปัญหา
+og_image_alt: Screenshot of a C# program converting HTML to a PNG image
+og_title: สร้าง PNG จาก HTML ด้วย C# – คู่มือทีละขั้นตอน
+schemas:
+- author: Aspose
+ dateModified: '2026-08-12'
+ description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ headline: Create PNG from HTML in C# using Aspose.HTML
+ type: TechArticle
+- description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ name: Create PNG from HTML in C# using Aspose.HTML
+ steps:
+ - name: Why this works
+ text: '- **`HtmlDocument.Open`** parses the HTML string into a DOM that Aspose.HTML
+ can render. - **`ImageRenderingOptions`** lets you control anti‑aliasing, text
+ hinting, and font handling, which are essential when you **render HTML as image**
+ to avoid blurry text. - **`ImageConverter.ConvertHtmlToImage`*'
+ - name: 1. Preparing the HTML source
+ text: You can load HTML from a string (as shown), a local file, or a remote URL.
+ - name: 2. Fine‑tuning rendering options
+ text: '| Option | Effect | When to adjust | |--------|--------|----------------|
+ | `UseAntialiasing` | Reduces jagged edges on vector graphics | Always enable
+ for high‑quality output | | `TextOptions.UseHinting` | Sharpens glyph edges
+ | Important for small font sizes | | `FontOptions.WebFontStyle` | Choose'
+ - name: 3. Performing the conversion
+ text: The `ImageConverter` overload you used writes a single PNG file. If you
+ need multiple pages (e.g., a multi‑page HTML document), use the overload that
+ returns a collection of images.
+ - name: a. Missing fonts
+ text: If the HTML references a custom web font that isn’t installed on the server,
+ the rendered text falls back to a default font, which may affect layout.
+ - name: b. Large pages and memory consumption
+ text: Rendering a very tall page can consume a lot of RAM.
+ - name: c. Transparent backgrounds
+ text: PNG supports transparency, but the default background is white.
+ type: HowTo
+tags:
+- Aspose.HTML
+- C#
+- image rendering
+- HTML conversion
+title: สร้าง PNG จาก HTML ด้วย C# โดยใช้ Aspose.HTML
+url: /th/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/
+---
+
+{{< blocks/products/pf/main-wrap-class >}}
+{{< blocks/products/pf/main-container >}}
+{{< blocks/products/pf/tutorial-page-section >}}
+
+# สร้าง PNG จาก HTML ด้วย C# โดยใช้ Aspose.HTML
+
+หากคุณต้องการ **สร้าง PNG จาก HTML** ในแอปพลิเคชัน .NET คู่มือนี้จะพาคุณผ่านกระบวนการทั้งหมด คุณจะได้เห็นวิธี **แปลง HTML เป็น PNG** ด้วยเพียงไม่กี่บรรทัดของโค้ด C# โดยใช้เอนจินการเรนเดอร์ที่ทรงพลังของ Aspose.HTML
+
+การเรนเดอร์ HTML เป็นภาพเป็นความต้องการที่พบบ่อยเมื่อสร้างภาพย่อ, ตัวอย่างอีเมล, หรือรายงานที่ต้องฝังใน PDF ในส่วนต่อไปนี้คุณจะได้เรียนรู้ขั้นตอนที่แน่นอน, ดูตัวอย่างการทำงานเต็มรูปแบบ, และเข้าใจว่าการตั้งค่าแต่ละอย่างมีความสำคัญอย่างไร
+
+## สิ่งที่คุณจะได้เรียนรู้
+
+- วิธีสร้าง `HtmlDocument` จากสตริงหรือไฟล์
+- วิธีกำหนดค่า `ImageRenderingOptions` เพื่อปรับปรุงคุณภาพ
+- วิธี **แปลง HTML เป็น PNG** และบันทึกผลลัพธ์ลงดิสก์
+- เคล็ดลับในการจัดการฟอนต์, หน้าใหญ่, และเส้นทางการส่งออกแบบกำหนดเอง
+
+**ข้อกำหนดเบื้องต้น**
+- .NET 6.0 SDK (หรือรุ่นใหม่กว่า) ติดตั้งแล้ว
+- ลิขสิทธิ์ Aspose.HTML for .NET ที่ถูกต้อง (หรือคีย์ประเมินผลชั่วคราว)
+- ความคุ้นเคยพื้นฐานกับ C# และ Visual Studio หรือ IDE ที่รองรับ .NET ใด ๆ
+
+---
+
+## สร้าง PNG จาก HTML ด้วย Aspose.HTML
+
+ขั้นตอนแรกคือการตั้งค่าสภาพแวดล้อมและอ้างอิงเนมสเปซของ Aspose.HTML ที่จำเป็น
+
+```csharp
+using System;
+using Aspose.Html;
+using Aspose.Html.Rendering.Image;
+using Aspose.Html.Drawing;
+using Aspose.Html.Converters;
+
+namespace HtmlToPngDemo
+{
+ class Program
+ {
+ static void Main()
+ {
+ // 1️⃣ Build the HTML document from a raw string.
+ var html = "Bold text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // 2️⃣ Configure rendering options for best visual fidelity. + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, // Smooths edges of drawn shapes + TextOptions = { UseHinting = true }, // Improves glyph clarity + FontOptions = { WebFontStyle = WebFontStyle.Normal } // Uses standard web‑font style + }; + + // 3️⃣ Convert the HTML document to a PNG file. + string outputPath = @"output.png"; + ImageConverter.ConvertHtmlToImage(document, outputPath, renderOptions); + + Console.WriteLine($"PNG image created at: {outputPath}"); + } + } +} +``` + +### ทำไมวิธีนี้ถึงได้ผล + +- **`HtmlDocument.Open`** จะทำการพาร์สสตริง HTML เป็น DOM ที่ Aspose.HTML สามารถเรนเดอร์ได้ +- **`ImageRenderingOptions`** ให้คุณควบคุมการแอนติ‑เอเลียส, การให้คำแนะนำข้อความ, และการจัดการฟอนต์ ซึ่งจำเป็นเมื่อคุณ **เรนเดอร์ HTML เป็นภาพ** เพื่อหลีกเลี่ยงข้อความเบลอ +- **`ImageConverter.ConvertHtmlToImage`** ทำหน้าที่หลัก: แปลง DOM เป็นบิตแมพและเขียนไฟล์ PNG + +การรันโปรแกรมจะสร้างไฟล์ `output.png` ที่มีย่อหน้าหนา (bold) ตามที่กำหนดในซอร์ส HTML อย่างแม่นยำ + +--- + +## แปลง HTML เป็น PNG ทีละขั้นตอน + +ด้านล่างเป็นการอธิบายอย่างละเอียดของแต่ละขั้นตอน การเข้าใจวัตถุประสงค์ของแต่ละบรรทัดช่วยให้คุณปรับโค้ดสำหรับหน้าใหญ่หรือซับซ้อนได้ + +### 1. การเตรียมแหล่งที่มาของ HTML + +คุณสามารถโหลด HTML จากสตริง (ตามที่แสดง), ไฟล์ในเครื่อง, หรือ URL ระยะไกล + +```csharp +// Load from a file +var document = new HtmlDocument(); +document.Open(@"C:\templates\invoice.html"); + +// Load from a URL (requires internet access) +document.Open("https://example.com/report.html"); +``` + +**เคล็ดลับ:** เมื่อโหลดทรัพยากรภายนอก (CSS, รูปภาพ) ให้แน่ใจว่า property `BaseUrl` ชี้ไปยังโฟลเดอร์ที่ถูกต้องเพื่อให้ลิงก์แบบ relative แก้ไขได้อย่างถูกต้อง + +### 2. การปรับแต่งตัวเลือกการเรนเดอร์อย่างละเอียด + +| ตัวเลือก | ผล | เมื่อควรปรับ | +|--------|--------|----------------| +| `UseAntialiasing` | ลดขอบหยักบนกราฟิกเวกเตอร์ | ควรเปิดใช้งานเสมอสำหรับผลลัพธ์คุณภาพสูง | +| `TextOptions.UseHinting` | ทำให้ขอบ glyph คมชัด | สำคัญสำหรับขนาดฟอนต์เล็ก | +| `FontOptions.WebFontStyle` | เลือกการเรนเดอร์เว็บฟอนต์แบบปกติ, เอียง, หรือออบลิก | ใช้ `WebFontStyle.Oblique` สำหรับฟอนต์เอียง | +| `ResolutionX` / `ResolutionY` | DPI ของภาพผลลัพธ์ | เพิ่มค่าเพื่อ PNG ที่พร้อมพิมพ์ (เช่น 300 DPI) | + +ตัวอย่างการเพิ่ม DPI: + +```csharp +renderOptions.ResolutionX = 300; +renderOptions.ResolutionY = 300; +``` + +### 3. การทำการแปลง + +โอเวอร์โหลด `ImageConverter` ที่คุณใช้จะเขียนไฟล์ PNG เพียงไฟล์เดียว หากคุณต้องการหลายหน้า (เช่น เอกสาร HTML หลายหน้า) ให้ใช้โอเวอร์โหลดที่คืนคอลเลกชันของภาพ + +```csharp +ImageConverter.ConvertHtmlToImages(document, "output_folder", renderOptions); +``` + +แต่ละหน้าจะกลายเป็น `output_folder/page_0.png`, `page_1.png`, เป็นต้น + +--- + +## เรนเดอร์ HTML เป็นภาพ – การจัดการกับปัญหาทั่วไป + +### a. ฟอนต์หาย + +หาก HTML อ้างอิงเว็บฟอนต์ที่กำหนดเองซึ่งไม่ได้ติดตั้งบนเซิร์ฟเวอร์ ข้อความที่เรนเดอร์จะกลับไปใช้ฟอนต์เริ่มต้น ซึ่งอาจส่งผลต่อการจัดวาง + +**วิธีแก้:** ฝังฟอนต์โดยใช้กฎ `@font-face` ใน CSS ของคุณ หรือจัดหาโฟลเดอร์ฟอนต์ในเครื่องผ่าน `FontOptions` + +```csharp +renderOptions.FontOptions.FontFolder = @"C:\fonts"; +``` + +### b. หน้าใหญ่และการใช้หน่วยความจำ + +การเรนเดอร์หน้าที่สูงมากอาจใช้ RAM มาก + +**วิธีแก้:** กำหนดความสูงสูงสุดหรือแบ่งเอกสารเป็นส่วนก่อนทำการแปลง + +```csharp +renderOptions.PageHeight = 2000; // pixels +``` + +### c. พื้นหลังโปร่งใส + +PNG รองรับความโปร่งใส แต่พื้นหลังเริ่มต้นคือสีขาว + +**วิธีแก้:** เปลี่ยนสีพื้นหลังเป็นโปร่งใส + +```csharp +renderOptions.BackgroundColor = System.Drawing.Color.Transparent; +``` + +--- + +## วิธีเรนเดอร์ HTML เป็นภาพ – สรุปตัวอย่างเต็ม + +เมื่อนำทุกอย่างมารวมกัน นี่คือตัวอย่างโค้ดพร้อมใช้งานในผลิตภัณฑ์ที่ครอบคลุมความต้องการที่พบบ่อยที่สุด: + +```csharp +using System; +using Aspose.Html; +using Aspose.Html.Rendering.Image; +using Aspose.Html.Drawing; +using Aspose.Html.Converters; + +namespace HtmlToPngDemo +{ + class Program + { + static void Main() + { + // Load HTML (string, file, or URL) + string html = "" + + "Bold blue text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // Configure rendering for high quality and transparency + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, + TextOptions = { UseHinting = true }, + FontOptions = { WebFontStyle = WebFontStyle.Normal, FontFolder = @"C:\fonts" }, + BackgroundColor = System.Drawing.Color.Transparent, + ResolutionX = 150, + ResolutionY = 150 + }; + + // Convert and save + string outPath = @"C:\temp\html_snapshot.png"; + ImageConverter.ConvertHtmlToImage(document, outPath, renderOptions); + + Console.WriteLine($"Image saved to {outPath}"); + } + } +} +``` + +**ผลลัพธ์ที่คาดหวัง:** ไฟล์ `html_snapshot.png` ที่มีย่อหน้าหนาและสีน้ำเงินบนแคนวาสโปร่งใส ภาพจะมีการแอนติ‑เอเลียส พร้อมข้อความคมชัดด้วยการให้คำแนะนำ (hinting) + +--- + +## สรุป + +ตอนนี้คุณรู้วิธี **สร้าง PNG จาก HTML** ด้วย C# โดยใช้ Aspose.HTML แล้ว การสร้าง `HtmlDocument`, การกำหนดค่า `ImageRenderingOptions`, และการเรียก `ImageConverter.ConvertHtmlToImage` ทำให้คุณสามารถ **แปลง HTML เป็น PNG** และ **เรนเดอร์ HTML เป็นภาพ** ได้อย่างเชื่อถือสำหรับสถานการณ์อัตโนมัติใด ๆ + +ต่อจากนี้คุณอาจสำรวจ: + +- การสร้างภาพย่อสำหรับหน้าเว็บแบบไดนามิก +- การฝัง PNG ลงใน PDF ด้วย Aspose.PDF +- ใช้วิธีเดียวกันเพื่อสร้าง JPEG หรือ BMP โดยเปลี่ยนส่วนขยายไฟล์ + +คุณสามารถทดลองปรับ DPI, สีพื้นหลัง, และการเรนเดอร์หลายหน้าเพื่อให้ตรงกับความต้องการของโครงการของคุณได้เลย ขอให้สนุกกับการเขียนโค้ด! + +## สิ่งที่คุณควรเรียนต่อไป + +บทแนะนำต่อไปนี้ครอบคลุมหัวข้อที่เกี่ยวข้องอย่างใกล้ชิดซึ่งต่อยอดจากเทคนิคที่แสดงในคู่มือนี้ แต่ละแหล่งข้อมูลมีตัวอย่างโค้ดทำงานเต็มรูปแบบพร้อมคำอธิบายทีละขั้นตอนเพื่อช่วยให้คุณเชี่ยวชาญฟีเจอร์ API เพิ่มเติมและสำรวจแนวทางการใช้งานอื่น ๆ ในโครงการของคุณ + +- [เรนเดอร์ HTML เป็น PNG ใน .NET ด้วย Aspose.HTML](/html/english/net/rendering-html-documents/render-html-as-png/) +- [วิธีเรนเดอร์ HTML เป็น PNG – คู่มือ C# ฉบับสมบูรณ์](/html/english/net/rendering-html-documents/how-to-render-html-as-png-complete-c-guide/) +- [สร้าง PNG จาก HTML – คู่มือการเรนเดอร์ C# ฉบับเต็ม](/html/english/net/rendering-html-documents/create-png-from-html-full-c-rendering-guide/) + +{{< /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 2474ca32c0..cfa02d1477 100644 --- a/html/thai/net/html-extensions-and-conversions/_index.md +++ b/html/thai/net/html-extensions-and-conversions/_index.md @@ -71,6 +71,8 @@ Aspose.HTML สำหรับ .NET ไม่ใช่แค่ไลบรา เรียนรู้วิธีสร้าง PDF จากไฟล์ HTML ด้วย C# โดยใช้ Aspose.HTML สำหรับ .NET ตามขั้นตอนที่ชัดเจน ### [บันทึก HTML เป็น ZIP – คอร์สเต็ม C#](./save-html-as-zip-complete-c-tutorial/) บันทึกไฟล์ HTML เป็น ZIP อย่างครบถ้วนด้วย C# ตามขั้นตอนของเรา +### [บันทึก HTML เป็น ZIP ใน C# – คู่มือแบบทีละขั้นตอน](./save-html-as-zip-in-c-step-by-step-guide/) +เรียนรู้วิธีบันทึกไฟล์ HTML เป็น ZIP ด้วย C# อย่างละเอียดตามขั้นตอน ### [บันทึก HTML เป็น ZIP ใน C# – ตัวอย่างทำงานในหน่วยความจำเต็มรูปแบบ](./save-html-to-zip-in-c-complete-in-memory-example/) บันทึกไฟล์ HTML เป็นไฟล์ ZIP โดยใช้ C# ด้วยตัวอย่างทำงานในหน่วยความจำเต็มรูปแบบ diff --git a/html/thai/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md b/html/thai/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..3c917fea49 --- /dev/null +++ b/html/thai/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md @@ -0,0 +1,320 @@ +--- +category: general +date: 2026-08-12 +description: บันทึก HTML เป็น ZIP ด้วย Aspose.HTML เรียนรู้วิธีโหลดสตริง HTML, สร้างตัวจัดการทรัพยากรแบบกำหนดเอง, + และสร้างไฟล์ ZIP อย่างมีประสิทธิภาพ. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save html as zip +- load html string +- custom resource handler +language: th +lastmod: 2026-08-12 +og_description: บันทึก HTML เป็นไฟล์ ZIP ด้วย Aspose.HTML ใน C# บทแนะนำนี้แสดงวิธีโหลดสตริง + HTML, สร้างตัวจัดการทรัพยากรแบบกำหนดเอง, และสร้างไฟล์ ZIP เพียงไม่กี่ขั้นตอน. +og_image_alt: Diagram showing save html as zip process with custom resource handler +og_title: บันทึก HTML เป็น ZIP ด้วย Aspose.HTML – คู่มือ C# ฉบับสมบูรณ์ +schemas: +- author: Aspose + dateModified: '2026-08-12' + description: Save HTML as ZIP using Aspose.HTML. Learn to load HTML string, create + a custom resource handler, and generate a ZIP archive efficiently. + headline: Save HTML as ZIP in C# – step‑by‑step guide + type: TechArticle +tags: +- Aspose.HTML +- C# +- ZIP archive +title: บันทึก HTML เป็น ZIP ใน C# – คู่มือแบบขั้นตอนต่อขั้นตอน +url: /th/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# บันทึก HTML เป็น ZIP ใน C# – คู่มือขั้นตอนต่อขั้นตอน + +หากคุณต้องการ **บันทึก HTML เป็น ZIP** ในแอปพลิเคชัน .NET คู่มือนี้จะแสดงขั้นตอนการทำงานทั้งหมด คุณจะได้เรียนรู้วิธี **โหลดสตริง HTML**, สร้าง **custom resource handler**, และสร้างไฟล์ ZIP โดยไม่ต้องเขียนไฟล์ชั่วคราวลงดิสก์ + +วิธีการใช้ Aspose.HTML 5.x ซึ่งให้เอนจิ้นการเรนเดอร์ที่มีประสิทธิภาพสูงและตัวเลือกการบันทึกที่ยืดหยุ่น เมื่อจบบทเรียนแล้วคุณจะมี handler ที่นำกลับมาใช้ใหม่ได้ ซึ่งสามารถผสานรวมกับเว็บเซอร์วิส, งานเบื้องหลัง, หรือเครื่องมือเดสก์ท็อป + +## สิ่งที่คุณจะสร้าง + +โค้ดสุดท้ายจะสร้างไฟล์ ZIP ที่อิงจาก `MemoryStream` ซึ่งบรรจุเอกสาร HTML และทรัพยากรที่อ้างอิง (รูปภาพ, CSS, ฟอนต์) ไฟล์ ZIP จะถูกเขียนไปยังโฟลเดอร์เป้าหมาย แต่คุณสามารถเปลี่ยนปลายทางเป็นสตรีมการตอบกลับสำหรับ HTTP API ได้ + +## ข้อกำหนดเบื้องต้น + +- .NET 6.0 หรือใหม่กว่า (ตัวอย่างใช้ .NET 6) +- Aspose.HTML for .NET (แพ็กเกจ NuGet `Aspose.HTML`) +- ความคุ้นเคยพื้นฐานกับรูปแบบ async ของ C# (ไม่บังคับแต่เป็นประโยชน์) + +> **เคล็ดลับ:** ติดตั้งแพ็กเกจด้วย `dotnet add package Aspose.HTML` ก่อนเริ่ม + +## ขั้นตอนที่ 1: กำหนด custom resource handler + +**custom resource handler** จะดักจับทุกคำขอทรัพยากรภายนอกที่ renderer ของ HTML ทำขึ้น โดยการคืนค่าเป็นสตรีม คุณจะควบคุมว่าข้อมูลทรัพยากรจะถูกเก็บไว้ที่ไหน ตัวอย่างนี้เก็บทุกอย่างในหน่วยความจำ ซึ่งเหมาะสำหรับการสร้างไฟล์ ZIP แบบทันที + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +///Hello, world!
+
+
+";
+
+// Create a new document instance.
+HtmlDocument document = new HtmlDocument();
+
+// Load the HTML markup.
+document.Open(htmlContent);
+```
+
+**ทำไมขั้นตอนนี้สำคัญ:**
+ความสามารถ **load html string** มีประโยชน์เมื่อ HTML ถูกสร้างแบบไดนามิก (เช่น จาก template engine) หรือรับมาจาก API มันช่วยหลีกเลี่ยงการพึ่งพาไฟล์ระบบและทำงานได้ในสภาพแวดล้อมที่แยกกัน
+
+## ขั้นตอนที่ 3: กำหนดค่า save options ให้ใช้ handler
+
+`HtmlSaveOptions` ของ Aspose.HTML ให้คุณระบุกลไกการจัดเก็บผลลัพธ์ กำหนด handler ที่กำหนดเองให้กับ property `OutputStorage` และตั้งค่า `Compress` เพื่อสร้างไฟล์ ZIP
+
+```csharp
+// Instantiate the custom handler.
+var resourceHandler = new InMemoryResourceHandler();
+
+// Prepare save options.
+HtmlSaveOptions saveOptions = new HtmlSaveOptions
+{
+ // Use the handler for all external resources.
+ OutputStorage = resourceHandler,
+
+ // Enable ZIP compression.
+ Compress = true
+};
+```
+
+**ทำไมขั้นตอนนี้สำคัญ:**
+`Compress = true` บอก Aspose.HTML ให้บรรจุไฟล์ HTML และทรัพยากรที่เก็บรวบรวมไว้ทั้งหมดเป็นแพคเกจ ZIP เดียว `OutputStorage` ทำให้ทรัพยากรถูกจับในหน่วยความจำแทนการเขียนลงตำแหน่งชั่วคราว
+
+## ขั้นตอนที่ 4: บันทึกเอกสารเป็นไฟล์ ZIP
+
+ตอนนี้เรียก `HtmlDocument.Save` พร้อมพาธปลายทางและตัวเลือกที่กำหนด หลังจากบันทึก ไฟล์ ZIP จะมี `index.html` พร้อมทรัพยากรที่ handler จับไว้
+
+```csharp
+// Define the output path (you can change this to a response stream for web APIs).
+string outputPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+
+// Save the document; Aspose.HTML creates the ZIP automatically.
+document.Save(outputPath, saveOptions);
+
+// Optional: Verify the resources that were stored.
+foreach (var entry in resourceHandler.Resources)
+{
+ Console.WriteLine($"Resource: {entry.Key}, Size: {entry.Value.Length} bytes");
+}
+```
+
+**ผลลัพธ์ที่คาดหวัง:**
+เมื่อรันโปรแกรมจะสร้าง `output.zip` ในไดเรกทอรีปัจจุบัน การแตกไฟล์ ZIP จะได้:
+
+```
+index.html
+styles.css
+logo.png
+```
+
+แต่ละไฟล์สอดคล้องกับการอ้างอิงใน markup และ HTML ภายใน `index.html` จะชี้ไปยังทรัพยากรที่บรรจุไว้
+
+## ขั้นตอนที่ 5: ปรับ handler ให้จัดการข้อมูลทรัพยากรจริง (ขั้นสูง)
+
+handler พื้นฐานด้านบนสร้างสตรีมเปล่า ในการใช้งานจริงคุณมักต้องเขียนเนื้อหาจริง (เช่น ไบต์ของ `styles.css` หรือ `logo.png`) ขยาย `HandleResource` เพื่อดึงข้อมูลจากฐานข้อมูล, bucket บนคลาวด์, หรือทรัพยากรฝังตัว
+
+```csharp
+public override Stream HandleResource(ResourceInfo info)
+{
+ // Example: Load resource from an embedded folder.
+ string resourcePath = Path.Combine("EmbeddedResources", info.Path);
+ byte[] data = File.ReadAllBytes(resourcePath);
+
+ // Write data into a memory stream.
+ var stream = new MemoryStream(data);
+ _resources[info.Path] = stream;
+
+ // Return the populated stream.
+ return stream;
+}
+```
+
+**ทำไมการเปลี่ยนแปลงนี้สำคัญ:**
+การให้เนื้อหาจริงทำให้ไฟล์ ZIP ทำงานได้เมื่อเปิดในเบราว์เซอร์ handler ยังสามารถทำการแปลง (เช่น minify CSS) ก่อนเขียนสตรีมได้อีกด้วย
+
+## ขั้นตอนที่ 6: ใช้ไฟล์ ZIP ใน Web API (ไม่บังคับ)
+
+หากคุณเปิดให้บริการผ่าน ASP.NET Core ให้ส่งไฟล์ ZIP กลับเป็นผลลัพธ์ไฟล์:
+
+```csharp
+[HttpGet("download")]
+public IActionResult DownloadZip()
+{
+ // Reuse the same logic from steps 1‑4.
+ // ...
+
+ // Read the generated ZIP into a byte array.
+ byte[] zipBytes = System.IO.File.ReadAllBytes(outputPath);
+
+ // Return the file with the appropriate content type.
+ return File(zipBytes, "application/zip", "document.zip");
+}
+```
+
+**ทำไมขั้นตอนนี้สำคัญ:**
+ลูกค้าสามารถดาวน์โหลด HTML ที่บรรจุไว้โดยไม่ต้องจัดการไฟล์ชั่วคราวบนเซิร์ฟเวอร์ วิธีนี้ทำงานได้กับฟังก์ชัน serverless ที่มีข้อจำกัดการเข้าถึงดิสก์
+
+## ข้อผิดพลาดทั่วไปและวิธีหลีกเลี่ยง
+
+| ปัญหา | สาเหตุ | วิธีแก้ |
+|---------|--------|-----|
+| ทรัพยากรว่างใน ZIP | Handler คืน `MemoryStream` ใหม่โดยไม่ได้เขียนข้อมูล | เติมสตรีมด้วยไบต์จริงก่อนคืนค่า |
+| ไม่มีรายการ `index.html` | ไม่ได้ตั้งค่า `Compress` หรือไม่ได้กำหนด `OutputStorage` | ตรวจสอบให้ `saveOptions.Compress = true` และ `saveOptions.OutputStorage = handler` |
+| HTML ขนาดใหญ่ทำให้หน่วยความจำอัด | ทุกทรัพยากรถูกเก็บในหน่วยความจำ | สลับไปใช้การทำงาน `FileStorage` ที่เขียนลงโฟลเดอร์ชั่วคราว |
+| URL แบบ relative พังหลังการแตก | มี URL แบบ absolute ที่ไม่ได้บันทึก | แก้ URL ให้เป็น relative ภายใน handler หรือระหว่าง post‑processing |
+
+## ตัวอย่างเต็มที่สามารถรันได้
+
+```csharp
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Saving;
+
+class InMemoryResourceHandler : ResourceHandler
+{
+ private readonly DictionaryHello, world!
+
+
+ ";
+
+ HtmlDocument doc = new HtmlDocument();
+ doc.Open(html);
+
+ // Step 1 & 3: Create handler and configure save options.
+ var handler = new InMemoryResourceHandler();
+ HtmlSaveOptions options = new HtmlSaveOptions
+ {
+ OutputStorage = handler,
+ Compress = true
+ };
+
+ // Step 4: Save as ZIP.
+ string zipPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+ doc.Save(zipPath, options);
+ Console.WriteLine($"ZIP file created at: {zipPath}");
+
+ // Optional verification.
+ foreach (var kvp in handler.Resources)
+ {
+ Console.WriteLine($"Resource {kvp.Key} captured, length {kvp.Value.Length} bytes");
+ }
+ }
+}
+```
+
+เมื่อรันโปรแกรมจะสร้าง `output.zip` อยู่ข้างๆ executable การแตกไฟล์จะแสดง `index.html`, `styles.css`, และ `logo.png` (เป็น placeholder ว่างในตัวอย่างนี้)
+
+## สรุป
+
+คุณมีวิธีที่เชื่อถือได้ในการ **บันทึก HTML เป็น ZIP** ด้วย Aspose.HTML ใน C# บทเรียนนี้ครอบคลุมการโหลดสตริง HTML, การสร้าง **custom resource handler**, การกำหนดค่า save options, และการสร้างไฟล์ ZIP พร้อมแจกจ่ายหรือดาวน์โหลด
+
+ต่อจากนี้คุณสามารถ:
+
+- แทนที่สตรีม placeholder ด้วยเนื้อหาจริง (เช่น อ่านจากฐานข้อมูล)
+- เปลี่ยนไปใช้ handler ที่จัดเก็บเป็นไฟล์สำหรับเอกสารขนาดใหญ่มาก
+- ผสานตรรกะนี้เข้าไปใน endpoint ของ ASP.NET Core เพื่อดาวน์โหลดตามความต้องการ
+- สำรวจฟีเจอร์เพิ่มเติมของ Aspose.HTML เช่น การแปลงเป็น PDF หรือการเรนเดอร์ภาพ
+
+ลองทดลองกับแหล่งทรัพยากรและการตั้งค่าการบีบอัดต่างๆ เพื่อปรับโซลูชันให้ตรงกับความต้องการด้านประสิทธิภาพและขนาดของคุณ ขอให้สนุกกับการเขียนโค้ด!
+
+## สิ่งที่คุณควรเรียนต่อไป
+
+บทแนะนำต่อไปนี้ครอบคลุมหัวข้อที่เกี่ยวข้องอย่างใกล้ชิดและต่อยอดจากเทคนิคที่แสดงในคู่มือนี้ แต่ละแหล่งข้อมูลมีโค้ดตัวอย่างทำงานเต็มรูปแบบพร้อมคำอธิบายขั้นตอนเพื่อช่วยคุณเชี่ยวชาญฟีเจอร์ API เพิ่มเติมและสำรวจวิธีการทำงานทางเลือกในโปรเจกต์ของคุณ
+
+- [Save HTML as ZIP – Complete C# Tutorial](/html/english/net/html-extensions-and-conversions/save-html-as-zip-complete-c-tutorial/)
+- [How to Save HTML in C# – Complete Guide Using a Custom Resource Handler](/html/english/net/working-with-html-documents/how-to-save-html-in-c-complete-guide-using-a-custom-resource/)
+- [Create HTML from String in C# – Custom Resource Handler Guide](/html/english/net/html-document-manipulation/create-html-from-string-in-c-custom-resource-handler-guide/)
+
+{{< /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/generate-jpg-and-png-images/_index.md b/html/turkish/net/generate-jpg-and-png-images/_index.md
index a918363c42..1ed16205ee 100644
--- a/html/turkish/net/generate-jpg-and-png-images/_index.md
+++ b/html/turkish/net/generate-jpg-and-png-images/_index.md
@@ -45,6 +45,8 @@ HTML belgelerini düzenlemek, HTML'yi resimlere dönüştürmek ve daha fazlası
DOCX belgelerini PNG veya JPG formatına dönüştürürken antialiasing'i etkinleştirerek daha net ve pürüzsüz görüntüler elde edin.
### [docx'i png'ye dönüştür – zip arşivi oluşturma C# eğitimi](./convert-docx-to-png-create-zip-archive-c-tutorial/)
C# kullanarak docx dosyalarını png formatına dönüştürüp, sonuçları zip arşivi içinde paketlemeyi öğrenin.
+### [C# ile Aspose.HTML kullanarak HTML'den PNG Oluşturun](./create-png-from-html-in-c-using-aspose-html/)
+C# ve Aspose.HTML ile HTML içeriğinden PNG resim oluşturmayı adım adım öğrenin.
## Çözüm
diff --git a/html/turkish/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md b/html/turkish/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
new file mode 100644
index 0000000000..222c066f85
--- /dev/null
+++ b/html/turkish/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
@@ -0,0 +1,292 @@
+---
+category: general
+date: 2026-08-12
+description: C# ile Aspose.HTML kullanarak HTML'den PNG oluşturun. HTML'yi PNG'ye
+ dönüştürmeyi ve sadece birkaç satır kodla HTML'yi görüntü olarak render etmeyi öğrenin.
+draft: false
+images:
+- PLACEHOLDER_URL/og-image.png
+keywords:
+- create png from html
+- convert html to png
+- render html as image
+- how to render html to image
+language: tr
+lastmod: 2026-08-12
+og_description: Aspose.HTML kullanarak C#'de HTML'den PNG oluşturun. Bu rehber, HTML'yi
+ hızlı bir şekilde görüntüye nasıl dönüştüreceğinizi, dönüşüm seçeneklerini, kod
+ kurulumunu ve sorun giderme adımlarını gösterir.
+og_image_alt: Screenshot of a C# program converting HTML to a PNG image
+og_title: C#'ta HTML'den PNG Oluşturma – adım adım rehber
+schemas:
+- author: Aspose
+ dateModified: '2026-08-12'
+ description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ headline: Create PNG from HTML in C# using Aspose.HTML
+ type: TechArticle
+- description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ name: Create PNG from HTML in C# using Aspose.HTML
+ steps:
+ - name: Why this works
+ text: '- **`HtmlDocument.Open`** parses the HTML string into a DOM that Aspose.HTML
+ can render. - **`ImageRenderingOptions`** lets you control anti‑aliasing, text
+ hinting, and font handling, which are essential when you **render HTML as image**
+ to avoid blurry text. - **`ImageConverter.ConvertHtmlToImage`*'
+ - name: 1. Preparing the HTML source
+ text: You can load HTML from a string (as shown), a local file, or a remote URL.
+ - name: 2. Fine‑tuning rendering options
+ text: '| Option | Effect | When to adjust | |--------|--------|----------------|
+ | `UseAntialiasing` | Reduces jagged edges on vector graphics | Always enable
+ for high‑quality output | | `TextOptions.UseHinting` | Sharpens glyph edges
+ | Important for small font sizes | | `FontOptions.WebFontStyle` | Choose'
+ - name: 3. Performing the conversion
+ text: The `ImageConverter` overload you used writes a single PNG file. If you
+ need multiple pages (e.g., a multi‑page HTML document), use the overload that
+ returns a collection of images.
+ - name: a. Missing fonts
+ text: If the HTML references a custom web font that isn’t installed on the server,
+ the rendered text falls back to a default font, which may affect layout.
+ - name: b. Large pages and memory consumption
+ text: Rendering a very tall page can consume a lot of RAM.
+ - name: c. Transparent backgrounds
+ text: PNG supports transparency, but the default background is white.
+ type: HowTo
+tags:
+- Aspose.HTML
+- C#
+- image rendering
+- HTML conversion
+title: C#'ta Aspose.HTML kullanarak HTML'den PNG oluşturma
+url: /tr/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/
+---
+
+{{< blocks/products/pf/main-wrap-class >}}
+{{< blocks/products/pf/main-container >}}
+{{< blocks/products/pf/tutorial-page-section >}}
+
+# C# ile Aspose.HTML kullanarak HTML'den PNG Oluşturma
+
+Bir .NET uygulamasında **HTML'den PNG oluşturmanız** gerektiğinde, bu kılavuz size sürecin tamamını adım adım gösterir. Aspose.HTML’in güçlü render motoru sayesinde sadece birkaç satır C# kodu ile **HTML'yi PNG'ye dönüştürmeyi** öğreneceksiniz.
+
+HTML'yi görüntü olarak render etmek, küçük resimler, e‑posta ön izlemeleri veya PDF'lere gömülmesi gereken raporlar oluştururken sıkça ihtiyaç duyulan bir özelliktir. Takip eden bölümlerde tam adımları, çalışan bir örneği ve her ayarın neden önemli olduğunu göreceksiniz.
+
+## Öğrenecekleriniz
+
+- Bir `HtmlDocument`'i dizeden ya da dosyadan nasıl oluşturacağınız.
+- `ImageRenderingOptions` ile kaliteyi nasıl artıracağınız.
+- **HTML'yi PNG'ye dönüştürme** ve sonucu diske kaydetme.
+- Yazı tipleri, büyük sayfalar ve özel çıktı yolları ile başa çıkma ipuçları.
+
+**Önkoşullar**
+- .NET 6.0 SDK (veya daha yeni) yüklü.
+- Geçerli bir Aspose.HTML for .NET lisansı (veya geçici bir değerlendirme anahtarı).
+- C# ve Visual Studio ya da herhangi bir .NET‑uyumlu IDE hakkında temel bilgi.
+
+---
+
+## Aspose.HTML ile HTML'den PNG Oluşturma
+
+İlk adım ortamı hazırlamak ve gerekli Aspose.HTML ad alanlarını referans göstermek.
+
+```csharp
+using System;
+using Aspose.Html;
+using Aspose.Html.Rendering.Image;
+using Aspose.Html.Drawing;
+using Aspose.Html.Converters;
+
+namespace HtmlToPngDemo
+{
+ class Program
+ {
+ static void Main()
+ {
+ // 1️⃣ Build the HTML document from a raw string.
+ var html = "Bold text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // 2️⃣ Configure rendering options for best visual fidelity. + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, // Smooths edges of drawn shapes + TextOptions = { UseHinting = true }, // Improves glyph clarity + FontOptions = { WebFontStyle = WebFontStyle.Normal } // Uses standard web‑font style + }; + + // 3️⃣ Convert the HTML document to a PNG file. + string outputPath = @"output.png"; + ImageConverter.ConvertHtmlToImage(document, outputPath, renderOptions); + + Console.WriteLine($"PNG image created at: {outputPath}"); + } + } +} +``` + +### Neden Bu Şekilde Çalışıyor + +- **`HtmlDocument.Open`** HTML dizesini Aspose.HTML'in render edebileceği bir DOM'a ayrıştırır. +- **`ImageRenderingOptions`** anti‑aliasing, metin ipuçları ve yazı tipi yönetimini kontrol etmenizi sağlar; bu da **HTML'yi görüntü olarak render** ederken bulanık metinleri önlemek için kritiktir. +- **`ImageConverter.ConvertHtmlToImage`** ağır işi yapar: DOM'u bir bitmap üzerine rasterleştirir ve PNG dosyasını yazar. + +Programı çalıştırdığınızda, HTML kaynağında tanımlanan kalın paragrafı tam olarak içeren `output.png` oluşturulur. + +--- + +## HTML'yi PNG'ye Adım Adım Dönüştürme + +Aşağıda her aşamanın daha ayrıntılı bir açıklaması yer alıyor. Her satırın amacını anlamak, kodu daha büyük ya da karmaşık sayfalara uyarlamanıza yardımcı olur. + +### 1. HTML kaynağını hazırlama + +HTML'yi bir dizeden (aşağıda gösterildiği gibi), yerel bir dosyadan ya da uzak bir URL'den yükleyebilirsiniz. + +```csharp +// Load from a file +var document = new HtmlDocument(); +document.Open(@"C:\templates\invoice.html"); + +// Load from a URL (requires internet access) +document.Open("https://example.com/report.html"); +``` + +**İpucu:** Dış kaynakları (CSS, görseller) yüklerken `BaseUrl` özelliğinin doğru klasöre işaret ettiğinden emin olun; böylece göreli bağlantılar doğru çözülür. + +### 2. Render seçeneklerini ince ayar yapma + +| Seçenek | Etki | Ne Zaman Ayarlanmalı | +|--------|------|----------------------| +| `UseAntialiasing` | Vektör grafiklerde tırtıklı kenarları azaltır | Yüksek kalite çıktısı için her zaman etkinleştirilmeli | +| `TextOptions.UseHinting` | Glif kenarlarını keskinleştirir | Küçük punto boyutları için önemlidir | +| `FontOptions.WebFontStyle` | Normal, italic veya oblique web‑font renderını seçer | Eğik yazı tipleri için `WebFontStyle.Oblique` kullanın | +| `ResolutionX` / `ResolutionY` | Çıktı görüntüsünün DPI değeri | Baskı‑hazır PNG'ler için DPI'yi artırın (ör. 300 DPI) | + +DPI artırma örneği: + +```csharp +renderOptions.ResolutionX = 300; +renderOptions.ResolutionY = 300; +``` + +### 3. Dönüşümü gerçekleştirme + +Kullandığınız `ImageConverter` aşırı yüklemesi tek bir PNG dosyası yazar. Çok sayfalı bir HTML belgesi (ör. çok‑sayfalı) varsa, bir koleksiyon döndüren aşırı yüklemeyi kullanın. + +```csharp +ImageConverter.ConvertHtmlToImages(document, "output_folder", renderOptions); +``` + +Her sayfa `output_folder/page_0.png`, `page_1.png` vb. olarak oluşturulur. + +--- + +## HTML'yi Görüntü Olarak Render Etme – Yaygın Tuzaklar + +### a. Eksik yazı tipleri + +HTML, sunucuda yüklü olmayan özel bir web fontuna referans veriyorsa, render edilen metin varsayılan bir fonta düşer ve bu da düzeni etkileyebilir. + +**Çözüm:** CSS içinde bir `@font-face` kuralı ile fontu gömün ya da `FontOptions` aracılığıyla yerel bir font klasörü sağlayın. + +```csharp +renderOptions.FontOptions.FontFolder = @"C:\fonts"; +``` + +### b. Büyük sayfalar ve bellek tüketimi + +Çok uzun bir sayfayı render etmek büyük miktarda RAM tüketebilir. + +**Çözüm:** Maksimum yükseklik belirleyin veya belgeyi bölümlere ayırarak dönüştürün. + +```csharp +renderOptions.PageHeight = 2000; // pixels +``` + +### c. Şeffaf arka planlar + +PNG şeffaflığı destekler, ancak varsayılan arka plan beyazdır. + +**Çözüm:** Arka plan rengini şeffaf olarak değiştirin. + +```csharp +renderOptions.BackgroundColor = System.Drawing.Color.Transparent; +``` + +--- + +## HTML'yi Görüntü Olarak Render Etme – Tam Örnek Özeti + +Her şeyi bir araya getirdiğimizde, en sık karşılaşılan gereksinimleri karşılayan üretim‑hazır bir kod parçacığı elde ederiz: + +```csharp +using System; +using Aspose.Html; +using Aspose.Html.Rendering.Image; +using Aspose.Html.Drawing; +using Aspose.Html.Converters; + +namespace HtmlToPngDemo +{ + class Program + { + static void Main() + { + // Load HTML (string, file, or URL) + string html = "" + + "Bold blue text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // Configure rendering for high quality and transparency + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, + TextOptions = { UseHinting = true }, + FontOptions = { WebFontStyle = WebFontStyle.Normal, FontFolder = @"C:\fonts" }, + BackgroundColor = System.Drawing.Color.Transparent, + ResolutionX = 150, + ResolutionY = 150 + }; + + // Convert and save + string outPath = @"C:\temp\html_snapshot.png"; + ImageConverter.ConvertHtmlToImage(document, outPath, renderOptions); + + Console.WriteLine($"Image saved to {outPath}"); + } + } +} +``` + +**Beklenen çıktı:** Şeffaf bir kanvas üzerinde kalın, mavi bir paragraf içeren `html_snapshot.png` dosyası. Görüntü anti‑aliasing uygulanmış, metin ipuçları sayesinde net olacaktır. + +--- + +## Sonuç + +Artık C# ile Aspose.HTML kullanarak **HTML'den PNG oluşturmayı** biliyorsunuz. Bir `HtmlDocument` oluşturup, `ImageRenderingOptions` ayarlarını yapılandırarak ve `ImageConverter.ConvertHtmlToImage` metodunu çağırarak, **HTML'yi PNG'ye dönüştürebilir** ve **HTML'yi görüntü olarak render** edebilirsiniz; bu da her türlü otomasyon senaryosu için güvenilir bir çözümdür. + +Bundan sonra şunları keşfedebilirsiniz: + +- Dinamik web sayfaları için küçük resimler üretme. +- PNG'yi Aspose.PDF ile PDF'lere gömme. +- Dosya uzantısını değiştirerek aynı yaklaşımı JPEG veya BMP üretmek için kullanma. + +DPI, arka plan renkleri ve çok‑sayfalı render gibi ayarlarla proje ihtiyaçlarınıza tam uyacak şekilde deneyler yapın. İyi kodlamalar! + +## Sonra Ne Öğrenmelisiniz? + + +Aşağıdaki öğreticiler, bu kılavuzda gösterilen tekniklere dayanan ve ilgili konuları derinlemesine ele alan içeriklerdir. Her kaynak, adım adım açıklamalar ve tam çalışan kod örnekleri sunar; böylece ek API özelliklerini öğrenebilir ve projelerinizde alternatif uygulama yaklaşımlarını keşfedebilirsiniz. + +- [Render HTML as PNG in .NET with Aspose.HTML](/html/english/net/rendering-html-documents/render-html-as-png/) +- [How to Render HTML as PNG – Complete C# Guide](/html/english/net/rendering-html-documents/how-to-render-html-as-png-complete-c-guide/) +- [Create PNG from HTML – Full C# Rendering Guide](/html/english/net/rendering-html-documents/create-png-from-html-full-c-rendering-guide/) + +{{< /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 8dd996b055..6a9ca795cc 100644 --- a/html/turkish/net/html-extensions-and-conversions/_index.md +++ b/html/turkish/net/html-extensions-and-conversions/_index.md @@ -66,6 +66,8 @@ Aspose.HTML for .NET ile HTML'yi TIFF'e nasıl dönüştüreceğinizi öğrenin. ### [HTML'den PDF Oluşturma – C# Adım Adım Kılavuz](./create-pdf-from-html-c-step-by-step-guide/) Aspose.HTML for .NET kullanarak HTML'den PDF'ye nasıl dönüştüreceğinizi adım adım öğrenin. ### [C#'ta HTML'i Zip Dosyasına Sıkıştırma](./how-to-zip-html-in-c-save-html-to-zip/) +### [C#'ta HTML'yi ZIP Olarak Kaydet – Adım Adım Kılavuz](./save-html-as-zip-in-c-step-by-step-guide/) +Aspose.HTML for .NET kullanarak C# içinde HTML dosyalarını ZIP arşivine kaydetmeyi adım adım öğrenin. ### [Stil Verilmiş Metinle HTML Belgesi Oluşturma ve PDF'ye Dışa Aktarma – Tam Kılavuz](./create-html-document-with-styled-text-and-export-to-pdf-full/) ### [HTML'yi ZIP Olarak Kaydet – Tam C# Öğreticisi](./save-html-as-zip-complete-c-tutorial/) Aspose.HTML for .NET kullanarak HTML dosyalarını ZIP arşivine kaydetmeyi adım adım öğrenin. diff --git a/html/turkish/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md b/html/turkish/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..d0245e221d --- /dev/null +++ b/html/turkish/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md @@ -0,0 +1,322 @@ +--- +category: general +date: 2026-08-12 +description: Aspose.HTML kullanarak HTML'yi ZIP olarak kaydedin. HTML dizesini yüklemeyi, + özel bir kaynak işleyicisi oluşturmayı ve ZIP arşivini verimli bir şekilde üretmeyi + öğrenin. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save html as zip +- load html string +- custom resource handler +language: tr +lastmod: 2026-08-12 +og_description: Aspose.HTML kullanarak C#'ta HTML'yi ZIP olarak kaydedin. Bu öğreticide, + bir HTML dizesi nasıl yüklenir, özel bir kaynak işleyici nasıl oluşturulur ve birkaç + adımda ZIP arşivi nasıl oluşturulur gösterilmektedir. +og_image_alt: Diagram showing save html as zip process with custom resource handler +og_title: Aspose.HTML ile HTML'yi ZIP olarak kaydedin – tam C# rehberi +schemas: +- author: Aspose + dateModified: '2026-08-12' + description: Save HTML as ZIP using Aspose.HTML. Learn to load HTML string, create + a custom resource handler, and generate a ZIP archive efficiently. + headline: Save HTML as ZIP in C# – step‑by‑step guide + type: TechArticle +tags: +- Aspose.HTML +- C# +- ZIP archive +title: C#'ta HTML'yi ZIP olarak kaydet – adım adım rehber +url: /tr/net/html-extensions-and-conversions/save-html-as-zip-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 ZIP Olarak Kaydetme – C# Adım Adım Kılavuz + +Eğer bir .NET uygulamasında **HTML'yi ZIP olarak kaydetmeniz** gerekiyorsa, bu kılavuz tam süreci gösterir. **HTML dizesini yüklemeyi**, bir **özel kaynak işleyicisi** uygulamayı ve ara dosyaları diske yazmadan bir ZIP arşivi üretmeyi öğreneceksiniz. + +Bu yaklaşım, yüksek performanslı bir render motoru ve esnek kaydetme seçenekleri sunan Aspose.HTML 5.x'i kullanır. Eğitim sonunda, web servislerine, arka plan görevlerine veya masaüstü araçlarına entegre edilebilecek yeniden kullanılabilir bir işleyici elde edeceksiniz. + +## Ne oluşturacaksınız + +Son kod, HTML belgesini ve başvurulan tüm kaynakları (görseller, CSS, fontlar) içeren `MemoryStream` tabanlı bir ZIP dosyası oluşturur. ZIP dosyası hedef bir klasöre yazılır, ancak hedefi HTTP API'leri için bir yanıt akışına da değiştirebilirsiniz. + +## Önkoşullar + +- .NET 6.0 veya üzeri (örnek .NET 6 hedeflemektedir) +- Aspose.HTML for .NET (NuGet paketi `Aspose.HTML`) +- C# async desenlerine temel aşinalık (isteğe bağlı ancak faydalı) + +> **Pro ipucu:** Başlamadan önce paketi `dotnet add package Aspose.HTML` komutuyla kurun. + +## Adım 1: Özel bir kaynak işleyicisi tanımlayın + +Bir **özel kaynak işleyicisi**, HTML render'ının yaptığı her dış kaynak isteğini yakalar. Bir akış döndürerek, kaynak verisinin nerede saklanacağını kontrol edersiniz. Örnek, her şeyi bellekte tutar; bu, anlık bir ZIP arşivi oluşturmak için idealdir. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +///Hello, world!
+
+
+";
+
+// Create a new document instance.
+HtmlDocument document = new HtmlDocument();
+
+// Load the HTML markup.
+document.Open(htmlContent);
+```
+
+**Neden bu adım önemlidir:**
+**load html string** yeteneği, HTML'nin dinamik olarak (ör. bir şablon motorundan) üretilmesi veya bir API'den alınması durumunda faydalıdır. Dosya sistemi bağımlılıklarını ortadan kaldırır ve sandbox ortamlarında çalışır.
+
+## Adım 3: Kaydetme seçeneklerini işleyiciyi kullanacak şekilde yapılandırın
+
+Aspose.HTML’in `HtmlSaveOptions` sınıfı, çıktının depolama mekanizmasını belirlemenizi sağlar. Özel işleyiciyi `OutputStorage` özelliğine atayın ve `Compress` bayrağını ZIP arşivi üretmek için ayarlayın.
+
+```csharp
+// Instantiate the custom handler.
+var resourceHandler = new InMemoryResourceHandler();
+
+// Prepare save options.
+HtmlSaveOptions saveOptions = new HtmlSaveOptions
+{
+ // Use the handler for all external resources.
+ OutputStorage = resourceHandler,
+
+ // Enable ZIP compression.
+ Compress = true
+};
+```
+
+**Neden bu adım önemlidir:**
+`Compress = true` Aspose.HTML'e HTML dosyasını ve toplanan tüm kaynakları tek bir ZIP paketi içinde birleştirmesini söyler. `OutputStorage` ise kaynakların geçici konumlara yazılmak yerine bellekte yakalanmasını sağlar.
+
+## Adım 4: Belgeyi ZIP arşivi olarak kaydedin
+
+Şimdi `HtmlDocument.Save` metodunu çağırın, hedef yolu ve yapılandırılmış seçenekleri geçirin. Kaydetme sonrası, ZIP dosyası `index.html` ve işleyici tarafından yakalanan tüm kaynakları içerir.
+
+```csharp
+// Define the output path (you can change this to a response stream for web APIs).
+string outputPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+
+// Save the document; Aspose.HTML creates the ZIP automatically.
+document.Save(outputPath, saveOptions);
+
+// Optional: Verify the resources that were stored.
+foreach (var entry in resourceHandler.Resources)
+{
+ Console.WriteLine($"Resource: {entry.Key}, Size: {entry.Value.Length} bytes");
+}
+```
+
+**Beklenen sonuç:**
+Programı çalıştırmak, geçerli dizinde `output.zip` oluşturur. Arşivi çıkardığınızda şunlar görülür:
+
+```
+index.html
+styles.css
+logo.png
+```
+
+Her dosya işaretleme referanslarıyla eşleşir ve `index.html` içindeki HTML, paketlenmiş kaynaklara işaret eder.
+
+## Adım 5: Gerçek kaynak verileri için işleyiciyi uyarlayın (ileri düzey)
+
+Yukarıdaki temel işleyici boş akışlar oluşturur. Üretimde genellikle gerçek içeriği (ör. `styles.css` veya `logo.png` baytları) yazmanız gerekir. `HandleResource` metodunu, verileri bir veritabanından, bulut depolama biriminden veya gömülü bir kaynaktan alacak şekilde genişletin.
+
+```csharp
+public override Stream HandleResource(ResourceInfo info)
+{
+ // Example: Load resource from an embedded folder.
+ string resourcePath = Path.Combine("EmbeddedResources", info.Path);
+ byte[] data = File.ReadAllBytes(resourcePath);
+
+ // Write data into a memory stream.
+ var stream = new MemoryStream(data);
+ _resources[info.Path] = stream;
+
+ // Return the populated stream.
+ return stream;
+}
+```
+
+**Neden bu varyasyon önemlidir:**
+Gerçek içeriği sağlamak, ZIP arşivinin bir tarayıcıda açıldığında işlevsel olmasını garantiler. İşleyici, akışa yazmadan önce dönüşümler (ör. CSS sıkıştırma) uygulayabilir.
+
+## Adım 6: ZIP arşivini bir web API'sinde kullanın (isteğe bağlı)
+
+Eğer işlevselliği ASP.NET Core üzerinden sunuyorsanız, ZIP dosyasını bir dosya sonucu olarak döndürün:
+
+```csharp
+[HttpGet("download")]
+public IActionResult DownloadZip()
+{
+ // Reuse the same logic from steps 1‑4.
+ // ...
+
+ // Read the generated ZIP into a byte array.
+ byte[] zipBytes = System.IO.File.ReadAllBytes(outputPath);
+
+ // Return the file with the appropriate content type.
+ return File(zipBytes, "application/zip", "document.zip");
+}
+```
+
+**Neden bu adım önemlidir:**
+İstemciler, sunucuda geçici dosyalarla uğraşmadan paketlenmiş HTML'yi indirebilir. Bu yaklaşım, disk erişiminin sınırlı olduğu sunucusuz fonksiyonlarda da çalışır.
+
+## Yaygın tuzaklar ve nasıl önlenir
+
+| Sorun | Sebep | Çözüm |
+|-------|-------|------|
+| ZIP içinde boş kaynaklar | İşleyici, veri yazmadan yeni bir `MemoryStream` döndürür | Akışı gerçek baytlarla doldurun ve döndürün |
+| `index.html` girdisi eksik | `Compress` bayrağı ayarlı değil veya `OutputStorage` atanmadı | `saveOptions.Compress = true` ve `saveOptions.OutputStorage = handler` olduğundan emin olun |
+| Büyük HTML bellek baskısına neden oluyor | Tüm kaynaklar bellekte tutuluyor | Geçici bir klasöre yazan bir `FileStorage` uygulamasına geçin |
+| Çıkarma sonrası göreceli URL'ler bozuluyor | Depolanmayan mutlak URL'lerle referans verilen kaynaklar | İşleyici içinde veya son işleme sırasında URL'leri göreceli yollara yeniden yazın |
+
+## Tam, çalıştırılabilir örnek
+
+```csharp
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Saving;
+
+class InMemoryResourceHandler : ResourceHandler
+{
+ private readonly DictionaryHello, world!
+
+
+ ";
+
+ HtmlDocument doc = new HtmlDocument();
+ doc.Open(html);
+
+ // Step 1 & 3: Create handler and configure save options.
+ var handler = new InMemoryResourceHandler();
+ HtmlSaveOptions options = new HtmlSaveOptions
+ {
+ OutputStorage = handler,
+ Compress = true
+ };
+
+ // Step 4: Save as ZIP.
+ string zipPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+ doc.Save(zipPath, options);
+ Console.WriteLine($"ZIP file created at: {zipPath}");
+
+ // Optional verification.
+ foreach (var kvp in handler.Resources)
+ {
+ Console.WriteLine($"Resource {kvp.Key} captured, length {kvp.Value.Length} bytes");
+ }
+ }
+}
+```
+
+Programı çalıştırmak, yürütülebilir dosyanın yanına `output.zip` üretir. Arşivi çıkardığınızda `index.html`, `styles.css` ve `logo.png` (bu minimal örnekte boş yer tutucular) görülür.
+
+## Sonuç
+
+Artık Aspose.HTML kullanarak C# içinde **HTML'yi ZIP olarak kaydetmek** için güvenilir bir yönteme sahipsiniz. Eğitim, bir HTML dizesi yüklemeyi, bir **özel kaynak işleyicisi** uygulamayı, kaydetme seçeneklerini yapılandırmayı ve dağıtıma veya indirmeye hazır bir ZIP arşivi oluşturmayı kapsadı.
+
+Bundan sonra şunları yapabilirsiniz:
+
+- Yer tutucu akışları gerçek içerikle değiştirin (ör. bir veritabanından okuyun)
+- Çok büyük belgeler için dosya tabanlı bir depolama işleyicisine geçin
+- İsteğe bağlı indirmeler için mantığı ASP.NET Core uç noktalarına entegre edin
+- PDF dönüşümü veya görüntü render'ı gibi ek Aspose.HTML özelliklerini keşfedin
+
+Farklı kaynak türleri ve sıkıştırma ayarlarıyla deneyler yaparak çözümü performans ve boyut gereksinimlerinize göre özelleştirin. Kodlamanın tadını çıkarın!
+
+## Sonra Ne Öğrenmelisiniz?
+
+Aşağıdaki eğitimler, bu kılavuzda gösterilen tekniklere dayanan ve yakından ilgili konuları kapsar. Her kaynak, ek API özelliklerini öğrenmenize ve kendi projelerinizde alternatif uygulama yaklaşımlarını keşfetmenize yardımcı olmak için adım adım açıklamalar içeren tam çalışan kod örnekleri sunar.
+
+- [Save HTML as ZIP – Complete C# Tutorial](/html/english/net/html-extensions-and-conversions/save-html-as-zip-complete-c-tutorial/)
+- [How to Save HTML in C# – Complete Guide Using a Custom Resource Handler](/html/english/net/working-with-html-documents/how-to-save-html-in-c-complete-guide-using-a-custom-resource/)
+- [Create HTML from String in C# – Custom Resource Handler Guide](/html/english/net/html-document-manipulation/create-html-from-string-in-c-custom-resource-handler-guide/)
+
+{{< /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/generate-jpg-and-png-images/_index.md b/html/vietnamese/net/generate-jpg-and-png-images/_index.md
index 364f751610..5aff994bbf 100644
--- a/html/vietnamese/net/generate-jpg-and-png-images/_index.md
+++ b/html/vietnamese/net/generate-jpg-and-png-images/_index.md
@@ -45,6 +45,8 @@ Học cách sử dụng Aspose.HTML cho .NET để thao tác với các tài li
Hướng dẫn chi tiết cách bật khử răng cưa để cải thiện chất lượng hình ảnh khi chuyển đổi tài liệu DOCX sang PNG hoặc JPG bằng Aspose.HTML.
### [Chuyển đổi DOCX sang PNG – tạo tệp ZIP bằng C# – Hướng dẫn](./convert-docx-to-png-create-zip-archive-c-tutorial/)
Hướng dẫn cách chuyển đổi tài liệu DOCX thành hình ảnh PNG và đóng gói chúng vào tệp ZIP bằng C#.
+### [Tạo PNG từ HTML trong C# bằng Aspose.HTML](./create-png-from-html-in-c-using-aspose-html/)
+Hướng dẫn chi tiết cách tạo ảnh PNG từ mã HTML bằng C# và Aspose.HTML.
## Phần kết luận
diff --git a/html/vietnamese/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md b/html/vietnamese/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
new file mode 100644
index 0000000000..e8c12a036e
--- /dev/null
+++ b/html/vietnamese/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/_index.md
@@ -0,0 +1,291 @@
+---
+category: general
+date: 2026-08-12
+description: Tạo PNG từ HTML trong C# với Aspose.HTML. Tìm hiểu cách chuyển đổi HTML
+ sang PNG và hiển thị HTML dưới dạng hình ảnh chỉ trong vài dòng mã.
+draft: false
+images:
+- PLACEHOLDER_URL/og-image.png
+keywords:
+- create png from html
+- convert html to png
+- render html as image
+- how to render html to image
+language: vi
+lastmod: 2026-08-12
+og_description: Tạo PNG từ HTML trong C# bằng Aspose.HTML. Hướng dẫn này cho thấy
+ cách chuyển đổi HTML thành hình ảnh nhanh chóng, bao gồm các tùy chọn chuyển đổi,
+ thiết lập mã và khắc phục sự cố.
+og_image_alt: Screenshot of a C# program converting HTML to a PNG image
+og_title: Tạo PNG từ HTML trong C# – hướng dẫn từng bước
+schemas:
+- author: Aspose
+ dateModified: '2026-08-12'
+ description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ headline: Create PNG from HTML in C# using Aspose.HTML
+ type: TechArticle
+- description: Create PNG from HTML in C# with Aspose.HTML. Learn how to convert HTML
+ to PNG and render HTML as image in just a few lines of code.
+ name: Create PNG from HTML in C# using Aspose.HTML
+ steps:
+ - name: Why this works
+ text: '- **`HtmlDocument.Open`** parses the HTML string into a DOM that Aspose.HTML
+ can render. - **`ImageRenderingOptions`** lets you control anti‑aliasing, text
+ hinting, and font handling, which are essential when you **render HTML as image**
+ to avoid blurry text. - **`ImageConverter.ConvertHtmlToImage`*'
+ - name: 1. Preparing the HTML source
+ text: You can load HTML from a string (as shown), a local file, or a remote URL.
+ - name: 2. Fine‑tuning rendering options
+ text: '| Option | Effect | When to adjust | |--------|--------|----------------|
+ | `UseAntialiasing` | Reduces jagged edges on vector graphics | Always enable
+ for high‑quality output | | `TextOptions.UseHinting` | Sharpens glyph edges
+ | Important for small font sizes | | `FontOptions.WebFontStyle` | Choose'
+ - name: 3. Performing the conversion
+ text: The `ImageConverter` overload you used writes a single PNG file. If you
+ need multiple pages (e.g., a multi‑page HTML document), use the overload that
+ returns a collection of images.
+ - name: a. Missing fonts
+ text: If the HTML references a custom web font that isn’t installed on the server,
+ the rendered text falls back to a default font, which may affect layout.
+ - name: b. Large pages and memory consumption
+ text: Rendering a very tall page can consume a lot of RAM.
+ - name: c. Transparent backgrounds
+ text: PNG supports transparency, but the default background is white.
+ type: HowTo
+tags:
+- Aspose.HTML
+- C#
+- image rendering
+- HTML conversion
+title: Tạo PNG từ HTML trong C# sử dụng Aspose.HTML
+url: /vi/net/generate-jpg-and-png-images/create-png-from-html-in-c-using-aspose-html/
+---
+
+{{< blocks/products/pf/main-wrap-class >}}
+{{< blocks/products/pf/main-container >}}
+{{< blocks/products/pf/tutorial-page-section >}}
+
+# Tạo PNG từ HTML trong C# sử dụng Aspose.HTML
+
+Nếu bạn cần **tạo PNG từ HTML** trong một ứng dụng .NET, hướng dẫn này sẽ đưa bạn qua toàn bộ quy trình. Bạn sẽ thấy cách **chuyển đổi HTML sang PNG** chỉ với vài dòng mã C#, nhờ vào engine render mạnh mẽ của Aspose.HTML.
+
+Việc render HTML thành hình ảnh là yêu cầu phổ biến khi tạo thumbnail, preview email, hoặc báo cáo cần nhúng vào PDF. Trong các phần tiếp theo, bạn sẽ học các bước chính xác, xem một ví dụ hoàn chỉnh, và hiểu lý do tại sao mỗi thiết lập lại quan trọng.
+
+## Những gì bạn sẽ học
+
+- Cách tạo một `HtmlDocument` từ chuỗi hoặc tệp.
+- Cách cấu hình `ImageRenderingOptions` để cải thiện chất lượng.
+- Cách **chuyển đổi HTML sang PNG** và lưu kết quả ra đĩa.
+- Mẹo xử lý phông chữ, trang lớn, và đường dẫn xuất tùy chỉnh.
+
+**Yêu cầu trước**
+- .NET 6.0 SDK (hoặc mới hơn) đã được cài đặt.
+- Giấy phép Aspose.HTML for .NET hợp lệ (hoặc khóa đánh giá tạm thời).
+- Kiến thức cơ bản về C# và Visual Studio hoặc bất kỳ IDE nào hỗ trợ .NET.
+
+---
+
+## Tạo PNG từ HTML với Aspose.HTML
+
+Bước đầu tiên là thiết lập môi trường và tham chiếu các namespace Aspose.HTML cần thiết.
+
+```csharp
+using System;
+using Aspose.Html;
+using Aspose.Html.Rendering.Image;
+using Aspose.Html.Drawing;
+using Aspose.Html.Converters;
+
+namespace HtmlToPngDemo
+{
+ class Program
+ {
+ static void Main()
+ {
+ // 1️⃣ Build the HTML document from a raw string.
+ var html = "Bold text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // 2️⃣ Configure rendering options for best visual fidelity. + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, // Smooths edges of drawn shapes + TextOptions = { UseHinting = true }, // Improves glyph clarity + FontOptions = { WebFontStyle = WebFontStyle.Normal } // Uses standard web‑font style + }; + + // 3️⃣ Convert the HTML document to a PNG file. + string outputPath = @"output.png"; + ImageConverter.ConvertHtmlToImage(document, outputPath, renderOptions); + + Console.WriteLine($"PNG image created at: {outputPath}"); + } + } +} +``` + +### Tại sao cách này hoạt động + +- **`HtmlDocument.Open`** phân tích chuỗi HTML thành DOM mà Aspose.HTML có thể render. +- **`ImageRenderingOptions`** cho phép bạn kiểm soát anti‑aliasing, text hinting và xử lý phông chữ, những yếu tố thiết yếu khi **render HTML thành hình ảnh** để tránh văn bản mờ. +- **`ImageConverter.ConvertHtmlToImage`** thực hiện công việc nặng: rasterize DOM lên bitmap và ghi file PNG. + +Chạy chương trình sẽ tạo ra `output.png` chứa đoạn văn bản in đậm chính xác như trong nguồn HTML. + +--- + +## Chuyển đổi HTML sang PNG từng bước + +Dưới đây là hướng dẫn chi tiết hơn cho mỗi giai đoạn. Hiểu mục đích của từng dòng mã sẽ giúp bạn điều chỉnh cho các trang lớn hoặc phức tạp hơn. + +### 1. Chuẩn bị nguồn HTML + +Bạn có thể tải HTML từ chuỗi (như ví dụ), tệp cục bộ, hoặc URL từ xa. + +```csharp +// Load from a file +var document = new HtmlDocument(); +document.Open(@"C:\templates\invoice.html"); + +// Load from a URL (requires internet access) +document.Open("https://example.com/report.html"); +``` + +**Mẹo:** Khi tải các tài nguyên bên ngoài (CSS, hình ảnh), hãy chắc chắn thuộc tính `BaseUrl` trỏ tới thư mục đúng để các liên kết tương đối được giải quyết chính xác. + +### 2. Tinh chỉnh các tùy chọn render + +| Tùy chọn | Hiệu ứng | Khi cần điều chỉnh | +|----------|----------|--------------------| +| `UseAntialiasing` | Giảm các cạnh răng cưa trên đồ họa vector | Luôn bật để có đầu ra chất lượng cao | +| `TextOptions.UseHinting` | Làm sắc nét các cạnh glyph | Quan trọng đối với kích thước phông chữ nhỏ | +| `FontOptions.WebFontStyle` | Chọn render web‑font bình thường, nghiêng, hoặc oblique | Dùng `WebFontStyle.Oblique` cho phông chữ nghiêng | +| `ResolutionX` / `ResolutionY` | DPI của ảnh đầu ra | Tăng lên để tạo PNG chuẩn in (ví dụ, 300 DPI) | + +Ví dụ tăng DPI: + +```csharp +renderOptions.ResolutionX = 300; +renderOptions.ResolutionY = 300; +``` + +### 3. Thực hiện chuyển đổi + +Phương thức overload `ImageConverter` bạn dùng sẽ ghi một file PNG duy nhất. Nếu cần nhiều trang (ví dụ, tài liệu HTML đa trang), hãy dùng overload trả về một collection các ảnh. + +```csharp +ImageConverter.ConvertHtmlToImages(document, "output_folder", renderOptions); +``` + +Mỗi trang sẽ được lưu thành `output_folder/page_0.png`, `page_1.png`, v.v. + +--- + +## Render HTML thành hình ảnh – xử lý các vấn đề thường gặp + +### a. Thiếu phông chữ + +Nếu HTML tham chiếu một web‑font tùy chỉnh mà không được cài trên server, văn bản sẽ fallback về phông chữ mặc định, có thể làm thay đổi bố cục. + +**Giải pháp:** Nhúng phông chữ bằng quy tắc `@font-face` trong CSS hoặc cung cấp thư mục phông chữ cục bộ qua `FontOptions`. + +```csharp +renderOptions.FontOptions.FontFolder = @"C:\fonts"; +``` + +### b. Trang lớn và tiêu thụ bộ nhớ + +Render một trang rất dài có thể tiêu tốn nhiều RAM. + +**Giải pháp:** Đặt chiều cao tối đa hoặc chia tài liệu thành các phần trước khi chuyển đổi. + +```csharp +renderOptions.PageHeight = 2000; // pixels +``` + +### c. Nền trong suốt + +PNG hỗ trợ độ trong suốt, nhưng nền mặc định là màu trắng. + +**Giải pháp:** Thay đổi màu nền thành trong suốt. + +```csharp +renderOptions.BackgroundColor = System.Drawing.Color.Transparent; +``` + +--- + +## Cách render HTML thành hình ảnh – tổng hợp ví dụ đầy đủ + +Kết hợp tất cả lại, đây là đoạn mã sẵn sàng cho môi trường production, đáp ứng các yêu cầu phổ biến nhất: + +```csharp +using System; +using Aspose.Html; +using Aspose.Html.Rendering.Image; +using Aspose.Html.Drawing; +using Aspose.Html.Converters; + +namespace HtmlToPngDemo +{ + class Program + { + static void Main() + { + // Load HTML (string, file, or URL) + string html = "" + + "Bold blue text
"; + using var document = new HtmlDocument(); + document.Open(html); + + // Configure rendering for high quality and transparency + var renderOptions = new ImageRenderingOptions + { + UseAntialiasing = true, + TextOptions = { UseHinting = true }, + FontOptions = { WebFontStyle = WebFontStyle.Normal, FontFolder = @"C:\fonts" }, + BackgroundColor = System.Drawing.Color.Transparent, + ResolutionX = 150, + ResolutionY = 150 + }; + + // Convert and save + string outPath = @"C:\temp\html_snapshot.png"; + ImageConverter.ConvertHtmlToImage(document, outPath, renderOptions); + + Console.WriteLine($"Image saved to {outPath}"); + } + } +} +``` + +**Kết quả mong đợi:** Một file `html_snapshot.png` chứa đoạn văn bản in đậm, màu xanh trên nền trong suốt. Hình ảnh sẽ được anti‑aliased, với văn bản sắc nét nhờ hinting. + +--- + +## Kết luận + +Bây giờ bạn đã biết cách **tạo PNG từ HTML** trong C# bằng Aspose.HTML. Bằng việc tạo một `HtmlDocument`, cấu hình `ImageRenderingOptions`, và gọi `ImageConverter.ConvertHtmlToImage`, bạn có thể tin cậy **chuyển đổi HTML sang PNG** và **render HTML thành hình ảnh** cho bất kỳ kịch bản tự động nào. + +Từ đây bạn có thể khám phá: + +- Tạo thumbnail cho các trang web động. +- Nhúng PNG vào PDF bằng Aspose.PDF. +- Sử dụng cùng một cách tiếp cận để tạo JPEG hoặc BMP bằng cách thay đổi phần mở rộng file. + +Hãy thử nghiệm với DPI, màu nền, và render đa trang để phù hợp chính xác với nhu cầu dự án của bạn. Chúc bạn lập trình vui vẻ! + +## Bạn nên học gì tiếp theo? + +Các hướng dẫn sau đây đề cập đến các chủ đề liên quan chặt chẽ, xây dựng trên các kỹ thuật đã trình bày trong hướng dẫn này. Mỗi tài nguyên bao gồm mã mẫu đầy đủ với giải thích từng bước để giúp bạn làm chủ các tính năng API bổ sung và khám phá các cách triển khai thay thế trong dự án của mình. + +- [Render HTML dưới dạng PNG trong .NET với Aspose.HTML](/html/english/net/rendering-html-documents/render-html-as-png/) +- [Cách Render HTML thành PNG – Hướng dẫn C# đầy đủ](/html/english/net/rendering-html-documents/how-to-render-html-as-png-complete-c-guide/) +- [Tạo PNG từ HTML – Hướng dẫn Render C# toàn diện](/html/english/net/rendering-html-documents/create-png-from-html-full-c-rendering-guide/) + +{{< /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 169c7624f6..aeb42b005e 100644 --- a/html/vietnamese/net/html-extensions-and-conversions/_index.md +++ b/html/vietnamese/net/html-extensions-and-conversions/_index.md @@ -71,6 +71,8 @@ Hướng dẫn chi tiết cách tạo tài liệu HTML có văn bản định d Tạo PDF từ HTML trong .NET bằng C#. Hướng dẫn chi tiết từng bước để chuyển đổi HTML sang PDF nhanh chóng. ### [Lưu HTML dưới dạng ZIP – Hướng dẫn C# hoàn chỉnh](./save-html-as-zip-complete-c-tutorial/) Hướng dẫn chi tiết cách lưu tài liệu HTML thành tệp ZIP bằng Aspose.HTML cho .NET với C#. +### [Lưu HTML dưới dạng ZIP trong C# – hướng dẫn từng bước](./save-html-as-zip-in-c-step-by-step-guide/) +Hướng dẫn chi tiết cách lưu tài liệu HTML thành tệp ZIP bằng C# và Aspose.HTML cho .NET. ### [Lưu HTML thành ZIP trong C# – Ví dụ Toàn bộ trong Bộ nhớ](./save-html-to-zip-in-c-complete-in-memory-example/) Hướng dẫn lưu tài liệu HTML vào tệp ZIP trong C# bằng Aspose.HTML, sử dụng bộ nhớ tạm và không tạo file tạm trên đĩa. diff --git a/html/vietnamese/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md b/html/vietnamese/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md new file mode 100644 index 0000000000..76b59d3de0 --- /dev/null +++ b/html/vietnamese/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/_index.md @@ -0,0 +1,321 @@ +--- +category: general +date: 2026-08-12 +description: Lưu HTML dưới dạng ZIP bằng Aspose.HTML. Tìm hiểu cách tải chuỗi HTML, + tạo trình xử lý tài nguyên tùy chỉnh và tạo tệp ZIP một cách hiệu quả. +draft: false +images: +- PLACEHOLDER_URL/og-image.png +keywords: +- save html as zip +- load html string +- custom resource handler +language: vi +lastmod: 2026-08-12 +og_description: Lưu HTML dưới dạng ZIP bằng Aspose.HTML trong C#. Hướng dẫn này cho + thấy cách tải một chuỗi HTML, tạo trình xử lý tài nguyên tùy chỉnh và tạo một tệp + ZIP trong vài bước. +og_image_alt: Diagram showing save html as zip process with custom resource handler +og_title: Lưu HTML dưới dạng ZIP với Aspose.HTML – hướng dẫn C# đầy đủ +schemas: +- author: Aspose + dateModified: '2026-08-12' + description: Save HTML as ZIP using Aspose.HTML. Learn to load HTML string, create + a custom resource handler, and generate a ZIP archive efficiently. + headline: Save HTML as ZIP in C# – step‑by‑step guide + type: TechArticle +tags: +- Aspose.HTML +- C# +- ZIP archive +title: Lưu HTML dưới dạng ZIP trong C# – hướng dẫn từng bước +url: /vi/net/html-extensions-and-conversions/save-html-as-zip-in-c-step-by-step-guide/ +--- + +{{< blocks/products/pf/main-wrap-class >}} +{{< blocks/products/pf/main-container >}} +{{< blocks/products/pf/tutorial-page-section >}} + +# Lưu HTML dưới dạng ZIP trong C# – hướng dẫn từng bước + +Nếu bạn cần **lưu HTML dưới dạng ZIP** trong một ứng dụng .NET, hướng dẫn này sẽ trình bày quy trình hoàn chỉnh. Bạn sẽ học cách **tải chuỗi HTML**, triển khai **bộ xử lý tài nguyên tùy chỉnh**, và tạo một tệp ZIP mà không cần ghi các tệp trung gian lên đĩa. + +Phương pháp này sử dụng Aspose.HTML 5.x, cung cấp một engine render hiệu suất cao và các tùy chọn lưu linh hoạt. Khi kết thúc tutorial, bạn sẽ có một bộ xử lý có thể tái sử dụng, có thể tích hợp vào các dịch vụ web, công việc nền, hoặc công cụ desktop. + +## Những gì bạn sẽ xây dựng + +Mã cuối cùng tạo một tệp ZIP dựa trên `MemoryStream` chứa tài liệu HTML và mọi tài nguyên được tham chiếu (hình ảnh, CSS, phông chữ). Tệp ZIP được ghi vào một thư mục đích, nhưng bạn có thể thay đổi đích thành một luồng phản hồi cho các API HTTP. + +## Yêu cầu trước + +- .NET 6.0 hoặc phiên bản mới hơn (mẫu này nhắm tới .NET 6) +- Aspose.HTML cho .NET (gói NuGet `Aspose.HTML`) +- Kiến thức cơ bản về các mẫu async trong C# (tùy chọn nhưng hữu ích) + +> **Mẹo chuyên nghiệp:** Cài đặt gói bằng `dotnet add package Aspose.HTML` trước khi bắt đầu. + +## Bước 1: Định nghĩa bộ xử lý tài nguyên tùy chỉnh + +Một **bộ xử lý tài nguyên tùy chỉnh** can thiệp vào mọi yêu cầu tài nguyên bên ngoài mà trình render HTML thực hiện. Bằng cách trả về một stream, bạn kiểm soát nơi dữ liệu tài nguyên được lưu trữ. Ví dụ lưu mọi thứ trong bộ nhớ, rất thích hợp để tạo một tệp ZIP ngay lập tức. + +```csharp +using System.IO; +using Aspose.Html; +using Aspose.Html.Saving; + +///Hello, world!
+
+
+";
+
+// Create a new document instance.
+HtmlDocument document = new HtmlDocument();
+
+// Load the HTML markup.
+document.Open(htmlContent);
+```
+
+**Tại sao bước này quan trọng:**
+Khả năng **load html string** hữu ích khi HTML được tạo động (ví dụ, từ một engine mẫu) hoặc nhận từ một API. Nó tránh phụ thuộc vào hệ thống tệp và hoạt động trong môi trường sandbox.
+
+## Bước 3: Cấu hình tùy chọn lưu để sử dụng bộ xử lý
+
+`HtmlSaveOptions` của Aspose.HTML cho phép bạn chỉ định cơ chế lưu trữ cho đầu ra. Gán bộ xử lý tùy chỉnh vào thuộc tính `OutputStorage`, và đặt cờ `Compress` để tạo một tệp ZIP.
+
+```csharp
+// Instantiate the custom handler.
+var resourceHandler = new InMemoryResourceHandler();
+
+// Prepare save options.
+HtmlSaveOptions saveOptions = new HtmlSaveOptions
+{
+ // Use the handler for all external resources.
+ OutputStorage = resourceHandler,
+
+ // Enable ZIP compression.
+ Compress = true
+};
+```
+
+**Tại sao bước này quan trọng:**
+`Compress = true` báo cho Aspose.HTML gói tệp HTML và tất cả tài nguyên đã thu thập vào một gói ZIP duy nhất. `OutputStorage` đảm bảo các tài nguyên được nắm bắt trong bộ nhớ thay vì ghi vào vị trí tạm thời.
+
+## Bước 4: Lưu tài liệu dưới dạng tệp ZIP
+
+Bây giờ gọi `HtmlDocument.Save`, truyền đường dẫn đích và các tùy chọn đã cấu hình. Sau khi lưu, tệp ZIP chứa `index.html` cộng với bất kỳ tài nguyên nào được bộ xử lý bắt giữ.
+
+```csharp
+// Define the output path (you can change this to a response stream for web APIs).
+string outputPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+
+// Save the document; Aspose.HTML creates the ZIP automatically.
+document.Save(outputPath, saveOptions);
+
+// Optional: Verify the resources that were stored.
+foreach (var entry in resourceHandler.Resources)
+{
+ Console.WriteLine($"Resource: {entry.Key}, Size: {entry.Value.Length} bytes");
+}
+```
+
+**Kết quả mong đợi:**
+Chạy chương trình sẽ tạo `output.zip` trong thư mục hiện tại. Giải nén gói sẽ hiển thị:
+
+```
+index.html
+styles.css
+logo.png
+```
+
+Mỗi tệp khớp với các tham chiếu markup, và HTML trong `index.html` trỏ tới các tài nguyên đã được đóng gói.
+
+## Bước 5: Điều chỉnh bộ xử lý cho dữ liệu tài nguyên thực (nâng cao)
+
+Bộ xử lý cơ bản ở trên tạo các stream rỗng. Trong môi trường sản xuất bạn thường cần ghi nội dung thực (ví dụ, byte của `styles.css` hoặc `logo.png`). Mở rộng `HandleResource` để lấy dữ liệu từ cơ sở dữ liệu, bucket đám mây, hoặc tài nguyên nhúng.
+
+```csharp
+public override Stream HandleResource(ResourceInfo info)
+{
+ // Example: Load resource from an embedded folder.
+ string resourcePath = Path.Combine("EmbeddedResources", info.Path);
+ byte[] data = File.ReadAllBytes(resourcePath);
+
+ // Write data into a memory stream.
+ var stream = new MemoryStream(data);
+ _resources[info.Path] = stream;
+
+ // Return the populated stream.
+ return stream;
+}
+```
+
+**Tại sao biến thể này quan trọng:**
+Cung cấp nội dung thực đảm bảo tệp ZIP hoạt động khi mở trong trình duyệt. Bộ xử lý cũng có thể áp dụng các biến đổi (ví dụ, minify CSS) trước khi ghi vào stream.
+
+## Bước 6: Sử dụng tệp ZIP trong một Web API (tùy chọn)
+
+Nếu bạn cung cấp chức năng này qua ASP.NET Core, trả về tệp ZIP như một kết quả file:
+
+```csharp
+[HttpGet("download")]
+public IActionResult DownloadZip()
+{
+ // Reuse the same logic from steps 1‑4.
+ // ...
+
+ // Read the generated ZIP into a byte array.
+ byte[] zipBytes = System.IO.File.ReadAllBytes(outputPath);
+
+ // Return the file with the appropriate content type.
+ return File(zipBytes, "application/zip", "document.zip");
+}
+```
+
+**Tại sao bước này quan trọng:**
+Khách hàng có thể tải xuống HTML đã đóng gói mà không phải xử lý các tệp tạm thời trên máy chủ. Phương pháp này hoạt động với các hàm serverless nơi truy cập đĩa bị giới hạn.
+
+## Những lỗi thường gặp và cách tránh
+
+| Lỗi | Nguyên nhân | Cách khắc phục |
+|-----|-------------|----------------|
+| Tài nguyên rỗng trong ZIP | Bộ xử lý trả về một `MemoryStream` mới mà không ghi dữ liệu | Điền dữ liệu thực vào stream trước khi trả về |
+| Thiếu mục `index.html` | Cờ `Compress` chưa được đặt hoặc `OutputStorage` chưa được gán | Đảm bảo `saveOptions.Compress = true` và `saveOptions.OutputStorage = handler` |
+| HTML lớn gây áp lực bộ nhớ | Tất cả tài nguyên được giữ trong bộ nhớ | Chuyển sang triển khai `FileStorage` ghi vào thư mục tạm |
+| URL tương đối bị hỏng sau khi giải nén | Tài nguyên được tham chiếu bằng URL tuyệt đối mà không được lưu | Viết lại URL thành đường dẫn tương đối trong bộ xử lý hoặc trong quá trình hậu xử lý |
+
+## Ví dụ đầy đủ, có thể chạy
+
+```csharp
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Aspose.Html;
+using Aspose.Html.Saving;
+
+class InMemoryResourceHandler : ResourceHandler
+{
+ private readonly DictionaryHello, world!
+
+
+ ";
+
+ HtmlDocument doc = new HtmlDocument();
+ doc.Open(html);
+
+ // Step 1 & 3: Create handler and configure save options.
+ var handler = new InMemoryResourceHandler();
+ HtmlSaveOptions options = new HtmlSaveOptions
+ {
+ OutputStorage = handler,
+ Compress = true
+ };
+
+ // Step 4: Save as ZIP.
+ string zipPath = Path.Combine(Environment.CurrentDirectory, "output.zip");
+ doc.Save(zipPath, options);
+ Console.WriteLine($"ZIP file created at: {zipPath}");
+
+ // Optional verification.
+ foreach (var kvp in handler.Resources)
+ {
+ Console.WriteLine($"Resource {kvp.Key} captured, length {kvp.Value.Length} bytes");
+ }
+ }
+}
+```
+
+Chạy chương trình sẽ tạo `output.zip` bên cạnh tệp thực thi. Giải nén gói sẽ hiển thị `index.html`, `styles.css`, và `logo.png` (các placeholder rỗng trong ví dụ tối thiểu này).
+
+## Kết luận
+
+Bây giờ bạn đã có một phương pháp đáng tin cậy để **lưu HTML dưới dạng ZIP** bằng Aspose.HTML trong C#. Tutorial đã bao gồm việc tải một chuỗi HTML, triển khai **bộ xử lý tài nguyên tùy chỉnh**, cấu hình các tùy chọn lưu, và tạo một tệp ZIP sẵn sàng cho việc phân phối hoặc tải xuống.
+
+Từ đây bạn có thể:
+
+- Thay thế các stream placeholder bằng nội dung thực (ví dụ, đọc từ cơ sở dữ liệu)
+- Chuyển sang bộ xử lý lưu trữ dựa trên tệp cho các tài liệu rất lớn
+- Tích hợp logic vào các endpoint ASP.NET Core để tải xuống theo yêu cầu
+- Khám phá các tính năng bổ sung của Aspose.HTML như chuyển đổi PDF hoặc render hình ảnh
+
+Thử nghiệm với các nguồn tài nguyên và cài đặt nén khác nhau để điều chỉnh giải pháp phù hợp với yêu cầu về hiệu năng và kích thước của bạn. Chúc lập trình vui vẻ!
+
+## Bạn nên học gì tiếp theo?
+
+Các tutorial sau đây bao gồm các chủ đề liên quan chặt chẽ, xây dựng trên các kỹ thuật được trình bày trong hướng dẫn này. Mỗi tài nguyên bao gồm các ví dụ mã hoạt động đầy đủ với các giải thích từng bước để giúp bạn nắm vững các tính năng API bổ sung và khám phá các cách triển khai thay thế trong dự án của mình.
+
+- [Lưu HTML dưới dạng ZIP – Hướng dẫn C# đầy đủ](/html/english/net/html-extensions-and-conversions/save-html-as-zip-complete-c-tutorial/)
+- [Cách lưu HTML trong C# – Hướng dẫn đầy đủ sử dụng bộ xử lý tài nguyên tùy chỉnh](/html/english/net/working-with-html-documents/how-to-save-html-in-c-complete-guide-using-a-custom-resource/)
+- [Tạo HTML từ chuỗi trong C# – Hướng dẫn bộ xử lý tài nguyên tùy chỉnh](/html/english/net/html-document-manipulation/create-html-from-string-in-c-custom-resource-handler-guide/)
+
+{{< /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