#112: How to handle xml document in Powershell?

 In PowerShell, you can handle XML data using various cmdlets and methods provided by the .NET Framework. Here's a basic guide on how to handle XML with PowerShell:

Loading XML Data:

You can load XML data from a file or a string using the Get-Content cmdlet and then convert it to an XML object using the Select-Xml cmdlet or the [xml] type accelerator.

Example:

# Load XML from a file

$xmlContent = Get-Content -Path "C:\path\to\file.xml"

# Convert XML content to an XML object

$xmlObject = [xml]$xmlContent

Accessing XML Elements and Attributes:

You can access XML elements and attributes using dot notation or by using XPath expressions.

Example:

# Access elements using dot notation

$elementValue = $xmlObject.Root.Element.SubElement.InnerText

# Access elements using XPath

$elementValue = $xmlObject.SelectSingleNode("/Root/Element/SubElement").InnerText

Modifying XML Data:

You can modify XML data by assigning new values to elements and attributes.

Example: 

# Modify element value

$xmlObject.Root.Element.SubElement.InnerText = "New Value"

# Add new element

$newElement = $xmlObject.CreateElement("NewElement")

$newElement.InnerText = "New Element Value"

$xmlObject.Root.Element.AppendChild($newElement)

Saving XML Data:

You can save modified XML data to a file using the Save method.

Example: 

$xmlObject.Save("C:\path\to\modified_file.xml")

Example:

Here's a simple example demonstrating loading XML from a file, accessing elements, modifying data, and saving the changes:

Example: 

# Load XML from a file

$xmlContent = Get-Content -Path "C:\path\to\file.xml"

$xmlObject = [xml]$xmlContent

# Access and modify XML data

$xmlObject.Root.Element.SubElement.InnerText = "New Value"

# Save modified XML to a new file

$xmlObject.Save("C:\path\to\modified_file.xml")

This example showcases some common operations you can perform with XML data in PowerShell. Depending on your specific requirements, you can use additional cmdlets and methods to handle XML data effectively.

Hope you enjoyed this article. 

Thanks!!

#111: Find the list of all the permissions on a directory using PowerShell?

Windows permissions are sometimes very complex to understand.

Below snippet can be used to get the list of all the permissions list:

# Define the directory path to inspect

$directoryPath = "C:\MyDirectory"

# Get ACLs for the directory and its subdirectories

$directoryACLs = Get-ChildItem -Path $directoryPath -Recurse |

    Get-Acl |

    Select-Object -ExpandProperty Access

# Output information about each ACL

foreach ($acl in $directoryACLs) {

    Write-Output "Path: $($acl.Path)"

    Write-Output "IdentityReference: $($acl.IdentityReference)"

    Write-Output "FileSystemRights: $($acl.FileSystemRights)"

    Write-Output "AccessControlType: $($acl.AccessControlType)"

    Write-Output "IsInherited: $($acl.IsInherited)"

    Write-Output "-----------------------------"

}

Thanks!!

#110: How to search a string in all files in a folder recursively using Powershell?

 Sometimes, we run into a situation where we are looking for certain entries in all files in a directory and withing all the directories. Below is a small code snippet that might help:

# Define the folder path to search

$folderPath = "C:\Path\To\Your\Folder"

# Define the string to search for

$searchString = "your_search_string_here"

# Search for the string in all files recursively

Get-ChildItem -Path $folderPath -Recurse |

    Where-Object { !$_.PSIsContainer } |

    ForEach-Object {

        $filePath = $_.FullName

        $content = Get-Content -Path $filePath -Raw

        if ($content -match $searchString) {

            Write-Output "Found '$searchString' in file: $filePath"

        }

    }

Thanks!!

#109: How to pediodically cleanup recycle bin using Powershell

Sometime, we accidently delete a big file that is left over in recycle bin. Whether you are using a server or laptop, this might be useful.
You can use PowerShell to periodically clean up the Recycle Bin by deleting its contents. Here's a script that you can schedule to run at specified intervals to perform this cleanup:

# Function to clean up Recycle Bin

function Clean-RecycleBin {

    # Get Recycle Bin items

    $recycleBinItems = Get-ChildItem -Path $env:USERPROFILE\RecycleBin -Force

    # Delete Recycle Bin items

    foreach ($item in $recycleBinItems) {

        Remove-Item -Path $item.FullName -Force -Recurse

    }

    Write-Output "Recycle Bin cleaned up successfully."

}

# Call the function to clean up Recycle Bin

Clean-RecycleBin

Save this script with a .ps1 extension (e.g., Cleanup-RecycleBin.ps1). Then, you can schedule it to run at specified intervals using Task Scheduler in Windows.

Here's how you can schedule it:

1. Open Task Scheduler.

2. Click on "Create Basic Task" or "Create Task" from the right-hand pane.

3. Follow the wizard to specify a name and description for the task.

4. In the "Action" tab, choose "Start a program" and specify the path to PowerShell (C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe).

5. In the "Add arguments" field, specify the path to the script you saved earlier (e.g., C:\Path\To\Script\Cleanup-RecycleBin.ps1).

5. Set the schedule for the task (daily, weekly, etc.).

6. Complete the wizard to create the task.

Thanks!!

#108: How to find the version of .NET installed using Powershell

Below is small snippet that might help you in this case. 

# Get installed versions of .NET Framework

$dotNetVersions = Get-ChildItem 'HKLM:\SOFTWARE\Microsoft\NET Framework Setup\NDP' -Recurse | Get-ItemProperty -Name Version -ErrorAction SilentlyContinue | Where-Object { $_.Version -match '^4.' -or $_.Version -eq 'v2.0.50727' }

# Output information about each installed .NET Framework version

foreach ($version in $dotNetVersions) {

    Write-Output ".NET Framework Version: $($version.Version)"

    Write-Output "-----------------------------"

}

#107: Find list of all the applications installed in your system using Powershell

Below code can be quick and easy to get the list. 

# Get all installed applications

$installedApplications = Get-WmiObject -Class Win32_Product

# Output information about each installed application

foreach ($app in $installedApplications) {

    Write-Output "Name: $($app.Name)"

    Write-Output "Version: $($app.Version)"

    Write-Output "Vendor: $($app.Vendor)"

    Write-Output "InstallDate: $($app.InstallDate)"

    Write-Output "-----------------------------"

}

As you know, use $app object and get more and more details that written above. 

If this one does not work for some reason, you can try another one: 
Somehow it runs faster for me than the above one.

# Define the registry path where installed applications are stored

$registryPath = "HKLM:\Software\Microsoft\Windows\CurrentVersion\Uninstall\*"

# Get all installed applications from the registry

$installedApplications = Get-ItemProperty -Path $registryPath |

    Where-Object { $_.DisplayName -and $_.DisplayName -ne "" } |

    Select-Object DisplayName, DisplayVersion, Publisher, InstallDate

# Output information about each installed application

foreach ($app in $installedApplications) {

    Write-Output "Name: $($app.DisplayName)"

    Write-Output "Version: $($app.DisplayVersion)"

    Write-Output "Publisher: $($app.Publisher)"

    Write-Output "InstallDate: $($app.InstallDate)"

    Write-Output "-----------------------------"

}

Hope you liked this post.

Thanks!!

#106: Get list of all the USB devices installed in you system using Powershell

Below is small snippet that can be used to get the list of all the usb devices installed.  

# Get all USB devices

$usbDevices = Get-PnpDevice -Class USB

# Output information about each USB device

foreach ($device in $usbDevices) {

    Write-Output "Device ID: $($device.InstanceId)"

    Write-Output "Description: $($device.Description)"

    Write-Output "Manufacturer: $($device.Manufacturer)"

    Write-Output "Status: $($device.Status)"

    Write-Output "-----------------------------"

}

Hope this was easy to understand the code. 

Thanks!

#105: Get list of all the monitors installed in your system using Powershell

Welcome back!

Today, I want to provide a small snippet that could list all the monitors installed in you system.

# Get all monitors

$monitors = Get-WmiObject -Namespace root\cimv2 -Class Win32_DesktopMonitor

# Output information about each monitor

foreach ($monitor in $monitors) {

   

    Write-Output "Monitor Name: $($monitor.Name)"

    Write-Output "Monitor Manufacturer: $($monitor.Manufacturer)"

    Write-Output "Monitor Screen Height: $($monitor.ScreenHeight)"

    Write-Output "Monitor Screen Width: $($monitor.ScreenWidth)"

    Write-Output "-----------------------------"

}

This was quite quick and easy.

Thanks!

#104: Get all the network cards installed in system using PowerShell

Below is small snippet that gives you info about all the network cards installed on your system. 

# Get all network adapters

$networkAdapters = Get-NetAdapter

# Output information about each network adapter

foreach ($adapter in $networkAdapters) {

    Write-Output "Name: $($adapter.Name)"

    Write-Output "Description: $($adapter.Description)"

    Write-Output "Interface Index: $($adapter.InterfaceIndex)"

    Write-Output "MAC Address: $($adapter.MacAddress)"

    Write-Output "Status: $($adapter.Status)"

    Write-Output "-----------------------------"

}

As you know, $adapter used above can be used to get more and more details you want. 

Hope this was quick and easy. 

Thanks!

