Hi There,

I am Syam Pinnaka, Dev in IAM services team at Microsoft.

Windows Installer XML (WIX) is a great way to create windows installer packages. WIX makes it easy to create simple installer packages and its also possible to create an installer of any complexity with WIX. Today I would like to share a simple trick to set the installer path from a registry entry.

WIX has ‘RegistrySearch’ element which makes it possible to search for a registry element. After we find the required registry entry, we can set this path as a property value which can then be referenced as the install directory during the install.

Here is the code snippet to search the registry.

    <Property Id="INSTALLFOLDER">
      <RegistrySearch Id='InstallPathRegistry' Type='raw'
        Root='HKLM' Key='SOFTWARE\Microsoft\my software' Name='InstallPath' Win64='no'/><!--Win64='yes'-->
    </Property>

In the above code, HKLM is the root to start the search. ‘SOFTWARE\Microsoft\my software’ is the key that’s searched. ‘InstallPath’ is the name of the subkey that’s being searched. Use Win64 value ‘No’ to search on x32 bit systems. Win64 value ‘Yes’ can be used for x64 bit systems.

It’s a common scenario to fail the installer if lets say the install path is not found. We can accomplish this using the below XML.

<Condition Message=''xxx' Install Folder not found'>INSTALLFOLDER</Condition>

Once after we find the correct install path, we would like to use it during the install. This can be achieved using the below XML.

        <Directory Id="TARGETDIR" Name="SourceDir">
                <Directory Id="INSTALLFOLDER" Name="My software" />
        </Directory>

Assuming that you have two .dlls to copy to the user computer and one registry entry to add, here is a sample XML which can be used with WIX.

<?xml version="1.0" encoding="UTF-8"?>
<?define Version="01.01.00" ?>

<Wix xmlns="https://schemas.microsoft.com/wix/2006/wi">
    <Product Id="*" Name="My software" Language="1033" Version="$(var.Version)" Manufacturer="Awesome Corporation" 

UpgradeCode="[[your guid here]]">
        <Package InstallerVersion="200" Compressed="yes" InstallScope="perMachine" Platform="x86"/> <!--Platform="x64"-->

    <MajorUpgrade DowngradeErrorMessage="A newer version of 'My software' is already installed." />
        <MediaTemplate EmbedCab="yes" CabinetTemplate="media{0}.cab"/>

    <Property Id="INSTALLFOLDER">
      <RegistrySearch Id='InstallPathRegistry' Type='raw'
        Root='HKLM' Key='SOFTWARE\Microsoft\my software' Name='InstallPath' Win64='no'/><!--Win64='yes'-->
    </Property>
    <Condition Message=''xxx' Install Folder not found'>INSTALLFOLDER</Condition>   
   
    <Feature Id="my feature1" Title="my feature1" Level="1">
      <ComponentGroupRef Id="feature1" />
    </Feature>
    
  </Product>

    <Fragment>
        <Directory Id="TARGETDIR" Name="SourceDir">
                <Directory Id="INSTALLFOLDER" Name="my application" />
        </Directory>
    </Fragment>

  <Fragment>
    <ComponentGroup Id="MyApplicationBin" Directory="INSTALLFOLDER">
      <Component Id="MyDll1" Guid="YOUR GUID1 HERE">
        <File Id="mydll1.dll" KeyPath="yes" Source="Binaries\mydll1.dll" />
      </Component>
      <Component Id="MyDll2" Guid="YOUR GUID2 HERE">
        <File Id="mydll2.dll" KeyPath="yes" Source="Binaries\mydll2.dll" />
      </Component>
      <Component Id="MyApplicationRegistryEntries" Guid="YOUR GUID3 HERE" Win64="no"><!--Win64="yes"-->
        <RegistryKey Root="HKLM"
                      Key='SOFTWARE\Microsoft\my application\[[your guid here]]'
              Action="createAndRemoveOnUninstall">
          <RegistryValue Type="string" Name="BinaryName" Value="mydll1.dll"/>
        </RegistryKey>
      </Component>
    </ComponentGroup>
  </Fragment>
  
