MS Israel Community

Closing Another Year

Gil Fink — Tue, 09 Feb 2010 11:11:59 GMT

Closing Another Year

Another year of writing is
over. A lot has happened in
my life during the last year.
Here are some highlights:

I have a new baby boy
at home :-)
I received a MVP award from
Microsoft.
I started to work in a new
company – Sela Group.
And many more.

Few Stats About my Blog

Subscribed readers by Feedburner: ~350 (first year – ~115).

Total blog posts: 219 (first year – 113).

Total comments: 421 (first year – 216).

Total trackbacks and pingbacks: 368 (first year – 81).

Google Analytics summary of last year:

Page Views: 178,589 (first year – 57,539).
Unique Pageviews: 154,821 (first year – 49,714).
Average time on site: 03:12 (first year – 02:42).

Tell me how can I Improve My Blog

I’d like to hear from you, the readers of my blog, how can I improve it.
feel free to leave comments such as which topics would you like me to
write about? which things add value to you when you read my blog? or every
comment that you want to share with me in regard to my blog.

SharePoint 2010 Overview & Introduction to SharePoint 2010 Service Architecture – Session Slides

Adir Ron — Tue, 09 Feb 2010 09:28:48 GMT

Hey,

First of all, many thanx to those of you who attended my SharePoint 2010 sessions in Microsoft. This was the first session we've made publicly available to customers and it really kicked off the launch of SharePoint 2010 events scheduled all through the coming months. Hope you all got a glimpse of the SharePoint capabilities and I promise further drill down on the large topics in future events.

Attached here are the slides for both of my presentations. The Overview session mainly discussed the Information Worker features and was aimed for the end users. The SharePoint 2010 Service Architecture session was designed to introduce some of the new & improved extricating services in this release for the IT & Developer such as Search, BI, Business Connectivity and more.

SharePoint 2010 Overview slides:

http://blogs.microsoft.co.il/files/folders/515584/download.aspx

Introduction to SharePoint 2010 Service Architecture slides:

http://blogs.microsoft.co.il/files/folders/515588/download.aspx

I'll be more than happy to hear your thoughts and requests for the future. Please comment by mail for fast response: adir@advantech.co.il

Have a nice day,

Adir Ron

Windows Mobile 7 – Good or Bad ?

Noam — Tue, 09 Feb 2010 09:27:00 GMT

This post is based on the on going buzz in the net about the capabilities of Windows Mobile 7 due this year 1. First nothing is official, wait for next Monday (Feb 15th) for the official announcement. 2. Multitasking – Still exist but this time no one can create a busy wait loop and kill the device battery in 30min (happened to me couple of times with some applications), Making software more stable and better suitable for mobile device is good at my book. 3. Flash – Why I need to ask ? first of all...(read more)

Disposable Property

Shlomo — Tue, 09 Feb 2010 07:16:00 GMT

עדי הראה לי רעיון מאוד מעניין למימוש שמירת אובייקט זמני בזיכרון. למה הכוונה ?

נניח שיש לנו קוד כזה

public class FileLogger : ILogger
{
}
public class MockLogger : ILogger
{
}
 
public class Person
{
    public ILogger Logger { get; set; }
}

ויש לנו את פונקצייה שמקבלת כפרמטר Person אבל בחלק מהקוד של הפונקצייה לא רוצים שה - Logger יהיה FileLogger אלא MokeLogger - מן הסתם נעשה קוד כזה

public void Func(Person person)
{
    ILogger original = person.Logger;
    person.Logger = new MockLogger();
 
    //work.....
 
    person.Logger = original;
 
}

מה שעדי הציע - זה לעשות את הקוד הבא

using (DisposableProperty<ILogger>.Set(person, new MockLogger()))
{
    // work..
 
 
}

וכעת באורח פלא בתוך בלוג ה - using ה - Logger יהיה Mock וכשנצא מהבלוק זה יחזור להיות ה - Logger המקורי.

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

אז איך זה עובד ?

public class DisposableProperty<T> : IDisposable where T : class
{
    private T _original;
    private PropertyInfo _property;
    private object _obj;
 
    private DisposableProperty(object obj, T replaceValue)
    {
        if (obj == null) 
            throw new ArgumentNullException();
 
        this._obj = obj;
 
        _property = obj.GetType().GetProperties().
                             FirstOrDefault(p => p.PropertyType == typeof(T));
 
        if (_property == null) 
            throw new ArgumentException();
 
        _original = _property.GetValue(obj, null) as T;
 
        _property.SetValue(obj, replaceValue, null);
    }
 
    public void Dispose()
    {
        _property.SetValue(_obj, _original, null);
    }
 
    public static IDisposable Set(object obj, T replaceValue) 
    {
        return new DisposableProperty<T>(obj, replaceValue);
    }
}

אמנם לא הכי יעיל מבחינת ביצועים - אבל בדרך כלל קוד כזה ירוץ בסביבות Tests אז לא כל כך נורא.

המתודה Set מחזירה מופע חדש של המחלקה, בבנאי שומרים את המקורי וב - Dispose מחזירים את המקורי.

does MEF apply the SOA paradigm?

bnaya — Tue, 09 Feb 2010 07:02:21 GMT

does MEF apply the SOA paradigm?

in this post I'm going to argue that the Manage Extensibility Framework (MEF),

is actually applying to the 4 tenet of Service Orientation Architecture (SOA),

therefore MEF is actually, in-process implementation of the SOA paradigm.

Background

when we speaking about SOA we used to think about technologies like web services and WCF,

which is cross process technologies.

but does SOA define that services should always be consumed from the clouds?

local services like loggers, rule engine, cache and more are everyday practice for in-process services.

What make your architecture, service oriented?

different architect having different opinions of how to construct SOA architecture,

but most of them agree that SOA design should apply to the 4 tenets of SOA.

The 4 tenets of SOA

Service should have Explicit Boundaries.

Service should be Autonomous.

Service API should rely on Contract.

Service behavior and compatibility should rely on Policy.

How MEF apply to the 4 tenets?

MEF boundaries define explicitly by the Export definition.

separating exports into separate dlls will create autonomous unit which has no need

for any reference but the reference for the services contract.

Imports does not aware of the actual implementation, imports are solely relay on the contract

(composition will find export that mach the import contract).

MEF has different policies mechanism like metadata, creation policy,

instantiation policy, recomposition.

Summary

