Powershell : Import-Module : Could not load file or assembly

Sometimes you might face above issue while importing module(written using C# dll) downloaded from internet. One reason could be that, windows considers downloaded dll's as malicious or whatever, so just 'Unblock'(right-click into Properties->General tab) if you trust it.

IP Address's

Loop back address - It is a virtual network interface implemented in software only and not connected to any hardware, but which is fully integrated into the computer system's internal network infrastructure. Any traffic that a computer program sends to the loopback interface is immediately received on the same interface. Localhost is mapped to loopback address, usually 127.0.0.1 for IPv4, although any address in the range 127.0.0.0 to 127.255.255.255 is mapped to it. IPv6 designates only a single address for this function, 0:0:0:0:0:0:0:1 (also written as ::1).

Unspecified or 0:0:0:0 or * address - represents any address, but should not be present on outgoing packets. If you bind a listening socket to 0.0.0.0, you're telling the OS to accept connections on any ip address that the host has network adapters bound to. e.g. if your host had two network adapters with two different ip addresses. You can bind a socket to either one and it will accept connections only on that adapter. Or you can bind a socket to 0.0.0.0 (INADDR_ANY in WinSock) and it will bind to both adapters.

Private address - used within organization, range from 192.168.0.0 to 192.168.255.255 and 172.16.0.0 to 172.16.255.255

Public address - can be static or dynamic(per internet session). Static IP's are used sometime for gaming or hosting website etc.

IPV6 - IPV4 is 4 part address with each part size is of 8 bits, so totally 32 bits. It allows 4,29,49,67,296 or 2^32 addresses. But IPV6 is 8 part address with each part size is of 16 bits, so totally 128 bits.

Sample code to figure out whether IP address is 32 or 128 bits

    string input = "your IP address goes here";

    IPAddress address;
    if (IPAddress.TryParse(input, out address))
    {
        switch (address.AddressFamily)
        {
            case System.Net.Sockets.AddressFamily.InterNetwork:
                // we have IPv4
                break;
            case System.Net.Sockets.AddressFamily.InterNetworkV6:
                // we have IPv6
                break;
            default:
                // umm... yeah... I'm going to need to take your red packet and...
                break;
        }
    }

Split unity configuration file

For maintenance reasons, it is better to split a 'BIG' unity configuration into multiple files. One such way to do this is

1. Let us imagine we need to split into two files, so your root config file will look like below

<configSections>
    <section name="unitySection1" 

          type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, 

          Microsoft.Practices.Unity.Configuration"/>

    <section name="unitySection2" 

          type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection, 

          Microsoft.Practices.Unity.Configuration"/>
</configSections>

<unitySection1 configSource="unity1.config" />

<unitySection2 configSource="unity2.config" /> 

2. And your individual unity files will look like below(see the highlighted section that 'unity' tag becomes 'unitySection1')

   <unitySection1>

       <container /> 

   </unitySection1>
 

   <unitySection2> 

       <container />

   </unitySection2>

3. Load the separate configuration files into Container


    UnityContainer.LoadConfiguration - will adds up the container details, so we just need to call it twice

 private void Initialise()
 {

   string[] unitySections = new string[] {"unitySection1", "unitySection2"};

   IUnityContainer container = new UnityContainer(); 

   foreach(var section in unitySections)

   {

      var configuration = ConfigurationManager.OpenExeConfiguration(path);
 

      var unitySection = (UnityConfigurationSection)configuration.

                          GetSection(section);
        
      container.LoadConfiguration(unitySection);

    }
 }

reference link 

CmdLet.ShouldContinue

Please refer this

Below example code

protected override void ProcessRecord()
{
    if (this.ShouldContinue("Are you sure you want to uninstall", "Confirm Uninstall"))
    {
        //your script here
    }
}

IRequestChannel - Demo 1

Let's assume below ServiceContract

[ServiceContract]
public interface IDemo1
{
    [OperationContract]
    string HelloWorld(string name);
}

so how can we invoke above using IRequestChannel

var httpsBasicBinding = new BasicHttpBinding(BasicHttpSecurityMode.Transport);
var endpoint = "https://host/service.svc";
var channelFactory = new ChannelFactory<IRequestChannel>(httpsBasicBinding, endpoint);
var channel = null;

try
{
    channelFactory.Open();
 
    channel = channelFactory.CreateChannel();
 
    channel.Open(); 

    string body = "<HelloWorld xmlns="http://tempuri.org/"><name>Suresh</name></HelloWorld>";

    var messageBody = XmlReader.Create(new MemoryStream(Encoding.UTF8.GetBytes(body)

    Message message = Message.CreateMessage(MessageVersion.Soap11,  

                       "http://tempuri.org/IDemo1/HelloWorld");
 
    Message response = channel.Request(message);

    var result = response.GetReaderAtBodyContents().ReadOuterXml(); //parse based on the requirments
    
    Console.WriteLine(result);

    channel.Close();
}
finally
{

    channel.close(); //abort if faulted 

    channelFactory.Close(); //abort if faulted
}

reference : http://www.codeproject.com/Articles/34632/How-to-pass-arbitrary-data-in-a-Message-object-usi 

XSD: restriction on type to not be empty or blank

I wanted to create a SimpleType called 'ValidInput', basically i don't want to allow empty spaces. I started with below but for some reasons it worked on XML SPY, but not thru c#.

  <xs:simpleType name="ValidInput">
    <xs:restriction base="xs:string">
      <xs:minLength value="1"/>
      <xs:whiteSpace value="collapse"/>
    </xs:restriction>
  </xs:simpleType>

But below worked, can't figure out why

<xs:simpleType name="ValidInput">

    <xs:restriction base = "xs:string">
       <xs:minLength value="1" />
       <xs:pattern value=".*[^\s].*" />
   </xs:restriction>

</xs:simpleType>

Any CPU vs x64 vs x86

When we compile .net applications/libraries we get IL's, not Machine readable codes. So when we say 'Any CPU'(in a way architecture-neutral PE files) we create neutral IL's, and as part of JIT compilation, output will be either x64 or x86 PE's based on executing machine or calling process.

On a 32-bit machine:

• Any CPU: runs as a 32-bit process, can load Any CPU and x86 assemblies, will get BadImageFormatException if it tries to load an x64 assembly.
• x86: same as Any CPU.
• x64: BadImageFormatException always.

On a 64-bit machine:

• Any CPU: runs as a 64-bit process, can load Any CPU and x64 assemblies, will get BadImageFormatException if it tries to load an x86 assembly.
• x86: runs as a 32-bit process, can load Any CPU and x86 assemblies, will get BadImageFormatException if it tries to load an x64 assembly.
• x64: same as Any CPU.

It is the JIT compiler that generates an assembly code that's compatible with the requested target based on this flag.

Also CorFlags.exe assembly.dll|assembly.exe will tell us whether it is targeted x86 or Any CPU

Just for clarification, CorFlags.exe is part of the .NET Framework SDK. I have the development tools on my machine, and the simplest way for me determine whether a DLL is 32-bit only is to:

1. Open the Visual Studio Command Prompt (In Windows: menu Start/Programs/Microsoft Visual Studio/Visual Studio Tools/Visual Studio 2008 Command Prompt)
2. CD to the directory containing the DLL in question
3. Run corflags like this: corflags MyAssembly.dll

You will get output something like this:

    Microsoft (R) .NET Framework CorFlags Conversion Tool.  Version  3.5.21022.8
Copyright (c) Microsoft Corporation.  All rights reserved.
Version   : v2.0.50727
CLR Header: 2.5
PE        : PE32CorFlags  : 3
ILONLY    : 1
32BIT     : 1
Signed    : 0

The key is the "32BIT" flag as documented above: 1 = x86; 0 = Any CPU.

·        Any CPU: PE = PE32    and  32BIT = 0

·         x86:         PE = PE32    and  32BIT = 1

      ·         x64:         PE = PE32+  and  32BIT = 0