</Wix>

Please note that the above XML is just to illustrate as to how the complete WIX XML will look like for this scenario. The above code is not tested so it may not work as desired if you try to use it as is.

Thanks for reading and happy installing.

Hi There,

I am Syam Pinnaka, Dev in IAM services team at Microsoft.

Forefront Identity Manager (FIM) supports querying its data using XPath. XPath queries can be constructed using standard XPath 2.0 specification. FIM XPath queries are a great way to query and fetch the required data from FIM but they can become tricky sometime as explained below.

Lets consider a simple xpath query to read a group with a display name. The xpath for this will look like below.

    "/Group[DisplayName = 'My Group1']";

When querying programmatically, we typically would like to parameterize this query and so the query will like below.

 string group = "my group";

"/Group[(DisplayName = '" + group + "')]";

”group” is a variable which will contain the group name that you would like to query FIM for.

This query will work perfectly for most of the data values until the group that you are searching for contains a single quote. Example below.

    string group = "I have a single quote(')";
    "/Group[(DisplayName = '" + group + "')]";

Notice a single quote in group name, i.e. "I have a single quote(')" and xpath query will try to enclose this name with two additional quotes before the query is dispatched to FIM. Obviously this query will not fetch the group and fails with an exception saying ‘Cannot filter as requested’. That’s because the extra single quote (‘) in the display name will make the total number of single quotes in the xpath query as 3. The system will detect this condition and fail saying ‘Cannot filter as requested”.

Its good to understand what the issue is but how do you fix\work around it? There could be multiple ways to work around this and here is what that has worked for me. Just enclose the display name with double quotes instead of single quotes. i.e. The xpath filter will need to look like this.

    "/Group[(DisplayName = \"I have a single quote(')\")]";

We can parameterize the above query as shown below.

    string group = "I have a single quote(')";
    "/Group[(DisplayName = \"" + group + "\")]"

Looks pretty simple, right? Well its only after I know the work around. :- )

Hi There, I am Syam Pinnaka, Dev in IAM services team at Microsoft.

I was trying to fix a bug in my code about a week back and was stumbled upon this. Think it will be useful to others. The story goes like this.

I have a collection (List) of my custom objects and took a copy of one of the list items. example below.

    class myObject

    {

        public myObject(int id, string name)

        {

            this.id = id;

            this.name = name;

        }

        public int id

        {

            get;

            set;

        }

        public string name

        {

            get;

            set;

        }

    }

            static List<myObject> items = new List<myObject>();

            myObject first = new myObject(1, "first");

            myObject second = new myObject(2, "second");

            items.Add(first);

            items.Add(second);

            myObject firstCopy = items[0];

After taking the copy, I try to make some changes to the copy and use it and finally set it to null.

            firstCopy.id = firstCopy.id + 1000;

            //Use firstCopy, code stripped for brevity..

            firstCopy = null;

now what do you think will be there items[0]? If you think its null that’s incorrect. it will still have the modified value and is not set to null. We can see this by checking the object.

            foreach (myObject item in items)

            {

                if (item != null )

                    Console.WriteLine("In main: id = " + item.id + ", name = " + item.name);

                else

                    Console.WriteLine("In main: item is null");

            }

The output is as below.

This is because the copy here is just a pointer to original list item and setting null on copy is like removing the reference and not release the original item. The only way to make the original item as null is to reference original item and set explicit null on that like below.

      item[0] = null;

This is a good learning for me and hope will be useful to others as well.

Thanks for reading and happy coding!

Hi There, I am Syam Pinnaka, Dev in IAM services team at Microsoft.

Have you ever wondered how to set an FIM connector space (CS) object Distinguished Name (DN) to a value that’s easy to read and use format? I had this question last week and the solution is easy.

Before I go into the solution to the above problem, its worth mentioning\recap “IMVSynchronization.Provision” method.