despite MEF being an in-process technology it does apply to the 4 tenet of SOA,

therefore it can consider as such.

תגים של Technorati:‏ MEF,extensibility,SOA,CLR 4

Visual Studio 2010 RC Now Available

Eran Stiller — Tue, 09 Feb 2010 06:07:00 GMT

To all of you out there who are already playing with the VS2010 and .NET 4.0 Beta 2 bits, it was announced today that the Release Candidate version is now available for download for MSDN subscribers and would be made available to the general public on Wednesday.

The RC version contains many performance improvements and bug fixes, and should be more mature than Beta 2. I can’t wait to download & install it already!

מסמך השיפורים של RDP 7

גדי פלדמן — Mon, 08 Feb 2010 23:10:11 GMT

כולנו מכירים כבר את החידושים של RDP 7 (או RDC אם תרצו) שהוכנסו כחלק מ- Windows 7 ו- Windows Server 2008 R2.
לפני כמה שבועות מיקרוסופט הוציאה מסמך אשר משווה בין הביצועים של RDP 6.1 לבין האח הבכור שלו, הלא הוא כאמור ה- RDP 7.

מה אפשר ללמוד מהנתונים?

כ- 25% פחות שימוש ברוחב ב- Session של RDP7 עם 32-bit צבעים. משום מה 27% ו- 8% אחוז יותר שימוש ברוחב פס ב- RDP 7 לעומת 6.1 בעבודה על קובץ וורד וגלישה עם Internet Explorer באיכות צבעים של 16-bit.
Session עם Font smoothing (האפשרות להצגה חדה יותר על גבי צגי LCD) צורך כמעט פי 2 יותר רוחב פס מאשר Session רגיל. החדשות הטובות הן שב- RDP7 העליה היא “רק” בסביבות ה- 80% יותר ברוחב פס.
יכולת ה- Desktop Composition שהוצגה עוד ב- Vista לתצוגה חלקה יותר של ה- Session (בגדול, התצוגה המגיעה מה- Session המרוחק לא מוצגת ישירות על המסך, אלה עוברת קודם כל דרך ה- DWM אשר אוגר את כל השינויים ומציג אותם ביחד) לא ממש משנה את כמות רוחב הפס בו עושה ה- Session שימוש.
תצוגת Silverlight נראת כדורשת מעט יותר רוחב פס מתצוגת Flash, אולי זה מסביר את זה שב- Silverlight נראים יותר Frames לשניה (17.3 באיכות צבעים של 32 ביט, ו- 13 ב-16 ביט) מאשר בפלאש (11.7 ו-9.3 בהתאמה).
משהו שהיה די ברור, אבל טוב שהוא הובהר. אין הבדל באיכות התצוגה כאשר נעשה Redirection של תצוגת המולטימדיה (במקרה הזה סרט במדיה פלייר) לתחנת העבודה ונעשה שימוש ב- Codec המקומי של ה- Client.
השפעות של Latency אמורות להשפיע פחות על RDP7 מאיך שהן השפיעו על 6.1. למרות שנבקד רק Latency של 100mSec, ה- delay שהיה ב- session של RDP7 היה נמוך בכ- 8% מאשר ב- RDP6.1. בסה”כ נרשם delay של אחוזים בודדים (סביבות ה- 5%) בין session עם latency של 100msec לבין session ללא latency בכלל.

אז אכן, נראה שנעשה שיפור משהו ב- RDP, אבל מה זה אומר בעצם? שזה אמור לתת סוג של אישור לארגונים להשתמש ב- RDS של מיקרוסופט ללא השלמות של Citrix\Quest\Ericom? או האם זה אומר שעכשיו כולנם ינהרו להטמיע את ה- VDI של מיקרוסופט? מממ… לא. בעיקר מכיוון שהתחרות בשני השווקים האלה (נגיד ונקרא להם TS ו- VDI) היא לא למי יש את הפרוטוקול הטוב ביותר – בכל מקרה בסביבות LAN הם כולם פחות או יותר זהים – אלה למי יש את היכולות הטובות ביותר בנושאים כמו ניהול מרכזי, ניהול פרופילים, ניהול עידכונים, הפצות, דיסק מרכזי, הקשר בין המערכות השונות ועוד. בעצם כל אותם הרכיבים/יכולות שמיקרוסופט משאירה לשותפים שלה להשלים.

אבל בכל זאת, ה- RDP 7 נראה הרבה יותר טוב מקודמיו, כבר טוב.

למסמך המלא

Microsoft MVP’s,MRD’s, MRS’s and UG Managers Summit - Israel

shair — Mon, 08 Feb 2010 21:34:36 GMT

Microsoft MVP’s,MRD’s, MRS’s and UG Managers Summit - Israel

Microsoft Israel arranged a “Movie Meeting” (we saw Avatar – My second time – still great movie) for all Microsoft Experts in Israel.
The event were take place in Rav-Chen Ayalon Ramat-Gan, good food, drinks, gadgets and most important good People.

It’s very nice to take a break from work and meet all those great people in one place without work involved :-D

Here is some pictures from the event:

SSIS – Importing data from an Oracle data source

yanivmor — Mon, 08 Feb 2010 19:49:46 GMT

A quick note this week: this may be a known issue for some of you, I have only got to know this little trick the other day when I had to import data from an Oracle database to a SQL Server database (believe it or not – I did not have to use an Oracle database as a source up until now…). There were quite a few tables involved and a considerable amount of data to be moved, so the obvious solution was to use SSIS for this task. If you want to use the Microsoft provider for Oracle you have to install an Oracle client on the machine that runs your SSIS packages, so that was pretty easy to accomplish and once the client was installed we started to configure the ole-db source adapter. The data was a mix of numbers and character-type data and the next message that popped up the minute I configured the source was: “Cannot retrieve the column code page info from the OLEDB provider. If the component supports the “DefaultCodePage” property, the code page from that property will be used…”. Needless to say, when you hook this into a SQL Server ole-db destination and try to run the package, it does not run and throws this error again.

So, what to do? You need to change the “AlwaysUseDefaultCodePage” property of the Oracle ole-db source to True. This way the component will indeed use the machine’s default code page and things should go smooth from this point onwards.

-Yaniv

(This is post number 12 for week number 11 of my SQL blog challenge)

Technorati Tags: SSIS,Oracle,SQL Server 2008

WCF Contrib v2.1 – Customize Output Caching Provider

