itaysk

Posts Summary 29 October, 2012

Itay Shakury — Tue, 30 Oct 2012 00:26:36 GMT

Posts Summary - 22 September, 2012

Itay Shakury — Sun, 23 Sep 2012 03:59:03 GMT

Stretched Farms are Not Supported Anymore in SharePoint 2013

Posts Summary – September 01, 2012

Itay Shakury — Sat, 01 Sep 2012 17:21:40 GMT

Posts Summary – August 11, 2012

Itay Shakury — Sat, 11 Aug 2012 21:18:58 GMT

Refreshing my social presence - New blog, Twitter

Itay Shakury — Wed, 01 Aug 2012 21:44:41 GMT

Hello readers,

Ready for some changes?

I am starting a new independent blog, which will be my primary work related blog.
It is called “Itay as a Service”, and is available now under: http://blog.itayasaservice.com
The old link will work as well: http://blog.itaysk.com

As for this blog, I will keep posting here summaries of my new posts, in order for subscribed readers to stay in the loop. All the content that was written here will stay here and will not be moved.

Also, I am (finally) joining the twitter community with a new account specifically for my professional interests.
Follow me on Twitter! @itayasaservice

Itay Shakury.

Is Metro Interface a “Performance Driven Design”?

Itay Shakury — Wed, 20 Jun 2012 02:07:11 GMT

האם ממשק המטרו הוא רעיון גאוני לעיצוב מונחה ביצועים?

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

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

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

מסך הפתיחה של Windows 8 (דוגמא לממשק מטרו)

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

מסך הפתיחה של Windows Phone 7.5 (דוגמא לממשק מטרו)

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

אם מסתכלים על המאפיינים של מטרו שתיארתי מקודם, קל לשים לב שהעקרונות מכתיבים ממשקים מאוד פשוטים, לא רק פשוטים למשתמש, אך גם פשוטים למחשב.
מבחינה עיבודית, כשמכונה כמו מחשב צריכה לצייר (to Render) מסך של מטרו, זה הרבה יותר פשוט מאשר מסך כמו של Android לדוגמא, או אפילו Windows 7.
עכשיו קחו את מה שאמרתי, ותוסיפו לזה את המגמה האדירה של עולם התכנה לכיוון אפליקציות מבוססות דפדפן, שגם הפכה למיינסטרים ב Windows 8, ותבינו איך הגעתי לחשוב על הקונפירציה הזו - אם אני רוצה לצייר בדפדפן באמצעות HTML\JS\CSS מסך של מטרו, זה הרבה הרבה הרבה יותר פשוט מלצייר לדוגמא מסך של אנדרואיד, או של מק. זו עבודה פשוטה מאוד, גם לדפדפן וגם למתכנת.

מסך הפתיחה של Android with HTC Sense (דוגמא לממשק שאינו מטרו)

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

