itaysk

BDC -> BCS?

Itay Shakury — Tue, 15 May 2012 12: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 07: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 — Sun, 15 Apr 2012 17: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 — Mon, 26 Mar 2012 21: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 13: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 12: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 17: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

Resources From My Session At SharePoint Extreme Event

Itay Shakury — Wed, 23 Mar 2011 19:30:50 GMT

שלום לכולם,

בתאריך 22.3.11 העברתי בכנס SharePoint Extreme ‘הרצאה בנושא שיפור ביצועים באתרי SharePoint.

תודה לכל מי שהשתתף, ותודה לירון ורועי מתבונה-מילניום שארגנו את המסלול.

מצורפת המצגת שהעברתי. שימו לב שבחלק הערות (Notes) של כל שקופית יש קישורים רלוונטיים.

http://cid-3d176b702454b41b.office.live.com/view.aspx/blog/SPE%20-%20SharePoint%202010%20Performance.pptx

I Will Be Speaking at SharePoint Extreme Event

Itay Shakury — Sun, 20 Mar 2011 18:22:19 GMT

בתאריך 22.3.11 עד 24.3.11 יתקיים כנס SharePoint Extreme - שלושה ימים של סדנאות והרצאות שכולן על SharePoint.

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

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

לפרטים והרשמה:
http://www.microsoft.com/israel/sharepointExtreme/Default.aspx

ההרשמה כרוכה בתשלום.

Joining The Mothership

Itay Shakury — Tue, 15 Feb 2011 08:30:38 GMT

Short Summary for English speaking readers: I’m Joining Microsoft, no longer MVP.

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

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

איתי שקורי.

SharePoint Group–1/11

Itay Shakury — Thu, 06 Jan 2011 09:30:17 GMT

שלום לכולם,

מפגש ראשון של השנה החדשה יתקיים בתאריך ה 23/01/2011. את המפגש יעבירו יוני תורג’מן ואלכס לויטין מחברת גארדיאן.

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

תיאור המפגש:

במפגש זה נעסוק בכל נושא העבודה מול ממשק ה-UI של SharePoint 2010. המפגש יתחלק לשלושה חלקים:
1. עבודה עם ממשק ה-Ribbon: בחלק זה נדבר על עבודה מול ממשק ה-Ribbon באמצעות SharePoint Designer 2010 (ללא כתיבת קוד), דרך המתאימה בעיקר למיישמים ומטמיעים, ובאמצעות Visual Studio 2010 ונראה כיצד ניתן באמצעות קוד להרחיב את יכולות הממשק.
2. User Notifications: בחלק זה נדבר על התראות למשתמש באמצעות ה-User Notifications של SharePoint 2010.
Popup Modal .3: בחלק האחרון של המפגש נדבר על עבודה מול ממשק ה-Modal החדש של SharePoint 2010 ונראה איך באמצעות JavaScript ניתן להקפיץ חלונות למשתמש.

לפרטים נוספים והרשמה:
http://www.sharepoint-israel.co.il/events/SPG/SPG11

נתראה במפגש,
איתי שקורי.

SharePoint Group–Meeting 10 Summary

Itay Shakury — Tue, 28 Dec 2010 18:36:16 GMT

שלום לכולם,

בתאריך 26/12/10 התקיים מפגש בנושא ALM With SharePoint 2010.
את המפגש העביר אסף אבן מחברת אדוונטק.

את המצגת, וחומרים נוספים מהאירוע, ניתן למצוא באתר האירוע, בכתובת הבאה:
http://www.sharepoint-israel.co.il/events/SPG/SPG10

שאלות המשך, ניתן לשאול בפורום בכתובת
http://www.sharepoint-israel.co.il/forums

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

How My Latest Post Can Help You Save Time

Itay Shakury — Sun, 19 Dec 2010 16:01:01 GMT

I recently wrote a post regarding a certain performance issue with SharePoint that we solved. I since got some comments and questions about when is this problem relevant.

Well.. It’s practically everywhere ,in an isolated environment, and It’s very common for development machines (usually virtual) to be disconnected. The fixes suggested in that post can help you speed up your work in the following cases:

