@Pesia
איזה התקפה...
לא ראיתי התקפה, הוא רק אמר את דעתו.
והוא מתכנת מקצועי לפי מה שנראה בפורום.
ואני חושב שבישקול הוא קריאות. אם זה מסובך בהתבוננות ראשונה, לפרק. אם לא, זה עניין של טעם.
פורסם במקור בפורום CODE613 ב19/05/2015 19:32 (+03:00)
הפורום כעת לקריאה בלבד, לקריאה נוספת.
@Pesia
איזה התקפה...
לא ראיתי התקפה, הוא רק אמר את דעתו.
והוא מתכנת מקצועי לפי מה שנראה בפורום.
ואני חושב שבישקול הוא קריאות. אם זה מסובך בהתבוננות ראשונה, לפרק. אם לא, זה עניין של טעם.
פורסם במקור בפורום CODE613 ב19/05/2015 19:32 (+03:00)
אני חושב שהתכונת לזה.
string str = base.ToString() + "Birthday:" + birthday.ToString();
return str;
פורסם במקור בפורום CODE613 ב17/05/2015 14:32 (+03:00)
אני מנחש שאתה לא עושה את העצה של ClickOne כי זה גדול עליך.
אז לאט לאט.
הוסף למודול VB מתודה ריקה ופונקציה ככה:
Sub TestSkill()
MsgBox ClickOneImplation("כתובת קלאסית לבדיקה 5/2 ב'")
End Sub
Function ClickOneImplation(unput As String)
ClickOneImplation = "פה בסוף תתן את הפלט"
End Function
כנס עם הסמן למתודה הנקראת TestSkill והקש F5.
לאט לאט נסה להבין מה ואיך ולבצע צעד אחר צעד את הרעיון של ClickOne. כשההודעה תביא את הטקסט הרצוי, תעתיק את הרעיון ללולאה שעוברת על כל הרשומות.
פורסם במקור בפורום CODE613 ב14/05/2015 17:31 (+03:00)
אם אני מבין נכון, נכון לומר שwpf זה פלטפורמה לפיתוח תוכנה שולחנית עם ממשק משתמש מעוצב גרפית. אבל המימוש של התוכנה עדיין משתמש באותה שפה
בדיוק.
ולא מספיק (או שלא מומלץ..) לבנות כמה טפסים שפשוט מזינים אוטומטית את הנתונים ישירות למסד הנתונים המרכזי
אין כזה דבר. לא שלא מומלץ, זה פשוט לא קיים. בשביל זה יש את אקסס או תוכנה שמישהו בנה, בWPF למשל 
הבנתי שעכשיו מיקרוסופט מאפשרים לפתח אפליקציה שיודעת לרוץ על כל סוגי הפלטפורמות (מחשב נייח/נייד) האם זו פלטפורמת פיתוח שונה, או שזה שכלול של WPF?
פותח כבר, רק השתדרג לקראת WIN10 לרוץ גם על פלפורמות זרות (מק לינוקס אנדואיד).
זה פלטפורמה חדשה מעט, דומה מאוד מאוד לWPF. רק מוגבלת בכמה דברים מטבעה - התוכנה רצה בתוך ארגז חול - כמו JS בדפדפן שלא יכול לעשות הרבה בלי רשות.
כמו כן, האם נכון לומר שASPNET זה בעצם פלטפורמה לתכנות אתרי אינטרנט, או שלאו בהכרח?
בדיוק.
האם בעצם עדיף לקחת נושא אחד ללמוד אותו היטב ולהתמקצע בו או שעדיף (או שצריך) לנסות להקיף וללמוד כמה פלטפורומות כי בסוף צריך לדעת להשתמש בכל הכלים? כלומר, האם עדיף סיני או עוקר הרים :lol:
לא יודע...
מצד אחד צריכים להשקיע בכל דבר שלומדים, אבל מאידך הפיזור עוזר להחליט במה לבנות מערכת, מה החסרונות והתירונות של כל פלטפורמה.
(כמו כן, האם יש ספר מומלץ ללימוד WPF?)
אני קניתי את הספר הזה WPF 4.5 Unleashed. אבל יש הרבה אחרים.
יש גם מדריכים אינטרנטיים לרוב:
http://webmaster.org.il/articles/wpf
http://www.codeproject.com/Articles/22980/WPF-A-Beginner-s-Guide-Part-of-n כבד ובאנגלית - אבל יסודי.
http://www.wpftutorial.net/LearnWPFin14Days.html
https://joshsmithonwpf.wordpress.com/a-guided-tour-of-wpf/ תוכן לסדרה בcodeproject
פורסם במקור בפורום CODE613 ב18/05/2015 11:28 (+03:00)
אם אני רוצה לבנות תוכנה עם ממשק משתמש בWPF האם גם בשביל זה אני צריך להגדיר מחלקות וכדו' או שבשביל זה אני מכניס בממשק טבלה והמשתמש מזין לתוכה את נתוני המתפללים, ואח"כ אני יכול להגדיר פונקציות שיפעלו עליה, או כל דבר אחר. או שגם בשביל זה הכי טוב זה לבנות מחלקות, ואח"כ לממש אותם דרך ממשק המשתמש (שאת זה עדיין אין לי מושג איך עושים.. אבל אני מניח שזה השלב הבא שאני צריך ללמוד, כלומר WPF..)?
C# נשארת אותה שפה בכל הפלפורמות. WPF זה פלטפורמה אחת. אני ממליץ לך ללמוד אותה אם אתה רוצה לעשות תוכנות שולחניות.
האם ללמוד ASP.NET MVC, SQL? או שיש דברים יותר בסיסים שצריך להשלים, כיון שאין לי מושג איך כותבים תוכנה שיכולה גם להסתנכרן עם מאגרי מידע באינטרנט/GPS ודברים כאלה? או שזה מה שאני אלמד בASP ודומיו?
אם מישו יוכל לעשות לי קצת סדר בנושאים הללו אשמח..
תודה רבה!
כמעט כל תוכנה שתכתוב תהיה קשורה לנתונים. אז כדאי קצת לעבור על SQL.
ASPNET MVC זה פלטפורמה (ווב) + וMVC זה ללמוד מתודלוגיה (סגנון תכנות, תבנית עבודה). זה מאוד מומלץ אבל זה חתיכת לימוד.
לא יודע כ"כ לכוון אותך כי ייתכן שכדאי להתחיל אחרת ממה שצעדתי אני. אני שנים הייתי בWPF. כעת אני קצת נמצא בMVC.
פורסם במקור בפורום CODE613 ב17/05/2015 14:39 (+03:00)
שלום! מקוה שתתמיד איתנו גם אחרי שכבגר לא תהיה ירוק (אלא כריש בס"ד)!
@avr416
חוצמיזה, אני מנסה להבין האם כדי לבנות תוכנה כזאת, צריך לבנות מחלקות של אנשים ומתפללים וכן על זה הדרך? האם לא יותר פשוט לעשות טבלה עם נתונים ופשוט כל פעם לשלוף אותם משם? או בשביל מה בעצם צריך את כל הדרך המסורבלת הזאת של הגדרת קלאסים וממשקים?
יפה מאוד שקלטת את ה"מונחה אובייקטים" שזה שאיפה להסתכל על הכל כאובייקטים. אבל ודאי שאינך חייב לשום מתודולגיה.
אבל הכי מעניין זה מה שאתה שואל "בשביל מה בעצם צריך את כל הדרך המסורבלת הזאת של הגדרת קלאסים וממשקים"
במילים אחרות בשביל מה החיה הזאת ששמה OOP.
אז התשובה היא כדי להעביר כמה שיותר את התפיסה האנושית שלך לקוד ה"גולם". במקום שאתה תידע שיש מתפלל, אך הקוד יתייחס אליו כרשומה נוספת, ואתה בכח הידע שלך תתרגם את הסתום בקוד לבעל משמעות כל פעם מחדש בעזרת לוגיקה בראש שלך ולפי זה תפעל עליו בהתאם פעולות, אתה פורס את התפיסה שלך בפני המחשב. ואז שאתה כבר לא צריך להיכנס לתוך הגולמות של הקוד הרבה יותר קל לכתוב ולהחזיק ראש ב"מערכת" אותה אתה בונה.
הכי טוב זה דוגמאות. אני מקוה לכתוב על זה בשבוע הקרוב בל"נ.
חוצמיזה, אם אני רוצה לעשות ממשק משתמש קלאסי (כגון דרך WPF או windowsForm) האם עדיין צריך לכתוב את התוכנה בצורה הזאת, או ששם זה משהו אחר..
הכל אותו דבר. C# זה C#, והממשק זה סתם ספרייה מוכנה.
אני מבין שזו שאלה של בור.. אבל לא הביישן למד..
ממש לא שאלה של בור, וגם אם כן זכותך להיות בור במתכנות כמו שאני בכל מה שלא תכנות (סידור פרחים למשל. אבל אני מניח שגם אתה לא מבין בזה :)).
שאלה נוספת האם יש טעם ללמוד WindowsForm
אין טעם. הוא לא מחליף לגמרי (הWinFoms נחשב לקומפקטי בתוכנות זעירות), אבל זה כבר לא שווה דקה לימוד לדעתי.
פורסם במקור בפורום CODE613 ב14/05/2015 15:54 (+03:00)
Foreground/Background Thread
טריד יכול להיות טריד רקע - Background והמשמעות היחידה של זה היא שכשהתהליך הראשי באפליקציה גומר הוא מפסיק אותו באמצע. לעומת זאת בטריד Foreground (וזה הברירת מחדל של טריד) האפליקציה ממתינה לסיומו.
הגדרת תהליך כBackground נעשית ע"י הצבת true למאפיין IsBackground.
Thread Priority
ניתן לתת לThread רמת עדיפות ביחס לטרידים האחרים באפליקציה שלנו (ל ביחס לתהליכים של אפליקציות אחרות במחשב. זה ניתן לשינוי אבל זה לא קשור לנושא שלנו). ע"י הצבה של ערך במאפיין Priority הערכים האפשריים הם: Lowest, BelowNormal, Normal, AboveNormal, Highest.
Thread Safety
הבעיה מס' 1 בריבוי טרידים זה מה שנקרא Thread Safety. כלומר בטיחות המידע מפני גישה של תהליכים בו זמנית.
המצב שתהליך פונה למשאב משותף ומשנה אותו בה בעת שתהליך אחר משתמש בו עשוייה להביא לתוצאות בלתי צפויות. דוגמה פשוטה: כשאנחנו עושים מונה בלולאה או בכל מקום אחר בקוד אנחנו כותבים משתנה++. המשמעות המלאה של זה היא: 1. קח את ערך המשתנה, 2. הוסף לו אחד, 3. ואכלס את ערך התוצאה במשתנה הזה (תוך דריסת הערך הקודם). עכשיו בריבוי תהליכים יכול להיות מצב שתהליך א' עושה את הפרצדורה 1 ו2, ובה בעת תהליך אחר גם כן. כעת כששניהם אוחזים בשלב 3, במקום שהמשתנה "יגדל" בשניים, הוא יגדל רק באחד. ייתכן שתהליך אחד הגדיל את המשתנה כבר בשתי פעימות, ותהליך אחר יחזיר אותו אחרוה ע"י השמת החישוב של משתנה+1 המעודכן ללפני כמה מילישניות.
הנה המחשה:
static int result = 0; //משאב משותף לשתי התהליכים
private static void Main(string[] args)
{
//יצירת שתי טרידים.
var t1 = new Thread(Do);
var t2 = new Thread(Do);
//הרצת התהליכים.
t1.Start();
t2.Start();
//הרצת המתודה גם בתהליך הראשי/נוכחי
Do();
//וידוא שהתהליכים יגמרו לפני הדפסת התוצאה
t1.Join();
t2.Join();
//הדפסת התוצאה
Console.WriteLine(result);
Console.ReadLine();
}
static void Do()
{
for (int i = 0; i < 10; i++)
{
Thread.Sleep(1); //האטת התהליך הנוכחי כדי שתהיה חפיפה בזמני הריצה.
result++;
}
}
הקוד הזה מריץ את הפונקציה Do משתי תהליכים ובנוסף מהתהליך הראשי. הפונקציה פונה שוב ושוב, 10 פעמים, למשתנה result בוחנת את ערכו ומשימה בו את הערך אות בחנה + 1. לפי החשבון המשתנה result צריך להכיל לבסוף את הערך 30, שהרי זה מס' הפעמים בהם הועלה ערכו ב1. אבל בגלל ההתנגשויות בין התהליכים הערך יהיה כל פעם משהו אחר נמוך מ30 בדרך כלל.
כמובן שהקוד הזה חסר תכלית אז קשה להציע בו שינוי מועיל.
בהודעה הבאה אציע מקרה ממחיש יותר. בו תהיה הבעיה ופתרון הLocking - בלוק קוד שרק תהליך אחד יכול להיכנס אליו בו זמנית. זה פותר את הבעיה של משתנה++. כי מתחילת התהליך עד סופו, יש רק תהליך אחד שעושה את הפעולה ברגע נתון.
רגע, מה אם JS? וNode.js? איך הם מתגוננים מכזה דבר? התשובה היא שהם עובדים על טריד אחד תמיד. האסינכרוניות שלהם עובדת על אירועים ותזמון. ממילא לעולם לא רצים במקביל שתי פקודות שעלולות לשבש או לסתור אחת את השניה. תמיד יש אחת ראשונה ואחת שניה. אכן, זה חולשה של JS בעיבוד, אבל זה לא כ"כ התפקיד שלו
פורסם במקור בפורום CODE613 ב18/05/2015 12:53 (+03:00)
Lambda כדרך להעברת פרמטרים לטריד
אם משתמשים בביטוי למדה המצב הוא אלגנטי בהרבה:
private static void Main(string[] args)
{
Console.WriteLine("enter min value to check: ");
var min = int.Parse(Console.ReadLine());
Console.WriteLine("enter max value to check: ");
var max = int.Parse(Console.ReadLine());
List<int> results = new List<int>();
Thread t = new Thread(() => Do(min, max, results));
...
...
}
private static void Do(int minValue, int maxValue, List<int> results)
{
for (int i = minValue; i < maxValue; i++)
{
bool exsistDivisor = false;
for (int j = 2; j < (i / 2); j++)
{
if (i % j == 0)
{
exsistDivisor = true;
break;
}
}
if (!exsistDivisor) results.Add(i);
}
}
מה זה ביטוי למ(ב)דה? זה לא כ"כ המקום להסביר אבל בשתי מילים: דרך מקוצרת ליצור מתודה אנונימית לשימוש מקומי, רק נגדיר את הצורך והכללים:
הצורך - אני במהלך פונקציה מסויימת צריך לבדוק חמש פעמים את האורך של טקסט לחלק ל12. אז במקום לכתוב כמה פעמים את התהליך אז אני רוצה פונקציה (מה שנקרא Reuse -לא לכתוב קוד פעמיים). אין שום טעם ליצור פונקציה חיצונית כשהמקום היחידי בה היא באה לשימוש זה בתוך הפונקציה שלי.
האופן: מבנה פונקציה רגילה בC# היא ככה
- מציין גישה (פרטי ציבורי וכו')
- ערך מוחזר
- שם
- פרמטרים נדרשים - סוג ושם
- גוף הפונקציה שכללי הגוף הם: א. מוקף בסוגריים מסולסלים חובה, ב. חובה לכלול return כשמחזיר ערך ג. כל פקודה אפי' יחידה מסתיימת בנקודה פסיק.
ובכן למדה תמיד מכניסים לתוך משתנה/פרמטר שהוא כבר הגדיר את חתימת הפוקנציה - מה היא מחזירה ומקבלת (2, 4). וגם השם מיותר (3) (כי הרי בפרמטר אין לנו צורך להעניק שם ובמשתנה הלא אנו "מחזיקים ביד" את המשתנה). אבל יש צורך לתת שם לפרמטרים. כי אנחנו צריכים לדעת איך להתייחס אליהם מגוף הפונקציה. מציין גישה (1) ודאי שלא צריך. אז נשאר: שמות פרמטרים (במידה ויש יותר מאחד מופסקים בפסיק וחובת עטיפתם בסוגריים) ובלוק הפונקציה. אבל שתי דברים :
א. בין שמות הפרמטרים שלגוף התחביר הוא לשים =< היינו שווה ואח"כ "גדול מ" . (זה בא לומר הקלט משמאל (הפרמטרים מועברים לגוף הפונקציה מימין)
ב. בגוף הפונקציה עצמו ישנה "קולות" למקרה בו הפונקציה מכילה שורה אחת בלבד, 1 .לא צריך לעטוף בסוגריים מסולסלות 2. לא צריך נקודה פסיק בסוף הפקודה 3. לא צריך לפרש return להחזרת הערך אלא פשוט כותבים אותו וזהו.
פורסם במקור בפורום CODE613 ב14/05/2015 19:58 (+03:00)
[size=110:14bu1mwd]דרכים להעביר ולקבל מידע מהThread[/size:14bu1mwd]
כמו שראינו הטריד מקבל פרמטר שהוא מסוג דלגייט פשוט שככה נראה:
public delegate void ThreadStart();
זה מתודה שלא מקבלת פרמטרים (יש גירסה שמקבלת פרמטר מסוג ParameterizedThreadStart שכשמו הוא מקבל פרמטר אחד מסוג אוסייקט. אבל נשאיר את זה כי זה שיירים עלובים מתקופת האבן של דוט נט, כעת זה מיותר לגמרי).
מה אם אנחנו רוצים להעביר לטריד מידע? הדרך לאינראקציה עם Thread זה פשוט גישה לאותו משאב (משתנה/אובייקט) של התהליך הקורא או כלל התהליכים. זה מה שנקרא Shared Data.
Shared Data - שיתוף זכרון בין תהליכים
איך עוישם זאת? איך נגשי ם מטריד אחד למשאב של טריד אחר?
בעיקרון זה מידי קל. לכן, כלל ראשון במעלה: תהליך שניגש למידע משותף המשמש יותר מטריד אחד, הוא מצב שצריך למנוע אותו ככל האפשר, ובעצם זה שער לכל הבעיות של ריבוי-תהליכים.
פשוט מאוד. אם המתודה שמועברת לטריד פונה למשאב חיצוני (לא לוקלי מבחינת סקופ) למשל למאפיין/שדה החבר באותה המחלקה, או יותר מזה, למאפיין/שדה סטטי של מחלקה כל שהיא, אז בעצם הטריד פונה למידע הנגיש (לעיתים לקריאה בלבד לעיתים גם לכתיבה) לטריד אחר באותה מידה (והכי גרוע אולי באותה העת).
המצב האידאלי הוא שהמשאב הזה המשותף מוקדש כל כולו לצרכי הטריד הזר, ולא משתמשים בו בטריד הנוכחי כל עוד הטריד הזר בפעולה.
המצב שמומלץ להתרחק ממנו ככל האפשר, הוא משאב אחד המשמש בו זמנית שתי תהליכים.
טוב קיללתי בין השיטין הרבה את הדרך הזאת אז זה הזמן לומר שלפעמים זה לגיטימי לגמרי. נדבר בהמשך על ההשלכות של SharedData.
דוגמה לאינטראקציה בין התהליך הראשי לתהליך חדש:
private static void Main(string[] args)
{
Thread t = new Thread(Do);
Console.WriteLine("enter min value to check: ");
minValue = int.Parse(Console.ReadLine());
Console.WriteLine("enter max value to check: ");
maxValue = int.Parse(Console.ReadLine());
t.Start();
Console.WriteLine("started!");
Console.WriteLine("press any key for recive the status\result... for abort press X");
while (t.IsAlive)
{
if (Console.ReadKey().Key == ConsoleKey.X && t.IsAlive)
{
t.Abort();
return;
}
Console.WriteLine("the thread is busy (the current results count is " + results.Count + "). retry later!");
}
Console.WriteLine(" finsh! \n result count is: " + results.Count + "\n results list:");
results.ForEach(Console.WriteLine);
Console.ReadLine();
}
private static int minValue;
private static int maxValue;
private static List<int> results;
private static void Do()
{
results=new List<int>();
for (int i = minValue; i < maxValue; i++)
{
bool exsistDivisor = false;
for (int j = 2; j < (i / 2); j++)
{
if (i % j == 0)
{
exsistDivisor = true;
break;
}
}
if (!exsistDivisor) results.Add(i);
}
}
מה יש כאן? מתודה שבודקת על טווח מספרים אם הם ראשוניים. היא בעצם ניזונה משתי פרמטרים minValue וmaxValue שהם לא לוקליים בתוך הפונקציה, אלא חברים במחלקה (סטטיים במקרה שלנו). והפלט? נוסף לתוך אובייקט ליסט שגם הוא חבר במחלקה. בעצם ישנה גישה בו זמנית לתהליך הראשי ולחדש שרץ ברקע לכל המידע הזה.
זו דוגמה גרועה מאוד כי ממש מגושם ומעצבן לייחד מאפיין/משתנה ברמת המחלקה על כל פיסת מידע שרוצים להעביר לתהליך.
הדרך המומלצת כיום (פעם (NET 2) זה היה ParameterizedThreadStart אבל אפשר לשכוח ממנו) זה להשתמש בביטוי למדה.
פורסם במקור בפורום CODE613 ב14/05/2015 19:03 (+03:00)
עצם יצירת הטריד לא עושה מאומה, עד שקוראים למתודה Strat. החל ממתי שקוראים למתודה Start אפשר להשהות או לעצור את הטריד, עד שהוא נגמר.
המתודה Start היא חד פעמית. אחרי שטריד הורץ א"א להריץ אותו פעם נוספת.
לThread יש מאפיין כן/לא בשם IsAlive שמחזיר חיובי במידה והטריד עדיין פועל, לא נגמר וכבר התחיל.
יש גם מאפיין מפורט יותר בשם ThreadState שמחזיר את מצבו. המצבים הקלאסיים הם Unstarted ללפני ההרצה ע"י Start, בעת ההרצה זה Running ואם זה מושהה Suspend, נעצר (ע"י מתודה שנראה בהמשך) Aborted.
Join
אם רוצים לחכות בטריד אחד לסיומו של טריד אחר, אפשר להשתמש בפונקציה Join. היא בעצם תוקעת את הטריד הנוכחי עד שהטריד הזר גמר.
למתודה join יש גירסה שמקבלת פרק זמן קצוב, שאם לא נגמר הטריד בפרק הזה, התוכנית כן ממשיכה לרוץ. הפונקציה Join מחזירה ערך בוליאני שמציין האם ה"איחוד" עם הטריד הצליח, כלומר נגמר בפרק הזמן הקצוב.
Sleep
המתודה הסטטית Thread.Sleep() היא משהה את הטריד הנוכחי. היא מקבלת פרמטר מספרי שהוא מס' המילישניות בהם הטריד "ישן" (אפשר להעביר למתודה פרמטר TimeSpan במקום מס' מילישניות). זה פועל על הטריד הנוכחי, לא על טריד אחר.
פורסם במקור בפורום CODE613 ב13/05/2015 20:25 (+03:00)
לאחרונה אני מרפרף על JS ואני מאוד מסתבך מתכונת הדגל של השפה: אסינכרוניות.
התכונה כ"כ מובנית בשפה, שמסובך בה לפעול להפך.
בC# הכל בברירת מחדל סינכרוני, וכשרוצים אסינכרוני זה נחשב "נושא מתקדם".
אז אני רוצה לסכם הפעם מהקל אל הכבד את הנושא של מקביליות ובו זמניות בC#.
מתי יש צורך בזה? למה שהמחשב לא יעשה קודם א' ואח"כ ב'
הסיבות הנפוצות הם:
בדרך כלל הפעלת קטעי קוד שונים בו זמנית נעשים ע"י הטכנלוגיית "ריבוי-תהליכים" - Multi-Threading.
Thread - תהליך
לכל יישום שרץ במחשב יש לפחות תהליך אחד, תהליך ראשי. אבל יכול להיות ליישום עוד תהליכים שחולקים משאבים של זיכרון ועוד, אבל מבודדים מבחינת הריצה שלהם - כל אחד רץ כשלעצמו, כלומר עצירה או תקיעה של אחד לא מפריעה לשני.
איך יוצרים Thread (נוסף) בC#?
למה נוסף? כי האפליקציה עצמה היא כבר Thread אחד. אז בשביל ליצור אחד יש ליצור אובייקט Thread בקוד ו"להריץ" אותו.
הבנאי של Thread מקבל כמה גרסאות פרמטרים, הפשוטה שבהם זה delegate מסוג void ללא פרמטרים.
הנה דוגמה. ייבאתי את מרחב השמות System.Threading. אני יוצר טריד חדש, וכפרמטר אני נותן לו את שם המתודה Do שהיא void וללא פרמטרים.
private static void Main(string[] args)
{
Thread t = new Thread(Do);
Console.WriteLine(t.ThreadState); //Unstated
t.Start();
Console.WriteLine(t.ThreadState); //Running
Console.ReadLine();
}
static void Do()
{
Console.WriteLine("do do do!");
}
פורסם במקור בפורום CODE613 ב13/05/2015 18:19 (+03:00)
תודה לך
כל קשר הוא על אחריותך בלבד..
וכעת ברצינות, אנא ערוך את הודעתך. אם הייתי חפץ בהיקש הזה (בין הניק פה לשם) הייתי חוסך לך את הבירור מזמן.
פורסם במקור בפורום CODE613 ב14/05/2015 12:33 (+03:00)
בנתיים על הטבלה הזאת זה עובד,
לייק או תודה, יש?
אלא"כ ClickOne קיבל ממך זר פרחים והעברה בנקאית 
פורסם במקור בפורום CODE613 ב13/05/2015 12:38 (+03:00)
ולמה שתעשה כל חודש בדיקת מיקוד על כולם?
תעשה רק למי שלא עודכן ל7 ספרות
ובהכנסת רשומה חדשה שיכניס אוטמטי מיקוד.
יש לי בלגן מי חדש מי היה ומי עודכן אבל בגדול אתה צודק, אפשר להתגבר על זה.
פורסם במקור בפורום CODE613 ב13/05/2015 11:51 (+03:00)
אלפי רשומות אני לא מאמין שזה יעבור.
עדיף לכתוב את זה בC# ולעשות טיימר שייתן זמן טוב בין שאילתה לשאילתה אחרת אני מאמין שזה ייחסם.
ראה כאן: http://tchumim.com/topic/580
אם זה עובד תודיע לי, אשמח לעדכן ככה כל חודש (מעל מאה אלף כתובות)...
פורסם במקור בפורום CODE613 ב12/05/2015 21:22 (+03:00)
יש את הפרוייקט openstreetmap.org, לא יודע בדיוק איך לוקחים ממנו מידע אבל הכל שמה נגיש חינם לציבור, שווה חקירה.
אם זה בשביל השלמה אוטומטית, ויש חיבור לאינטרנט, תוכל להשתמש בשירותים מקוונים. למשל:
https://developers.google.com/places/webservice/autocomplete
http://photon.komoot.de/
פורסם במקור בפורום CODE613 ב10/05/2015 19:32 (+03:00)
במחשבה שניה אני מבין שאישור הראוטר לא שווה הרבה כי זה בעצם אומר שהתוכן חשוף בפני כל הרשת הפנימית.
פורסם במקור בפורום CODE613 ב10/05/2015 18:22 (+03:00)
כידוע נט פרי קוראת את חבילות הSSL וחותמת אותם בתעודה משלה שצריך להתקין כדי לגלוש באתרי HTTPS.
הבעיה שאני רוצה להעביר את המקום בו אני עובד (בחלקו הקטן - 10 מחשבים בערך) לנט פרי וזה קרוב לאי אפשרי להתקין בכל מחשב מסיבות שונות. אפשר להתקין ברמה גבוהה יותר, בראוטר למשל? יש לנו ראוטר מתקדם עם בלי סוף פונקציות, ויש שם מקום לCertifate האם התקנה שמה תבטל את הצורך בהתקנה במחשבים? אשמח לכל פיסת ידע ואף השערה.
פורסם במקור בפורום CODE613 ב10/05/2015 17:41 (+03:00)
עוד, עוד טיפים, זה נפלא!
תודה לכם ארכיטקט וsoft!
מצו"ב אשכול מקביל :lol: http://stackoverflow.com/q/121243/1271037
פורסם במקור בפורום CODE613 ב10/05/2015 17:37 (+03:00)
חישוב מרחקים בין נ"צ
לא הבנתי, מה הכוונה?
פורסם במקור בפורום CODE613 ב10/05/2015 16:02 (+03:00)