(of course you could use the same script to run any program with any other user)

psexec -u "nt authority\network service" -i "c:\program files\internet explorer\iexplore.exe"
 

Function Set-ApplicationSettingConfigProperty
 {
 param (
 [parameter(Mandatory = $true)][ValidateScript ({Test-Path $_})][string] $PathToConfigFile,
 [parameter(Mandatory = $true)][string] $PropertyName,
 [parameter(Mandatory = $true)][string] $PropertyValue,
 [Parameter(Mandatory = $false)][Validatescript ({(Get-Service $_) -ne $null})][string] $NameOfServiceToRestart = $null)
 
 $configurationAppSettingXmlPath = "//configuration/appSettings"
 
 [xml] $configurationDocument = Get-Content $PathToConfigFile
 $appSettingsNode = $configurationDocument.SelectSingleNode($configurationAppSettingXmlPath)
 
 if($appSettingsNode -eq $null)
 {
 $(throw "App Settings Does not Exists! Invalid Configuration File.")
 }
 
 $nodeToUpdate = $configurationDocument.SelectSingleNode($configurationAppSettingXmlPath+"/add[@key='$PropertyName']")
 if($nodeToUpdate -ne $null)
 {
 Write-Host "[$PropertyName] Already exists, Removing it to re-set its value."
 $removedElement = $appSettingsNode.RemoveChild($nodeToUpdate)
 }
 
 Write-Host "Creating new Configuration Node."
 $newPropertyNode = $configurationDocument.CreateNode("element", "add","")
 
 Write-Host "Setting Node Attributes."
 $newPropertyNode.SetAttribute("key", $PropertyName)
 $newPropertyNode.SetAttribute("value", $PropertyValue)
 
 Write-Host "Appending Child to AppSettings."
 $appSettingsNode = $configurationDocument.SelectSingleNode($configurationAppSettingXmlPath).AppendChild($newPropertyNode)
 
 Write-Host "Adding new property into the configuration file."
 $configurationDocument.Save($PathToConfigFile)
 
 Write-Host "Property was Successfully Updated."
 
 if([string]::IsNullOrWhiteSpace($NameOfServiceToRestart) -eq $false)
 {
 Write-Host "Service [$NameOfServiceToRestart] was defined.., Restarting it"
 Restart-Service -Name $NameOfServiceToRestart 
 Write-Host "Service was Restarted..."
 }
 }

ChangeAppConfigProperty.ps1

Debugging remote processes (No Authentication)

Disclaimer!!

First I would like to make clarify that this is not intended
for production purposes, you should rely mostly on logging to diagnose and detect
issues on your applications… Debugging in production with intrusive programs is
strongly discouraged for live environments as they might cause users to get
hanged in debug breakpoints.  The steps
that I’m describing below I use them mostly when debugging onebox issues, this
is, that I’m debugging a virtual machine (that I own) where a set of components
(that I own) have been deployed.

This is a very powerful feature to know, sometimes you need
to debug your application on a remote machine, so here are the steps that you
need to do

Copy the remote debugger from your dev machine to the one
where the process you are intending to debug is located.  Note that the Remote Debugger is specific to
the version of visual studio that you will be using for the debugging session; these
are the typical locations for VS 2012/2013 (it may vary depending on your
installation):

Visual Studio 2012

C:\Program Files (x86)\Microsoft Visual Studio
11.0\Common7\IDE\Remote Debugger

Visual Studio 2013

C:\Program Files (x86)\Microsoft Visual Studio
12.0\Common7\IDE\Remote Debugger

The Remote debugger is not particularly big 50-ish MBs so
copying it into the target machine should not be a big problem.

Now run msvsmon.exe. This should open the following Window

Now go to Tools->Options->No Authentication.

Now you can go to visual studio (on your dev machine) and go
to attach to process, from the transport drop down select Remote, and then use
the full name with the port as displayed in the msvsmon.exe in the Qualifier textbox,
now press enter and you should see the processes show up in the “Available Processes”
go to the process that you want to debug and then click on the Attach button.

Note:

As with any debugging
you will need the PDBs of the dll that you are trying to debug, for more
information about PDBs you can read this
fantastic article from wintellect’s John Robbins

