הגירה ל-.NET Standard 2.1

העברת יישום Doconut.NETStandard קיים מ‑26.7.0 ל‑26.8.0

Doconut יש שתי אינטגרציות .NET Standard מובחנות. הן משתמשות באותו שם חבילה Doconut.NETStandard, ולכן יש לזהות את הדור מהגרסה וה‑APIs ביישום לפני שינוי חבילות, אתחול, רשיונות או משאבי דפדפן.

הגרסה היא הצומת בדרך

שתי הדורות מפרסמים תחת זהה חבילה זהה. רק הגרסה מבחינה ביניהם:

גרסהיעדAPI
26.7.0 ומטהnetstandard2.0ה‑API הקודם
26.8.0 ומעלהnetstandard2.1ה‑API הנוכחי

העלאת מספר הגרסה היא השדרוג. אין חבילה נפרדת להתקנה ואין שכבת התאמה — 26.8.0 הוא משטח API שונה. צפו לשגיאות קומפילציה לאחר העלאה; שאר המדריך הוא רשימתן.

איזו אינטגרציה אתה משתמש?

אם הפרויקט מכיל…דור
new Viewer(_cache, _accessor, ...)קודמת
viewer.OpenDocument(...) (סינכרוני)קודמת
viewer.InitCache()קודמת
UseDoconut(new DoconutOptions { ... })קודמת
UseDoconutWebFarm(...) / WebFarmOptionsקודמת
Viewer.DoconutLicense(...) או Viewer.SetLicensePlugin(...)קודמת
viewer.Converter.GetConverter()קודמת
using Doconut.Configs; / using Doconut.Models;קודמת
docViewer.js, documentLinks.js, או docViewer.UI.js הועתקו ידניתקודמת
builder.Services.AddDoconut(...)נוכחית
app.UseDoconutResources() בתוספת app.UseDoconut() ללא ארגומנטיםנוכחית
Viewer מסופק על ידי הזרקת תלויותנוכחית
await viewer.OpenDocumentAsync(...)נוכחית

אם שני העמודות מופיעות באותו יישום, יש להתייחס למיגרציה כחסרה. אל תשלח אסימון מסמך אחד דרך משאבים או middleware מהדור השני.

בדוק תחילה את מסגרת האירוח

זהו שער קפדני, לא העדפה. החבילה הנוכחית ממקדת ל‑netstandard2.1:

מארחיכול לצרוך 26.8.0
.NET Core 3.0 או מאוחר יותר (כולל .NET 5/6/7/8)כן
.NET Framework, כל גרסהלא

.NET Framework אינו יכול להתייחס לספריית netstandard2.1. אם היישום פועל על .NET Framework, עצור כאן והשתמש בחבילה Doconut.NETFramework במקום; החל מ‑26.9.0 היא דורשת .NET Framework 4.7.2. שני יישומי ההפניה עבור גרסה זו ממקדים net8.0.

לפני שאתה ממגר

  1. צור סניף וגיבוי שניתן לפריסה של היישום הקיים.
  2. תעד את גרסאות החבילות הליבה והתוספים המדויקות.
  3. ערוך רשימת כל קריאת new Viewer(...), קריאת InitCache(), קריאת טעינת רישיון, מיפוי UseDoconutWebFarm, בקרת המרה, סקריפט Doconut שהועתק, פעולה מותאמת של סרגל כלים, קריאת חזור של Viewer, ונקודת קצה של פתיחת מסמך.
  4. שמר את קבצי .lic הנוכחיים וסודות הפריסה מחוץ לבקרת גרסאות.
  5. לכוד סט ייצוגי של מסמכי PDF, Office, תמונות, CAD, אימייל, DICOM, ניתנים לחיפוש, מוגנים בסיסמה, ומועברים עם הערות.
  6. תעד את זמן קצוב של הסשן הקיים, התנהגות האבטחה, הגופנים והגדרות הפלטפורמה.

