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

@חגי האם אתה היית ממליץ למי שכבר מפתח לווינדוס ב NET Core. לעבור ל NET Framework.?

זה קצת מפליא אותי אבל אני לא יכול לשפוט בצורה אובייקטיבית, כי לפחות כמה שנים לא נגעתי ב NET Framework. מה שאני כן יודע זה שהוא הוצא מתמיכה ומה שהחליף אותו זה NET. שהוא מודרני, חוצה פלטפורמות, מתעדכן עם שיפורי ביצועים ותיקוני אבטחה, מסקרן אותי אם יש ל NET Framework. יתרון קונקרטי, לומר שהוא יותר בוגר בלי להסביר איפה לא עוזר לי הרבה (WinXP גם יותר בוגר, אבל במוזיאון)

(WinForm @pcinfogmach פחות מעניין אותי, אבל תן לי לדוגמא פקד שקיים רק ב framework, גם זה נשמע לי מוזר..)

@dovid התכוונתי לאפוקי NET Framework.
(NET Core. עבר שינוי השם ל NET. בגרסה 5)

@dovid כתב במה ההבדל בין שני סוגי הפרויקטים הללו בויז'ואל סטודיו?:

אז אני לא יודע בדיוק מה הייתרון לפתח ב.net core.

אפשר לשאול הפוך: מה היתרון לפתח ב net framework?

@מוטי-מן כתב ביצירת קובץ exe יחיד לאחר הקימפול בויזו'אל סטודיו:

בכל אופן, כשאני מעתיק את הקובץ exe לבדו מהפרויקט שבתמונה לעיל זה לא עובד

אתה צריך גם את ה dll עם אותו שם, ככה זה עובד ב NET., (הקוד שלך נמצא רק ב dll ולא ב exe) אם אתה רוצה לפרסם כקובץ אחד, זה אפשרי ברוב המקרים (אם אין תלות לא מנוהלת) על ידי המאפיין PublishSingleFile, בשורת הפקודה זה משהו כזה dotnet publish .. /p:PublishSingleFile=true ויש גם אפשרות בממשק של ויז'ואל סטודיו.

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

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

public static partial class ComActivator
{
    [LibraryImport("ole32")]
    private static partial int CoCreateInstance(
        ref Guid clsid,
        nint pUnkOuter,
        int dwClsContext,
        ref Guid iid,
        [MarshalAs(UnmanagedType.Interface)] out object pObj
    );

    public static TInterface ActivateClass<TInterface>(Guid clsid, Guid iid)
    {
        Debug.Assert(iid == typeof(TInterface).GUID);

        var hResult = CoCreateInstance(ref clsid, default, 1, ref iid, out var obj);

        if (hResult < 0)
        {
            Marshal.ThrowExceptionForHR(hResult);
        }

        return (TInterface)obj;
    }
}

ב. למחלקה ITaskbarList3 הוספתי את התכונה GeneratedComInterface

ג. ככה אני מקבל את האובייקט:

var clsid = Guid.Parse("56FDF344-FD6D-11D0-958A-006097C9A090"); // TaskBarList
var iid = Guid.Parse("EA1AFB91-9E28-4B86-90E9-9E9F8A5EEFAF"); // ITaskBarList3

var taskbar = ComActivator.ActivateClass<ITaskbarList3>(clsid, iid);

קישור שעזר לי: https://learn.microsoft.com/en-us/dotnet/standard/native-interop/tutorial-comwrappers

נ.ב. מצאתי עוד פתרון עם ComWrappers אבל הפתרון הראשון עובד מצויין אז השתמשתי בו.

@קו-כשר-מערכות-טל כתב בקוד באט לסגירת תוכנית:

אגב לפי מה שידוע לי כן אפשר לגשת למנהל המשימות על ידי הצרוף Ctrl+Alt+Delete

נכון, אבל התוכנה סוגרת את זה ישר אחרי שזה נפתח, ואגב אפשר לפתוח גם עם Crtl+Shift+Esc.

@אוריי כתב בקוד באט לסגירת תוכנית:

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

אם אתה רוצה גישה למנהל המשימות בחדר מחשבים, אתה יכול להוריד את systeminformer.

@חגי כתב ב#C | הטמעת ממשקי COM במצב NativeAOT‏:

בסוף אחד הקישורים הם מציינים בהקשר הזה שהם מתחילים להוסיף תמיכה לcode generator עבור רכיבי COM, ניסית לבדוק אם זה פותר את השגיאה?
https://learn.microsoft.com/en-us/dotnet/core/whats-new/dotnet-8#source-generated-com-interop

