תחומים - פורום חרדי מקצועי

@mekev לא ברור מהו סוג המידע שהטבלה מייצגת.

אם הטבלה מייצגת משלוחים (כל רקורד מייצג משלוח בודד) סביר להניח שכמות שסופקה מייצג נתון שקשור באופן אינטרגרלי למשלוח.

ספקים - טבלה נפרדת.
מוצרים - טבלה נפרדת.

אם הטבלה מייצגת משלוח של סוג מוצר מסויים (משלוח מכיל מספר מרובה של סוגי מוצרים) סביר למקם את כמות שסופקה באותה טבלה.

משלוחים - טבלה נפרדת.

יש את Zmanim Project שנכתב במקור בשפת JAVA ע"י יהודי מלייקוד בשם אליהו הירשפלד, בשל הצלחתו הגדולה, הפרויקט הועתק לשפות רבות נוספות ביניהם PhpZmanim עבור PHP (הספרייה זמינה בנוסף עבור Net. ,Objective C, Ruby וPython) .

בנוסף יש את הספריה Zman (קישור לתיעוד) החושפת מחלקה בשם Zman היורשת מהמחלקה הפופולרית Carbon שיורשת בתורה מDateTime.
 
 

הספריה Zman חושפת מתודות כגון:
 

• האם התאריך הוא יום טוב:

Zman::now()->isYuntif();   

• האם התאריך הוא צום:

Zman::now()->isFastDay();  

• האם התאריך הוא חול המועד:

Zman::now()->isCholHamoed();  

שים לב שהMSBuild item המכונה Folder הוא משתנה שרירותי המייצג קבצים (באותה מידה יכולת להשתמש עם תג בשם NiceFolder) כל עוד לא הItem אינו מועבר כפרמטר לTask כלשהוא, לא יתרחש עם הקבצים שהוא מייצג דבר.

בניגוד ל:

• Compile
• Content (האפשרות הרצויה במקרה שלך)
• None
• EmbeddedResource ועוד.
  המייצגים Build Actions בMSBuild
   
   
  לכל Framework בNet. יש Target המייצג את פעולת הBuild (הTarget הנ"ל אינו מופיע בקובץ הפרויקט אולם ניתן להתייחס אליו בתזמון Targets נוספים, למשל לMSBuild item בשם Page יש משמעות מיוחדת רק בBuild של WPF), לMSBuild item בשם Folder אין כל משמעות בBuild של Asp.
   
  לשם ההדגמה, להלן Target המכיל שלושה Tasks (המשימה: ביצוע Build של פרויקט כלשהוא והעתקת התוצאה לנתיב שרירותי כלשהוא במערכת הקבצים)

1. MSBuild מייצג Build של קובץ MSBuild אחר (במקרה זה אנחנו מבצעים Build לפרויקט X)
2. MakeDir מייצג Task היוצר תיקייה (אנחנו משתמשים בPropertyGroup בשם Destination כדי לקבוע את היעד)
3. Copy מייצג Task המעתיק קבצים (אנחנו משתמשים בItemGroup השרירותי MySourceFiles על מנת לקבוע את הקבצים שיועתקו (במקרה זה התוצאה של משימה 1) ובPropertyGroup בשם Destination על מנת לקבוע את היעד)

<Target Name="BuildProjectAndCopyFiles" AfterTargets="BeforeBuild">
	<PropertyGroup>
		<MyDestination>\SomePath</MyDestination>
	</PropertyGroup>

	<ItemGroup>
		<MySourceFiles Include="ProjectName\bin\$(Platform)\$(Configuration)\$(TargetFramework)\$(RuntimeIdentifier)\**\*.*" />
	</ItemGroup>

	<MSBuild Projects="ProjectName\ProjectName.csproj" Targets="Build" Properties="Configuration=$(Configuration);Platform=$(Platform)"/>
	<MakeDir Directories="$(MyDestination)" />
	<Copy SourceFiles="@(MySourceFiles)" DestinationFolder="$(MyDestination)\%(RecursiveDir)" SkipUnchangedFiles="true" />
</Target>

כאן ניתן למצוא את הרשימה המלאה של הTasks המובנים בMSbuild
 
 

לסיכום:

הBuild Action הרצוי עבור קבצים סטטים הוא Content, הקבצים יועתקו לשורש תיקיית היעד תוך שמירה על ההיררכיה המקורית:

<ItemGroup>
   <Content Include="files\**" />
</ItemGroup>

הקבצים בתיקיית files יהיו זמינים בנתיב הבא:

new Uri("files/somefile.xyz")

** שים לב שהתהליך הנ"ל מתבצע בASP אוטומטית עבור התיקייה wwwroot.

** כאן ניתן הסבר בהרחבה כיצד לחשוף קבצים סטטים מחוץ לתיקיית wwwroot לבקשות HTTP באמצעות ASP.

@אבי_770 איפה ראית ש @dovid הוא הכתובת לעניין?

Swagger זה מימוש של התקן המתקרא OpenAPI (גירסה מס' 3), התקן מיועד עבור תיעוד REST APIs.
Swagger גם מספקת כלים אוטומטיים ליצור את התיעוד וכלים חזותיים (Middlewares) לצפות בתיעוד (התקן כולל קובץ JSON\YAML בלבד) בנוסף לאפשרות לבצע קריאה לכל אחד מהEndpoint החשופים בתיעוד, עם הפרמטרים וההדרים הדרושים.

@שמחה-זו-הסיסמא לדעתי הצנועה ישנה קורולציה ברורה בין כל מילה\חוק באנגלית שתלמד לבין ההתפתחות העתידית שלך בתכנות (כן, גם שמות של פירות וירקות באנגלית), כך שאם יש לך את הבחירה בין התקדמות באנגלית או שבירת השיניים בהבנת Framework חדש התשובה ברורה לדעתי.

@משתמש-מקצוען ניתן לעשות שימוש במחלקה ManagementEventWatcher על מנת להירשם לאירועים במערכת המתאימים לשאילתות מותאמות אישית.

להלן מחלקה היפותטית לחלוטין אשר דוגמת את InstanceCreationEvent מדי 2 שניות על מנת לגלות ערכים חדשים מסוג Win32_DiskDrive (השימוש בWin32_DeviceChangeEvent אינו יתכן במקרה זה, משום שאינו מכיל כל מידע על המכשיר) במידה וערך חדש מסוג Win32_DiskDrive אכן נוצר, המתודה DeviceInsertedEvent שרשמנו כEvent handler תרוץ, במידה והמכשיר המסויים כבר התחבר בעבר, אנו נדפיס את הSerial Number לקונסול, במידה ולא, אנו נכניס אותו לרשימה של המכשירים המוכרים (familiarSerialNumbers), כך שהSerial Number יודפס בפעם הבאה שהמכשיר יחובר.

class FamiliarDeviceDetection
{
    private readonly string _query = "SELECT * FROM __InstanceCreationEvent WITHIN 2 WHERE TargetInstance ISA 'Win32_DiskDrive'";
    private readonly List<string> _familiarSerialNumbers = new();

    public FamiliarDeviceDetection()
    {
        var watcher = new ManagementEventWatcher();
        watcher.Query = new WqlEventQuery(_query);
        watcher.EventArrived += DeviceInsertedEvent;
        watcher.Start();
    }

    private void DeviceInsertedEvent(object sender, EventArrivedEventArgs e)
    {
        var device = (ManagementBaseObject)e.NewEvent["TargetInstance"];

        if (device["SerialNumber"].ToString() is var serialNumber && _familiarSerialNumbers.Contains(serialNumber))
        {
            Console.WriteLine(serialNumber);
        }
        else _familiarSerialNumbers.Add(serialNumber);
    }
}

 
דוגמא לשימוש במחלקה הנ"ל באפליקציית Console:

public void Main()
{
    new FamiliarDeviceDetection();
    Console.ReadLine();  // comment out unless in console application  
}

על מנת להשתמש בManagementEventWatcher יש להוסיף לפרויקט את הספרייה System.Management אשר הייתה בעבר חלק מהFramework, אולם הושמטה במעבר לCore עקב היותה מותאמת לסביבת ווינדוס בלבד (במטרה לטהר את הפלטפורמה ממחלקות אשר אינן מותאמות לריצה על לינוקס ו-MacOS) WMI עושה שימוש בDCOM (טכנולוגיה השייכת ופועלת ע"ג ווינדוס בלבד).

ניתן להוסיף את הספרייה באמצעות הפקודה:

dotnet add package System.Management

לחלופין ע"י הוספת השורה הבאה לקובץ הפרויקט (csproj):

<ItemGroup>
    <PackageReference Include="System.Management" Version="6.0.0" />
</ItemGroup>

ניתן להרחיב על WMI עוד רבות, מעט התעצלתי, אולם אשמח לענות על שאלות ספציפיות.

המעבר מדפוס סלאוויטה (12 דפים) לדפוס וילנא (21) התבצע החל מהסבב השמיני (בהתאם להכרעתו של מרן הגאון רבי משה פיינשטיין זצוק"ל שאין במיעוט הלימוד חשש של הפרת נדר)
הפרש הדפים הוא 9 כפול 7 מחזורים (9 * 7 = 63)
כפי שניתן לראות הספרייה הספרייה המדוברת מאת @צדיק-תמים לקחה את הדבר בחשבון.

dapim_in_current_cycle = days_since % total_dapim + 63

@הפצת-אנקי ע"ע הדף היומי

@משתמש-מקצוען לא ציינת את הסביבה שבה תרוץ התוכנה (Windows/Linux)

@yossiz אמר בעזרה | תיקון קוד של kotlin:

isEmpty הוא inline

אכן, זה עוד סיבה לטובת המתודות בkotlin.text, הנהנות מיתרון מזערי במהירות, משום שהקוד בתוך המתודות יוטמע במקום הקריאה (מה שחוסך את הOverhead של קריאה למתודה).

@mmmm אמר בעזרה | תיקון קוד של kotlin:

זה גם באנדרואיד (לא מדויק...), מה צריך לייבא (import) בשביל זה?

הנתיב המלא של המחלקה : android.text.TextUtils

Java

המתודה isNullOrEmpty איננה קיימת בJava והשימוש בstring.isEmpty עם Null יניב את השגיאה NullPointerException, אי לכך הוסיפו אנשי Android לTextUtils את המתודות הבאות:

• isBlank
• isEmpty
• isNotBlank
• isNotEmpty
   

Kotlin

כל המתודות הנ"ל בנוסף לשני המתודות הבאות [המיועדות עבור String?) Nullable Receiver)]:

• isNullOrEmpty
• isNullOrBlank

מומשו בחבילה kotlin.text המהווה חלק מהStandard Library של Kotlin **, כך שאין סיבה להשתמש במחלקה TextUtils השייכת לAndroid SDK.
 

@yossiz אמר בעזרה | תיקון קוד של kotlin:

אבל עדיין צריך לי עיון במקרה של interop עם Java

המתודה isEmpty מסומנת עם @InlineOnly מה שהופך אותה ללא זמינה עבור Java (המתודה מתורגמת לPrivate) אולם במקרים רבים אחרים הדבר אכן מהווה בעיה חמורה (בניגוד לKotlin, אף אחד לא מונע ממפתח בJava להעביר Null למתודות בKotlin המצפות לNon-Nulls), כדי למזער את נזקי את הבעיה, המהדר של Kotlin עבור JVM יוסיף בדיקה עבור Null לכל המתודות הציבוריות המצפות לNon-Nulls.

** אין צורך ליבא את החבילה kotlin.text על מנת לעשות שימוש במתודות הנ"ל, הדבר מתבצע באופן מרומז עבור כל החבילות המרכיבות את הStandard Library, בדומה לשפות רבות אחרות.

@avramk אמר

אבל לאחמכ חשבתי שזה לא הגיוני כי אין למחשב כתובת כשהוא מכובה. אני משתמש בנתב שלבזק. מה האפשרויות שלי ?

נסה שוב להבין את כוונת @upsilon01

הפנית פורטים לברודקאסט

אם המשפט הנ"ל אינו אומר לך דבר, למד על Broadcasting ועל MagicPacket ואז נסה להבין את המשפט דלהלן (מתוך Does Wake-on-LAN via WAN need port forwarding?)

The packets are sent to the special broadcast address of the LAN, so it will be received by all network-attached hosts, rather than by a specific host, The MAC address is used to identify the particular host that should "Wake Up"

@ארכיטקט ממש לא, גם לא Thread בפני עצמו.
HostedService זה Service מסוג סינגלטון רגיל אך בעל Lifetime משלו (נוצר בתחילת הריצה של האפליקציה [בניגוד לServices רגילים הנוצרים לפי הצורך], ומושמד בסיום הריצה), אין בו שום קסם אולם הוא מהווה פלטפורמה נחוצה להרצת משימות ארוכות או מתוזמנות.

@ארכיטקט אמר בהפעלת פונקציה אסינכרונית ללא await:

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

פספסתי. אני חושד שיש לנו חוסר הבנה.

אופן הוספת המשימות לתור זהה ואינו תלוי כלל בטיב המשימה:

[HttpPost]
public Guid Post(Model model)
{
   return _queue.Enqueue((ct, sp) => sp.GetService<ISomeService>().DoAsync(model, ct));
}

@ארכיטקט לא ברור לי מה מכונה אצלך "התרחיש".
השימוש בHosted Service הוא הפתרון המומלץ והיחיד שקיים היום עבור פעולות אסינכרוניות קצרות וארוכות כאחד.

@dovid אמר בהפעלת פונקציה אסינכרונית ללא await:

רק תרשה לי לשחרר את הבקשה

שחרור הבקשה מתבצע (בלי לקחת בחשבון Filters וMiddlewares) בעת הרצת הreturn (גם בעת כתיבה ישירה לBody) לאחר מכן הController ושאר הServices שרשומים כScope יושמדו (תיאורטית ניתן להזריק את IServiceScopeFactory (שהוא Singleton) ולבקש את הServices הדרושים גם אחרי שהבקשה הושלמה, אם כי הבעיה הגדולה של טיפול בשגיאות עדיין קיימת)

@dovid בהחלט, אתה חייב להמתין עבור פעולה אסינכרונית על מנת לתפוס את השגיאות שלה.

@ארכיטקט מדובר בנושא שיש הרבה מקום להרחיב בו, בל"נ אנסה לקצר, אם יש לך השגות או שאלות אשמח להרחיב.
הדרך המומלצת להריץ משימות רקע בASP.NET בפרט ובNET. בכלל, היא שימוש בHosted Service מדובר בService הרשום כSingleton החי בפני עצמו תחת אותו Host המריץ את האפליקציה.

Host
התהליך המארח - מופקד על ההרצה וניהול חיי האפליקציות המתארחות, בנוסף תפקידו לטפל בכל הפרוצדורות הגנריות כדוגמת Logging וDI (מה שמאפשר שיתוף Services בין האפליקציות המתארחות עקב יצירתו של Root ServiceProvider בודד), והוא מוגדר ברובו באופן זהה ללא קשר לסוג האפליקציה המתארחת.

צורת המימוש - Producer–Consumer:
האפליקציה והHosted Service יחלקו (באמצעות Serivce משותף) תור של משימות המחזירות Task\ValueTask (לדוגמה <<Channel<Func<CancellationToken, ValueTask) לחלופין ניתן ליצור מחלקה ייחודית אשר תייצג משימת-רקע בודדת, המחלקה תכיל את המשימה עצמה כשדה, ובנוסף תכיל גם GUID כך שיהיה ניתן להחזירו ללקוח להמשך מעקב ולצורך מתן אפשרות לביטול (באמצעות CancellationToken ייחודי שיהווה שדה נוסף במחלקה ההיפותטית הנ"ל)

לסיכום:

• האפליקציה תשחק את תפקיד הProducer - תפקידה יהיה להוסיף את המשימות לתור באופן סינכרוני לחלוטין
• הHosted Service את תפקיד הConsumer - תפקידו יהיה להריץ את המשימות הנכנסות לתור (אחת אחרי השניה במקרה של Channel או במקביל עם שימוש בActionBlock) וטיפול בשגיאות

דוגמא למימוש מתוך התיעוד הרשמי

הדרך הרשמית לבצע זאת בEntity Framework Core היא שימוש בפקודה dotnet ef dbcontext scaffold, אשר תיצור את הDbContext ואת הEntities בצורה אוטומטית, אחת מהמעלות הבולטות של השימוש בפקודה היא השינוי של שמות המחלקות והProperties כך שיתאימו למוסכמות של C# (ניתן לבטל את הפיצר באמצעות הפרמטר use-database-names--) כמו כן באמצעות הכלי ניתן להגדיר דברים רבים נוספים הקשורים ליצירה של המחלקות.

דוגמא בסיסית (שימוש בlocaldb):

dotnet ef dbcontext scaffold "Data Source=(localdb)\MSSQLLocalDB;Initial Catalog=DatabaseName" Microsoft.EntityFrameworkCore.SqlServer

דוגמא נרחבת:

dotnet ef dbcontext scaffold "Server=ServerName; Database=DatabaseName; User Id=UserId; Password=Password" Microsoft.EntityFrameworkCore.SqlServer   --context=DbContext --context-dir  DbDir --data-annotations --output-dir DbDir/Entities

לשימוש בכלי מומלץ להתקינו גלובלית:

dotnet tool install --global dotnet-ef

דוגמא פשוטה של שימוש בSemaphoreSlim

var ss = new SemaphoreSlim(1, 1);

await ss.WaitAsync();
try
{
	await DoSomeThingAsync();
}
finally
{
	ss.Release();
}

הסבר בקצרה:

• הבנאי מקבל שני פרמטרים:
  1. המספר ההתחלתי של בקשות לסמפור שיאושרו במקביל
  2. המספר המקסימלי של בקשות שיאושרו במקביל
     בדוגמא למעלה מכיוון שהמספר מוגדר לאחד - רק בקשה אחת תאושר בכל פעם.
• המתודה WaitAsync ממתינה בצורה אסינכרונית עד אשר הCounter הפנימי של SemaphoreSlim יירד למספר נמוך יותר מהמספר המקסימלי שהוגדר, בסיום ההמתנה הCoutner הפנימי יעלה באחד ושורות הקוד הבאות יתבצעו.
• המתודה Release מפחיתה את הCounter באחד, מה שמפנה מקום לבקשות הממתינות (חשוב לקרוא לRelease בתוך הFinally כך שהשחרור יתבצע גם במקרה של כשלון הקוד המופיע בTry).

מספר הערות:

• חשוב שהאוביקט SemaphoreSlim יהיה משותף כך שלא יווצר מופע חדש בכל קריאה למתודה או יצירת מופע שמכיל אותו כשדה (כדאי לחשוב בכיוון שלSingleton או שדה סטטי).
• עבור EntityFramework השימוש בSemaphoreSlim אינו דרוש תודות לConcurrency Tokens/Timestamp שנוצרו על מנת לטפל בבעיה זו, להלן מדריך לOptimistic Concurrency.