In FIM 2010 or latest versions IMVSynchronization.Provision method is used to handle changes to a metaverse object. Most notably to check if specific connector space object exists and if not, to create one. The triggering point for IMVSynchronization.Provision is when an import attribute flow changes attribute values to the metaverse object. IMVSynchronization.Provision is also triggered when a connector space object is projected, joined or disconnected to the metaverse object.

Typically relative distinguished name (RDN) and from that distinguished name (DN) is constructed in this method and set on the connector space object along with its other properties.

Assuming the connector space is from a SQL MA, the “IMVSynchronization.Provision” code will look like below.

string csEntryObjectType = null;
if (mventry.ObjectType == Constants.Common.Person)
    csEntryObjectType = Constants.Common.Person;
else if (mventry.ObjectType == Constants.Common.Computer)
    csEntryObjectType = Constants.Common.Computer;

csentry = managementAgent.Connectors.StartNewConnector(csEntryObjectType);
csentry[Constants.Common.IsDeleted].Value = Constants.Common.False; //"IsDeleted" is a field in SQL table.
csentry[Constants.Common.ObjectGUIDString].Value = mventry[Constants.Common.ObjectGUIDString].Value;
//"ObjectGUIDString" is another field in SQL table.
csentry.CommitNewConnector();

All this works perfect and connector space object will be created as desired. Now lets see how to set connector space (CS) object distinguished name (DN) to a value that’s easy to read and use. For this all that we need to do is construct that easy to use value and set it to DN property of the csentry. For example if we would like to set it to lets say ‘domain\alias’ format the code will look like below.

string csEntryObjectType = null;
if (mventry.ObjectType == Constants.Common.Person)
    csEntryObjectType = Constants.Common.Person;
else if (mventry.ObjectType == Constants.Common.Computer)
    csEntryObjectType = Constants.Common.Computer;

csentry = managementAgent.Connectors.StartNewConnector(csEntryObjectType);

string RDN = mventry[Constants.Common.Domain].Value + Constants.Common.ForwardSlash + 

mventry[Constants.Common.AccountName].Value;
csentry.DN = managementAgent.EscapeDNComponent(RDN);

csentry[Constants.Common.IsDeleted].Value = Constants.Common.False; //"IsDeleted" is a field in SQL table.
csentry[Constants.Common.ObjectGUIDString].Value = mventry[Constants.Common.ObjectGUIDString].Value;
//"ObjectGUIDString" is another field in SQL table.
csentry.CommitNewConnector();
  

Please note EscapeDNComponent in the above code. EscapeDNComponent works based on the management agent its called against and escapes Backslash ('\'). In order to work around the same, the above code uses a forwardSlash instead of backslash.

lDN can be set to any value as shown above and in some cases its advantageous to set it to a custom format.

Thanks for reading and happy syncing. :- )

.Net has provided many different ways of Asynchronous programming over various releases. The latest offering that comes with .Net 4.0 is Task Parallel Library (TPL). TPL comes with various benefits over other Async programming models like IAsyncResult or Event based models. The most notable benefits are as follows.

1. Ability to create parent to child tasks and create complex task hierarchy of dependent tasks.
2. Ability to Cancel or timeout tasks.
3. Ability to Wait for one or all tasks.
4. Continuation options for failed and succeeded tasks.
5. Ability to catch and handle exceptions.

Exception handling with Async programming is present with both IAsyncResult and Event based models but TPL makes this looks so natural that even a new programmer can start using without much difficulty. As always lets see some example code about how to start using Task Parallel Library.

Creating a task and getting the result is just a few lines of code.

        Task<int> t1 = new Task<int>(CalcSum, 5);
        t1.Start();
        Console.WriteLine("Sum = " + t1.Result);

        private static int CalcSum(object arg)
        {
            int sum = 0, count = (int)arg;
            for (int i = 0; i < count; i++)
                sum += i;

            Console.WriteLine("In CalcSum, Sum = " + sum);

            return sum;
        }

Note in the above code that a new Task that returns an int is declared. The same can be applied to create a task that returns a void or a custom data type.

