Sharepoint 2010 - Business Intelligence (BI)

Setup Load balance in Sharepoint 2010 farm

How to setup Load balance in Sharepoint 2010 farm ?

Answer :

Source 1:
http://www.sharepointboost.com/blog/how-to-setup-load-balance-in-sharepoint-2010-farm/

Source 2:
This contains a lot of screenshots
http://aarohblah.blogspot.in/2013/01/how-to-setting-up-nlb-in-sharepoint.html

Grid & DataTable Tips

The below is the sample to show a alert message in the ASP.Net Grid View

int intTotalColumns = grdGRIDName.Rows[0].Cells.Count;

grdGRIDName.Rows[0].Cells.Clear();

grdGRIDName.Rows[0].Cells.Add(new TableCell());

grdGRIDName.Rows[0].Cells[0].ColumnSpan = intTotalColumns;

grdGRIDName.Rows[0].Cells[0].Text = "No records are found!";

grdGRIDName.Rows[0].Cells[0].Style.Add("text-align", "Center");

grdGRIDName.Rows[0].Cells[0].Style.Add("color", "red");

The below is the sample to filter the Data in a DataTable using column name and value.

DataTable users = (DataTable)Session[DB_USERS];

var items = users.AsEnumerable().Where(p => p.Field<string>("FIELD_NAME").Contains(value));

Modernizr - A Javascript library

What Is Modernizr

It is a JavaScript library that detects HTML5 and CSS3 features in the user’s browser.

Why use Modernizr?

Taking advantage of cool new web technologies is great fun, until you have to support browsers that lag behind. Modernizr makes it easy for you to write conditional JavaScript and CSS to handle each situation, whether a browser supports a feature or not. It’s perfect for doing progressive enhancement easily.

How it works

Modernizr runs quickly on page load to detect features; it then creates a JavaScript object with the results, and adds classes to the html element for you to key your CSS on. Modernizr supports dozens of tests, and optionally includes YepNope.js for conditional loading of external .js and .css resources.

http://www.alistapart.com/articles/taking-advantage-of-html5-and-css3-with-modernizr/

Source : Internet

Firebug Tutorials

 Nice guide for Web Developers

http://www.w3resource.com/web-development-tools/firebug-tutorials.php

Asyncronous Deligate with Callback method & BeginInvoke

BeginInvoke method : Executes the specified delegate asynchronously with the specified arguments, on the thread that the control's underlying handle was created on.

 

using System;

using System.Threading;

using System.Runtime.Remoting;

using System.Runtime.Remoting.Messaging;

namespace AsyncInvoke

{

    // Create an asynchronous delegate.

    public delegate bool FactorizingAsyncDelegate(

             int factorizableNum,

             ref int primefactor1,

             ref int primefactor2

    );

    // Create a class that factorizers the number.

    public class PrimeFactorizer

    {

        public bool Factorize(

                     int factorizableNum,

                     ref int primefactor1,

                     ref int primefactor2)

        {

            primefactor1 = 1;

            primefactor2 = factorizableNum;

            // Factorize using a low-tech approach.

            for (int i = 2; i < factorizableNum; i++)

            {

                if (0 == (factorizableNum % i))

                {

                    primefactor1 = i;

                    primefactor2 = factorizableNum / i;

                    break;

                }

            }

            if (1 == primefactor1)

                return false;

            else

                return true;

        }

    }

    // Class that receives a callback when the results are available.

    public class ProcessFactorizedNumber

    {

        private int _ulNumber;

        public ProcessFactorizedNumber(int number)

        {

            _ulNumber = number;

        }

        // Note that the qualifier is one-way.

        [OneWayAttribute()]

        public void FactorizedResults(IAsyncResult ar)

        {

            int factor1 = 0, factor2 = 0;

            // Extract the delegate from the AsyncResult. 

            FactorizingAsyncDelegate fd = (FactorizingAsyncDelegate)((AsyncResult)ar).AsyncDelegate;

            // Obtain the result.

            fd.EndInvoke(ref factor1, ref factor2, ar);

            // Output the results.

            Console.WriteLine("On CallBack: Factors of {0} : {1} {2}",

                          _ulNumber, factor1, factor2);

        }

    }

    // Class that shows variations of using Asynchronous

    public class Simple

    {

        // The following demonstrates the Asynchronous Pattern using a callback.

        public void FactorizeNumber1()

        {

            // The following is the client code.

            PrimeFactorizer pf = new PrimeFactorizer();

            FactorizingAsyncDelegate fd = new FactorizingAsyncDelegate(pf.Factorize);

            int factorizableNum = 1000589023, temp = 0;

            // Create an instance of the class that is going

            // to be called when the call completes.

            ProcessFactorizedNumber fc = new ProcessFactorizedNumber(factorizableNum);

            // Define the AsyncCallback delegate.

            AsyncCallback cb = new AsyncCallback(fc.FactorizedResults);

            // You can use any object as the state object.

            Object state = new Object();

            // Asynchronously invoke the Factorize method on pf.

            IAsyncResult ar = fd.BeginInvoke(

                                 factorizableNum,

                                 ref temp,

                                 ref temp,

                                 cb,

                                 state);

            //

            // Do some other useful work.

            //. . .

        }

        // The following demonstrates the Asynchronous Pattern using a BeginInvoke, followed by waiting with a time-out.

        public void FactorizeNumber2()

        {

            // The following is the client code.

            PrimeFactorizer pf = new PrimeFactorizer();

            FactorizingAsyncDelegate fd = new FactorizingAsyncDelegate(pf.Factorize);

            int factorizableNum = 1000589023, temp = 0;

           // Asynchronously invoke the Factorize method on pf.

            IAsyncResult ar = fd.BeginInvoke(

                              factorizableNum,

                              ref temp,

                              ref temp,

                              null,

                              null);

            ar.AsyncWaitHandle.WaitOne(10000, false);

           

            if ( ar.IsCompleted )

            {

                int factor1 = 0, factor2 = 0;

                // Obtain the result.

                fd.EndInvoke(ref factor1, ref factor2, ar);

                // Output the results.

                Console.WriteLine("Sequential : Factors of {0} : {1} {2}", factorizableNum, factor1, factor2);

            }

        }

        public static void Main(String[] args)

        {

            Simple simple = new Simple();

            //simple.FactorizeNumber1();

            simple.FactorizeNumber2();

            Console.ReadLine();

        }

    }

}