הוזכרו כאן Frameworks רבים אולם מקומו של ASP.NET נפקד, לכן לקחתי על עצמי בדחילו ורחימו את המשימה החשובה ( אני חייב לציין שזו דעתי האישית בלבד, ואני אשמח לשמוע את חוות דעתם של המומחים ממני כאן)

ASP.NET מהירה בהרבה מNodeJs, ולמעשה היא נחשבת אחת מהWeb servers המהירים והיעילים ביותר כיום (משאירה הרחק מאחור את Java, Go, NodeJs).

בניגוד לפיתוח בסביבת NodeJs בה אתה נתון לחסדיהם של ספריות שנכתבו ע"י חברות ואנשים שונים בתקווה שהכל יתחבר איך שהוא לאפליקציה אחת, בASP.NET הפיצרים החשובים והשימושים ביותר מובנים בFramework לדוגמא:

• Dependency Injection
• Logger
• Localization
• Template engine
• WebSocket
• ORM
• Authentication/Authorization

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

כחלק מהגדרות הBuild ניתן לבחור במצב Self-hosted, מה שאומר שבסיום התהליך, נקבל קובץ הרצה ללא תלויות (ניתן להרצה כיישום Portable על כל מחשב), לחלופין ניתן לפרוס את האפליקציה באמצעות תמונת Docker רשמית של Microsoft.

מספר בקשות לשניה:

לסיכום
NodeJs איננה מציעה יתרונות כלשהם על פני ASP.NET ,למעשה אני סבור שהיא מציעה רק חסרונות שהמשמעותי שביניהם הוא היותה Single-Threaded, הטיב להגדיר זאת @dovid בשימוש באנלוגיה של טרקטור צעצוע שעבר הסבה לשימוש באתרי בנייה.
ASP.NET לעומת זאת היא סביבה יציבה מאוד, בה יש דרך מוגדרת לבצע משימות, בה כולם מדברים באותה שפה ושבה אתה מקבל יכולות אדירות בתמורה למעט מאוד שורות קוד.

אגב שווה להכיר את התחביר המינימלי החדש של ASP.NET שדומה באופן חשוד לExpress:

var app = WebApplication.CreateBuilder(args).Build();

app.MapGet("/", () => "Hello World!");

app.Run();

שרת HTTP בשלושה שורות בלבד.

הקוד הנ"ל מתאפשר עקב שיפורים (חלקם בתחביר של השפה) שהתבצעו בשנים האחרונות:

1. Implicit using directives: חסל סדר הרשימה הארוכה של Using בראש כל קובץ.
2. Top level statements: ניתן לכתוב קוד בקובץ הראשי מחוץ למחלקה או למתודה,
3. אין יותר צורך במחלקת Startup.

@davidnead זה בדיוק מה שניסיתי להסביר, מנסיוני הצנוע הפיתוח בASP מהיר יותר מNode.
הקמת אפליקציה הכוללת מסד נתונים, אימות, וHttp API היא משימה שמסתכמת בדקות ספורות עבור מפתחים בASP.
ובכלל הפיתוח בASP, מלא אוטומציות, לדוגמה המחלקות שאתה בונה מתורגמות לטבלאות במסד הנתונים, אחרי שיש לך Entity שמייצגת טבלה, באפשרותך ליצור Controller שמכיל נקודות קצה עבור כל הפעולות הבנאליות (CRUD) עבור אותו Entity בלחיצת כפתור.

@צדיק-תמים

כלומר להעביר אליו את הריפו שלי?

מעולם לא רמזתי דבר כזה, הציטוט מהתיעוד הוא לגבי המדיניות של Github והוא נכון ללא קשר לכלי DevOps כזה או אחר.

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

Caddy נחשב איטי בצורה משמעותית מNginx.