Assuming that the “CalcSum” returns a void, in order to  compare “Task” with “QueueUserWorkItem” the below two lines of code are equivalent.

            ThreadPool.QueueUserWorkItem(CalcSum, 5);
            Task t2 = new Task(CalcSum, 5).Start();

Task has methods like .Wait, .ContinueWith and .RunSynchronously which will be handy in certain situations.

Task status can be found with .Status or .IsFaulted and .IsCompleted and .IsCanceled.

Exception if any during the task execution can be found using .Exception.

A method that needs special attention is .ContinueWith. This can be used to Continue a task when the parent task is completed or Failed or Cancelled. Example code would look like this.

            Task<int> t1 = new Task<int>(CalcSum, 5);
            t1.Start();
            t1.ContinueWith(task => Console.WriteLine("Fault: " + task.Exception, TaskContinuationOptions.OnlyOnFaulted);

Similarly .ContinueWhenAll can be used to continue a task when more than one task is completed. This concept can easily be used to build a hierarchy of dependent tasks with complex structure.

In addition to Task, .Net 4.0 TPL also provides three static methods which can be used to schedule lot of tasks with independent work. These constructs are as below.

1. System.Threading.Parallel.For; Example: Parallel.For(0, 100, i=> DoSomething() );
2. System.Threading.Parallel.ForEach; Example: Parallel.ForEach(collection, item =>DoSomething(item));
3. System.Threading.Parallel.Invoke; Example: Parallel.Invoke( ()=> DoSomething1(), ()=> DoSomething2());

I find both Task and Parallel very useful to address most of my common asynchronous needs without having to deal with Threading complexities. Hope you will find them useful too.

Thanks for reading and happy coding!

Hi There,

I am Syam Pinnaka, Dev in IAM services team at Microsoft.

Managed threading in .Net provide many different ways of creating threads and processing the tasks in separate threads and thus gain all the advantages that comes with multi threading. One way of creating a separate thread is by using “ThreadPool.QueueUserWorkItem” which has two overloads. First one takes the WaitCallback which takes the method to execute in the ThreadPool thread. Second one takes a WaitCallback along with a state object which can be used to provide the input information required for the ThreadPool thread. The first overload works fine if all the information required for the ThreadPool thread is present in the method itself or in the classes that it has access to. There could be a complex scenario where in you will need to provide some custom information to the ThreadPool thread like lets say the Callback to call after the ThreadPool thread completes its task. This post provides the information and example code required to handle this scenario. i.e. Provide custom information to the ThreadPool thread which includes a Callback reference and TheadPool thread uses to this Callback to notify the client when its work is completed.

Lets assume that we would like to handle a series of web page download requests using thread pool threads. Lets also assume that we would like each Threadpool thread to notify the client when its done downloading the web page. Lets see how we can handle this scenario using ThreadPool threads in an example.

Here is a simple class which downloads a web page given its Uri.

    class WebPageDownloader
    {
        public WebPageDownloader() { }

        public string PageDownload(Uri pageUri)
        {
            WebRequest request = null;
            HttpWebResponse response = null;
            Stream dataStream = null;
            StreamReader reader = null;
            string responseFromServer = string.Empty;
            try
            {
                request = WebRequest.Create(pageUri);
                request.Credentials = CredentialCache.DefaultCredentials;
                response = (HttpWebResponse)request.GetResponse();
                // Get the stream containing content returned by the server.
                dataStream = response.GetResponseStream();
                // Open the stream using a StreamReader for easy access.
                reader = new StreamReader(dataStream);
                // Read the content.
                responseFromServer = reader.ReadToEnd();
            }
            finally
            {
                reader.Close();
                dataStream.Close();
                response.Close();
            }

            return responseFromServer;
        }
    }

In order to make this as an ASync and execute the “PageDownload” in a separate thread, we can call ThreadPool.QueueUserWorkItem(new WaitCallback(PageDownload)) . But we would like this new thread to notify the client when the download is complete by passing in the callback method information to this ThreadPool thread. Thats two pieces of information now that we need to pass in. 1) Page Uri to download and 2) Callback to notify the client. This would lead us to modify PageDownload method to take a custom object which can have both Uri and the callback. Return type will change to void from string as we now use the callback to return the downloaded web page. Our new PageDownload method looks like below.

        private void PageDownload(object state)
        {
            Uri pageUri = ((PageDownloadInfo)state).uri;
            EndDownloadCallback endDownloadCallback = ((PageDownloadInfo)state).endDownloadCallback;

            if (endDownloadCallback == null)
                throw new ArgumentNullException("endDownloadCallback");

            WebRequest request = null;
            HttpWebResponse response = null;
            Stream dataStream = null;
            StreamReader reader = null;
            string responseFromServer = string.Empty;
            try
            {
                request = WebRequest.Create(pageUri);
                request.Credentials = CredentialCache.DefaultCredentials;
                response = (HttpWebResponse)request.GetResponse();
                // Get the stream containing content returned by the server.
                dataStream = response.GetResponseStream();
                // Open the stream using a StreamReader for easy access.
                reader = new StreamReader(dataStream);
                // Read the content.
                responseFromServer = reader.ReadToEnd();
            }
            finally
            {
                reader.Close();
                dataStream.Close();
                response.Close();
            }

            endDownloadCallback(responseFromServer);
        }

