Archive for the Category ◊ .Net ◊

Thursday, December 11th, 2014

Anonymous authentication gives users access to the public areas of your Web or FTP site without prompting them for a user name or password.

By default, IIS 7 uses Anonymous authentication. You must disable Anonymous authentication for any Web site, Web application, or Web service for which you want to enable other authentication methods such as Basic or Windows authentication.

The <anonymousAuthentication> element controls how Internet Information Services (IIS) 7 processes requests from anonymous users. You can modify the <anonymousAuthentication> element to disable Anonymous authentication, or you can configure Internet Information Services (IIS) to use a custom user account to process anonymous requests.

How to disable Anonymous Authentication

  1. Open Internet Information Services (IIS) Manager:
  • If you are using Windows Server 2012 or Windows Server 2012 R2:
    • On the taskbar, click Server Manager, click Tools, and then click Internet Information Services (IIS) Manager.
  • If you are using Windows 8 or Windows 8.1:
    • Hold down the Windows key, press the letter X, and then click Control Panel.
    • Click Administrative Tools, and then double-click Internet Information Services (IIS) Manager.
  • If you are using Windows Server 2008 or Windows Server 2008 R2:
    • On the taskbar, click Start, point to Administrative Tools, and then click Internet Information Services (IIS) Manager.
  • If you are using Windows Vista or Windows 7:
    • On the taskbar, click Start, and then click Control Panel.
    • Double-click Administrative Tools, and then double-click Internet Information Services (IIS) Manager.
  1. In the Connections pane, expand the server name, expand Sites, and go to the level in the hierarchy pane that you want to configure, and then click the Web site or Web application.
  2. Scroll to the Security section in the Home pane, and then double-click Authentication.
  3. In the Authentication pane, select Anonymous Authentication, and then click Disable in the Actions pane.

 

 

How to change Anonymous Authentication credentials from the IUSR Account

  1. Open Internet Information Services (IIS) Manager:
  • If you are using Windows Server 2012 or Windows Server 2012 R2:
    • On the taskbar, click Server Manager, click Tools, and then click Internet Information Services (IIS) Manager.
  • If you are using Windows 8 or Windows 8.1:
    • Hold down the Windows key, press the letter X, and then click Control Panel.
    • Click Administrative Tools, and then double-click Internet Information Services (IIS) Manager.
  • If you are using Windows Server 2008 or Windows Server 2008 R2:
    • On the taskbar, click Start, point to Administrative Tools, and then click Internet Information Services (IIS) Manager.
  • If you are using Windows Vista or Windows 7:
    • On the taskbar, click Start, and then click Control Panel.
    • Double-click Administrative Tools, and then double-click Internet Information Services (IIS) Manager.
  1. In the Connections pane, expand the server name, expand Sites, and navigate to the level in the hierarchy pane that you want to configure, and then click the Web site or Web application.
  2. Scroll to the Security section in the Home pane, and then double-click Authentication.
  3. In the Authentication pane, select Anonymous Authentication, and then click Edit… in the Actions pane.
  4. In the Edit Anonymous Authentication Credentials dialog box, do one of the following:
  • Select Application pool identity to use the identity set for the application pool, and then click OK.

 

    • Click Set…, and then in the Set Credentials dialog box, enter the user name for the account in the User name box, enter the password for the account in the Password and Confirm password boxes, click OK, and then click OK again.

 

        Note: If you use this procedure, only grant the new account minimal privileges on the IIS server computer.

References:

  1. http://technet.microsoft.com

 

 

Author:
Monday, December 08th, 2014
Dictionary Initializer in C# 6.0 – Some details
You might already know that C# 6.0 provides us a new of initializing dictionary.
We can initialize like we do with other collection objects.

Below code snippet shows both ways of initializing a dictionary.

 
	Old way
               
	public IDictionary<string, string> GetDictionary()
	{
		return new Dictionary<string, string> {
				{"Language1", "C#" },
				{"Language2", "Java"}
		};
	}				
                
	New way
		 
	public IDictionary<string, string> GetDictionary()
	{
		return new Dictionary<string, string> {
			["Language1"] = "C#" ,
			[ "Language2"] ="Java"
		};
	}			
                

