ארכיטקטורה (5)
|
פתח מאמר מלא בחלון חדש
שאלה:
לא ניתן לשתף באופן ישיר משתנים בין MasterPage והדפים שמתמשים בו(כלומר לגשת מדף X למשתנה שנמצא ב - MasterPage שלו),
יש כל מיני חלטורות כאלו (לדוגמה לשתף עם Session או כל מיני דברים מסובכים), האם מישהו מכיר פתרון קל, נוח ויעיל לנושא
תשובה:
הבעיה הראשונה היא דווקא בעיה מאוד מעניינת ומאוד נפוצה - עבודה מול MasterPage מתוך הדף (Page) שלנו.
נחשוף מאפיין (גם באנגלית: Property) מתוך ה-MasterPage שיאפשר לשנות את הטקסט של ה-Label:
public string HeadlineText
{
get
{
EnsureChildControls();
return lblHeadline.Text;
}
set
{
EnsureChildControls();
lblHeadline.Text = value;
}
}
הדף שלנו (Content2.aspx) נמיר את ה-MasterPage שלו לטיפוס MasterPage שלנו ואז ניגש למאפיין.
public partial class Content2 : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
MasterPage myMasterPage = (MasterPage)this.Master;
myMasterPage.HeadlineText = "www.JustinAngel.Net";
}
}
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
רציתי לדעת מה הדרך הנכונה יותר מבחינת ארכיטקטורה להריץ שאילתות דינמיות במערכת מבוססת שכבות ( Business logic ו -Data access ) כלומר,
אם יש ממשק משתמש בעל כמה שדות שונים וברצוני להריץ שאילתה אך ורק עם אותם שדות שמולאו מבלי להחזיק את משפט הSQL כתוב בקוד.
תשובה:
שאילתות Find הן אכן נושא מסובך. מסכי חיפוש כאלו באמת מאתגרים ובוחנים את הכוח של הארכיטקטורה שלנו.
דבר ראשון בנושא קבלת "החלטות ארכיטקטורה נכונות" צריך לדעת מה הארכיטקטורה הנוכחית הרי נושא כמו שאילתות Find למיניהן לא תקבע לנו את הארכיטקטורה.
public static Cow[] FindAllWithTheseProperties(string Name, decimal? ID,
DateTime? BetweenBirthDate, DateTime? AndThisBirthDate)
{
List<ICriterion> Crit = new List<ICriterion>();
if (ID != null)
Crit.Add(Expression.Eq("Id", ID));
if (BetweenBirthDate != null)
Crit.Add(Expression.Between("BirthDate", BetweenBirthDate,AndThisBirthDate));
List<Order> order = new List<Order>();
order.Add(Order.Desc("FirstName"));
order.Add(Order.Desc("Id"));
return ((Cow[])(ActiveRecordBase.FindAll(typeof(Cow), order.ToArray(), Crit.ToArray())));
}
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
הפתרון הנכון במקרה הזה הוא עבודה עם מאפיינים. נגיד ויש לנו טופס Content1.aspx שיש בו כפתור ואנחנו רוצים לגלות מה הטקסט של הכפתור בדף Content2.aspx שאליו נבצע Cross Page PostBack. ברמת Content1 נחשוף מאפיין שיציג את הטקסט של הכפתור שאותה ינצל Content1.
public partial class Content1 : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
}
public string ButtonText
{
get
{
return Button1.Text;
}
}
}
בטעינה ב-Content2 נבדוק שבאמת מדובר ב-Cross Page PostBack ואם כן ניקח את הדף הקודם ונמיר אותו לסוג Content1 ובכך נקבל גישה למאפיין החדש שלנו.
public partial class Content2 : BasePage
{
protected void Page_Load(object sender, EventArgs e)
{
if (this.PreviousPage != null)
{
Content1 myPreviousPage = (Content1)PreviousPage;
Reponse.Write(myPreviousPage.ButtonText);
}
}
}
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה: מה ההבדל בין ארכיטקטורת MVC לבין ארכיטקטורת 3Tier?
תשובה:
3Tier או כל ארכיטקטורת שכבות אחרת מדברת על "יש לי פרוייקט א' שתלוי בפרוייקט ב' שתלוי בפרוייקט ג'" וממשיך עד תלוי בפרוייקט X.
MVC מסתמכים הרבה יותר על חלוקה לוגית של אחריות ושל הפרדת "מי מדבר עם מי".
protected void btnCreateCow_Click(object sender, EventArgs e)
{
Cow myNewCow = new Cow();
myNewCow.Name = tbxCowName.Text;
myNewCow.Meadow = Meadow.Find(BLHelper.SelectIndexToId(ddlMedows.SelectedIndex));
myNewCow.Create();
}
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
איך הייתם ניגשים לממש שאלה כזו מבחינת האפיון וגם תכנותית (.NET)?
1. שתי ישויות - CONTACT , CONTACT-GROUP (לטובת EMAIL)
2. CONTACT-GROUP יכולה להכיל גם CONTACT וגם CONTACT-GROUP
3. CONTACT יכול להיות במספר CONTACT-GROUPS או באף אחת
4. יש לאפין ולכתוב תכנה המאפשרת
א. יצירת CONTACT ו CONTACT-GROUP
ב. הוספת CONTACT ל CONTACT-GROUP
ג. מחיקת CONTACT מ CONTACT-GROUP
ד. הדפסת כל ה CONTACTS בתצורה עצית
ה. מיון CONTACTS עפ"י שם
פתח מאמר מלא בחלון חדש
|
|
כללי (5)
|
פתח מאמר מלא בחלון חדש
שאלה:
אני לפני רכישת מחשב חדש,
והשאלה אליכם היא בעצם על איזו קונפיגורציה אתם ממליצים מנסיונכם להרצת ויז'ואל סטודיו 2005 בזריזות (מעבד, זכרונות, דיסקים) ובנוחות (מסך, אולי אפילו מקלדת ועכבר ספציפיים עם קיצורים מיוחדים?)
תשובה:
בבירור מחשבי פיתוח הם בעלי דרישות מאוד גבוהות ואולי תמיד אפילו הכי גבוהות שיש לשוק להציע למחשבים.
יש הרבה דברים שצריכים לבדוק: מעבד, מספר הליבות במעבד, זכרון (RAM), כמות הזכרון ומהירות ה-fbs
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה: איך להיות מתכנת חזק?
תשובה:
אין רשימת נושאים אחידה שניתן לתת לתכנת דוט נט כדי שהוא יהפוך ל"תכנת חזק".
כמות הנושאים הקיימת בדוט נט היא באזור ה-20,000 פלוס מינוס. יש בפריימוורק 12,000 מחלקות כיום ועוד אלפי נושאים שלא נכללים כחלק מהפריימוורק (Application blocks, presistence, testing, ארכיטוקטורה וכיו"ב).
בעיניי, "תכנת חזק" הוא לא תכנת שיודע הכל או שיש לו ניסיון בהכל.
אלא זה תכנת שבא עם הגישה הנכונה.
גישה של תמיד ללמוד, של תמיד להיות מוכן לבצע השלמת ידע, של תמיד להישאר מעודכן.
|
|
פתח מאמר מלא בחלון חדש
אני תומך גדול בכך שתעשיית התוכנה תקבע לעצמה תקנים בתחום ההדרכה.
תעשיית התוכנה צריכה לעשות לעצמה רגולציה בהוכחת ידע המינימלי הנדרש.
סטנדרטיים של הוכחת ידע מינימליים צריכים להתקיים ולבוא מתוך התעשייה ולא מהאקדמיה. חובה שתהיה אבן-בוחן שתאפשר למצוא ולהבדיל בין בעלי הידע והניסיון הרלוונטיים מבין חסרי הידע וחסרי הניסיון.
הצורך הזה בא משני דרישות יחודיות של תחום התוכנה: מתחום גיוס משאבי אנוש שכדי למצוא קורות חיים מתאימים מחפשים Buzz-words מגניבות (UML, SOAP, SOA ומה לא) ומתחום חפיפה ראשונית לתפקיד מפתח תוכנה בהיי-טק שאומר שאנחנו חייבים לדעת מה הבן-אדם מולנו יודע.
מבחני הסמכה מקצועיים הם האבן-בוחן הזו שהתעשייה צריכה באופן נואש.
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
"פיתוח אפליקציות שרת-לקוח בשפת C# .Net מאת ד"ר דוט נט, ASP.Net & Xml Web Services" (מהדורה ראשונה, 2006) מאת יוסף בלאן הינו ספר חדש על דוט נט. היחוד האמיתי של הספר הזה הוא שהסופר ישראלי, הספר נכתב בישראל ופורסם במקור בעברית. בתור ספר שמקורו בתרבות הישראלית יש לו באמת גישה שפונה הרבה יותר לקהל הישראלי. המנטליות הישראלית אומרת ככה "אם אני משקיע במשהו את הזמן שלי, אני מצפה לקבל את התמורה המקסימלית. בנוסף, אני לומד הכי טוב מדוגמאות ולא מדיבורים אקדמיים".
אז בשביל ספר שנכתב ע"י ד"ר דוט נט מדובר בספר פרקטי לחלוטין (ואגב, בשביל גילוי נאות יוסף בלאן כותב באתרו ובכריכה האחורית שהוא בעל תואר ראשון ולא דוקטורט). הספר כתוב בצורה שתתקשו למצוא שתי עמודים שאין בהם דוגמת קוד ומבחינתי - נהדר. לימודים טכניים באסמפטיה זה יפה, אבל אם מישהו מקדיש כמה שעות לספר ומצפה לצאת עם ידע מסויים וניסיון כלשהו מן הראוי שזה מה שהוא יקבל (וככה בדיוק המצב בספר זה).
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
לאחרונה ישבתי עם מפתחת דוט נט מוכשרת מאוד. התוכניתנית הזו מחפשת משרה חלקית ובעלת שנתיים ניסיון בדוט נט בחברת אלביט. חלק מהשיחה התמקדה בשאלות טכניות על דוט נט שידוע לי שנוטים לשאול בראיונות עבודה. אחרי שהיא ענתה על השאלות הכי מכשילות שהיו לי והוכיחה רמת ידע מאוד גבוהה, החלטתי לכתוב מאמר מקיף המכיל אוסף רב של שאלות כאלו.
פתח מאמר מלא בחלון חדש
|
|
.Net Development (12)
|
פתח מאמר מלא בחלון חדש
שאלה:
האם קיימת תוכנת obfuscator טובה ככה שלא יהיה ניתן לקרוא בכלל את הקוד של התוכנה שלי?
תשובה:
אני לא מאמין שקיים כזה דבר.
לא ניתן ליצור Obfuscation טוב לדוט נט.
אם לסכם את העניין - לא ניתן להצפין MSIL בצורה חד כיוונית.
זה בדיוק הנקודה - בסופו של דבר ה-CLR עדיין חייב להריץ משהו.
אם ה-MSIL מוצפן בצורה חד כיוונית -ה-CLR לא מריץ קוד ואז למרות ש"ניצחת" והצפנת את התוכנה באופן סופי - אין לך שום תוכנה להריץ.
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
איךאפשר ליצור קובץ בשם DestPath="c:\1.xls" ולשים ב A1 ערך 20 וב A2 ערך 30?
תשובה:
יש הרבה דרכים לעבוד עם קבצי אקסל בדוט נט.
אחת מהן היא להעמיד פנים שאנחנו יוצרים גליון אקסל.
לאקסל יש תכונה מאוד מעניינת - הוא יכול לטעון קובץ HTML לכל דבר ולהציג אותו כקובץ אקסל.
אז בואו נכתוב טבלה <table> ב-HTML, נשמור אותה לקובץ עם סיומת XLS ונראה שאקסל מרנדר אותה.
אבל רגע, אנחנו תכנתי דוט נט - אנחנו לא מדפיסים HTML בעצמנו, יש לנו Server-side controls בשביל זה!
אז ניצור פקד Table של ASP.Net ואותה נשמור לקובץ.
// render to string
StringBuilder sb = new StringBuilder();
using (StringWriter tw = new StringWriter(sb))
using (HtmlTextWriter hw = new HtmlTextWriter(tw))
{
myTable.RenderControl(hw);
}
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
טיפים וטריקים לאבטחת אתר, ממה צריך להיזהר ועל מה לשים דגש.
1. כמובן SQL INJECTION
2. עוגיות (שניתן יהיה לקרוא אותן רק מהשרת)
3. לא לאפשר להעלות קבצים עם סקריפטים למינהם.
4. אני יודעת שאפשר דרך הלוגים של האתר לזהות טרולים למינהם ש"אינם חפצים ביקר" האתר, איך מזהים אותם?
--------מה עוד?
תשובה:
אין גבול לאבטחה.
כמות הידע המקצועי שנדרשת לאבטחה "טובה" (שיכולה לעמוד מול האקר עם ניסיון מינימלי) היא עשרות שנות ניסיון והבנה של איך הכל מתחבר עם הכל. זה תחום ענק שלפי דעתי בלי התמחות סולידית בו (על כל הרבדים ולא רק הרובד התכנותי) אין שום דרך לתפוס אותו בצורה טובה.
אני אסביר למה הכוונה "הכל מתחבר עם הכל". אבטחה מבחינה "פילוסופית" בראות עיניי לא עוסקת בנקודת כשל יחידה, אלא עוסקת בכשל חסר משמעות במקום אחד שגורם לבעיות במקום אחר.
דוגמה שאני מאוד אוהב להראות היא של Rocky שהוא Security MVP והוא מדגים איך דרך פרצה של Sql Injection באפליקציה דוט נטית, אפשר להשתמש בפרצת FTP במסד נתונים סיקוול סרבר, כדי להעלות אסמבלי חדשה לאפליקצה הדוט נטית שלנו שמדווחת לפורץ על כל מה שקורא באפליקציה.
Assembly Hijacking
בארץ יש קבוצת Net Security. שפעם בחודש נפגשים וסוקרים איום אחר.
ניתן לראות העתק של כל המצגות מאז שהקבוצה התחילה להיפגש ובהחלט מומלץ לקרוא את המצגות ולהגיע לפגישות.
צירפתי את סלייד מספר 8 מהמצגת של נימרוד לוריה מהפגישה האחרונה של הקבוצה שממחישה כמה מהפרצות היותר מוכרות בתחום ה-web.
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
יש לי מערך של קבציםומערך של אובייקטים המכיל ערך ישן וערך חדש.
אני צריכה להחליף בכל הקבצים את הערך הישן לערך החדש.
אני עשיתי את זה כך / אשמח לשמוע ביקורת לכאן ולכאן או אפשרות לשיפור הביצועים.
מה דעתכם? האם יש דרך לשפר?
public static void Main()
{
//רשימה של השמות הישנים והשמות החדשים על מנת להחליף את הטקסט
List<manageFiles> mf = new List<manageFiles>();
mf.Add(new manageFiles("replace me", "with me"));
//רשימת הקבצים החדשה
List<string> filesUrl = new List<string>();
filesUrl.Add("myFile1.txt");
filesUrl.Add("myFile2.txt");
filesUrl.Add("myFile3.txt");
//מילוי הנתונים
foreach (string strFile in filesUrl)
{
string tochen = "";
foreach (manageFiles manf in mf)
{
string path = HttpContext.Current.Server.MapPath("../../files/") + strFile;
Regex rg = new Regex(manf.OldName);
using (StreamReader sr = new StreamReader(path))
{
tochen = sr.ReadToEnd();
}
//החלפת הערכים
tochen = rg.Replace(tochen, manf.NewName);
//מחיקת הקובץ הישן
if (File.Exists(path))
{
File.Delete(path);
}
using (StreamWriter sw = new StreamWriter(path, true, System.Text.Encoding.UTF8))
{
sw.Write(tochen);
}
}
}
}
תשובה:
יש מקום לשיפור ונעבור על זה ביחד דרך כללי Refactoring.
קודם נגדיר מילונית (או אבטיחית) מה זה החיה המוזרה הזאת Refactoring.
Refactoring זה שינוי הקוד הקיים, כך שהוא מבצע בדיוק מה שהוא ביצע קודם, רק כתוב בצורה שונה.
כלומר, הפונקציונליות לא תשתנה, אבל הקוד עצמו ישתנה.
מה אנחנו מנסים להשיג ב-Refactoring? קריאות קוד כדי שמתכנתים יוכלו להבין את הקוד, משהו שנקרא חלוקת אחריות נכונה שגם מסתבר שזאת חיה פרוותית שעוזרת במערכות, ובכלל ננסה להביא את המערכת למצב שבה היא ברת תחזוקה.
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
The informative error message:
An unhandled exception of type 'System.BadImageFormatException' occurred in .dll
Additional information: An attempt was made to load a program with an incorrect format. (Exception from HRESULT: 0x8007000B)
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
שלום שלום לכולם,
אני בדיוק מקנפג באפליקציה כלשהי מערכת רישום אירועים (LOGGING), ספציפית
אני משתמש ב-LOG4NET אבל השאלות שעלו במוחי הן כלליות יותר.
1. האם מבחינה טכנית מודולים חיצוניים יוכלו לגשת ישירות להגדרות לWEB.CONFIG?
למשך דרך CONFIGURATIONMANAGER?
2. האם זה נכון לטעמכם מבחינת הנדסת תוכנה שמודולים חיצונים (שיכולים לשמש אתרים אחרים גם)
תלויים בקובץ קונפיג של אתר ספציפי ומניחים הנחות לגביו?
3. אינני רוצה שכל קוד באתר שרוצה לרשום אירוע יצטרך לאתחל מופע של מודול הרישום, הייתי רוצה שיהיה
מקום מרכזי (סטטי) שדרכו עושים את כל רישום האירועים. איפה וכיצד הכי נכון להגדיר מקום מרכזי כזה?
תשובה:
ב-log4net צריך ליצור מחלקה סטטית עם מופע סטטי של הלוגר לפי קובץ הקונפיגיורציה.
namespace Common
{
public static class Log
{
public static ILog logger = log4net.LogManager.GetLogger(typeof(Log));
private static ILog log
{
get
{
return logger;
}
}
public static void Error(string message, System.Exception e)
{
if (log.IsErrorEnabled)
log.Error(ReturnCallStrackInformation(message), e);
}
}
}
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
יש לי את הקוד הבא ואני בטוח שיש דרך יותר טובה ונקייה לכתוב אותו, למישהו יש רעיונות?<<>
// טבלא ראשית
Table MainTbl = new Table();
// הגדרות עבור טבלא
MainTbl.CellPadding = 0;
MainTbl.CellSpacing = 0;
MainTbl.Width = Unit.Parse("456");
TableRow MainRow = new TableRow();
MainTbl.Rows.Add(MainRow);
// טור קו שמאלי של טבלא ראשית
TableCell MainLineLeftCell = new TableCell();
MainRow.Cells.Add(MainLineLeftCell);
MainLineLeftCell.Width = Unit.Parse("1px");
MainLineLeftCell.Height = Unit.Parse("100%");
MainLineLeftCell.Style.Add("background-image", "url(simages/FramePixel.gif)");
תשובה:
בלי לשנות את הפתרון של שימוש בטבלה (במעבר ל-GridView או ל-DataList) בהחלט יש כאן מקום לשיפור הפתרון המוצא.
הפתרון הוא שימוש במתודות סטטיות ואף במאפיינים סטטיים כדי להכיל את כל ההגדרות המעניינות האלו ולרכז קוד.
נתחיל ביחד בתהליך שנקרא Refactoring. מילת המפתח כאן היא Refactoring.
הכוונה היא: שינוי הקוד בלי לשנות את הפונקציונליות שלו.
כלומר, אנחנו יודעים שהקוד עובד אבל עכשיו הגיע הזמן להפוך אותו ליותר קריא וסה"כ יותר "נכון".
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
אני משתמש בStreamReader כדי לקרוא את התוכן של דף Web. כלומר:
Dim dataStream As Stream = m_response.GetResponseStream()
Using reader As New StreamReader(dataStream, Text.Encoding.Default)
Return reader.ReadToEnd()
End Using
(הm_response הוא מסוג HttpWebResponse.)
הבעיה היא שכל עוד לא קראתי את תוכן הדף אני לא יכול לדעת באיזה קידוד הוא נשלח.
האם קיימת דרך לגלות באיזה קידוד הדף נמצא ולהמיר בהתאם?
תשובה:
תשובתו של דניאל כץ.
מה שאנחנו למעשה רוצים לעשות כאן זה לקרוא את המידע עד הסוף מה-StreamReader ורק לאחר מכן לחפש בתוך התוכן ה-HTMLי ולראות מהו הקידוד של המסמך.
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
מה המשמעות של מפתח SNK שיוצרים Strong-Named Assembly, ומה המשמעות של המחרוזת שהוא מייצר?
האם מומלץ להכניס את קובץ ה snk לתוך ה solution?
ראיתי שבמאפיינים של הפרוייקט יש חוצץ signing או משהו בסגנון ושם גם אפשר לציין את קובץ ה snk ע"י GUI ולא ע"י קוד, מה ההבדל?
האם יש דרך אחרת מלבד זו שציינתי להזין את ה public key? לדוגמא לרשום ישירות את ה key במקום להפנות לקובץ?
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
כולנו עובדים עם Assemblies (להלן: אסמבליס ברבים, אסמבלי ביחיד). גם אם אתמול התחלתם לעבוד בדוט נט ובניתם רק אפליקציה לדוגמה - אתם עבדתם עם אסמבלי. בואו כולנו נפתח עכשיו Visual studio, נבחר לפתוח פרוייקט חדש ונקמפל (נעשה build). מה שכרגע קרה זה שהקומפיילר בנה לכם אסמבלי. אם בנינו אפליקציית web אז קיבלנו בספריית ה-bin קובץ myProject.dll, ואם בנינו אפליקציית winform/console נקבל בספריית ה-bin קובץ myProject.exe.
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
החלטתי לכתוב רשימה של כלים שאני חושב שחובה שיהיו לכל מפתח בדוט
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
מיקרוסופט היא חברה מאוד מונופולית. בכל תחום אפשרי היא מקשה על המתחרים שלה ובכך הורגת אותם באכזריות (מהלך שאני תומך בו מאוד). אז למה מיקרוסופט לא עשתה אותו דבר לפיתוח דוט נט עם אורקל? היה מאוד פשוט לבוא ולהגיד “כן, טוב, אי-אפשר לפתח עם אורקל בדוט-נט”. אבל אורקל הוא מסד נתונים מאוד מבוסס ומיקרוסופט ידעו ויודעים שכל ניסיון להתעלם מאורקל רק יוביל שיתעלמו מדוט נט. אז הם התייחסו אליו, וברצינות.
המאמר הזה מיועד בעיקרו לאלו שעובדים עם אורקל ונתקלו בבעיות נפוצות.
פתח מאמר מלא בחלון חדש
|
|
.Net Framework (9)
|
פתח מאמר מלא בחלון חדש
שאלה:
אני רוצה לחלק 5/3 ולקבל את הערך המלא כלומר גם מה שמאחורי הנקודה העשרונית אפשר אולי להראות לי איך?
תשובה:
בואו נראה איך נראית חלוקה רגילה של למשל 6 ו-3.
כצפוי, התשובה היא 2.
עכשיו בואו נשתמש באותה תבנית ונחלק 5 ב-3.
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
ב-List<T> Collection יש כל מיני Methods שמקבלות כל מיני פרמטרים ג'נאריים.
List<T>.ConvertAll מקבלת משהו בשם <Converter<T.
List<T>.Exists, List<T>.RemoveAll, List<T>.TrueForAll ו-List<T>.FindXXX מקבלים משהו בשם <Predicate<T.
List<T>.Sort מקבל <IComprar<T.
List<T>.ForEach מקבל <Action<T.
מה זה כל ה-Methods האלו? מה המחלקות האלו? צריך לעשות Inheritance מהן? שמעתי שאפשר לעשות משהו בשם Anonymous Methods? מה הקשר ל-Generics?
קראתי את התיעוד ב-MSDN, אבל הוא מעיק והדוגמאות לא ברורות...
תשובה:
זאת שאלה מצויינת שמראה את ההבדל בין 1.1 #C לבין 2.0 #C לבין 3.5 #C.
בואו נתחיל בליצור מודל בעיה - יש לנו אוסף של בקבוקי וויסקי.
 
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
בנינו מחלקה שמכילה כמה סוגים של Collections ואנחנו חושפים אותם החוצה ב-Properties.
ה-Collections האלו הם Private למחלקה עצמה, והחוצה אנחנו רוצים לחשוף רק אפשרויות לעבור עליהם בקריאה בלבד.
ההוספה והמחיקה לאוספים הפנימיים הוא תוצאה של אלגוריתמים פנימיים, למשל אנחנו רוצים שיהיה אפשר להוסיף רק דרך Add שלנו כדי שנוכל לעלות Events.
הבעיה היא שב-Get של ה-Property אנחנו מחזירים Reference Type ואפשר לשנות מחוץ למחלקה את ה-Collections בלי לעבור דרך האלגורתימים.
יש לזה פתרון בדוט נט?
תשובה:
בואו נבנה מחלקה לדוגמה שחושפת שלושה סוגי אוספים: (גם באנגלית: Collections)
1. ArrayList - שהשתמנו בדוט נט 1.1
2. List ג'נארי של דוט נט 2.0
3. StringCollection - שזה Collection יעודי שעבר אופטיזמציה לטפל רק במחרוזות
מה מסתבר? עם הפריימוורק מגיעים סוגי אוספים שהם קריאה בלבד.
האוספים האלו הם עותקים שרק אפשר לעבור להם על התוכן, אבל לא ניתן להוסיף, למחוק או בכלל לשנות אותם.
נשנה את המאפיינים שלנו שיחזירו אוספים לקריאה בלבד.
private List<SomeClass> _dotNet20Collection = new List<SomeClass>();
public ReadOnlyCollection<SomeClass> DotNet20Collection
{
get { return _dotNet20Collection.AsReadOnly(); }
}
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
אני מעונין להוסיף קטע קוד שבודק איזו גרסה יש ל Framework במחשב שמריץ אחת מהאפליקציות שלי.
אשמח לקבל דוגמא לקטע קוד ב C# שיוכל לזרוק Exception ברגע שקוד שנוצר על VS2005 מנסה לרוץ על פלטפורמה שאיננה Framework 2 (למשל Framework 1.1)
תשובה:
בקובץ הקונפיגיורציה של האפליקציה שלך יש אלמנט מעניין שלרוב לא מזכירים בשם <startup>.
באלמנט הזה ניתן לפרט אלמנט <supportedRuntime> עם גירסת הפריימוורק שבקונטקסט שלה תרוץ התוכנה שלנו.
הנה דוגמה של האלמנט:
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<startup>
<supportedRuntime version="v1.1.4322"/>
<supportedRuntime version="v1.0.3705"/>
<supportedRuntime version="v2.0.50727"/>
</startup>
</configuration>
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
יש לי פקד CheckBoxList עם מס' פריטים בתוכו.
אני מעוניין שבאירוע מסויים, כמו למשל CLICK, הפריטים ב-CheckBoxList שלא ניבחרו על ידי המשתמש, יימחקו. כתבתי את הקוד הבא:
for(int i = 1;i<CheckBoxList1.Items.Count;i++)
{
if(!CheckBoxList1.Items[i].Selected)
{
CheckBoxList1.Items.Remove(CheckBoxList1.Items[i]);
Label1.Text = CheckBoxList1.Items.Count.ToString();
}
שאני מריץ לולאת for, אני מקבל כל מיני התנהגויות מוזרות וזה בכלל לא עושה מה שרציתי. איך אפשר לעשות כזה דבר?
תשובה:
עדיף להימנע מביצוע לולאות for כאשר הערך עליו שואפים הוא גבול משתנה היות ותיווצר התנהגות בלתי-סדירה (כמו זו שהוצגה בתחילת השרשור).
כמו כן, בלולאות foreach לא ניתן להסיר אלמנטים עליהם עוברים.
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
אני מנסה להבין את איך דוט נט עובדת עם מחלקות שמכילות הצבעות למחלקות אחרות מאותו סוג?
למשל, אני רוצה לבנות עץ היררכי של אזרחי מדינת ישראל כאשר מכל הורה ניתן לנווט לילדים ומכל ילד ניתן לנווט בחזרה להורים.
יש מושג "מצביעים" או תחליף להם בvb.net?האם זו בכלל הגישה הנכונה?
תשובה:
בדוט נט אין מצביעים פר-סה, אלא אנחנו יודעים שאם יש לי משתנה מסוג מחלקה ישאר שם מצביע על הדבר הזה שנקרא זכרון. לעומת זאת, זה לא משנה לנו כי אנחנו לא מטפלים בזכרון. מבחינתנו, כל עוד אני יכול לקבוע שאני מחזיק משתנה מסוג מחלקה ואז אני יכול לגשת אליו זה מספיק טוב לנו.יש מצבים למשל שלא ישמרו מצביעים אלא העתקים על הזכרון (למשל שנעבוד עם Structים ולא עם Classים).
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
במאמר הבא נבנה ביחד אפליקציה שתנצל את היכולות של System.IO ובעיקר עבודה עם כוננים, ספריות, קבצים כיווץ ו-Isolated Storage.
הרעיון מאחורי ה-System.IO Namespace הוא לרכז את כל העבודה מול Streams ולהציע ספרייה מכובדת שמאפשרת עבודה מול ההארד-דיסק.
נתחיל את הפרוייקט שלנו ונפתח Windows application חדש בשם WinSystemIO. בטופס נוסיף Multiline Textbox בשם tbxOutput שלתוכה נדפיס את המידע שלנו במהלך הפרוייקט ונוסיף כפתור שינקה את תיבת הטקסט. נציין שאין שום חשיבות לכך שיצרנו פרוייקט חלונאי ולא פרוייקט ASP.Net היות ו-System.IO פועלת בשניהם אותו דבר.
במהלך המאמר נפתח את האפליקציה עד שנידע לעשות כל אחת מהפעולות הבאות:
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
System.Net.Mail הוא הגירסה בדוט נט 2.0 של System.Web.Mail. כן כן, שמתם לב להבדל - העבירו את זה Namespace משני.
במאמר זה נעבור על כל מה שיש לדעת על System.Net.Mail.
בואו נתחיל מהתחלה. בכל שרת אינטרנט של מיקרוסופט מותקן IIS שזה ה-Internet information services. שמתם לב שהדגשתי את ה-s ב-services? כן, ה-IIS המיקרוסופטי מכיל מספר שירותים אפשריים ולא רק את היכולת להגיש דפי אינטרנט. שלושת השירותים העיקריים שה-IIS מציע הם: הגשת דפי אינטרנט, גישת FTP ושרת SMTP. כולנו מכירים את יכולת הגשת דפי אינטרנט וכולנו פחות או יותר יודעים מה זה FTP ("נו, אתה יודע, זה כמו העתקת קבצים רגילה רק איטי ומתסכל"). אבל מה זה ה-SMTP הזה שהזכרתי?
בפשטות ובקצרה, שרת ה-SMTP המובנה ב-IIS הוא שירות מוכר, ידוע ואמין שמאפשר שליחת דוא"ל. במאמר זה אנחנו נלמד כיצד ניתן לנצל את השירות הזה דרך דוט נט בכדי לשלוח דוא"ל מתוך הישומיים שלנו.
MailMessage myMessage = new MailMessage();
myMessage.To.Add(new MailAddress("J@justinAngel.net", "Justin Angel"));
myMessage.From = new MailAddress("mail@JustinAngel.net");
myMessage.Subject = "simple mail";
myMessage.Body = "hello justin, how are you today?";
SmtpClient mySmtp = new SmtpClient();
mySmtp.Host = "127.0.0.1";
mySmtp.Port = 25;
mySmtp.Send(myMessage);
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
בואו נדבר קצת על ההבדלים בין Struct (להלן: מבנה) ל-Class (להלן: מחלקה). למי שרק עכשיו שומע על מבנה נסביר בתמצות מהו מבנה (מהפן הפרקטי). שאנו כותבים מחלקה חדשה הקוד יראה בערך ככה:
public class ClassName
{
// ...
}
אז שאנחנו עובדים עם מבנה זה יראה ככה:
public struct StructName
{
// ...
}
הבדל ענק נכון? אז אתם, שנתקלים במושג הזה פעם ראשונה או שנתקלתם בו בעבר, כנראה חושבים שהוא מיותר לחלוטין. סתם עוד פדנטיות שמתכנתי הסיפיפי האלו הכניסו לנו לשפה כי הייתה להם חרדת נטישה. אז אני בא ואומר שזה לא המצב. במאמר הזה נראה מה באמת ההבדלים בין מבנה למחלקה, ולא רק מה ההבדלים - אלה נראה איזה כוח עצום טמון במבנים.
פתח מאמר מלא בחלון חדש
|
|
ASP.Net (12)
|
פתח מאמר מלא בחלון חדש
שאלה:
יש לי מערכת די גדולה, ואני משתמשת בה בSessions.
הבעיה היא שה Session מתנהג לי בצורה מאוד לא יציבה, למרות הגדרת הtimeOut ב web.config הוא פג אחרי זמן קצר מאוד של חוסר תזוזה במערכת. וגם- אם אני עושה איזו שהיא פעולה מחוץ למערכת, כמו פעולה על FTP (העברת קבצים, למשל) - כשאני מסיימת את הפעולה הזאת ה sessions פשוט פגים.
תשובה:
Sessions מתאפסים מהרבה מאוד סיבות.
כמה לדוגמה:
1. הגעת לגבול העליון מבחינת זכרון שמוקצה ל-Sessions.
2. ה-AppDomain עצמו של השרת אותחל.
3. ה-Session עצמו פג תוקף ביחס לקריטריונים של השרת.
ויש עוד הרבה סיבות.
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
באפליקציית ASP.Net החיבור ל-DB לא עובד כשמנסים מרחוק, להבדיל מכאשר מנסים לוקלית (F5). למטה יש את הודעת השגיאה: Cannot open database "pubs" requested by the login. The login failed.
Login failed for user 'MOSHE-F91B90F39\ASPNET'.
תשובה:
לפי מה שאתה מתאר סביר להניח שמדובר ב-Impersnation עם Windows Authentcation של ASP.Net בשילוב עם Windows Authentication של סיקוול סרבר.
ל-ASP.Net יש שלושה אפשרויות לזיהוי משתמשים:
סיקוול סרבר מאפשר שתי אפשרויות לזיהוי משתמשים:
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
הוספתי למסך כפתור, שמבצע פוסטבק,
במתודת ה Click של הכפתור (בשרת), אני ניגש ל SelectedValue של ה DropDownList בקונטרול,
אך תמיד אני מקבל את הערך הראשון ברשימה, ולא באמת את הערך שהגולש בחר. מדוע ?
תשובה:
אי-טעינת מידע ViewState או PostBack נגרמת ב-99% מהמקרים ע"י דבר אחד: ה-ID של הפקד שאמור לקלוט את הערכים אינו קבוע ומשתנה בין PostBackים.
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
יש לי User Control שמכיל DropDownList, ויש לי דף שמכיל אותו.
שמתי לב שה Page_Load של המסך רץ לפני ה Page_Load של הקונטרול,
לכן אני לא יכול לאתחל את הקונטרול ב Page_Load של המסך, אלא רק בשלב מאוחר יותר,
למשל OnPreRender של המסך.
האם הבנתי נכון, וכך עושים זאת ?
תשובה:
כ-כלל אצבע, מה שעושים במצבים כאלו שרוצים לגשת לפקדים של Custom Control או User Control שיתכן שקיימים ויתכן שאינם קיימים הם לדאוג שהפקדים קיימים. בתוך כל Property שאתה חושף לפני שאתה ניגש לפקדים עצמם תצטרך לקרוא למתודה EnsureControlsCreated. זאת מתודה שנמצאת בשימוש נרחב בכל מקום שבו כותבים פקדים באמת כדי לוודא שקיימים פקדים לפני שניגשים אליהם מתוך Properties למיניהן שאינן קשורות בישירין לסדר האירועים הדיפולטי של הדף.
public string HeadlineText
{
get
{
EnsureChildControls();
return lblHeadline.Text;
}
set
{
EnsureChildControls();
lblHeadline.Text = value;
}
}
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה: האם שימוש ב-UserControls וב-MasterPages (שהוא למעשה UserControl) גורר פגיעה כלשהי בביצועים?
תשובה:
בדוט נט 2.0 יש אפשרות חדשה שהיא לבצע Precompile לכל האתר עצמו מה שלוקח את קבצי ה-ASPX וה-ASCX שבעבר נותחו רק עם פנייה לדף ומקפמל אותם למחלקות אמיתיות. את ה-Procompile הזה ניתן להגדיר בעת הפריסה של האפליקציה באמצעות Deploy Web Site של Visual Studio 2005 או ניתן להשתמש ב-aspnet_precompile.exe שמגיע עם הפריימוורק ומאפשר לקמפל אתר כאתר או לקמפל אתר לתוך תיקייה שתיפרס במועד מאוחר יותר.
עם ההצגה של מודל הקומפילציה של דוט נט 2.0 אין יותר הבדלים בין כתיבת ASPX/ASCX לכתיבת קוד מבחינת ביצועים.
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
הקביעה של היכולות של הדפדפן שלך נקבעת ע"י הפריימוורק ובהתאם הרנדור.
בדוט נט 1.1 קיים אלמנט <browserCaps> שיושב ברמת ה-machine.config (למרות שגם ניתן לקבוע אותו ברמת ה-web.config) ומכיל את ההתאמה בין המאפיינים השונים של הדפדפן (בעיקר שמו ופילטרים נוספים המבוססים על כך) לבין היכולות של הדפדפן ביחס למה שהפריימוורק צריך לדעת (האם תומך בטבלאות, האם תומך ב-CSS, האם תומך ב-XML, האם תומך בג'אווה סקריפט, האם תומך בעוגיות וכיו"ב).
בדוט נט 2.0 הקונספט הזה השתנה עקב קיומם של כמה אלפי דפדפנים בימינו. מה שנהוג כיום הוא ליצור קבצי browser שמופקים אוטומטית מאתר מיקרוסופט.
<browserCaps>
<case match="^Mozilla/5\.0 \([^)]*\) (Gecko/[-\d]+)(?'VendorProductToken'
(?'type'[^/\d]*)([\d]*)/(?'version'(?'major'\d+)(?'minor'\.\d+)(?'letters'\w*)))?">
browser=Gecko
frames=true
tables=true
cookies=true
javascript=true
javaapplets=true
ecmascriptversion=1.5
w3cdomversion=1.0
css1=true
css2=true
xml=true
tagwriter=System.Web.UI.HtmlTextWriter
</case>
</browserCaps>
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
נתחיל בהגדרה כוללנית, Late Bound Data Expressions מיועדים לקבלת מידע (משתנים) בתצוגת עיצוב ולפרמט אותו לתצורה נבחרת. נעשה פירוש רש“י. ב”קבלת מידע (משתנים)” אנו מתכוונים כל אובייקט המכיל מידע, הכל ממחרוזות, DataReaderים וכלה ב-DataSetים. ב”בתצוגת עיצוב” אנו מתכוונים שבזמן שתמיד ניתן לשנות את תוכן המידע כחלק מה-Code Behind, ה-Late Bound Data Expressions מאפשרים לנו לשנות את המידע בתצוגת ה-Design. ב”פרמט אותו לתצורה נבחרת” אנו אומרים למעשה שאנו נקבל את הנתונים האלו ונגדיר להם אלגוריתם שהם יעברו לפני תצוגה ללקוח.
ישנם שתי שיטות בנויות בדוט נט ל-Late Bound Data Expressions: הראשונה DataBinder.Eval, והשנייה String.Format. שתיהן למעשה מאפשרות לקחת מידע במהלך אירוע ה-OnDataBound ולהציגו או לשנות לו את אופי התצוגה. נסקור את שתי הפונקציות הללו במהלך אפשרויות א' ו-ב'. אם אתם כבר מכירים ומבינים את דרך פעולתם, אני ממליץ שתקפצו ישר לחלק ג'.
<html>
<head>
<title><%# myStr %></title>
</head>
...
</html>
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
במהלך העבודה בכל שפת תכנות מתפתחות תבניות מסויימות שהתפתחו עם הזמן והניסיון של תכנתנים רבים. התבניות האלו מאופיינות על פי שהם עונות על צורך\בעיה מסויימת בצורה שעם הזמן הפכה להיות מקובלת על כלל התוכניתנים. השם המקצועי שלהן הוא - Design Patterns.
אחת מה-Design Patterns האלו היא Connection Design Pattern של דוט נט שהתפתחה עם הזמן וכיום מאוד מקובלת בעולם הדוט נט. אאל”ט היא שייכת לקבוצת ה-Behavioral Design Patterns. אפשרי שבין פתיחת חיבור למסד הנתונים ועד סגירתו תעלה שגיאה, מה שישאיר את החיבור פתוח עד לאתחול תהליך השרת (aspnet_wp.exe).
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שלום לכולם,
במאמר נערוך סקירה על מגוון האפשרויות לשמירה של קונפיגיורציה לאפליקציות (Application Configuration) בתוך קובץ ה-web.config.
שתי השאלות הראשונות שנשאל הן: מהי קונפיגיורציה אפלקטיבית? ומדוע לשמור ב-web.config?
ישנם נתונים בכל אפליקציה שאין צורך או יכולת לשמור במסד נתונים, למשל: רשימת סוגי מוצרים ואת מחרוזת החיבור למסד הנתונים. נהוג לשמור את מרבית הנתונים מהסוג הזה בקובץ XML חיצוני שיושב באפליקציה. ניצמד לדוגמאות שהעלינו קודם: רשימת סוגי מוצרים ומחרוזת חיבור. אופציה א': appsettings
<configuration>
<appSettings>
<add key="DataBaseConnectionString" value="data source=ServerName; initial catalog= Northwind;" />
</appSettings>
</configuration>
אופציה ב': Custom Web.config tags, configSections
<configSections>
<section name="Production" type="System.Configuration.NameValueSectionHandler" />
<section name="Development" type="System.Configuration.NameValueSectionHandler" />
</configSections>
<Production>
<!-- קונפיגיורציה לריצה -->
<add key="BackGroundColor" value="blue" />
<add key="FontColor" value="white" />
</Production>
<Development>
<!-- קונפיגיורציה לפיתוח -->
<add key="BackGroundColor" value="white" />
<add key="FontColor" value="black" />
</Development>
אופציה ג': sectionGroup
<configSections>
<sectionGroup name="SvivotPitoch">
<section name="Riza" type="System.Configuration.DictionarySectionHandler" />
<section name="Pitoch" type="System.Configuration.NameValueSectionHandler" />
<section name="Testing" type="System.Configuration.NameValueSectionHandler" />
</sectionGroup>
</configSections>
אופציה ד': XmlNode, CustomHandlers
<configSections>
<section name="Enviorments" type="ProjectNameSpace.XmlNodeSectionHandler, ProjectNameSpace" />
</configSections>
<Enviorments>
<Development>
<BackGroundColor>blue</BackGroundColor>
<FontColor>white</FontColor>
</Development>
<Production>
<BackGroundColor>white</BackGroundColor>
<FontColor>black</FontColor>
</Production>
</Enviorments>
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
טעות נפוצה שאני נתקל כאשר אני עובר על קוד של תוכניתנים אחרים זה בלבול בנושא תכונת ה-ReadOnly של TextBox. מאיזהשהי סיבה, תוכניתנים יוצאים מנקודת הנחה שברגע שהם כתבו ReadOnly אז המשתמש באמת לא יוכל לערוך את התוכן של תיבת הטקסט.
נלחץ על הכפתור, נגרום ל-PostBack ונקבל את התמונה הבאה:
מה שקיבלנו זה שקביעת TextBox עם תכונת Readonly=true למעשה אינו מגן על הערך מפני שינוי בצד לקוח ולאחר מכן בצד שרת. השרת לוקח את ערך תיבת הטקסט מתוך הנתונים אשר הלקוח שולח לשרת ולא מתוך נתוני השרת.
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
Response.recdirect ו-Server.transfer לכאורה מבצעות אותה פעולה, אך יש הבדלים מהותיים בעבודה של שני המתודות הללו. לא מדובר רק על העברה בין דף לדף, אלא על היכן העברה מתרחשת, מה היכולות שלה וכיצד המשתמש יקלוט אותה.
ישנן מספר הבדלים שנצטרך להיות מודעים עליהם: תחבירית, הבדלים בקונספט, שימור נתוני הטופס, העברה בצד לקוח מול העברה בצד שרת.
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
sessionState מאפשר זיהוי ומעקב על פני מספר webforms של משתמש מסויים. דוגמאות טובות הן: לעקוב אחרי הרשאות למערכת (למשל, Login), לעקוב אחרי שינויים במצב העבודה של המשתמש עם האפליקציה (למשל, עגלת קניות), לעקוב אחרי אופן הגלישה של משתמש באתר ומאוחר יותר לנתח את הממצאים כדי להראות הרגלי גלישה באתר.
ספציפית במאמר זה נתמקד באפשרויות השונות לשימוש ב-sessionState כפי שהן באות לכדי ביטוי ב-web.config ו-machine.config:
1. כבוי
2. InProc כחלק מ-aspnet_wp.exe (או w3wp.exe)
3. OutProc / State Server
4. סיקוול סרבר
פתח מאמר מלא בחלון חדש
|
|
ASP.Net 2.0 (15)
|
פתח מאמר מלא בחלון חדש
שאלה:
לא נראה לי שכאן מתאים להשתמש בפקד ה-Menu של ASP.Net 2.0.
את כל מבנה התפריטים אני שומר ב-DB מה שמכריח אותי בזמן ריצה ליצור "ידנית" Menu Nodes על פי ערכים מה-DB.
תשובה:
להפך, זה בדיוק המצב שלשמו נבנה ASP.Net 2.0.
אחת מהבשורות הגדולות של ASP.Net 2.0 היא מה שנקרא מודל ה-Providers.
הרעיון אומר ככה "אנחנו נספק לכם אפשרויות ברירת מחדל למקורות מידע של בעיות נפוצות ואתם תוכלו להחליף אותם אם תצטרכו".
למשל, זיהוי משתמשים (Membership), תפקידים (Roles), מידע עסקי על משתמשים (Profiles), קיסטום של WebParts ע"י משתמשים ופירוט מבנה האתר (SiteMap).
<siteMap>
<providers>
<add siteMapFile="web.sitemap" name="AspNetXmlSiteMapProvider" type="System.Web.XmlSiteMapProvider, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
</providers>
</siteMap>
לכל אחד מאלו ולמספר נוספים יש Provider.
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
אני רוצה תפריט מגניב ב-ASP.Net 2.0 שיהיה מותאם לתצוגה בעברית.
התפריט צריך להיות דינמי (להציג את החלקים הרלוונטיים בתפריט רק לפי מיקום העכבר על ההורה) וצריך להיות כמה שיותר סטדנרטי.
למישהו יש רעיונות?
תשובה:
בעקבות שני שינויי ה-CSS קטנטנים, נוכל לקבל תפריט דינמי שתומך בעברית.
 
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
יש לי FormView WebControl ואני רוצה להכניס ערכים מתוך קובץ XML שיוצגו בתוכו. כיצד ניתן לעשות זאת?
תשובה:
נגעת בנושא מאוד מעניין שהוא המשך ישיר של הפוסט הזה:
Question from .Net Tapuz Forum: Using the ASP.Net Menu WebControl with XmlDataSource
כלומר, הגענו עכשיו למצב שאנחנו יודעים שאפשר להכניס ביטוי XPath לתוך XmlDataSource, אבל אנחנו בבעיה נוספת עכשיו איך אני יכול להשתמש בו בפקדים עם Templateים?
<asp:FormView ID="FormView1" runat="server" DataSourceID="XmlDataSource1">
<ItemTemplate>
price:
<asp:Label Text='<%# XPath("price") %>' runat="server" ID="Label1" /><br />
name:
<asp:Label Text='<%# XPath("title") %>' runat="server" ID="Label2" /><br />
name:
<asp:Label Text='<%# XPath("title/@lang") %>' runat="server" ID="Label3" /><br />
</ItemTemplate>
</asp:FormView>
<asp:XmlDataSource ID="XmlDataSource1" runat="server" DataFile="~/XMLFile.xml" XPath="bookstore/book">
</asp:XmlDataSource>
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
אני רוצה להוסיף עמודת קישור mailto ל-GridView אבל שאני מוסיף את הקוד הבא אני מקבל טקסט רגיל :
<asp:HyperLinkField DataTextField="Email" HeaderText="דוא'ל" DataNavigateUrlFields="Email" DataNavigateUrlFormatString="mailto:{0}" />
מה צריך לעשות כדי שהכתובת דוא"ל ב-Email יופיעו כקישורי mailto?
תשובה:
שאלה מאוד טובה ובאמת התשובה מעניינת.
נסביר את הבעיה קצת יותר לעומק, בואו נניח ויש לי את הקישור הבא <asp:HyperLink ID="HyperLink1" runat="server" NavigateUrl="mailto:J@JustinAngel.Net">HyperLink</asp:HyperLink>
במצב הזה הקישור יתרנדר לקישור רגיל לכל דבר שברגע שנלחץ עליו הדפדפן שלנו יפתח את תוכנת הדוא"ל שלנו עם אי-מייל שמכוון ל-J@JustinAngel.Net.
נרצה שה-GridView שלנו ירנדר לינקים מסוג Mailto.
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
אם ב-GridView של ASP.Net 2.0 אין בכלל ערכים להציג, אז ה-GridView עצמו אינו מוצג כלל.
האם ניתן להציג כותרת טבלה בלבד? מה נהוג לעשות במצב הזה?
תשובה:
מדובר בפיצ'ר מאוד חזק של GridView שהשתנה מאז ימי ה-DataGrid של 1.1.
בדוט נט 1.1 כל פעם של-DataGrid לא היה מידע להציג הוא היה מציג את ה-Header של הטבלה. מה שנראה מאוד מוזר כי יש לך כותרת לטבלה שאין בה שום תוכן.
אם את רוצה לחזור לאותו מצב שהיה בדוט נט 1.1 תצטרכי להוסיף שורה חדשה וריקה למקור המידע של ה-GridView.
כלומר, בסופו של דבר את כן תוסיפי שורת מידע כי אחרת באמת ה-GridView לא ירנדר את הכותרת.
תתפסי את הרנדור של השורת מידע הזו ותקבעי שהיא לא תתרנדר אצל הלקוח.
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
יש אפשרות להוסיף javascript ב Data Grid?
נגיד ואני רוצה לעשות onmouseover בטבלת Data Grid שמקושרת לdatabase ושזה יסמן לי שורה בכל פעם שהסמן עובר, אפשר לעשות כזה דבר?
תשובה:
protected void GridView1_RowCreated(object sender, GridViewRowEventArgs e)
{
if (e.Row.RowType == DataControlRowType.DataRow)
{
e.Row.Attributes.Add("onmouseover", "this.style.backgroundColor = 'Pink';");
e.Row.Attributes.Add("onmouseout", "this.style.backgroundColor = 'White';");
}
}
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
האם כדאי לעבוד עם Themes ב-ASP.Net 2.0?
מה הנסיבות בהן אתם משמתמשים בהם?
האם הם גורמים לפגיעה בביצועים?
תשובה:
יצא לי לעבוד עם themes עוד מהגרסאות היותר מוקדמות של ASP.Net 2.0 ובהחלט מדובר בכלי עבודה מאוד חזק.
למי שלא מכיר Themes ורוצה להשתתף בדיון:
Visual Studio .Net 2005 - מצגת Webcast שלי בנושא Themes
בהחלט לא תהיה איזהשהי פגיעה בביצועים (של שום דבר) היות ומדובר על אסמבליס מקומפלות לכל דבר שסה"כ מכילות מספר תנאים ברמת ה-Adapter של הדף. הנושא עבר אופטימיזציה מאוד חזקה והטמעה ברמות מאוד גבוהות של הפריימוורק.
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
לא ניתן לשתף באופן ישיר משתנים בין MasterPage והדפים שמתמשים בו(כלומר לגשת מדף X למשתנה שנמצא ב - MasterPage שלו),
יש כל מיני חלטורות כאלו (לדוגמה לשתף עם Session או כל מיני דברים מסובכים), האם מישהו מכיר פתרון קל, נוח ויעיל לנושא
תשובה:
הבעיה הראשונה היא דווקא בעיה מאוד מעניינת ומאוד נפוצה - עבודה מול MasterPage מתוך הדף (Page) שלנו.
נחשוף מאפיין (גם באנגלית: Property) מתוך ה-MasterPage שיאפשר לשנות את הטקסט של ה-Label:
public string HeadlineText
{
get
{
EnsureChildControls();
return lblHeadline.Text;
}
set
{
EnsureChildControls();
lblHeadline.Text = value;
}
}
הדף שלנו (Content2.aspx) נמיר את ה-MasterPage שלו לטיפוס MasterPage שלנו ואז ניגש למאפיין.
public partial class Content2 : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
MasterPage myMasterPage = (MasterPage)this.Master;
myMasterPage.HeadlineText = "www.JustinAngel.Net";
}
}
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
הפתרון הנכון במקרה הזה הוא עבודה עם מאפיינים. נגיד ויש לנו טופס Content1.aspx שיש בו כפתור ואנחנו רוצים לגלות מה הטקסט של הכפתור בדף Content2.aspx שאליו נבצע Cross Page PostBack. ברמת Content1 נחשוף מאפיין שיציג את הטקסט של הכפתור שאותה ינצל Content1.
public partial class Content1 : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
}
public string ButtonText
{
get
{
return Button1.Text;
}
}
}
בטעינה ב-Content2 נבדוק שבאמת מדובר ב-Cross Page PostBack ואם כן ניקח את הדף הקודם ונמיר אותו לסוג Content1 ובכך נקבל גישה למאפיין החדש שלנו.
public partial class Content2 : BasePage
{
protected void Page_Load(object sender, EventArgs e)
{
if (this.PreviousPage != null)
{
Content1 myPreviousPage = (Content1)PreviousPage;
Reponse.Write(myPreviousPage.ButtonText);
}
}
}
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
הקביעה של היכולות של הדפדפן שלך נקבעת ע"י הפריימוורק ובהתאם הרנדור.
בדוט נט 1.1 קיים אלמנט <browserCaps> שיושב ברמת ה-machine.config (למרות שגם ניתן לקבוע אותו ברמת ה-web.config) ומכיל את ההתאמה בין המאפיינים השונים של הדפדפן (בעיקר שמו ופילטרים נוספים המבוססים על כך) לבין היכולות של הדפדפן ביחס למה שהפריימוורק צריך לדעת (האם תומך בטבלאות, האם תומך ב-CSS, האם תומך ב-XML, האם תומך בג'אווה סקריפט, האם תומך בעוגיות וכיו"ב).
בדוט נט 2.0 הקונספט הזה השתנה עקב קיומם של כמה אלפי דפדפנים בימינו. מה שנהוג כיום הוא ליצור קבצי browser שמופקים אוטומטית מאתר מיקרוסופט.
<browserCaps>
<case match="^Mozilla/5\.0 \([^)]*\) (Gecko/[-\d]+)(?'VendorProductToken'
(?'type'[^/\d]*)([\d]*)/(?'version'(?'major'\d+)(?'minor'\.\d+)(?'letters'\w*)))?">
browser=Gecko
frames=true
tables=true
cookies=true
javascript=true
javaapplets=true
ecmascriptversion=1.5
w3cdomversion=1.0
css1=true
css2=true
xml=true
tagwriter=System.Web.UI.HtmlTextWriter
</case>
</browserCaps>
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה: האם שימוש ב-UserControls וב-MasterPages (שהוא למעשה UserControl) גורר פגיעה כלשהי בביצועים?
תשובה:
בדוט נט 2.0 יש אפשרות חדשה שהיא לבצע Precompile לכל האתר עצמו מה שלוקח את קבצי ה-ASPX וה-ASCX שבעבר נותחו רק עם פנייה לדף ומקפמל אותם למחלקות אמיתיות. את ה-Procompile הזה ניתן להגדיר בעת הפריסה של האפליקציה באמצעות Deploy Web Site של Visual Studio 2005 או ניתן להשתמש ב-aspnet_precompile.exe שמגיע עם הפריימוורק ומאפשר לקמפל אתר כאתר או לקמפל אתר לתוך תיקייה שתיפרס במועד מאוחר יותר.
עם ההצגה של מודל הקומפילציה של דוט נט 2.0 אין יותר הבדלים בין כתיבת ASPX/ASCX לכתיבת קוד מבחינת ביצועים.
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
Metadata file 'C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\Temporary ASP.NET Files\my_proj\ce601211 \9d5d0aae\App_WEB_header.ascx.asdf7d2.vcvdd1d.dll' could not be found"
אני מקבל את השגיאה הזאת כשאני מנסה לקמפל את האתר ASP.Net 2.0 שלי.
החלק המוזר הוא - שאם אני לוחץ F5 ומריץ את האתר השגיאה פשוט נעלמת והפרוייקט רץ בסדר.
הבעיה היא שקיימת הגבלה ברמת הקונפיגיורציה של הפריימוורק על מספר הגרסאות השונות של ASP.Net Page Assmebly שניתן לטעון במהלך אותו תקופת חיים של הפרוסס של ה-IIS. ההגבלה הזאת נובעת מהצורך של ה-IIS לבצע אופטימיזציה בזכרון ביחס לכמות הגרסאות השונות של האסמבלי של אותו דף שהוא ידרש לטעון.
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
פקד ה-Menu החדש של ASP.Net 2.0 מאפשר להציג תפריט של אתר. ניתן לקשר את הפקד לקבצי XML באמצעות XmlDataSource. האם יש הגבלות על המבנה של קבצי ה-XML?
<asp:menuitembinding datamember="MapHomeNode"
depth="0"
ImageUrlField = "myImageUrlXmlNode"
NavigateUrlField ="myLinkUrlXmlNode"
TextField= "myDisplayTextXmlNode"
ToolTipField = "myTooltipXmlNode"
ValueField = "myValueXmlNode" />
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
מה זה WebParts? איפה יש דוגמה אמיתית לשימוש ב-WebParts? מה זה WebPartManager? מה אלו WebPartZones? איך אני מאחסן מידע של WebParts? מה זה CatalogZone? מה זה DeclarativeCatalogPart? מה זה ImportCatalogPart? מה זה PageCatalogPart? מה אלו EditZones? מה זה BehaviorEditorPart? מה זה LayoutEditorPart? מה זה ApperenceLayoutEditorPart? מה זה PropertyGridEditorPart? מה הם Connections בין WebParts? מה הם Static Connection ואיך הם עובדים? מה הם Dynamic Connection ואיך הם עובדים? איך בונים User Control כ-WebPart? איך שומרים מידע יחודי לכל משתמש? איך משלבים WebParts עם MasterPages? האם WebParts עובדים בדפדפנים אחרים? הפעם במקום מאמר של 50 עמודים, החלטתי על פורמט קצת שונה.
עשיתי WebCast באורך שעתיים על מנגנון ה-WebParts החדש ב-ASP.Net 2.0.
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
מהן Themes? איך אפשר להשתמש בהן? למה לא השתמשו בהן בדוט נט 1.1? כיצד ניתן לבנות Theme? מה אפשר לעשות איתן? איך מחליפים צבעים עם Themes? איך מחליפים תצוגה של תמונות? איך גורמים למבנה שונה בפקדים? כל זאת ועוד בהמשך. אז לפניכם: Visual Studio .Net 2005 Themes Webcast
פתח מאמר מלא בחלון חדש
|
|
Deployment (3)
|
פתח מאמר מלא בחלון חדש
I've recently been asked by a company I'm working with to make a short list of real-world application that use ClickOnce for deployment over the Internet.
Here's what I came up with: (more in the full article)
...
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
פיתחנו אפליקציה שנפרסת דרך אינטרנט מקומי במשרד.
אך כאשר אנו מריצים אותה אנחנו מקבלים SecurityException.
לפי MSDN צריך לתת לאסמבלי Full-Trust וזה איכשהו קשור ל-ClickOnce. מישהו יכול להרחיב בנושא?
תשובה:
ישנן שלוש אפשרויות: לתת ידנית Full-Trust לאפליקציה, להשתמש ב-Full Trust דרך פריסת Clickonce, או לתת Full Trust באמצעות caspol בהתקנה באמצעות קבצי MSI.
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
מה המשמעות של מפתח SNK שיוצרים Strong-Named Assembly, ומה המשמעות של המחרוזת שהוא מייצר?
האם מומלץ להכניס את קובץ ה snk לתוך ה solution?
ראיתי שבמאפיינים של הפרוייקט יש חוצץ signing או משהו בסגנון ושם גם אפשר לציין את קובץ ה snk ע"י GUI ולא ע"י קוד, מה ההבדל?
האם יש דרך אחרת מלבד זו שציינתי להזין את ה public key? לדוגמא לרשום ישירות את ה key במקום להפנות לקובץ?
פתח מאמר מלא בחלון חדש
|
|
Microsoft AJAX (8)
|
פתח מאמר מלא בחלון חדש
שאלה:
אני צריך להציג מידע ברשימה ממויינת אפלבתית.
בשביל זה בחרתי לעבוד עם PagingBulltedList של AJAX Control Toolkit.
איך אפשר לגרום לרשימה להציג את הסימן "#" שעל פיו יסנן את כל המספרים?
איך אפשר לקבל הודעה שהמשתמש בוחר אינדקס מסויים ולדעת איזה אינדקס נבחר?
להדגמה חיה ניתן ללחוץ כאן - http://ajax.asp.net/ajaxtoolkit/PagingBulletedList/PagingBulletedList.aspx.
תשובה:
השאלה הזו נוגעת לבדיוק כיצד ראוי לעבוד עם AJAX Control Toolkit כאשר צריך להרחיב אותו ולשנות את ההתנהגות הקיימת.
BulltedList תוצג בצד לקוח כך: (לאחר שנלחץ על E)
לחיצה על האות O למשל תגרום לסינון חדש:
אנחנו רוצים שתוצג כך:
מתי נשנה בזמן ריצה ומתי נדאג לקמפל מחדש את ה-AJAX Control toolkit?
פתח מאמר מלא בחלון חדש
|
|
Open full article in new window
Let's say I've got a Windows Forms project and I want to add a new WinForm:
When I click the magical "Windows Form" button on the menu one would expect I would be able to create a new Windows Form Item. This is what you get if you have Script# Installed:
Open full article in new window
|
|
פתח מאמר מלא בחלון חדש
שאלה:
אני עובדת עם Microsoft AJAX ומחזירה מהשרת ללקוח Enumים. הבעיה היא שבמקום להעביר ללקוח את הטקסט של ה-Enum אנחנו מקבלים את האינדקס של הערך הנבחר.
אפשר לשנות את ההתנהגות הזו שיעביר את הטקסט של הערך? אולי בצמוד לאינדקס?
תשובה:
לאחר מעט עבודה נוכל לגשת למאפיינים name ו-value בצד לקוח בג'אווה סקריפט.
<script type="text/javascript">
function UseEnum()
{
PageMethods.ReturnMyEnum(onReturnMyEnum);
}
function onReturnMyEnum(result)
{
alert( result.value + " " + result.name);
}
</script>
ואם נריץ עכשיו את הדף נקבל:
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
משהו לא ברור לי איך UpdatePanel עובד עם ViewState.
אם ב-ViewState נשמר המצב של פקדי ה-Web שלנו, ואנחנו משנים את המצב הזה במהלך ריצת הדף, איך זה שה-ViewState חוזר לשרת אין חזרה למצב המקורי?
תשובה:
בואו נבין מה אנחנו רואים כאן עכשיו - אחרי ה-Slient PostBack ה-ViewState הכתוב ב-Source של הדף הוא עדיין אותו ViewState בטעינת הדף. (הרי הדף לא מתפרשרש)
אז איך השרת יודע אחרי ה-PostBack האמיתי והמלא שהערך של ה-Text של ה-Label הוא "I was changed by postback"?
נתקין תוכנה קטנה בשם Fiddler מבית מיקרוסופט שמטרתה היא לעקוב אחרי ה-Request וה-Response מהדפדפן.
נבצע את שלב א' עוד פעם (נטען את הדף מחדש).
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
אני כותב ממשק הזנה לDB. משתמש ב gridview. עם asp.net2.
יש רשימת לקוחות ולכל לקוח יש רשימת פרוייקטים. כשבוחרים לקוח רשימת הפרוייקטים מסתננת לפי הבחירה.
מה הדרך הכי טובה להשתמש ליישם סינון אינטרקטיבי?
תשובה:
ב-Microsoft AJAX קיים פקד חדש בשם UpdatePanel. בדיוק כמו Panel רגיל הוא מכיל בתוכו פקדים אחרים, אך בנוסף ליכולות של Panel רגיל יש לו יכולות AJAXיות.
כל פקד שנמצא בתוך ה-UpdatePanel יכול להתרפרש בצורה דינמית ע"י טריגרים מסויימים.
<asp:UpdatePanel ID="UpdatePanel1" runat="server">
<Triggers>
<asp:AsyncPostBackTrigger ControlID="DropDownList1" EventName="SelectedIndexChanged" />
</Triggers>
<ContentTemplate>
<asp:GridView runat="server" ID="GridView1" />
</ContentTemplate>
</asp:UpdatePanel>
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
בשעת הלחיצה אני יוצר thread שמפעיל פונקציה במחלקה אחרת , לפני הפעלת ה thread אני מגדיר delegate + ManualResetEvent ,עכשיו המשתמש יכול מצידו לסגור את הדף הזה אך כמובן להשאר באפליקציה.
הבעיה שלי היא שאני לא יודע באיזהאני אני אוכל לתפוס את הEvent שה Thread סיים ולהציג למשתמש הודעה?
תשובה:
בוא ננסה רגע להגדיר את הבעיה מחדש, אתה רוצה לבצע פעולה "כבדה" בשרת ולהודיע ללקוח בדפדפן כאשר היא הסתיימה.
כל זה בלי לתקוע את הלקוח או השרת (כלומר, אסינכרוניות כפולה), ובתוך ההגבלה שאם הלקוח סוגר את הדפדפן או פשוט עובר דף כי לא מעניין אותו יותר אז אין למי לשלוח תגובה (עקב הגבלות של פרוטוקול HTTP).
Microsoft AJAX עושה בדיוק את מה שאתה מבקש.
AJAX מאפשר לך גישה א-סינכרונית לצד שרת למתודות ברמת הדף או ב-Webservice והוא דואג לביצוע הא-סינכרוני.
// in myPage.aspx
<asp:Button ID="btn1" runat="server" OnClientClick="CallPageMethod(); return false;" />
<script type="text/javascript">
function CallPageMethod()
{
PageMethods.DoSomeHeavyLifiting(onFinishedHeavyLifting);
}
function onFinishedHeavyLifting(result)
{
alert(result);
}
</script>
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
יש לי אתר שעובד עם תגיות <iframe> ב-HTML שמחקה התנהגות של טאבים בדפדפן של הלקוח. הייתי רוצה לבנות אותו טוב יותר, מה הייתם ממליצים לעשות?
תשובה:
נשאלת השאלה הבאה: אם אתה רוצה שפעולת שינוי הטאב תהיה שקופה למשתמש או שהיא תדרוש PostBack?
אם אתה רוצה שהיא תדרוש PostBack באמת תוכל לעבוד עם פקד MultiView וסט כפתורים שכל אחד מהם יגרום ל-ActiveViewIndex של ה-MultiView להשתנות בהתאם.
ככה הלקוח בדפדפן שלו לוחץ על כפתור, הלחיצה על הכפתור רצה בחזרה לשרת עם כל הדף, משנה את ה-View הפעיל ב-MultiView והכל חוזר ללקוח מרונדר ויפה. השילוב בין ה-MultiView ובין הסט כפתורים שכל אחד מהם קובע אינדקס אחר ושונה מצדיק לשים את שניהם כחלק מפקד משותף (או Composite Control או User Control) ולהשתמש רק באחד מהם. הפקד עצמו לא מסובך מדי, אבל אם תבחר לכתוב אותו בקוד בלבד (Composite Control) אתה תאבד את היכולת להוסיף Templateים של קוד ASP.Net כ-Viewים. כדי להוסיף Viewים בצורה הזו תצטרך או לרשת את View וליצור את ה-Viewים שלך כ-Custom Controls או לחשוף מחדש יכולת לערוך Templateים.
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
מה הדרך הנכונה לבנות אפליקציה אינטרנטית סטייל GMAIL,
שבה כל הניווט והפעולות באתר מתבצע בצורה שקטה ?
תשובה:
האפשרות היותר מתוחכמת היא לעבוד עם AJAX אמיתי, ספציפית עם Microsoft AJAX Libary (לשעבר: אטלס).
קיים אלמנט בשם UpdatePanel שהקונספט מאחוריו הוא לאפשר מה שנקרא PartialRendering, שזה רנדור מחדש של כל הפנאל בלי לגרום לרנדור מחדש של כל הדף. אם אתה רוצה "ניווט שקט" "סטייל GMAIL" תוכל להכניס את כל התוכן של האתר לתוך UpdatePanel.
פתח מאמר מלא בחלון חדש
|
|
Silverlight (7)
|
Open full article in new window
Question:
I am using Blend to create Silverlight application. But Silverlight is behaving quite strange.
I have installed Silverlight alpha refresh. When I browse other sites with silverlight content I can view them without any issue. However when I try to execute my application from blend it opens the browser and just displays the logo to download Silverlight.
Answer:
Let's get it clear on what the problem is before we solve it.
Working with Silverlight today we often see these buttons prompting us to download Silverlight when opening an existing Silverlight application:
  