Please note in the above code that we have created and using a new type called PageDownloadInfo to pass in the required input information. PageDownloadInfo looks like below.

    /// <summary>
    /// Class to contain information about page to download.
    /// </summary>
    internal class PageDownloadInfo
    {
        public Uri uri;
        /// <summary>
        /// Callback to use after the download completes.
        /// </summary>
        public EndDownloadCallback endDownloadCallback;

        public PageDownloadInfo(Uri pageUri, EndDownloadCallback callback)
        {
            uri = pageUri;
            endDownloadCallback = callback;
        }
    }

We also need two other methods to initiate the ThreadPool thread to start downloading the web page asynchronously and another method to receive the callback. Those two would look something like below.

        public void StartDownloadPageAsync(Uri pageUri)
        {
            PageDownloadInfo pageInfo = new PageDownloadInfo(pageUri, new EndDownloadCallback(EndDownloadPage));
            ThreadPool.QueueUserWorkItem(new WaitCallback(PageDownload), pageInfo);
        }

        public void EndDownloadPage(string page)
        {
            PageDownloadedEventArgs downloadedPage = new PageDownloadedEventArgs();
            downloadedPage.Page = page;
            pageDownloaded(this, downloadedPage);
        }

“StartDownloadPageAsync” is the Async call initiator. It creates a new ThreadPool thread using ThreadPool.QueueUserWorkItem by passing in PageDownload method and pageInfo. PageDownload method will be queued up with this call to download the web page and call the EndDownloadPage using the Callback provided in pageInfo.

Note that EndDownloadPage has some code which in turn notifies its clients about downloaded page and its done using pageDownloaded event. pageDownloaded is a custom event that’s created to notify and provide the downloaded web page information to the client.

    /// <summary>
    /// Event arguments to use with page downloaded event.
    /// </summary>
    internal class PageDownloadedEventArgs : EventArgs
    {
        public string Page { get; set; }
    }


        /// <summary>
        /// Event to fire to trigger the download complete notificatio to clients.
        /// </summary>
        public event EventHandler<PageDownloadedEventArgs> pageDownloaded;

With all the above plumbing in place we now have a fully functional page download Class which can processes the incoming requests asynchronously. The clients can now subscribe to pageDownloaded event and make a call StartDownloadPageAsync to start downloading the page and get notified when its done.

Complete code looks like below and enjoy the full power of Managed threading. Happy coding!

using System;
using System.IO;
using System.Net;
using System.Threading;

namespace AsyncExercises
{
    /// <summary>
    /// Declare the delegate to use when download completes.
    /// </summary>
    /// <param name="page"></param>
    public delegate void EndDownloadCallback(string page);

    /// <summary>
    /// Event arguments to use with page downloaded event.
    /// </summary>
    internal class PageDownloadedEventArgs : EventArgs
    {
        public string Page { get; set; }
    }