My Breakpoint is Not Working!!!  “:(

Learn to love the Modules window! Whenever you are debugging
a process and your breakpoint is not breaking and there is an exclamation mark
on the breakpoint saying that no symbols have been loaded for the current process
it usually means that!  This means that
Visual Studio was unable to find the PDBs and therefore Visual studio cannot infer
the mapping between your binary and your code.

Now… Q: how can you find out where the dlls are being pulled
from and where it is trying to get the PDBs from? A: The Modules Window!

When debugging: Go to Debug->Windows->Modules… your
breakpoint is not working? Go to the modules window find your dll, and check
the reason why the PDBs are not getting loaded, if you have the PDBs at hand
you can right click and do “Load from Location” and then you can tell it where
to load it from.

Loading Symbols Automatically

In visual studio you can define paths from where to load
PDBs dynamically, you do this by going into Tools->Options, then from the
options on the left select Debugging->Symbols, and in here you can define a
location where your build system might store the PDBs automatically.

First you need to install the latest "Windows Azure Active Directory Module for Windows PowerShell".  The commands can be installed from here.

1. Download the ps1 attached to this article
2. Run the "Windows Azure Active Directory Module for Windows PowerShell", this should open a PowerShell window
3. Import-Module <FullPathToAttachedFile>
   1. Example: Import-Module C:\temp\SetLicenseToUsersInSecurityGroup.ps1
4. Set-LicenseToUsersInSecurityGroup -UserName <TenantAdminUserName> -Password <TenantadminPassword> -GroupName <NameOfTheGroup> -AccountSkuId <accountSkuToAddLicensesTo>
   1. You may get the AccountSkuId by running the following command: Get-MsolAccountSku
5. After running this command you should get a confirmation of the users that were licensed.

Important Notes:

• Users that were already licensed will not be changed, this is, this script will not remove licenses to users that were removed from the Security Group
• Further changes on the Security Group will not reflect any changes in licenses
• You will need PowerShell 3.0

References:

• How to Assign EMS Licenses Using the Azure Portal

• Office 365 Assign Licenses Based on Groups Using PowerShell

Function Set-LicenseToUsersInSecurityGroup
 {
 param (
 [parameter(Mandatory = $true)][string] $UserName,
 [parameter(Mandatory = $true)][string] $Password,
 [parameter(Mandatory = $true)][string] $GroupName,
 [parameter(Mandatory = $true)][string] $AccountSkuId)
 
 Import-Module MSOnline
 
 $securePassword = ConvertTo-SecureString $Password -AsPlainText -Force
 $userCredentials = New-Object System.Management.Automation.PSCredential($UserName, $securePassword)
 Connect-MsolService -Credential $userCredentials
 
 $groupId = (Get-MsolGroup | Where-Object {$_.DisplayName -eq $GroupName}).ObjectId
 $accountSku = Get-MsolAccountSku | Where-Object {$_.AccountSKUID -eq $AccountSkuId}
 
 if($accountSku -eq $null)
 { 
 Write-Error 'Invalid Account Sku, Please get the account information from Get-MsolAccountSku'
 RETURN
 }
 
 Write-Output "Getting unlicensed users for Group Guid: $GroupID"
 
 $usersInGroup = (Get-MsolGroupMember -GroupObjectId $groupId -All).EmailAddress
 
 Write-Output 'Setting license to: ' $usersInGroup.Count
 foreach ($currentUserInGroup in $usersInGroup) 
 {
 try 
 {
 $currentUser = Get-MsolUser -UserPrincipalName $currentUserInGroup
 if($currentUser.UsageLocation -eq $null)
 {
 Write-Warning "Current User $currentUserInGroup does not have Usage Location, please set it using Set-MsolUser commandlet"
 continue;
 }
 
 if(($currentUser).Licenses | Where-Object {$_.AccountSkuId -eq $accountSku.AccountSkuId})
 {
 Write-Warning "Current User $currentUserInGroup is Already Licensed."
 continue;
 }
 
 Set-MsolUserLicense -UserPrincipalName $currentUserInGroup -AddLicenses $accountSku.AccountSkuId -ErrorAction Stop -WarningAction Stop
 Write-Output "Successfully licensed $currentUserInGroup with $AccountSkuId"
 } 
 catch 
 {
 Write-Warning "Error when licensing $currentUserInGroup"
 }
 }
 }

SetLicenseToUsersInSecurityGroup.ps1

C:\windows\system32\inetsrv\appcmd.exe list wp

This command will list all the available application pools along with their process Id, now you can go and attach to the process specific to the application pool you are trying to debug

[Reflection.Assembly]::LoadWithPartialName("System.EnterpriseServices") | Out-Null 
[System.EnterpriseServices.Internal.Publish] $publish = new-object System.EnterpriseServices.Internal.Publish
$publish.GacInstall(<<FullFilePathToTheDll>>)
 

This has to do very little with native PowerShell but rather with instantiating and using .NET libraries from PowerShell

Let's say that you have:

• DLLYouWantToDebug.dll
• DLLYouWantToDebug.pdb

 Then you will create a new text file with the same name as the dll you are trying to debug but with "ini" extension, example:

• DLLYouWantToDebug.ini

Open this file with Notepad and insert the following text in it:

[.NET Framework Debugging Control]
GenerateTrackingInfo=1
AllowOptimize=0

This will override the optimization flag and then you will be able to see all the variable values

Disclaimer!

Please note that this is not intended for production usage!

References

https://msdn.microsoft.com/en-us/library/9dd8z24x(v=vs.110).aspx

The following PowerShell will disable the optimization for the files in a folder or a specific dll/exe.

Function Set-OptimizationConfigurationFiles
 {
 param (
 [parameter(Mandatory = $true)][ValidateScript ({Test-Path $_})][string] $PathToDeploymentFolder,
 [parameter(Mandatory = $false)][string] $SpecificDll)
 
 $allDllFiles = Get-ChildItem -Path $pathToDeploymentFolder | Where-Object {($_.Name -like '*.dll' -or $_.Name -like '*.exe') -and ($SpecificDll -eq $null -or $_.Name -eq $SpecificDll)}
 
 foreach($currentDllFile in $allDllFiles)
 {
 $fileName = $currentDllFile.BaseName
 $iniFullFileName = $currentDllFile.DirectoryName + '\' + $fileName + '.ini'
 
 '[.NET Framework Debugging Control]' > $inifullFileName
 'GenerateTrackingInfo=1' >> $inifullFileName
 'AllowOptimize=0' >> $inifullFileName
 }
 }

I was inspired to open this blog from all the day-to-day experiences of a normal developer.