Amir Zuker — Mon, 08 Feb 2010 19:15:09 GMT

Via http://wcfcontrib.codeplex.com/wikipage?title=ClientChannelOutputCache

Output Cache Provider Factory
This is the factory class that is responsible for creating the actual output cache provider.
This is where you extensibility point kicks in, you can replace the built-in factory with your own, read about it here.

The factory needs to have a public parameter-less constructor and implement 'IOutputCacheProviderFactory'

public interface IOutputCacheProviderFactory
{
    IOutputCacheProvider CreateProvider();
}

As you can see, this is a simple factory interface for providing the actual provider implementation.

Output Cache Provider
Output cache provider is where the magic really happens.
This is where you should implement your custom output caching solution if you like.

public interface IOutputCacheProvider
{
    void AddItem(OutputCacheItemKey key, OutputCacheInterval interval, object value);
    bool TryGetItem(OutputCacheItemKey key, out object value);
}

AddItem - this method is supposed to add a new item to the output cache solution.
TryGetItem - this method should look up the output cache solution for the item that was stored.
OutputCacheInterval - you're getting the desired interval as a parameter.
- Consider setting the fields "LastVisitedAt" and "AddedAt" to the proper values at a given time so you can reference it later.
- You can use "IsActive()" method if you like to check whether the interval is active for the current time according to its policy and time properties.

Note: If the provider implements IDisposable, it will be disposed once the OutputCacheController is disposed.
The built-in provider is called "IntervalBasedCacheProvider", it is important to know this since this too is written in a reusable way where you can plug-in your custom store.
The provider gets two parameters in its constructor:

purgeTimerIntervalInMilliseconds - The interval in milliseconds for the timer that is in charge of iterating the items and purging those which are inactive.
store - An implementation for IOutputCacheStore
1. AddItem - The provider basically saves the key and interval in its local state, sets the time properties of the interval to the current time and adds the item to the store.
2. TryGetItem - When an item is requested from the cache, the provider checks if there's an active key in its local state, if so, sets the last visited time to the current time and gets the item from the store.
3. Removing Items - In the timer callback, it iterates the keys in its local state and removes the inactive ones from the store

Output Cache Store
The store is responsible for storing the items.

public interface IOutputCacheStore
{
    void SetItem(OutputCacheItemKey key, object value);
    void RemoveItem(OutputCacheItemKey key);
    bool TryGetItem(OutputCacheItemKey key, out object value);
}

The store that is provided with the built-in solution is using the SynchronizedDictionary that is a part of WCF Contrib as well.

Implementing your own custom output caching solution
You can go about it in two ways:

Plug-in your own factory and provider and implement a different scenario - you can use this approach to write a provider that uses an interval-based caching solution such as HttpRuntime Caching, Enterprise Library, etc
Plug-in your own factory and still use the built-in IntervalBasedCacheProvider only with your own custom store, such as a AppFabric caching, file-system, database, etc

Output Cache Item Key
It's important to recognize the description of the item keys if you like to implement you own solution since you will need a way a way to correlate between the item and key.

The key contains the operation action and parameters and custom equality comparers if any were provided.
It can be used as a dictionary key since it overrides Equals and GetHashCode by calculating it over the action and parameters using the appropriate comparer.
ToString() is also overriden to return the aggregation of the action and parameters.

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

Kobi Magnezi — Mon, 08 Feb 2010 13:36:29 GMT

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

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

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

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

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

Posted via email from Kobi Magnezi

איך מיקרוסופט הרגו את Windows Mobile

Ambious — Mon, 08 Feb 2010 10:23:50 GMT

בימים האחרונים החלו לצוץ באינטרנט כל מיני שמועות על ההכרזה הגדולה של מיקרוסופט בכנס הסלולארים הבינלאומי שיפתח ביום שני בברצלונה. הצפי הוא שמיקרוסופט תכריז על “Windows Mobile 7” – או בשמו החדש, “Windows Phone”, ובינתיים הספיקו לדלוף לרשת גם כמה פרטים על מערכת ההפעלה החדשה לטלפונים, פרטים שברובם כבר אושרו על ידי מקורות שונים בצוות הפיתוח של מיקרוסופט. לפני שאסביר מה הגורם האפשרי לכל אחת מההחלטות הללו ומה ההשלכות של זה, הנה מה שידוע בינתיים: ממשק המשתמש מבוסס על פרויקט בשם “מטרו”, שדומה מאד בממשק שלו...(read more)

SharePoint developers required

dorong — Mon, 08 Feb 2010 08:29:34 GMT

Job description

The candidate will be responsible for the SharePoint at Playtech

Implementation and maintenance tasks in the corporate Portal

Providing services to the corporate reference and management

Managing work with suppliers

Requirements

At least 3 years experience in large scale SharePoint implementation.

Proven experience in managing and maintaining enterprise portal based MOSS2007

Practical knowledge on SharePoint Designer

Knowledge of basic Web technologies HTML, CSS, etc.

Email me your CV if it interests you.

Using Cookie in Client Side (JavaScript)

Shlomo — Mon, 08 Feb 2010 07:28:00 GMT

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

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

HttpCookie cookie = new HttpCookie("ClientColumns");
for (int j = 0; j < cbl.Items.Count; j++)
{
    cookie.Values.Add("name", "value");
}

ברור שאפשר גם לייצר Cookie שיש לו רק ערך אחד

HttpCookie cookie = new HttpCookie("ClientColumns");
cookie.Value = "value";

שימו לב להבדל בין שימוש ב - Values לבין שימוש ב - Value.

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

הנה הפונקצייה לייצר ולקרוא מ - Cookie (הפונקצייה הועתקה מכאן - מומלץ לקרוא)

function CreateCookie(name, value, expiredays) {
    var expires = '';
 
    if (expiredays != undefined) {
        var exdate = new Date();
        exdate.setDate(exdate.getDate() + expiredays);
        expires = exdate.toGMTString();
    }
 
    document.cookie = name + "=" + value + (expires == '' ? '' : ";expires=" + expires) + "; path=/";
}
 
function ReadCookie(name) {
    var nameEQ = name + "=";
    var ca = document.cookie.split(';');
    for (var i = 0; i < ca.length; i++) {
        var c = ca[i];
        while (c.charAt(0) == ' ') c = c.substring(1, c.length);
        if (c.indexOf(nameEQ) == 0) return c.substring(nameEQ.length, c.length);
    }
    return null;
}

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

