by Buz

Single Instance Application - Part 2 : activating existing instance

Buz & Skup — Thu, 24 Nov 2005 18:00:00 GMT

Well, I did not have post for a long time. I was working hard on the next version of PixVillage, which will be released soon now.

I'm coming back with a new post in the Single Instance Application series.

In the previous post, we have written a ProcessLock object that help us to detect an existing instance of the program we attempt to run, so that we can prevent running it twice.

Today I'm dealing with the ability to activate an existing instance of a Windows Forms application when running a new one. In order to achieve that, we have to notify the application it has to go foreground and get focus.

This can be done though a message send to the main thread of the application. The message is received by the thread, not by a window, so we have to write a specific handler and register it. The IMessageFilter interface helps providing this kind of service. Let's implement it!

Code Copy HideScrollFull

namespace SingleInstance {/// <summary>
/// Provides a thread message filter and handle messages.
/// </summary>
public class ThreadMessageFilter : IMessageFilter {private Form owner;

/// <summary>
/// Initializes a new instance of the <see cref="ThreadMessageFilter"/> class.
/// </summary>
/// <param name="owner">The owner.</param>
public ThreadMessageFilter(Form owner) {this.owner = owner;
}

/// <exclude/>
[SecurityPermission(SecurityAction.LinkDemand, UnmanagedCode=true)]
bool IMessageFilter.PreFilterMessage(ref Message m) {if (m.HWnd != IntPtr.Zero) // Get rid of message if it's sent to a window...return false;
// Handle the message here...

return false;
}
}
}

Now, supposing we want to activate the window when a new instance of the application is launched, we can, for instance, send a WM_SHOWWINDOW message to the thread, using the Windows PostThreadMessage API. The IMessageFilter.PreFilterMessage is implemented as follow:

Code Copy HideScrollFull

/// <exclude/>
[SecurityPermission(SecurityAction.LinkDemand, UnmanagedCode=true)]
bool IMessageFilter.PreFilterMessage(ref Message m) {if (m.HWnd != IntPtr.Zero) // Get rid of message if it's sent to a window...return false;
if (m.Msg == WM_SHOWWINDOW) {// Shows the window
try {owner.Show();
if (owner.WindowState == FormWindowState.Minimized)owner.WindowState = FormWindowState.Normal;
return true;
}
catch {} // return false;
}

return false;
}

With WM_SHOWWINDOW declared as follow:

Code Copy

private const int WM_SHOWWINDOW = 0x18;

Now, we just have to modify the Main() method in order to:

Create and show the form the first time the application is started.
Registers and unregisters a ThreadMessageFilter object.
Send the message to any thread of any process having the same name as the current assembly.

The code is given below. (MainForm is a class derived from System.Windows.Form).

Code Copy HideScrollFull

using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Windows.Forms;

namespace SingleInstance
{public sealed class SingleInstance
{private SingleInstance(){}
private static readonly string assemblyName = Assembly.GetExecutingAssembly().GetName().Name;

[DllImport("user32.dll")]
private static extern bool PostThreadMessage(int threadId, int message, int wParam, int lParam);

private const int WM_SHOWWINDOW = 0x18;

/// <summary>
/// Application entry point.
/// </summary>
[STAThread]
static void Main() {using(ProcessLock processLock = new ProcessLock(assemblyName)) {if (processLock.AlreadyExists)
{// Sets the existing application foreground.
SetForeground();
}
else
{// The program operation must run inside the 'using' block.
Run();
}
}
}

private static void SetForeground() {// Find all processes having the same name
Process[] processes = Process.GetProcessesByName(assemblyName);
foreach (Process process in processes)
{if (process.Id == Process.GetCurrentProcess().Id)                // This is the current process, pass
continue;
// Activates the other instance window by sending the message to any thread in the process.
foreach (ProcessThread thread in process.Threads)PostThreadMessage(thread.Id, WM_SHOWWINDOW, 0, 0);
}
}

private static void Run() {using(MainForm form = new MainForm()) {IMessageFilter filter = new ThreadMessageFilter(form);
Application.AddMessageFilter(filter);

try
{form.Show();
Application.Run(form);
}
finally {Application.RemoveMessageFilter(filter);
}
}
}
}
}