ממשק פשוט, מינימליסטי, נקי - מבחינת המחשב זה פשוט מאוד. כמה שפחות דברים שהוא צריך לצייר למסך, הוא יעשה את זה יותר מהר. אם אנחנו אומרים שאנחנו רוצים מסכים פחות עמוסים בפקדים, זה אומר שהמסך ירוץ יותר מהר.
צבעים אחידים - בשביל מחשב לצבוע ריבוע בצבע כחול, זה הרבה יותר קל מלצבוע אותו בצבע מדורג (Gradiant) שהופל מכתום לכחול. אם מסתכלים עם דפדפנים זה אפילו יותר בולט, כשצביעה בצבע אחיד היא פעולה טריוואלית, בעוד שצבע מדורג היא פעולה לא פשוטה בכלל. אם נתחיל להשוות לאפקטים למיניהם כמו שקיפות למחצה, או אפקט הזכוכית, כאן זה כבר הבדל עצום בביצועים, וכשמדברים על דפדפן זה גם קשה למימוש עד בלתי אפשרי (תלוי באפקט).
ריבועים - צורות מלבניות למיניהן, הן יחידת ציוד די בסיסית למחשב. זאת לעומת צורות מורכבות יותר כמו לדוגמא, צורה של טיפה (סתם דוגמא). זה נובע מהמתמטיקה שמאחורי הצורה, אבל בשורה התחתונה, המחשב יצייר ריבועים הרבה יותר טוב מאשר טיפות, או לדוגמא ריבועים עם פינות מעוגלות (שרואים הרבה לדוגמא באייפון). אם נדבר על דפדפנים אז כאן ריבועים זה אבני היסוד של דפים. לצייר טיפה בדפדפן זו עבודה לא פשוטה בכלל וצורכת הרבה יותר משאבים מציור מלבן שפחות או יותר מסתכם בשורה אחת המייצרת Div עם Border ו Background-Color.
טיפוגרפיה - קחו לדוגמא את ממשק הפנורמה של Windows Phone 7. הוא מורכב רובו ככולו מטקסטים בלבד. אין אייקונים או סמלים מיוחדים, או תמונות או צורות אחרות. כמעט הכל שם זה טקסט. כתיבת טקסט היא גם אחת הפעולות הבסיסיות של המחשב ושל כל תשתית UI. אין צורך בכלי ציור מתוחכמים כדי לכתוב טקסט למסך. במיוחד כשמדובר על דפדפנים שבמקור נבנו עבור המטרה היחידה של הצגת טקסט, ולכן עושים זאת בקלות רבה מאוד.
ממשק ללא תמונות - זו אינה עיקרון ישיר של ממשק מטרו, אבל אם תשימו לב, לרוב באפליקציות מטרו אין תמונות אשר משמשות לבניית הממשק. אני לא מדבר על תמונות שהן חלק מהתוכן כמו לדוגמא תמונה של תל אביב בכתבה שמדברת על תל אביב. אני מדבר על תמונות שבונות את הממשק, כמו לדוגמא אייקונים למיניהם, תמונות רקע, חלקים מהתפריט, וכולי. לצייר תמונה על המסך זו לא עבודה קשה למחשב, אבל בטוח שיותר קשה מלצייר קו, או ריבוע. בנוסף, מעבר ליתרון בביצועים, עם תמונות קשה להתעסק. כדי שיראו טוב צריך שיהיו ברזולוציה גבוהה, וזה אומר נפח גדול. צריך לדאוג לשמור על פרופורציות. לפעמים צריך לספק כמה גדלים לאותה תמונה עבור שימושים שונים, ואי אפשר להגדיל או להקטין אותן בקלות תוך שמירה על המראה המקורי.

בואו נראה את ההבדלים בפועל:

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

לעומת ממשק ההגדרות של Windows Phone:

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

דוגמא נוספת:

שולחן העבודה של Windows Vista:

(האמת שיש כאן המון אפקטים קטנים, אבל רק הדגשתי את הבולטים מביניהם.)

לעומת שולחן העבודה של Windows 8:

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

“To complete the story, we updated the appearance of most common controls, such as buttons, check boxes, sliders, and the Ribbon. We squared off the rounded edges, cleaned away gradients, and flattened the control backgrounds”

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

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

Presenting at SharePoint User Group Tomorrow

Itay Shakury — Sun, 27 May 2012 14:10:15 GMT

תזכורת: מחר (28/05/2012) בשעה 17:30 יתקיים מפגש של SharePoint User Group. אני אעביר הרצאה על Claims Based Authentication in SharePoint 2010.
המפגש אינו כרוך בתשלום, אך מצריך הרשמה מראש בקישור:
http://spug-28-may-eorg.eventbrite.com

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

BDC -> BCS?

Itay Shakury — Tue, 15 May 2012 19:40:17 GMT

MOSS 2007 had a feature called Business Data Catalog. When SharePoint 2010 came out, this feature was introduced as Business Connectivity Services.

The common belief is that BCS is the new version of BDC, and that in the new version the name was changed from BDC to BCS. According to this, there is no reason to use the term BDC in the context of SharePoint 2010.
This is not exactly correct.
BDC was and still the infrastructure that allows SharePoint to connect to other systems. It has the concept of metadata and descriptors, and is still present in 2010 under the name “Business Data Connectivity”. BCS is based on BDC and is what makes all the advanced connectivity scenarios possible (such as integration with Office, ECT,…).

In the bottom-line, the terms BDC and BCS is used interchangeably, so you should too. But you don’t have to be angry if you see BDC in the same sentence with SharePoint 2010 :)

