משחקי קוד

Finding identical items on a list

tal.nospam@nospam.talgiladi.net (talgiladi) — Wed, 25 May 2011 14:08:00 +0400

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

var accounts= table.Rows.Cast<DataRow>().Select(a => Convert.ToInt32(a["CustomerId"], CultureInfo.InvariantCulture));

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

var items = accounts.GroupBy(a => a);
                    foreach (var group in items)
                    {

                        int customerId= group.Key;
                        int numberOfActions= group.Count();

}

SandCastle documention

tal.nospam@nospam.talgiladi.net (talgiladi) — Mon, 05 Jul 2010 14:30:12 +0400

לאחרונה הייתי צריך להוציא את תיעוד הקוד לקבצי HTML, לא תהליך מסובך אבל בכל זאת צריך לעקוב אחר כמה צעדים כדי להימנע מעצבים מיותרים…

1. הורדת והתקנת HtmlWorkShop – התוכנה שמאפשרת לייצר קבצי עזרה מסוג chm (הגירסה האחרונה הייתה 4.74.8702.0)

http://download.microsoft.com/download/0/A/9/0A939EF6-E31C-430F-A3DF-DFAE7960D564/htmlhelp.exe

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

http://download.microsoft.com/download/c/2/0/c20073e0-c842-44a8-a4e9-7dd5d289eafe/VsSDK_sfx.exe

3. הורדת והתקנת SandCastle ממיקרוסופט (הגירסה האחרונה הייתה 2.4.10520)

http://www.microsoft.com/downloads/details.aspx?familyid=e82ea71d-da89-42ee-a715-696e3a4873b2&displaylang=en#Instructions

4. הורדת והתקנת הממשק של SandCastle (הגירסה האחרונה הייתה 1.8.0.3)

http://shfb.codeplex.com/

5. הרצת הממשק. יש לבחור בחלונית ProjectExplorer תחת Sources את קבצי הקוד. אפשר לבחור גם סולושן שלם.

לחיצה על Build תיצור את הקבצים. אם עדיין יש בעיה תנסו לתת לו את הערך HtmlHelp1xCompilerPath ידנית – שזה הנתיב לקבוץ HtmlWorkshop שהתקנתם בסעיף 1, שבברירת מחדל יהיה ..\..\Program Files\HTML Help Workshop\

Technorati Tags: SandCastle,documentation,code remarks

Install/Uninstall windows service using cmd

tal.nospam@nospam.talgiladi.net (talgiladi) — Tue, 25 May 2010 14:03:00 +0400

Find the path to the 'InstallUtil.exe' program. It should be found on the .NET framework path, usually on 'C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727'
Browse to the directory with your service files
Open a command prompt
To install, write the 'InstallUtil' path and 'MyService.exe'. For example : "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\InstallUtil.exe" MyService.exe
To uninstall, write the 'InstallUtil' path, /u , and 'MyService.exe'. For example : "C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\InstallUtil.exe" /U MyService.exe

הצפנה אסימטרית

tal.nospam@nospam.talgiladi.net (talgiladi) — Mon, 07 Dec 2009 13:43:00 +0400

הפעם נדבר על הצפנה אסימטרית. מה הכוונה? ובכן, החיסרון הכי גדול של הצפנה סימטרית הוא כיצד להעביר לצד השני את המפתח/סיסמא. הרי הסיבה העיקרית שרצינו להשתמש בהצפנה היא כי אנחנו לא בוטחים בדרך שהמידע עובר בה ובאנשים שיראו אותו בדרך, אז איך נעביר את המפתח באותו הדרך??אז יש פיתרון... הצפנה אסימטרית. הפעם אין מפתח אחד שיכול גם להצפין וגם לפתוח את ההצפנה, אלא יש מפתח אחד (מפתח פרטי) שיכול גם להצפין וגם לפענח את ההצפנה, ויש מפתח אחד (מפתח ציבורי) שיכול רק להצפין. אז מה יצא לנו מזה? ככה, אנחנו מפרסמים לכולם את המפתח הציבורי שלנו, אז הם יכולים כעת להצפין את המידע מאצלהם, ואז לשלוח אלינו, ורק אנחנו עם המפתח הפרטי יכולים לפענח את ההצפנה... נחמד...ואם אני רוצה לשלוח להם תשובה מוצפנת בחזרה? אז שוב, או שהצד השני ישלח לי מפתח ציבורי משלו, ואז לאחר שאצפין את התשובה עם המפתח שלו, אחזיר לו את המידע המוצפן והוא יפענח אותו עם המפתח הפרטי שלו, או, שבעזרת המפתח הציבורי ששלחתי לצד השני בהתחלה, הוא יצפין לי מפתח/סיסמא להצפנה סימטרית ואז פשוט נמשיך את השיחה שלנו בעזרת הצפנה סימטרית(שזו השיטה הסטנדרטית שבה עובד SSL) . למה שיטה זו עדיפה? ובכן, ההצפנה האסימטרית דורשת הרבה מאמץ מהמעבד והיא מאוד איטית ביחד לשיטה הסימטרית.ועכשיו לקצת קוד:
קודם ניצור זוג מפתחות , אם עדיין אין לנו:המחלקה ב C# שמשמשת להצפנה אסימטרית נקראת RSACryptoServiceProvider (שלוש אותיות ראשונות על שם בוני האלגוריתם...)

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

RSACryptoServiceProvider rsa = new RSACryptoServiceProvider ();

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

string privateKey= rsa.ToXmlString(true);

את המפתח הציבורי ניצור באותה שיטה אך על ידי שליחת ערך false כדי שלא להוסיף את המידע על מפתח פרטי לה

string publicKey = rsa.ToXmlString(false);

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

ניצור אובייקט הצפנה:

RSACryptoServiceProvider rsa = new RSACryptoServiceProvider ();

נאתחל אותו עם המפתח הציבורי:

rsa.FromXmlString(publicKey);

נהפוך את המידע שאנו רוצים להצפין למערך בתים:

byte[] clearData=Encoding.UTF8.GetBytes(clearText);

נבצע את ההצפנה :

byte[] encryptedData = rsa.Encrypt(clearData, false);

ונהפוך חזרה לסטרינג שניתן לשליחה בתור טקסט באימייל או דף אינטרנט:

string encryptedString = Convert.ToBase64String(encryptedData);

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

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

RSACryptoServiceProvider rsa = new RSACryptoServiceProvider ();

rsa.FromXmlString(privateKey);

נהפוך את המידע המוצפן שקיבלנו למערך בתים:

byte[] encryptedData = Convert.FromBase64String(encryptedString);

נבצע את הפיענוח:

byte[] clearData = rsa.Decrypt(encryptedData, false);

ונהפוך לטקסט קריא:

string clearText = Encoding.UTF8.GetString(clearData);

זהו... די פשוט

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

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