This blog is dedicated to new technologies of Microsoft, including LINQ, sharepoint, ADO.NET entity framework and lot more
add
Wednesday, February 25, 2009
How to access SharePoint User Profile from C# code
We all know sharepoint user profile stores users information. Sometimes we use out of box features to update these profile values like mysite stc but many times we come across the situation where we need to access uer profile from code, update the properties and save the profile.
In this post, I will tell you the step by step way to access user profile and to access/update the property field.
Step 1: Refer the following dlls in the code:
using Microsoft.SharePoint;
using Microsoft.SharePoint.Administration;
using Microsoft.Office.Server;
using Microsoft.Office.Server.UserProfiles;
Step 2: Create the instance of SPSite object:
using (SPSite ospSite=new SPSite("http://servername:portname")
{}
where http://servername:portname is your sharepoint application url.
Here we have used using to create the instance of SPSite since 'using' automatically disposes the object when the block gets finished.
Withing 'using' block , add the following codes:
Step 3: Create the instance of servercontext object:
ServerContext ospServerContext = ServerContext.GetContext(ospSite);
Step 4: Create the instance of userporfile object propertycollection object:
UserProfileManager ospUserProfileManager = new UserProfileManager(ospServerContext);
UserProfile ospUserProfile = ospUserProfileManager.GetUserProfile(UniqueId);
Microsoft.Office.Server.UserProfiles.PropertyCollection propColl = ospUserProfile.ProfileManager.PropertiesWithSection;
here uniqueid is the id by which each profile is recognized individually. Eacn user profile has a uniqueId many ny 5-2-1 id if it is an AD account or GUID.
Step 5: Check whether the USerprofile object is null or not
if (ospUserProfile != null && propColl != null)
{}
Step 6: Iterate thorugh all the proerties in property collection:
foreach (Property prop in propColl)
{}
In the for loop you can get the property name and value like this:
To get property name: prop.Name
To get property value: ospUserProfile[prop.Name].Value
To set a value to a proerty : ospUserProfile[prop.Name].Value ="SOME VALUE";
To save the user profile after updation: ospUserProfile.Commit();
This will get the userporfile of a user and update the profile.
The whole code is as follows:
using System;
using System.Collections.Generic;
using System.Text;
using System.Configuration;
using System.Data.SqlClient;
using Microsoft.SharePoint;
using Microsoft.SharePoint.Administration;
using Microsoft.Office.Server;
using System.IO;
using System.Data;
using Microsoft.Office.Server.UserProfiles;
namespace Program1
{
public static void Main(string args[])
{
using (SPSite ospSite = new SPSite(webApp))
{
try
{
ServerContext ospServerContext = ServerContext.GetContext(ospSite);
UserProfileManager ospUserProfileManager = new UserProfileManager(ospServerContext);
UserProfile ospUserProfile = ospUserProfileManager.GetUserProfile(uniqueId);
Microsoft.Office.Server.UserProfiles.PropertyCollection propColl = ospUserProfile.ProfileManager.PropertiesWithSection;
if (ospUserProfile != null && propColl != null)
{
foreach (Property prop in propColl)
{
Console.WriteLine("property Name : " + prop.Name);
Console.WriteLine("proerpty Value : " + ospUserProfile[prop.Name].Value);
//If updation is required
ospUserProfile[prop.Name].Value="SOME VALUE";
}
ospUserProfile.Commit();
}
}
catch(Exception ex){
Console.WriteLine(ex.Message);
}
}
}
}
Monday, February 23, 2009
How to get old index value of dropdown when index change occures
In the code block, one can get the current index value of dropdown but what if old value is required. that is value before selecting the new index.
The simple solution is to use viewstate to hold the old value:
Suppose we have a dropdown 'dropdown1' with some item values.
Steps:
1.In code behind, we defined a public property IndexVal that store and fetch dropdown index value from a viewstate variable:
public int IndexVal {
get
{
return Convert.ToInt32(ViewState["OldSelectedIndex"]);
}
set {
ViewState["OldSelectedIndex"] = DropDownList1.SelectedIndex;
}
}
2. When the page loads for 1st time, set the viewstate value to dropdown index value
if (!IsPostBack)
IndexVal = DropDownList1.SelectedIndex;
3. When SelectedIndexChanged event fires, we can get the old index value from viewstate and new index value from the dropdown itself.
Then set the viewstate with new value.
protected void DropDownList1_SelectedIndexChanged(object sender, EventArgs e)
{
int oldValue IndexVal;
int newValue DropDownList1.SelectedIndex;
IndexVal = DropDownList1.SelectedIndex;
}
Varun Sharma
Saturday, February 21, 2009
Javascript call from Master page and content Page -Part I
C#
protected void Page_Load(object sender, EventArgs e)
{
string someScript = "";
someScript = "";
Page.ClientScript.RegisterStartupScript(this.GetType(), "onload", someScript);
}
VB.NET
Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
Dim someScript As String = ""
someScript = ""
Page.ClientScript.RegisterStartupScript(Me.GetType(), "onload", someScript)
End Sub
The Page.ClientScript.RegisterStartupScript() allows you to emit client-side script blocks from code behind. More info can be found over here http://msdn.microsoft.com/en-us/library/system.web.ui.clientscriptmanager.registerstartupscript.aspx
Tuesday, February 10, 2009
Using Lambard Expression
Lambda Expressions are based on functional calculus—Lambda Calculus—from the 1930s, and Lambda Expressions exist in other languages.Think of Lambda Expressions as brief inline functions whose concise nature is an ideal fit for LINQ.
Lambda Expressions are written with a left side, the => symbol, and a right side, as in(x,y) => x + y;.
The left side represents the input arguments and the right side is theexpression to be evaluated.
For example(x,y) => x + y;is read x and y goes to—or as I read it gosinta—the function x + y.
Implicit in the expression is the return result of x + y.
The input argument or arguments can be inferred and generated by the compiler, called implicit arguments, or expressed explicitly by you.
The preceding Lambda Expression can also be rewritten as(int x, int y) => x + y;
class Program{
static void Main(string[] args) {
Func<int, int, int> add = (int x, int y) => x + y; Console.WriteLine(add(3, 4)); Console.ReadLine(); }}[/code]
You can begin exploring how Lamba Expressions support LINQ queries by seeing howLambda Expressions are used in extension methods such as Select
Using Select<T> with Lambda Expressions
Check the following example:[code] var numbers = new int[]{1,2,3,4,5,6}; foreach(var result in numbers.Select(n => n)) Console.WriteLine(result);[/code]
Here we are executing the SELECT * behavior of SQL queries by initializing the Select extension method with n => n. n => n means that n is the input and you want to return n.
Using Where<T> with Lambda Expressions
The Where
[code] var words = new string[]{"Drop", "Dead", "Fred"}; IEnumerable<string> hasDAndE = words.Where(s => s.Contains('D') && s.Contains('e')); foreach(string s in hasDAndE) Console.WriteLine(s);[/code]
Using OrderBy<T> with Lambda Expressions
OrderBy
[code]
var numbers = new int[] {1, 3, 5, 7, 9, 2, 4, 6, 8, 10 };IEnumerable<int> ordered = numbers.OrderBy(n=>n); foreach(var num in ordered) Console.WriteLine(num);[/code]
Using Conversion Types
The new version of .NET has conversion operators ToArray, OfType, Cast, AsEnumerable, ToList, ToDictionary, and ToLookup. We will discuss each one by one:
ToArray : Arrays are fast but not very convenient. It is tedious to write array management code when collections like List
OfType : The conversion operator OfType
var numbers = new object[]{1, "two", null, "3", 4};
foreach(var anInt in numbers.OfType
Console.WriteLine(anInt);
Cast: To receive an exception if elements of the source type cannot be converted to the target type, use the Cast
AsEnumerable : Many types implement IEnumerable.AsEnumerable Forces an Object That Implements IEnumerable to Use theBehaviors of the IEnumerable Interface.
ToList: The ToList conversion operator forces an immediate query evaluation and stores the results in a List
ToDictionary:A dictionary is a collection of name and value pairs. ToDictionary converts anIEnumerable
ToLookup:ToLookup converts an IEnumerable
Summary:
Compound type initialization makes it easier to initialize arrays and lists and is an essential capability for initializing anonymous types. Conversion operators take some of the tedium out of converting between convenient types and other types. More important, this chapter demonstrates the classic onion layering of complexity in .NET that makes it possible to do a lot of work with relatively few lines of code.
Introduction to LINQ - Part 2 - Anonymous types
In this article, we will discuss Anonymous types
First thing about Anonymous types is that it uses the keyword var. The var introduced with .NET 3.5 indicates an anonymous types. A developer who has worked in VB6, may say that var was there in VB6 also. So what's the difference?
Anonymous types defined with var are not similar to VB variant. So what is var?
The var keyword signals the compiler to emit a strong type based on the value of the operator on the right side.
A simple anonymous type begines with a var keyword, the assignment operator and a not null initial value.
var title="Tutorial on LINQ";
here the data type of var will be set based on the data type of the right hand side. So the datatype of title will be string.
As you will notice that I have mentioned that we need to assigna 'not null initial value'.
Anonymous types must always have an initial assignment and it can’t be nullbecause the type is inferred and fixed to the initializer.
SummaryAnonymous types are strong typeswhere the compiler does the work of figuring out the actual type and writing the classimplementation, if the anonymous type is a composite type.
Introduction to LINQ - Part 1
Language Integrated Query (LINQ) is a methodology that simplifies and unifies the implementation of any kind of data access.
- provide a solution for the problem of object-relational mapping
- simplify the interaction between objects and data sources
LINQ eventually evolved into a general-purpose language-integrated querying toolset. This toolset can be used to access data coming from in-memory objects (LINQ to Objects), databases (LINQ to SQL), XMLdocuments (LINQ to XML), a file-system, or any other source.
Advantage of LINQ
Developers can use LINQ with any data source.
They can express efficient query behavior in their programming language of choice, optionally transform/shape data query results into whatever format they want, and then easily manipulate the results.
LINQ-enabled languages can provide full type-safety and compile-time checking of query expressions, and development tools can provide full intellisense, debugging, and rich refactoring support when writing LINQ code.LINQ supports a very rich extensibility model that facilitates the creation of ery efficient domain-specific operators for data sources.