דוגמא לשימוש עם ערך אחד

CreateCookie('name', 'value', 100);
CreateCookie('name', 'value');

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

דוגמא לשימוש עם יותר מערך אחד

CreateCookie('name', 'Id=1&First Name=Shlomo&Work=true');

קריאה ל - ReadCookie תמיד תחזיר את מה שיש ב - value של ה - Cookie.

כלומר לא באמת קיים כזה דבר Cookie שיש לו יותר מערך אחד - אלא שבמקרה שה - Value של ה - Cookie מכיל את התו & האובייקט בצד השרת יודע לפרק את ה - value של ה - cookie להרבה ערכים.

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

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

ל - CheckListBpx נוסיף טיפול בצד הלקוח

<asp:CheckBoxList ID="cbl" runat="server" RepeatDirection="Horizontal" onclick="Change(this)">

המתודה:

function Change(tbl) {
    var value = CookieString(tbl);
    CreateCookie("ClientColumns", value, 100);
    ChangeGrid(false);
}

המתודה CookieString מקבלת את ה - CheckListBox ומחזירה מחרוזת מתאימה ל - Cookie.

המתודה CreateCookie שומרת את ה - Cookie.

המתודה ChangeGrid מעלימה את העמודות בגריד, ומקבלת את הערך false כדי להגיד למתודה שלא צריך לשנות את הערך ב - CheckBox (מכיון שכשהעמוד נטען צריך להפעיל את המתודה הזאת כדי לטעון את הערכים מה - Cookie ואז צריך לשנות את ה - CheckBox).

נוסיף ל - body

<body onload="ChangeGrid(true)">

כעת נראה את אותם מתודות.

function CookieString(tbl) {
    var inputArr = tbl.getElementsByTagName('INPUT');
    var str = '';
 
    for (var i = 0; i < inputArr.length; i++) {
        str += inputArr[i].nextSibling.innerText + '=' + inputArr[i].checked + '&';
    }
    if (str != '') {
        str = str.substr(0, str.length - 1);
    }
 
    return str;
}

אני מקבל מערך של כל ה - CheckBox שקיים ב - CheckBoxList.

רץ על כולם ומייצר מחרוזת מתאימה.

אחרי הלולאה אני מוחק את התו האחרון &.

function ChangeGrid(setCheckBox) {
    var value = ReadCookie('ClientColumns');
    if (value != null) {
        var values = value.split('&');
        var grid = document.getElementById('<%= grid1.ClientID %>');
        var clb = document.getElementById('<%= cbl.ClientID %>');
        var inputs = clb.getElementsByTagName('INPUT');
 
        for (var m = 0; m < values.length; m++) {
            var display = values[m].split('=')[1] == "true" ? 'block' : 'none';
 
            for (var i = 0; i < grid.rows.length; i++) {
                grid.rows[i].cells[m].style.display = display;
            }
 
            if (display == 'none' && setCheckBox) {
                inputs[m].checked = false;
            }
        }
    }
}

אני מנסה לקרוא את ה - Cookie

עושה מה - value מערך לפי סימן ה - &

אני מקבל את הגריד, ה - CheckBoxList ומערך של כל ה - CheckBox שקיימים בו.

אני רץ בלולאה על כל הערכים ב - Cookie.

השורה הבאה:

var display = values[m].split('=')[1] == "true" ? 'block' : 'none';

במידה והערך הוא true נקבל את המילה block אחרת נקבל none

אני רץ על כל השורות בגריד ומגדיר לעמודה האם יראו אותה או לא.

במידה ומוגדר שלא יראו את העמודה והגענו אחרי ה - load של ה - body - נשנה גם את הערך של ה - checkBox.

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

Back to Basics – Using MasterType Directive

Gil Fink — Mon, 08 Feb 2010 06:50:13 GMT

Back to Basics – Using MasterType Directive

This post is
a result of
a question that
I got from one
of the developers
that I work with.
The question was
how to use master page properties from an ASP.NET page.

Setting the Environment

The first thing that you want to do is to expose the properties
as public in the master page. For example this is code behind
of a simple master page that exposes the IsPageEnabled property:

     public partial class Site1 : MasterPage

    {

        #region Properties

        public bool IsPageEnabled { get; set; }

        #endregion

        #region Page events

        protected void Page_Load(object sender, EventArgs e)

        {

        }

        #endregion

    }

The MasterType Directive

When we want to use the property in a page which reference the
previous master page we need to put the inside of it the MasterType
directive:

    <%@ MasterType VirtualPath="~/Site1.Master" %>
  

This directive declare that the master page of a page is strongly type.
By that simple directive we gain access to the master exposed public
properties and methods through the Master property of the page.
For example this is how in the page I’ll call the IsPageEnabled property of
the master page:

    public partial class WebForm5 : Page

    {

        #region Page Events

        protected void Page_Load(object sender, EventArgs e)

        {

            Master.IsPageEnabled = true;

        }

        #endregion

    }

The markup of the page I use:

    <%@ Page Title="" Language="C#" MasterPageFile="~/Site1.Master" AutoEventWireup="true"

        CodeBehind="WebForm5.aspx.cs" Inherits="TestModalDialog.WebForm5" %>

    <%@ MasterType VirtualPath="~/Site1.Master" %>

    <asp:Content ID="Content1" ContentPlaceHolderID="ContentPlaceHolder1" runat="server">

    </asp:Content>

Summary

Lets sum up, when we use master pages we can expose properties
and methods for the pages. We use the MasterType directive in the
page in order to create a strong type master page inside of it. By
doing that we can pass data from the page to its master.
Very easy and very useful.

WPF: How To Animate Visibility Property?

arik — Sun, 07 Feb 2010 22:22:00 GMT

In this post I’ll show you an easy way to add fade-in / fade-out effects to your user controls, when you change their Visibility property.

Adding the animation is done with an attached property, so using the code will be extremely simple.

Usage Sample

XAML:

<Window x:Class="WpfDemoVisibilityAnimation.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:common="clr-namespace:WPF.Common"
    Title="Window1" Height="300" Width="300">
    <StackPanel>
        <Button Content="Hide" Click="Hide_Click" />
        <Button Content="Show" Click="Show_Click" />
        <Image common:VisibilityAnimation.AnimationType="Fade" 
               x:Name="Image" 
               Source="C:\Users\Public\Pictures\Sample Pictures\Desert.jpg" />
    </StackPanel>