You can see how compiler treats pre-C# 6.0 code in the below code snippet

 
               
	public IDictionary<string, string> GetDictionary()
	{
		  Dictionary<string, string> dictionary = new Dictionary<string, string>();
		  dictionary.Add("Language1", "C#");
		  dictionary.Add("Language2", "Java");
		  return (IDictionary<string, string>) dictionary;
	}
                

As you observe it calls Add method for every item in our dictionary. We have initialized dictionary with two items, so it calls add method twice.

If you see the compiler code for new way of dictionary initialization

 
               
	public IDictionary<string, string> GetDictionary()
	{
		  Dictionary<string, string> dictionary = new Dictionary<string, string>();
		  dictionary["Language1"] = "C#";
		  dictionary["Language2"] = "Java";
		  return (IDictionary<string, string>) dictionary;
	}
                

There is no call for add method. It’s the same way it handles other collections. Its in line with json notation.

If you add one more item with the same id while initializing it will overwrite the previous value, so in below code, new value of “Language2″ will be “Php” and not “Java”

 
               
	public IDictionary<string, string> GetDictionary()
	{
		return new Dictionary<string, string>
		{
			["Language1"] = "C#",
			["Language2"] = "Java",
			["Language2"] = "Php"
		};
	}
                

But in old way it will result in a runtime exception. Because when add method of dictionary is called it checks if the key is already present and throws exception since its a duplicate key.

 

Category: .Net  | 2 Comments
Author:
Monday, December 08th, 2014
Internals of Null propagating operator(?.) in C# 6.0

If we do not do null checks on our objects we often run into NullReferenceExceptions. Wouldn’t it be good if compiler simply return null if an object you are referring to is null, with out performing any action on that object which I intended to do.

Well, C# 6.0 provides a new operator(?.) named ‘Null Propagating Operator’.

The main idea behind introducing this operator is to reduce the lines of code we write in doing null checks. As the name says it propagates the null value instead of doing further operation on the object which is null.

Lets see how compiler treats it.

I have a customer class which has a property MyName of type Name
snippet below shows this code

 
               
	public class Customer
	{
		public Name MyName { get; } 
	}

	public class Name
	{
		public string  FirstName { get; set; } = "Sunil";

		public string LastName { get; set; } = "Kumar";

		public string SurName { get; set; } = "Sharma";
	}
                

We need to get the customer’s first name, method in below code snippet does that

 
               
	public string GetFirstName(Customer customer)
	{
		string name = null;

		if (customer != null && customer.MyName != null)
			name = customer.MyName.FirstName;

		return name;

	}
                

This is how compiler sees it

 
               
	public string GetFirstName(Customer customer)
	{
		  string str = (string) null;
		  if (customer != null && customer.MyName != null)
			str = customer.MyName.FirstName;
		  return str;
	}
                

Now lets modify the method using null propagating operator

 
               
	public string GetFirstName(Customer customer)
	{
		return customer?.MyName?.FirstName;
	}
                

This is how compiler sees it

 
               
	public string GetFirstName(Customer customer)
	{
		  string str;
		  if (customer == null)
		  {
			str = (string) null;
		  }
		  else
		  {
			Name myName = customer.MyName;
			str = myName != null ? myName.FirstName : (string) null;
		  }
		  return str;
	}
                

If you observe there is not much change in how the compiler handles this new operator compared to explicit null checks. Compiler is intern doing the required null checks for you. As said earlier it reduces the number of lines of code and makes your code much more readable

But the interesting thing here is, where does this NullReferenceException occur?. Is it in compiler or JIT?
It gets generated at a much lower level. We need to know a bit about operating system jargon’s to understand this. Just to brief, when ever a thread tries to access an address, if that address in page table is not yet mapped to a virtual address then a page-fault is generated for which CLR responds by generating NullReferenceException.

Also there are lot of discussions happening on, whether to make this operator left-associative or right-associative. Click here for more interesting read.

 

Category: .Net  | 3 Comments
Friday, December 05th, 2014

Code-First has a set of default behaviours for the models that are refered to as conventions. EF 6 provides the ability to define your own custom conventions, which will be default behaviour for your models.

There are two main types of Conventions, Configuration Conventions and Model Conventions.In this blog, we will focus on Configuration Conventions. Configuration Conventions are a way to configure a set of objects, without overriding the explicit configuration provided in the Fluent API.

There are two ways how you define Convention

Define in OnModelCreating(...)
Or
Inherit from System.Data.Entity.ModelConfiguration.Conventions.Convention and add it to modelbuilder.Conventions.Add()