There are some reported cases of customers clicking these buttons, downloading Silverlight, installing it and still seeing these "Please install Silverlight" notices. Which is to say the least - highly problematic.
Open full article in new window
|
|
Open full article in new window
Question:
I've got this XAML code in my application:
<Canvas Height="25" Width="75" Canvas.Top="250" Canvas.Left="250" Background="LightGray">
<TextBlock Width="75" FontSize="12" Text="This is a long line"></TextBlock>
</Canvas>
Problem is eventually the text goes beyond border of canvas. Ideally I want text string be cut right by canvas border.
I though about using text wrapping. But the TextBlock would wrap the text and continue on next line which is outside of canvas as well.
Does anyone know how to do that with Silverlight?
Answer:
If you need an absolute border on a TextBlock just add a Clipping region around it.
Open full article in new window
|
|
Open full article in new window
Presenting - Silverlight 1.1 Hebrew & Arabic Language Support.
Since I've started working on Silverlight projects in Israel I've got one constant request from every customer - "We need Hebrew support!".
So, we developed a Silverlight component that enables just that - Hebrew & Arabic Right-to-left & Align-to-right support.
* www.Codeplex.com/SilverlightRTL - The codeplex project page
* www.JustinAngel.Net/SilverlightRTL - online demo & lab
* http://ttvv.tv/users/publicftp/justinangel/SilverlightRTL.wmv - A webcast showing everything done in this article
Standard hello world examples
This is how we would expect each "hello world!" sample to render: (using the browser rendering engine)
שלום עולם!
????? ????!
hello world!
As we can all see - English text is aligned to left and is written Left-to-Right (LTR).
But Hebrew & Arabic are written aligned to right and are written Right-To-Left (RTL).
However, when running the Silverlight 1.1 application in the browser we get this:
Open full article in new window
|
|
Open full article in new window
Question:
Is possible to create a context menu with Silverlight 1.1 and override or extend the currently context menu with Silverlight configuration?
Answer:
First let's explain the problem further. Silverlight doesn't have an event to catch a mouse right click. Here's the official list of Mouse events in Silverlight (from the SDK):
And if we right click on a Silverlight application we'll get this normal context menu:
Open full article in new window
|
|
Open full article in new window
Changes from V1.0 to V1.1:
1. Smaller Javascript files. (roughly 50% in actual file size)
2. Strongly typed Attached properties
3. Enum support.
4. getHost() support
5. exposed the inner Xaml element.
Open full article in new window
|
|
Open full article in new window
Silverlight is like the wild wild west.
Everyone code however they want, Every new discovery is like virgin territory and everything has that new car smell.
Most samples of Silverlight out there today are procedural based and not Object-Oriented.
We're all so wrapped up in making shiny snazzy samples that we forgot those weird alien like concepts "Don't repeat yourself" and "Blob"/"Big Hairy Object"/"God object".
Don't Repeat Yourself (DRY, also known as Once and Only Once) is a process philosophy aimed at reducing duplication, particularly in computing. The philosophy emphasizes that information should not be duplicated, because duplication increases the difficulty of change, may decrease clarity, and leads to opportunities for inconsistency.
http://en.wikipedia.org/wiki/Don%27t_repeat_yourself
The basic idea behind structured programming is that a big problem is broken down into many smaller problems (divide and conquer) and solutions are created for each of them. God object–based code does not follow this approach. Instead, much of a program's overall functionality is coded into a single object. Because this object holds so much data and has so many methods, its role in the program becomes God-like (all-encompassing).
http://en.wikipedia.org/wiki/God_object
Open full article in new window
|
|
Open full article in new window
We are sure to get intellisense for Canvas.
Wait, What??? No intellisense for Canvas?
Well, I'd like to print out the background color of our Canvas.
So what will we write?
hmm.. well, I guess I can work without intellisense and write something up.
Ok, We need Silverlight Javascript Intellisense!
Open full article in new window
|
|
Sql Server (2)
|
פתח מאמר מלא בחלון חדש
שאלה:
באפליקציית ASP.Net החיבור ל-DB לא עובד כשמנסים מרחוק, להבדיל מכאשר מנסים לוקלית (F5). למטה יש את הודעת השגיאה: Cannot open database "pubs" requested by the login. The login failed.
Login failed for user 'MOSHE-F91B90F39\ASPNET'.
תשובה:
לפי מה שאתה מתאר סביר להניח שמדובר ב-Impersnation עם Windows Authentcation של ASP.Net בשילוב עם Windows Authentication של סיקוול סרבר.
ל-ASP.Net יש שלושה אפשרויות לזיהוי משתמשים:
סיקוול סרבר מאפשר שתי אפשרויות לזיהוי משתמשים:
פתח מאמר מלא בחלון חדש
|
|
Open full article in new window
Files for download:
Open full article in new window
|
|
Validation Application Block (15)
|
פתח מאמר מלא בחלון חדש
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
נכניס גיל חשפנית שהוא קטן מ-17 ונראה דבר דומה:
ולאחר לחיצה על כפתור ה-submit נראה ש:
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
אז עכשיו ניקח את הקוד הפשוט, הקל והקריא הבא ונהפוך אותו ללא קריא בעליל עם VAB (קיצור: Validation Applicatin Block):
Console.Write("Please enter stripper's name: ");
string StripperName = Console.ReadLine();
if (string.IsNullOrEmpty(StripperName))
Console.WriteLine("no stripper name supplied");
יהפוך ל
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
נניח שאנחנו מנהלים מועדון חשפנות.
יש לנו אפליקציה שהיא אפליקציית Console, או אפליקציית WinForms או אפילו אפליקציית ASP.Net.
אנחנו רוצים עכשיו כמטרת על "לקלוט חשפנית חדשה". נרצה לקלוט שם חשפנית ואת הגיל שלה. בפרוייקט Winforms ניצור טופס חדש בשם NewStripper עם שתי Labels, שתי Textboxs וכפתור.
בפרוייקט ASP.Net ניצור טופס NewStripper.aspx זהה:
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
בתחילת שנות ה-2000 נהוג היה לייצג את המשתמש בתרשימי UML אי-אלו בדמות הבאה ![image_thumb[11]](http://blogs.microsoft.co.il/blogs/justinangel/WindowsLiveWriter/LearningValidationApplicationBlockWithSt_121A9/image_thumb%5B11%5D_thumb.png) , לקראת שנת 2005 שנינו את הפרספקטיבה ל-![image_thumb[10]](http://blogs.microsoft.co.il/blogs/justinangel/WindowsLiveWriter/LearningValidationApplicationBlockWithSt_121A9/image_thumb%5B10%5D_thumb.png) והיום בעידן האופיס 2007 המשתמש נראה כך ![image_thumb[9]](http://blogs.microsoft.co.il/blogs/justinangel/WindowsLiveWriter/LearningValidationApplicationBlockWithSt_121A9/image_thumb%5B9%5D_thumb.png) .
תרשו לי להציג דמות אחרת למשתמש:
כן - קוף, שימפנזה, אורנג-אוטנג, למור וקופיפים באשר הם.
נהוג לחשוב על בני-אדם כאינטלגנטיים, זוהי טעות שמקורה בנתינת יותר מדי קרדיט לזן מתקדם של קופים.
את המשפט הבא למד על בשרו כל מתכנת, ארכיטקט, ראש צוות ומנהל פרוייקט:
המשתמש טיפש או מניאק
פתח מאמר מלא בחלון חדש
|
|
Winforms (7)
|
פתח מאמר מלא בחלון חדש
שאלה:
יש לנו טופס Winforms שפותח דף Web (שהוא HTML קלאסי) שאנחנו פיתחנו.
היינו רוצים שה-Javascript בדף HTML יוכל להעביר מסרים לטופס Winforms ושזה יגיב.
אנחנו גם צריכים שה-Winforms יעביר ל-Javascript נתונים נוספים.
יש כלי מובנה ב-Framework לזה?
תשובה:
נחדד את נושא השאלה: תקשורת Winforms בין Javascript.
לתקשורת הזו יש שני כיוונים: Javascript שמדבר עם Winforms והכיוון השני הוא Winforms שמדבר עם Javascript.
...
נריץ את האפליקציה ונבחר את כונן C.
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
איך אפשר להשתמש בעכבר או בעט סטיילוס (במחשבי Tablet) כדי לצייר ב-Windows Forms?
ציור על המסך באמצעות עזרים חיצוניים (עכבר במקרה של מחשבים שולחניים או ציור באמצעות לחיצות על המסך במקרה של Tablet Pc) הוא מנת חלקם של מחשבי Tablet.
יש DLL דוט-נטי בשם Microsoft.Ink.DLL שבא עם ההתקנה של Tablet PC SDK.
כחלק מה-DLL המסתורי הזה, מגיעים כמה מחלקות מעניינות מאוד שמאפשרות לנו "לצייר על פקדים".
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
אם אני אתנהג במשך הרבה זמן כאילו אני יודעת מה זה GDI בסוף אני באמת אדע?
תשובה:
GDI היא טכנולוגיה בת בערך 10 שנים פחות או יותר שיצאה עם חלונות 3.11 שמטרתה היא לדאוג לציור ולרנדור של מסכים ואפקטים חלונאיים. מיותר לציין שכל דבר בן 10+ שנים בטכנולוגיה מיקרוסופטית כבר הוחלף.
+GDI היא טכנולוגיה הדוט נטית והיא מהווה שכבת תקשורת בין אפליקציות דוט נטיות לבין ה-GDI של מערכת ההפעלה. הרעיון מאחורי +GDI הוא "היי, GDI גרוע ואי-אפשר לעשות איתו כלום בלי לדאוג ל-4,000 דברים לא רלוונטים אז בואו נבנה מעליו ממשק שמאפשר באמת לעשות משהו".
בטכנולוגיה המיקרוסופטית החדשה שמחליפה את Winforms שנקראת WIndows Presentation Framework (או בקצרה, WPF) יש תמיכה הרבה הרבה יותר פשוטה בכל נושא האנימציות והציור (ותמיכה נוספת קלה יותר בנושאים כמו סאונד ווידאו).
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
כתבתי תכנית קטנה, מאוד קטנה, והיא תופסת בערך כ-14,000 KB מהזכרון בזמן ההרצה.
האם ניתן לצמצם את הגודל הזה?
התכנית כתובה ב-C# והיא בסביבת WINForm.
תשובה:
הנה דוגמה לאפליקציה שנטענת לתוך ה-RAM בלי שום הגבלה:
רק עם הגבלה על הגבול העליון של הזכרון:
רק עם הגבלה על הגבול התחתון של הזכרון:
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
בעיה נפוצה כאשר עובדים עם אפליקציות חלונאיות בדוט נט היא שכאשר מציירים ישירות על הטופס (בין אם באמצעות אירוע ה-Paint שמספק e.Graphics לצייר אליהם או באמצעות Control.CreateGraphics) היא שכל מה שנצייר ימחק כאשר הטופס יצייר את עצמו מחדש.
כיצד ניתן לדאוג לצייר ב-WinForms כך שהציור ישאר בצורה קבועה על הטופס וגם לשמור לאחר מכן לקובץ? (למשל כמו שצייר/Paint של חלונות עושה)
תשובה:
עדיף להימנע מציור ישירות על הטופס עצמו.
הסיבה היא שאירועים שגורמים מחדש לציור הטופס (למשל, הזזה מחוץ לגבלות המסך ובחזרה לתוך המסך או השמה של טופס מעל הטופס) אינם שומרים את כל השינויים שבוצעו.
מדובר בבעיה ידועה והגיונית לחלוטין, הרי לא נתנו למערכת ההפעלה שלנו שום הוראה לשמור על ציור המסך.
עדיף לשמור ברמת הטופס\פקד\משטח-הציור על אובייקט מסוג Bitmap שעליו נבצע את כל הציורים ואותו נצייר על הטופס.
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
איך ניתן לדעת מה הצבע של פיקסל שהעכבר עומד עליו בזמן מסוים?
תשובה:
אני מניח שהשאלה מתייחסת לתזוזת עכבר בתוך הדוט-נט פריימוורק ולא תנועות עכבר ברמת מערכת ההפעלה.
הפתרון הוא אחד יחסית פשוט אך עקום ומסתמך על זה שאין באמת פתרון.
המתודה היחידה בכל הפריימוורק שמאפשרת באמת להשיג את הצבע של פיקסל מסויים היא Bitmap.GetPixel שמקבלת נקודה (קורדינטות X ו-Y). זה מסתדר נהדר עם זה שהמתודה היחידה בכל הפריימוורק שמאפשרת לדגום את המסך היא Graphics.CopyFromScreen שמעתיקה חלק מהמסך לתוך אובייקט Graphics. למה זה מסתדר? כי אפשר לבסס אובייקט Graphics על אובייקט Bitmap ככה שההעתקה לתוך Graphics תשפיע בחזרה על ה-Bitmap שלנו.
פתח מאמר מלא בחלון חדש
|
|
פתח מאמר מלא בחלון חדש
שאלה:
כרגע אני בונה אפליקציית WinForms (שקשורה לרשת) שמטבע הדברים חייבת לעבוד בצורה Multi-threaded (כדי לחסוך את הזמן של הResponse).
קודם יצא לי לעבוד עם Threading רק בסביבת console ובnet 1.1. כואשר ניסיתי ליישם את הטכניקות הישנות לאפליקציית WinForm ב net 2.0 נתקלתי בבעיה שלא ניתן (בדרכים המוכרות לי) להשפיע מתוך thread שונה על הForm. כיצד בכל זאת ניתן לעבוד עם Threadים באפליקציות חלונאיות?
תשובה:
לעבודה א-סינכרונית ב-Winforms מומלץ להשתמש ב-BackgroundWorker.
הקונספט הוא כזה, בכל עבודה א-סינכרונית באפליקציות חלונאיות תמיד יהיו שתי שלבים: תעשה משהו מאוד מאוד ארוך, ואז תשנה משהו קטן וזניח בטופס בעקבותו. הבעיה היא שכפי ששמת לב, לא ניתן לגשת מ-Thread שאינו ה-Thread הראשי לרכיבים הגרפיים של ה-GUI.
פתח מאמר מלא בחלון חדש
|
|