ChunkedData -המשך

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

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

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

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

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

    client-

    Code Snippet
    1. (function () {
    2.     ‘use strict’;
    3.  
    4.     angular
    5.         .module(‘chunkedApp’)
    6.         .controller(‘chunkedController’, controller);
    7.  
    8.     controller.$inject = [‘$scope’, ‘$http’];
    9.  
    10.     function controller($scope, $http) {
    11.  
    12.         $scope.chunkedData = “”;
    13.         getData();
    14.  
    15.         function getData() {
    16.             $http.post(“/Chunked/indexData”, {}).success(function (res) {
    17.                 getData2(res.guid);
    18.             })
    19.         }
    20.  
    21.         function getData2(guid) {
    22.             $http.post(“/Chunked/IndexData2”, { guid: guid }).success(function (res) {
    23.                 for (var i = 0; i < res.length; i++) {
    24.                     $scope.chunkedData = [$scope.chunkedData, res[i].Chunk].join(” “);
    25.                 }
    26.                 
    27.                 if (res == “”) {
    28.                     alert(“Finish!”);
    29.                     return;
    30.                 }
    31.                 getData2(guid);
    32.             })
    33.         }
    34.     }
    35. })();

    controller-

    Code Snippet
    1. namespace WebApplication1.Controllers
    2. {
    3.     public class ChunkedController : Controller
    4.     {
    5.         Service s = new Service();
    6.  
    7.         public ActionResult IndexData()
    8.         {
    9.             Guid guid = Guid.NewGuid();
    10.  
    11.             Task.Run(() =>
    12.             {
    13.                 s.Service_Data(guid);
    14.             });
    15.  
    16.             return Json(new { guid = guid.ToString() });
    17.         }
    18.  
    19.         public ActionResult IndexData2(Guid guid)
    20.         {
    21.             var result = s.Service_Data(guid);
    22.             return Json(result);
    23.         }
    24.  
    25.         public ActionResult Api()
    26.         {
    27.             byte[] buffer = null;
    28.             string msg = “Hello world!; Lorem ipsum dolor; sit amet, consectetur adipiscing elit. ;Vestibulum rutrum pulvinar commodo.; Proin vitae posuere augue.;Nam rutrum ex eu ;magna finibus, at faucibus leo mattis.;Vestibulum rutrum dui non nisi; venenatis interdum cursus sed ;magna. Vestibulum placerat; magna magna, vel tempus ligula aliquet ac. Phasellus;egestas efficitur nulla, non pretium lacus tristique;vitae. Nam dignissim ;non erat ac faucibus. In hac; habitasse platea dictumst.; Aenean sollicitudin nisi dui,; vel condimentum erat aliquet vitae.; Nullam feugiat massa vitae tellus ;dictum venenatis. Morbi vel turpis ;sit amet est volutpat volutpat.; Nulla sit amet ex id eros;elementum semper; a a ex. Vestibulum ante ipsum primis in ;faucibus orci luctus; et ultrices posuere cubilia Curae;”;
    29.             for (int i = 0; i < msg.Count(); i++)
    30.             {
    31.                 buffer = System.Text.Encoding.UTF8.GetBytes(msg.Skip(i).Take(1).ToArray());
    32.  
    33.                 HttpContext.Response.OutputStream.Write(buffer, 0, buffer.Length);
    34.                 HttpContext.Response.Flush();
    35.             }
    36.             HttpContext.Response.Close();
    37.             return null;
    38.         }
    39.     }
    40. }

    service-

    Code Snippet
    1. public class Service
    2.     {
    3.         Cache cache = System.Web.HttpContext.Current.Cache;
    4.         public List<ChunkedData> Service_Data(Guid guid)
    5.         {
    6.             if (cache[guid.ToString()] == null)
    7.             {
    8.                 cache[guid.ToString()] = new List<ChunkedData>();
    9.                 cache[guid.ToString() + “Count”] = 0;
    10.                 cache[guid.ToString() + “Finished”] = false;
    11.                 Service_CreateApiData(guid);
    12.                 return null;
    13.             }
    14.             else
    15.             {
    16.                 int count = (int)cache[guid.ToString() + “Count”];
    17.                 List<ChunkedData> dataList;
    18.                 do
    19.                 {
    20.                     dataList = (List<ChunkedData>)cache[guid.ToString()];
    21.                     if (count == dataList.Count && (bool)cache[guid.ToString() + “Finished”])
    22.                     {
    23.                         return null;
    24.                     }
    25.                 } while (dataList.Count – count == 0);
    26.  
    27.  
    28.                 var copy = dataList.ToList();
    29.                 cache[guid.ToString() + “Count”] = copy.Count;
    30.                 List<ChunkedData> resultList = copy.Skip(count).ToList();
    31.                 return resultList;
    32.             }
    33.         }
    34.  
    35.  
    36.         public void Service_CreateApiData(Guid guid)
    37.         {
    38.             List<ChunkedData> dataList = (List<ChunkedData>)cache[guid.ToString()];
    39.             const int bufsize = 32 * 1024;
    40.             List<byte> obj = new List<byte>();
    41.  
    42.             WebRequest request = WebRequest.Create(“http://localhost:57976/Chunked/Api”);
    43.  
    44.             using (WebResponse response = request.GetResponse())
    45.             {
    46.                 using (Stream responseStream = response.GetResponseStream())
    47.                 {
    48.                     byte[] buffer = new byte[bufsize];
    49.                     MemoryStream memoryStream = new MemoryStream();
    50.                     int i = 0, read = 0;
    51.  
    52.                     do
    53.                     {
    54.                         read = responseStream.Read(buffer, i, buffer.Length);
    55.                         string result = Encoding.UTF8.GetString(buffer);
    56.                         if (!result.Contains(“;”))
    57.                         {
    58.                             obj.AddRange(buffer.Take(read));
    59.                         }
    60.                         else if (read != 0)
    61.                         {
    62.                             obj.AddRange(buffer.Take(read));
    63.                             result = Encoding.UTF8.GetString(obj.ToArray());
    64.                             int index = result.LastIndexOf(“;”);
    65.  
    66.                             var endIndex = result.Substring(index + 1);
    67.                             var start = result.Substring(0, index);
    68.  
    69.                             var splitArrey = start.Split(‘;’);
    70.  
    71.                             foreach (var item in splitArrey)
    72.                             {
    73.                                 obj = new List<byte>();
    74.                                 obj.AddRange(Encoding.ASCII.GetBytes(item));
    75.                                 Serialize(dataList, obj);
    76.                             }
    77.  
    78.                             buffer = new byte[bufsize];
    79.  
    80.                             obj = new List<byte>();
    81.                             obj.AddRange(Encoding.ASCII.GetBytes(endIndex));
    82.                         }
    83.  
    84.  
    85.                     } while (read != 0);
    86.                     cache[guid.ToString() + “Finished”] = true;
    87.                 }
    88.             }
    89.         }
    90.  
    91.         private void Serialize(List<ChunkedData> dataList, List<byte> obj)
    92.         {
    93.             //change the object, Serialization….
    94.             dataList.Add(new ChunkedData() { Chunk = Encoding.UTF8.GetString(obj.ToArray()) });
    95.         }
    96.  
    97.         public class ChunkedData
    98.         {
    99.             public string Chunk { get; set; }
    100.         }

    הסבר-

    הקטע קוד הראשון  הוא הclient שבעת טעינת העמוד הוא פונה ל-controller ל- action הראשון (“/Chunked/indexData” קטע קוד ראשון שורה 16)

    ה-action indexData (קטע קוד שני שורה 7)  –

    • מייצר guid יחודי לכל פניה.
    • מפעיל את הפונקציה Service_Data בצורה אסינכרונית.(כלומר, מפעיל את הפונקציה אך  לא מחכה למידע , ולא מחכה עד שתסתיים הפונקציה)
    • מחזיר  guid ל-client.

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

    ובserver מורצת הפונקציה Service_Data (שכבר נראה מה היא עושה) עד שהיא תגמור.

    הפונקציה Service_Data (קטע קוד שלישי שורה 4)  –

    מקבלת את ה-guid שנוצר בcontroller, ובודקת אם קיים כבר מקום בזכרון עם הguid הזה.

    אם לא קיים (שזה יקרה רק בפעם הראשונה שנגיע לפונקציה הזאת מה-indexData ):

    • מאתחלת מקום בזכרון עם key ה- guid הנ”ל ו- value מסוג List<ChunkedData (ה- ChunkedData  הוא אוביקט שמכיל מחרוזת- שורה 97)
    • מאתחלת מקום ב זכרון עם key ה- guid +count
    • מאתחלת מקום ב זכרון עם key ה- guid +finished
    • מפעילה פונקציה Service_CreateApiData–
      שהיא פונה לapi שמחזיר chunked data ועושה עליו פעולות.
      בדוגמה הנ”ל הפונקציה בודקת אם התו ‘;’ קיים במה שהגיע מה api  אם לא היא שומרת מה שהגיע במשתנה obj, אם כן היא בודקת כמה מילים מכיל הobj (מילה זה אומר רשימת תוים עד התו ‘;’) ועל כל מילה היא מפעילה את הפונקציה Serialize שאצלינו היא רק שומרת את המילה בlist שקיים לי בcache.(שורה 91) .

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

    כלומר היא הופעלה ע”י task והcontroller לא חיכה לה והודיע על סיום הפעילות, והגיע בclient לפונציה שמופעלת בתוך ה –success (שורה 17) getData2

    שהפונקציה הזאת פונה ל-controller ל- action השני(“/Chunked/indexData2” קטע קוד ראשון שורה 22) עם ה- guid שחזר לה מaction ראשון

    ה-action indexData2 (קטע קוד שני שורה 19) –

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

    כלומר עם קיים מקום בcache עם הguid הנ”ל

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

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

    בקצרה התהליך הוא כזה –

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

    מקווה שעזרתי למישהו…סמיילי

    ניתן להוריד כאן את הקוד המלא.

     

    חיפוש

    פוסטים אחרונים

    Import files from git using CSharp
    MVC Actions and Object Oriented
    Upload file using angularjs with some data

    תגיות

    הרב דוטנט

    החברה מספקת שירותי ייעוץ פיתוח והדרכה.

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

    פוסטים אחרונים

    דף הבית

    צור קשר

    רבי שמעון בן שטח 8
    אלעד, ישראל
    טלפון: 052-624-9139
    פקס: 077-444-7864
    Email: info@haravdotnet.co.il