Here are some supporting quotes from MSDN:

“Business Data Connectivity (BDC) service is the new version of the Business Data Catalog that was provided in Microsoft Office SharePoint Server 2007”
http://msdn.microsoft.com/en-us/library/ee556407.aspx

“Business Data Connectivity (BDC) service succeeds the Business Data Catalog that was provided in Microsoft Office SharePoint Server 2007”
http://msdn.microsoft.com/en-us/library/ee558876.aspx

“BDC is the foundation of Business Connectivity Services”
http://msdn.microsoft.com/en-us/library/ee559650.aspx

“Business Data Connectivity (BDC) service in Microsoft Business Connectivity Services (BCS) is the underlying framework in the Microsoft SharePoint Foundation 2010 platform on which Business Connectivity Services is built”
http://msdn.microsoft.com/en-us/library/ee557963.aspx

Xml Serialize Interface Typed Members

Itay Shakury — Mon, 30 Apr 2012 14:48:30 GMT

If you try to serialize a class that has a public member of an interface type to xml file using the regular .net XmlSerializer, you will get an error: “Cannot serialize member {m} of type {t} because it is an interface.” ({m} and {t} are placeholders).
In this post I suggest a workaround to this issue.

Consider the following scenario:

You have an object model like this:

        1: public class Car

       2: {

       3:     public string Model { get; set; }

       4:     public int Year { get; set; }

       5:     public IEngine Engine { get; set; }

       6: }

       7:  

       8: public interface IEngine

       9: {

    void Work();

}

  

public class ElectricEngine : IEngine

{

    int batteryPrecentageLeft;

    public int BatteryPrecentageLeft

    {

        get { return this.batteryPrecentageLeft; }

        set { this.batteryPrecentageLeft = value; }

    }

  

    void IEngine.Work() { }

}

  

public class InternalCombustionEngine : IEngine

{

    int gasLitersLeft;

    public int GasLitersLeft

    {

        get { return this.gasLitersLeft; }

        set { this.gasLitersLeft = value; }

    }

  

    void IEngine.Work() { }

}

And you use it like so:

       1: Car myCar = new Car();

       2: myCar.Model = "Ford Focus";

       3: myCar.Year = 2011;

       4: myCar.Engine = new ElectricEngine() { BatteryPrecentageLeft = 70 };

       5:  

       6: myCar.Engine.Work();

If you would try to serialize myCar using the regular XmlSerializer, you will get the error above.

There are many reasons why you shouldn’t want to serialize an interface typed member. I will not dive into this debate right now. I assume that you have considered this before, and are just looking for a workaround.

So first lets understand what we are trying to achieve.
In the example above, I expect the serialized output of myCar to be something like this:

       1: <Car xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">

       2:   <Model>Ford Focus</Model>

       3:   <Year>2011</Year>

       4:   <Engine>

       5:     <ElectricEngine FullAssemblyQualifiedTypeName="Common.ElectricEngine, Common, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null">

       6:       <BatteryPrecentageLeft>70</BatteryPrecentageLeft>

       7:     </ElectricEngine>

       8:   </Engine>

       9: </Car>

I have asked a question on StackOverflow, and Jens Granlund has pointed me in the right direction.
The workaround that I have implemented consists of the following steps:

Mark all interface typed members with the XmlIgnoreAttribute, that tells the XmlSerializer to not serialize those members.
Now serialize the class to produce an output similar to the one above, but without the problematic members.
For-each member marked with the attribute, get it’s current value, and that value’s type. That can only be done in runtime.
Use that type to create a standard XmlSerializer, and use that serializer to serialize that value.
Inject those serialized values to the parent class’s serialized xml.
In order to allow regular use of the XmlIgnoreAttribute, implement a new attribute that act like it.
During deserialization perform the same process in reverse.

