משחקי קוד

A conversation with a 2.5 years girl

tal.nospam@nospam.talgiladi.net (talgiladi) — Sun, 01 Nov 2009 12:28:00 +0400

It starts with a random question, but continues with a well designed pattern...

static void Main(string[] args)

        {

            string source = null;

            while (true)

            {

                if (source == null)

                {

                    source = GetTheQuestionThatMostInterestsMeNow();

                }

                Console.WriteLine("Why " + source + "?");

                var answer = Console.ReadLine();

                var nextQuestion = ThinkDeeplyAboutTheAnswerAndGetTheNextQuestion(answer);

                source = nextQuestion ?? source;

            }

        }

        private static string GetTheQuestionThatMostInterestsMeNow()

        {

            return "are the birds singing";

        }

        private static string ThinkDeeplyAboutTheAnswerAndGetTheNextQuestion(string answer)

        {

            string result = null;

            if (answer != null)

            {

                int index;

                if ((index = answer.IndexOf("because", StringComparison.OrdinalIgnoreCase)) > -1)

                {

                    answer = answer.Substring(index + "because".Length);

                }

                result = answer;

            }

            return result;

        }

Code Contracts

tal.nospam@nospam.talgiladi.net (talgiladi) — Sun, 28 Jun 2009 12:07:07 +0400

המטרה: ליצור שפה אחידה שמתארת את ההנחות והציפיות שלי כשאני משתמש באובייקט של מישהו אחר, או כשמישהו אחר משתמש

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

היום כשאני מקבל ערך לאיזה מאפיין במחלקה שלי, אני בודק האם הערך תקין, האם הוא לא ריק וכו’, ואם הערכים לא מתאימים לי, אני זורק

הודעת שגיאה בדרך כלל:

  private int _age;
        public int Age
        {
            get
            {
                return _age;
            }
            set
            {
                if (value < 0)
                {
                    throw new ArgumentException("Age must be a positive value");
                }
                _age = value;
            }
        }

ואיך נכתוב את זה באמצעות חוזה?

 private int _age;
        public int Age
        {
            get
            {
                return _age;
            }
            set
            {
                Contract.Requires(value > 0);
                _age = value;
            }
        }

זהו…

הקוד עדיין בתהליכי פיתוח במייקרוסופט, אך הוא מופץ כבר משולב בתוך דוט נט גירסה 4, וניתן להורדה גם עבור ויז’ואל סטודיו 2008.

אז מה יש לנו שם עוד?

יש כמה דברים מעניינים, לדוגמה:

בדיקה של הערכים שפונקציה יכולה להחזיר, לפני שהיא מחזירה אותם. בדיקה
סטטית(compile time) של קריאות עם ערכים לא תקינים לפונקציה כך שאנו מקבלים אזהרה עוד לפני זמן הריצה (רק שבינתיים הם הוסיפו את האופציה הזאת רק עבור גירסה team suite…)
הגדרת דרישות עבור ממשק, כך שכל מחלקה שמיישמת אותו תצטרך למלא את הדרישות האלו.

אבל הדברים העיקריים הם אלו:

תנאי מקדים- שאנו מבטאים באמצעות הקוד שעכשיו כתבנו : Contract.Requires, שבעצם בודק שהכל תקין לפני שאני מתחיל את המתודה שלי.
תנאי מאוחר – שבודק את התקינות לאחר שהקוד שלי רץ והמתודה עומדת להסתיים.
תנאים לא תלויי אובייקט- אלו תנאים שתמיד אמורים להיות נכונים לגבי האובייקט שלי, לא משנה מה מצבו- גיל לא יכול להיות שלילי, גם אם הלקוח לא מילא את פרטי גילו, ולכן בכל מצב זה אמור להיות נכון, ולא רק לאחר שהכנסתי ערך לפרטי הגיל.

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

אם אתם משתמשים בויז’ואל סטודיו 2010 לכו למאפייני הפרוייקט ( לחצן ימני על שם הפרוייקט-> מאפיינים)

תוסיפו שם את המילה CONTRACTS_FULL

בויז’ואל סטודיו 2008 נדרשת התקנה של הקוד, ולאחר מכן יש להוסיף הפניה ל microsoft.contracts, אך לאחר ההתקנה יהיה לכם בהגדרות פרוייקט טאב מיוחד להגדרות של החוזים.

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

Service locator

tal.nospam@nospam.talgiladi.net (talgiladi) — Wed, 04 Mar 2009 21:46:00 +0400

ראיתי את הפרוייקט הזה ב code plex שמיקל על השימוש בService Locator בצורה יותר Loosley Coupled. לאחר מה שקרה לי

לפני כמה זמן, בדיוק בנושא הזה, החלטתי מעצמי לישם פיתרון כזה ואז ראיתי היום שיש כבר קוד מוכן… לא שזה כזה משנה, בסך הכל 3

מחלקות יצרתי שם עם כמה שורות קוד…

בכל מקרה, עדיין הפרוייקט שלהם טעון שיפור, שכן הוא לא מספק דרך לקנפג את השירות דרך הקוד. הם פשוט סומכים על כל מחלקה שמממשת את הממשק שתקנפג את עצמה, שזה די טוב לרוב האנשים שמשתמשים בקבצי XML חיצוניים לקינפוג, אבל אני טוען את המידע בעצמי ואז בזמן ריצה מקנפג את המיפוי, וזה אומר שאני אצטרך בכל מחלקה שמממשת את הממשק אני אצטרך להכניס מעל 100 שורות עם המיפויים, וכולנו יודעים מה זה אומר לשכפל קוד…

אז רק כדי להשלים את הפרוייקט שלהם נראה שצריך להוסיף 2 מתודות בממשק. הראשונה:

void RegisterType<TFrom, TTo>() where TTo : TFrom;

זאת שאמורה למפות ממשק למחלקה הדיפולטית שמיישמת אותו, והשניה:

void RegisterInstance<TType>(TType instance);

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

עכשיו אני יכול בנקודת הכניסה לאפליקציה (נניח ב global.asax) למפות את כל מה שאני רוצה בלי להיות תלוי במימוש מסוים.

Technorati Tags: IOC,ServiceLocator

רינדור User Control לבקשה מאג’קס

tal.nospam@nospam.talgiladi.net (talgiladi) — Sun, 01 Mar 2009 01:23:00 +0400

הבעיה: אני מאפשר להוסיף תגובות בדף, אני רוצה לשלוח את הבקשה באג’קס לשרת, ואם היא מאושרת להוסיף את התגובה ישירות לדף, בלי לרפרש אותו. קוד ה HTML של תגובה נמצא ב user control . אני רוצה שהשרת ישלח לי בחזרה את קוד ה HTML של התגובה החדשה, לא סתם ישלח, אלא בפורמט JSON.

עם web forms לא הייתה לי בעיה, יש מתודה שנקראת RenderControl עבור כל פקד, והיא מדפיסה את קוד ה HTML שלו, ואחר כך אני עושה עם הטקסט הזה מה שאני רוצה, במקרה שלי, שולח לדפדפן בפורמט JSON.

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

יש אפשרות לשלוח JSON על ידי שימוש במתודה Json שנמצאת בקונטרולר, או על ידי יצירת JsonResult.

יש אפשרות לרנדר קונטרול פשוט כמו שמרנדרים כל view אחר- פשוט לקרוא למתודה View() עם שם הקונטרול. הבעיה היא שהתוצאה מודפסת ישירות ל response בתור טקסט, ואני רוצה לשלוח אותה בתור json. אז ניסיתי לעבוד עליו, ליצור response מדומה ואז למשוך ממנו את הטקסט ולשלוח על ידי המתודה Json(), לא עבד. ניסיתי עוד כמה דברים שהיו בגוגל, לא עבד.

טוב, אז זה מה שיצא לי… לא שאני הכי שמח עם זה, אבל זה עובד..

מחלקה שמרנדרת את הקונטרול לטקסט:

public class BlockRenderer

    {

        private readonly HttpContextBase _httpContext;

        public BlockRenderer(HttpContextBase httpContext)

        {

            _httpContext = httpContext;

        }

        public partial class HttpResponse

        {

            public bool UsingHttpWriter { get { return true; } }

        }

        public string Capture(Action viewRenderer)

        {

            HttpResponseBase resp = _httpContext.Response;

            Stream originalFilter = null;

            CapturingResponseFilter innerFilter;

            string capturedHtml = "";

            if (viewRenderer != null)

            {

                try

                {

                    resp.Flush();

                    originalFilter = resp.Filter;

                    innerFilter = new CapturingResponseFilter(resp.Filter);

                    resp.Filter = innerFilter;

                    viewRenderer();

                    resp.Flush();

                    capturedHtml = innerFilter.GetContents(resp.ContentEncoding);

                }

                finally

                {

                    if (originalFilter != null)

                    {

                        resp.Filter = originalFilter;

                    }

                }

            }

            return capturedHtml;

        }

    }

עכשיו כדי לקרוא לה, צריך מתוך הקונטרולר להוסיף את המתודה הבאה:

        public string RenderPartialToString(string userControl, ViewDataDictionary viewData, ControllerContext controllerContext)

        {

            HtmlHelper h = new HtmlHelper(new ViewContext(controllerContext, new WebFormView("Index"), viewData, TempData), new ViewPage());

            var blockRenderer = new BlockRenderer(controllerContext.HttpContext);

            string s = blockRenderer.Capture(

                () => RenderPartialExtensions.RenderPartial(h, userControl, viewData)

            );

            return s;

        }

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

ViewDataDictionary viewData = new ViewDataDictionary(new List<Reply>() { reply });

string s = RenderPartialToString("~/Views/Shared/ReplyItem.ascx", viewData, this.ControllerContext);

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

JavaScriptSerializer js = new JavaScriptSerializer();

return new TextResult(js.Serialize(new { approved = reply.IsApproved.ToString(), replyHtml = html }));

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

Technorati Tags: mvc,user control,ajax

Captcha for MVC

tal.nospam@nospam.talgiladi.net (talgiladi) — Fri, 27 Feb 2009 13:33:00 +0400

Technorati Tags: asp.net,mvc

כתבתי בעבר על איך ליצור captcha control פשוט, וגם כתבתי אחד קצת יותר מתקדם,

אבל עכשיו כשאני בתהליכי מעבר ל mvc הקונטרולים הקודמים לא כל כך מועילים, שהרי הם משתמשים ב webforms.

אז כמובן שאי אפשר פשוט לזרוק כאן קונטרול על הדף וזה יעבוד, זה חלק מהמחיר שאנו משלמים עם mvc,

אז נצטרך לכתוב כמה שורות קוד, לא יותר מדי…

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

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

א. GetCaptchaString – מייצר טקסט רנדומלי ושומר אותו בסשן להשוואה.

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

ג. RenderImage מייצרת את התמונה עבור הקונטרולר שאמור לשלוח אותה לדפדפן.

ד. IsValid – ערך שמציין האם הפניה האחרונה שהגיע מהדפדפן מכילה ערך תקין בהתאם לתמונה שנשלחה. זוהי בעצם הבדיקה שלי.

public class CaptchaManager

{

    public static string GetCaptchaString()

    {

        string result;

        if (HttpContext.Current.Session["captchaText"] != null)

        {

            result = HttpContext.Current.Session["captchaText"] as string;

        }

        else

        {

            result = Guid.NewGuid().ToString("N").Substring(0, CaptchaImage.TextLength);

            HttpContext.Current.Session["captchaText"] = result;

        }

        return result;

    }

    public static void ResetCaptcha()

    {

        HttpContext.Current.Session["captchaText"] = null;

    }

    public static Bitmap RenderImage()

    {

        CaptchaImage ci = new CaptchaImage()

        {

            Text = GetCaptchaString()

        };

        return ci.RenderImage();

    }

    public static bool IsValid