הגר את סביבת עבודה אחת לפני שינוי בייצור. האינטגרציה הנוכחית משנה את חיי השירות, ניתוב הבקשות, בעלות הסשן, אספקת משאבי הלקוח, ו‑— אם אתה מריץ חווה — איך הדפים מגיעים לדפדפן בכלל.

1. מרחבי שמות: כמעט הכל הועבר לשורש

סוגי התצורה היו מפוזרים על פני ארבעה מרחבי שמות. כעת כולם נמצאים ב‑Doconut.

לפניעכשיו
using Doconut.Configs.View;using Doconut;
using Doconut.Models;using Doconut;
using Doconut.Configs;using Doconut;
using Doconut.Configs.Cloud;using Doconut.Clouds;
using Doconut.Configs.Conversion;ללא שינוי
using Doconut.Middleware;ללא שינוי

השמות סוגים לא השתנו: WordConfig, PdfConfig, ExcelConfig, CssConfig, ScriptConfig, CloudUploadConfig, AzureConfig, CDNConfig, FileShareConfig והשאר עדיין קיימים. ברוב הקבצים העריכה המלאה היא מחיקת שני קווי using.

Doconut.Configs.Editor (BaseConfigEditor, PdfConfigEditor) הוסר ואין לו תחליף בחבילה זו. אם היישום שלך התייחס לאותם סוגים, תכנן חלק זה בנפרד ואל תחשיב זאת כחלק מהמיגרציה.

2. התאמה של חבילות ורשיונות

החלף או עדכן את חבילת הליבה במכוון; אל תסתמך על מזהה החבילה המזהה לבחירת ה‑API החדש. הפקודה המוגדרת כברירת מחדל מתקינה את הגרסה היציבה האחרונה:

bash
dotnet add package Doconut.NETStandard

כדי לבצע מעבר ניתן לשחזור לגרסה שנבדקה על ידי מדריך זה, העבר את הגרסה כאופציה נפרדת:

bash
dotnet add package Doconut.NETStandard --version 26.9.0

שמור שכל תוסף של Doconut באותה גרסה כמו חבילת הליבה — Doconut.NETStandard.Converter ו‑Doconut.NETStandard.Dicom. האינטגרציה הנוכחית טוענת רשיונות פעם אחת במהלך AddDoconut(), תוך שימוש בעדיפות זו:

text
LicenseStream > LicenseContent > LicensePath > automatic discovery

גילוי אוטומטי מחפש את Doconut.Viewer.lic וקבצי המלווה Doconut.Viewer.<Capability>.lic. הקריאות הסטטיות הקודמות Viewer.DoconutLicense(...) ו‑Viewer.SetLicensePlugin(...) אינן מנגנון אתחול נוכחי, וגם לא List<string> של נתיבי רישיון שהקונסטרוקטור הישן Viewer קיבל. העבר את הרישיון ל‑DoconutOptions, שמור על קבצי המלווה יחד כאשר משתמשים בגילוי אוטומטי, הפעל מחדש לאחר שינוי רישיון, ואמת את היכולות דרך IDoconutLicenseService.

אל תניח שהימצאות רישיון תוסף ישן מוכיחה זכאות לבנייה של תוסף נוכחי. בדוק את Viewer, Search, Annotation, Converter ו‑DICOM בנפרד עם artefacts של הגרסה המאושרת.

3. אתחול והזרקת תלות

במקודם, ה‑Viewer נבנה לכל בקשה והאפשרויות הועברו למידלוור:

csharp
// אינטגרציה קודמת — רק ניגוד; אל תקומפיל זאת נגד ה‑SDK הנוכחי.
var viewer = new Viewer(_cache, _accessor);
// …
appBranch.UseDoconut(new DoconutOptions { UnSafeMode = false, ShowDoconutInfo = false });

האינטגרציה הנוכחית רושמת את Doconut פעם אחת ומקבלת Viewer מהזרקת תלות:

csharp
builder.Services.AddDoconut(options =>
{
    options.UnsafeMode      = false;   // הערה: שינוי האיות: UnSafeMode → UnsafeMode
    options.ShowDoconutInfo = false;
    options.LicensePath     = "Doconut.Viewer.lic";
});
builder.Services.AddDistributedMemoryCache(); // מצב סשן צריך מטמון (MVC/Razor Pages כבר מוסיפים אחד)
builder.Services.AddSession();

app.UseSession();
app.UseDoconutResources();
app.UseDoconut();

Viewer הוא שירות זמני. מנהל סשן המסמך והמטמון שלו מחזיקים במצב המסמך ארוך החיים, ולא במופע המוזרק המסוים של Viewer.

שלוש דברים להעביר:

  • new Viewer(cache, accessor) הוסר. הזרק Doconut.Viewer לתוך הבקר שלך, או השתמש ב‑@inject Doconut.Viewer Viewer בתצוגת Razor.
  • UseDoconutResources() מחליף חיבור ידני של app.UseMiddleware<EmbeddedResourceMiddleware>(), וחייב לרוץ לפני סניף המסמך.
  • UnSafeMode → UnsafeMode. שינוי שם של תו אחד שהקומפיילר יזהה.

כאשר UnsafeMode הוא false, ה‑SDK מאמת את אסימון הסשן מול הבקשה המקורית, ולכן AddSession() / UseSession() חייבים עדיין להיות בצינור, UseSession() לפני הסניף.

שיטות שאינן קיימות יותר

לפניעכשיו
viewer.OpenDocument(path, config, options)await viewer.OpenDocumentAsync(path, config, options)
viewer.InitCache()הוסר — אין דבר לחמם ידנית; מחק את הקריאה וכל דגל "האם כבר אתחולתי?" סביבו
viewer.ExportToPng(sharedPath)ראה §7
viewer.ExportToCloud(cloudConfig)ראה §7
using var v = new Viewer(...); v.CloseDocument(t)viewer.CloseDocument(token) על המופע המוזרק

4. מידלוור וניתוב משאבים

UseDoconut() כעת אינו מקבל ארגומנטים. צורת הסניף של MapWhen עצמה אינה חייבת להשתנות — רק המידלוור בתוכו:

csharp
app.UseDoconutResources();   // לפני הסניף

app.MapWhen(
    ctx => ctx.Request.Path.Value?.EndsWith("DocImage.axd", StringComparison.OrdinalIgnoreCase) == true,
    branch => branch.UseDoconut());

בצינור הנוכחי:

  1. קרא UseSession() לפני Doconut כאשר אבטחת הסשן מופעלת;
  2. קרא UseDoconutResources() לפני UseDoconut();
  3. שמור על ResourcesPath, כתובות ה‑URL של המשאבים שנוצרו, וה‑client ResPath מיושרים;
  4. שמור על הסניף שאתה ממפה וה‑client BasePath מיושרים.

MiddlewarePath היא תצורה מאומתת; היא אינה יוצרת סניף של ASP.NET Core בעצמה.

5. Viewer construction and lifetime

הסר מטמונים שבבעלות היישום של עצמים מסוג Viewer. אין דבר שנשאר ב-Viewer שכדאי לשמור: הוא אינו נושא מצב מסמך, ומטמון הסשן מחזיק בכל מה שנשאר אחרי בקשה. הזרק אותו לנקודת קצה, דף Razor, בקר, או שירות יישום בעל תחום:

csharp
app.MapPost("/api/open", async (Viewer viewer) =>
{
    var token = await viewer.OpenDocumentAsync("wwwroot/files/Sample.pdf");
    return Results.Ok(new { token });
});

האסימון שהוחזר מזהה סשן מסמך בצד השרת. התייחס אליו כלאפיון נושא: אל תתעד אותו, אל תשמור אותו, ואל תכניס אותו לניתוחים.

6. Opening and closing documents

החלף את OpenDocument(...) הסינכרוני ב-OpenDocumentAsync(...):