I have followed that basic recipe to create my own “RuntimeXmlSerializer”. You use it the same way you would use the standard XmlSerializer.

       1: public class RuntimeXmlSerializerAttribute : XmlIgnoreAttribute { }

       2:  

       3: public class RuntimeXmlSerializer

       4: {

       5:     private Type m_type;

       6:     private XmlSerializer m_regularXmlSerializer;

       7:  

       8:     private const string k_FullClassNameAttributeName = "FullAssemblyQualifiedTypeName";

       9:  

    public RuntimeXmlSerializer(Type i_subjectType)

    {

        this.m_type = i_subjectType;

        this.m_regularXmlSerializer = new XmlSerializer(this.m_type);

    }

  

    public void Serialize(object i_objectToSerialize, Stream i_streamToSerializeTo)

    {

        StringWriter sw = new StringWriter();

        this.m_regularXmlSerializer.Serialize(sw, i_objectToSerialize);

        XDocument objectXml = XDocument.Parse(sw.ToString());

        sw.Dispose();

        SerializeExtra(i_objectToSerialize,objectXml);

        string res = objectXml.ToString();

        byte[] bytesToWrite = Encoding.UTF8.GetBytes(res);

        i_streamToSerializeTo.Write(bytesToWrite, 0, bytesToWrite.Length);

    }

  

    public object Deserialize(Stream i_streamToSerializeFrom)

    {

        string xmlContents = new StreamReader(i_streamToSerializeFrom).ReadToEnd();

        StringReader sr;

        sr = new StringReader(xmlContents);

        object res = this.m_regularXmlSerializer.Deserialize(sr);

        sr.Dispose();

        sr = new StringReader(xmlContents);

        XDocument doc = XDocument.Load(sr);

        sr.Dispose();

        deserializeExtra(res, doc);

        return res;

    }

  

    private void deserializeExtra(object i_desirializedObject, XDocument i_xmlToDeserializeFrom)

    {

        IEnumerable propertiesToDeserialize = i_desirializedObject.GetType()

            .GetProperties().Where(p => p.GetCustomAttributes(true)

                .FirstOrDefault(a => a.GetType() ==

                    typeof(RuntimeXmlSerializerAttribute)) != null);

        foreach (PropertyInfo prop in propertiesToDeserialize)

        {

            XElement propertyXml = i_xmlToDeserializeFrom.Descendants().FirstOrDefault(e =>

                e.Name == prop.Name);

            if (propertyXml == null) continue;

            XElement propertyValueXml = propertyXml.Descendants().FirstOrDefault();

            Type type = Type.GetType(propertyValueXml.Attribute(k_FullClassNameAttributeName).Value.ToString());

            XmlSerializer srl = new XmlSerializer(type);

            object deserializedObject = srl.Deserialize(propertyValueXml.CreateReader());

            prop.SetValue(i_desirializedObject, deserializedObject, null);

        }

    }

  

    private void SerializeExtra(object objectToSerialize, XDocument xmlToSerializeTo)

    {

        IEnumerable propertiesToSerialize =

            objectToSerialize.GetType().GetProperties().Where(p =>

                p.GetCustomAttributes(true).FirstOrDefault(a =>

                    a.GetType() == typeof(RuntimeXmlSerializerAttribute)) != null);

        foreach (PropertyInfo prop in propertiesToSerialize)

        {

            XElement serializedProperty = new XElement(prop.Name);

            serializedProperty.AddFirst(serializeObjectAtRuntime(prop.GetValue(objectToSerialize, null)));

            xmlToSerializeTo.Descendants().First().Add(serializedProperty); //TODO

        }

    }

  

    private XElement serializeObjectAtRuntime(object i_objectToSerialize)

    {

        Type t = i_objectToSerialize.GetType();

        XmlSerializer srl = new XmlSerializer(t);

        StringWriter sw = new StringWriter();

        srl.Serialize(sw, i_objectToSerialize);

        XElement res = XElement.Parse(sw.ToString());

        sw.Dispose();

        XAttribute fullClassNameAttribute = new XAttribute(k_FullClassNameAttributeName, t.AssemblyQualifiedName);

        res.Add(fullClassNameAttribute);

  

        return res;

    }

}

Notice that this solution doesn’t handle situations in which the interface typed member is not a direct descendent of the type being serialized. In example if Car has a member of type List<IWheel> or if Car has a member of type Dashboard which has a member f type IGauge, than serialization will fail.
This can be solved by recursively performing the “Runtime” serialization on all members, until we reach a primitive member which we can serialize using the regular serializer.

You can find the Visual Studio project in this link:
http://blogs.microsoft.co.il/files/folders/1078707/download.aspx