    {

        get

        {

            string request = HttpContext.Current.Request["captchaText"];

            string user = HttpContext.Current.Session["captchaText"] as string;

            return request == user;

        }

    }

}
יצרתי מחלקה שתשמש כ ActionFilter , למרות שאתם יכולים כמובן לדלג עליה ולדחוף את הקוד שבה ישירות לקונטרולר שבו אתם רוצים את הבדיקה.

הדבר היחיד שאנו עושים כאן זה לתפוס את הבקשה לפני שהיא מגיעה ל action, ואם ה captcha לא תקין, להחזיר הודעת שגיאה לדפדפן. במקרה שלי זה הודעה בפורמט JSON לפניה מאג'קס, אבל כמובן שהתוצאה יכולה להיות כל ActionResult אחר.

public class ValidateCaptchaAttribute : ActionFilterAttribute

    {

        public override void OnActionExecuting(ActionExecutingContext filterContext)

        {

                if (!CaptchaManager.IsValid)

                {

                    filterContext.Result = new JsonResult() { Data = new { error = "true" } };

                    return;

                }

            base.OnActionExecuting(filterContext);

        }

    }
מה נשאר לנו? נשאר לכתוב את קוד ה Html ולשלוח את התמונה פיזית לדף. לצורך יצירת התמונה ושליחתה לדף, יצרתי קונטרולר נוסף שזה כל הקוד שלו:

public class CaptchaController : Controller

    {

        public FileResult Index()

        {

            using (Bitmap b = CaptchaManager.RenderImage())

            {

                var ms = new MemoryStream();

                b.Save(ms, ImageFormat.Gif);

                return File(ms.ToArray(), "image/png");

            }

        }

        public JsonResult Render()

        {

            CaptchaManager.ResetCaptcha();

            return Json(new { success = "true" });

        }

    }

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

א. פונה לשרת כדי לאפס את הטקס (זו הפעולה שאנו רואים פה Render)

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

<table>

<tr>
               <td>
                   <img src="<%=Url.Action("Index", "Captcha") %>" alt="captcha" name="captchaImages" /><a href="javascript:void(0)" onclick="renderCaptcha();return false;">a</a>
               </td>
               <td>
                   <input type="text" id="txtReplyCaptchaText" name="captchaText"/>
                   <span>Enter the text in the image</span>
               </td>
           </tr>

</table>

6. ונשאר רק פונקציה ב javascript למי שרוצה אפשרות לרנדר מחדש את התמונה

<script type="text/javascript">
    
</script>

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

שימו לב ששם תיבת הטקסט הוא קבוע “captchaText” , כדי שהפילטר שלנו ידע מה לחפש

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

להורדת פרוייקט דוגמה

ומה אתם הייתם עושים...?

tal.nospam@nospam.talgiladi.net (talgiladi) — Sun, 15 Feb 2009 14:38:00 +0400

אם לקוח גדול היה מסכים לקנות את האפליקציה רק בתנאי שחלק מהמודולים יעבוד עם דוט נט 2.0 כי הוא לא יכול להתקין את גירסה 3.5?

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

אז קיבלתי הוראה שהלקוח הזה כל כך חשוב, ושאני פשוט צריך לעשות הכל כדי שזה יעבוד, כולל לייצר לו גירסה מיוחדת, לא משנה איך... נחמד אה?

שכבת הrepository שלנו עובדת עם דוט נט 2, ה services דוט נט 3, והמודולים שהוא רוצה עובדים עם 2, רק הבעיה כמובן היא שהיא פונים לשכבת ה services ... אז היו לי כמה אופציות, כמובן שכולם לא טובות. אחת הייתה לחלק את שיכבת הservices לשתי שכבות נפרדות, כך שהקוד שמשתמש בגירסה 3 יהיה מלמעלה ואז ניתן יהיה להשתמש בשאר השירותים בשכבה התחתונה יותר, אבל כמובן שזה דפוק... זה כמו לחצות DLL לשניים ולעשות כאילו זה צורך ארכטיקטיוני... אז ויתרתי.

אחר כך חשבתי פשוט שהמודולים האלה יפנו ישירות ל repository, שוב, אני יודע שזה לא נכון, אבל אין ברירה, וחוץ מזה אין בהם כל הרבה business logic שאני צריך את כל הפניות לשיכבת ה services, ואכן התחלתי לבצע, עד שהבנתי שלא רק שאני אצטרך לשכפל קוד (!!!) אלא שה IOC שלי שנמצא בשכבת ה services יצטרך להשתכפל גם!! ואיפה אני אשים אותו?

בסוף אמרתי, גם ככה אני אצטרך לעשות עבודה של חמור, אז כנראה שהכי טוב זה פשוט לגרום ל services לעבוד עם גירסה 2... וככה עשיתי, התחלתי מה Linq היקרים שהפכו לשורות קוד שאני כתבתי, וכלה ב extension methods שפשוט הפכתי למתודות סטטיות ועל שאר הדברים הקטנים פשוט ויתרתי...

Technorati Tags: refactoring

Continuous Integration

tal.nospam@nospam.talgiladi.net (talgiladi) — Thu, 29 Jan 2009 10:41:00 +0400

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

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

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

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

שתי התוכנות העיקריות הן cruise control שהיא תוכנת קוד פתוח, ו team city שהיא תוכנה עם רשיון, אך גירסה ה professional שלה היא בחינם עד ל 20 משתמשים (תבדקו בדיוק את הפרטים שם).

לצורך הדוגמאות בחרתי להשתמש ב team city.

1. ההתקנה די פשוטה, יש הוראות באתר שלהם. מה שכן, עדיף לבחור פורט אחר ולא הדיפולטי שלהם שהוא 80

2. לאחר ההתקנה נעשה לוגין, וניגש ליצירת פרוייקט חדש

3. לאחר היצירת הפרוייקט נתחיל בהגדרות

4. תנו שם לפרוייקט, ותיאור אפשרי. אפשר להשאיר את השאר ריק

5. הקליקו על “VCS Settings” כדי להגדיר את הסורס קונטרול.

אני משתמש ב Visual Source Safe, אז אם יש לכם סוג אחר, תצטרכו לחפש את ההגדרות המתאימות…

תבחרו את סוג השרת:

בנתיב לקובץ srcsafe.ini שים את הנתיב המלא לקובץ של כל הסורס סייף, לאו דווקא הפרוייקט הנוכחי. אם הוא נמצא על שרת פשוט הקלידו את הנתיב לשרת:

\\ServerName\directory\srcsafe.ini

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

$/ProjectName.root/ProjectName

מלאו את שם המשתמש והסיסמה שלכם עבור הסורס סייף ואתם יכולים לבדוק אם הפרטים נכונים על ידי הקלקה על “Test Connection”. כמובן ללחוץ על שמירה בסוף.

6. כעת נבחר את דרך קימפול ובניית הפרוייקט. תלחצו על הלינק Runner שיש בצד:

לשם התחלה נבחר במה שאנו מכירים – שזה sln2005 או sln2008 תלוי באיזה גירסה של ויז'ואל סטודיו אתם משתמשים.

בתיבת הטקסט הראשונה (solution file path)תכניסו את שם הסולושן שזה ProjectName.sln בדרך כלל.

בתיבה working directory תכניסו את שם התיקיה בה נמצא הפרוייקט, שזה בדרך כלל פשוט שם הפרוייקט.

בתיבה Targets תכתבו Rebuild

שמירה ואתם מוכנים לצאת לדרך!

בצד ימין למעלה יש כפתור עם המילה Run, תלחצו עליו

עכשיו תלחצו על הטאב הגדול בצד שמאל בשם Projects – שם מופיעים כל הפרוייקטים שלנו, שזה כרגע רק אחד בעצם. אתם יכולים לראות

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

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

מה שבעצם קורה הוא שכל קבצי הפרוייקט נמשכים מה source control לתיקיה זמנית, ושם מקומפלים בהתאם להגדרות. המטרה שלנו כרגע היא לדעת שתמיד יש לנו אפליקציה שמתקמפלת.

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

Technorati Tags: continous integration

הנסיון שלי עם StructureMap

tal.nospam@nospam.talgiladi.net (tal) — Fri, 09 Jan 2009 13:20:00 +0400

לא היה כל כך טוב בפעם האחרונה…

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

בניתי לאשתי איזה אתר קטן, ולאחר מחשבות הגיע למסקנה שיתכן שהוא יגדל ונצטרך לשנות דברים אז כדאי להשתמש ב dependency injection. מכיוון שאני מכיר את StructureMap ודי אוהב לעבוד איתו אז כמובן שבחרתי בו.

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

טוב, אז עשיתי כמה רפקטורים לקוד, בדרך שיניתי עוד כמה דברים, העליתי לשרת, וקיבלתי את דף השגיאה… שיניתי בווב קונפיג כדי שיציג את השגיאה והתברר שהאסמבלי של StructureMap לא יכול לעבוד בסביבה שלא מאפשרת הרשאות מלאות…

System.Security.SecurityException: That assembly does not allow partially trusted callers.

ניגשתי לגוגל, התברר שאני לא היחיד עם הבעיה, ניגשתי שוב לאתר שלהם כדי לבדוק שוב שאכן ניתן להריץ גם על שרת משותף ללא כל ההרשאות…

טוב, השארתי לבחור ההוא הודעה בבלוג אבל בינתיים אני בלי אפליקציה…

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

מצאתי את NInject, בדקתי שניתן להריץ על שרת משותף, הורדתי , מהר התאמתי את הקוד שלי, ו…

System.Runtime.CompilerServices.ExtensionAttribute' is defined in
multiple assemblies in the global alias; using definition from 'c:\xxx
\Ninject-1.0-release-net-2.0\Ninject.Core.dll

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

חזרה לגוגל, מצאתי משהו נחמד בשם Autofac, שוב בדקתי שניתן להריץ, הורדתי, התאמתי את הקוד, העליתי לשרת, ו… אכן עלה הדף הראשי!!!

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

אני עובד עם MVC, ואם אני מקבל הודעת שגיאה ש Action מצפה לפרמטר ID ולא קיבל אותו, ואני רואה בדיבאג שהפרמטר שם, משהו קצת מוזר…

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

ממשיך לרוץ באפליקציה, שוב שגיאה… שוב פרמטר חסר, שוב מתקן וחושב לעצמי, איזה מתכנת אתה…

ממשיך לרוץ, עכשיו ה UpdateModel מעדכן ערכים ריקים, לא זורק שגיאה, פשוט שם ערכים ריקים…

הראש כבר לא עובד טוב אז נפטרתי גם מ UpdateModel ועדכנתי ידנית…

וכך עוד דבר ועוד דבר…

עד שנפל האסימון!

זה לא אני! זה Autofac! איכשהו היא מצליחה לדפוק את הנתונים שמגיעים לקונטרולרים שלי!!

אולי לא הגדרתי לא טוב, אין לי מושג, זה גם לא כל כך משנה לי, פשוט זה לא אמור לקרות!! היא בסדר הכל אמורה לספק פרמטרים לקונסטרוקטור וליצור אובייקט, עובדה שזה עבר תקין עם StructureMap אצלי על המחשב!

החלטתי לבדוק את החשד שלי, הורדתי את Autofac עבור קונטרולר אחד, ואכן! גם הפרמטרים מגיעים, גם ה UpdateModel חזר לעדכן ועוד כמה דברים מוזרים חזרו להיות תקינים!

מהר הורדתי את Autofac וחזרתי לשיטה הפרימיטיבית שבה הכל עבד!

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

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

Technorati Profile

Technorati Tags: ioc,dependency injection,structure map,autofac,ninject

Copy source as HTML

tal.nospam@nospam.talgiladi.net (tal) — Sat, 03 Jan 2009 13:29:00 +0400

Technorati Tags: programs,visual studio addin

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