. . .

Single Instance Application - Part 1 : preventing multiple instances

Buz & Skup — Thu, 21 Apr 2005 13:48:00 GMT

Don't worry, the Exif series is not closed yet... preparing Part 4 just requires more work...

This new post series is dedicated to - as title say - the creation of a single instance application. That is, application that can only run once simultaneously. That's a frequently encountered issue, particularly when your program makes use of resources that cannot be shared (overlay video surfaces, network listen ports, etc.)

My solution to the single instance application problem is to create a class called ProcessLock that can be locked, unlocked, and indicate whether the application is running.
The ProcessLock implements the IDisposable interface, so that the process lock can be locked and unlocked through a using statement. The implementation uses a named mutex (with is global to the user session).

The ProcessLock tries to create the underlying mutex in the constructor. A failure means that the mutex does already exist : the application is running.

Code Copy HideScrollFull

#region
    References

using System;
using System.Diagnostics;
using System.Threading;

#endregion

     

     namespace SingleInstance {///
      <summary>
/// Provides a lock object to 
      prevent a program from being launched multiple times.
/// </summary>
public class ProcessLock 
     : IDisposable {
#region Fields

private string applicationName;
private Mutex mutex;
private bool created;
private bool disposed;

#endregion

       

       #region Instance Management

/// <summary>
/// Initializes a new instance 
       of the <see cref="ProcessLock"/>
       class.
/// </summary>
/// <param 
       name="applicationName">Name of the 
       process lock</param>
public ProcessLock(string
      applicationName) {this.applicationName 
       = applicationName;

       TryLock();

      }

/// <summary>
/// Disposes the process lock 
       resources.
/// </summary>
public void Dispose() 
      {if (mutex!=null){if
        (created)Unlock();

        else {mutex.Close();

         mutex = null;

        }

       }


       disposed = true;

      }

#endregion

       

       #region Properties

/// <summary>
/// Indicates whether a process 
       for the given name does already exist.
/// </summary>
public bool AlreadyExists 
      {get {return
        !created;

       }

      }

/// <summary>
/// Indicates whether the 
       process lock is disposed.
/// </summary>
public bool Disposed 
      {get {return
        disposed;

       }

      }

#endregion

       

       #region Methods

/// <summary>
/// Try to get the process lock 
       again.
/// </summary>
public bool TryLock(){if
       (disposed)throw
         new ObjectDisposedException("ProcessLock");

        
       

       if (created)throw
         new InvalidOperationException();

        
       

       if (mutex!=null)mutex.Close();

       mutex = new Mutex(true, 
       applicationName, out created);

return created;

      }

/// <summary>
/// Releases the process lock.
/// </summary>
public void Unlock() 
      {if (disposed)throw
         new ObjectDisposedException("ProcessLock");
if (!created)

        throw new InvalidOperationException();

       Debug.Assert(mutex!=null);


       mutex.ReleaseMutex();

       mutex = null;

       created = false;

      }

#endregion

     }

    }

Using a ProcessLock is quite straight-forward. A sample Console application follows (you will note the use of System.Reflection.Assembly for retrieving the application name) :

Code Copy HideScrollFull

using
    System;
using System.Reflection;