    /// <summary>
    /// Class to contain information about page to download.
    /// </summary>
    internal class PageDownloadInfo
    {
        public Uri uri;
        /// <summary>
        /// Callback to use after the download completes.
        /// </summary>
        public EndDownloadCallback endDownloadCallback;

        public PageDownloadInfo(Uri pageUri, EndDownloadCallback callback)
        {
            uri = pageUri;
            endDownloadCallback = callback;
        }
    }

    /// <summary>
    /// Class that downloads a web page and returns the contents as a string.
    /// </summary>
    class WebPageDownloader
    {
        /// <summary>
        /// Event to fire to trigger the download complete notificatio to clients.
        /// </summary>
        public event EventHandler<PageDownloadedEventArgs> pageDownloaded;

        /// <summary>
        /// Constructor
        /// </summary>
        public WebPageDownloader()
        {
        }

        /// <summary>
        /// Async download start, This will start a new thread and schedule page download task.
        /// </summary>
        /// <param name="pageUri"></param>
        public void StartDownloadPageAsync(Uri pageUri)
        {
            PageDownloadInfo pageInfo = new PageDownloadInfo(pageUri, new EndDownloadCallback(EndDownloadPage));    
            ThreadPool.QueueUserWorkItem(new WaitCallback(PageDownload), pageInfo);
        }

        /// <summary>
        /// Method that will be called by the thread pool thread when download completes.
        /// </summary>
        /// <param name="page"></param>
        public void EndDownloadPage(string page)
        {
            PageDownloadedEventArgs downloadedPage = new PageDownloadedEventArgs();
            downloadedPage.Page = page;
            pageDownloaded(this, downloadedPage);
        }

        /// <summary>
        /// Method which downloads the web page given its Uri and return the downloaded page using callback provided.
        /// </summary>
        /// <param name="state"></param>
        private void PageDownload(object state)
        {
            Uri pageUri = ((PageDownloadInfo)state).uri;
            EndDownloadCallback endDownloadCallback = ((PageDownloadInfo)state).endDownloadCallback; 

            if (endDownloadCallback == null)
                throw new ArgumentNullException("endDownloadCallback");

            WebRequest request = null;
            HttpWebResponse response = null;
            Stream dataStream = null;
            StreamReader reader = null;
            string responseFromServer = string.Empty;
            try
            {
                request = WebRequest.Create(pageUri);
                request.Credentials = CredentialCache.DefaultCredentials;
                response = (HttpWebResponse)request.GetResponse();
                // Get the stream containing content returned by the server.
                dataStream = response.GetResponseStream();
                // Open the stream using a StreamReader for easy access.
                reader = new StreamReader(dataStream);
                // Read the content.
                responseFromServer = reader.ReadToEnd();
            }
            finally
            {
                reader.Close();
                dataStream.Close();
                response.Close();
            }

            endDownloadCallback(responseFromServer);
        }
    }
}

I am Syam Pinnaka, Dev in IAM services team at Microsoft.

As promised in my last post, lets examine event based Asynchronous Programming Technique.

The key difference between IAsyncResult and Event based pattern is the way they notify the client when  asynchronous call is completed. While using the IAsyncResult pattern, client will either wait on the call they made with “BeginInvokeXXX” or wait for the callback method to be called which it has supplied to the “BeginInvokeXXX” method. In event based pattern, client can subscribe to a completion event and then the client will be notified using this subscribed event when the Asynchronous call is completed. The event based Asynchronous class signature will look something similar to below.

        /// <summary>
        /// Event for when writing to log file is completed.
        /// </summary>
        public event EventHandler CompletedWriting;

Client can subscribe to this event as shown below.

            LogFileWriter logFileWriter = new LogFileWriter();
            logFileWriter.CompletedWriting += OnCompletedWriting;

And call a method which operates Asynchronously.

            logFileWriter.WriteLineAsync(charsToLog);