שיפצרתי קצת את המקור – קצת הפריע לי שבכל פעם הוא יוצר שמות אחרים ל css class שהוא נותן שם, והאופציה השניה שם היא פשוט לדחוף את כל הסטייל ישירות ל HTML, שזה מפוצץ את גודל הדף וגם מונע שינויים עתידיים, אז הוספתי שם שאם כבר הוא השתמש באיזה css class בעבר אזי הוא ישתמש בה שוב עבור אותו סטייל, וגם שניתן יהיה לערוך את השמות שהוא נותן לסטיילים.

לא הצלחתי ליצור קשר עם קולין קולר, זה שכתב את המקור, אז אני מקווה שלא איכפת לו...

להורדת הפרוייקט

להורדת ההתקנה

Reflection for Unit Testing - update

tal.nospam@nospam.talgiladi.net (talgiladi) — Thu, 04 Dec 2008 10:23:00 +0400

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

להזכיר, רציתי להשוות שני אובייקטים – אחד מה שהקוד החזיר ואחד זה מה שמצופה, אז כתבתי מתודה פשוטה שתשווה בין כל 2 אובייקטים.

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

public static void Compare<T>(T expected, T actual, params string[] exclude)

        {

            Assert.IsNotNull(expected);

            Assert.IsNotNull(actual);

            List<string> p = new List<string>();

            if (exclude != null)

            {

                p.AddRange(exclude);

            }

            foreach (var pi in typeof(T).GetProperties())

            {

                if (p.SingleOrDefault(a => a.Equals(pi.Name, StringComparison.InvariantCultureIgnoreCase)) != null)

                {

                    continue;

                }

                Assert.AreEqual(pi.GetValue(expected, null), pi.GetValue(actual, null), pi.Name);

            }

        }

והשימוש פשוט כמובן:

[TestMethod()]

        public static void Test()

        {

            var a = new MailMessage()

            {

                Subject = "MYSubject",

                Body = Guid.NewGuid().ToString()

            };

            var b = new MailMessage()

            {

                Subject = "MYSubject",

                Body = Guid.NewGuid().ToString()

            };

            Compare<MailMessage>(a, b, null);//will fail

            Compare<MailMessage>(a, b, "Body");//will pass

        }

Technorati Tags: Reflection,UnitTesting

Liskov Substitution Principle

tal.nospam@nospam.talgiladi.net (talgiladi) — Fri, 28 Nov 2008 19:28:00 +0400

או בעברית משהו כמו “עיקרון החילופין של ליסקוב”- אחד מהעקרונות של תכנות מונחה אובייקטים, שאומר בעצם:

אם אני יורש ממחלקת אם, ודורס אחת מהמתודות שלה (overide), הלקוח שמשתמש בקוד שלי, צריך להיות מסוגל להמשיך להשתמש בקוד בצורה שקופה, בלי שהעובדה שהעברתי לו את המחלקה היורשת ולא את מחלקת האם, תפגע בהנחות שלו לגבי המתודה.

אני חייב לקיים את החוקיות שקיימת במחלקת האם, כך שכל unit test, כל קריאה לפרופרטי או פונקציה, תמשיך לפעול בצורה זהה מבחינת מי שמשתמש בקוד שלי. כמובן שמה שקורה מאחורי הקלעים יכול להיות שונה, בשביל זה הרי יצרתי מחלקה יורשת, אבל מבחינתו אין שום הבדל.

דוגמה קטנה תסביר בבירור:

יש לי מחלקה שמייצגת מרובע כלשהוא

 public class Rectangle

    {

        public virtual int Width { get; set; }

        public virtual int Height { get; set; }

        public Rectangle() { }

        public Rectangle(int width, int height)

        {

            this.Width = width;

            this.Height = height;

        }

        public virtual int Size

        {

            get

            {

                return this.Height * this.Width;

            }

        }

    }

וגם בניתי עבורה טסט:

  [TestMethod()]

        public void TestSize()

        {

            int expectedWidth = 3;

            int expectedHeight=7;

            Rectangle rectangle = new Rectangle(expectedWidth, expectedHeight);

            Assert.AreEqual(expectedWidth, rectangle.Width);

            Assert.AreEqual(expectedHeight, rectangle.Height);

        }

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

של המרובע שלי:

 public class Square : Rectangle

    {

        public Square() { }

        public Square(int width)

            : base(width, width)

        {

        }

        public override int Size

        {

            get

            {

                return this.Width * this.Width;

            }

        }

    }

אבל בגלל שלריבוע הרוחב והאורך זהים, אני צריך רק ערך תמיד – של רוחב או גובה, אז שיניתי את הקוד כלעיל.

עכשיו הטסט שלי יכשל:

[TestMethod()]

        public void TestSize()

        {

            int expectedWidth = 3;

            int expectedHeight=7;

            Rectangle square = new Square(expectedWidth);

            Assert.AreEqual(expectedWidth, square.Width);

            Assert.AreEqual(expectedHeight, square.Height);//fail

        }

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

מה הפיתרון? במקרה שלנו באמת זה לא אפשרי, אז נצטרך לבטל את הירושה וליצור אולי מחלקה שלישית אבסטרקטית שממנה ירשו גם הריבוע

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

Technorati Tags: object oriented,liskov,lsp

Web Services Extensions

tal.nospam@nospam.talgiladi.net (talgiladi) — Fri, 03 Oct 2008 20:47:00 +0400

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

הבשורה הרעה שכולנו לא אוהבים לשמוע, זה שצריך להוריד משהו מהאינטרנט... כן, זה עדיין לא בא בתור סטנדרט בתוך הפריימוורק, אולי בעתיד...
אז תגשו לגוגל ותחפשו wse, בפעם האחרונה שבדקתי הגירסה הייתה 3.0 ולינק ההורדה ממיקרוסופט הוא כאן
לאחר ההתקנה יהיו לכם כמה דוגמאות קוד והוראות שימוש די נוחות...
הדבר הראשון שצריך לעשות אם אנחנו רוצים להשתמש בחתימה דיגיטלית זה להתקין מפתח אסימטרי.
למזלנו הקובץ מגיע עם 4 מפתחות לצורך הדוגמה, והדבר היחיד שצריך לעשות זה להריץ את הקובץ setup.bat שנמצא בתוך ספריית ההתקנה, בתוך ספריית samples, רק שימו לב שצריך לפתוח את שורת הפקודה של ויזואל סטודיו קודם:

ללכת לנתיב שציינתי, ואז לכתוב את שם הקובץ להרצה... תתפללו שהכל יעבוד, ואם כן אז יש לכם 4 מפתחות להצפנה מותקנים על ה iis.

אם ממש בא לראות אותן, ניתן להקיש בשורת הפקודה mmc כדי לפתוח את הקונסול, אחר כך להקיש על file->Add/Remove snap in->Add->certificates->Add
ואז תראו שם את כל המפתחות שמותקנות אצלכם על המחשב מהגלישה באינטרנט... אלו שעכשיו התקנו - אחת מופיע תחת personal , עוד אחת תחת other people ועוד 2 איפשהו שם...

איך עובדת החתימה הדיגיטלית בשירותי רשת?
כמו בכל מקום אחר. הלקוח מייצר מפתח פרטי-ציבורי מהחתימה שלו. את המפתח הציבורי הוא ישלח ביחד עם ההודעה לשרת שמפעיל את שירותי הרשת.
הלקוח עושה האש על ההודעה.
על קוד ההאש שקיבלנו, אנו מבצעים את ההצפנה בעזרת המפתח הפרטי, מה שקיבלנו עכשיו זו בעצם החתימה הדיגיטלית.
את החתימה אנחנו מצרפים להודעה שאנחנו שולחים.

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

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

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

אז בואו נתחיל עם חתימה על ידי שם משתמש וסיסמא.

הגדרת צד השרת

קודם כל ניצור אתר פשוט.

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

אבל אז תצטרכו למקם את הקובץ שנוצר לבד בתוך תיקיית האתר שלכם)

התוכנה הזאת בעצם חוסכת מאיתנו את המשחק בווב קונפיג ומכניסה לשם את ההגדרות הדרושות.
בטאב הראשון נאפשר את השימוש בהרחבות המתקדמות בפרוייקט שלנו:
בטאב ה security בחלק של seucrity tokens manager נוסיף מנהל חדש על ידי לחיצה על add

תבחרו בקומבו בוקס Username Token Manager ושאר הפרטים יתמלאו לבד.
כאן בעצם הגדרנו שההודעה שלנו צריכה להכיל חתימה בעזרת שם משתמש וסיסמה.
אנחנו צריכים לעשות זה ליצור מחלקה שאליה יעביר ה wse את שם המשתמש, והיא תחזיר לו את הסיסמה
כדי שהוא יוכל לבדוק את החתימה הדיגיטלית. המחלקה הזאת במצב רגיל מן הסתם תמשוך את המידע מדטה בייס או קובץ.
את שם המחלקה, שעוד מעט נראה איך ליצור, אנו כותבים בתיבת הטקסט Type. אני קראתי למחלקה UserNameTokenHandler

תקליקו על אישור
עוד דבר יש לנו בטאב הזה, כדי שנוכל לשחק עם המפתחות שלנו, שאינן אמיתיים ולא הונפקו על ידי חברה מורשית כגון verisign וכו',

יש לסמן צ'ק בוקס בשם Allow test roots
עלינו ליצור קובץ שיכיל את ה Policy. הקובץ הזה מכיל הגדרות שונות לגבי החתימה הדיגיטלית. אתם יכולים להעתיק את הקובץ מספריית הדוגמאות שהגיעה עם התקנה ה wse, שם הקובץ הוא wse3policyCache.config והתוכן שלו הוא

<policies xmlns="http://schemas.microsoft.com/wse/2005/06/policy">

<extensions>

    <extension name="usernameForCertificateSecurity" type="Microsoft.Web.Services3.Design.UsernameForCertificateAssertion, Microsoft.Web.Services3, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />

    <extension name="x509" type="Microsoft.Web.Services3.Design.X509TokenProvider, Microsoft.Web.Services3, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />

    <extension name="requireActionHeader" type="Microsoft.Web.Services3.Design.RequireActionHeaderAssertion, Microsoft.Web.Services3, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />

</extensions>

<policy name="ServerPolicy">

    <usernameForCertificateSecurity establishSecurityContext="false" requireSignatureConfirmation="false" messageProtectionOrder="SignBeforeEncrypt" requireDerivedKeys="true" ttlInSeconds="300">

      <serviceToken>

        <x509 storeLocation="LocalMachine" storeName="My" findValue="CN=WSE2QuickStartServer" findType="FindBySubjectDistinguishedName" />

      </serviceToken>

      <protection>

        <request signatureOptions="IncludeAddressing, IncludeTimestamp, IncludeSoapBody" encryptBody="true" />

        <response signatureOptions="IncludeAddressing, IncludeTimestamp, IncludeSoapBody" encryptBody="true" />

        <fault signatureOptions="IncludeAddressing, IncludeTimestamp, IncludeSoapBody" encryptBody="false" />

      </protection>

    </usernameForCertificateSecurity>

    <requireActionHeader />

</policy>

</policies>

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

7. כעת נראה למנהל ה Policy היכן ניתן למצוא את הקובץ. לכו לטאב של ה Policy, תסמנו את הצ'ק בוקס כדי לאפשר Policy, תקליקו על Browse ותמצאו את הקובץ הנ"ל.
כעת תנו שם ל Policy. אצלנו השם הוא ServerPolicy

תלחצו על אישור
בואו ניצור את המחלקה שתטפל בשם המשתמש:
ניצור מחלקה בשם UserNameTokenHandler שתירש מהמחלקה UsernameTokenManager. נדרוס את הפונקציה AuthenticateToken שהחתימה שלה היא

protected override string AuthenticateToken(UsernameToken token)

הפונקציה הזאת מקבלת מה wse את ה UsernameToken ואמורה להחזיר את הסיסמה עבור המשתמש הזה. עם הסיסמה שאנחנו מחזירים, ה wse מנסה לפענח את החתימה הדיגיטלית, ואם הוא מצליח הוא אז הוא יעשה האש להודעה וישווה לערך שנמצא בחתימה הדיגיטלית. לצורך הדוגמה הקוד יהיה פשוט