ואם בReverse proxy servers עסקינן, לאחרונה התוודעתי דרך הבלוג של מיקרוסופט לפרויקט חדש של מיקרוסופט בשם Yarp, (ר"ת של Yet Another Reverse Proxy) למרות השם המטעה מדובר בספרייה שמספקת כלים לבניית שרתי פרוקסי מהירים עבור ישומים של Net., היא מבוססת על העקרונות של ASP.NET ומותאמת לpipeline של ASP.NET, מה שמבדיל אותה משרתי פרוקסי אחרים, זה הצורה בו היא משתלבת בסביבה של ASP.NET מה שמאפשר יכולות שלא היו קיימות עד עתה עבור מפתחי Asp.

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

למעוניינים להלן הGet started שלהם.

הגירסה החדשה של NET. תוכרז במהלך החודש הבא באירוע NET Conf 2021 היוקרתי של מיקרוסופט, היא תכלול שיפורים רבים במגוון מחלקות, אחת מהיותר מעניינות שבינהן היא Enumerable, מספר מתודות Linq חדשות התווספו למחלקה, לצד הוספת Overloads חדשים עבור מתודות קיימות.

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

1. Chunking
   אם יצא לכם לעבוד עם מבני נתונים גדולים, ודאי נתקלתם בצורך לחלק אוסף גדול למספר אוספים קטנים, בדיוק בשביל זה נולדה המתודה Chunk, המתודה מקבלת כפרמטר את הגודל הרצוי ומחזירה IEnumrable של תתי מערכים:

public static IEnumerable<TSource[]> Chunk<TSource>(this IEnumerable<TSource> source, int size);

private record Person(int Age) 

int chunkSize = 10; 

IEnumerable<Person> largeCollecton = Enumerable.Range(0, 1_000).Select(age => new Person(age));

IEnumerable<Person[]> chunks = largeCollecton.Chunk(chunkSize);

foreach (var chunk in chunks) 
{
    foreach (var person in chunk)
    {
        Console.WriteLine(person);
    }
}

2. MaxBy\MinBy
   המתודה מאפשרת לקבוע את האובייקט הגדול\הקטן באוסף ע"פ המאפיינים של האוביקטים, בשונה מMax\Min הוותיקים שמבצעים את ההשוואה מול האוביקטים עצמם.
   לדוגמא: אם נרצה לקבוע מיהו האדם המבוגר באוסף של מופעים מסוג Person, נבצע את המשימה כך: people.MaxBy(x => x.Age) , עד כמה שהדבר מוזר, האפשרות טרם הייתה קיימת עד כה, הדרך המקובלת הייתה השילוב הלא חביב דלהלן:
   ()people.OrderByDescending(x => x.Age).First.
   כמו כן נוספו: DistinctBy ,ExceptBy ,IntersectBy וUnionBy בעלי עיקרון דומה.

3. תמיכה בRange
   מכירים את Range מC# 8? עד היום התמיכה הייתה בלעדית למערכים, מעתה התמיכה מתרחבת לLinq, לדוגמא: people.Take(6..10) יחזיר ארבעה אובייקטים, מהאובייקט במיקום השישי עד האובייקט במיקום העשירי (מקביל לpeople.Skip(6).Take(4)).

4. ערך דיפולטיבי עבור SingleOrDefault ,LastOrDefault ,FirstOrDefault
   המתודות הנ"ל יקבלו Overload חדש התומך בערך ברירת מחדל.
   בדוגמא דלהלן אנו ננסה למצוא באוסף מסוג Person, אדם שגילו הוא חמישים, ונחזיר מופע חדש (המצייג אדם שגילו הוא 50) במידה וניכשל:

people.FirstOrDefault(m => m.Age == 50, new(){ Age = 50 })

4. Zip עבור שלושה Enumrables
   כיום התמיכה מוגבלת עבור שניים בלבד.

5. TryGetNonEnumeratedCount
   המתודה תנסה לקבוע את מספר האוביקטים בEnumrable מבלי לבצע איטרציה (פעולה העשויה להיות יקרה), כחלק מהתהליך המתודה תבדוק האם הEnumerable מממש את ICollection (המכיל מאפיין בשם Count), או לחילופין האם הוא מערך (המכיל מאפיין בשם Length).

מקווה שנהנתם מהפוסט ושמצאתם אותו כשימושי, בהצלחה.

@yyy כדאי להימנע מיצירת מופעים עבור מחלקות בצורה ליטרלית משום שהPrototype שלהם יהיה זהה לזה של Object.

ההשלכות המצערות:

• האובייקט לא יכיל את המתודות והProperties של המחלקה.
• ההצבות (בתוך הבנאי ומחוצה לו) לא יתבצעו (התגלית שהערך של השדה Y במופע שיצרת יהיה זהה לundefined לא אמורה להיות מפתיעה במיוחד כעת).
• השימוש בisPrototypeOf ו instanceof לא יניב את התוצאה הרצויה (וכן כל המתודות שבPrototype).

מסקנה:

• היכן שהשימוש בObject literal נחוץ (ומתאפשר) השתמש בInterface לציון הType (עקב הצורך בערך דיפולטיבי עבור Y האפשרות לא רלוונטית עבורך)
• צור מופעים עבור מחלקות באמצעות הבנאי:

class ZeroYCoordinate {
  public readonly y: number = 0;
  constructor(public x: number) { }
}

const points = [new ZeroYCoordinate(4)]

** שינוי Prototype אפשרי באמצעות השימוש בsetPrototypeOf, אם כי הדבר אינו מהווה פתרון מקיף לכל הבעיות שציינתי.

@אבי-203
אני חושב שהקוד תקין.

class LayoutConvertor {
  static convert(str) {
    return str.replace(/./g, x => this.#lookup.get(x.toLowerCase()) ?? x)
  }

  static #lookup = new Map([
    ["q", "/"],
    ["w", "'"],
    ["e", "ק"],
    ["r", "ר"],
    ["t", "א"],
    ["y", "ט"],
    ["u", "ו"],
    ["i", "ן"],
    ["o", "ם"],
    ["p", "פ"],
    ["[", "]"],
    ["{", "}"],
    ["]", "["],
    ["}", "{"],
    ["\\", "\\"],
    ["|", "|"],
    ["a", "ש"],
    ["s", "ד"],
    ["d", "ג"],
    ["f", "כ"],
    ["g", "ע"],
    ["h", "י"],
    ["j", "ח"],
    ["k", "ל"],
    ["l", "ך"],
    [";", "ף"],
    [":", ":"],
    ["'", ","],
    ["\"", "\""],
    ["z", "ז"],
    ["x", "ס"],
    ["c", "ב"],
    ["v", "ה"],
    ["b", "נ"],
    ["n", "מ"],
    ["m", "צ"],
    [",", "ת"],
    ["<", ">"],
    [".", "ץ"],
    [">", "<"],
    ["/", "."],
    ["?", "?"]
  ]);
}