</Window>

Code Behind:

private void Hide_Click(object sender, RoutedEventArgs e)
{
    Image.Visibility = Visibility.Hidden;
}

private void Show_Click(object sender, RoutedEventArgs e)
{
    Image.Visibility = Visibility.Visible;
}

Note that the only required addition for the animation effect was setting the attached property: VisibilityAnimation.AnimationType="Fade"

You can find here the full source code for the VisibilityAnimation attached property and here the usage sample application.

Where is the magic?
The magic resides in the implementation of the attached property. Before I’ll show you the code, let me explain the basic idea.

We “register” for getting visibility property “before change” event.
When an element’s visibility property tries to change, somewhere in the application, we get the notification and check if the element has our attached property.
If it has, we start an animation on the opacity property and force the current visibility value to Visibility.Visible, This will allow the animation to present without interruptions.
When the animation completes, we set the original requested value.
Setting the original requested value will invoke (again) our “before change” event, so we need to keep a flag that indicates whether we already started the animation, in which case we just set the value.

Credit
The original idea is based on an answer from stack overflow. I’ve improved the code, added support for the case where the Visibility was getting the value using data binding and added lots of comments.

That’s it for now,
Arik Poznanski.

Appendix A – Source Code for VisibilityAnimation class

using System;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Data;
using System.Windows.Media.Animation;

namespace WPF.Common
{
    /// <summary>
    /// Supplies attached properties that provides visibility of animations
    /// </summary>
    public class VisibilityAnimation
    {
        public enum AnimationType
        {
            /// <summary>
            /// No animation
            /// </summary>
            None,

            /// <summary>
            /// Fade in / Fade out
            /// </summary>
            Fade
        }

        /// <summary>
        /// Animation duration
        /// </summary>
        private const int AnimationDuration = 300;

        /// <summary>
        /// List of hooked objects
        /// </summary>
        private static readonly Dictionary<FrameworkElement, bool> _hookedElements = 
            new Dictionary<FrameworkElement, bool>();

        /// <summary>
        /// Get AnimationType attached property
        /// </summary>
        /// <param name="obj">Dependency object</param>
        /// <returns>AnimationType value</returns>
        public static AnimationType GetAnimationType(DependencyObject obj)
        {
            return (AnimationType)obj.GetValue(AnimationTypeProperty);
        }

        /// <summary>
        /// Set AnimationType attached property
        /// </summary>
        /// <param name="obj">Dependency object</param>
        /// <param name="value">New value for AnimationType</param>
        public static void SetAnimationType(DependencyObject obj, AnimationType value)
        {
            obj.SetValue(AnimationTypeProperty, value);
        }

        /// <summary>
        /// Using a DependencyProperty as the backing store for AnimationType. 
        /// This enables animation, styling, binding, etc...
        /// </summary>
        public static readonly DependencyProperty AnimationTypeProperty = 
            DependencyProperty.RegisterAttached(
                "AnimationType",
                typeof(AnimationType),
                typeof(VisibilityAnimation),
                new FrameworkPropertyMetadata(AnimationType.None, 
                    new PropertyChangedCallback(OnAnimationTypePropertyChanged)));

        /// <summary>
        /// AnimationType property changed
        /// </summary>
        /// <param name="dependencyObject">Dependency object</param>
        /// <param name="e">e</param>
        private static void OnAnimationTypePropertyChanged(
            DependencyObject dependencyObject, 
            DependencyPropertyChangedEventArgs e)
        {
            FrameworkElement frameworkElement = dependencyObject as FrameworkElement;

            if (frameworkElement == null)
            {
                return;
            }

            // If AnimationType is set to True on this framework element, 
            if (GetAnimationType(frameworkElement) != AnimationType.None)
            {
                // Add this framework element to hooked list
                HookVisibilityChanges(frameworkElement);
            }
            else
            {
                // Otherwise, remove it from the hooked list
                UnHookVisibilityChanges(frameworkElement);
            }
        }

        /// <summary>
        /// Add framework element to list of hooked objects
        /// </summary>
        /// <param name="frameworkElement">Framework element</param>
        private static void HookVisibilityChanges(FrameworkElement frameworkElement)
        {
            _hookedElements.Add(frameworkElement, false);
        }

        /// <summary>
        /// Remove framework element from list of hooked objects
        /// </summary>
        /// <param name="frameworkElement">Framework element</param>
        private static void UnHookVisibilityChanges(FrameworkElement frameworkElement)
        {
            if (_hookedElements.ContainsKey(frameworkElement))
            {
                _hookedElements.Remove(frameworkElement);
            }
        }

        /// <summary>
        /// VisibilityAnimation static ctor
        /// </summary>
        static VisibilityAnimation()
        {
            // Here we "register" on Visibility property "before change" event
            UIElement.VisibilityProperty.AddOwner(
                typeof(FrameworkElement),
                new FrameworkPropertyMetadata(
                    Visibility.Visible, 
                    VisibilityChanged, 
                    CoerceVisibility));
        }

        /// <summary>
        /// Visibility changed
        /// </summary>
        /// <param name="dependencyObject">Dependency object</param>
        /// <param name="e">e</param>
        private static void VisibilityChanged(
            DependencyObject dependencyObject, 
            DependencyPropertyChangedEventArgs e)
        {
            // Ignore
        }

        /// <summary>
        /// Coerce visibility
        /// </summary>
        /// <param name="dependencyObject">Dependency object</param>
        /// <param name="baseValue">Base value</param>
        /// <returns>Coerced value</returns>
        private static object CoerceVisibility(
            DependencyObject dependencyObject, 
            object baseValue)
        {
            // Make sure object is a framework element
            FrameworkElement frameworkElement = dependencyObject as FrameworkElement;
            if (frameworkElement == null)
            {
                return baseValue;
            }

            // Cast to type safe value
            Visibility visibility = (Visibility)baseValue;

            // If Visibility value hasn't change, do nothing.
            // This can happen if the Visibility property is set using data binding 
            // and the binding source has changed but the new visibility value 
            // hasn't changed.
            if (visibility == frameworkElement.Visibility)
            {
                return baseValue;
            }

            // If element is not hooked by our attached property, stop here
            if (!IsHookedElement(frameworkElement))
            {
                return baseValue;
            }