ניסיתי גם את זה ונשאר עם אותה שגיאה (זה מגנרט קוד, אבל ב-native-aot זה זורק אותו חריג), אולי לא ממשתי את זה נכון (יש דרך אחרת לקבל מופע של ממשק COM?)

static partial class Taskbar
{
    [GeneratedComInterface]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    [Guid("EA1AFB91-9E28-4B86-90E9-9E9F8A5EEFAF")]
    public partial interface ITaskbarList3
    {
        // ITaskbarList
        [PreserveSig] void HrInit();
        [PreserveSig] void AddTab(IntPtr hwnd);
        [PreserveSig] void DeleteTab(IntPtr hwnd);
        [PreserveSig] void ActivateTab(IntPtr hwnd);
        [PreserveSig] void SetActiveAlt(IntPtr hwnd);

        // ITaskbarList2
        [PreserveSig] void MarkFullscreenWindow(IntPtr hwnd, [MarshalAs(UnmanagedType.Bool)] bool fFullscreen);

        // ITaskbarList3
        [PreserveSig] void SetProgressValue(IntPtr hwnd, ulong ullCompleted, ulong ullTotal);
        [PreserveSig] void SetProgressState(IntPtr hwnd, int state);
    }

    [ComImport]
    [GeneratedComClass]
    [ClassInterface(ClassInterfaceType.None)]
    [Guid("56FDF344-FD6D-11d0-958A-006097C9A090")]
    public partial class TaskBarCommunication { }
}

@dovid לא שמתי לב שזה כתוב שם, אבל אני יודע שאפשר ליישם ממשקי COM ב native-aot, בדקתי את קוד המקור של avalonia שתומכת ב native-aot באופן מלא, וראיתי שהם פיתחו תת פרויקט (MicroCom) שמחולל קוד לממשקי COM מקבצי idl. לא התעמקתי בזה כ"כ כי אני לא מכיר קבצי idl, בתכלס אני שואל מה הדרך הכי קלה ליישם ממשקי COM עם או בלי מיקרוסופט?

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

ב - 8 NET. שהושק לפני כמה ימים, במיקרוסופט פיתחו בין היתר את התכונה Native-AOT, למי שלא מכיר זה מאפשר לקמפל קוד #C לקוד מכונה מקורי, ללא קוד IL ובלי שימוש במנגנון JIT. יש בזה הרבה מעלות (אין צורך בזמן ריצה מותקן, זמן טעינה מהיר, ועוד) אבל יש גם קצת מגבלות, כרגיל.
אחת הבעיות היא הטמעת ממשקי COM בקוד, ראיתי שיש הרבה דיבור על זה ברשת, אבל בתכל'ס אני לא מצליח ליישם את זה.

אני לוקח לדוגמא את הקוד הבא:

using System.Runtime.InteropServices;
using static Taskbar;

try
{
    var taskbar = (ITaskbarList3)new TaskBarCommunication();

    Console.WriteLine("COM interface created successfully");
}
catch (Exception exception)
{
    Console.WriteLine($"Error at creating COM interface: {exception}");
}

Console.ReadLine();

static class Taskbar
{
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    [Guid("EA1AFB91-9E28-4B86-90E9-9E9F8A5EEFAF")]
    public interface ITaskbarList3
    {
        // ITaskbarList
        [PreserveSig] void HrInit();
        [PreserveSig] void AddTab(IntPtr hwnd);
        [PreserveSig] void DeleteTab(IntPtr hwnd);
        [PreserveSig] void ActivateTab(IntPtr hwnd);
        [PreserveSig] void SetActiveAlt(IntPtr hwnd);

        // ITaskbarList2
        [PreserveSig] void MarkFullscreenWindow(IntPtr hwnd, [MarshalAs(UnmanagedType.Bool)] bool fFullscreen);

        // ITaskbarList3
        [PreserveSig] void SetProgressValue(IntPtr hwnd, ulong ullCompleted, ulong ullTotal);
        [PreserveSig] void SetProgressState(IntPtr hwnd, int state);
    }

    [ComImport]
    [ClassInterface(ClassInterfaceType.None)]
    [Guid("56FDF344-FD6D-11d0-958A-006097C9A090")]
    public class TaskBarCommunication { }
}

קובץ הפרויקט:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <PublishAot>true</PublishAot>
    <BuiltInComInteropSupport>true</BuiltInComInteropSupport>
  </PropertyGroup>
</Project>

כשאני מריץ עם: dotnet run זה רץ בלי בעיות, אבל כשאני מקמפל עם dotnet publish זה זורק את החריג הבא:

System.InvalidProgramException: Common Language Runtime detected an invalid program. The body of method 'Void TaskBarCommunication..ctor()' is invalid.
   at Internal.Runtime.TypeLoaderExceptionHelper.CreateInvalidProgramException(ExceptionStringID, String) + 0x40
   at Internal.Runtime.CompilerHelpers.ThrowHelpers.ThrowInvalidProgramExceptionWithArgument(ExceptionStringID, String) + 0x9
   at ComWithNativeAotSample.Taskbar.TaskBarCommunication..ctor() + 0x15
   at Program.<Main>$(String[] args) + 0x34

משהו יכול להסביר לי איך אני אמור לשנות את הקוד כדי שזה יעבוד עם native-aot?

@WWW במקרה שלך זה בלתי אפשרי לייצר מספר בן 10 ספרות ממספר בן 5 ספרות.

הפתרון הוא שהקוד הנגדי יהיה באורך של 8 ספרות (זהה לאורך של מספר פלא' חוץ מהקידומת הקבועה 05, כמו שכתבו פה) ואז להפוך את המספר פלאפון איכשהו (xor לדוגמא) לקוד הנגדי, ובאותה דרך לשחזר למספר הפלאפון שהמשתמש הזין.

תשובה לשאלה הראשונה:
הסרוויס צריך להכיל את כל המידע ולהפיץ אותו בכמה שיטות לקומפוננטות כך שהם יוכלו לקבל אותו באיזה צורה שהם רוצים (מידע קצר / מידע מלא), במקרה שזה ממש הרבה קוד לסרוויס אחד אולי באמת מומלץ לפצל את זה לשני סרוויסים (שמקושרים אחד לשני)

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

יש אפשרות לעקוף את זה, או שתם עידן הג'מבו מייל לאינטרנט מסונן? (למי שאין מנוי)

Process Hacker

@nigun כתב בכך תריצו מודל שפה חזק על המחשב הביתי שלכם:

זה קובץ של "רשת נוירונים" שאף אחד לא יודע להסביר מה הולך בתוכו, כשהמודל מקבל משפט הוא מחשב ע"פ הקובץ הזה מה ההסתברות למילה הבאה.

לייתר דיוק, זה קובץ שמכיל 'משקלים' שהם מיועדים כקלט לרשת הנוירונים, הרשת עצמה כלולה בארכיטקטורה של המודל ולא שוקלת הרבה, במהלך שלב האימון נוצר הקובץ של ה'משקלים', שאתו משתמשים בשלב ההסקה.

@משתמש-תמים כתב בהגנה מפישינג והאקינג:

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

מדויק, זה הסיבה שלא הפעלתי את זה.

@אף-אחד-3 אם תיקח סתם קובץ שמע, שיר לדוגמא, ותבצע לו את ההגברה עם הסקריפט, מה שיקרה זה שחלק מהמידע (מה שעובר את ה 0db) בשיר יאבד, קוראים לזה בהגדרה המקצועית 'clipping, לכן הדרך הנכונה להגביר קובץ שמע שקט זה באמצעות נירמול, שזה אומר להגביר את כל הקובץ בעוצמה קבועה אבל בלי שהעוצמה בשום חלק מהשיר תעבור את ה 0db.

אני רק מוסיף שמה ש @אף-אחד-3 כתב זה מגביר את העוצמת שמע בעוצמה קבועה, כדי להגביר בצורה אוטומטית עד שיגיע לסף של 0db צריך ל'נרמל' את השמע, יש לזה פונקציה מיוחדת שנקראת normalize.

@dovid כתב בפלייבקים חדשים באורגני yamaha:

האם נכון לומר שאין במפרט אפשרות לדעת אם זה תומך בדגימות?

תמיכה בדגימות זה דבר בסיסי שאמור להיות כתוב במפרט אבל השאלה איך זה כתוב, לדוג' ב-PST-SX900 זה מצוין כ- internal memory, ובחברה אחרת זה מצוין כ- Wave Expansion Memory for Sampling/Sample Import.

לגבי המקצבים זה משנה על איזה דגם בנו את המקצב, בד"כ יש תאימות לאחור, אבל לא להיפך, לדוג' אם מקצב משתמש בצליל או פונקציה מסוימת שקיימת בדגם חדש, אז כשינסו לטעון אותו על דגם מדור ישן שלא קיימת בו הפונקציה הזאת זה יהיה בעיה (אני לא יודע לדייק בפרטים כי אני לא מחזיק ב-Yamaha)