csharp
// האינטגרציה הנוכחית: Viewer מגיע מ‑DI ופתיחת המסמך היא אסינכרונית.
var token = await viewer.OpenDocumentAsync(path, new PdfConfig { AllowSearch = true });

הגרסאות הנוכחיות מקבלות נתיב קובץ או זרם, תצורת פורמט אופציונלית, DocOptions אופציונלי, וטוקן ביטול. סגור את סשן השרת במפורש כאשר הדפדפן אינו זקוק לו יותר:

csharp
viewer.CloseDocument(token);

מחק כל קריאה ל-InitCache() ואת הדגל המגן עליו — אין צורך לחמם ידנית. אל תשתמש מחדש באסימון שנוצר על ידי הספרייה הקודמת לאחר המעבר: פתח כל מסמך מחדש דרך ה-API הנוכחי.

7. Web farm → distributed: the biggest change

UseDoconutWebFarm ו-WebFarmOptions אינם קיימים יותר. אם האפליקציה שלך קוראת להם, הקטע הזה הוא השדרוג שלך; אם לא, דלג ל‑§8.

לפני כן middleware אחד היה עושה את הכל: הוא שירת תמונות שהוכנו מראש מתיקייה משותפת, ובצע סקר בזמן שמערכת אחרת עדיין כתבה אותן.

csharp
// האינטגרציה הקודמת — קריאה אחת, תיאום מרומז דרך מערכת הקבצים.
appBranch.UseDoconutWebFarm(new WebFarmOptions
{
    Path                = Path.Combine(env.WebRootPath, "webfarm"),
    PageWaitTimeSeconds = 180,
    StartWaitFromPage   = 5,
});

המשימה אותה מחולקת כעת לשני חצאים ברורים. צד הכתיבה — המערכת שפותחת את המסמך מפרסמת את כל קבוצת הארטיפקטים (דפים, מידע על המסמך, אינדקס חיפוש, מטא‑דאטה) לשיתוף:

csharp
var result = await _publisher.PublishAsync(          // DistributedDocumentPublisher, מוזרק מ‑DI
    pathToFile,
    new FileShareConfig
    {
        Location              = CloudLocation.FileShare,
        RootPath              = @"\\fileserver\doconut",   // אותה תיקייה שאתה משתמש בה היום
        UsePerTokenSubfolders = true,
    },
    config,
    documentOptions,
    new DistributedDocumentPublishOptions
    {
        CleanUpStagingDirectory = true,
        FirstPagePriority       = true,
    });

return Content(result.Token);

צד הקריאה — כל מערכת משמשת מהשיתוף:

csharp
app.MapWhen(
    ctx => ctx.Request.Path.Value?.EndsWith("DocImage.axd", StringComparison.OrdinalIgnoreCase) == true,
    branch => branch.UseDoconutCloud<FileShareCloudHandler>(options =>
    {
        options.Location          = CloudLocation.FileShare;
        options.CloudUploadConfig = /* אותו FileShareConfig כמו למעלה */;
    }, "/"));
לפניעכשיו
WebFarmOptions.PathFileShareConfig.RootPath
PageWaitTimeSeconds / StartWaitFromPageהוסר — מוחלף ב-FirstPagePriority בצד הכתיבה ועוד FileShareConfig.ReadReadyPollMs בצד הקריאה
viewer.OpenDocument(...) ואז viewer.ExportToPng(share)קריאה אחת ל-PublishAsync(...)
DocOptions.IsWebfarm / WebfarmPathעדיין קיים, נכתב כ-IsWebFarm / WebFarmPath — אך אינו נדרש בנתיב הפרסום

הטופולוגיה שלך לא משתנה. הפנה את RootPath לאותו שיתוף UNC וכל מערכת ממשיכה לפעול כפי שהיא פועלת היום. מה שמשתנה הוא שהפרסום הוא פעולה שאתה קורא לה, במקום להיות תופעת לוואי של רינדור.