העובדה שיש לך אפליקציה נוספת שמשתמשת בNetwork של הHost הינה חסרת חשיבות, השאלה שלך היא כיצד ניתן לגשת לקונטיינר (bridge network mode) מבחוץ (הHost המארח).

המשמעות של Expose היא תיעודית בלבד, בשביל לאפשר גישה לקונטיינר מבחוץ אתה צריך לבקש זאת באופן מפורש (Publish), מעבר לעובדה שאתה לא רוצה שזה יתבצע כברירת מחדל (בשל שיקולי אבטחה), אתה גם מעוניין לקבוע באיזה פורט התהליך (שמאזין בקונטיינר) יהיה זמין בHost.

התהליך מתבצע באמצעות מיפוי פורט X בקונטיינר לפורט Y בHost.

להלן מספר דוגמאות מתוך הדוקומנטציה:

אם המיפוי של המסד נתונים יתבצע באופן דלהלן "3306:3306", המסד יהיה זמין בפורט 3306 של הlocalhost.

services:
  db:
    image: mariadb:10.5
    environment:
      MYSQL_ROOT_PASSWORD: 54fghjghjk44RkjJHkhgv3798
    ports:
      - "3306:3306"

@צדיק-תמים אמר במגבלות מאגר ב-github - גודל מאגר מירבי, וגודל מירבי לכל קובץ בודד במאגר:

וגם פוש לפי מה שהבנתי
מוגבל ל50/100 מגה

מדוייק

GitHub blocks pushes that exceed 100 MB.

הפתרון הוא שימוש ב Git Large File Storage (או בקיצור Git LFS)

Git LFS מיועד עבור קבצים מעל 100MB, הקבצים אינם מאוחסנים בRepository, במקום זאת Git LFS יוצר Pointer file שמשמש כReference עבור אותם קבצים.
בחשבון החינמי של Github\Gitlab אתה מוגבל עד 2GB לקובץ.

תיישם את זה כך:

<input  type="date" [ngModel]="CLS.BirthDate | date:'yyyy-MM-dd'" (ngModelChange)="CLS.BirthDate = $event"/>

הפתרון הוא לחלק את הTwo-ways binding לשניים: One-way binding ו Event Binding.
למעשה [(ngModel)] כולל את שניהם, [ ] מייצג One-way binding, ו ( ) מייצג Event binding.
הסיבה שאינך יכול להשתמש עם התחביר המשולב [( )] היא השימוש בDatePipe (אנגולר לא מאפשרת שימוש בPipes בשילוב עם Two-ways binding)