Enterprise Wiki site template vs. Wiki Library template

Itay Shakury — Mon, 16 Apr 2012 00:00:52 GMT

We all know wikis and how they work. It's a quick way to create inter-connected items of unstructured data.
SharePoint 2010 Introduces two wiki solutions that appear similar on first sight, but are actually different. In this post I will cover technical differences between the two.

First is the "Enterprise Wiki" site template. It's a template that can be used to create site collections, or sub-sites. The Enterprise Wiki site template creates a site that is dedicated to wiki content. The main component in the site is the "Pages" Library. We will explorer it later.

Second is the "Wiki Page Library" list template. This Wiki Library can host wiki pages. It can be created in any kind of site.
As a matter of fact, this Wiki Library list template is used as the default pages library in the "Team Site" site template.

According to this article on MSDN, here is a short comparison between the two:

If you want to:	Use this site template:
Encourage one-to-many communication	Team Site
Encourage many-to-many communication	Enterprise Wiki
Offer a structured exchange of information	Team Site
Enable a collaborative exchange of information	Enterprise Wiki
Insert images or files in a pages	Team Site or Enterprise Wiki
Mark pages for easier reference by tagging them with enterprise keywords	Enterprise Wiki

These are nice guidelines, but what is the real difference of each?
I am now going to go through the detailed process that I took for investigating the case. You can skip to the end if you want the summary.

Wiki Page Library

The template is part of the feature called "WebPageLibrary". In this feature, you can find the list definition at: "14\TEMPLATES\FEATURES\WebPageLibrary\ListTemlpates\WebPageLibrary.xml".
If you look at it, you'll notice that the list template id is 119, and BaseType="1", which means it is a regular document library.

If we take a look at the schema.xml file at "14\TEMPLATES\FEATURES\WebPageLibrary\WebPageLib\schema.xml", we will see that the template associates a content type with ID 0x010108 to the library. This content type is called "WikiDocument", and is defined in: "14\TEMPLATES\FEATURES\ctypes\ctypeswss.xml". It inherits from the base "Document" content type, does 2 things: Add the "WikiField", and remove the "Title" field.
The "WikiField" field is what holds the content of the page.

Enterpries Wiki

This is an entierly different beast. First of all, it's a site definition. You will find the "Enterprise Wiki" site definition at 14\TEMPLATE\1033\XML\webtempsps.xml. Let's take a closer look at it.
The site definition onet.xml file is at: 14\TEMPLATE\SiteTemplates\ENTERWIKI\XML\onet.xml. In here, we can see that this is actually a publishing site (publishing features, such as "Publishing 22A9EF51-737B-4ff2-9346-694633FE4416" are activated).

In addition to the standatd pablishing features, there's an additional feature with id "76D688AD-C16E-4cec-9B71-7B7F0D79B9CD". This is the EnterpriseWiki feature, you can find it's source at: 14\TEMPALTE\FEATURES\EnterpriseWiki.

If you take a look at EnterpriseWikiContentTypeBinding.xml, you will see that the feature takes the default pages library that is created with the publishing infrastructure, and binds to it 2 content types. One is the standard Redirect Page content type, and the other is the Enterprise Wiki content type.
The Enterprise Wiki content type is defined at: 14\TEMPALTE\FEATURES\EnterpriseWikiContentTypes, and defines the following fields: ModifiedBy, PublishingPageContent, Rating, RatingCount.

If we take a look at the page layout at: 14\TEMPALTE\FEATURES\EnterpriseWikiLayouts\PageLayouts\EnterpriseWiki.aspx, we will see that the field that holds the content of the page is "PublishingPageContent". This field is just like the "WikiField" field that we discussed earlier.

Rendering

Handling wiki style markup is integrated into SharePoint foundation. From what I have found, it seems that the translation from wiki syntax to html is done in the field level (not UI control). The class "SPFieldMultilineText" has a property called "WikiLinking" (boolean), that toggles the feature on or off.
For publishing pages, the "HtmlField" inherits indirectly from SPFieldMultilineText, so it supports this too.

You can use this feature with regular publishing pages as well (not nessicarely wiki page layouts).
If you look at the source of a publishing page you will see a line similar to this: document.getElementById('ctl00_PlaceHolderMain_PageContent_RichHtmlField_displayContent').WikiLinking = 'on';
This controls whether or not the wiki syntax translation is active.