I have two problems that i will be solving in this blogpost

1) Consistency – All decimal columns must have precision of (10,2)
2) All table names must have Title Casing with Pluralized.

Consistency
Traditionally, Since the release of EF Codefirst 4.1 FluentApi, it has default behaviour of setting precision for decimal to (18,2), and now we want to change that EXPLICITY, prior to release of EF6, there is no way you could achieve it, other than manually configuring each type – decimal column using Fluent Api. With the power of EF6, we could do that in just one line of code and it affect all models which are having decimal properties.

Here is our domain model:

public class Person
        {
            public Guid PersonId { get; set; }
            public decimal Salary { get; set; }
            //other properties omitted for clarity
        }

        public class Student
        {
            public int Id;
            public decimal Average { get; set; }
            //other properties omitted for clarity
        }

With our models in place, this is how you configure decimal as below

public class MyContext : DbContext
        {
            protected override void OnModelCreating(DbModelBuilder modelBuilder)
            {
                modelBuilder.Properties<decimal>().Configure(x => x.HasPrecision(10, 2));
            }
        }

With this configuration in place, EF Runtime will apply precision to (10,2) for all decimal properties.

All table names must have Title Casing with Pluralized.

I want all tables in my database to have Title Cased, So In order to achive we can configure all types in model builder Or create a class that inherit from Convention Class and add it to modelbuilder.Conventions as below.

public class TableConvention : Convention
        {
            private static readonly TextInfo _textInfo = new CultureInfo("en-US", false).TextInfo;
            public TableConvention()
            {
                this.Types().Configure(x =>
                {
                    string declaringType = x.ClrType.Name;
                    x.ToTable(new EnglishPluralizationService().Pluralize(_textInfo.ToTitleCase(declaringType)));
                });
            }
        }

Add it to model builder now

public class MyContext : DbContext
        {
            protected override void OnModelCreating(DbModelBuilder modelBuilder)
            {
                modelBuilder.Conventions.Add(new TableConvention());
            }
        }

With this convention in place, we enforce all types defined, must Title Cased & Pluralized in our database. Hope this helps, In my next blog post, we will see how to create more complex conventions on SSpace and OSpace.

Category: .Net | Tags:  | Leave a Comment
Thursday, December 04th, 2014

ORM’s can help address impedance mismatch between datastore and object models by making developer life much simpler, which means you dont have write sql queries and create mappings between columns in datastore to the properties/fields defined in object models.So we are now in a position that we dont worry about sql at all, because ORM’s are very handy to use in situations like this. But remember ORM’s are very powerful,back from those days when Martin Fowler talked about Object Relational Patterns in his ground breaking book ‘Patterns of Enterprise Application Architecture’. It is very important for us, to understand how good they are by saving Development Time and how bad if you dont understand them correctly. But not knowing their pitfalls can put applications pay the penality right away., And Yes I am talking about Performance Penality. One of the most common performance issues that comes is “SELECT N+1″ Problem.

Select N+1 is a data access anti-pattern where the database is accessed in a suboptimal way. This problem is being caused mainly because most of the ORMs out there are enabling lazy loading behavior by default. Detecting Select N+1 problem usually means that the data fetch strategy of the application can be optimized. By default traversing a collection of related objects would lead to the execution of an additional query for each object in the collection. While this would still work, it is highly inefficient. Lets understand better with the example.

        public class Student
        {
            public int StudentId { get; set; }
            public string StudentName { get; set; }
            public int StandardId { get; set; }
            public virtual Standard Standard { get; set; }
        }

        public class Standard
        {
            public Standard()
            {
                this.Students = new HashSet<Student>();
            }
            public int StandardId { get; set; }
            public string StandardName { get; set; }
            public string Description { get; set; }
            public virtual ICollection<Student> Students { get; set; }
        }

        public class StudentContext : DbContext
        {
            public DbSet<Student> Students { get; set; }
            public DbSet<Standard> Standards { get; set; }
            protected override void OnModelCreating(DbModelBuilder modelBuilder)
            {
                modelBuilder.Entity<Student>()
                            .HasRequired<Standard>(s => s.Standard)
                            .WithMany(s => s.Students)
                            .HasForeignKey(s => s.StandardId);

            }
        }

To summarize above code, I defined 1:M relationship between Standard(1) and Students(M). To simulate SELECT N+1, Lets fetch standard and its associated students as below.