A desktop application (WinForm\Console) that uses SharePoint APIs.
STSADM.exe.
PowerShell work with SharePoint.
First hit of your SharePoint site.
IIS reset\Recycle app pool when deploying to SharePoint.
Anything else I didn’t think of, that uses SharePoint API’s in it’s own process (app domain to be precise).

SharePoint Is Slow On Isolated Environments

Itay Shakury — Wed, 15 Dec 2010 12:09:04 GMT

This is an interesting case that was solved thanks to the help of Nitsan Raz – an all mighty system administrator and SharePoint admin.

Problem

So I was asked to investigate a performance problem at one of my regular clients.

To demonstrate the performance problem, the client’s developers showed me a simple WinForm application (on the server), that created an instance of an SPSite object. the code had 1 line of interest, which is:

SPSite site = new SPSite("http://mySite");

That line alone took 30 seconds to execute! What’s more interesting, was that subsequent calls was very fast to execute. It was just the first one that took so long.

Cause

First thing we though was to isolate the location of the hang. Was it on the application side, or DB side? We ran SQL profiler and saw that SQL queries took like a millisecond to execute. That test eliminated the option of DB problem.

Having figured that out, we decided to run some tests on the application server (SharePoint Web Front End). After hours of time measures and watching endless performance counters go up and down the screen, we decided to monitor network activity.

We found 2 interesting lines in the log. These were DNS queries for crl.microsoft.com. How is that has to do with our application?

It turns out, that SharePoint’s assemblies are signed using a Authenticode, and that every time they are loaded into an app domain, the system tries to verify their validity by asking Microsoft for Certificate Revocation List (CRL). This is a list that contains certificates that are no longer valid.
Our environment was disconnected from the internet, so obviously we can’t reach Microsoft’s servers to get the CRL. That process failed on the very beginning , when trying to lookup Microsoft.com on DNS. The DNS didn’t respond on time, so we were waiting for the lookup to time out… guessing what’s the time out for DNS lookups? 15 seconds. This explains why we waited 30 seconds (for 2 assemblies to load).

Solution

There are several ways we can deal with this: (You should choose only one of the following)

1. Add the following configuration to the configuration file for the application that is loading the files: (This could be MyApp.config, web.config, machine.config, etc… – depending on your application)

<configuration> 
  <runtime> 
    <generatePublisherEvidence enabled="false"/> 
  </runtime> 
</configuration>

This solution requires a hotfix for .NET 2.0, and is already built into later versions. More info:
http://support.microsoft.com/kb/936707

2. Turn off CRL checks (the the user level). Internet Options->Advanced tab->Security section under the Settings area->Check for publisher’s certificate revocation->turn that off (uncheck).

3. Add a fake DNS record that points to yourself (127.0.0.1), that will shorten the time to fail.

4. Pre-fetch CRL files, so that it will be pulled locally and not from the internet.

Download these:
http://crl.microsoft.com/pki/crl/products/CodeSignPCA.crl
http://crl.microsoft.com/pki/crl/products/CodeSignPCA2.crl
Add to certificate store:
certutil -addstore CA CodeSignPCA.crl 
certutil -addstore CA CodeSignPCA2.crl

5. Allow internet access, obviously (if only to crl.microsoft.com)

Credits

Dirk Van den Berghe
Nitsan Raz

For more info on assembly signing:
http://blogs.msdn.com/b/junfeng/archive/2006/03/11/549355.aspx

itaysk

BDC -> BCS?

Xml Serialize Interface Typed Members

Enterprise Wiki site template vs. Wiki Library template

More Findings from reading SharePoint 15 CTP SDK

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

Storing Configuration Settings For Timer Jobs

Follow Up on My SharePoint Extreme Session on Claims Based Authentication

I’m Speaking at SharePoint Extreme 2012

Resources From My Session At SharePoint Extreme Event

I Will Be Speaking at SharePoint Extreme Event

Joining The Mothership

SharePoint Group–1/11

SharePoint Group–Meeting 10 Summary

How My Latest Post Can Help You Save Time

SharePoint Is Slow On Isolated Environments