protected override string AuthenticateToken(UsernameToken token)

    {

        if (token.Username == "talg")

        {

            return "mypassword";

        }

        else

        {

            return null;

        }

    }

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

[Policy("ServerPolicy")]

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

להורדת קוד והגדרות השרת

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

ניצור פרוייקט, אני יצרתי אפליקציית קונסול.
לחצן ימני על הגדרות פרוייקט-> wse settings
לסמן את הצ'ק בוקס הראשון שמופיע, שבעצם מאפשר שימוש ב wse בפרוייקט הזה:
כעת ניצור הפנייה לווב סרביס בשרת שלנו על ידי הוספת web reference כרגיל. כעת לנקודה הכי חשובה! הפנייה רגילה לווב סרביס יורשת מהמחלקה SoapHttpClientProtocol , אנו צריכים לשנות כך שההפניה שלנו תירש מ WebServicesClientProtocol, שום שינוי אחר לא נדרש בקוד של ההפניה. רק שימו לב שכדאי לכם להוציא את ההפניה מהתיקיה של web references, אחרת כל פעם כשיבוצע עידכון הקוד הישן ימחק ותיצטרכו שוב לשנות את שם המחלקה.
הפנייה בקוד לווב סרביס

SecureWebService.WebService ws = new WebServiceClient.SecureWebService.WebService();
יצירת מקבילה בקוד לקובץ הפוליסי שיצרנו בשרת:

UsernameForCertificateAssertion assertion = new UsernameForCertificateAssertion();
נגדיר עם איזו חתימה להשתמש, ואיך למצוא אותה

assertion.X509TokenProvider = new X509TokenProvider(StoreLocation.CurrentUser,

                                                                StoreName.AddressBook,

                                                                "CN=WSE2QuickStartServer",

                                                                X509FindType.FindBySubjectDistinguishedName);
עוד הגדרה שמופיעה אצלנו בקובץ הפוליסי בשרת:

assertion.RequireDerivedKeys = true;
כעת נכניס את השם המשתמש והסיסמה:

assertion.UsernameTokenProvider = new UsernameTokenProvider("talg", "mypassword");
ונוסיף את הפוליסי לווב סרביס:

Policy policy = new Policy();

policy.Assertions.Add(assertion);

ws.SetPolicy(policy);
ונקרא לשירות:

string result = ws.HelloWorld();

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

להורדת קוד פרוייקט הלקוח

Technorati Tags: WebServices

XSLT

tal.nospam@nospam.talgiladi.net (talgiladi) — Tue, 03 Jun 2008 21:02:00 +0400

ראינו לא מזמן כיצד ליצור RSS Feed לאתר (הסימן הכתום הזה שהדפדפן מראה כשאפשר להירשם לחדשות ועידכונים מהאתר...)
שם בעצם יצרנו קובץ xml פשוט והדפדפן הציג לנו אותו בצורה יפה ומסודרת. רציתי להראות משהו נחמד שנקרא xslt שזהו בעצם קובץ, שאומר לתוכנה שקוראת xml, איך להציג את הקובץ
שימו לב, את הקובץ xml עם התוכן אני יוצר כרגיל איך שיצרתי עד היום בלי שינוי, הקובץ הזה רק נותן הוראה איך להציג את התוכן, וכך הדפדפן, או כל קורא xml יודע להציג אותו בצורה יפה ולא בתור טקסט פשוט
נראה דוגמה ואז נבין איזה פשוט זה.
נניח שיש לי קובץ xml כזה:

<?xml version="1.0" encoding="utf-8" ?>
    <channel>
        <title>coding games</title>
        <link>http://www.talgiladi.net</link>
        <description>code samples </description>
        <ttl>180</ttl>
        <item>
            <title><![CDATA[Creating xml documents with xml text writer]]></title>
            <link>http://www.talgiladi.net/XmlTextWriter.aspx</link>
            <guid isPermaLink="true">http://www.talgiladi.net/XmlTextWriter.aspx</guid>
            <description><![CDATA[xml text writer for fast and easy creation of xml documents]]></description>
            <pubDate>2/5/2008 9:24:18 PM</pubDate>
        </item>
</channel>

זה בעצם אותו קובץ שהשתמשתי בו בשביל ה RSS רק הורדתי 2 שורות כדי שהדפדפן לא יזהה אותו בתור RSS ויציג אותו בצורה שונה.
כעת נלך ליצירת קובץ חדש ונבחר xslt

קיבלנו קובץ xml חדש. 3 שורות הראשונות אנחנו לא נוגעים, כעת נתחיל לתת הוראות. זיכרו שהקובץ הזה אמור להורות לקורא xml כיצד להציג כל חלק בקובץ
נתחיל להסביר לו איך לקרוא:

<?xml version="1.0" encoding="utf-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:msxsl="urn:schemas-microsoft-com:xslt" exclude-result-prefixes msxsl" >
<xsl:output method="xml" indent="yes"/>

עד כאן השורות המקוריות שאומרות שהקובץ הוא xslt, שהוא בעצם גיליון עיצוב ל xml, ושהתוצאה שלו תהיה xml

<xsl:template match="/">

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

מכיוון שאני רוצה שהתוצאה תהיה html חוקי אני אומר לו להדפיס את תגי ה html
כעת אני רוצה לתת לדף שלי כותרת לפי ערך שאני בוחר מקובץ ה xml ולכן נכתוב את ההוראה:

<xsl:value-of select="/channel/title" />

ההוראה הזאת אומרת להציג ערך שהוא התוצאה של האלמנט בשם "channel/title", כך שכל ערך שאשים במסמך ה xml שלי בתוך האלמנט הזה הוא יהיה הכותרת של הדף.
כעת נמשיך ב html פשוט

</title></head><body>

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

ועכשיו אני לתת הוראה לרוץ בלולאה, עבור כל אלמנט item שיש לי ב xml

<xsl:for-each select="/rss/channel/item">

ועבור כל אלמנט נכתוב את התבנית הבאה:

בתוך הלינק שמתי {link} כך שהערך שנמצא באלמנט link בקובץ xml שלי יוכנס כאן.
ואז שוב השתמשתי במה שראינו מקודם- להציג את הערך שנמצא בתוך אלמנט title בתוך כל item. ונוסיף גם לדף שלנו את התיאור של כל item:

&<span>
</span>xsl:value-of select="description" disable-output-escaping="yes" />
&</span>

שוב אותה שיטה, רק הוספתי גם הוראה לא לפרמט את התוצאה - הכוונה היא שאם הקורא יראה את הסימן span class="code_keywords"><

אז לא לפרמט אותו ל < וזאת מכיוון שיתכן שהתיאור שלי במאמר יכיל בעצמו Html כמו טקסט בולט, קו תחתון וכו' ואני רוצה שזה אכן יראה כמו Html ולא כמו אוסף של דברים מוזרים...
זהו... כעת במסמך ה xml שלי שעבורו בניתי את ה xslt יש להוסיף שורה למעלה שאומרת לקורא ה xml שיש קובץ מיוחד שמסביר איך להציג את התוכן , ולתת קישור לקובץ הזה:

<?xml-stylesheet type="text/xsl" href="MyXSLT.xslt" version="1.0"?>

ישנה מחלקה מיוחדת בדוט נט בשם XPath שעוזרת לנו להשתמש ב xslt בצורה תכנותית להמרה של קבצי xml, שזה בעצם מה שהדפדפן עושה או כל קורא xml אחר, בעזרת השם נדבר על המחלקה הזאת בקרוב

להורדת דוגמה

למידע נוסף

Technorati Tags: xslt,xml

Creating virtual directory with code

tal.nospam@nospam.talgiladi.net (talgiladi) — Tue, 03 Jun 2008 19:56:00 +0400

, לשם כך יש צורך ביצירת אתר חדש או ספריה וירטואלית חדשה (אלא אם כן השתמשתם בקאסיני...)
יוצא לפעמים שאנחנו צריכים להכין תוכנת התקנה של אתר ללקוחות הקוד לא ארוך ומסובך אבל מעצבן קצת.
קודם נוסיף הפניה לשם המתחם using System.DirectoryServices; שמשמש בעצם גם לגישה ל active directory. שימו לב שההפניה צריכה להיות דרך Add Reference :

כעת נפנה ל IIS:

DirectoryEntry iisRoot = new DirectoryEntry("IIS://" +

serverUrl + "/W3SVC/1/Root");

כש serverUrl זו הכתובת של המחשב שעליו מתקינים, במקרה של התקנה אצל הלקוח זה בדרך localhost
כעת, מכיוון שאנחנו רוצים ליצור ספריה וירטואלית ולא ליצור אתר חדש, אנחנו צריכים הפניה לאיזה אתר קיים כבר, אני אפנה לאתר הדיפולטי ושם אצור את הספריה:

DirectoryEntries defaultSite = iisRoot.Children; ;//default site

כעת ניצור את הספריה החדשה:

DirectoryEntry newVirtualDirectory = defaultSite.Add(virtualDirectoryName,iisRoot.SchemaClassName.ToString());//add new site

newVirtualDirectory.CommitChanges();

ו virtualDirectoryName הוא כמובן שם הספריה החדשה

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

newVirtualDirectory.Properties["Path"].Value = physicalPath;//the path to the files

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

כעת קצת מאפיינים לאתר החדש שלנו:

newVirtualDirectory.Properties["AccessRead"][0] = false;

newVirtualDirectory.Properties["AccessWrite"][0] = true;

newVirtualDirectory.Invoke("AppCreate", true);

newVirtualDirectory.Properties["AppFriendlyName"][0] = virtualDirectoryName;

ובסוף לשמור

newVirtualDirectory.CommitChanges();//save the changes

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

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

newVirtualDirectory = defaultSite.Find(virtualDirectoryName, oDE.SchemaClassName.ToString());

רק שימו לב שהפונקציה הזאת לא כל כך נחמדה, היא לא מחזירה null אלא זורקת exception אם לא נמצאה הספרייה, אז להקיף ב try catch בבקשה... תיהנו!

להורדת פרוייקט דוגמה

Technorati Tags: VirtualDirectory,DirectoryEntry

Service Controller

tal.nospam@nospam.talgiladi.net (talgiladi) — Mon, 02 Jun 2008 21:50:00 +0400

לעיתים אנו רוצים לשלוט ב WinService על המחשב דרך הקוד. בתוכנה שלנו למשל, מופעלים מספר שירותים על המחשב, ועוד אחד שמפקח עליהם, ועוד יש התקנה של המוצר שצריכה גם להתקין את הסרביסים האלה, ולכן שליטה מוחלטת דרך הקוד הכרחית עבורנו. לשם כך ניעזר במחלקה ServiceController.
קודם כל צריכים להוסיף הפניה לאסמבלי System.ServiceProcess שכן הפניה לשם לא קיימת בברירת המחדל
כעת אפשר להתחיל להשתמש בו

System.ServiceProcess.ServiceController myController = new System.ServiceProcess.ServiceController(svcName);

כפי שניתן לראות הבנאי שלו מקבל את שם הסרביס שאיתו אני רוצה לעבוד - השם הוא כמו שמופיע כשלוחצים alt+ctrl+del ובוחרים את טאב הסרביסים
בינתיים גם אם הסרביס לא קיים הכל עובד כרגיל. ישנה בעיה קטנה - אם פונקציה שעונה לי פשוט האם סרביס קיים או לא, ולכן נתחכם קצת :

if (myController != null)
{
try
{
string s=myController.DisplayName;
myController.Dispose();
return true;
}
catch { return false; }
}
return false;

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

ServiceControllerStatus scs= myController.Status;

אם נרצה לעצור אותו, נשתמש בפונקציה מובנית

switch (myController.Status)
{
case ServiceControllerStatus.Stopped:
//already stopped...nothing to do
break;
case ServiceControllerStatus.StopPending:
myController.WaitForStatus(ServiceControllerStatus.Stopped);
break;
default:
myController.Stop();
myController.WaitForStatus(ServiceControllerStatus.Stopped);
break;
}
myController.Close();

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