The WriteLineAsync method which will look like below.

        /// <summary>
        /// WriteLineAsync to start write to file asychronously.
        /// </summary>
        /// <param name="line">Text to write</param>
        public void WriteLineAsync(string line)
        {
            IAsyncResult result = writelineToLogfile.BeginInvoke(line, callback, state);
            result.AsyncWaitHandle.WaitOne();
            CompletedWriting(this, null);
        }

Note in the above code that writelineToLogfile is a delegate to the actual method which does the writing work. When this call is completed, WaitOne will receive the signal to resume execution which will then call “CompletedWriting” to notify the client about Asynchronous call completion. This can also be done in “callback” argument method and thus “WaitOne” can be avoided.

Also note the second argument in CompletedWriting event which is null now. This argument can be used to pass back some useful information to the client when the Asynchronous call is completed. The CompletedWriting event declaration will need a change like below.

        public event EventHandler<CompletedWritingEventArgs> CompletedWriting;

CompletedWritingEventArgs is a class derived from EventArgs as show below.

  internal class CompletedWritingEventArgs : EventArgs
  {
      public double BytesWritten;
  }

That’s all for now and all the best with your asynchronous programming designs and code!

I am Syam Pinnaka, Dev in IAM services team at Microsoft.

During the past two weeks, I was trying to explore the .Net Asynchronous programming and so thought I would share my learning. In general, there are two different ways of Asynchronous programming in .Net. 1) Using IAsyncResult 2) using event based Asynchronous pattern. Lets see how to use IAsyncResult in this blog post and I will try and cover Event based Asynchronous pattern in my next post.

Some functionality in .Net can be called from client application either synchronously or asynchronously. Webservice calls are a common example for this. Loading the high resolution  images in a web page could be another good scenario for this. Whenever an asynchronous call is supported, these methods typically start with BeginMethodname and EndMethodName. BeginMethodName typically have signature similar to its synchronous variant with two additional parameters AsyncCallback and object state. AsyncCallback can be used to pass in the callback method for when the asynchronous call is completed and object state is used to pass in some custom data to the asynchronous call. In case when multiple asynchronous calls are made, this state can be used to differentiate these various client calls. A typical begin signature and client call would look like below.

public IAsyncResult BeginWriteLine(string line, AsyncCallback callback, object state) { ... }

Client call: 

IAsyncResult result = writelineToLogfile.BeginInvoke(line, callback, state);

The return value from the above call is IAsyncResult which can be used to track and wait for Asynchronous call to complete. IAsyncResult has IsCompleted property which will tell whether the Asynchronous call is completed or not. IsCompleted can also be used in scenario like Polling technique where in the client can keep checking the return value of IsCompleted until the Asynchronous call is completed. There is also AsyncWaitHandle property which gives us a WaitHandle object which can be used to wait for the Asynchronous operation to complete. WaitHandle can also be used in scenario when the client will need to wait until all Asynchronous calls or a specific set of Asynchronous calls are completed. Variations of with WaitAll or WaitAny can be used for this.

To retrieve the return value when the Asynchronous operation completes, Call the EndMethodName by passing in the IASyncResult as input.

To block the client application execution until the Asynchronous call is completed, use either 1)  AsyncWaitHandle or  2) Call EndMethodName. EndMethodName will block the application execution until the Asynchronous call is completed.

The client applications which do not need to wait until Asynchronous call is completed can either use 1) polling technique or 2) provide an EndCallback which will then be called when the Asynchronous operation is completed.

Best of all, .Net also provides a means by which any synchronous call can be made Asynchronous using delegates. This in itself is a good topic and I will try covering this in a separate blog post.

That’s it for now and I will cover Event based Asynchronous programming in my next post.

Happy coding and Happy new year 2012!

Hi There,

I am Syam Pinnaka, Developer in IAM Services team at Microsoft.

In the last post we have seen how to search for and find a deleted AD Object. In this post let’s see how to restored a deleted AD Object using “Restore-ADObject” Cmdlet and C#.

1. Add a reference to below assemblies.

   using System.Management.Automation;
   using System.Management.Automation.Runspaces;

   Note: You can get the System.Management.Automation assembly from here.