שני החצאים חייבים להסכים. אם RootPath או UsePerTokenSubfolders שונים בין המפרסם למטפל, המערכת השנייה מחזירה 404. בנה את התצורה בעזר אחד וקרא לה משני הצדדים.

PageWaitTimeSeconds = 180 משמעותו "חסימה עד שלוש דקות בתקווה שהדף יופיע". ההחלפה היא מפורשת: עם FirstPagePriority = true, דף 1 ניתן לשירות מיידית והדפים הבאים משיבים HTTP 202 Accepted עד שנכתבים. הצופה המשולב מנסה מחדש אוטומטית כאשר retryOn409 מוגדר. לקוח שלא מנסה מחדש יציג אריחים שבורים עבור דפים שעדיין מתרנדרים.

הסידור המלא, כולל פרסום ברקע וכרטיסי גישה, נמצא ב-פריסות מבוזרות.

8. ההמרה היא תוסף, וקטנה הרבה יותר

רשום את התוסף, ואז הזרק את המעטפת DocumentConverter:

csharp
builder.Services.AddDoconut(o => o.AddPlugin<ConverterPlugin>());
csharp
// אינטגרציה קודמת
var converter = viewer.Converter.GetConverter();
var config    = new WordConfigConverter { TargetFormat = WordConfigConverter.EnTargetFormat.PDF };
var result    = converter.Convert(stream, SourceFormatConverter.DOCX, config);

// אינטגרציה נוכחית
var result = await _converter.ConvertAsync(stream, ".docx", ConversionTarget.Pdf, null, ct);

מה שזה מחליף:

  • SourceFormatConverter — הוסר. העבר את סיומת הקובץ כמחרוזת, כולל הנקודה.
  • סוגי *ConfigConverter לכל משפחה (WordConfigConverter, ExcelConfigConverter, …), כל אחד עם enum מקונן של EnTargetFormat — הוסר. כעת יש enum אחד של ConversionTarget לכל משפחה.
  • viewer.Converter.GetConverter() — הוסר. הזרק Doconut.DocumentConverter.

ConvertAsync מחזיר זרם שניתן לחיפוש, ולכן return File(result, mime, name) עובד ישירות — העתקת הקוד הישנה של MemoryStream אינה נדרשת. בדוגמה המשולבת זה מחק מתג הרחבה של 68 מקרים ועשרה בקרים כמעט זהים.

ראה תוסף הממיר לקבלת המידע המלא.

9. ספקי ענן

UseDoconutCloud הפך לכללי. הספק הוא ארגומנט הסוג במקום ערך Location שמופעל בתוך ה‑middleware:

csharp
// אינטגרציה קודמת
appBranch.UseDoconutCloud(new CloudOptions { Location = CloudLocation.CDN, ... });

// אינטגרציה נוכחית
branch.UseDoconutCloud<CDNCloudHandler>(options =>
{
    options.Location          = CloudLocation.CDN;
    options.CloudUploadConfig = new CDNConfig { DoconutCdnUrl = "..." };
}, "/");

מחלקות התצורה אינן משתנות פרט למרחב השמות (Doconut.Configs.Cloud → Doconut.Clouds): AzureConfig, AmazonConfig, GoogleCloudConfig, DropBoxConfig, RedisConfig, CDNConfig, FTPConfig, בנוסף לFileShareConfig החדש. המפעילים נקראים <Provider>CloudHandler.

המפעיל של CDN הוא קריאה‑בלבד — הוא מגיש את מה שכבר נמצא ב‑CDN; הוא לא מעלה.

10. אובייקטי תצורה שהשתנו שם

לפניעכשיו
DoconutOptions.UnSafeModeUnsafeMode
DocOptions.IsWebfarmIsWebFarm
DocOptions.WebfarmPathWebFarmPath
DocOptions.ImageResolutionעדיין קיים אך מיושן — הגדר רזולוציה בתצורת הפורמט במקום זאת

DocOptions גם מקבל IsSecured.