using (var ctx = new StudentContext())
            {
                var standards = ctx.Standards;
                foreach (Standard standard in standards)
                {
                    Console.WriteLine(standard.StandardName);
                    foreach (Student student in standard.Students)
                    {
                        Console.Write("\t");
                        Console.Write(student.StudentName);
                    }
                }
            }

Assume that I have 5 Standards and each standard containing 50 students, If you run the profile, you will notice
(1) + (5) Queries generated.. Very strange right., outer foreach above generates 1(get standard) + inner for each generate (5) Queries as below.

SELECT * FROM Standard
SELECT * FROM Students WHERE StandardId = 1
SELECT * FROM Students WHERE StandardId = 2
SELECT * FROM Students WHERE StandardId = 3
SELECT * FROM Students WHERE StandardId = 4
SELECT * FROM Students WHERE StandardId = 5

Although this looks like a very small issue, it blows up when you try to access large amount of data, totally killing the performance of the application, In order to overcome this, we have to eager load the Students. as below

var standards = ctx.Standards;

                foreach (Standard standard in standards.Include(x=>x.Students))
                {
                    Console.WriteLine(standard.StandardName);
                    foreach (Student student in standard.Students)
                    {
                        Console.Write("\t");
                        Console.Write(student.StudentName);
                    }
                }

Above code generates just ’1′ query as below. Superb right !!!! Atleast now you should agree that ORM’s are very powerful :)

SELECT
    [Project1].[StandardId] AS [StandardId],
    [Project1].[StandardName] AS [StandardName],
    [Project1].[Description] AS [Description],
    [Project1].[C1] AS [C1],
    [Project1].[StudentId] AS [StudentId],
    [Project1].[StudentName] AS [StudentName],
    [Project1].[StandardId1] AS [StandardId1]
    FROM ( SELECT
        [Extent1].[StandardId] AS [StandardId],
        [Extent1].[StandardName] AS [StandardName],
        [Extent1].[Description] AS [Description],
        [Extent2].[StudentId] AS [StudentId],
        [Extent2].[StudentName] AS [StudentName],
        [Extent2].[StandardId] AS [StandardId1],
        CASE WHEN ([Extent2].[StudentId] IS NULL) THEN CAST(NULL AS int) ELSE 1
END AS [C1]
        FROM  [dbo].[Standards] AS [Extent1]
        LEFT OUTER JOIN [dbo].[Students] AS [Extent2] ON [Extent1].[StandardId]
= [Extent2].[StandardId]
    )  AS [Project1]
    ORDER BY [Project1].[StandardId] ASC, [Project1].[C1] ASC
Category: .Net | Tags:  | Leave a Comment
Monday, December 01st, 2014

This article explains in which situation we go for setting SPN and delegation.

It also focuses on what Kerberos authentication stands for.

 

Let us say that we have 4 machines set up for a client

  1. Dmbberg   –Machine where the client performs business calculation/operation through the xl sheet. XL sheet contains the macro. When xl sheet changes are made and submitted, a call is made to the web services which is deployed in ‘Dmweb’
  2. Dmweb  — Machine where the main web services are hosted
  3. Dmprod – Machine where dependent web services are hosted. Call is made from ‘Dmweb’ to ‘Dmprod’
  4. Dmdb   — Database machine

1

  • Now when the xl sheet values are submitted, web service call is made, which will invoke ‘Dmweb’ web service. This in turn calls ‘Dmprod’ services where few more services are hosted. ‘Dmprod’ machine services writes the values to the data base present in ‘dmdb’.
  • You  have observed that there are 4 different call. i.e Dmbberg > Dmweb > Dmprod > Dmdb.
  • In this scenario we need to have secure web service calls. i.e call has to be made for those  user who is a part of the domain and their name should be listed in active directory.

 

  • But just with the windows authentication turned on,  successive calls to 2 different machines can be made (i.e from ‘Dmbberg > Dmweb’). But at the moment it tries to access the 3rd machine service (i.e from ‘Dmweb > Dmprod’) you will receive an error similar to this :

 2