            // Update animation flag
            // If animation already started, don't restart it (otherwise, infinite loop)
            if (UpdateAnimationStartedFlag(frameworkElement))
            {
                return baseValue;
            }

            // If we get here, it means we have to start fade in or fade out animation. 
            // In any case return value of this method will be Visibility.Visible, 
            // to allow the animation.
            DoubleAnimation doubleAnimation = new DoubleAnimation
            {
                Duration = new Duration(TimeSpan.FromMilliseconds(AnimationDuration))
            };

            // When animation completes, set the visibility value to the requested 
            // value (baseValue)
            doubleAnimation.Completed += (sender, eventArgs) =>
            {
                if (visibility == Visibility.Visible)
                {
                    // In case we change into Visibility.Visible, the correct value 
                    // is already set, so just update the animation started flag
                    UpdateAnimationStartedFlag(frameworkElement);
                }
                else
                {
                    // This will trigger value coercion again 
                    // but UpdateAnimationStartedFlag() function will reture true 
                    // this time, thus animation will not be triggered. 
                    if (BindingOperations.IsDataBound(frameworkElement, 
                        UIElement.VisibilityProperty))
                    {
                        // Set visiblity using bounded value
                        Binding bindingValue = 
                            BindingOperations.GetBinding(frameworkElement, 
                                UIElement.VisibilityProperty);
                        BindingOperations.SetBinding(frameworkElement, 
                            UIElement.VisibilityProperty, bindingValue);
                    }
                    else
                    {
                        // No binding, just assign the value
                        frameworkElement.Visibility = visibility;
                    }
                }
            };

            if (visibility == Visibility.Collapsed || visibility == Visibility.Hidden)
            {
                // Fade out by animating opacity
                doubleAnimation.From = 1.0;
                doubleAnimation.To = 0.0;
            }
            else
            {
                // Fade in by animating opacity
                doubleAnimation.From = 0.0;
                doubleAnimation.To = 1.0;
            }

            // Start animation
            frameworkElement.BeginAnimation(UIElement.OpacityProperty, doubleAnimation);

            // Make sure the element remains visible during the animation
            // The original requested value will be set in the completed event of 
            // the animation
            return Visibility.Visible;
        }

        /// <summary>
        /// Check if framework element is hooked with AnimationType property
        /// </summary>
        /// <param name="frameworkElement">Framework element to check</param>
        /// <returns>Is the framework element hooked?</returns>
        private static bool IsHookedElement(FrameworkElement frameworkElement)
        {
            return _hookedElements.ContainsKey(frameworkElement);
        }

        /// <summary>
        /// Update animation started flag or a given framework element
        /// </summary>
        /// <param name="frameworkElement">Given framework element</param>
        /// <returns>Old value of animation started flag</returns>
        private static bool UpdateAnimationStartedFlag(FrameworkElement frameworkElement)
        {
            bool animationStarted = (bool)_hookedElements[frameworkElement];
            _hookedElements[frameworkElement] = !animationStarted;

            return animationStarted;
        }
    }
}

Coke steels Yotvata commercial advertisement !

Ohad Israeli — Sun, 07 Feb 2010 22:07:00 GMT

Coke showed the following commercial advertisement at the super bowl 2010…

Reminds you something ???

Check this…

Visual Studio 2010 RC

Ohad Israeli — Sun, 07 Feb 2010 21:47:00 GMT

Watch out Soma’s blog for an upcoming announcement targeted to MSDN subscribers…

jQuery ו- Ajax

Arnold — Sun, 07 Feb 2010 18:28:10 GMT

בעידן של Web 2.x כמעט כל אתר משתמש ב Ajax - Asynchronous JavaScript And XML. פיתוח בעזרת Ajax משפר את חווית הגלישה של המשתמש.
היום נלמד על שילוב של ajax ו jQuery.
זהו מאמר חמישי בסדרת המאמרים בנושא jQuery:
סדרת מאמרים בנושא jQuery
חיפוש אובייקטים – חלק א’
חיפוש אובייקטים – חלק ב’
jQuery Events – אירועים ב jQuery

מה זה Ajax?

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

ויקידיה

jQuery ו- Ajax

ספריית jQuery משלבת בתוכה אפשריות ajax החל מבסיסיות ועל למתקדמות.

הספרייה כוללת את הפונקציות הבאות לעבודה עם ajax (הסבר מורחב ניתן למצוא באתר הספרייה):

jQuery.ajax()
jQuery.get()
jQuery.getJSON()
jQuery.getScript()
.load()
jQuery.post()

()get

פונקציה זו פונה לשרת בעזרת HTTP GET REQUEST ומחזירה את הנתונים שהתקבלו מהשרת:

$.get(url,function(data) {

     alert(data)

});

הפונקציה מקבלת קישור ולאחר ביצוע הפעולה היא מבצעת את הפונקציה עם הנתונים שהתקבלו (הנתונים יכולים להיות xml או html).

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

()jQuery.getJSON

פונקציה זהה ל-get אך במקום להחזיר html או xml היא מחזירה json

()jQuery.getScript

פונקציה שטוענת קובץ javascript ומריצה אותו.

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

()load.

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

$('#result').load(url, function() {

  alert('הנתונים נטענו');

});

לאחר טעינה הנתונים שהתקבלו מוצגים באובייקט עם ID בשם result.

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

$('#result').load('myPage.html #innerDiv', function() {

  alert('הנתונים נטענו');

});

load יטען לתוך result את הנתונים אשר נמצאים בעמוד myPage.html ובתוך אובייקט innerDiv.

()post.

פונקציה זו פונה לשרת בעזרת HTTP POST REQUEST, שולחת פרמטרים ומחזירה את הנתונים שהתקבלו מהשרת

$.post("myPage.aspx", {name: "Arnold", lastName: "Simha" }, function(data){

     alert(data);

} );

jQuery.ajax()

זאת האפשרות הכי מתקדמת הכוללת בתוכה המון אפשריות שונות:

$.ajax({

   type: "POST",

   url: "myPage.aspx",

   data: "name=Arnold&lastName=Simha",

   success: function(msg){

     alert(msg);

},

   error: function(XMLHttpRequest, textStatus, errorThrown){

     alert(errorThrown);

});

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

סוף!

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

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

Michal David — Sun, 07 Feb 2010 13:33:00 GMT

חשוב מאד להרבה משתמשים בתוכנת Ms Project להשוות את נתוני הפרויקט מתאריכים שונים , ולמטרות שונות.

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

לדוגמא:

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

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

מה עושים? איך אפשר לייעל?

הבעיה של רמי מוכרת. מכיוון שהעמודה האפורה שאין לנו גישה אליה - עמודת ID או קוד או מזהה

( השם תלוי באיזו שפה וגרסה אתם משתמשים)

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

הפתרון :

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

להוספת העמודה : קליק ימני על עמודה שלפניה רוצים להוסיף עמודה חדשה ובחירת השדה Unique ID .

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

מצב ראשוני:

לאחר שנוספה פעילות חדשה - מספר 10 :

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

SAVE THE DATE: Developers Academy 4

Guy Burstein — Sun, 07 Feb 2010 12:12:00 GMT

SAVE THE DATE: Developers Academy 4

The one I remember the most

nirkatz — Sun, 07 Feb 2010 10:21:00 GMT

If you will wake me up in the middle of the night and ask me which bug I remember the most I will tell you this story:

It was 6 months after I joined Microsoft and the installation of a new MSMQ build in my lab failed. This particular installation was distributed between 3 machines; Primary Server, Backup Server and a Client. The installation of the Primary and Backup servers passed however the Client installation failed. I was sure that I did something wrong because this build passed the build verification tests (BVT) on the same type of lab topology. So I uninstalled everything and tried again making sure I don’t enter a wrong value somewhere along the way, but again the client installation failed. One might ask why I didn’t look at the tracing / logs of the setup in order to understand what went wrong, well at that time there weren’t any L.

So I reinstalled my lab from scratch (these were the days before virtualization) and crossing my fingers didn’t help as the client setup failed again. I called the developer in charge and after a short debugging session she found out that there was a parsing bug in the setup that caused the client setup to fail if the length machine name of the primary server and backup server were not equal. In the BVT lab all the machine names were MSMQXX (e.g. MSMQ01, MSMQ02, etc), in my lab the machines' name were NKPRIMARY, NKBACK1 and NKCLT1, thus the bug was not discovered during the BVT execution.

I wasted almost a whole working day due to this bug but I learned 3 important lessons:
1.       Diversity is very important pillar in testing and its is always better to be diverse as the customers.
2.       Tracing and a logging are not nice to have but rather a must to have.
3.       SDET should know how to debug the product he or she is working working on.

Thanks for taking the time to read my blog post.

Nir

PS Just to put things in perspective here is a list of more serious bugs

Microsoft Business Intelligence Roadshow - Tuesday, Feb 16th

ItayBraun — Sun, 07 Feb 2010 10:01:00 GMT

שלום לכולם

בעוד שבוע וקצת יתקיים בבית מיקרוסופט ברעננה אירוע בשםMicrosoft Business Intelligence Roadshow. היה לי העונג לשמו את המרצה, רפל לוקוויקי בעבר בלונדון. אז הוא דיבר על data mining. הפעם הוא יתרכז בחידושים של SQL Server 2008 R2 ובאינטגרציה עם אופיס 2010.

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

מומלץ להירשם כאן:

http://www.microsoft.com/israel/promotionalMail/birshowlnd/index.html

Entity Framework Context Lifetime Best Practices

Gil Fink — Sun, 07 Feb 2010 07:43:38 GMT

Entity Framework Context Lifetime Best Practices

In this post I’m
going to write
about one of the
major decisions
that you need to
take when you use
ORM tools like Entity Framework.
This decision is the context lifetime.

The Problem

Context lifetime is a very crucial decision to make when we
use ORMs. Since the context is acting as an entity cache (it holds
references to all the loaded entities for change tracking and
lazy loading purpose), it may grow very fast in memory consumption.
Also this behavior can cause a memory leak because if we don’t
dispose our context it will have references to all the loaded entities
and by that they will never be collected by the Garbage Collection.
Another problem that raise its ugly head is keeping a context lifetime
to long or to short. If we dispose the context after every database
manipulation or query we won’t enjoy the all the features it holds
(for example change tracking).
For example the following code disposes the context very fast and
shows the problem I talk about:

     using (var context = new SchoolEntities())

    {

        context.AddToDepartments(department);

        context.SaveChanges();

    }

On the other hand, keeping a long running context is also bad practice.
Sometimes I see developers that use the context as a singleton in their
system. This is very bad since as I wrote it can cause a memory leak.
Also it is bad habit because you will have transactions for longer time
than you should have them. Business transactions and connection
management should be used in very short bursts and only as they are
needed.

My Rules of Thumb

Web applications – use the context per request. Since in web
applications we deal with requests that are very short but holds
all the server transaction then they are the proper duration for
the context to live in. We will enjoy all the functionality of the
context and it won’t hang up very long.
Smart clients (Win Forms/WPF etc) – use a context per form.
Since we don’t want to have the context as a singleton for our
application we will dispose it when we move from one form to
another. In this way we will gain a lot of the context’s abilities
and won’t suffer from the implications of long running contexts.

Summery

Managing context lifetime is very crucial decision that we need to take
at the starting of every project. My rules of thumb is context per
request and context per form lifetimes.

Architecture Styles / Patterns

Danny Cohen — Sun, 07 Feb 2010 04:30:00 GMT

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

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

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

שאלה ראשונה: מענה לאיזה סוג של דרישות ?

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

את מידת המענה של הפתרון לדרישות פונקציונאליות קל (יחסית...) לבחון מבחינה טכנולוגית. "תופסים" את הדרישות האלו באמצעות תסריטים (scenarios) ו – use cases (או themes, epics ו – user stories , תלוי במתודולוגיית הפיתוח). האתגר בדרישות אלו הוא בדרך כלל אתגר של התנהלות ופוליטיקה ארגונית (השאלה "מהי הפונקציונליות הרצויה" תלויה לעתים קרובות באופי הארגון המפתח מאשר בצרכי המשתמש הסופי), בשיקולים של מאפייני המשתמשים (רקע וניסיון, ציפיות מוצהרות ולא-מוצהרות להתהגות המערכת, ציפיות סמנטיות, עומס קוגניטיבי סביר) ועוד.

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

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

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

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

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

וכאן נכנסים לתמונה ה – Architecture Styles.

ההגדרה ה"רשמית" של architecture styles (עד כמה שניתן למצוא הגדרות רשמיות במקצוע עמו ארכיטקטורת תוכנה, שעדיין נמצא בתהליכי התגבשות), היא:

"A set of principles for a family of systems that determines the vocabulary of components and connectors that can be used in instances of that style, together with a set of constraints on how they can be combined"

(מתוך המאמר המומלץ בחום "Introduction to Software Architecture" של David Garlan and Mary Shaw מ – 1994. מאמר שאפשר לשייך לו לא מעט השפעה בהיסטוריה של מקצוע ארכיטקטורת תוכנה).

ישנו דמיון רב בין Design Patterns לבין Architecture Styles (הכינוי הנפוץ "Architecture Patterns" מעיד על כך). עם זאת מדובר במשפחות שונות של תבניות (Patterns) שגם ממוקמות ברמות שונות בהיררכיה של ניתוח ואפיון מערכות תוכנה (רמת הארכיטקטורה לעומת רמת העיצוב – design – של המערכת). בגדול, אפשר לתאר את ה – architecture styles כתבניות בעלות נפח והשפעה מערכתית גדולים יותר (לעתים, הרבה יותר) מאשר Design Patterns.

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

שאלה שלישית: כיצד בוחרים את ה – Architecture Style המתאים ?

לכל Architecture Style יש מגוון מסוים וידוע מראש של מאפיינים אותם הוא מספק (במידה זו או אחרת). מאפיינים אלו ניתנים לניסוח כאותם Quality Attributes, הידועים כדרישות לא-פונקציונאליות. דוגמא אחת היא ה – Pipes and Filters architecture style (ה - style החביב עלי), שמאפשר לספק Quality Attributes כגון: Configurability, Composeability, Manageability, Reusability, Testability ועוד (הגדרת ה – Quality Attributes הנ"ל אינה ב – scope של הפוסט הנוכחי, אך ניתן ללמוד יותר בקישורים המצורפים).

וכאן אנו מגיעים לנקודה המרכזית –

היכולת לבחון ולבחור Architecture Styles בהתאם למידת התאמתם ל – Quality Attributes (הדרישות הלא-פונקציונאליות) של המערכת, היא זו המאפשרת להמחיש כיצד פתרון ארכיטקטוני מספק מענה לדרישות אלו.

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

מידת ההתאמה ל – quality attributes נובעת מהמאפיינים המובנים והידועים מראש של ה – Architecture Styles השונים (כאן בא לידי ביטוי הדמיון הרבה בינם לבין Patterns בכלל). הניסיון הרב שנצבר במימוש ה – Architecture Styles השונים מספק מידע רב לגבי יתרונותיהם וחסרונותיהם בהתייחס למגוון של תסריטים, וכן, עצם השימוש במונחים אחידים (vocabulary) מאפשר תקשורת יעילה מול ארכיטקטי תוכנה אחרים על מנת לאסוף המלצות, תובנות, הערות והארות בשלב מוקדם ככל האפשר בתהליך הניתוח האפיון.

כל זאת, בלי לזלזל או להתעלם מחשיבות הרבה שיש למימוש בפועל של ה – Architecture Style על היכולת לספק מענה לדרישות השונות.
לאחר צמצום האפשרויות ובחירת מספר Architecture styles שמועמדים לאימוץ במסגרת הפתרון הארכיטקטוני, מומלץ (מלשון "חובה" J), לבחון מאפיינים מעשיים, מדידים ומוחשיים של פתרונות אפשריים שמממשים Architecture Style שמועמד לשימוש. היות ורוב ה – Architecture Styles מומשו במסגרת Framework או מוצר זה או אחר, וזמינים לשימוש כ"קופסא שחורה", עולה השאלה של מידת ההתאמה של המוצר (או הרכיב, או התשתית וכו') לתסריט הספציפי עבורו מנסים לספק מענה. כמו תמיד – אלוהים נמצא בפרטים הקטנים (והשטן גם).

ולסיכום -

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

קישורים למקורות מידע נוספים בנושא -

Introduction to Software Architecture - המאמר המייסד של התחום
Microsoft Patterns & Prectices Application Architecture Guide 2.0 - Chapter 3 - Architectural Patterns and Styles - ספר מצוין של החבר'ה מ - Patterns & Practices
Pattern-Oriented Software Architecture - A System of Patterns - החלק הראשון בסדרה (POSA1), ולטעמי הטוב שבהם. מכיל סקירה מצוינת של מגוון Architecture Styles.
מצגת Architecture Styles מתוך סדנת ארכיטקטורת תוכנה.

HTH,

דני.

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

MS Israel Community

Closing Another Year

Closing Another Year

Few Stats About my Blog

Top Three Posts Ordered by Number of Views

Tell me how can I Improve My Blog

SharePoint 2010 Overview & Introduction to SharePoint 2010 Service Architecture – Session Slides

Windows Mobile 7 – Good or Bad ?

Disposable Property

does MEF apply the SOA paradigm?

does MEF apply the SOA paradigm?

Background

What make your architecture, service oriented?

The 4 tenets of SOA

How MEF apply to the 4 tenets?

Summary

Visual Studio 2010 RC Now Available

מסמך השיפורים של RDP 7

Microsoft MVP’s,MRD’s, MRS’s and UG Managers Summit - Israel

Microsoft MVP’s,MRD’s, MRS’s and UG Managers Summit - Israel

SSIS – Importing data from an Oracle data source

WCF Contrib v2.1 – Customize Output Caching Provider

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

איך מיקרוסופט הרגו את Windows Mobile

SharePoint developers required

Using Cookie in Client Side (JavaScript)

Back to Basics – Using MasterType Directive

Back to Basics – Using MasterType Directive

Setting the Environment

The MasterType Directive

Summary

WPF: How To Animate Visibility Property?

Coke steels Yotvata commercial advertisement !

Visual Studio 2010 RC

jQuery ו- Ajax

מה זה Ajax?

jQuery ו- Ajax

()get

()jQuery.getJSON

()jQuery.getScript

()load.

()post.

jQuery.ajax()

סוף!

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

SAVE THE DATE: Developers Academy 4

SAVE THE DATE: Developers Academy 4

The one I remember the most

Microsoft Business Intelligence Roadshow - Tuesday, Feb 16th

Entity Framework Context Lifetime Best Practices

Entity Framework Context Lifetime Best Practices

The Problem

My Rules of Thumb

Summery

Architecture Styles / Patterns