ה‑API הנוכחי גם מפריד תחומי עניין בצורה קפדנית יותר מהקודם, ולכן יש לבדוק שכל הגדרה נמצאת באובייקט שכעת שולט בה:

תחוםסוג נוכחי
נתיבי Middleware, רישוי, רישום תוסףDoconutOptions
סיסמה, זמן קצוב, אבטחה, סימן מיםDocOptions
רינדור פורמט ו‑DPIPdfConfig, WordConfig, ExcelConfig, וסוגים אחרים של BaseConfig
ברירות מחדל של וידג'ט דפדפןViewerConfig או אפשרויות JavaScript המקבילות
CSS ו‑scripts שנוצרוCssConfig ו‑ScriptConfig
אחסון משותף וספקי ענןFileShareConfig והקונפיגורציות האחרות של Doconut.Clouds

אל תמשיך להשתמש בDocOptions.ImageResolution כבקר הרינדור. הוא מיושן; הגדר BaseConfig.ImageResolution בתצורת הפורמט הספציפית. בדוק את כל ברירות המחדל במקום להניח שתצורה קודמת מתנהגת באותו אופן.

11. הצופה בצד הלקוח — שני שינויי שגורמים לכשל בשקט

שניהם משאירים את השרת פועל בצורה מושלמת. המסמך שלך מוצג, העמוד נראה נכון, ואין שום דבר שמופיע בקונסול של הדפדפן. קרא סעיף זה גם אם הקוד ב‑C# שלך מתורגם בפעם הראשונה.

קריאות חזרה של הצופה הן אפשרויות כעת, ולא פונקציות גלובליות

הצופה הקודם קרא למטפלים שלך בשם, וגזר את שם הפונקציה הגלובלית ממזהה המכולה. הצהרת function ctlDoc_OnViewerReady() על דף עם <div id="div_ctlDoc"> הייתה מספיקה. הצופה הנוכחי מקבל קריאות חזרה מפורשות באובייקט האפשרויות ולא מחפש יותר את הגלובליים האלה:

javascript
objctlDoc = $("#div_ctlDoc").docViewer({
    // ... האפשרויות הקיימות שלך ...
    onViewerBusy:     ctlDoc_OnViewerBusy,      // נמצא לפי שם
    onViewerReady:    ctlDoc_OnViewerReady,     // נמצא לפי שם
    onCopy:           ctlDoc_Copy,              // היה ctlDoc_Copy(text)
    onAutoLoadStatus: ctlDoc_AutoLoadStatus     // היה ctlDoc_AutoLoadStatus(page)
});

למה זה בעייתי: הקריאה הישנה הייתה עטופה ב‑catch ריק, שספג את הכול. כעת הפונקציות שלך פשוט אף פעם לא רצות ושום דבר לא מדווח על שגיאה. התסמין הרגיל הוא סיבוב טעינה שלא מפסיק — מכיוון שהפונקציה שהסתירה אותו הייתה ctlDoc_OnViewerReady. המסמך שמאחוריו תקין.

רשימת האפשרויות המלאה היא onPageLoading, onPageLoaded, onThumbnailClicked, onPageClicked, onDoubleClick, onViewerBusy, onViewerReady, onViewerError, onCopy, onAnnSaved, onAnnSaveError, onAnnLoaded, onAnnClosed, onAutoLoadStatus, onThumbsShown, ו‑onError. אין קריאת חזרה על לחיצה על קישור: טיפול בקישורים מובנה, מונע על‑ידי showHyperlinks.

ResPath חייב להצביע על קידומת המשאב

javascript
ResPath: '',                      // לפני — המשאבים הגיעו משורש היישום
ResPath: 'doconut-res/images',    // עכשיו    — הקידומת UseDoconutResources() מפעילה

אם שינית את הקידומת דרך DoconutOptions.ResourcesPath, השתמש בערך הזה במקום זאת.

12. סרגל הכלים של הצופה, חיפוש והערות