3

  • This is called  ‘Double hop’ issue. Kerberos Double Hop is a term used to describe the method of maintaining the client’s Kerberos authentication credentials over two or more connections. In this fashion we can retain the user’s credentials and act on behalf of the user in further connections to other servers.
  • So in this scenario, we need to delegate the user from one machine to another. This is where ‘SPN , Delegation and Kerberos authentication’ comes into picture.  In this case we have to  turn on the impersonation. By default it is Disabled.

 4

  • Impersonation enables ASP.NET to execute code and access resources in the context of an authenticated and authorized user, but only on the server where ASP.NET is running. To access resources located on another computer on behalf of an impersonated user requires authentication delegation (or delegation for short). You can think of delegation as a more powerful form of impersonation, as it enables impersonation across a network.
  • For delegation to work, ASP.NET must be able to authenticate against the remote server using the credentials of the client you wish to delegate. However, there are numerous factors that determine if delegation can occur, such as Internet Information Services (IIS) authentication scheme, ASP.NET process identity, and the operating systems of the machines involved.

We can initiate this process by first setting  custom account for the application pool so that this account will be registered for all the machines.

5

In my next article I will share my previous experience of setting SPN and Delegation

Category: .Net  | Leave a Comment
Tuesday, November 18th, 2014

In my previous blog post, we saw what ngen is all about and how it helps improve application start up performance. In this blog post, we will see how to use Ngen in Entity Framework based applications. Lets get started.

PS: Prior to Entity Framework 6.0, Core libraries of Entity Framework runtime were part of .NET Framework, which means native images were generated automatically. From EF 6.0, Whole runtime is part of nuget package (comprising of EntityFramework.dll & EntityFramework.SqlServer.dll)

I defined StudentContext in Main.cs as below , lets keep model simple as our focus is on ngen)

        public class StudentContext : DbContext
        {
            public DbSet<Student> Students;
        }

        public class Student
        {
            public int Id { get; set; }
            public string Name { get; set; }
        }

To Evaluate application startup, lets use Windows Performance Recorder , that ships with Windows ADK, For this phase of demo, i have not ngen’d EF at all.,As you see below, clrjit.dll starts doing JIT Compilation.
With clrjit.dll

With ngen:

  • Open VS Developer Command Prompt in Admin mode
  • Navigate to location where EntityFramework.dll resides
  • Run Command “ngen install EntityFramework.dll” as below

ngen_issue_command

Running WPA again, yield below results and its clear that there is no clrjit.dll
Without_JIT

As you see, its very clear, there is no clrjit.dll, which infact means that clr is using native image cache of EntityFramework.dll instead of JITting again. Inorder to see where is the cache located, we need to issue command as

ngen display EntityFramework.dll

after_using_ngen_display

Summary:

Ngen.exe is very effective in saving performance during application startup and in some cases it can even reduce memory usage. B/w multiple applications can use the same assembly which is already ngen’ed., so that they can get benefits of low memory footprint and fast app startup.

Category: .Net | Tags: ,  | Leave a Comment
Monday, November 17th, 2014

For all new bees who have not heard of ngen, ngen means Native Image Generator (Ngen.exe) is a tool provided by Microsoft to improve the performance of application during application start up. Ngen comes with .NET Framework itself and is used to Compile IL code to processor-specific machine code, and installs them into native image cache on local computer.

With out ngen: Once the application starts up, CLR’s JIT compiler(clrjit.dll) will be invoked ON DEMAND to convert IL code(usually byte code) to native instruction set, which at times take significant amount of time., delaying application startup. This is one situation where ngen comes handy.

How it works ?
Once you invoke ngen.exe on executable(.exe) or dll, exe or dll have their IL gets compiled to native code. A new assembly file containing only native code is created by Ngen.exe., and will be located in a directory %SystemRoot%\Assembly\NativeImages_v4.0.XXXXX_64. The directory name include version of CLR and information header denoting whether native code is compiler for 32 bit or 64 bit. The good part about this is if we use ngen for one of our dll, all its dependencies will be automatically ngen’d. This is the significant change from .NET 4 framework, Having said this, once we run execute application, CLR will do a check whether the application is ngen’d or not by checking corresponding native image file in the said directory(above)., If its not found, CLR JIT compiler compiles the IL code. Otherwise CLR uses the native image code generated by ngen, and CLR does not have to compile the methods in the native image file during runtime. Thats it, this is how ngen works. In my next article i will demonstrate how to use ngen through commandline and interpret the results of the application performance.

Category: .Net | Tags:  | Leave a Comment
Sunday, November 09th, 2014