switch (myController.Status)
{
case ServiceControllerStatus.Stopped:
myController.Start();
myController.WaitForStatus(ServiceControllerStatus.Running);
break;
case ServiceControllerStatus.StopPending:
//wait for it to stop
myController.WaitForStatus(ServiceControllerStatus.Stopped);
//... and then start
myController.Start();
myController.WaitForStatus(ServiceControllerStatus.Running);
break;
case ServiceControllerStatus.StartPending:
//nothing to do...just wait
myController.WaitForStatus(ServiceControllerStatus.Running);
break;
case ServiceControllerStatus.Running:
//nothing to do.already running...
break;
default:
myController.Start();
myController.WaitForStatus(ServiceControllerStatus.Running);
break;
}

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

עכשיו, כדי להתקין ולהסיר סרביסים דרך הקוד, כבר נצטרך שימוש בקוד c++, אבל לא הרבה... להתקנת שירות נגדיר קצת קבועים:

int SC_MANAGER_CREATE_SERVICE = 0x0002;
int SERVICE_WIN32_OWN_PROCESS = 0x00000010;
//int SERVICE_DEMAND_START = 0x00000003;
int SERVICE_ERROR_NORMAL = 0x00000001;
int STANDARD_RIGHTS_REQUIRED = 0xF0000;
int SERVICE_QUERY_CONFIG = 0x0001;
int SERVICE_CHANGE_CONFIG = 0x0002;
int SERVICE_QUERY_STATUS = 0x0004;
int SERVICE_ENUMERATE_DEPENDENTS = 0x0008;
int SERVICE_START = 0x0010;
int SERVICE_STOP = 0x0020;
int SERVICE_PAUSE_CONTINUE = 0x0040;
int SERVICE_INTERROGATE = 0x0080;
int SERVICE_USER_DEFINED_CONTROL = 0x0100;
int SERVICE_ALL_ACCESS = (STANDARD_RIGHTS_REQUIRED |
SERVICE_QUERY_CONFIG |
SERVICE_CHANGE_CONFIG |
SERVICE_QUERY_STATUS |
SERVICE_ENUMERATE_DEPENDENTS |
SERVICE_START |
SERVICE_STOP |
SERVICE_PAUSE_CONTINUE |
SERVICE_INTERROGATE |
SERVICE_USER_DEFINED_CONTROL);
int SERVICE_AUTO_START = 0x00000002;

הפונקציה שלנו תקבל 3 משתנים

string svcPath, string svcName, string svcDispName

את הנתיב הפיסי לסרביס שאנו רוצים להתקין, את שם הסרביס ואת השם שבו הוא יוצג
וכעת להתקנה עצמה:

IntPtr sc_handle =NativeMethods.OpenSCManager(null,
null, SC_MANAGER_CREATE_SERVICE);
if (sc_handle.ToInt32() != 0)
{
IntPtr sv_handle = CreateService(sc_handle,-->c++ native method svcName, svcDispName, SERVICE_ALL_ACCESS, SERVICE_WIN32_OWN_PROCESS,
SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, svcPath, null, 0,
null, null, null);
if (sv_handle.ToInt32() == 0)
{
CloseServiceHandle(sc_handle);-->c++ native method
throw new
ExternalException("Could not create service");
}
}
else
{
throw new
ExternalException("Could not open handle to service manager");
}

כשאנו משתמשים בעצם ב 2 פונקציות מספריית windows
כמובן שצריך להגדיר פונקציות חיצוניות לפני השימוש...:

[DllImport(
"advapi32.dll")]
public static
extern IntPtr OpenSCManager(string lpMachineName,
string lpSCDB, int scParameter);
[DllImport("Advapi32.dll")]
public static
extern IntPtr CreateService(IntPtr SC_HANDLE,
string lpSvcName, string lpDisplayName,
int dwDesiredAccess, int
dwServiceType, int dwStartType, int
dwErrorControl, string lpPathName,
string lpLoadOrderGroup, int
lpdwTagId, string lpDependencies, string lpServiceStartName, string
lpPassword);

ההגדרה DllImport היא ממש לפי המשמעות - אנו מגדירים הפניה ל DLL מקומי, מגדירים איך נראית הפונקציה ואז ניתן לפנות אליה
זה אמור להספיק כדי להתקין את הסרביס...
אם נרצה להסיר אותו השיטה דומה- קודם נעצור אותו בעזרת השיטה שראינו לעיל, אחר כך נקרא לפונקציות חיצוניות כדי להסיר ולמחוק אותו

StopService(svcName);-->out function
int GENERIC_WRITE = 0x40000000;
IntPtr sc_hndl = OpenSCManager(
null, pan class="code_keywords">nunull, GENERIC_WRITE);
-->c++ method
if (sc_hndl.ToInt32() != 0)
{
int DELETE = 0x10000;
IntPtr svc_hndl = OpenService(sc_hndl, svcName,
DELETE);-->c++ method
if (svc_hndl.ToInt32() != 0)
style="color: #a31515" {
int i = DeleteService(svc_hndl);
-->c++ method
if (i != 0)
{
CloseServiceHandle(sc_hndl);-->c++ method
}
else
{
CloseServiceHandle(sc_hndl);-->c++ method
throw new ExternalException("Could not delete service");
}
}
else
throw new
ExternalException("Could not open service");
}
else throw new ExternalException("Could not open handle to service manager");

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

להורדת הפרוייקט

חלק מהקוד נלקח מ http://www.thescripts.com/forum/post932461-9.html

Technorati Tags: ServiceController,WinService

Secure Web Services

tal.nospam@nospam.talgiladi.net (talgiladi) — Fri, 23 May 2008 20:52:00 +0400

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

עכשיו ניצור מחלקה חדשה שתייצג את ה Header שלנו

public class SecurityHeader : System.Web.Services.Protocols.SoapHeader
{
public string username;
public string pass;
}

כעת נגיד לשירות שלנו שהוא אמור לחכות ל Header הזה

