Sharvan Dhaka

How to convert a string to a byte array and convert a byte array to a string c# asp.net

2006-10-15T17:42:00-05:00:00

Convert a string to a byte array

string myString = "a test string";
byte[] myByteArray = new byte[myString.Length];
int i = 0;
foreach(char c in InStr.ToCharArray())
{
myByteArray [i] = (byte)c;
i++;
}

Convert a byte array to a string

System.Text.Encoding enc = System.Text.Encoding.ASCII;
byte[] myByteArray = enc.GetBytes("a text string);
string myString = enc.GetString(myByteArray );

Serialize & Deserialize c# asp.net

2006-10-15T17:43:00-05:00:00

Serialize (convert an object instance to an XML document):

// Assuming obj is an instance of an object
XmlSerializer ser = new XmlSerializer(obj.GetType());
System.Text.StringBuilder sb = new System.Text.StringBuilder();
System.IO.StringWriter writer = new System.IO.StringWriter(sb);
ser.Serialize(writer, obj);
XmlDocument doc = new XmlDocument();
doc.LoadXml(sb.ToString());

Deserialize (convert an XML document into an object instance):

//Assuming doc is an XML document containing a serialized object and objType is a System.Type set to the type of the object.
XmlNodeReader reader = new XmlNodeReader(doc.DocumentElement);
XmlSerializer ser = new XmlSerializer(objType);
object obj = ser.Deserialize(reader);
// Then you just need to cast obj into whatever type it is eg:
MyClass myObj = (MyClass)obj;

How to get the HTML name attribute of ASP.Net Control c# as.net

2006-10-15T17:49:00-05:00:00

//Function to get the HTML name of the server control from the Client Id

// Parameters:

// clientId - Control.ClientId

// serverId - Control.id

private string GetHTMLNameById(string clientId, string serverId)

{

int pos = serverId.IndexOf('_');

string HTMLName = "";

if(pos >= 0)

{

pos = clientId.IndexOf(serverId);

HTMLName = clientId.Remove(pos, serverId.Length);

HTMLName = HTMLName.Replace('_', '$');

HTMLName += serverId;

}

else

HTMLName = clientId.Replace('_', '$');

return HTMLName;

}

Force a page to download a file c# asp.net

2006-10-15T17:56:00-05:00:00

Read Response of a web request in a byte Array with C# Asp.net

2006-10-15T17:57:00-05:00:00

this code snippet read the respone fo a web request through binary reader

private byte[] getByte(string URL)
{
HttpWebRequest wrGETURL = (HttpWebRequest)WebRequest.Create(URL);
System.Net.HttpWebResponse webresponse = (HttpWebResponse)wrGETURL.GetResponse();
string ct = webresponse.ContentType;
Stream objStream = webresponse.GetResponseStream();
BinaryReader breader = new BinaryReader(objStream);
byte[] buffer = breader .ReadBytes((int)webresponse.ContentLength);
return buffer;
}

Perform a Case-IN sensitive Search in .NET Using XPath

2006-10-15T18:37:00-05:00:00

The following code shows to how to perform a case-sensitive search in .NET using XPath.

and contains is used as like operator in xpath.

XML File: <?xml version="1.0" encoding="utf-8"?> <USERS> <USER> <NAME>sharvan</NAME> <PASSWORD>dhaka</PASSWORD> </USER> </USERS> Code File:<%@ Import Namespace="System.Data" %> <%@ Import Namespace="System.Xml" %> <%@ Page Language="C#" Debug="true" %> <SCRIPT runat="server"> void Page_Load(object sender, System.EventArgs e){ if(!Page.IsPostBack) { XmlDocument xmlDoc = new XmlDocument(); xmlDoc.Load(Server.MapPath("user.xml")); XmlNodeList nodeList = xmlDoc.SelectNodes("Users/User[contains(translate(Name,'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz'),translate('Sharvan', 'ABCDEFGHIJKLMNOPQRSTUVWXYZ', 'abcdefghijklmnopqrstuvwxyz'))]"); Response.Write(nodeList.Count.ToString()); } }1. Case of matching the beginning of some text. miCommunities% LIKE where wildcard is at end Corresponding XPath expression predicate, [ starts-with( Name , 'miCommunities')]

2. Case of matching within some text.
%miCommunities% LIKE where there is a wildcard at both ends

 Corresponding XPath expression predicate,
[ contains( Name , 'miCommunities')]

Search in Xml File through XPATH

2006-10-15T18:29:00-05:00:00

Using xpath you can find elements in a xml file.
There is more to XML then just a way of describing data. Over the years, a number of XML-based standards have emerged. Among the most fundamental ones are XSD (XML Schema Definition), XPath Query, XSLT (Extensible Stylesheet Language Transformation), SOAP (Simple Object Access Protocol), and WSDL (Web Services Description Language). All build on top of the XML syntax.

The Sample XML Document for the Series of Articles

This series of articles assumes that you are familiar with XML itself. The sample XML document used throughout the articles is a list of employees, which must have for each employee the first name, last name, phone number, and e-mail address, and also can provide the job title and a Web address.

<?xml version="1.0" encoding="utf-8"?>
<Employees>
   <Employee ID="1">
      <FirstName>Klaus</FirstName>
      <LastName>Salchner</LastName>
      <PhoneNumber>410-727-5112</PhoneNumber>
      <EmailAddress>klaus_salchner@hotmail.com</EmailAddress>
      <WebAddress>http://www.enterprise-minds.com</WebAddress>
      <JobTitle>Sr. Enterprise Architect</JobTitle>
   </Employee>
   <Employee ID="2">
      <FirstName>Peter</FirstName>
      <LastName>Pan</LastName>
      <PhoneNumber>604-111-1111</PhoneNumber>
      <EmailAddress>peter.pan@fiction.com</EmailAddress>
      <JobTitle>Sr. Developer</JobTitle>
   </Employee>
</Employees>

A quick note to editing XML documents in Visual Studio .NET 2003: When you open up a XML document, you see at the bottom of the window an "XML" and "Data" tab. The XML tab allows you to edit the XML. It also formats the XML nicely for you with indentions and all that. The Data tab parses the XML and shows a data grid. You can add new nodes by adding new rows to the data grid and entering corresponding values. Using the example data, this would be new Employees.

You also can show a document outline through the "View | Other Windows | Document Outline" menu, which shows you a hierarchy of all the nodes in the XML document. Selecting a node in the "document outline" will automatically select it in the XML document too.

The Fundamentals of XPath Queries

Once you have data in XML format, you will want to be able to navigate and search its nodes. You don't want to have to parse the whole XML document to find that there are two Employee nodes. That would be terribly inefficient. You want to apply an XPath query, which then gives you all the matching nodes. To find all Employee nodes, you would run the following XPath query:

//Employee

If you use the table above, this query will return two nodes, each representing an employee. This makes it very easy to find matching nodes and walk through the result set.

XPath is a standard (XPath 1.0) and can be found at http://www.w3.org/TR/xpath/. The working draft of XPath 2.0 can be found at http://www.w3.org/TR/2001/WD-xpath20-20011220/. Let's look more closely at some of the most common XPath operators.

Operator	Description
/ (child operator)	Refers to the root of the XML document when used at the beginning of the XPath expression. The child operator is used to specify the next child to select. The expression "/Employees/Employee", for, example says, start at the root of the XML document, select the Employees node and then select all the Employee child nodes within the Employees node. This will return the two Employee nodes in the sample XML document.
// (recursive descendant operator)	The recursive descendant operator indicates to include all descendant nodes in the search. Using the operator at the beginning of the XPath expression means you start from the root of the XML document. The expression "//LastName" starts at the root and finds any LastName node. The expression "/Employees//LastName" selects the Employees node and then, within that node, finds any LastName node. It yields the same result, but searches in a different way.
* (wildcard operator)	The wildcard operator finds any node. The expression "/" finds any node under the root, which in our case is Employees. The expression "/Employees/" means find any node under the Employees node, which in our case results with the two Employee nodes. Now what is the difference between the "/Employees" and "/Employees/" expression? The first expression returns the Employees node but the second node finds any node under the Employees node, meaning it returns the two Employee nodes. The expression "//" means to select any node including descendant nodes, so it will effectively list every single node in the complete XML document.
. (current context operator)	The current context operator refers to the current context. For example, you have written some code that selected the Employees node and then from there you run the expression "./Employee", which means it starts out from the currently selected Employees node and then selects the two Employee nodes. The expression "Employee" would yield the same result because it also starts out from the current context. Similar the expression ".//LastName" means start from the current context, the Employees node, and find any LastName node including any descendant nodes.
.. (parent operator)	The parent operator refers to the parent. For example, the expression "/Employees/Employee/.." returns the Employees node because you navigate down to the Employee nodes and then tell it to return its parent, which is the Employees node.
@ (attribute operator)	The attribute operator refers to an attribute instead of an element. The expression "/Employees//@ID" selects any ID attribute it finds under the Employees node. Now, keep in mind that the XPath query always returns the selected node. In the case of an attribute, the node below it is its value. So, the expression really two returns nodes, each with the value of each selected attribute. Furthermore, you can use the wildcard operator with attributes, so "/Employees//@*" means any attribute underneath the Employees node.
[ ] (filter operator)	You can apply a filter operator to filter the selected nodes. This works with attributes and with elements. The expression "/Employees/Employee[@ID=1]" returns any Employee node under the Employees node that has an ID attribute with the value one. You also can apply filters that just say that an attribute or element with that name needs to be present. For example, the expression "/Employees/Employee[WebAddress]" returns Employee nodes that have a WebAddress node as child. The expression "/Employees/Employee[FirstName='Klaus']" returns the Employee node that has a FirstName node with the value Klaus.
text() function	The "text()" function refers to the text of the selected node or attribute. The expression "//Employee//text()" does not list all the descendant nodes of all Employee nodes but rather the value for each descendant node. The expression "//Employee/FirstName[text()='Klaus']" lists all FirstName nodes which have a value of Klaus.
[ ] (collection operator)	When your expression returns more then one node with the same name, you have a collection returned. The expression "//Employee" returns two Employee nodes, which is nothing more than a collection of Employee nodes. You can apply a collection operator and specify which item from the collection you want to select. Keep in mind that the index starts at one. The expression "//Employee[2]" returns the second Employee node. The order of the selected nodes is the same order as in the XML document. You can use the collection operator in any blend, such as "//Employee[1]/LastName", which selects the first Employee node and then from there the LastName node.
( ) (group operator)	The collection operator can sometimes have some odd side effects. Assume you have two Employee nodes and each has two Job nodes. What does the expression "//Employee/Job[1]" return? It returns the first Job node for each selected Employee node. But, using the group operator allows you to apply explicit precedence to selections. The expression "(//Employee/Job)[4]" first selects all Job nodes for all Employee nodes and from that collection it returns the fourth node. The group operator can only be applied to the top level expression; for example, "//Employees/(Employee/FirstName)" is invalid.
comment() function	Returns a comment node. The expression "//comment()" returns any comment node in the XML. The expression "/Employees/comment()" returns the comment nodes under the Employees node.
node() function	XML documents consist of elements, attributes, and their values, each being a node. So, in XPath expressions you can use a node() function instead of a node name or the text() function. It is a generic way to address a node. The expressions "//Employee/JobTitle/node()" and "//Employee/JobTitle/text()" return the same result, the value of both JobTitle nodes. But, "//Employee//node()" will not just return the elements but also the values of each element, because both are nodes.
\| (union or set operator)	Returns the union of one or more location paths. The expression "//LastName \| //FirstName" returns all the LastName and FirstName nodes. It preserves the order of the elements as in the XML and does not return any duplicates. The two location paths "//Employee[@ID=1] \| //Employee[FirstName='Klaus']" return the same nodes but the union of these two returns just the one unique node.

The table does not represent a complete list, but it lists the most basic operators and functions. As you can see from the samples, this already enables you to build fairly complex XPath queries. Keep in mind that the precedence of the operators is the group operator, followed by the filter operator, the child operator, and recursive descendant operator followed by the rest.

Let's spend a few minutes on a few basic terms commonly used. You have seen that I use the term XPath expression and XPath query interchangeably. An XPath expression is also called a "Location Path," because you are selecting one or more locations in your XML document and, to be able to do so, you specify the path to it. The expression "//Employees/Employee" is a path to certain locations in your XML document you want to select. It is the path to these locations. The "Location Path" consists of "Location Steps."

Your path has two steps: First, go to the Employees node and then, from there, go to all the Employee nodes. Each "Location Step" consists of an axis, a node-test, and a predicate or filter. The axis defines the relationship between your current location and the next location you specify. When no location is specified (see table below), child is assumed. The node-test is the node you want to select. You provide the name of the node or the wildcard operator for any node. The predicate or filter is any filter you apply by using the filter operator. The expression //child::Employees/child::Employee" is the same as "//Employees/Employee". Let's look closer at some of the most common axes:

Axes	Description
ancestor::	This returns all ancestors of the selected node. The expression "/Employees/Employee/JobTitle/ancestor::*" selects the JobTitle of each Employee node and then returns all its ancestors up to the root, so it returns the Employee node with the ID one, the Employee node with the ID two, and the Employees node itself. This makes it easy to find all ancestors of your nodes. But, you also can look for a specific ancestor; for example, with the expression "//JobTitle[ancestor::Employee/@ID=1]", you select all JobTitle nodes that have an ancestor node Employee with an ID attribute of the value one.
child::	This axis is the default if none is specified and has the same result as the child operator. For example, the expression "/child::Employees/child::Employee" selects all the Employee nodes in the Employees node.
self::	This has the same result as the current context operator. The expression "///self::JobTitle" first selects all nodes in the XML document and then refers to the current context and from there selects only the nodes of the type JobTitle. The expression "///./JobTitle" returns the same result using the current context operator.
ancestor-or-self::	Same as the ancestor axis, but it includes the current context. The expression "//JobTitle/ancestor-or-self::" lists both Employee nodes, both JobTitle nodes, and the Employees node. But, on the other hand, the expression "//JobTitle/ancestor::" does not return the two JobTitle nodes.
attribute::	The attribute axis returns the same as the attribute operator; it walks the attributes instead of the elements. The expression "//attribute::" as well as "//@" return all the attributes in your XML document.
descendant::	The descendant operator returns the same as the recursive descendant operator. It returns all descendant nodes. The expression "//Employee/descendant::" as well as "//Employee//" return all descendant nodes under the two Employee nodes.
descendant-or-self::	Same as the descendant axis but it includes the current context. So, the expression "//Employee/descendant-or-self::" lists both Employee nodes, including all its descendant nodes. But, on the other hand, the expression "//Employee/descendant::" does not return the two Employee nodes.
following::	Selects all the nodes following the current context node, which includes all siblings (nodes at the same hierarchy level) and its children but not their descendants. The expression "//Employee[@ID=1]/following::*" selects the Employee node with the attribute ID value of one and then returns all its following Employee nodes, in our case only the one with the attribute ID value of two, and its children, but not the descendants of the children.
following-sibling::	Returns the same as the following axis but includes only siblings and no children and not their descendants. So, the expression "//Employee[@ID=1]/following-sibling::*" returns only the Employee node with the attribute ID value of two.
preceding::	Selects all the nodes preceding the current context, which includes all siblings (nodes at the same hierarchy level), and its children but not its descendants. The expression "//Employee[@ID=2]/preceding::*" selects the Employee node with the attribute ID value of two and then returns all its preceding Employee nodes—in our case, only the one with the attribute ID value of one, and its children but not the descendants of the children.
preceding-sibling::	Returns the same as the preceding axis but includes only siblings and no children and not its descendants. So, the expression "//Employee[@ID=2]/preceding-sibling::*" returns only the Employee node with the attribute ID value of one.

The axes give you more control over which nodes you want to select. It makes it easy to find ancestors, descendants, following, and preceding nodes. Unfortunately, you cannot not run XPath queries against an XML document from within the Visual Studio .NET 2003 IDE. The overall support of XPath is rather weak in Visual Studio.

You can, however, use commercial tools such as XML Spy from Altova (http://www.altova.com), Stylus Studio from Sonic Software (http://www.stylusstudio.com), or as I use a simple freeware tool called "Visual XPath" (http://weblogs.asp.net/nleghari/articles/27951.aspx). It is very useful to use such tools so you can experiment with XPath and easily create the right XPath query you need plus visually verify that you got the expected result. Here are a few more examples to study:

Sample 1

/descendant::JobTitle[ancestor::Employee/@ID=2]

Selects all descendant JobTitle nodes that have as an ancestor an Employee node with the attribute ID value of two. The result will be as follows:

<JobTitle>
   Sr. Developer
</JobTitle>

Sample 2

//Employee[WebAddress and LastName='Salchner']/attribute::ID

Selects all descendant Employee nodes that have a WebAddress child node and a LastName child node with the value Salchner. From the result, it selects the ID attribute, which returns the values of the selected attributes. The result returns 1, the value of the selected ID attribute.

Sample 3

//JobTitle[ancestor::*/@ID=1]

Selects all descendant JobTitle nodes that have any ancestor node with an attribute ID value of one. The result is as follows:

<JobTitle>
   Sr. Enterprise Architect
</JobTitle>

Understanding the base operators, functions, and axes allows you to build very powerful XPath queries and easily select the XML elements, attributes, or nodes you require. In your filter, you can use a number of boolean and comparison expressions as well as string functions. Here is a list of the most common ones:

Expression or Function	Description
and (logical and)	Allows you to have two or more logical 'and' conditions in your filter. For example, the expression "//Employee[FirstName='Klaus' and LastName='Salchner']" checks for both the FirstName and LastName.
or (logical or)	Allows you to have two or more logical 'or' conditions in your filter. The expression "//Employee[FirstName='Klaus' or FirstName='Peter']" checks for nodes that have as FirstName either Klaus or Peter.
= (equal operator)	For example, "//FirstName[.='Klaus']".
!= (unequal operator)	For example, "//FirstName[.!='Klaus']".
not() (not operator)	For example, "//Employee[not(FirstName='Klaus')]".
"<=" or "<=" (less then equal operator)	For example, "//Employee[@ID<=1]".
"<" or "<" (less then operator)	For example, "//Employee[@ID<2]".
">=" or ">=" (greater equal operator)	For example, "//Employee[@ID>=2]".
">" or ">" (greater operator)	For example, "//Employee[@ID>2]".
position()	Returns the position or index relative to all the selected nodes. The expression "//Employee[position()=1]" returns the first Employee node.
last()	Returns the position or index of the last of all selected nodes. The expression "//Employee[position()=last()]" returns the last Employee node.
concat()	Concatenates two strings together. You can specify two string literals or actual node names. The following expression, //Employee[concat(FirstName,LastName)=concat('Klaus','Salchner')], concatenates the FirstName and LastName together and compares them to the concatenated string literals 'Klaus' and 'Salchner'. All matching nodes are returned.
contains()	Checks whether the first string contains the second string. You can specify node names or string literals. The following expression, "//Employee[contains(FirstName,'Kl')]", returns all nodes containing the string 'Kl' in the FirstName node.
starts-with()	Checks whether the first string starts with the second string. You can specify node names or string literals. The following expression, "//Employee[starts-with(FirstName,'Kl')]", returns all nodes starting with the string 'Kl' in the FirstName node.
substring-after()	Checks whether the first string contains the second string and returns the remaining string after the first occurrence. The expression "//Employee[substring-after(FirstName,'Kl')='aus']" first looks whether the string 'Kl is included in the FirstName node and returns the remaining string after the first occurrence. The FirstName node containing 'Klaus' contains the string 'Kl' and the remaining string returned is 'aus'. It selects all nodes that match this criteria.
substring-before()	Checks whether the first string contains the second string and returns the preceding string before the first occurrence. The expression "//Employee[substring-before(FirstName,'aus')='Kl']" first looks whether the string 'aus is included in the FirstName node and returns the preceding string before the first occurrence. The FirstName node containing 'Klaus' contains the string 'aus' and the preceding string returned is 'Kl'. It selects all nodes which match this criteria.
substring()	Returns a sub-string starting at the position specified and with the number of characters specified. This allows you to cut out a sub-string from the specified string. You can specify a node or string literal. The expression "//Employee[substring(FirstName,2,3)='lau']" takes the node FirstName and returns a sub-string starting at position two for three characters in length. The FirstName node containing 'Klaus' returns the sub-string 'lau'. It selects all nodes that match this criteria.
string-length()	Returns the length of a string. You can give a node name or string literal. The expression "//Employee[string-length(LastName)>=8]" returns all nodes that have a LastName node of greater or equal of eight characters.

The table does not contain a complete list but explains the most common expression and functions. For a complete list, please refer to the XPath standard.

XPath Introduction

2006-10-15T18:22:00-05:00:00

XPath is a language for finding information in an XML document. XPath is used to navigate through elements and attributes in an XML document.

What is XPath?

XPath is a syntax for defining parts of an XML document
XPath uses path expressions to navigate in XML documents
XPath contains a library of standard functions
XPath is a major element in XSLT
XPath is a W3C Standard

XPath Path Expressions

XPath uses path expressions to select nodes or node-sets in an XML document. These path expressions look very much like the expressions you see when you work with a traditional computer file system.

XPath Standard Functions

XPath includes over 100 built-in functions. There are functions for string values, numeric values, date and time comparison, node and QName manipulation, sequence manipulation, Boolean values, and more.

X509Chain Class

2006-10-15T18:18:00-05:00:00

Namespace: System.Security.Cryptography.X509Certificates
Assembly: System (in system.dll)

The X509Chain object has a global error status called ChainStatus that should be used for certificate validation. The rules governing certificate validation are complex, and it is easy to oversimplify the validation logic by ignoring the error status of one or more of the elements involved. The global error status takes into consideration the status of each element in the chain.

The following code example opens the current user's personal certificate store, allows you to select a certificate, then writes certificate and certificate chain information to the console. The output depends on the certificate you select.

using System;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.IO;

class TestX509Chain
{
    static void Main(string[] args)
    {
        //Create new X509 store from local certificate store.
        X509Store store = new X509Store("MY", StoreLocation.CurrentUser);
        store.Open(OpenFlags.OpenExistingOnly | OpenFlags.ReadWrite);

        //Output store information.
        Console.WriteLine ("Store Information");
        Console.WriteLine ("Number of certificates in the store: {0}", store.Certificates.Count);
        Console.WriteLine ("Store location: {0}", store.Location);
        Console.WriteLine ("Store name: {0} {1}", store.Name, Environment.NewLine);

        //Put certificates from the store into a collection so user can select one.
        X509Certificate2Collection fcollection = (X509Certificate2Collection)store.Certificates;
        X509Certificate2Collection collection = X509Certificate2UI.SelectFromCollection(fcollection, "Select an X509 Certificate", "Choose a certificate to examine.", X509SelectionFlag.SingleSelection);
        X509Certificate2 certificate = collection[0];
        X509Certificate2UI.DisplayCertificate(certificate);
        //Output chain information of the selected certificate.
        X509Chain ch = new X509Chain();
        ch.Build (certificate);
        Console.WriteLine ("Chain Information");
        ch.ChainPolicy.RevocationMode = X509RevocationMode.Online;
        Console.WriteLine ("Chain revocation flag: {0}", ch.ChainPolicy.RevocationFlag);
        Console.WriteLine ("Chain revocation mode: {0}", ch.ChainPolicy.RevocationMode);
        Console.WriteLine ("Chain verification flag: {0}", ch.ChainPolicy.VerificationFlags);
        Console.WriteLine ("Chain verification time: {0}", ch.ChainPolicy.VerificationTime);
        Console.WriteLine ("Chain status length: {0}", ch.ChainStatus.Length);
        Console.WriteLine ("Chain application policy count: {0}", ch.ChainPolicy.ApplicationPolicy.Count);
        Console.WriteLine ("Chain certificate policy count: {0} {1}", ch.ChainPolicy.CertificatePolicy.Count, Environment.NewLine);
        //Output chain element information.
        Console.WriteLine ("Chain Element Information");
        Console.WriteLine ("Number of chain elements: {0}", ch.ChainElements.Count);
        Console.WriteLine ("Chain elements synchronized? {0} {1}", ch.ChainElements.IsSynchronized, Environment.NewLine);

        foreach (X509ChainElement element in ch.ChainElements)
        {
            Console.WriteLine ("Element issuer name: {0}", element.Certificate.Issuer);
            Console.WriteLine ("Element certificate valid until: {0}", element.Certificate.NotAfter);
            Console.WriteLine ("Element certificate is valid: {0}", element.Certificate.Verify ());
            Console.WriteLine ("Element error status length: {0}", element.ChainElementStatus.Length);
            Console.WriteLine ("Element information: {0}", element.Information);
            Console.WriteLine ("Number of element extensions: {0}{1}", element.Certificate.Extensions.Count, Environment.NewLine);

            if (ch.ChainStatus.Length > 1)
            {
                for (int index = 0; index < element.ChainElementStatus.Length; index++)
                {
                    Console.WriteLine (element.ChainElementStatus[index].Status);
                    Console.WriteLine (element.ChainElementStatus[index].StatusInformation);
                }
            }
        }
        store.Close();
    }
}

Revoked property

Digital Certification X509Certificate C# Asp.net

2006-10-15T18:12:00-05:00:00

Any application of cryptography in building a secured infrastructure uses many of encryption, hashing and signature ciphers. In fact all the cryptographic solutions that are available today include a comprehensive infrastructure with many ciphers, extensive security policies, rich tools for creating, deploying and managing secure applications and other integrated set of cryptographic services. One such infrastructure that comes with Windows 2000 is Public Key Infrastructure (PKI).

The challenge for any such PKI is relating the public-key with the entity that owns it, and also the publication and management of public-keys. The standard mechanism to achieve this is digital certification. This part of the article discusses digital certificates and their implementation in FCL and Web Service Enhancements (WSE 1.0) for Microsoft .NET. It also digresses into Windows 2000 PKI.

Digital Certification

Digital certification is an application in which a certification authority signs a special message m, containing the name of user and the users public-key in such a way that any one can verify that the message was signed by no one other than the centralized certification authority. This message m along with its signature is called digital certificate or digital id. A typical digital certificate contains the subjects name, subjects public-key, subjects public-key algorithm and parameters, unique id of the certificate, validity period of the certificate, certificate issuer name and the issuers signature.

To understand the need for digital certification, revisit the scenario explained in Digital Signing section of Cryptographic Applications of this article where our fictitious personalities Alice and Bob exchange digitally signed messages between them. In this Alice sends a digitally signed message to Bob; Bob ensures that the message was not altered in transit by verifying the mathematical validity of the signature using the public-key of Alice (PBa).

Alice signs the message with her private-key (PKa) of signature key-pair and sends the signature along with the message to Bob.

Bob verifies the validity of the signature using Alices public-key (PBa).

The big challenge in this solution is publicizing the Alices public-key.

1.How Bob gets Alices public-key?

2.How can Bob be sure that the key he received is Alices public-key and not someone elses?

An apparent quick solution for this problem is Alice handing over her public-key to Bob in a secured manner. But this presupposes that Alice and Bob have had some form of secured communication prior. Even If Alice publicizes her public-key in this way, it is not scalable. If she needs to have similar secured communication with say 100 more users then this process becomes a nightmare. Also for Bob getting public-key in this way and managing them is a nightmare.

If both Bob and Alice can trust some intermediary who in a secured way can bind a public-key to the owner of it, the problem will be solved. Alice can simply ask this intermediary to certify her public key. Bob needs to trust only this intermediary. He can verify that trusted intermediary certified the public-key. Since both Alice and Bob need to trust the public-key with one person, this scales for any number of users. For anyone with whom Alice needs to communicate she can send the same certificate. Also Bob can verify the public-key for all the users who are certified by the intermediary.

Alice signs the message with her private-key and sends her certificate along with the message and signature to Bob. Bob verifies the validity of the signature using Alices public-key that he extracts from the Alice certificate issued by certifying authority

X 509 Certification

There are three certification methods that are commonly used now

1.Directory Methods (X 509 Certificates and CAs)

2.Referal Methods (PGP)

3.Collabrative Methods (SKIP)

Of these X 509 devised by ITU-T is the de facto standard. X 509 digital certificates associates the public-key with the distinguished name, defined by X 500, of the user.

Certificate Chain

X 509 digital certificates are signed messages by themselves, wherein the certifying authority (hereafter referred as CA) is the signer of the message. CA uses public-key of its signature key pair to sign users digital certificate. However this does not solve the Bobs problem of binding the public-key to owner of it. How do Bob bind the public-key of CA to CA? Chicken and Egg Problem? Bob now needs to find a certificate issued by a superior CA attesting the identity of this CA. By doing this Bob starts constructing a chain of certificates, each attesting the subordinate CAs identity, terminating in a certificate issued by someone that Bob implicitly trusts. Such a certificate is called a trusted root certificate. Trusted root certificate forms the root of a hierarchy of public-keys/identity bindings that Bob accepts as authentic. The CA that issued the trusted root certificate is called Root-CA, and the one that issued certificate to Alice is called Issuing-CA. All the other CAs between the root and the issuing CAs are called Intermediate-CA. When Bob chooses to explicitly trust a particular trusted root certificate, he is also implicitly trusting all the certificates issued by that trusted root CA, as well as all certificates issued by any subordinate CA certified by the trusted root.

Certificate Contents

In addition to the users distinguished name and public-key, digital certificate also contain other information. Following Picture shows the content of Version 1 X 509 digital certificates.

Version 2 X 509 digital certificates introduced two more fields,

Issuer Unique ID: Makes the issuer name unambiguous if it is used by more than one entity.

Subject Unique ID: Makes the subject name unambiguous if it is used by more than one entity.

Version 3 X 509 digital certificates allowed adding any number of custom fields, called Extensions, to the certificate.

Following pictures shows a Version 3 X 509 digital certificate issued by the Certification Server in Windows 2000 Advanced Server.

Following are the details of the certificate

Version 1 Fields

Version: V3
Serial Number: 6106 C4F8 0000 0000 0002
Valid From: Friday, December 20, 2002 7:55:34 PM
Valid To: Monday, December 20, 2004 7:48:02 PM
Subject: CN = w2k-as-1224.PGVIJAY.com
Public Key: RSA (1024 bits) 3081 8902 8181 00A5 4F71 CE5C B897 BBB5 DE85 790A E590 DCD5 6720 8B65 A98F 0A56 652E BC60 DF7B 783C 9DF0 373C AFD0 B447 4BAD BF56 C940 164B 534C 4CD9 A602 87B4 EF02 C8CB F9FA 89E2 53CB 350D 6096 416B EB16 E9F8 8DA2 5769 112F 3DE4 28FE 6CF5 9673 8093 A65A 3BB7 C420 9A7E 718E CF64 2725 3E71 F6A7 4E00 9A00 38B8 7F9F FC39 DD0E 9255 437B 5F02 0301 0001
Issuer: CN = Pgvijay, OU = pgvijay home, O = pgvijay Inc, L = Stamford, S = ct, C = US, E = pgvijay@msn.com
Signature Algorithm: sha1RSA

Version 2 Fields
Subject Key Identifier: 2377 9A5E EA96 93A3 7409 021E FCDA B713 A368 0C34
Authority Key Identifier: KeyID=BF9A 4988 5536 A242 7512 9AE2 FC68 CF27 6CA6 C283 Certificate Issuer: Directory Address: CN=Pgvijay, OU=pgvijay home, O=pgvijay inc, L=Stamford, S=ct, C=US, E=pgvijay@msn.com Certificate Serial Number=6D81 BF9C E657 C88B 42FD A72C 44D3 39E6

Version 3 Fields
Key usage: Digital Signature, Key Encipherment (A0) See the side bar 2.
Enhanced Key Usage: Client Authentication (1.3.6.1.5.5.7.3.2), Server Authentication (1.3.6.1.5.5.7.3.1)
Certificate Template: Domain Controller
Subject: Alternative Name: Other Name: 1.3.6.1.4.1.311.25.1=0410 9BF6 C540 6777 CD4C 965F 82D4 ADE4 7440 DNS Name=w2k-as-1224.PGVIJAY.com
CRL Distribution Point:
[1]CRL Distribution Point

Distribution Point Name:
Full Name:
               URL=ldap:///CN=Pgvijay,CN=w2k-as-1224,CN=CDP,CN=Public%20Key%20Services,CN=Services,CN=
Configuration,DC=PGVIJAY,DC=com?certificateRevocationList?base?objectclass=cRLDistributionPoint

[2]CRL Distribution Point

Distribution Point Name:

Full Name:

            URL=http://w2k-as-1224.pgvijay.com/CertEnroll/Pgvijay.crl

Authority Information Access:

[1]Authority Info Access

     Access Method=Certification Authority Issuer(1.3.6.1.5.5.7.48.2)

     Alternative Name:

          URL=ldap:///CN=Pgvijay,CN=AIA,CN=Public%20Key%20Services,CN=Services,CN=Configuration,DC=PGVIJAY,DC=com?cACertificate?base?objectclass=certificationAuthority

[2]Authority Info Access

     Access Method=Certification Authority Issuer(1.3.6.1.5.5.7.48.2)

     Alternative Name:

          URL=http://w2k-as-1224.pgvijay.com/CertEnroll/w2k-as-1224.PGVIJAY.com_Pgvijay.crt

Thumbprint Algorithm: sha1

Thumbprint: 8C14 83A7 CAAE ED61 DCBE A15E 7E9A B2A0 7713 F138

Certificate Revocation Lists

A certificate revocation list (CRL) is the list of certificates that were revoked by the CA for some reason like the subjects private key being compromised. CA publishes the CRL at well-known places. Certificate issued by the Certificate Server of Windows 2000 PKI has the pointer to CRL also in it as a version 3 extension.

The above certificate states that the CRL will be published in

1.Web server (http://w2k-as-1224.pgvijay.com/CertEnroll/Pgvijay.crl)

2.Active directory server (ldap:///CN=Pgvijay,CN=w2k-as-1224,CN=CDP,CN=Public%20Key%20Services,CN=Services,CN=Configuration,
DC=PGVIJAY,DC=com?certificateRevocationList?base?objectclass=cRLDistributionPoint)

Certificate Trust Lists

A certificate trust list (CTL) enables controlling the trust of the purpose and of the validity period of certificates that are issued by any external certification authorities (Windows 2000 PKI comes with Certificate Server and this becomes Internal certificate authority in the domain. Any CA that is not part of Windows 2000 domain, like Verisign etc, becomes external certificate authority). Typically, a certification authority issue certificates for a wide variety of purposes, such as secure e-mail or client authentication. But in situations when the trust of these certificates is to be limited, a certificate trust list is created. Suppose, for example, a certification authority named Abc CA is capable of issuing certificates for server authentication, client authentication, code signing, and secure e-mail. However, the certificates issued by Abc CA needs to be trusted only for the purpose of client authentication, a certificate trust list that limit the purpose for which certificates issued by Abc CA to client authentication is created. Any certificates issued for another purpose by Abc CA are not accepted for use by any computer to which this certificate trust list is applied.

Digital Certificate Support in CryptoAPI

Physical Store

Physical certificate store provides a grouping of certificates, certificate revocation lists (CRLs), and certificate trust lists (CTLs). Certificate store has only the pointers to the certificates and not the certificate themselves; instead certificates are persisted in permanent storages like file, registry (local or remote machine), active directory server, and smart card etc. Physical stores in turn are also located in different physical storages as the certificates. They can also be created on memory for temporary purposes.

Certificate Store Providers

CryptoAPI has predefined store provider types for different locations where a physical store can be persisted.

Logical Stores

Sometime a certificate might need to be member of several different logical groups. For this a logical collection of physical stores, called logical stores, is used. Any operation performed on the logical store is performed on the underlying physical stores. For instance, opening the logical store opens all the underlying physical stores, enumerating the certificates in the logical store enumerates all the certificates in all the underlying physical stores etc., An individual physical store can be a member of more than one logical store.

System Stores

Microsoft Windows 2000 comes with five predefined logical collection stores, namely MY, CA, TRUST, ROOT and USERDS. These stores are called system stores. Each of the following system store location has some or all of these system stores; and in addition they can also have other user created logical stores.

As said before every logical store in each of above locations have associated physical stores. For instance system stores at Current User has the following physical store association

Following picture shows a sample association between MY system store and the physical stores.

For more details on the store location please refer MSDN.

Key Databases in Cryptographic Service Providers (CSP)

Cryptography Service Providers in CrytpAPI persists the asymmetric key pairs across multiple sessions in a key database. These key databases have multiple key containers, which are identified by unique names. Windows creates a key container for each user of the machine. The key container is named after the user name. All the keys that belong to the user are kept in this container.

There are usually two key pairs in each container: key-exchange key pair and signature key pair. While the former is used to encrypt session keys, the later is used to create digital signatures. (For more details refer previous parts of this article).

Microsoft CSPs stores their key database in two different locations based on the type of the application, interactive standalone applications or non-interactive service applications. While Windows NT keeps the key containers in registry, Windows 2000 keeps them in file. Windows NT keeps key-database under the registry keys HKEY_CURRENT_USER\Software\Microsoft\Cryptography\UserKeys and HKEY_LOCAL_MACHINE\Software \Microsoft\Cryprography\MachineKeys for stand-alone applications and for non-interactive service applications respectively. Windows NT keeps key-database in a file under directories \Documents and settings\\Application Data\Microsoft\Crypto\RSA\ and \Documents and settings\All Users\Application Data\Microsoft \Crypto\RSA\Machinekeys for stand-alone applications and for non-interactive service applications respectively.

Cryptography Support in Microsoft.Net

System.Security.Cryptography.X509Certificates namespace provides classes to work with X509v3 Digital Certificates.

However the namespace does not have full support to work with digital certificates, for instance there is no support for very important tasks such as

1.Loading certificates from a certificate store.
2.Finding the private-key associated with the public-key of digital certificate, from the key database.
3.Reading X509 Version 2 Fields (Loads a v2 certificate but does not have methods to get the fields)
4.Reading X509 Version 3 Fields (Loads a v3 certificate but does not have methods to get the fields)
5.Working with CRL and CTL.

However X509Certificate class provides static methods to load a certificate from a file.

public static X509Certificate CreateFromCertFile(string filename);

Following snippet shows how to load a certificate from file msn.cer/.

Following is the output generated by the above snippet. Output is edited for brevity.

1.2.840.113549.1.1.1 is the OID for RSA. For more details refer MSDN

Following picture shows the msn.cer certificate used by MSN. The certificate is available as a part of the attached sample.

Web Service Extensions for Microsoft.Net

Microsoft.Web.Services.Security.X509 namespace of Web Service Extensions (WSE 1.0) attempts to bridge the gap between the extensive X509 support in CrytpoAPIs and the limited X509 support in FCL. It has an X509Certificate class, which derives from the X509Certificate in the FCL. It also has a class to work with Certificate store X509CertificateStore. To use WSE a reference to Microsoft.Web.Services.dll should be added to the project.

Microsoft.Web.Services.Security.X509.X509Certificate class has a property to find the associated private key.

Microsoft.Web.Services.Security.X509.X509Certificate first finds the public-key, the asymmetric algorithm of the public-key and the subject name from the certificate. Then it attempts to load the default CSP that can work with the asymmetric key cipher in the certificate. In this sample the public-key cipher is RSA and the key size of 1024 bits (certificate file is attached with the sample). So it attempts to load "Microsoft Enhanced Cryptographic Provider v1.0" CSP using System.Security.Cryptography.RSACryptoServiceProvider. Then it attempts to load the corresponding private-key from the key container named after the subject-name (in this sample pgvijay) from the CSPs key database.

Following snippet shows how to use it.

Certificate Store in WSE 1.0

Microsoft.Web.Services.Security.X509.X509CertificateStore class provides partial CryptoAPI certificate store support. The X509CertificateStore class constructor takes the store provider, store location and store name.

public X509CertificateStore(X509CertificateStore.StoreProvider provider, X509CertificateStore.StoreLocation location, string storeName);

It only supports four store providers, namely system, file, collection and memory; but all the store locations defined by the CryptoAPI.

X509CertificateStore class provides methods to search for certificates based on subject name, key identifier and the hash value. Following snippet shows one such code

Following snippet shows how to find the asymmetric key pair when given the subject name of the certificate.

Certificate Services in Windows 2000

Windows 2000 Public Key Infrastructure comes with a Certificate Server. To generate a certificate for a user using the certificate server navigate to the CertServ Web Application installed in the CA Server (http://w2k-as-1224/CertSrv/).

Select Request a certificate in this page and say Next.

Select Advanced request in this page and say Next

Select Submit a certificate request to this CA using a form. In this page and say Next

Fill up the page as shown above. This creates a 1024 bits RSA key-pair and stores the key set in the key container BobKeys of the CSP Microsoft Base Cryptographic Provider v1.0. The key set can be user as both signature key pair and key exchange key pair.

Selecting Install this certificate will install the certificate in the default store of the local machine.

LDAP Get Info from Active Directory

2006-10-15T17:54:00-05:00:00

To retrive all imformation from avtive directory through ldap protocol

using objX509Cert = System.Security.Cryptography.X509Certificates;

string filter = "mail=*";
xd = lcl.LDAPInfo(filter);

public XmlDocument LDAPInfo(string filter)
{
XmlDocument xd = new XmlDocument();
string domainAndUsername = string.Empty;
string userName = string.Empty;
string passWord = string.Empty;
string Sur = "";
string Cn = "";
string Name = "";
string GName = "";
string DGname = "";
string Member = "";
string Init = "";
string Postal = "";
string Loc = "";
string C = "";
string Mobile = "";
string HomePh = "";
string Title = "";
string Co= "";
string State = "";
string eMail = "";

string Password = "";
string SAM = "";

string MemOf = "";
string UID = "";
string Desc = "";
string UserCert = "";
string UserCertName = "";
string certno = "";
string certString64="";

Boolean chkpass = false;
AuthenticationTypes at = AuthenticationTypes.Anonymous;
StringBuilder sbb = new StringBuilder();

//****Connecting to LDAP active directory
domainAndUsername = @"LDAP://YourDomain/c=CH";
userName = "username" ;
passWord = "password";
//at = AuthenticationTypes.Secure;

//Create the object necessary to read the info from the LDAP directory
DirectoryEntry entry = new DirectoryEntry(domainAndUsername,userName, passWord,at);
DirectorySearcher mySearcher = new DirectorySearcher(entry);
SearchResultCollection results;
mySearcher.Filter = filter;

try
{
results = mySearcher.FindAll();

if (results.Count > 0)
{
sbb.Append("");
foreach(SearchResult resEnt in results)
{
sbb.Append("");
ResultPropertyCollection propcoll=resEnt.Properties;
//sbb.Append("" + propcoll.PropertyNames.Count+"");
Sur = "";
Cn = "";
Name = "";
GName = "";
DGname = "";
Member = "";
Init = "";
Postal = "";
Loc = "";
C = "";
Mobile = "";
HomePh = "";
Title = "";
Co = "";
State = "";
Password = "";
SAM = "";
MemOf = "";
UID = "";
Desc = "";
UserCert = "";
UserCertName = "";
certString64="";
//string vCardn;

StringBuilder strBMails = new StringBuilder();
StringBuilder strBCert = new StringBuilder();

foreach(string key in propcoll.PropertyNames)
{
string values = "";
if (propcoll[key].Count > 0)
values = propcoll[key][0].ToString();

#region Switch
switch (key)
{
case "sn":
Sur = values.ToString();
break;
case "cn":
Cn = values.ToString();
break;
case "name":
Name = values.ToString();
break;
case "givenname":
GName = values.ToString();
break;
case "distinguishedname":
DGname = values.ToString();
break;
case "member":
Member = values.ToString();
break;
case "initials":
Init = values.ToString();
break;
case "postalcode":
Postal = values.ToString();
break;
case "l":
Loc = values.ToString();
break;
case "c":
C = values.ToString();
break;
case "mobile":
Mobile = values.ToString();
break;
case "homephone":
HomePh = values.ToString();
break;
case "title":
Title = values.ToString();
break;
case "co":
Co = values.ToString();
break;
case "st":
State = values.ToString();
break;
case "mail":
BMails.Append("");
foreach (object valuess in propcoll[key])
{
eMail = valuess.ToString();
strBMails.Append("" + valuess.ToString() + "");
}
strBMails.Append("");
break;
case "password":
strPassword = values.ToString();
break;
case "samaccountname":
strSAM = values.ToString();
break;
case "memberof":
strMemOf = values.ToString();
break;
case "uid":
strUID = values.ToString();
break;
case "description":
strDesc = values.ToString();
break;
case "usercertificate;binary":
strBCert.Append("");
foreach (object valuess in propcoll[key])
{
FileStream fs = File.Create("./tempcer1.cer");
BinaryWriter bw = new BinaryWriter(fs);
bw.Write((byte[])valuess);
bw.Close();

objX509Cert.X509Certificate myCert = objX509Cert.X509Certificate.CreateFromCertFile("./tempcer1.cer");

strBCert.Append("" + myCert.GetSerialNumberString() + "");
strBCert.Append("" + myCert.GetName() + "");
strBCert.Append("" + myCert.GetExpirationDateString() + "");

strcertno = myCert.GetSerialNumberString();
FileInfo fi = new FileInfo("./tempcer1.cer");
if (File.Exists(myCert.GetSerialNumberString() + ".cer"))
File.Delete(myCert.GetSerialNumberString() + ".cer");
fi.MoveTo(myCert.GetSerialNumberString() + ".cer");

string cerPath = System.Web.HttpContext.Current.Server.MapPath("./Certificate/");
if (File.Exists(cerPath + myCert.GetSerialNumberString() + ".cer"))
File.Delete(cerPath + myCert.GetSerialNumberString() + ".cer");
fi.CopyTo(cerPath + myCert.GetSerialNumberString() + ".cer");
chkpass = true;

}
strBCert.Append("");
break;
}
#endregion

}
sbb.Append("" + strSur + "");
sbb.Append("" + strCn + "");
sbb.Append("" + strName + "");
sbb.Append(strBMails);
sbb.Append(strBCert);
sbb.Append("" + strGName + "");
sbb.Append("" + strGName + "");
sbb.Append("" + strMember + "");
sbb.Append("" + strInit + "");
sbb.Append("" + strPostal + "");
sbb.Append("" + strLoc + "");
sbb.Append("" + strC + "");
sbb.Append("" + strMobile + "");
sbb.Append("" + strHomePh + "");
sbb.Append("");
sbb.Append("" + strCo + "");
sbb.Append("" + strState + "");
sbb.Append("" +strPassword + "");
sbb.Append("" + strSAM + "");
sbb.Append("" + strMemOf + "");
sbb.Append("" + strUID + "");
sbb.Append("" + strDesc + "");
sbb.Append("");

}
sbb.Append("");

xd.LoadXml(sbb.ToString());
return xd;
}
}
catch (Exception ex)
{
string msg = ex.Message;
}
sbb.Append("No");
xd.LoadXml(sbb.ToString());
return xd;
}

Create .VCF File(outlook contact file) with C#

2006-10-15T17:55:00-05:00:00

This is code of to create vcf card on the fly

//sdBuild is string builder

sdBuild.Append("N:" + strCn + System.Environment.NewLine);
sdBuild.Append("FN:" + strCn +System.Environment.NewLine);
//// encoding to base 64
certString64 = certString64 + System.Environment.NewLine + "KEY;X509;ENCODING=BASE64:" + System.Environment.NewLine;
certString64 = certString64 + Convert.ToBase64String((byte[])valuess) + System.Environment.NewLine;
//// encoding to base 64 ends here
sdBuild.Append(certString64);

sdBuild.Append(System.Environment.NewLine+"ORG: None;"+System.Environment.NewLine);
sdBuild.Append("TITLE:" + strTitle +System.Environment.NewLine);
sdBuild.Append("NOTE;ENCODING=QUOTED-PRINTABLE:This is a note associated with this"+System.Environment.NewLine);
sdBuild.Append("contact=0D=0A"+System.Environment.NewLine);
sdBuild.Append("TEL;WORK;VOICE:"+System.Environment.NewLine);
sdBuild.Append("TEL;HOME;VOICE:" + strHomePh +System.Environment.NewLine);
sdBuild.Append("TEL;CELL;VOICE:" + strMobile +System.Environment.NewLine);
sdBuild.Append("TEL;WORK;"+System.Environment.NewLine);
sdBuild.Append("ADR;WORK:;;" + strState + ";" + strCo +System.Environment.NewLine);
sdBuild.Append("LABEL;WORK;ENCODING=QUOTED-PRINTABLE:" + strCo +System.Environment.NewLine);
sdBuild.Append("751234 =0D=0AUnited States of America" +System.Environment.NewLine);
sdBuild.Append("URL:"+System.Environment.NewLine);
sdBuild.Append("URL:"+System.Environment.NewLine);
sdBuild.Append("EMAIL;PREF;INTERNET:" + streMail +System.Environment.NewLine);
sdBuild.Append("REV:"+System.Environment.NewLine);
sdBuild.Append("END:VCARD");

How to change the ower of tables in Microsoft SQL Server database

2006-10-15T17:55:00-05:00:00

To do this, execute the following command on every table

exec sp_changeobjectowner '?????', 'DBO' - where ????? is the name of your database table.

Also below is the stored procedure through which you can change the owner for every table in the database.

EXEC sp_changeobjectowner @oldownerplusobject, @new

create procedure _ChangeObjectOwner (@type varchar(1),@old varchar(20),@new

varchar(20))

as

declare @ObjectName varchar(100)

declare @oldownerplusobject varchar(50) begin declare Cursor_Object cursor for select [name] from sysobjects where type=@type and xtype=@type open Cursor_Object FETCH NEXT FROM Cursor_Object INTO @ObjectName WHILE @@FETCH_STATUS = 0 begin

set @oldownerplusobject=@old+'.'+@ObjectName

EXEC sp_changeobjectowner @oldownerplusobject, @new

print 'Permission Changed for ' + @oldownerplusobject +' to ' + @new + ' :

Process Done'

FETCH NEXT FROM Cursor_Object INTO @ObjectName end close Cursor_Object deallocate Cursor_Object end

exec _ChangeObjectOwner 'p','xxx','yyy'

How to change the ower of tables in Microsoft SQL Server database

2006-10-15T17:54:00-05:00:00

Clear Project List from Start Page

2006-10-15T17:51:00-05:00:00

Here is a nice tips to clear the Recent project list or File list from Visual Studio .Net
Run--> RegEdit and navigate to

HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\\ProjectMRUList delete unnecessary list.

similarly for FileMRuList.

Make sure not disturb other key from the registry.