Few days ago I was looking at some cool new features that would be introduced in C# 6.0. Although mentioning about all the features in a single blog would be difficult, I would like to share the improvisations made to the most commonly used functionalities that we as developers use very frequently.

Initializing Auto Properties:

C# 6.0 allows developers to declare and initialize auto properties just like fields.

public class Employee

{

public string Id { get; } = “PROXXX”;

public string Name  { get; set; } = “XXXXXX”;

}

 

Primary Constructors

This is a very useful feature for developers since it helps us overcome the difficulty of assigning values of constructor parameters to fields in a class. The primary constructors makes the initialization process much simpler. The below code snippet explains how to declare primary constructors.

 

public class Employee(int id, string name)    // Primary Constructor declaration

{

public int Id { get; } = id;

public string Name  { get; set; } = name;

}

 

Accessing static methods:

The general way of accessing a static method is <StaticClassName>.<MethodName>. This is made even simpler in C# 6.0. All we need to do is declare the type in a using statement and all the static members of that type will be accessible.

 

using System.Console;

namespace ExploreCSharpSix

{

class Program

{

static void Main(string[] args)

{

WriteLine(“Welcome to Prowareness”);

}

}

}

 

Declaration Expressions:

This feature allows to declare local variables in the middle of an expression

 

Before C# 6.0:

public void ConvertStringToDatetime(string strDate)

{

strDate = “09/11/2014″;

DateTime result;

bool isParsed = DateTime.TryParse(strDate, out result);

}

 

C# 6.0:

 

public void ConvertStringToDatetime(string strDate)

{

strDate = “09/11/2014″;

bool isParsed = DateTime.TryParse(strDate, out Datetime result);

}

 

Category: .Net, General  | 4 Comments
Monday, November 03rd, 2014

This is a follow up to Microsoft Release Management from scratch – Part 1. In this post, we will look at the following things.

  1. Setup Users for Release Management
  2. Download installers for Release Management
  3. Install Release Management Server
  4. Verify Release Management Server was configured properly.
  5. Install Release Management Client
  6. Install Release Management Deployment Agent
  7. Verify Release Management Deployment was configured properly.

Release Management is a three step install – Release Mangement Server, Client and Deployment Agent.

1) Setup Users for Release Management

image

Create 3 users for Release management.

  1. RMServerDude – This user will be used to run the Release Management Server which will be installed.
  2. RMIntegrationDude – This user will be used to integrate Team Foundation Server and Release Management
  3. RMDeploymentAgentDude – This user will be used to run the Deployment agent.

2) Download installers for Release Management

Download the Release Management installers from here. Once download is completed, follow these steps.

3) Install Release Management Server

Click on rm_Server.exe.image

Agree to the terms and conditions and click on install.

image

On completion of installation, click on Launch.image

Once the installation is complete, the following screen pops up. For Release Management Services, use the user account RmServerDude which we created earlier. Give the port and the database details and click on Apply settings.image

On click of apply settings, we get this error. It is pretty straight forward. Release Management Server expects the user running its services to be an administrator.

image

image image

image

Now click on apply settings in the Release Management Server console.

image Now, the Release Management Server configuration succeeds.

4) Verify Release Management Server was configured properly.

Open IIS and click on Application pools. Verify ReleaseManagementAppPool is created.

image

Verify Release Management Website is created.

image

Verify ReleaseManagement database is created.image

5)Install Release Management Client

Click on rm_Client.exe

image

Agree to the terms and conditions and click on Install.image

image

image

Once the setup is complete, click on Launch.image

Configure the Release Management Client to the Release Management Server which was created. Give the Web Server Name and click on Ok. The Release Management client opens.

image

6)Install Release Management Deployment Agent

Click on the installer for Release Management Deployment Agent.image

Agree to the terms and conditions and click on Launch.

image

Configure the Deployment Agent. It is the agent who actually deploys software to the target machine. use the RMDeploymentAgentDude user to run the Deployment Agent. Also enter the Release Management Server URL.

image

This successfully configures the Release Management server.

image

 

7)Verify Release Management Deployment was configured properly.

fire up services.msc from the command prompt. Verify if Release Management Monitor is running as RmServerDude.

image

Verify if Microsoft Deployment Agent is running as RMDeploymentAgentDude.image 

This completes the Microsoft Release Management from scratch – Part 2. Watch out for this space for more updates.