[WebMethod]
[SoapHeader("SecurityHeader")]
public string HelloWorldSecure() {

כפי שניתן לראות מדובר בסך הכל בתוספת של שורה אחת
עכשיו עוד דבר קטן, נגדיר משתנה גלובלי מסוג המחלקה של ה Header שלנו

public class SayHello : System.Web.Services.WebService
{
public SecurityHeader secHeader;

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

if (secHeader == null)
{
    return "Please authenticate!";
}
    if (secHeader.username == "tal" && secHeader.pass == "giladi")
{
    return "Shalom " + secHeader.username;
}
    else
{
    return "Bad username or password";
}

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

קראתי להפניה הזאת server_sayHello
ניצור אובייקט של ההפניה הזאת

server_sayHello.SayHello sayHello = new server_sayHello.SayHello();

ניצור הפניה של ה Header שלנו באותה צורה

server_sayHello.SecurityHeader secHeader = new server_sayHello.SecurityHeader();

ניתן ערכים לשם והסיסמה

secHeader.UserName = "tal";
secHeader.Password = "giladi";
sayHello.SecurityHeaderValue = secHeader;

וזהו... פשוט נקרא לשירות:

string result = sayHello.HelloWorldSecure();

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

if (!HttpContext.Current.Request.IsSecureConnection)
{
return "Please use secure connection!";
}

להורדת הפרוייקט

Technorati Tags: WebServices,Security

Save & Retrieve Image from DataBase

tal.nospam@nospam.talgiladi.net (talgiladi) — Mon, 05 May 2008 21:28:00 +0400

משום מה השאלה הזאת נשאלת שוב ושוב בפורומים...
לשמור זה די ברור איך, אני יוצר פקודת sql עם פרמטרים, או stored procedure ,ומעביר אליה את הבתים של התמונה, כמובן שהעמודה בדטה בייס צריכה להיות מסוג image/binary.
לדוגמה:

byte[] imagedata = null;

//now we can get the image bytes with filestream on local system, or from FileUpload on our web page

System.Data.SqlClient.SqlConnection con=new System.Data.SqlClient.SqlConnection("myconstring");

System.Data.SqlClient.SqlCommand com = new System.Data.SqlClient.SqlCommand("insert into images (imagename,imagedata) values (@imagename,@imagedata)", con);

com.Parameters.Add(new System.Data.SqlClient.SqlParameter("@imagename", "myimage.gif"));

com.Parameters.Add(new System.Data.SqlClient.SqlParameter("@imagedata", imagedata));

con.Open();

com.ExecuteNonQuery();

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

byte[] b=null;//get bytes from data base... b=(byte[])com.ExecuteScalar("select imagedata from myimages where...)

MemoryStream ms=new MemoryStream(b);

System.Drawing.Bitmap bm = new System.Drawing.Bitmap(ms);

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

נניח שיש לי דף PictureGallery.aspx
בתוך הדף אני רוצה להציג תמונות שימשכו מהדטה בייס. אני יוצר דף מיוחד שכל תפקידו הוא למשוך תמונה מהדטה בייס ולשלוח אותה ללקוח, נקרא לו PictureView.aspx
בדף PictureGallery.aspx אני שם לינקים לדף PictureView.aspx בתור כתובת של תמונה:

וככה מוסיף תמונות כמה שארצה. כעת בדף PictureView.aspx הקוד יראה משהו כמו:

byte[] b = (byte[])com.ExecuteScalar("select imagedata from myimages where imageid=" + Request.Params["imgid"]);

Response.ContentType = "image/jpeg";

Response.BinaryWrite(b);

Response.End();

Technorati Tags: Sql,SqlParameter

Zip

tal.nospam@nospam.talgiladi.net (talgiladi) — Tue, 15 Apr 2008 21:16:00 +0400

כיווץ בפורמט zip ניתן לביצוע בפשטות בדוט נט עם המחלקות היעודיות לכך.
קודם יש להוסיף את השורה using System.IO.Compression
וכעת ניתן להשתמש במחלקה שנקראת GZipStream

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

קודם נבחר איזה קובץ אנחנו רוצים לקבץ:

FileStream source = new FileStream(Server.MapPath("myfile.txt"), FileMode.Create);

את הקובץ שאליו נשמור את המידע המכווץ:

FileStream target = new FileStream(Server.MapPath("myzip.zip"), FileMode.Create);

נבנה את האובייקט ונבחר באופצית הכיווץ:

GZipStream zip = new GZipStream(target , CompressionMode.Compress);

וכעת נעביר את הבתים מקובץ המקור לקובץ המטרה:

int bytesCount;
byte[] buffer=new byte [1024];
while((bytesCount = source .Read(buffer, 0, buffer.Length)) != 0)
{
zip.Write(buffer, 0, bytesCount);
}
target.Close();
zip.Close();

לא לשכוח לסגור את הקובץ בסוף!
ובשביל לקרוא קובץ מכווץ התהליך דומה, נפתח את הקובץ שמכיל את המידע המכווץ:

FileStream source = new FileStream(Server.MapPath("myzip.zip"), FileMode.Open);

את הקובץ שאליו נשמור את המידע שנפתח:

FileStream target = new FileStream(Server.MapPath("myfile.txt"), FileMode .Create);

נבנה את האובייקט וכעת נחבר באופצית הפתיחה, לא כיווץ:

GZipStream zip = new GZipStream(source, CompressionMode .Decompress);

וכעת נעביר את הבתים מהזיפ שלנו לקובץ המטרה:

int bytesCount;
byte[] buffer=new byte [1024];
while ((bytesCount = zip.Read(buffer, 0, buffer.Length)) != 0)
{
target .Write(buffer, 0, bytesCount);
}
target.Close();
zip.Close();

להורדת הפרוייקט

Technorati Tags: GZipStream,Zip

Weak Reference

tal.nospam@nospam.talgiladi.net (talgiladi) — Thu, 03 Apr 2008 20:49:00 +0400

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

Bitmap picture=new Bitmap("pic.gif");

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

Bitmap pic2=picture;

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

picture=null;

עד כאן הייתה ההקדמה שרובנו יודעים. עכשיו לנושא שלנו. נניח שאני רוצה לשמור בזיכרון הפניה לאובייקטים כדי לא לפנות אליהם כל פעם מחדש, לדוגמה DataSet מתוך דטה בייס. אם אני אתחיל למלא את הזיכרון במידע הוא עשוי להיגמר, מצד שני אני רוצה שהאפליקציה תרוץ מהר ולא תמשוך כל פעם מהדטה בייס... בשביל זה ניתן להשתמש ב WeakReference. המחלקה הזאת מוסיפה הפניה לאובייקט, כך שהוא לא נמחק מהזיכרון, אך זאת הפניה "חלשה", זאת אומרת שאנחנו לא מכריחים את סביבת הריצה לשמור את האובייקט תמיד בזיכרון, זאת יותר מעין בקשה - תשמרו לי הפניה לאובייקט, אבל אם הזיכרון מתחיל להיגמר אתם יכולים למחוק אותו ואז ההפניה שלי תצביע לאובייקט שלא קיים...
זה כל הסיפור... שימו לב לקוד:

System.Drawing.Bitmap picture=new System.Drawing.Bitmap("pic.gif");//we save a big object in memory
WeakReference wr = new WeakReference(picture);//assign a weak reference to it
picture = null;//dispose the strong reference
//do other stuff
System.Drawing.Bitmap mypicture = wr.Get() as System.Drawing.Bitmap;//we try to get our picture
if (mypicture == null)//we check if it still exists... null? it has bee disposed already...
{
mypicture = new System.Drawing.Bitmap("pic.gif");
}

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

Technorati Tags: WeakReference

מציאת מיקום אלמנט בדפדפן

tal.nospam@nospam.talgiladi.net (talgiladi) — Wed, 02 Apr 2008 09:46:00 +0400

Technorati Tags: javascript,position

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

הפונקציה הראשונה - שולחים לה את האובייקט (לא את השם שלו...) והיא מחזירה אובייקט עם ערך x וערך y

function zxcPos(zxcobj){
    var position = new Object;
    zxclft=zxcobj.offsetLeft;
    zxctop=zxcobj.offsetTop;
    while(zxcobj.offsetParent!=null){
        zxcpar=zxcobj.offsetParent;
        zxclft+=zxcpar.offsetLeft;
        zxctop+=zxcpar.offsetTop;
        zxcobj=zxcpar;
    }
    position.x=zxctop;
    position.y=zxclft;
    return position;
}

הפונקציה שניה בנויה משני פונקציות בעצם, אחת מחזירה את המיקום x ואחת את המיקום y

File Permissions

tal.nospam@nospam.talgiladi.net (talgiladi) — Fri, 07 Mar 2008 09:41:00 +0400

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

Technorati Tags: File Security,access rights,permissions

fs = File.GetAccessControl(this.filename);

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

FileSystemAccessRule ar = new FileSystemAccessRule("Everyone", FileSystemRights.FullControl, AccessControlType.Deny);

המחלקה זאת מקבלת את שם הקבוצה שעליה יחול הכלל - EVERYONE, את סוג הגישה לקובץ - FULLCONTROL, והאם להרשות/לאסור - DENY

נוסיף את הכלל החדש לרשימת הכללים של הקובץ

fs.AddAccessRule(ar);

כעת רק נשאר לשמור את הכלל החדש

File.SetAccessControl(this.filename, fs);

והתוצאה

כעת כדי להסיר את הכלל שעשינו נבצע את אותו התהליך, רק הפוך

FileSecurity fs = File.GetAccessControl(this.filename);
FileSystemAccessRule ar = new FileSystemAccessRule("Everyone", FileSystemRights.FullControl, AccessControlType.Deny);
fs.RemoveAccessRule(ar );
File.SetAccessControl(this.filename, fs);

שימו לב שבנינו שוב את הכלל הזה שאוסר גישה לקובץ, רק הפעם השתמשנו בפונקציה RemoveAccessRule כדי להוריד אותו מהקובץ

להורדת פרוייקט דוגמה

Server Execute

tal.nospam@nospam.talgiladi.net (talgiladi) — Mon, 03 Mar 2008 09:26:00 +0400

אם אני רוצה לשלב בתוך הדף שלי פלט של דפים אחרים במערכת(לא header או footer שאותם ניתן לשלב ב masterpage...), משהו שיהיה תלוי באיזה משתנה למשל, אז בעבר הלא רחוק היה נהוג להשתמש ב include, למשל, אם נכנסתי לדף בתור משתמש רגיל אזי הייתי רוצה לכלול את הקובץ:
<-- #include File = "c:\Inetpub\wwwroot\MyApplication\userWelcome.asp" -->
ואם בתור מנהל אז קובץ אחר...
<-- #include File = "c:\Inetpub\wwwroot\MyApplication\ManagerWelcome.asp" -->

הבעיה עם הקוד הזה היא שהשרת היה מריץ את הקובץ שאני רוצה להכליל, עוד לפני שהוא בודק את התנאי שלי, מה שאומר שהוא בעצם הריץ גם את הקובץ למנהל וגם את הקובץ למשתמש רגיל בעת הכניסה לדף, ורק אז היה בודק את התנאי והיה מציג את התוכן שרציתי.
ואם היו לי 8 כאלה בדף...?

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

<html>
<body>
<H1>Company Name</H1>
<% string lang = Request.ServerVariables["HTTP_ACCEPT_LANGUAGE"];
lang = lang.SubString(0,2);
Server.Execute(lang+"Welcome.asp") ; %>

</body> </html>

להורדת הפרוייקט

msdn at microsoft

Technorati Tags: ServerExecute

Reflection for Unit Testing

tal.nospam@nospam.talgiladi.net (talgiladi) — Sun, 02 Mar 2008 17:34:00 +0400

רוב מה שאני כותב בקשר לרפלקשן אני משתמש לצורך ה unit testing שלי, בדרך כלל אני מנסה להימנע משימוש בזה בייצור.
עם כל ההנאה שיש בקוד דינאמי, לא תמיד אני יכול להרשות את זה לעצמי, בעיקר בגלל נושא הביצועים.

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

FieldInfo a;

FieldInfo b;

Assert.AreEqual(a.FieldType, b.FieldType, "field type");

Assert.AreEqual(a.IsAssembly, b.IsAssembly, "is assembly");

וכך עבור כל פרופרטי שיש לאובייקט. ואז אמרתי לעצמי, למה להיות חמור? בסך הכל אתה משווה ערכים, תכתוב כבר פונקציה שתעשה את זה בשבילך. וזה מה שיצא לי:

public static void CompareObjects(object a, object b)

{

if (a == null) Assert.Fail("a is null");

if (b == null) Assert.Fail("b is null");

Type t1 = a.GetType();

Type t2 = b.GetType();

if (t1 != t2)

{

Assert.Fail("Type a (" + t1.Name + ") is not as type as type b(" t2.Name + ")");

}

PropertyInfo[] pi = t1.GetProperties();

for (int i = 0; i < pi.Length; i++)

{

object val1 = pi[i].GetGetMethod().Invoke(a, null);

object val2 = pi[i].GetGetMethod().Invoke(b, null);

Assert.AreEqual(val1, val2, pi[i].Name);

}

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

public static void CompareObjects(object a, object b, string[] exclude)

{

if (a == null) Assert.Fail("a is null");

if (b == null) Assert.Fail("b is null");

Type t1 = a.GetType();

Type t2 = b.GetType();

if (t1 != t2)

{

Assert.Fail("Type a (" + t1.Name + ") is not as type b (" + t2.Name + ")");

}

PropertyInfo[] pi = t1.GetProperties();

for (int i = 0; i < pi.Length; i++)

{

if (exclude != null && Array.IndexOf<string>(exclude, pi[i].Name) > -1)

{

continue;

}

object val1 = pi[i].GetGetMethod().Invoke(a, null);

object val2 = pi[i].GetGetMethod().Invoke(b, null);

Assert.AreEqual(val1, val2, pi[i].Name);

}

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

Customer a;

Customer b;

CompareObjects(a, b, new string[] { "Id", "LastUpdate" });

Technorati Tags: Reflection,UnitTesting

מיון לפי עמודה משתנה ב Stored Procedures

tal.nospam@nospam.talgiladi.net (talgiladi) — Wed, 23 Jan 2008 17:29:00 +0400

Technorati Tags: sql,sort,stored procedure

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

create procedure temp1
@sortName varchar(20)
as
begin
select * from article order by @sortName
end

אז מה כן עושים אם אנו עדיין רוצים להמשיך להשתמש ב stored procedures וגם לאפשר מיונים לפי שדות שונים?
אז צריך קצת להתחכם, וגם לסרבל, אבל עדיין נראה לי שזה שווה את זה...
נניח שיש לי 2 עמודות שניתן למיין לפיהן, וגם ניתן למיין בסדר עולה או יורד. אז נכון שתמיד ניתן להשתמש ב sp_executesql , אבל אז הלכה כל התועלת של שימוש ב stored procedure... מישהו פעם הציע לי לבנות 4 stored procedures... כמובן שזה לא סביר... אבל נעשה משהו די דומה:)

create procedure temp1
@sortName varchar(20),
@sortDirection varchar(4)='asc'
as
begin
select * from article order by

case WHEN @sortName = 'article_id' and @sortDirection='asc' THEN article_id end asc,
case WHEN @sortName = 'article_id' and @sortDirection='desc' THEN article_id end desc,
case WHEN @sortName = 'publish_date' and @sortDirection='asc' THEN publish_date end asc,
case WHEN @sortName = 'publish_date' and @sortDirection='desc' THEN publish_date end desc
end

חתימה דיגיטלית

tal.nospam@nospam.talgiladi.net (talgiladi) — Fri, 18 Jan 2008 18:08:00 +0400

Technorati Tags: digital signature,encryption

חתימה דיגיטילית זה בעצם שילוב של מפתח ציבורי/פרטי עם האש. אני רוצה להשיג 2 מטרות בבת אחת- גם לוודא שהמכתב שהנמען קורא הוא המכתב שאני כתבתי והמידע בו לא השתנה, וגם שזהו אכן מכתב שאני כתבתי ולא מישהו אחר. כדי להשיג את המטרה הראשונה, אנחנו משתמשים בהאש – כך אנו מוודאים שהמידע במכתב לא השתנה, והמטרה השניה מושגת על ידי שימוש בהצפנה על ידי המפתח הפרטי שלי- אבל הצפנה רק של ערך ההאש, לא של המכתב כולו.

ועכשיו לקצת קוד:

using System.Security.Cryptography;

DSACryptoServiceProvider dsa = new DSACryptoServiceProvider();

* ניתן באופן זהה במחלקה RSACryptoServiceProvider ושם ניתן גם לציין את האלגוריתם לביצוע ההאש.

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

dsa.FromXmlString(privatekey);

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

string publickey = dsa.ToXmlString(false);

זהו בעצם, עכשיו פשוט נייצר את החתימה:

byte[] signature = dsa.SignData(mydata);

וניתן להפוך לסטרינג כמובן:

string result = Convert.ToBase64String(signature);

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

1. ניצור אובייקט מהמחלקה המתאימה:

DSACryptoServiceProvider dsa = new DSACryptoServiceProvider();

2. ניתן לו את המפתח הציבורי שקיבלנו:

dsa.FromXmlString(publickey);

3. וכעת ניתן לו את המידע עצמו ואת החתימה ונקבל ערך בוליאני האם החתימה מתאימה או לא:

bool match = dsa.VerifySignature(data, signature);

וזהו...

להורדת קבצי המקור והפרוייקט

FCKEditor - עורך HTML

tal.nospam@nospam.talgiladi.net (talgiladi) — Tue, 25 Dec 2007 09:44:00 +0400

ראיתי מספר פעמים ששאלו על FCKEditor בקשר להתקנה ותיפעול אז צירפתי הוראות פשוטות אני מקווה שלא תתקלו בבעיות...

קודם נלך לאתר שלהם ונוריד את הגירסה הרגילה

אחר כך נוריד את התוסף לדוט נט

נפתח את קובץ הזיפ הראשון לתיקיה בשם fckeditor בתיקית ה root של האתר שלנו
לקובץ השני שהוא התוסף לדוט נט אנחנו צריכים להוסיף הפניה פשוט ולהראות לויז'ואל סטודיו את הקובץ המתאים (נמצא בתיקיית bin\Release\2.0 בזיפ השני שפתחנו)
כעת נלך לדף שבו אנו רוצים להוסיף את האדיטור, ונוסיף למעלה הפניה ל dll של האדיטור כך:

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>
<%@ Register Assembly="FredCK.FCKeditorV2" Namespace="FredCK.FCKeditorV2" TagPrefix="FCKeditorV2" %>

ונוסיף את האדיטור במקום שאנו רוצים בדף כמו כל קונטרול אחר

<FCKeditorV2:FCKeditor ID="FCKeditor1" BasePath="fckeditor\" runat="server" Height="345px"> </FCKeditorV2:FCKeditor>

הפרמטר הכי חשוב כאן זה בעצם הנתיב לספריה שלו - שזה אצלנו fckeditor ששם הוא מוצא את כל הקבצים שלו
בקוד שלנו אנו ניגשים אליו לפי ה ID כמובן וכך אפשר להכניס לו HTML מראש ולמשוך אחר כך את ה HTML שהמשתמש ערך בו
ישנה עוד נקודה אחת רק... קטנה אבל בעייתית, למרות שבגירסה האחרונה היא לא התעוררה, אז אתם יכולים להתפלל שהיא גם לא תופיע... אבל בכל מקרה טוב לדעת על הנושא.
כידוע יש את אלמנט ההתקפה שנקרא XSS ומתבצע דרך סקריפטים שנשלחים לשרת ואז מוצגים שוב למשתמשים. שרת הדוט נט, במטרה להפחית את הסבירות, זורק exception אם הוא מקבל לשרת כל מידע שמתחיל עם > ואחריו איזושהי אות ,מה שאומר שזה בעצם כל תגית ב html. כך שאם תנסו בטקסט בוקס רגיל או באיזה פרמטר בשורת הכתובת להכניס את המילה <script> תקבלו שגיאה מאוד נחמדה מהשרת:

"A potentially dengerous Request..."

קוראים לתכונה הזאת Request Validation וניתן לבטל את זה, רק שתדעו שפעם מישהו אמר:

" אתה חייב לדעת טוב מאוד מה אתה עושה כדי לבטל את ה Request Validation, ואם אתה אכן יודע טוב מאוד מה אתה עושה, אז אתה לא תבטל את ה Request Validation"
אני ביטלתי כמה פעמים :)

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

ValidateRequest="false" EnableEventValidation="false"

להורדת פרוייקט דוגמה

Technorati Tags: fckeditor,html editor

Custom web controls

tal.nospam@nospam.talgiladi.net (talgiladi) — Sun, 09 Dec 2007 17:04:00 +0400

Technorati Tags: custom web control

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

או שניתן ליצור פרוייקט חדש, והתוצאה שלו תהיה dll שניתן להוסיף לאתר שלנו

יש הבדלים בין השיטות. בדרך הראשונה, הקונטרול יהיה זמין רק לאתר שבו יצרתי אותו, אני לא אוכל להשתמש בו באתרים אחרים. מצד שני, כל תהליך הבניה הוא קל יותר כי לא צריך לקמפל מחדש כל פעם , הוא מתקפל אוטומטית כמו כל שאר הדפים באתר. הקונטרול בצורה הזאת יורש מהמחלקה System.Web.UI.UserControl
בשיטה השניה זה הפוך כמובן... אני יכול להוסיף הפניה ל dll שנוצר מכל פרוייקט ווב שארצה, אך מצד שני פחות נוח בתהליך הפיתוח לקמפל מחדש כל פעם את הפרוייקט. ישנם עוד הבדלים קטנים בצורת כתיבת הקוד ובקריאת לאירועים של הקונטרול . הקונטרול בצורה הזאת יורש מ WebControl

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

[ToolboxData("<{0}:LightCaptchaControl runat=server></{0}:LightCaptchaControl>")]

public class LightCaptchaControl : WebControl

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

public class LightCaptchaControl : WebControl, INamingContainer

שאינה רלוונטית לקונטרול שלנו. כפי שניתן לנחש, התגית ToolboxData אומרת כיצד יראה הקוד בדף ה aspx לאחר שנזרוק את הקונטרול על הדף, כש {0} זה הערך שניתן בדף ל TagPrefix

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

[Browsable(false)]

מעל פרופרטי שאמור להיות מוחבא. התגית:

[Category("Appearance")]

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

protected override void RenderContents(HtmlTextWriter output)

{

output.Write(Text);

}

המתודה הזאת נקראת על ידי הדף כשהוא מוכן לשלב את פלט ה HTML של הקונטרול שלנו בתוכו. היא המתודה שבה אנו כותבים את הפלט הסופי של הקונטרול שלנו וזהו בעצם ה HTML שיוצג על הדף. כפי שניתן לראות המחלקה מקבלת פרמטר מסוג HtmlTextWriter(כתבתי עליו כמה מילים במקום אחר).
אם נשים את הקונטרול עכשיו על דף ונריץ, נקבל בעצם טקסט ריק, כי זה מה שהמתודה הזאת מדפיסה לדף
טוב, נמשיך. מה יעשה הקונטרול שלנו? הוא יהיה כמו captcha זולה... אנו נציג טקסט בוקס, עם שאלה במתמטיקה לידו, והגולש אמור להכניס את התשובה. כשעושים פוסטבאק לשרת הקונטרול שלנו בודק את התשובה ויכול להודיע לדף שאכן היא נכונה ורוב הסיכויים שהגולש איננו סקריפט אוטומטי. כמובן שאי אפשר להציג את השאלה בצורת טקסט פשוט כי אז הסקריפט פשוט ימצא את הפיתרון, אבל זו כבר בעיה אחרת שאולי יהיה לנו זמן גם לפתור...
אז אנחנו צריכים לייבל, שיודיע לגולש שהוא אמור לענות על השאלה שלנו, טקסט בוקס שאליו יכניסו את התשובה, ועוד לייבל שיציג את התרגיל במתמטיקה. כמובן שאפשר להוסיף ולידטור, ואפשר אפילו להוסיף לינק כדי שאפשר יהיה לבחור תרגיל אחר אבל זה לא עכשיו...
כדי להוסיף קונטרולים אחרים לקונטרול שלי , אני צריך להוסיף מתודה אחרת שנקראת על ידי הדף והיא:

protected override void CreateChildControls()

{

}

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

protected override void CreateChildControls()

{

////the label with the text asking

///the user to answer the question

Label lblText = new Label();

lblText.Text = this.Text;

lblText.ID = "lblText";

this.Controls.Add(lblText);

////the text box with the answer

TextBox txtAnswer = new TextBox();

txtAnswer.ID = "txtAnswer";

this.Controls.Add(txtAnswer);

////The label with the methematics question

Label lblQuestion = new Label();

lblQuestion.ID = "lblQuestion";

this.Controls.Add(lblQuestion);

}

ללייבל lblQuestion עדיין לא שמתי ערך טקסט כי עדיין לא חשבנו איך ניצור את התרגיל המתמטי, אבל נחזור לזה אחר כך. lblText קיבלה את ערך הטקסט של הפרופרטי Text מהקונטרול שלנו, כך שכשהמשתמש יעצב את הקונטורל וישנה לו את ערך הטקסט, זה מה שיוצג לגולש.

בואו נוסיף אתר לפרוייקט שלנו, כדי שנוכל לראות את הקונטרול שלנו בפעולה(או שאפשר להוסיף הפניה ל dll מאתר קיים כמובן)

נלך לעיצוב הדף, ארגז כלים, לחצן ימני - choose items כדי להוסיף את הקונטרול שלנו לארגז הכלים

בחלון שנפתח נלחץ על Browse ונחפש את תיקיית הפרוייקט שלנו, שם בתוך תיקיית bin\debug נמצא את ה dll שלנו. אם הוא לא שם אז לא עשיתם build לפרוייקט או שתחפשו בספריית release. לחיצה על OK והקונטרול מופיע בארגז הכלים. תמשכו אותו לדף. אם יש איזו בעיה אז אתם תראו, אם לא, אז אנו רואים דף חלק... ואיפה הקונטרולים שלנו? זה שהוספנו אותם זה לא מספיק עדיין, אנו צריכים לרנדר אותם...
אז בחזרה לקונטרול שלנו, כבר יש שם פונקציה מתאימה:

protected override void RenderContents(HtmlTextWriter output)

אפשר לרנדר בריצה בלולאה:

for (int i = 0; i < this.Controls.Count; i++)

{

this.Controls[i].RenderControl(output);

}

אבל אני מעדיף למצוא כל אחד מהקונטרולים ולרנדר אותו:

Label lbl = (Label)this.FindControl("lblText");

lbl.RenderControl(output);

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

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

[Bindable(true)]

[Category("Appearance")]

[DefaultValue("Please enter the answer")]

[Localizable(true)]

public string Text

{

get

{

String s = (String)ViewState["Text"];

return ((s == null) ? "Please enter the answer" : s);

}

set

{

ViewState["Text"] = value;

}

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

והמחלקה שלנו:

public class Question:ICloneable

{

private double _answer;

public double Answer

{

get { return _answer; }

set { _answer = value; }

}

private List<string> _items;

public List<string> Items

{

get {

if (_items == null)

{

_items = new List<string>();

}

return _items; }

set { _items = value; }

}

#region ICloneable Members

public object Clone()

{

Question q = new Question();

q.Answer = this.Answer;

q.Items = new List<string>();

q.Items.AddRange(this.Items);

return q;

}

#endregion

}

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

public class QuestionsGenerator

{

private Question _question;

private Question Question

{

get

{

if (_question == null)

{

Generate();

}

return _question;

}

private int _itemsCount;

public int ItemsCount

{

get

{

return (int)Math.Max(_itemsCount, 2);

}

set { _itemsCount = value; }

}

private int _maxNumber;

public int MaxNumber

{

get

{

return (int)Math.Max(10, _maxNumber);

}

set { _maxNumber = value; }

}

public QuestionsGenerator()

{

this.MaxNumber = 10;

this.ItemsCount = 4;

}

public double Result

{

get

{

return Question.Answer;

}

public Question Source

{

get

{

return (Question)Question.Clone();

}

public override string ToString()

{

StringBuilder sb = new StringBuilder();

for (int i = 0; i < this.Question.Items.Count; i++)

{

sb.Append(Question.Items[i]);

sb.Append(" ");

}

return sb.ToString();

}

private void Generate()

{

this._question = new Question();

Question.Answer = new Random().Next(0, MaxNumber);

Question.Items.Add(Question.Answer.ToString());

for (int i = 0; i < ItemsCount-1; i++)

{

AddPair();

}

private enum Sign

{

Plus,

Minus,

Multiply,

Divide

}

private void AddPair()

{

System.Security.Cryptography.RandomNumberGenerator rng = System.Security.Cryptography.RandomNumberGenerator.Create();

byte[] b=new byte[1];

rng.GetBytes(b);

int next = (int)b[0] % MaxNumber;

Sign s = (Sign)Enum.Parse(typeof(Sign), ((int)b[0]%4).ToString());

switch (s)

{

case Sign.Plus:

Question.Answer = Question.Answer + next;

Question.Items.Add("+");

break;

case Sign.Minus:

Question.Answer = Question.Answer - next;

Question.Items.Add("-");

break;

case Sign.Multiply:

Question.Answer = Question.Answer * next;

Question.Items.Add("*");

break;

case Sign.Divide:

bool found = false;

for (int i = 0; i < 5; i++)

{

if (Question.Answer % next != 0)

{

next++;

}

else

{

found = true;

break;

}

if (!found)

{

next = 1;//dont' get complicated now...

}

Question.Answer = (int)(Question.Answer / next);

Question.Items.Add("/");

break;

}

Question.Items.Add(next.ToString());

}

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

lbl = (Label)this.FindControl("lblQuestion");

QuestionsGenerator qg = new QuestionsGenerator();

lbl.Text = qg.ToString();

lbl.RenderControl(output);

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

lbl = (Label)this.FindControl("lblQuestion");

QuestionsGenerator qg = new QuestionsGenerator();

HttpContext.Current.Session.Add("LightCaptchaControl_answer", qg.Result);

lbl.Text = qg.ToString();

lbl.RenderControl(output);

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

[Browsable(false)]

public bool IsValid

{

get

{

double result;

if (double.TryParse(((TextBox)this.FindControl("txtAnswer")).Text, out result))

{

if (HttpContext.Current.Session["LightCaptchaControl_answer"] != null)

{

return result == (double)HttpContext.Current.Session["LightCaptchaControl_answer"];

}

return false;

}

וזהו... עכשיו מי שמשתמש בקונטרול צריך בסך הכל לבדוק את הפרופרטי הזה:

protected void btnSubmit_Click(object sender, EventArgs e)

{

bool valid = this.LightCaptchaControl1.IsValid;

}

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

public string ToRandomHtml()

{

char[] chars="abcdefghijklmnopqrstuvwxyz1234567890".ToCharArray();

StringBuilder sb = new StringBuilder();

for (int i = 0; i < this.Question.Items.Count; i++)

{

System.Security.Cryptography.RandomNumberGenerator rng = System.Security.Cryptography.RandomNumberGenerator.Create();

byte[] b = new byte[1];

rng.GetBytes(b);

int ran = (int)b[0] % 5;

switch (ran)

{

case 0:

sb.Append(Question.Items[i]);

sb.Append(new String(' ',new Random().Next(4)));

break;

case 1:

sb.Append(Question.Items[i]);

sb.Append("<span style=\"display:none\">");

sb.Append(Question.Items[i]);

sb.Append("</span>");

break;

case 2:

sb.Append("<span style=\"display:none\">");

sb.Append(Question.Items[i]);

sb.Append("</span>");

sb.Append(Question.Items[i]);

break;

case 3:

sb.Append("<b>");

sb.Append(Question.Items[i]);

sb.Append("</b>");

break;

case 4:

sb.Append("<u>");

sb.Append(Question.Items[i]);

sb.Append("</u>");

break;

}

return sb.ToString();

}

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

להורדת הפרוייקט ודוגמה

דיפדוף באמצעות אג'קס

tal.nospam@nospam.talgiladi.net (talgiladi) — Tue, 04 Dec 2007 15:40:00 +0400

Technorati Tags: javascript,paging,ajax

.התחלנו כבר לדבר על דיפדוף יעיל בדטה בייס בעבר, עכשיו נמשיך את זה לצד הלקוח
נשתמש באג'קס ליישום הדיפדוף (אני משתמש ב framework לנוחות, אבל כל אג'קס יעשה את העבודה)
נתחיל בבניית הטבלה בדף, אנחנו כבר יודעים איך למשוך את הנתונים כך שנקבל רק את השורות המתאימות לדף שלנו, אז פשוט נזרוק את כל הנתונים לדף בצורת טבלה. את הטבלה נשים בתוך div עם id

נבנה בדף פונקציה שתמשוך לנו את הנתונים מה ADP

private string GetTable()
{
    int pagenum;
    if (!int.TryParse(Request.Params["pagenum"], out pagenum))
    {
        pagenum = 1;
    }
    int rowsPerPage = 10;
    string sortByColumn = Request.Params["sortName"];
    if (string.IsNullOrEmpty(sortByColumn)) sortByColumn = "id";
    string sortOrder = Request.Params["sortOrder"];
    if (string.IsNullOrEmpty(sortOrder)) sortOrder = "asc";
    DataTable table = ADP.GetUsers(pagenum, rowsPerPage, sortByColumn, sortOrder);
    StringBuilder sb = new StringBuilder();
    sb.Append("<table><tr><td>id</td><td>name</td></tr>");
    foreach (DataRow dr in table.Rows)
    {
        sb.Append("<tr>");
        sb.Append("<td>");
        sb.Append(dr["id"]);
        sb.Append("</td>");
        sb.Append("<td>");
        sb.Append(dr["name"]);
        sb.Append("</td>");
        sb.Append("</tr>");
    }
    sb.Append("</table>");
    return sb.ToString();
}

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

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

int rowsCount =ADP.GetUsersCount();
int rowsPerPage = 10;
int totalPages=(int)Math.Ceiling((double)rowsCount / rowsPerPage);

הפייג'ר עצמו בדף html:

<%for (int i=0;i<totalPages;i++)
{ %>
<a href="javascript:doPaging(<%=(i+1)%>)"><%=(i+1)%></a>
%<}%>

ופונקציית ג'אווה קטנה

זהו, בשביל הדפדוף זה מספיק... רק בשביל המיון צריך עוד 2 דברים קטנים לעשות. קודם כל כשאנו בונים את הטבלה, אז בכותרות להוסיף הפניה לפונקציה של ג'אווה סקריפט כדי שכשמקליקים על הכותרת יתבצע מיון
נשנה מעט את איך שבנינו את הטבלה מקודם במקום לכתוב id בכותרת נכתוב <a href=\"javascript:doSort('id');\">id</a> ,וכך לגבי שאר הכותרות, ונבנה את הפונקציה המתאימה בג'אווה סקריפט

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

להורדת דוגמה (ללא דטה בייס כמובן)

ILMerge - לאיחוד קבצים

tal.nospam@nospam.talgiladi.net (talgiladi) — Sun, 02 Dec 2007 10:02:00 +0400

קרה לי מספר פעמים שכתבתי תוכנה שמשתמשת ב dll מצד שלישי, ושלא רציתי שהצד שמקבל את התוכנה יראה את הקבצים האלה, מסיבות שלי... ואז חיפשתי ומצאתי את הכלי הזה שבעצם מאחד dllים... חוץ מזה שלפעמים זה נחמד שיש לך קובץ אחד ולא 10 מפוזרים...
השימוש מאוד פשוט - פשוט תנו לתוכנה הזאת את הקבצים שאתם רוצים לאחד ואת שם הקובץ הסופי והיא כבר תאחד אותם.
רק שימו לב למספר נקודות:

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

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

Ilmerge MyApplication.exe ThirdPartyApplication.dll /out:MyApplication.exe

ניתן להוריד את התוכנה מאתר מיקרוסופט , וראיתי שכבר כתבו כלים גרפיים להריץ אותה, כשהראשון נכתב על ידי ישראלים :)

Technorati Tags: Ilmerge,join dlls

דיפדוף יעיל

tal.nospam@nospam.talgiladi.net (talgiladi) — Sat, 01 Dec 2007 15:30:00 +0400

Technorati Tags: sql,paging

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

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

ניצור טבלה בשם t1 עם 3 עמודות:

מספר השורות שאנחנו רוצים להציג בדף

const int rowsPerPage=2;

משתנה שמכיל את מספר המזהה של השורה האחרונה שמשכנו (בפעם הראשונה הוא יהיה 0 כמובן):

int lastid=0;

השאילתה :

sql:Sel ect top [rowsPerPage] from t1 where id>[lastid] order by id

MySql : Sel ect * from t1 where id>[lastid] order by id limit [rowsPerPage]

כעת נשמור לנו את המספר המזהה של הרשומה האחרונה שמשכנו -3 את המספר כאמור ניתן לשמור או בסשן (לא מומלץ) או בדף עצמו - למשל בלחצן שמעביר לדף הבא - להוסיף לו את הפרמטר הזה.

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

Sql :Sel ect top 2 * from t1 where id>3 order by id

MySql: Sel ect * from t1 where id>3 order by id limit 2

וכך הלאה לשאר הדפים.

החסרונות ברורים:

לא ניתן למיין לפי עמודות אחרות שכן אנחנו חייבים עמודה עם מזהה יחודי

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

כדי לנסות לפתור את 2 המגבלות האלה, ניתן לשכלל קצת את הפיתרון שלנו כפי שמופיע באתר של מיקרוסופט

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

int pageNum=1;

Sql : select top [rowsPerPage] * from (select top [rowsPerPage*pageNum] * from t1 order by name desc) as t2 order by name
Mysql : select * from (select * from t1 order by name desc limit [rowsPerPage*pageNum]) as t2 order by name limit [rowsPerPage]

דבר נוסף שחסכנו זה את הצורך לשמור את האינדקס של העמודה האחרונה, אנחנו ישר בוחרים לפי מספר הדף שהלקוח לחץ עליו. נניח שהוא לחץ על דף מספר 3, ואנו כאמור רוצים להציג 2 שורות בכל דף, אזי השאילתה תהיה :

MySql : sel ect * from (SEL ECT * FROM t1 order by name desc limit 6) as t2 order by name limit 2

Sql :sel ect top 2* from( sel ect top 6 * from t1 order by name desc) as t2 order by name

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

MySql : sel ect * from (SEL ECT * FROM t1 order by gender desc limit 6) as t2 order by gender limit 2

Sql : sel ect top 2 * from (sel ect top 6 from t1 order by gender desc) as t2 order by gender

עדיין אנחנו לא יכולים למיין לפי עמודת "מין"...

אז מה כן עושים? טוב, אז אם יש לנו Sql Server 2005 או MySql הפיתרון יעיל וקל. לא משנה לפי איזו עמודה אני רוצה למיין:

ב sql server 2005 נכתוב

select * ,rank from (select *, row_number() over(order by gender desc) as rank from t1) as t2 where rank between [(pageNum-1)*rowsPerPage+1] and [(pageNum-1)*rowsPerPage+rowsPerPage]

וב MySql הרבה יותר פשוט, פשוט נכתוב

select * from clients limit [(pageNum-1)*rowsPerPage],[rowsPerPage]

והתוצאה כצפוי:

MySql : sel ect * from t1 order by gender limit 2,2

Sql : sel ect *,rank from

(sel ect *,row_number() over(order by gender desc) as rank from t1 ) as t2

where rank between 7 and 8

אבל מה עושים אם אני עובד עם שרת אחר?

אז הפיתרון קצת יותר איטי ויותר מסובך, אבל עדיין יותר יעיל מלמשוך את כל הרשומות אלי לדף...

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

Create table temp1 (tid int not null primary key auto_increment/identity,foreign_id int)

* אם אני לא סוגר את החיבור לדטה בייס במהלך הפונקציה אז ניתן ליצור את הטבלה בתור טבלה זמנית ואז היא תימחק אוטומטית בעת סגירת החיבור- יותר מהיר ויותר נקי....

כעת נעביר לטבלה הזאת את מספרי האינדקס מהטבלה המקורית, כשהם כבר ממויינים לפי העמודה שאני רוצה:

Insert into temp1 (foreign_id) select id from t1 order by gender

וכעת אני יכול לבחור את מספרי השורות שאני רוצה:

Select * from t1, temp1 where t1.id=temp1.foreign_id and temp1.tid between [(pageNumber-1)*rowsPerPage+1] and [(pageNumber-1)* rowsPerPage+rowsPerPage]

והתוצאה כצפוי:

sel ect t1.* from temp1,t1 where t1.id=temp1.foreign_id and temp1.tid between ((2-1)*2+1) and ((2-1)*2+2) order by gender

רק לא לשכוח בסוף למחוק את הטבלה אם לא השתמשנו בטבלה זמנית...

* יש דרך לשיפור המהירות של השיטה האחרונה באתר 4guysfromrolla
* ניתן להשתמש ב stored procedures ליעול המהירות