genericfactory.cs

基于sqlserver2k,reporting service的扩展(auth,render,deliver==)应用（mssql,RS,AS,BI）

using System;
using System.IO;
using System.Reflection;

namespace AWC.Reporter.Web.EnterpriseReporting
{
	/// <summary>
	/// Acts as the basic implementation for the Factory design pattern to load and bind to
	/// report adapters
	/// </summary>
	sealed class GenericFactory
	{
		#region Declarations

		private const string COMMA_DELIMITER	 = ",";

		#endregion

		#region Constructors

		static GenericFactory(){}
		

		private GenericFactory(){}


		#endregion

		#region Private Helper Methods

		/// <summary>
		/// Takes incoming assembly full type string, and splits the type into two strings, the typeName and assemblyName.  Those are passed by as OUT params
		/// </summary>
		/// <param name="fullType"></param>
		/// <param name="typeName"></param>
		/// <param name="assemblyName"></param>
		private static void SplitType( string fullType, out string typeName, out string assemblyName )
		{

			string[] parts = fullType.Split( COMMA_DELIMITER.ToCharArray() );

			switch (parts.Length)
			{
				case 2: 	// explicit assembly path specified
					//  package type name:
					typeName = parts[0].Trim();
					//  package fully-qualified assembly name separated by commas
					assemblyName = parts[1].Trim();	
					break;
				case 5: 
					//  package type name:
					typeName = parts[0].Trim();
					//  package fully-qualified assembly name separated by commas
					assemblyName = String.Concat(   parts[1].Trim() + COMMA_DELIMITER,
						parts[2].Trim() + COMMA_DELIMITER,
						parts[3].Trim() + COMMA_DELIMITER,
						parts[4].Trim() );
					return;					
				default: throw new ArgumentException(String.Format ("Invalid argument {0}.", fullType ));
			}
	
		}


		#endregion

		#region Create Overloads

		/// <summary>
		/// Returns an object instantiated by the Activator, using fully-qualified combined assembly-type  supplied.
		/// </summary>
		/// <param name="fullTypeName">the fully-qualified type name</param>
		/// <returns>instance of requested assembly/type typed as System.Object</returns>
		public static object Create( string fullTypeName )
		{
			string assemblyName;
			string typeName;
			//  use helper to split
			SplitType( fullTypeName, out typeName, out assemblyName );
			//  just call main overload
			return Create( assemblyName, typeName, null );
		}


		/// <summary>
		/// Returns an object instantiated by the Activator, using fully-qualified asm/type supplied.
		/// </summary>
		/// <param name="assemblyName">fully-qualified assembly name</param>
		/// <param name="typeName">the type name</param>
		/// <returns>instance of requested assembly/type typed as System.Object</returns>
		public static object Create( string assemblyName, string typeName )
		{
			string aName;
			string tName;

			//  use helper to split
			SplitType( typeName + "," + assemblyName , out tName, out aName );
			
			//  just call main overload
			return Create( aName, tName, null );
		}


		/// <summary>
		/// Returns an object instantiated by the Activator, using fully-qualified asm/type supplied.
		/// </summary>
		/// <param name="assemblyName">fully-qualified assembly name</param>
		/// <param name="typeName">the type name</param>
		/// <param name="constructorArguments">constructor arguments for type to be created</param>
		/// <returns>instance of requested assembly/type typed as System.Object</returns>
		public static object Create( string assemblyName, string typeName, object[] constructorArguments )
		{
			Assembly assemblyInstance			= null;
			Type typeInstance					= null;

			try 
			{
				if (assemblyName.IndexOf(Path.DirectorySeparatorChar)>0)
					// path is specified, get assembly from path
					assemblyInstance = Assembly.LoadFrom(assemblyName.Trim() );
				else
					//  expect the assembly to located in the app bin folder
					/// use full asm name to get assembly instance
					assemblyInstance = Assembly.Load(assemblyName.Trim() );
			}
			catch ( Exception e )
			{		
				throw new TypeLoadException( 
					String.Format ("Cannot load type {0} from assembly {1}.", 
					assemblyName , typeName ), 
					e );
			}
			
			try
			{
				//  use reflection to get to the adapter class
				typeInstance = assemblyInstance.GetType( typeName.Trim(), true, false );

				//  instantiate the adapter
				if( constructorArguments != null )
				{
					return Activator.CreateInstance( typeInstance, constructorArguments);
				}
				else
				{
					return Activator.CreateInstance( typeInstance );
				}
			}
			catch( Exception e )
			{	
				throw new TypeLoadException( 
					String.Format ("Cannot load type {0} from assembly {1}.", 
					assemblyName , typeName ), 
					e );
			}
		}
		
		
		#endregion
	}
}