TypeLibraryHelper.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ WCF / WCF / 3.5.30729.1 / untmp / Orcas / SP / ndp / cdf / src / WCF / ServiceModel / System / ServiceModel / ComIntegration / TypeLibraryHelper.cs / 1 / TypeLibraryHelper.cs

                            //------------------------------------------------------------------------------ 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------------------------
namespace System.ServiceModel.ComIntegration
{ 
     using System;
     using System.Runtime.InteropServices; 
     using System.Runtime.InteropServices.ComTypes; 
     using Microsoft.Win32;
     using System.Reflection; 
     using System.Collections.Generic;
     using System.Threading;
     using System.Diagnostics;
     using System.ServiceModel.Diagnostics; 

 
 

     internal sealed class TypeLibraryHelper 
     {

         internal static Assembly GenerateAssemblyFromNativeTypeLibrary (Guid iid, Guid typeLibraryID, ITypeLib typeLibrary)
         { 
                TypeLibraryHelper helper = GetHelperInstance ();
                try 
                { 
                    return helper.GenerateAssemblyFromNativeTypeLibInternal (iid, typeLibraryID, typeLibrary);
 
                }
                finally
                {
                    ReleaseHelperInstance (); 
                }
 
 
         }
         private static  object instanceLock = new object (); 
         private static  TypeLibraryHelper instance;
         private static  int instanceCount = 0;
         private static  TypeLibraryHelper GetHelperInstance ()
         { 
            lock (instanceLock)
            { 
                if (instance == null) 
                {
                    TypeLibraryHelper tlhTemp = new TypeLibraryHelper(); 
                    Thread.MemoryBarrier();
                    instance = tlhTemp;
                }
            } 

            Interlocked.Increment (ref instanceCount); 
            return instance; 
         }
 
         private static void ReleaseHelperInstance ()
         {
            if (0 == Interlocked.Decrement (ref instanceCount))
                instance = null; 
         }
 
 
         internal class  ConversionEventHandler : ITypeLibImporterNotifySink
         { 

                Guid iid;
                Guid typeLibraryID;
                public ConversionEventHandler (Guid iid, Guid typeLibraryID) 
                {
                    this.iid = iid; 
                    this.typeLibraryID = typeLibraryID; 
                }
 
                void ITypeLibImporterNotifySink.ReportEvent( ImporterEventKind eventKind, int eventCode, string eventMsg )
                {
                    ComPlusTLBImportTrace.Trace(TraceEventType.Verbose, TraceCode.ComIntegrationTLBImportConverterEvent,
                                SR.TraceCodeComIntegrationTLBImportConverterEvent, iid, typeLibraryID, eventKind, eventCode, eventMsg); 
                }
 
                Assembly ITypeLibImporterNotifySink.ResolveRef( object typeLib ) 
                {
 
                   ITypeLib tlb = typeLib as ITypeLib;
                   IntPtr ptr = IntPtr.Zero;
                   try
                   { 
                        tlb.GetLibAttr(out ptr);
                        System.Runtime.InteropServices.ComTypes.TYPELIBATTR attr = (System.Runtime.InteropServices.ComTypes.TYPELIBATTR)Marshal.PtrToStructure(ptr, typeof(System.Runtime.InteropServices.ComTypes.TYPELIBATTR)); 
                        return TypeLibraryHelper.GenerateAssemblyFromNativeTypeLibrary (iid, attr.guid, typeLib as ITypeLib); 

                   } 
                   finally
                   {
                        if ((ptr != IntPtr.Zero) && (tlb != null))
                             tlb.ReleaseTLibAttr (ptr); 
                   }
                } 
 
          }
 
          TypeLibConverter TypelibraryConverter = new TypeLibConverter();
          Dictionary  TypelibraryAssembly  = new Dictionary  ();

 
          private string GetRandomName ()
          { 
               Guid guid = Guid.NewGuid (); 
               String strGuid = guid.ToString ();
               return strGuid.Replace ('-','_'); 
          }
          private Assembly GenerateAssemblyFromNativeTypeLibInternal (Guid iid, Guid typeLibraryID, ITypeLib typeLibrary)
          {
               Assembly asm = null; 

               try 
               { 
                   lock (this)
                   { 
                       TypelibraryAssembly.TryGetValue(typeLibraryID, out asm);
                       if (asm == null)
                       {
                           string assemblyName = ""; 
                           string notused1 = "";
                           string notused2 = ""; 
                           int notused3; 
                           string namespaceName;
                           typeLibrary.GetDocumentation(-1, out namespaceName, out notused1, out notused3, out notused2); 
                           if (String.IsNullOrEmpty(namespaceName))
                           {
                               DiagnosticUtility.DebugAssert("Assembly cannot be null");
 
                               throw DiagnosticUtility.ExceptionUtility.ThrowHelperInternal(true);
                           } 
                           assemblyName = String.Concat(namespaceName, GetRandomName(), ".dll"); 
                           asm = TypelibraryConverter.ConvertTypeLibToAssembly(typeLibrary, assemblyName, TypeLibImporterFlags.SerializableValueClasses, new ConversionEventHandler(iid, typeLibraryID), null, null, namespaceName, null);
                           TypelibraryAssembly[typeLibraryID] = asm; 
                        }
                    }

               } 
               catch (ReflectionTypeLoadException )
               { 
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError (new InvalidOperationException (SR.GetString (SR.FailedToConvertTypelibraryToAssembly))); 

               } 

               if (asm == null)
               {
                   DiagnosticUtility.DebugAssert("Assembly cannot be null"); 

                   throw DiagnosticUtility.ExceptionUtility.ThrowHelperInternal(true); 
               } 
               return asm;
          } 
     }
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK