What’s New in SharePoint 2016

Watch the above video to find out what are the new features in SharePoint 2016. Also view the PowerPoint slide below as well.

Advertisements

Setting Up SharePoint 2013 Dev Environment in Office 365

To get started in setting up a SharePoint 2013 development environment, watch the above video. I have also documented the procedure for setting up a SharePoint 2013 environment which can be read below.

The presentation slide for the video can be read below.

Disclaimer: I do not own the content of the video or PowerPoint slide. All credit goes to Microsoft Academy.

SharePoint 2013 BootStrap

Watch the above video to demonstrate how to create a simple mobile responsive branded SharePoint 2013 site using only CSS.

However when developing a complex branding site for SharePoint 2013, where the site needs to be mobile responsive and compatible across mobile devices and tablets, then the starting point is learning how to implement a master page that uses BootStrap.

Getting Started

There are three ways below to get started in using BootStrap framework for SharePoint 2013.

  • ShareBoot – It is a responsive SharePoint 2013 theme that is downloaded from a Zip file. When uncompressed, the zip contains a master page, three page layouts and bootstrap files;
  • CodePlex – There is an open community source code called “Responsive SharePoint” that contains the source code and WSP file to deploy a branded SharePoint 2013 site with BootStrap; and
  • Twitter BootStrap – Solutions in GitHub with its documentations.

“ShareBoot” and “Responsive SharePoint CodePlex” already has their solution with BootStrap integrated with SharePoint 2013. So it is quicker to get started using either of them in SharePoint 2013. However “Twitter Bootstrap” has standalone solution with just CSS3,  JavaScript & Font files.

This blog focuses on how to use ShareBoot.  So for a complete instructions on how to deploy ShareBoot in SharePoint 2013, read below:

Note that the documented instructions is a manual process of deploying ShareBoot as a drawback. So to automate the deployment process, I suggest packaging up all the deployment ShareBoot files into Visual Studio 2012-13 as a solution package WSP file.

 

References

  1. http://getbootstrap.com/
  1. W3School links below:

Bootstrap 3 Home

Bootstrap Grids

Bootstrap CSS Ref

Bootstrap Comps

Bootstrap JS Ref

  1. SharePoint 20103 Responsive – CodePlex

What is REST?

REST stands for Representational State Transfer. (It is sometimes spelled “ReST”.) It relies on a stateless, client-server, cacheable communications protocol — and in virtually all cases, the HTTP protocol is used.

REST is an architecture style for designing networked applications. The idea is that, rather than using complex mechanisms such as CORBA, RPC or SOAP to connect between machines, simple HTTP is used to make calls between machines.

In many ways, the World Wide Web itself, based on HTTP, can be viewed as a REST-based architecture.

RESTful applications use HTTP requests to post data (create and/or update), read data (e.g., make queries), and delete data. Thus, REST uses HTTP for all four CRUD (Create/Read/Update/Delete) operations.

REST is a lightweight alternative to mechanisms like RPC (Remote Procedure Calls) and Web Services (SOAP, WSDL, et al.). Later, we will see how much more simple REST is.

  • Despite being simple, REST is fully-featured; there’s basically nothing you can do in Web Services that can’t be done with a RESTful architecture.

REST is not a “standard”. There will never be a W3C recommendataion for REST, for example. And while there are REST programming frameworks, working with REST is so simple that you can often “roll your own” with standard library features in languages like Perl, Java, or C#.

  • Architecture style – concept / theory
  • Architecture pattern – Components and how they interact with each other
  • Design pattern – Solution at code level and talks about logic and classes

 

REST As Light Weight Web Services

As a programming approach, REST is a lightweight alternative to Web Services and RPC.

Much like Web Services, a REST service is:

  • Platform-independent (you don’t care if the server is Unix, the client is a Mac, or anything else),
  • Language-independent (C# can talk to Java, etc.),
  • Standards-based (runs on top of HTTP), and
  • Can easily be used in the presence of firewalls.

Like Web Services, REST offers no built-in security features, encryption, session management, QoS guarantees, etc. But also as with Web Services, these can be added by building on top of HTTP:

  • For security, username/password tokens are often used.
  • For encryption, REST can be used on top of HTTPS (secure sockets).
  • … etc.

One thing that is not part of a good REST design is cookies: The “ST” in “REST” stands for “State Transfer”, and indeed, in a good REST design operations are self-contained, and each request carries with it (transfers) all the information (state) that the server needs in order to complete it.

How To Deploy InfoPath 2010 Form Templates with Administrative Approvals

The YouTube video above is base on the following set of instructions below about how to publish an InfoPath 2010 form template with admin approval in Central Administration.

  1. Update the existing InfoPath form in InfoPath 2010 Designer and make the request changes
  2. Once update changes is completed, save the file.

Publish

Before publish any forms, always perform a BACK UP of the current existing InfoPath form template(s) that will later be overwritten with the new changes. See Appendix A for more details.

3. Go to File tab->Info and click “Forms Options”

4. Go to Versioning section and ensure the “Automatically upgrade existing forms” has been selected. Take a note of the next version number

5. To publish, go to File tab->Publish and click “Quick Publish” button (Accept the default path location)

Upload and activate

To upload a new/existing InfoPath template form, do the following:

6. Go to SharePoint Central Administration site

7. Under “General Application Settings”, click “Manage form templates”

8. Click “Upload form template” link

9. Browse and select the InfoPath template form that is located in the path you had publish in step 5, for upload. Accept the default settings and click Upload button

10. A successful upload will display the message below. Click OK

11. Check that the form has successfully been uploaded. Note that the version number of the form must be the last version number (e.g. 10.0.2) observed in step 4. The status field should display “Ready”NOTE: Skip step 12 & 13 if the uploaded form was an existing form.

12. If this is a NEW form, then select the uploaded form and select “Activate to a site collection”.

13. Select the destination site collection to activate the form.

  1. Go the destination site collection where the form was activated and check the “Form Template” library to check that the form has been successfully published, by viewing the last modified date.
  2. Notify the user that UAT is in progress, and ignore any test emails (if any).
  3. Test the form by submitting with test data to verify that the changes worked.

References:

 

AutoSPInstallerGUI

Overview

AutoSPInstallerGUI was originally a windows UI to create config files to automate deployment of SharePoint 2010 & 2013. AutoSPInstallerGUI was originally developed by Ivan and he published it to CodePlex in April 2015.

Since then NOTE that, AutoSPInstallerGUI is now depreciated. It has been replaced with the online version at  http://autospinstaller.com or http://autospinstaller.azurewebsites.net homepage

 

Getting started

  1. Read the AutoSPInstaller Guide
  2. Download and extract the zip file for the AutoSPInstaller PowerScript version here
  3. After step 1 and 2 has been done, at this point you want to begin configuring AutoSPInstaller via online by going to Load Default Template section of the farm config webpage and click “Begin with Template” button (**if you don’t have an existing config file). Follow the instruction to save and download the configuration as an XML file
  4. Follow the installation step section from the AutoSPInstaller Guide. In summary:
    • Drop the XML into the extracted \SP\AutoSPInstaller folder that was done in stp 2
    • Run AutoSPInstaller.bat on each farm

**If you already have a config file, then upload the XML file by clicking the Browse button from Load from my XML section

A Beginner’s Tutorial on Implementing IEnumerable Interface

This article discusses how to implement IEnumerable interface and using yield keyword.

Introduction

In this article we will discuss about the IEnumerable interface. We will discuss how IEnumerable interface facilitate the use of foreach statement to iterate through a set of data. We will then look how to implement our own collections that implement IEnumerable interface. The use of yield keyword and Enumerating generic collections will also be discussed in this article.

Background

Whenever we work with collection of objects, we might find ourselves in need to iterate the collection. The best way to iterate through a collection is by implementing the Iterator pattern. (refer: Understanding and Implementing the Iterator Pattern in C# and C++[^]). C# provides a very clean construct of foreach statement to iterate in a read only manner over a collection.

C# also provides us the possibility of using the same foreach construct and all the enumeration techniques on our custom collection objects by implementing the IEnumerable interface. So let us see how we can implement IEnumerable interface with our custom collection classes.

Using the code

Enumerating the Collection classes

Before starting the discussion let us see how we can use the Built-in classes and iterate over them. Lets start by looking into the ArrayList class that implements IEnumerable and see how we can have read only iteration over that using foreach statement.

// Let us first see how we can enumerate an object implementing IEnumerable
ArrayList list = new ArrayList();

list.Add("1");
list.Add(2);
list.Add("3");
list.Add('4');

foreach (object s in list)
{
    Console.WriteLine(s);
}

Enumerating the Generic Collection classes

The Arraylist class is a generalized class that let us keep a collection. We can also have a generic class in which we can provide the type along with the data. Iterating over generic collection classes is also possible because they implementIEnumerable<T> interface. Lets see how we can enumerate over a generic collection.

// Let us first see how we can enumerate an object implementing IEnumerable<T>
List<string> listOfStrings = new List<string>();

listOfStrings.Add("one");
listOfStrings.Add("two");
listOfStrings.Add("three");
listOfStrings.Add("four");

foreach (string s in listOfStrings)
{
    Console.WriteLine(s);
}

Now our objective is to have our own custom collection class and a generic collection class that should implement the IEnumerable and IEnumerable<T> interface respectively to provide the possibility of enumerating over them.

Understanding the yield keyword

Before jumping into the Implementation of these classes, we need to understand a very important keyword yield which actually facilitate the enumeration over collection. yield statement is used while returning a value from a function.

A normal method call like the one shown below will return only the first value no matter how many times it is called.

static int SimpleReturn()
{
    return 1;
    return 2;
    return 3;
}

static void Main(string[] args)
{
    // Lets see how simeple return works
    Console.WriteLine(SimpleReturn());
    Console.WriteLine(SimpleReturn());
    Console.WriteLine(SimpleReturn());
    Console.WriteLine(SimpleReturn());
}

The reason for this is that the normal return statement does not preserve the state of the function while returning. i.e. every call to this function is a new call and it will return the first value only.

Where as if I replace the return keyword by yield return then the function will become capable of saving its state while returning the value. i.e. when the function is called second time, it will continue the processing from where is has returned in the previous call.

static IEnumerable<int> YieldReturn()
{
    yield return 1;
    yield return 2;
    yield return 3;
}
static void Main(string[] args)
{
    // Lets see how yield return works
    foreach (int i in YieldReturn())
    {
        Console.WriteLine(i);
    }
}

When we run the above code it will return 1,2 and then 3. The only catch while using the yield return statement is that the function should return an IEnumerable and should be called from an iteration block i.e. foreach statement.

Implementing IEnumerable in our custom Collection class

Now in our custom collection classes, if we define a function that will iterate over all the elements in the collection and return then using the yield keyword, we will be able to get hold of all the elements in the the collection.

So let us define our own MyArrayList class and implement IEnumerable interface, which will force us to implement the GetEnumerator function. This function will iterate over the collection and do a yield return on all the elements.

class MyArrayList : IEnumerable
{
    object[] m_Items = null;
    int freeIndex = 0;

    public MyArrayList()
    {
        // For the sake of simplicity lets keep them as arrays
        // ideally it should be link list
        m_Items = new object[100];
    }

    public void Add(object item)
    {
        // Let us only worry about adding the item 
        m_Items[freeIndex] = item;
        freeIndex++;
    }

    // IEnumerable Member
    public IEnumerator GetEnumerator()
    {
        foreach (object o in m_Items)
        {
            // Lets check for end of list (its bad code since we used arrays)
            if(o == null)
            {
                break;
            }

            // Return the current element and then on next function call 
            // resume from next element rather than starting all over again;
            yield return o;
        }
    }
}

This class will now let us enumerate all the elements using a foreach stemement.

static void Main(string[] args)
{
    //Let us now go ahead and use our custom MyArrayList with IEnumerable implemented
    MyArrayList myList = new MyArrayList();

    myList.Add("1");
    myList.Add(2);
    myList.Add("3");
    myList.Add('4');

    foreach (object s in myList)
    {
        Console.WriteLine(s);
    }
}

Note: This class is neither complete not a very good implementation. The only purpose of the sample implementation is to demonstrate the implementation of IEnumerable interface.

Implementing IEnumerable<T> in our custom Generic Collection class

Let us now take this approach a little further and define a generic collection class capable of being enumerated. To do this we need to implement IEnumerable<T> interface.

class MyList<T> : IEnumerable<T>
{
    T[] m_Items = null;
    int freeIndex = 0;

    public MyList()
    {
        // For the sake of simplicity lets keep them as arrays
        // ideally it should be link list
        m_Items = new T[100];
    }

    public void Add(T item)
    {
        // Let us only worry about adding the item 
        m_Items[freeIndex] = item;
        freeIndex++;
    }

    #region IEnumerable<T> Members

    public IEnumerator<T> GetEnumerator()
    {
        foreach (T t in m_Items)
        {
            // Lets check for end of list (its bad code since we used arrays)
            if (t == null) // this wont work is T is not a nullable type
            {
                break;
            }

            // Return the current element and then on next function call 
            // resume from next element rather than starting all over again;
            yield return t;
        }
    }

    #endregion

    #region IEnumerable Members

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        // Lets call the generic version here
        return this.GetEnumerator();
    }

    #endregion
}

This class will now let us enumrate all the elements using a foreach stemement.

static void Main(string[] args)
{
    // Let us first see how we can enumerate an custom MyList<t> class implementing IEnumerable<T>
    MyList<string> myListOfStrings = new MyList<string>();

    myListOfStrings.Add("one");
    myListOfStrings.Add("two");
    myListOfStrings.Add("three");
    myListOfStrings.Add("four");

    foreach (string s in myListOfStrings)
    {
        Console.WriteLine(s);
    }
}
</t>

So now we have a collection class and a generic collectio class that implement IEnumerable and IEnumerable<T> respectively. Althogh These class is neither complete not a very good implementation but they do serve the purpose of the article i.e. to demonstrate the implementation of IEnumerable interface.

Point of interest

What we have tried to do in this article is see how can we implement the IEnumerable andIEnumberable<T> interface. We have looked into the significance of yield keyword. This stuff is known to most experienced C# programmers but the beginners might find it useful. I hope this has been informative.

 

Reference

 

Customising SharePoint 2013 Search Result Page

How search works in a few words
In case you’re not so familiar with how search works, here’s a high level representation that might be useful for this series.

searchindex

  1. Content is stored in lists and libraries. Site columns are used to store values, or in other words information, about each item in a list or library.
  2. When lists and libraries are crawled, site columns and the site column values are added to the search index.
  3. In the search index, site columns are “transformed” into managed properties. Site column values are “transformed” into managed property values
  4. On a search page, a user enters a query in a Search Box Web Part. The query is sent to the search index.
  5. Search results are sent from the search index to a search results page, and displayed in a Search Results Web Part.  The Search Results Web Part uses display templates that specify which managed property values should be displayed.

 

Overview