#103: Get all the sound cards installed on system

 Sometimes, we get into situation where we are developiong something that requires listing all the soundcards in the system. You can do it easily with below code: 

# Get all sound devices

$soundDevices = Get-PnpDevice -Class AudioEndpoint

# Output information about each sound device

foreach ($device in $soundDevices) {

    Write-Output "Device ID: $($device.DeviceID)"

    Write-Output "Description: $($device.Description)"

    Write-Output "Manufacturer: $($device.Manufacturer)"

    Write-Output "Driver Version: $($device.DriverVersion)"

    Write-Output "Status: $($device.Status)"

    Write-Output "-----------------------------"

}

w code:        

#102: Hash Tables in Powershell

In PowerShell, a hash table, also known as an associative array or dictionary in other programming languages, is a collection of key-value pairs. Hash tables allow you to store and retrieve data efficiently based on keys rather than numerical indexes. Here's a detailed guide on how to use hash tables in PowerShell:

Creating a Hash Table:

You can create a hash table using the @{} syntax:

Example: 

$hashTable = @{

    Key1 = "Value1"

    Key2 = "Value2"

    Key3 = "Value3"

}

Accessing Values:

You can access values in a hash table by specifying the key:

Example:

$value = $hashTable["Key1"]

Adding or Modifying Values:

You can add or modify values in a hash table by assigning a value to a key:

$hashTable["Key4"] = "Value4"

$hashTable["Key2"] = "NewValue2"

Removing Values:

You can remove a key-value pair from a hash table using the Remove() method:

$hashTable.Remove("Key3")

Checking if a Key Exists:

You can check if a key exists in a hash table using the ContainsKey() method:

if ($hashTable.ContainsKey("Key1")) {

    Write-Output "Key1 exists in the hash table."

}

Iterating Over a Hash Table:

You can iterate over a hash table using a foreach loop:

foreach ($key in $hashTable.Keys) {

    $value = $hashTable[$key]

    Write-Output "$key: $value"

}

Using Hash Tables as Parameters:

You can use hash tables to pass named parameters to functions or cmdlets:

function Test-Function {

    param (

        [string]$Name,

        [int]$Age

    )

    Write-Output "Name: $Name, Age: $Age"

}

$params = @{

    Name = "John"

    Age = 30

}

Test-Function @params

Nested Hash Tables:

You can have nested hash tables to represent more complex data structures:

$nestedHashTable = @{

    Key1 = @{

        NestedKey1 = "Value1"

        NestedKey2 = "Value2"

    }

    Key2 = @{

        NestedKey3 = "Value3"

        NestedKey4 = "Value4"

    }

}

Hash tables are versatile data structures in PowerShell and are commonly used for configuration settings, organizing data, passing parameters, and more. Understanding how to work with hash tables effectively is essential for PowerShell scripting.

Hope you enjoyed this article. 

Thanks!

#101 : Variables in Powershell

 In PowerShell, variables are used to store data that can be referenced and manipulated throughout your script. 

Variable Declaration in Powershell:

Variables in PowerShell do not require explicit declaration of data types. You can simply assign a value to a variable using the $ symbol followed by the variable name.

$myVariable = "Hello, World!"

Variable Naming Convention:
PowerShell variable names are not case-sensitive, but it's a good practice to use camelCase or PascalCase for readability.

Variable Data Types:
PowerShell variables can hold various types of data, including strings, numbers, arrays, and objects.

Accessing Variables:
You can access the value of a variable by simply referencing its name preceded by the $ symbol.

Example: 

Write-Output $myVariable

What is scope of variable?
PowerShell variables can have different scopes, such as
1. Script scope
2. Global scope
3. Function scope
4. Local scope.

The default scope for variables is the script scope. You can specify the scope using the appropriate scope modifier ($script:, $global:, $local:, etc.).

Example:

$globalVariable = "I'm a global variable"

function Test-Scope {

    $localVariable = "I'm a local variable"

    Write-Output $globalVariable

    Write-Output $localVariable

}

Test-Scope

Variable Expansion:
PowerShell supports variable expansion within strings enclosed in double quotes, allowing you to include variable values directly within a string.

Example:

$name = "John"
Write-Output "Hello, $name!"

Automatic Variables:
PowerShell also provides a set of automatic variables that store various system and environment information, such as $PSVersionTable, $PID, $HOME, etc.

Variable Manipulation:
You can manipulate variables using various operators and methods, such as assignment (=), addition (+=), subtraction (-=), multiplication (*=), division (/=), and so on.

$num = 5

$num += 10

Write-Output $num  # Output: 15

These are some of the fundamental concepts related to variables in PowerShell. As you become more familiar with PowerShell scripting, you'll discover additional techniques and best practices for working with variables effectively.