2. Create an AD run space.

   private static InitialSessionState iss = null;
   private static Runspace myRunSpace = null;
   
   iss = InitialSessionState.CreateDefault();
   iss.ImportPSModule(new string[] { "activedirectory" });
   myRunSpace = RunspaceFactory.CreateRunspace(iss);
   myRunSpace.Open();

3. Create Pipeline.

   Pipeline pipeLine = myRunSpace.CreatePipeline();

4. Build “Get-ADObject” and “Restore-ADObject” commands.

   string filter = "(ObjectClass -eq 'group') -and (" + attributeName + " -like '" + attributeValue + "'" 
   + ") -and (isDeleted -eq 'TRUE')";
   
   string domain = “your-domain”;
   
   Command myCommand = new Command("Get-ADObject");
   myCommand.Parameters.Add("Filter", filter);
   myCommand.Parameters.Add("Server", domain);
   myCommand.Parameters.Add("IncludeDeletedObjects");
   
   pipeLine.Commands.Add(myCommand);
   
   Note: The above filter takes AD attributeName and attributeValue to search for an object. Also the above filter is targeted at searching for ‘groups’, if you want to find any object, you can removed this condition from the filter.
   
   Command restoreCommand = new Command("Restore-ADObject");
   pipeLine.Commands.Add(restoreCommand);

5. Run the command.

   Collection<PSObject> commandResults = pipeLine.Invoke();

6. Capture the results.
   foreach (PSObject cmdlet in commandResults)
   {
       string cmdletName = cmdlet.BaseObject.ToString();
       System.Diagnostics.Debug.Print(cmdletName);
   
       //do whatever you want with the results.
   }
   

That’s it and happy coding!

Hi There,

I am Syam Pinnaka, Developer in IAM Services team at Microsoft. In one of my recent projects I had a requirement to search for and restore a deleted AD object. AD Cmdlets provides a means for this using “Get-ADObject” and “Restore-ADObject”. However if you wanted to use these Cmdlets from C# here is how you do it.

1. Add a reference to below assemblies.

   using System.Management.Automation;
   using System.Management.Automation.Runspaces;

   Note: You can get the System.Management.Automation assembly from here.

2. Create an AD run space.

   private static InitialSessionState iss = null;
   private static Runspace myRunSpace = null;
   
   iss = InitialSessionState.CreateDefault();
   iss.ImportPSModule(new string[] { "activedirectory" });
   myRunSpace = RunspaceFactory.CreateRunspace(iss);
   myRunSpace.Open();

3. Create Pipeline.

   Pipeline pipeLine = myRunSpace.CreatePipeline();

4. Build “Get-ADObject” command.

   string filter = "(ObjectClass -eq 'group') -and (" + attributeName + " -like '" + attributeValue + "'" 

   + ") -and (isDeleted -eq 'TRUE')";
   
   string domain = “your-domain”;
   
   Command myCommand = new Command("Get-ADObject");
   myCommand.Parameters.Add("Filter", filter);
   myCommand.Parameters.Add("Server", domain);
   myCommand.Parameters.Add("IncludeDeletedObjects");
   
   pipeLine.Commands.Add(myCommand);

   Note: The above filter takes AD attributeName and attributeValue to search for an object. Also the above filter is targeted at searching for ‘groups’, if you want to find any object, you can removed this condition from the filter.

5. Run the command.

   Collection<PSObject> commandResults = pipeLine.Invoke();

6. Capture the results

   if (commandResults.Count > 1)
   {
       throw new Exception("Found more than one deleted group with '" + attributeName + "'='" 

   + attributeValue + "' in domain '" + domain + "'");
   }
   
   foreach (PSObject cmdlet in commandResults)
   {
       string cmdletName = cmdlet.BaseObject.ToString();
       System.Diagnostics.Debug.Print(cmdletName);
   
       //do whatever you want with the results.
   }

That’s it and Happy coding! I will show you how to restore a deleted AD object in my next post.

Technorati Tags: .NET,AD