Summary

SharePoint has different 2 solutions for wiki style editing:

1. Wiki Library - a web pages library that uses the "Wiki Document" content type. This content type has a field called "WikiField" to hold the wiki content.

2. Enterprise Wiki - a site definition that is based on the publishing infrustructure. As such, it is based on the built in "Pages" library. It uses a content type called "Enterprise Wiki", in which the field "PublishingPageContent" is used to hold wiki content.

This knowledge can be helpful if you are developing solutions that are usign the wiki features programmatically.

-- My name is Itay Shakury, and I'm a SharePoint consultant --

SharePoint 15 “Apps” (as documented in the CTP SDK)

Itay Shakury — Tue, 27 Mar 2012 03:25:22 GMT

A while ago, Microsoft has released a CTP (Community Tech Preview) version for the SDK (Software Development Kit) of the next version of SharePoint (aka SharePoint 15).
Browsing through it I have learned about the new concept of Apps in SharePoint 15 (codename). In this post I will share my findings and conclusions.

I start by noticing the SPApp object, that lies in the Microsoft.SharePoint.Administration namespace. It “Represents an app loaded onto Microsoft SharePoint Server and ready to be installed.”
Right next to the SPApp Object, we see the SPAppCatlog class which “Represents all of the SPAppInstance objects installed on an instance of Microsoft SharePoint Server. It provides querying capabilities for discovering installations.”. Naturally, if we are going to have apps, we need some sort of an App Store to obtain apps from.

If we drill down a level into the SPAppCatalog, we will see that it has a GetAppInstance method, that “Gets all the SPAppInstance objects installed at a given SPWeb.”. Also, the SPAppInstance class says it “Represents an SPApp object installed to a specific SPWeb site.”. So apps are scoped to the SPWeb level – cool.

Continuing to the SPWebApplication class, we find that is has a new method called IsUserLicensedForEntity, that “Checks if the currently logged in user has the proper license to access the specified entity.” If we going to have an App Store like system, we need to have a mechanism to enforce licensing.

What more do we know about apps from real world? They need your permissions to access your data. This is usually done (in real world) with the OAuth protocol, and SharePoint 15 apparently supports this too! There’s a new namespace called Microsoft.SharePoint.IdentityModel.OAuth2 that will probably contain the basis for this, and some classes in Microsoft.SharePoint like SPApplicationCredentials and SPAppPrincipalPermissionsManager that will probably allow programmatic handling of permissions.

There’s another new namespace called Microsoft.SharePoint.Administration.AppDeployment that contains two classes – DatabaseProviderConstants, and DatabaseProviderTypePersistedObject. So there’s apparently something with a database for an app. The SPWeb class also has new properties regarding App DBs – for example the AppDataBaseName property that “Gets the name of the app database associated with this Web.”. Frankly, this is still a mystery for me since it’s use is not documented in the CTP SDK, and not very self explanatory.

In conclusion:

SharePoint has a new concept of Apps
Apps are scoped to SPWeb
Apps are distributed via the AppCatalog
There’s built in support for licensing apps
Apps can ask for permission using OAuth
There’s something with app databases yet to be clarified

This is a very interesting direction that the SharePoint team is taking, and probably revolutionary in the SharePoint world. I hope we can here more details soon.

-- My name is Itay Shakury, and I’m a SharePoint Consultant --

Storing Configuration Settings For Timer Jobs

Itay Shakury — Fri, 23 Mar 2012 19:58:07 GMT

When you develop a custom timer job, there is often a need to store configuration settings.
The best way to do this is using the Hierarchical Object Store in SharePoint, by creating an SPPerststedObject. There are plenty of articles out there that tell you to how to do this.
For more info on this subject, see this:
http://msdn.microsoft.com/en-us/library/cc406686(office.12).aspx
http://msdn.microsoft.com/en-us/library/hh528519.aspx

So it’s called "hierarchical” object store, because you have to attach the settings to a certain object in the SharePoint object model, and that object must support this by inheriting from SPPersistedObject. Most of those articles shows you how to attach settings to SPFarm, SPWebApplication, or SPSiteCollection objects, but as a matter of fact, the SPJobDefinition class is also a SPPersistedObject!