namespace SingleInstance

    {public
      sealed class SingleInstance

     {private SingleInstance(){}
private static
       readonly string assemblyName = 
      Assembly.GetExecutingAssembly().GetName().Name;

/// <summary>
/// Application entry point.
/// </summary>

      [STAThread]
static void Main() {using(ProcessLock 
       processLock = new ProcessLock(assemblyName)) {if
        (processLock.AlreadyExists)return;

         
        

        // The program operation must run inside the 'using' block.

        Run();

       }

      }

private static
       void Run() {Console.WriteLine("{0} 
        running. Press 'Enter' to exit.", assemblyName);

       Console.ReadLine();

      }

     }

    }

In the next post, I will explain how to bring a window to the foreground, even if it is currently invisible...

Exif Properties in .Net - Part 3 : converting properties

Buz & Skup — Tue, 19 Apr 2005 12:20:00 GMT

In the first post of this Exif series, I talked about a technique for loading Exif properties as fast as GDI+ is able to do.
The second post was dealing with adding new properties to an empty image.

Now it's time to look more precisely at the Exif properties. How is a PropertyItem structured ?
The final goal of this post is to convert the raw data exposed by GDI+ (and the .Net Framework) into more useable data types.

An Exif property consists in the following information:

An identifier, determining the "meaning" of the property.
A data type, indicating how the data are represented.
A length (the number of bytes the property data contains).
A value which is a raw array of bytes.

The Exif property data type is a 16-bit integer, but it's quite simple to build an enum type that maps the values to a more comprehensive type :

Code Copy HideScrollFull

///
     <summary>

     /// Defines types for Exif Properties.
/// </summary>
public enum ExifPropertyType 
    {/// <summary>

     /// Specifies that the value 
      data member is an array of bytes.

     /// </summary>

     Byte = 1,

     /// <summary>

     /// Specifies that the value 
      data member is a null-terminated ASCII string.

     /// </summary>

     /// <remarks>If 
      you set <see 
      cref="PropertyItem.Type">PropertyItem.Type</see>
      to <see cref="PropertyItem.Type"/>, 
      you should set the length data member to the length of the string including the 
      NULL terminator. For example, the string HELLO would have a length of 6.</remarks>

     Ascii = 2,

     /// <summary>

     /// Specifies that the value 
      data member is an array of signed short (16-bit) integers.

     /// </summary>

     UInt16 = 3,

     /// <summary>

     /// Specifies that the value 
      data member is an array of unsigned long (32-bit) integers.

     /// </summary>

     UInt32 = 4,

     /// <summary>

     /// Specifies that the value 
      data member is an array of pairs of unsigned long integers. Each pair 
      represents a fraction; the first integer is the numerator and the second 
      integer is the denominator.

     /// </summary>

     URational = 5,

     /// <summary>

     /// Specifies that the value 
      data member is an array of bytes that can hold values of any data type.

     /// </summary>

     Raw = 7,

     /// <summary>

     /// Specifies that the value 
      data member is an array of signed long (32-bit) integers.

     /// </summary>

     Int32 = 9,

     /// <summary>

     /// Specifies that the value 
      data member is an array of pairs of signed long integers. Each pair represents 
      a fraction; the first integer is the numerator and the second integer is the 
      denominator.

     /// </summary>

     Rational = 10,

    }

As you can see in the code above, most of the data types are simple and can be directly mapped to .Net data types, excepted for rational and unsigned rational values. We need to create a .Net representation for each of them :

Rational :

Code Copy HideScrollFull

///
     <summary>

     /// Represents a signed rational number.
/// </summary>
public class Rational 
    {private
      int numerator;
private int denominator;

/// <summary>
/// Initializes a new instance 
      of the <see cref="Rational"/>
      class.
/// </summary>
/// <param 
      name="numerator">The numerator of the 
      rational number.</param>
/// <param 
      name="denominator">The denominator of 
      the rational number.</param>
public Rational(int numerator,
      int denominator) {this.numerator 
      = numerator;

      this.denominator = denominator;

     }

/// <summary>
/// Gets the numerator of the 
      rational number.
/// </summary>
public int Numerator 
     {get {return
       numerator;

      }

     }

/// <summary>
/// Gets the denominator of the 
      rational number.
/// </summary>
public int Denominator 
     {get {return
       denominator;

      }

     }

/// <summary>
/// Gets the floating-point 
      value of the rational number.
/// </summary>
public double Value {get
      {return (double) 
       numerator/(double) denominator;

      }

     }

/// <exclude/>
public override
      string ToString() {return
      Value.ToString();

     }

    }

. . .

URational :

Code Copy HideScrollFull

///
     <summary>

     /// Represents an unsigned rational number.
/// </summary>
public class URational 
    {private
      uint numerator;
private uint denominator;

/// <summary>
/// Initializes a new instance 
      of the <see cref="Rational"/>
      class.
/// </summary>
/// <param 
      name="numerator">The numerator of the 
      rational number.</param>
/// <param 
      name="denominator">The denominator of 
      the rational number.</param>
public URational(uint 
     numerator, uint denominator) {this.numerator 
      = numerator;

      this.denominator = denominator;

     }

/// <summary>
/// Gets the numerator of the 
      rational number.
/// </summary>
public uint Numerator 
     {get {return
       numerator;

      }

     }

/// <summary>
/// Gets the denominator of the 
      rational number.
/// </summary>
public uint Denominator 
     {get {return
       denominator;

      }

     }

/// <summary>
/// Gets the floating-point 
      value of the rational number.
/// </summary>
public double Value {get
      {return (double) 
       numerator/(double) denominator;

      }

     }

/// <exclude/>
public override
      string ToString() {return
      Value.ToString();

     }

    }

. . .

According to the Exif specification, properties may contain arrays of values. Our conversion tool must consequently have the following signature :

Code Copy

public
     static Array FromPropertyItem(PropertyItem propertyItem) {}

The conversion code is quite simple (a switch... case construct branching on different code depending on the data type).
When converting raw data into integers, just take care that Exif properties are stored as big endian values.

Code Copy HideScrollFull

#region
    References

using System;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;
using System.Text;

#endregion

     

     namespace ExifNative {///
      <summary>
/// Summary description for 
      ExifConvert.
/// </summary>
public sealed
      class ExifConvert {private
      ExifConvert() {}

/// <summary>
/// Converts a property item to 
       an array of objects.
/// </summary>
/// <param 
       name="propertyItem">The property item 
       to convert.</param>
/// <returns>An 
       array of <see cref="object"/>
       items.</returns>
public static Array 
      FromPropertyItem(PropertyItem propertyItem) {ExifPropertyType 
       type = (ExifPropertyType) propertyItem.Type;

switch (type) {case
        ExifPropertyType.Raw:// The value 
          represents raw data (a single byte[] value)

         return new
          byte[][] {propertyItem.Value};

         

        
case ExifPropertyType.Ascii:// 
          The value represents an array of strings separated by \0 characters

         string stringValue = 
         Encoding.ASCII.GetString(propertyItem.Value, 0, propertyItem.Len - 1);

         return stringValue.Split('\0');

         

        
case ExifPropertyType.Byte:// 
          The value represents an array of bytes

         return propertyItem.Value;

         

        
case ExifPropertyType.UInt16:// 
          The value represents an array of unsigned 16-bit integers.
int ushortCount = propertyItem.Len/ushortSize;

ushort[] ushortResult = new
          ushort[ushortCount];
for (int i = 0; i 
         < ushortCount; i++)ushortResult[i] = 
          ReadUInt16(propertyItem.Value, i * ushortSize);

         return ushortResult;

case ExifPropertyType.Int32:// 
          The value represents an array of signed 32-bit integers.
int intCount = propertyItem.Len/intSize;

int[] intResult = new
          int[intCount];
for (int i = 0; i 
         < intCount; i++)intResult[i] = 
          ReadInt32(propertyItem.Value, i * intSize);

         return intResult;

case ExifPropertyType.UInt32:// 
          The value represents an array of unsigned 32-bit integers.
int uintCount = propertyItem.Len/uintSize;

uint[] uintResult = new
          uint[uintCount];
for (int i = 0; i 
         < uintCount; i++)uintResult[i] = 
          ReadUInt32(propertyItem.Value, i * uintSize);

         return uintResult;

case ExifPropertyType.Rational:// 
          The value represents an array of signed rational numbers
// Numerator is an Int32 value, denominator a UInt32 value.
int rationalCount = propertyItem.Len/rationalSize;


         Rational[] rationalResult = new Rational[rationalCount];
for (int i = 0; i 
         < rationalCount; i++)rationalResult[i] =
           new Rational(ReadInt32(propertyItem.Value, 
           i * rationalSize),

           ReadInt32(propertyItem.Value, i * rationalSize + intSize));

         

         return rationalResult;

case ExifPropertyType.URational:// 
          The value represents an array of signed rational numbers
// Numerator and denominator are UInt32 values.
int urationalCount = 
         propertyItem.Len/rationalSize;


         URational[] urationalResult = new URational[urationalCount];
for (int i = 0; i 
         < urationalCount; i++)urationalResult[i] =
           new URational(ReadUInt32(propertyItem.Value, 
           i * urationalSize),

           ReadUInt32(propertyItem.Value, i * urationalSize + uintSize));

         

         return urationalResult;

default:return
          null;

       }

      }

#region Static Fields

private static
       readonly int ushortSize = 
      Marshal.SizeOf(typeof (ushort));
private static
       readonly int intSize = Marshal.SizeOf(typeof
      (int));
private static
       readonly int uintSize = Marshal.SizeOf(typeof
      (uint));
private static
       readonly int rationalSize = 2 * 
      Marshal.SizeOf(typeof (int));
private static
       readonly int urationalSize = 2 * 
      Marshal.SizeOf(typeof (uint));

#endregion

       

       #region Private Helpers

private static
       ushort ReadUInt16(byte[] buffer,
       int offset) {return
       (ushort) (((ushort) 
        buffer[offset] +

        ((ushort) buffer[offset + 1] << 8)));

      }

private static
       int ReadInt32(byte[] buffer,
       int offset) {return
       (int) (((uint) 
        buffer[offset] +

        ((uint) buffer[offset + 1] << 8) +

        ((uint) buffer[offset + 2] << 16) +

        ((int) buffer[offset + 3] << 24)));

      }

private static
       uint ReadUInt32(byte[] buffer,
       int offset) {return
       (uint) (((uint) 
        buffer[offset] +

        ((uint) buffer[offset + 1] << 8) +

        ((uint) buffer[offset + 2] << 16) +

        ((uint) buffer[offset + 3] << 24)));

      }

#endregion

     }

    }

The following code is a sample console application that make use of the code above to load an image and display the content of Exif properties.

Code Copy

[STAThread]
private static
     void Main(string[] args) {using(Image 
     image = Image.FromFile(args[0])) {Console.WriteLine("{0} 
       : {1} properties", args[0], image.PropertyItems.Length);

foreach (PropertyItem propertyItem
       in image.PropertyItems) {Array result = 
       ExifConvert.FromPropertyItem(propertyItem);

       Console.WriteLine("Property #{0}, type : {1}, {2} 
        value(s)", propertyItem.Id, 
       (ExifPropertyType)propertyItem.Type, result.Length);

foreach (object
        value in result)Console.WriteLine("\t{0}",
         value);

       

       Console.WriteLine();

      }

     }

    }
   

C# code and copyright notice

Buz & Skup — Mon, 18 Apr 2005 15:51:00 GMT

Some people asked me the question so...

If you wish to use the C# code we are publishing on this blog, you're free to do so, under the following condition : if your application source code is public, you must include the following header at the top of the source code you got from this blog :

/* Copyright © 2005, The PixVillage Team All rights reserved. http://www.pixvillage.com/blogs/devblog/ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. - Neither the name of the PixVillage Team, nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */

Implementing UPnP Nat Traversal

Buz & Skup — Thu, 31 Mar 2005 10:29:00 GMT

When creating a end-user network application, a number of problems arise such as, for instance, connectivity through firewalls and/or routers. Luckily, there is a number of standards and/or Windows API that deal with these problems, and the only thing we have to do to ensure a state-of-art support of networking technologies is to implement standards or stubs for API.

For instance, in order to make a network-aware application available through an IGD (Internet Gateway Device), The UPnP forum defines a standard for configuring IGD using UPnP: this is called NAT Traversal (where NAT stands for Network Address Translation). Microsoft exposes an API that implement NAT Traversal. The scope of this post is to use it in C#.

The NAT Traversal API is a COM Type Library. The first step is to add a stub for this component:

First, add a reference to the CustomMarshalers assembly (in the Solution Explorer, right-click on the project's References node, Add References..., .NET tab),
Then, create a file containing the following COM Interop code:

Code Copy HideScrollFull

using System.Collections;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.InteropServices.CustomMarshalers;

namespace NatTraversal.Interop {
[ComImport, Guid("624BD588-9060-4109-B0B0-1ADBBCAC32DF"), TypeLibType(4160)]
internal interface INATEventManager {
[DispId(1)]
object ExternalIPAddressCallback { [param: In, MarshalAs(UnmanagedType.IUnknown)] [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(1)] set; }
[DispId(2)]
object NumberOfEntriesCallback { [param: In, MarshalAs(UnmanagedType.IUnknown)] [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(2)] set; }
}

[ComImport, TypeLibType(4160), Guid("6F10711F-729B-41E5-93B8-F21D0F818DF1")]
internal interface IStaticPortMapping {
[DispId(1)]
string ExternalIPAddress { [return: MarshalAs(UnmanagedType.BStr)] [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(1)] get; }
[DispId(2)]
int ExternalPort { [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(2)] get; }
[DispId(3)]
int InternalPort { [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(3)] get; }
[DispId(4)]
string Protocol { [return: MarshalAs(UnmanagedType.BStr)] [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(4)] get; }
[DispId(5)]
string InternalClient { [return: MarshalAs(UnmanagedType.BStr)] [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(5)] get; }
[DispId(6)]
bool Enabled { [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(6)] get; }
[DispId(7)]
string Description { [return: MarshalAs(UnmanagedType.BStr)] [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(7)] get; }
[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(8)]
void EditInternalClient([In, MarshalAs(UnmanagedType.BStr)] string bstrInternalClient);
[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(9)]
void Enable([In] bool vb);
[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(10)]
void EditDescription([In, MarshalAs(UnmanagedType.BStr)] string bstrDescription);
[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(11)]
void EditInternalPort([In] int lInternalPort);
}

[ComImport, Guid("CD1F3E77-66D6-4664-82C7-36DBB641D0F1"), TypeLibType(4160)]
internal interface IStaticPortMappingCollection /*: IEnumerable*/ {
[return: MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(EnumeratorToEnumVariantMarshaler))]
[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(-4), TypeLibFunc(0x41)]
IEnumerator GetEnumerator();
[DispId(0)]
IStaticPortMapping this[int lExternalPort, string bstrProtocol] { [return: MarshalAs(UnmanagedType.Interface)] [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(0)] get; }
[DispId(1)]
int Count { [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(1)] get; }
[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(2)]
void Remove([In] int lExternalPort, [In, MarshalAs(UnmanagedType.BStr)] string bstrProtocol);
[return: MarshalAs(UnmanagedType.Interface)]
[MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(3)]
IStaticPortMapping Add([In] int lExternalPort, [In, MarshalAs(UnmanagedType.BStr)] string bstrProtocol, [In] int lInternalPort, [In, MarshalAs(UnmanagedType.BStr)] string bstrInternalClient, [In] bool bEnabled, [In, MarshalAs(UnmanagedType.BStr)] string bstrDescription);
}

[ComImport, Guid("B171C812-CC76-485A-94D8-B6B3A2794E99"), TypeLibType(4160)]
internal interface IUPnPNAT {
[DispId(1)]
IStaticPortMappingCollection StaticPortMappingCollection { [return: MarshalAs(UnmanagedType.Interface)] [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(1)] get; }
[DispId(2)]
object /*IDynamicPortMappingCollection*/ DynamicPortMappingCollection { [return: MarshalAs(UnmanagedType.Interface)] [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(2)] get; }
[DispId(3)]
INATEventManager NATEventManager { [return: MarshalAs(UnmanagedType.Interface)] [MethodImpl(MethodImplOptions.InternalCall, MethodCodeType=MethodCodeType.Runtime), DispId(3)] get; }
}

[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("9C416740-A34E-446F-BA06-ABD04C3149AE")]
internal interface INATExternalIPAddressCallback {
void NewExternalIPAddress([MarshalAs(UnmanagedType.BStr)]string newExternalIPAddress);
}

[ComImport, InterfaceType(ComInterfaceType.InterfaceIsIUnknown), Guid("C83A0A74-91EE-41B6-B67A-67E0F00BBD78")]
internal interface INATNumberOfEntriesCallback {
void NewNumberOfEntries(int newNumberOfEntries);
}

[ComImport, Guid("B171C812-CC76-485A-94D8-B6B3A2794E99"), CoClass(typeof(UPnPNATCreator))]
internal interface UPnPNAT : IUPnPNAT {}

[ComImport, TypeLibType(2), Guid("AE1E00AA-3FD5-403C-8A27-2BBDC30CD0E1"), ClassInterface(ClassInterfaceType.None)]
internal class UPnPNATCreator {}
}

. . .

According to the documentation, the IUPnPNAT.DynamicPortMappingCollection property is not implemented: I removed the definition of IDynamicPortMappingCollection and replaced it with a simple object in the interface definition.

Now we can work with the API. First, create a simple object that will represents the UPnP-compatible IGD, if present. The object initializer will create the COM object and check for availability of the StaticPortMappingCollection property:

Code Copy HideScrollFull

#region References

using System;
using System.Collections;
using System.Net;
using NatTraversal.Interop;

#endregion

namespace NatTraversal {
public class UPnPNat {
#region Fields
private UPnPNAT uPnpNat;
#endregion

#region Instance Management

public UPnPNat() {
try {
UPnPNAT nat = new UPnPNAT();
if (nat.NATEventManager != null && nat.StaticPortMappingCollection != null)
uPnpNat = nat;
}
catch { }

// No configurable UPNP NAT is available.
if (uPnpNat == null)
throw new NotSupportedException();
}

#endregion
}
}

In order to enumerate port mappings, we have to represent each mapping by a single object instead of a set of variables : the PortMappingInfo class is a helper that contains all the settings of a port mapping :

Code Copy HideScrollFull

. . .

Now, we can enumerate the existing port mappings. Since the StaticPortMappingCollection is an enumerator we should use the foreach statement, but unfortunately it does not work and throw an exception. That's why we enumerate the items using IEnumerator.MoveNext:

Code Copy HideScrollFull

public PortMappingInfo[] PortMappings {
get {
// Builds port mappings list
ArrayList portMappings = new ArrayList();

// Enumerates the ports without using the foreach statement (causes the interop to fail).
int count = uPnpNat.StaticPortMappingCollection.Count;
IEnumerator enumerator = uPnpNat.StaticPortMappingCollection.GetEnumerator();
enumerator.Reset();

for (int i = 0; i <= count; i++) {
IStaticPortMapping mapping = null;
try {
if (enumerator.MoveNext())
mapping = (IStaticPortMapping)enumerator.Current;
}
catch { }

if (mapping != null) {
portMappings.Add(new PortMappingInfo(
mapping.Description,
mapping.Protocol.ToUpper(),
mapping.InternalClient,
mapping.InternalPort,
IPAddress.Parse(mapping.ExternalIPAddress),
mapping.ExternalPort,
mapping.Enabled));
}
}

// Now copies the ArrayList to an array of PortMappingInfo.
PortMappingInfo[] portMappingInfos = new PortMappingInfo[portMappings.Count];
portMappings.CopyTo(portMappingInfos);

return portMappingInfos;
}
}

Invoking this property is done this way:

Code Copy

UPnPNat nat = new UPnPNat();

foreach (PortMappingInfo info in nat.PortMappings)
Console.WriteLine("{0} : {1} -> {2}:{3} ({4})", info.Description, info.ExternalPort, info.InternalHostName, info.InternalPort, info.Protocol); 

In order to use UPnP to configure the IGD, we have to implement stubs for adding and removing port mappings :

Code Copy

public void AddPortMapping(PortMappingInfo portMapping) {
uPnpNat.StaticPortMappingCollection.Add(portMapping.ExternalPort, portMapping.Protocol, portMapping.InternalPort, portMapping.InternalHostName, portMapping.Enabled, portMapping.Description);
}

public void RemovePortMapping(PortMappingInfo portMapping) {
uPnpNat.StaticPortMappingCollection.Remove(portMapping.ExternalPort, portMapping.Protocol);
} 

Now, last but not least, you have to configure both your IGD and Windows box to use UPnP !

Exif Properties in .Net - Part 2 : creating new properties

Buz & Skup — Sun, 27 Mar 2005 20:04:00 GMT

When you manage Exif properties, you commonly have two basic tasks to handle : reading Exif properties (which is quite simple), and writing Exif properties, which is, in C#, as simple as:

Code Copy

PropertyItem 
    property = ...;

    Image image = ...;

    image.SetPropertyItem(property);

In the code above, the Image object may have been created from a file, a stream, an existing image, or just from scratch...
The PropertyItem may have been retrieved from an image, or... nothing : the System.Drawing.Imaging.PropertyItem class do not have a public constructor!

In this post, I am describing a workaround that enable to create new PropertyItem objects.

The method is, in fact, quite simple. It consists in having a small Jpeg image with Exif information embedded in you application, and loading PropertyItem from it when necessary.

First, you have to add your Jpeg file (let's call it "property.jpg") to your project, and mark it as an embedded resource.

In the Solution Explorer, select the project icon,
In the Project menu, click the Add an existing item menu,
In the dialog box, choose a valid Jpeg file and click Open; the file does appear in the Solution Explorer,
In the Solution Explorer, select the Jpeg file ,
In the Properties view, set the "Build Action" property to "Embedded Resource".

The second step is to add a reference on the System.Drawing assembly to the project, if not present, and to add the following lines at the top of the source file:

Code Copy

using
    System;

    using System.Drawing;

    using System.Drawing.Imaging;

    using System.IO;

    using System.Reflection;

Now when have to load the image and return the first property item it contains :

Code Copy

///
     <summary>

     /// Creates a new property item.
/// </summary>

     /// <returns>A 
     new instance of the <see 
     cref="PropertyItem"/> class.</returns>
public static PropertyItem 
    CreatePropertyImage()

    {// Gets the current assembly, 
      retrieves the stream for the resource and loads the associated image.

     Assembly currentAssembly = Assembly.GetExecutingAssembly();
using(Stream propertyStream = 
     currentAssembly.GetManifestResourceStream(currentAssembly.GetName().Name + 
     "." + "property.jpg"))
using(Image resourceImage = 
     (Image)Image.FromStream(propertyStream))

     {return resourceImage.PropertyItems[0];

     }

    }
   

The job is almost complete : we can now optimize this code to load the image only once and to return a clean object.

Code Copy HideScrollFull

private
     static Image propertyImage;

private static Image 
    PropertyImage

    {get

     {if (propertyImage==null)propertyImage 
       = LoadPropertyImage();

       
      

      return propertyImage;

     }

    }

private static Image 
    LoadPropertyImage()

    {// Gets the current assembly, 
      retrieves the stream for the resource and loads the associated image.

     Assembly currentAssembly = Assembly.GetExecutingAssembly();
using(Stream propertyStream = 
     currentAssembly.GetManifestResourceStream(currentAssembly.GetName().Name + 
     "." + "property.jpg"))
using(Image resourceImage = 
     (Image)Image.FromStream(propertyStream))

     {// Creates a lightweight (1x1 
       pixel) bitmap with a single, empty exif property item.

      // This bitmap will remain in memory during the entire 
       application runtime.

      Image propertyImage = new Bitmap(1, 1);

      PropertyItem propertyItem = resourceImage.PropertyItems[0];

      propertyItem.Id = 0;

      propertyItem.Type = 0;

      propertyItem.Len = 0;

      propertyItem.Value = new byte[0];

      

      propertyImage.SetPropertyItem(propertyItem);

      

      return propertyImage;

     }

    }

/// <summary>

     /// Creates an empty property item.
/// </summary>

     /// <returns>A 
     new, empty instance of the <see 
     cref="PropertyItem"/> class.</returns>
public static PropertyItem 
    CreatePropertyItem()

    {return PropertyImage.PropertyItems[0];

    }

/// <summary>

     /// Creates a new property item having the given 
     id, type and value.
/// </summary>

     /// <param name="id">The 
     identifier of the property item.</param>

     /// <param name="type">The 
     type of value the property item does contain.</param>

     /// <param name="len">The 
     length of the property value.</param>

     /// <param name="value">The 
     property value.</param>

     /// <returns>A 
     new, initialized, instance of the <see 
     cref="PropertyItem"/> class.</returns>
public static PropertyItem 
    CreatePropertyItem(int id, short
    type, int len, byte[]
     value)

    {PropertyItem property = CreatePropertyItem();

     property.Id = id;

     property.Type = type;

     property.Len = len;

     property.Value = value;

    }

. . .

In the next post, we will convert the raw Exif data buffer (the PropertyItem.Value) into the native type.