אל תעביר את הסקריפטים הישנים אחד אחרי השני. היישומים הרפרנסיים הנוכחיים מרכיבים
חבילה של דף שלם:

  1. הפץ CSS של Viewer ו‑CSS של חיפוש/הערות ברישיון עם ReferenceCss;
  2. הצג את סרגל הכלים של Viewer שבבעלות היישום;
  3. הצג את searchBarMount, annBarMount, ואת הרכיב הנדרש של Viewer;
  4. הפץ סקריפטים של Viewer ומודולים ברישיון עם ReferenceScripts;
  5. טען את סקריפט העזר של סרגל הכלים של היישום עצמו;
  6. אתחל אחד objViewer;
  7. אתחל את רצועות החיפוש וההערות ברישיון;
  8. קרא לattach(objViewer) על כל רצועה;
  9. פתח את המסמך וקרא לobjViewer.View(token).

חיפוש והערות הם מודולים המחוברים לאותו Viewer, ולא סרגלי כלים עצמאיים.
סרגל הכלים הראשי שייך ליישום המארח; רצועות החיפוש וההערות מוטמעות, משאבים עם שערי יכולת.

הסר קבצים שהועתקו ידנית כגון documentLinks.js ו‑docViewer.UI.js רק לאחר
שהדף הנוכחי פועל עם משאבים שהופקו על ידי ReferenceCss ו‑ReferenceScripts.

13. רישום תוספים

שיטות רישיון תוסף סטטיות אינן רושמות תוספים נוכחיים. התקן ורשום כל
חבילה משוחררת במפורש:

csharp
builder.Services.AddDoconut(options =>
{
    options.AddPlugin<Doconut.Plugins.Converter.ConverterPlugin>();
    options.AddPlugin<Doconut.Plugins.Dicom.DicomPlugin>();
});

AddDoconut() מאמת את יכולות התוספים הרשומות בעת ההפעלה. Converter ו‑DICOM
הם התוספים של .NET Standard שהושחררו. חיפוש והערות רגילים הם
תכונות מובנות ברישיון, ולא חבילות AddPlugin<TPlugin>().

14. אבטחת סשן ומסמך

האינטגרציה הנוכחית קשורה מסמכים לאסימונים אטומים ולסשנים במטמון. עם
ברירת המחדל UnsafeMode = false, UseDoconut() מוסיף אבטחת גישה למסמך והמאחסן
חייב להגדיר סשן של ASP.NET:

csharp
builder.Services.AddDistributedMemoryCache(); // מצב סשן צריך מטמון (MVC/Razor Pages כבר מוסיפים אחד)
builder.Services.AddSession();
app.UseSession();

שמור את DocOptions.IsSecured = true אלא אם תכנון שבדק דורש אחרת. לעולם אל תשתמש
בUnsafeMode = true כקיצור דרך למיגרציה על צומת יחיד. בדוק בקשות ללא אסימון,
אסימון פגום, אסימון שפג תוקפו, ואסימון ממושב דפדפן שונה.

ב‑farm, בקשת הדף יכולה לנחות על צומת שמעולם לא ראה את בקשת הפתיחה, ולכן בדיקת הפר‑סשן תדחה אותה. זה המקרה היחיד שבו UnsafeMode = true הוא
נכון — והוא חייב להיות משוייך עם כרטיסי גישה חתומים דרך
AddDoconutDistributedDocumentSecurity, ולא נשלח לבד. ראה
פריסות מבוזרות.

הערת שם

בכל המסגרות המחלקה היא Viewer. אם אתה מוצא DocumentViewer בקטעי קוד ישנים
או במאמרים של צד שלישי, סוג זה מעולם לא היה קיים ב‑SDK.