ועוד Convention קטן שלא הרבה יודעים:
כל Output בעל שם דומה ל Input קיים, בתוספת המילה Change יכול לשמש עבור Two-ways binding ללא כל הגדרה נוספת.

@yossiz אני רואה שאכן הנפח הכולל מוגבל ל1GB בחשבון החינמי, הדבר עומד בסתירה לנפח שצויין בתיעוד (עבור קובץ בודד).
ניתן ליישב את העניין שגם אם נרכוש נפח נוסף, ההגבלה של 2GB עבור קובץ בודד תעמוד בעיניה.

לחברה מוכרת דרושים מפתחים בעלי ידע בטכנולוגיות הבאות:

• Angular
  1. Typescript - שליטה מלאה
  2. RxJs - שליטה מלאה
  3. NGRX - יתרון לבעלי ידע
• ASP.NET CORE
  1. #C - שליטה מלאה
  2. Entity Framework - ידע בסיסי
     .

משרה מאתגרת עם שכר הוגן.
לפרטים נא לפנות ל @clickone.

@yyy הevent$ מייצג את הערך שנשלח ע"י הOutput של הComponent\Directive הפנימי.

תיישם את זה כך:

<input  type="date" [ngModel]="CLS.BirthDate | date:'yyyy-MM-dd'" (ngModelChange)="CLS.BirthDate = $event"/>

הפתרון הוא לחלק את הTwo-ways binding לשניים: One-way binding ו Event Binding.
למעשה [(ngModel)] כולל את שניהם, [ ] מייצג One-way binding, ו ( ) מייצג Event binding.
הסיבה שאינך יכול להשתמש עם התחביר המשולב [( )] היא השימוש בDatePipe (אנגולר לא מאפשרת שימוש בPipes בשילוב עם Two-ways binding)

ועוד Convention קטן שלא הרבה יודעים:
כל Output בעל שם דומה ל Input קיים, בתוספת המילה Change יכול לשמש עבור Two-ways binding ללא כל הגדרה נוספת.

@צדיק-תמים אמר במגבלות מאגר ב-github - גודל מאגר מירבי, וגודל מירבי לכל קובץ בודד במאגר:

זה לא נראה בקישור שהבאת שמדובר על גיטאהב...

צודק טעות שלי.

@צדיק-תמים

כלומר להעביר אליו את הריפו שלי?

מעולם לא רמזתי דבר כזה, הציטוט מהתיעוד הוא לגבי המדיניות של Github והוא נכון ללא קשר לכלי DevOps כזה או אחר.

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

@yossiz אמר בהחלפת הקלדה לעברית.:

אפשר לשאול למה לא עשית convert ו-lookup סטטיים?

טעיתי לחשוב שלthis אין משמעות כלל במתודה סטטית, ומשכך הדרך להתייחס לשאר החברים הסטטיים, היא בשימוש של שמה של המחלקה.

בנוסף אולי יהיה אפשרי להסתפק רק בביטוי השני של הקוד דלהלן:

this.#lookup.get(x) ?? this.#lookup.get(x.toLowerCase())

עדכנתי את הקוד.

@צדיק-תמים שאלת על Hard limit, לא על המלצות והזהרות למיניהם.

@צדיק-תמים אמר במגבלות מאגר ב-github - גודל מאגר מירבי, וגודל מירבי לכל קובץ בודד במאגר:

ידוע לך אולי מה המגבלה לכל הrepo ביחד?

100 GB, אם כי כיום אין תיעוד מפורש על הנושא.

@צדיק-תמים אמר במגבלות מאגר ב-github - גודל מאגר מירבי, וגודל מירבי לכל קובץ בודד במאגר:

וגם פוש לפי מה שהבנתי
מוגבל ל50/100 מגה

מדוייק

GitHub blocks pushes that exceed 100 MB.

הפתרון הוא שימוש ב Git Large File Storage (או בקיצור Git LFS)

Git LFS מיועד עבור קבצים מעל 100MB, הקבצים אינם מאוחסנים בRepository, במקום זאת Git LFS יוצר Pointer file שמשמש כReference עבור אותם קבצים.
בחשבון החינמי של Github\Gitlab אתה מוגבל עד 2GB לקובץ.