This means that you can attach settings to the job object directly, and not leave them hanging at the farm or a higher level. This has two benefits:

It’s more organized to keep timer job related settings at the timer job level (and not web application level for example)
When you delete the timer job, the settings are deleted as well

Here’s a sample:

        1: SPWebApplication wa = SPWebApplication.Lookup(new Uri("http://MySP"));

       2: SPJobDefinition job = wa.JobDefinitions.First(j => j.Name == "MyTimerJob");

       3:  

       4: //Store the settings

       5: MyJobSettings settings = new MyJobSettings("settings", job); //here we set job as the parent

       6: settings.settings1 = "Sample Data";

       7: settings.Update();

And the reading:

       1: //Read the settings

       2: MyJobSettings res = job.GetChild<MyJobSettings>("settings");

       3: string setting1 = res.setting1;

-- My name is Itay Shakury, and I’m a SharePoint consultant --

Follow Up on My SharePoint Extreme Session on Claims Based Authentication

Itay Shakury — Thu, 22 Mar 2012 18:56:58 GMT

בכנס SharePoint Extreme האחרון העברתי מצגת על Claims Based Authentication עם SharePoint 2010.
מכיוון שזהו נושא חדש יחסית, המצגת התמקדה בעיקר בהיכרות עם מה זה בכלל Claims Based Authenticatoin, ואיך זה עובד.
לאחר המצגת קיבלתי שאלות בנוגע לתהליך הטכני. פוסט זה בא להבהיר את התהליך.

התהליך שהצגתי הוא כזה:

משתמש ניגש לשרת SP
המשתמש מופנה ל STS
STS מאמת את המשתמש
STS מחזיר למשתמש Token
המשתמש ניגש אל ה SP, הפעם עם ה Token
SP מאשר את ה Token ומאפשר גישה

השאלה העיקרית הייתה בנוגע לשימוש ב Cookies, ואיך כל זה עובד עם מגבלות כמו Cross-Domain.

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

משתמש מבצע HTTP GET ל SP
SP מחזיר 302 Redirect. בסופו של דבר המשתמש מופנה אל הכתובת של ה STS (בד”כ סדרה של הפניות)
הדפדפן ניגש אל ה STS, המשתמש מאומת באמצעות דף ה Login
ה STS מחזיר למשתמש דף שמכיל את ה Token (בגוף הדף, בד”כ כ hidden field),
באותו דף ישנו קוד Javascript שגורם לדפדפן לעשות HTTP POST אל ה SP, עם ה Token.
SP מקבל את הבקשה ויודע לנתח אותה בהתאם

אם כן, השאלה הבאה היא איך Cookies נכנסים לתמונה?

ה STS, או ה SP יכולים להשתמש ב cookies (או באיזו טכנולוגיה שהם רוצים) כדי לשמר session עם המשתמש.
כלומר, כדי שתהליך ההזדהות לא יקרה בכל פעם, ה SP מנפיק למשתמש cookie שמשאיר אותו מזוהה במהלך השימוש שלו באתר (ע”ע FedAuth).
באותה מידה ה STS יכול להנפיק למשתמש cookie כדי לזהות בצורה אוטומאטית את המשתמש אם הגיעה בקשה נוספת להזדהות.

I’m Speaking at SharePoint Extreme 2012

Itay Shakury — Mon, 12 Mar 2012 23:30:20 GMT

ביום שלישי הקרוב עד יום חמישי, 13-15/3/2012, יתקיים כנס SharePoint Extreme – כנס מקצועי לחלוטין עם הרצאות ממוקדות לקהלי יעד שונים בנושאי SharePoint.
אני ארצה ביום חמישי במסלול Real World SharePoint Architecture הרצאה על Claims Based Authentication ב SharePoint 2010.
בהרצאה אציג את העולם של Claims Based Authenticatoin, את היתרונות והמניעים לטכנולוגיה, את השילוב עם SharePoint, ותרחישים לדוגמא שמתבססים עליה.

(ההרשמה לכנס כרוכה בתשלום)

לפרטים נוספים והרשמה:
http://www.microsoft.com/israel/sharepointExtreme/content/Lectures/13036.aspx