15. סדר עבודה מומלץ

  1. אשר שהמסגרת המארחת יכולה לצרוך netstandard2.1. אם היא לא יכולה, עצור.
  2. העלה את הגרסה של החבילה ל‑26.8.0 ובנה. עבוד על שגיאות ההידור — רובן
    השורות using בסעיף §1.
  3. העבר את ההפעלה לAddDoconut() ואת קריאות ה‑middleware לסדר החדש שלהם (§3, §4).
  4. הזרק את Viewer במקום שבו בנית אותו, הפוך את OpenDocument לאסינכרוני, ומחק
    את InitCache() (§5, §6).
  5. אם אתה משתמש ב‑web farm, בצע §7 — החלק היחיד שהוא עיצוב מחדש ולא שינוי שם.
  6. אם אתה ממיר מסמכים, בצע §8.
  7. בצע §11 — השינויים בצד הלקוח. אלו הם השינויים שלא יכריזו על עצמם.
  8. פתח מסמך אמיתי בדפדפן, וצפה במסתובב העמוס. בנייה ירוקה אינה מוכיחה
    דבר כאן: רישוי, רישום תוספים, נתיב המשאב, וקולבקים של הצופה
    נכשלים רק בזמן ריצה. עבור farm, אמת שמסמך שפורסם על ידי צומת אחד
    מוגש על ידי צומת אחר.

בדיקת ההגירה

במינימום, יש לאמת:

  • הפעלת היישום עם רישיון הייצור וכל תוסף רשום;
  • CSS/סקריפטים של הצופה וכל בקשות תמונת‑דף בנתיבים שנבחרו;
  • פתיחת מסמך, ניווט, זום, תמונות ממוזערות, הדפסה וסגירה מפורשת;
  • חיפוש במסמך שמכיל טקסט והמצב הלא‑ניתן לחיפוש של קובץ שמורכב רק מתמונות;
  • טעינת, שמירת, יצוא והגבלת יכולות של הערות;
  • גילוי יעד הממיר, פלט, הורדה ומצב סימן המים;
  • דפי DICOM, פריימים והנפשה; מטא‑נתונים טכניים אינם זמינים בחבילה זו;
  • מסמכים מוגנים בסיסמה, גופנים מותאמים, טקסט לא‑לטיני וזמני קצוב שהוגדרו;
  • דחיית אסימון בין‑הפעלות והתנהגות של הפעלה שפג תוקפה;
  • עבור חווה: לפרסם על צומת אחד, לבקש דף מאוחר מצומת אחר, ולאשר שהצופה מנסה שוב תגובות 202 במקום להציג אריחים שבורים;
  • מובייל, מצב כהה, ונתיב ה‑reverse‑proxy של הייצור.

תוכנית חזרה לאחור

שמור את ארטיפקט הפריסה הקודם, החבילות המתאימות, קבצי הרישיון והמשאבים המועתקים של הדפדפן יחד. חזרה בטוחה מעבירה את כל הדור של היישום; היא אינה מערבבת שרת מדור קודם עם סקריפטים נוכחיים, או שרת נוכחי עם new Viewer(...) מקומות קריאה.

לפני המעבר, תעד:

  • משבצת הפריסה או הארטיפקט שבו השתמשו לחזרה לאחור;
  • השפעת האחסון המשותף, אם קיימת — ארטיפקטים שפורסמו ב‑26.8.0 אינם נצרכים על‑ידי תשתית ה‑web‑farm הקודמת;
  • כיצד הפעלות המסמך הפעילות יבוטלו;
  • בדיקת הבריאות והמסמך המהיר המשמשים להחלטת חזרה לאחור;
  • מי יכול לשחזר את קבוצת החבילות והקונפיגורציה הקודמות.

תיעוד מורשת

המדריך הקודם המתורגם עדיין זמין ב‑ הגדרת Legacy .NET Standard. ה‑ שער אינטגרציה קודמת מסביר את אותות הזיהוי זהים וקושר חזרה למדריך ההגירה הזה.

שמור את כתובת ה‑URL ההיסטורית במועדפים ובכרטיסי התמיכה כל עוד התקנות netstandard2.0 קיימות. היא מתעדת דור שונה ואינה מופנית ל‑API הנוכחי.

האם דף זה היה מועיל?