avalon-cvs mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From hamm...@apache.org
Subject cvs commit: avalon-sandbox/avalon-net/DynamicProxy/DynamicProxyTest Apache.Avalon.DynamicProxy.Test.csproj AssemblyInfo.cs ProxyGeneratorTestCase.cs
Date Sat, 06 Mar 2004 03:29:21 GMT
hammett     2004/03/05 19:29:21

  Added:       avalon-net/DynamicProxy Apache.Avalon.DynamicProxy.csproj
                        AssemblyInfo.cs DynamicProxy.sln
                        IInvocationHandler.cs ProxyGenerator.cs
               avalon-net/DynamicProxy/DynamicProxyTest
                        Apache.Avalon.DynamicProxy.Test.csproj
                        AssemblyInfo.cs ProxyGeneratorTestCase.cs
  Log:
  Simple dynamic proxy (java like proxies) for CLI (Mono/.Net)
  
  Revision  Changes    Path
  1.1                  avalon-sandbox/avalon-net/DynamicProxy/Apache.Avalon.DynamicProxy.csproj
  
  Index: Apache.Avalon.DynamicProxy.csproj
  ===================================================================
  <VisualStudioProject>
      <CSHARP
          ProjectType = "Local"
          ProductVersion = "7.10.3077"
          SchemaVersion = "2.0"
          ProjectGuid = "{70EE6AF2-1F6D-4CC5-A1B2-C3182F035F67}"
      >
          <Build>
              <Settings
                  ApplicationIcon = ""
                  AssemblyKeyContainerName = ""
                  AssemblyName = "Apache.Avalon.DynamicProxy"
                  AssemblyOriginatorKeyFile = ""
                  DefaultClientScript = "JScript"
                  DefaultHTMLPageLayout = "Grid"
                  DefaultTargetSchema = "IE50"
                  DelaySign = "false"
                  OutputType = "Library"
                  PreBuildEvent = ""
                  PostBuildEvent = ""
                  RootNamespace = "Apache.Avalon.DynamicProxy"
                  RunPostBuildEvent = "OnBuildSuccess"
                  StartupObject = ""
              >
                  <Config
                      Name = "Debug"
                      AllowUnsafeBlocks = "false"
                      BaseAddress = "285212672"
                      CheckForOverflowUnderflow = "false"
                      ConfigurationOverrideFile = ""
                      DefineConstants = "DEBUG;TRACE"
                      DocumentationFile = ""
                      DebugSymbols = "true"
                      FileAlignment = "4096"
                      IncrementalBuild = "false"
                      NoStdLib = "false"
                      NoWarn = ""
                      Optimize = "false"
                      OutputPath = "bin\Debug\"
                      RegisterForComInterop = "false"
                      RemoveIntegerChecks = "false"
                      TreatWarningsAsErrors = "false"
                      WarningLevel = "4"
                  />
                  <Config
                      Name = "Release"
                      AllowUnsafeBlocks = "false"
                      BaseAddress = "285212672"
                      CheckForOverflowUnderflow = "false"
                      ConfigurationOverrideFile = ""
                      DefineConstants = "TRACE"
                      DocumentationFile = ""
                      DebugSymbols = "false"
                      FileAlignment = "4096"
                      IncrementalBuild = "false"
                      NoStdLib = "false"
                      NoWarn = ""
                      Optimize = "true"
                      OutputPath = "bin\Release\"
                      RegisterForComInterop = "false"
                      RemoveIntegerChecks = "false"
                      TreatWarningsAsErrors = "false"
                      WarningLevel = "4"
                  />
              </Settings>
              <References>
                  <Reference
                      Name = "System"
                      AssemblyName = "System"
                      HintPath = "C:\WINDOWS\Microsoft.NET\Framework\v1.1.4322\System.dll"
                  />
                  <Reference
                      Name = "System.Data"
                      AssemblyName = "System.Data"
                      HintPath = "C:\WINDOWS\Microsoft.NET\Framework\v1.1.4322\System.Data.dll"
                  />
                  <Reference
                      Name = "System.XML"
                      AssemblyName = "System.Xml"
                      HintPath = "C:\WINDOWS\Microsoft.NET\Framework\v1.1.4322\System.XML.dll"
                  />
              </References>
          </Build>
          <Files>
              <Include>
                  <File
                      RelPath = "AssemblyInfo.cs"
                      SubType = "Code"
                      BuildAction = "Compile"
                  />
                  <File
                      RelPath = "IInvocationHandler.cs"
                      SubType = "Code"
                      BuildAction = "Compile"
                  />
                  <File
                      RelPath = "ProxyGenerator.cs"
                      SubType = "Code"
                      BuildAction = "Compile"
                  />
              </Include>
          </Files>
      </CSHARP>
  </VisualStudioProject>
  
  
  
  
  1.1                  avalon-sandbox/avalon-net/DynamicProxy/AssemblyInfo.cs
  
  Index: AssemblyInfo.cs
  ===================================================================
  // Copyright 2004 The Apache Software Foundation
  // 
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  // 
  //     http://www.apache.org/licenses/LICENSE-2.0
  // 
  // Unless required by applicable law or agreed to in writing, software
  // distributed under the License is distributed on an "AS IS" BASIS,
  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  // See the License for the specific language governing permissions and
  // limitations under the License.
  
  using System.Reflection;
  using System.Runtime.CompilerServices;
  
  [assembly: AssemblyTitle("Avalon DynamicProxy")]
  [assembly: AssemblyDescription("")]
  [assembly: AssemblyConfiguration("")]
  [assembly: AssemblyCompany("The Apache Software Foundation")]
  [assembly: AssemblyProduct("Avalon DynamicProxy")]
  [assembly: AssemblyCopyright("Copyright (c) 2004 The Apache Software Foundation")]
  [assembly: AssemblyTrademark("")]
  [assembly: AssemblyCulture("")]		
  [assembly: AssemblyVersion("1.0.0.0")]
  
  #if STRONG
  [assembly: AssemblyDelaySign(false)]
  [assembly: AssemblyKeyFile("../../../../ApacheAvalon.snk")]
  [assembly: AssemblyKeyName("")]
  #endif
  
  
  
  1.1                  avalon-sandbox/avalon-net/DynamicProxy/DynamicProxy.sln
  
  Index: DynamicProxy.sln
  ===================================================================
  Microsoft Visual Studio Solution File, Format Version 8.00
  Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Apache.Avalon.DynamicProxy", "Apache.Avalon.DynamicProxy.csproj",
"{70EE6AF2-1F6D-4CC5-A1B2-C3182F035F67}"
  	ProjectSection(ProjectDependencies) = postProject
  	EndProjectSection
  EndProject
  Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Apache.Avalon.DynamicProxy.Test", "DynamicProxyTest\Apache.Avalon.DynamicProxy.Test.csproj",
"{EF89321E-FB2A-41B6-85B3-794D50A55CF1}"
  	ProjectSection(ProjectDependencies) = postProject
  	EndProjectSection
  EndProject
  Global
  	GlobalSection(SolutionConfiguration) = preSolution
  		Debug = Debug
  		Release = Release
  	EndGlobalSection
  	GlobalSection(ProjectConfiguration) = postSolution
  		{70EE6AF2-1F6D-4CC5-A1B2-C3182F035F67}.Debug.ActiveCfg = Debug|.NET
  		{70EE6AF2-1F6D-4CC5-A1B2-C3182F035F67}.Debug.Build.0 = Debug|.NET
  		{70EE6AF2-1F6D-4CC5-A1B2-C3182F035F67}.Release.ActiveCfg = Release|.NET
  		{70EE6AF2-1F6D-4CC5-A1B2-C3182F035F67}.Release.Build.0 = Release|.NET
  		{EF89321E-FB2A-41B6-85B3-794D50A55CF1}.Debug.ActiveCfg = Debug|.NET
  		{EF89321E-FB2A-41B6-85B3-794D50A55CF1}.Debug.Build.0 = Debug|.NET
  		{EF89321E-FB2A-41B6-85B3-794D50A55CF1}.Release.ActiveCfg = Release|.NET
  		{EF89321E-FB2A-41B6-85B3-794D50A55CF1}.Release.Build.0 = Release|.NET
  	EndGlobalSection
  	GlobalSection(ExtensibilityGlobals) = postSolution
  	EndGlobalSection
  	GlobalSection(ExtensibilityAddIns) = postSolution
  	EndGlobalSection
  EndGlobal
  
  
  
  1.1                  avalon-sandbox/avalon-net/DynamicProxy/IInvocationHandler.cs
  
  Index: IInvocationHandler.cs
  ===================================================================
  // Copyright 2004 The Apache Software Foundation
  // 
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  // 
  //     http://www.apache.org/licenses/LICENSE-2.0
  // 
  // Unless required by applicable law or agreed to in writing, software
  // distributed under the License is distributed on an "AS IS" BASIS,
  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  // See the License for the specific language governing permissions and
  // limitations under the License.
  
  namespace Apache.Avalon.DynamicProxy
  {
  	using System;
  	using System.Reflection;
  
  	/// <summary>
  	/// Defines the handler that will receive all methods 
  	/// invoked on the proxy object.
  	/// </summary>
  	public interface IInvocationHandler
  	{
  		/// <summary>
  		/// Implementation should invoke the method on the real object.
  		/// </summary>
  		/// <param name="proxy">proxy instance</param>
  		/// <param name="method"><see cref="System.Reflection.MethodBase"/> being
invoked.</param>
  		/// <param name="arguments">Arguments of method - if any</param>
  		/// <returns>Should return the result of method invocation</returns>
  		object Invoke(object proxy, MethodBase method, params object[] arguments);
  	}
  }
  
  
  
  1.1                  avalon-sandbox/avalon-net/DynamicProxy/ProxyGenerator.cs
  
  Index: ProxyGenerator.cs
  ===================================================================
  // Copyright 2004 The Apache Software Foundation
  // 
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  // 
  //     http://www.apache.org/licenses/LICENSE-2.0
  // 
  // Unless required by applicable law or agreed to in writing, software
  // distributed under the License is distributed on an "AS IS" BASIS,
  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  // See the License for the specific language governing permissions and
  // limitations under the License.
  
  namespace Apache.Avalon.DynamicProxy
  {
  	using System;
  	using System.Reflection;
  	using System.Reflection.Emit;
  
  	/// <summary>
  	/// Generates a Java style proxy. This overrides the .Net proxy requirements 
  	/// that forces one to extend MarshalByRefObject or (for a different purpose)
  	/// ContextBoundObject to have a Proxiable class.
  	/// </summary>
  	/// <remarks>
  	/// The <see cref="ProxyGenerator"/> should be used to generate a class 
  	/// implementing the specified interfaces. The class implementation will 
  	/// only call the internal <see cref="IInvocationHandler"/> instance.
  	/// </remarks>
  	/// <example>
  	/// <code>
  	/// MyInvocationHandler handler = ...
  	/// IInterfaceExposed proxy = 
  	///		ProxyGenerator.CreateProxy( new Type[] { typeof(IInterfaceExposed) }, handler );
  	/// </code>
  	/// </example>
  	public class ProxyGenerator
  	{
  		/// <summary>
  		/// Private construtor
  		/// </summary>
  		private ProxyGenerator()
  		{
  		}
  
  		/// <summary>
  		/// Generates a proxy implementing all the specified interfaces and
  		/// redirecting method invocations to the specifed handler.
  		/// </summary>
  		/// <param name="interfaces">Array of interfaces to be implemented</param>
  		/// <param name="handler">instance of <see cref="IInvocationHandler"/></param>
  		/// <returns>Proxy instance</returns>
  		public static object CreateProxy(Type[] interfaces, IInvocationHandler handler)
  		{
  			if (interfaces == null)
  			{
  				throw new ArgumentNullException("interfaces");
  			}
  			if (handler == null)
  			{
  				throw new ArgumentNullException("handler");
  			}
  
  			AssemblyName assemblyName = new AssemblyName();
  			assemblyName.Name = "DynamicAssemblyProxyGen";
  
  			AssemblyBuilder assemblyBuilder = 
  				AppDomain.CurrentDomain.DefineDynamicAssembly(
  				assemblyName, 
  				AssemblyBuilderAccess.Run);
  			
  			ModuleBuilder moduleBuilder = 
  				assemblyBuilder.DefineDynamicModule( assemblyName.Name, true );
  
  			TypeBuilder typeBuilder = moduleBuilder.DefineType( 
  				"ProxyType", TypeAttributes.Public|TypeAttributes.Class, null, interfaces);
  
  			foreach(Type inter in interfaces)
  			{
  				GenerateInterfaceImplementation( typeBuilder, inter );
  			}
  
  			Type generatedType = typeBuilder.CreateType();
  
  			return Activator.CreateInstance( generatedType, new object[] { handler } );
  		}
  
  		/// <summary>
  		/// Iterates over the interfaces and generate implementation 
  		/// for each method in it.
  		/// </summary>
  		/// <param name="typeBuilder"><see cref="TypeBuilder"/> being constructed.</param>
  		/// <param name="inter">Interface type</param>
  		private static void GenerateInterfaceImplementation( 
  			TypeBuilder typeBuilder, Type inter )
  		{
  			if (!inter.IsInterface)
  			{
  				throw new ArgumentException("Type array expects interfaces only.");
  			}
  
  			FieldBuilder handlerField = GenerateField( typeBuilder );
  			ConstructorBuilder constr = GenerateConstructor( typeBuilder, handlerField );
  
  			PropertyInfo[] properties = inter.GetProperties();
  			PropertyBuilder[] propertiesBuilder = new PropertyBuilder[properties.Length];
  
  			for(int i=0; i < properties.Length; i++)
  			{
  				GeneratePropertyImplementation( typeBuilder, properties[i], ref propertiesBuilder[i]
);
  			}
  
  			MethodInfo[] methods = inter.GetMethods();
  
  			foreach(MethodInfo method in methods)
  			{
  				GenerateMethodImplementation( typeBuilder, method, 
  					propertiesBuilder, handlerField, inter );
  			}
  		}
  
  		/// <summary>
  		/// Generates a public field holding the <see cref="IInvocationHandler"/>
  		/// </summary>
  		/// <param name="typeBuilder"><see cref="TypeBuilder"/> being constructed.</param>
  		/// <returns><see cref="FieldBuilder"/> instance</returns>
  		private static FieldBuilder GenerateField( TypeBuilder typeBuilder )
  		{
  			return typeBuilder.DefineField( "handler", 
  				typeof(IInvocationHandler), FieldAttributes.Public );
  		}
  
  		/// <summary>
  		/// Generates one public constructor receiving 
  		/// the <see cref="IInvocationHandler"/> instance.
  		/// </summary>
  		/// <param name="typeBuilder"><see cref="TypeBuilder"/> being constructed.</param>
  		/// <param name="handlerField"><see cref="FieldBuilder"/> instance representing
the handler field</param>
  		/// <returns><see cref="ConstructorBuilder"/> instance</returns>
  		private static ConstructorBuilder GenerateConstructor( 
  			TypeBuilder typeBuilder, FieldBuilder handlerField )
  		{
  			ConstructorBuilder consBuilder = typeBuilder.DefineConstructor(
  				MethodAttributes.Public, 
  				CallingConventions.Standard, 
  				new Type[] { typeof(IInvocationHandler) } );
  			
  			ILGenerator ilGenerator = consBuilder.GetILGenerator();
  			ilGenerator.Emit(OpCodes.Ldarg_0);
  			ilGenerator.Emit(OpCodes.Call, typeof(Object).GetConstructor(new Type[0]));
  			ilGenerator.Emit(OpCodes.Ldarg_0);
  			ilGenerator.Emit(OpCodes.Ldarg_1);
  			ilGenerator.Emit(OpCodes.Stfld, handlerField);
  			ilGenerator.Emit(OpCodes.Ret);
  
  			return consBuilder;
  		}
  
  		/// <summary>
  		/// Generate property implementation
  		/// </summary>
  		/// <param name="typeBuilder"><see cref="TypeBuilder"/> being constructed.</param>
  		/// <param name="property"></param>
  		/// <param name="propertyBuilder"></param>
  		private static void GeneratePropertyImplementation( 
  			TypeBuilder typeBuilder, PropertyInfo property, ref PropertyBuilder propertyBuilder )
  		{
  			propertyBuilder = typeBuilder.DefineProperty( 
  				property.Name, property.Attributes, property.PropertyType, null);
  		}
  
  		/// <summary>
  		/// Generates implementation for each method.
  		/// </summary>
  		/// <param name="typeBuilder"><see cref="TypeBuilder"/> being constructed.</param>
  		/// <param name="method"></param>
  		/// <param name="properties"></param>
  		private static void GenerateMethodImplementation( 
  			TypeBuilder typeBuilder, MethodInfo method, 
  			PropertyBuilder[] properties, FieldBuilder handlerField, Type inter )
  		{
  			ParameterInfo[] parameterInfo = method.GetParameters();
  
  			System.Type[] parameters = new System.Type[parameterInfo.Length];
  			
  			for (int i=0; i<parameterInfo.Length; i++)
  			{
  				parameters[i] = parameterInfo[i].ParameterType;
  			}
  
  			MethodAttributes atts = MethodAttributes.Public|MethodAttributes.Virtual;
  
  			if ( method.Name.StartsWith("set_") || method.Name.StartsWith("get_") )
  			{
  				atts = MethodAttributes.Public|MethodAttributes.SpecialName|MethodAttributes.Virtual;
  			}
  
  			MethodBuilder methodBuilder = 
  				typeBuilder.DefineMethod( method.Name, atts, CallingConventions.Standard, 
  				method.ReturnType, parameters );
  
  			if ( method.Name.StartsWith("set_") || method.Name.StartsWith("get_") )
  			{
  				foreach( PropertyBuilder property in properties )
  				{
  					if (property == null)
  					{
  						break;
  					}
  
  					if (!property.Name.Equals( method.Name.Substring(4) ))
  					{
  						continue;
  					}
  
  					if ( methodBuilder.Name.StartsWith("set_") )
  					{
  						property.SetSetMethod( methodBuilder );
  						break;
  					}
  					else 
  					{
  						property.SetGetMethod( methodBuilder );
  						break;
  					}
  				}
  			}
  
  			WriteILForMethod( methodBuilder, parameters, handlerField );
  		}
  
  		/// <summary>
  		/// Writes the stack for the method implementation. This 
  		/// method generates the IL stack for property get/set method and
  		/// ordinary methods.
  		/// </summary>
  		/// <remarks>
  		/// The method implementation would be as simple as:
  		/// <code>
  		/// public void SomeMethod( int parameter )
  		/// {
  		///     MethodBase method = MethodBase.GetCurrentMethod();
  		///     handler.Invoke( this, method, new object[] { parameter } );
  		/// }
  		/// </code>
  		/// </remarks>
  		/// <param name="typeBuilder"><see cref="TypeBuilder"/> being constructed.</param>
  		/// <param name="parameters"></param>
  		/// <param name="handlerField"></param>
  		private static void WriteILForMethod( MethodBuilder builder, 
  			System.Type[] parameters, FieldBuilder handlerField )
  		{
  			int arrayPositionInStack = 1;
  
  			ILGenerator ilGenerator = builder.GetILGenerator();
  
  			ilGenerator.DeclareLocal( typeof( MethodBase ) );
  
  			if (builder.ReturnType != typeof(void))
  			{
  				ilGenerator.DeclareLocal(builder.ReturnType);
  				arrayPositionInStack = 2;
  			}
  
  			ilGenerator.DeclareLocal( typeof(object[]) );
  
  			ilGenerator.Emit(OpCodes.Call, typeof(MethodBase).GetMethod("GetCurrentMethod") );
  
  			ilGenerator.Emit(OpCodes.Stloc_0);
  			ilGenerator.Emit(OpCodes.Ldarg_0);
  			ilGenerator.Emit(OpCodes.Ldfld, handlerField );
  			ilGenerator.Emit(OpCodes.Ldarg_0);
  			ilGenerator.Emit(OpCodes.Ldloc_0);
  			ilGenerator.Emit(OpCodes.Ldc_I4, parameters.Length);
  			ilGenerator.Emit(OpCodes.Newarr, typeof(object) );
  
  			if (parameters.Length != 0)
  			{
  				ilGenerator.Emit(OpCodes.Stloc, arrayPositionInStack);
  				ilGenerator.Emit(OpCodes.Ldloc, arrayPositionInStack);
  			}
  
  			for (int c=0; c<parameters.Length; c++)
  			{
  				ilGenerator.Emit(OpCodes.Ldc_I4, c);
  				ilGenerator.Emit(OpCodes.Ldarg, c+1);
  
  				if (parameters[c].IsValueType)
  				{
  					ilGenerator.Emit(OpCodes.Box, parameters[c].UnderlyingSystemType);
  				}
  
  				ilGenerator.Emit(OpCodes.Stelem_Ref);
  				ilGenerator.Emit(OpCodes.Ldloc, arrayPositionInStack);
  			}
  
  			ilGenerator.Emit(OpCodes.Callvirt, typeof(IInvocationHandler).GetMethod("Invoke") );
  
  			if (builder.ReturnType != typeof(void))
  			{
  				if (!builder.ReturnType.IsValueType)
  				{
  					ilGenerator.Emit(OpCodes.Castclass, builder.ReturnType);
  				}
  				else
  				{
  					ilGenerator.Emit(OpCodes.Unbox, builder.ReturnType);
  					ilGenerator.Emit(ConvertTypeToOpCode(builder.ReturnType));
  				}
  
  				ilGenerator.Emit(OpCodes.Stloc, 1);
  
  				Label label = ilGenerator.DefineLabel();
  				ilGenerator.Emit(OpCodes.Br_S, label);
  				ilGenerator.MarkLabel(label);
  				ilGenerator.Emit(OpCodes.Ldloc, 1);
  			}
  			else
  			{
  				ilGenerator.Emit(OpCodes.Pop);
  			}
  
  
  			ilGenerator.Emit(OpCodes.Ret);
  		}
  
  		/// <summary>
  		/// Converts a Value type to a correspondent OpCode of 
  		/// </summary>
  		/// <param name="type"></param>
  		/// <returns></returns>
  		private static OpCode ConvertTypeToOpCode( Type type )
  		{
  			if ( type.Equals( typeof(Int32) ) )
  			{
  				return OpCodes.Ldind_I4;
  			}
  			else if ( type.Equals( typeof(Int16) ) )
  			{
  				return OpCodes.Ldind_I2;
  			}
  			else if ( type.Equals( typeof(Int64) ) )
  			{
  				return OpCodes.Ldind_I8;
  			}
  			else if ( type.Equals( typeof(Single) ) )
  			{
  				return OpCodes.Ldind_R4;
  			}
  			else if ( type.Equals( typeof(Double) ) )
  			{
  				return OpCodes.Ldind_R8;
  			}
  			else if ( type.Equals( typeof(UInt16) ) )
  			{
  				return OpCodes.Ldind_U2;
  			}
  			else if ( type.Equals( typeof(UInt32) ) )
  			{
  				return OpCodes.Ldind_U4;
  			}
  			else
  			{
  				throw new ArgumentException("Type " + type + " could not be converted to a OpCode");
  			}
  		}
  	}
  }
  
  
  
  1.1                  avalon-sandbox/avalon-net/DynamicProxy/DynamicProxyTest/Apache.Avalon.DynamicProxy.Test.csproj
  
  Index: Apache.Avalon.DynamicProxy.Test.csproj
  ===================================================================
  <VisualStudioProject>
      <CSHARP
          ProjectType = "Local"
          ProductVersion = "7.10.3077"
          SchemaVersion = "2.0"
          ProjectGuid = "{EF89321E-FB2A-41B6-85B3-794D50A55CF1}"
      >
          <Build>
              <Settings
                  ApplicationIcon = ""
                  AssemblyKeyContainerName = ""
                  AssemblyName = "Apache.Avalon.DynamicProxy.Test"
                  AssemblyOriginatorKeyFile = ""
                  DefaultClientScript = "JScript"
                  DefaultHTMLPageLayout = "Grid"
                  DefaultTargetSchema = "IE50"
                  DelaySign = "false"
                  OutputType = "Library"
                  PreBuildEvent = ""
                  PostBuildEvent = ""
                  RootNamespace = "Apache.Avalon.DynamicProxy.Test"
                  RunPostBuildEvent = "OnBuildSuccess"
                  StartupObject = ""
              >
                  <Config
                      Name = "Debug"
                      AllowUnsafeBlocks = "false"
                      BaseAddress = "285212672"
                      CheckForOverflowUnderflow = "false"
                      ConfigurationOverrideFile = ""
                      DefineConstants = "DEBUG;TRACE"
                      DocumentationFile = ""
                      DebugSymbols = "true"
                      FileAlignment = "4096"
                      IncrementalBuild = "false"
                      NoStdLib = "false"
                      NoWarn = ""
                      Optimize = "false"
                      OutputPath = "bin\Debug\"
                      RegisterForComInterop = "false"
                      RemoveIntegerChecks = "false"
                      TreatWarningsAsErrors = "false"
                      WarningLevel = "4"
                  />
                  <Config
                      Name = "Release"
                      AllowUnsafeBlocks = "false"
                      BaseAddress = "285212672"
                      CheckForOverflowUnderflow = "false"
                      ConfigurationOverrideFile = ""
                      DefineConstants = "TRACE"
                      DocumentationFile = ""
                      DebugSymbols = "false"
                      FileAlignment = "4096"
                      IncrementalBuild = "false"
                      NoStdLib = "false"
                      NoWarn = ""
                      Optimize = "true"
                      OutputPath = "bin\Release\"
                      RegisterForComInterop = "false"
                      RemoveIntegerChecks = "false"
                      TreatWarningsAsErrors = "false"
                      WarningLevel = "4"
                  />
              </Settings>
              <References>
                  <Reference
                      Name = "System"
                      AssemblyName = "System"
                      HintPath = "C:\WINDOWS\Microsoft.NET\Framework\v1.1.4322\System.dll"
                  />
                  <Reference
                      Name = "System.Data"
                      AssemblyName = "System.Data"
                      HintPath = "C:\WINDOWS\Microsoft.NET\Framework\v1.1.4322\System.Data.dll"
                  />
                  <Reference
                      Name = "System.XML"
                      AssemblyName = "System.Xml"
                      HintPath = "C:\WINDOWS\Microsoft.NET\Framework\v1.1.4322\System.XML.dll"
                  />
                  <Reference
                      Name = "DProxy"
                      Project = "{70EE6AF2-1F6D-4CC5-A1B2-C3182F035F67}"
                      Package = "{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}"
                  />
                  <Reference
                      Name = "nunit.framework"
                      AssemblyName = "nunit.framework"
                      HintPath = "..\..\..\..\..\..\dotnet\NUnit2\bin\nunit.framework.dll"
                  />
              </References>
          </Build>
          <Files>
              <Include>
                  <File
                      RelPath = "AssemblyInfo.cs"
                      SubType = "Code"
                      BuildAction = "Compile"
                  />
                  <File
                      RelPath = "ProxyGeneratorTestCase.cs"
                      SubType = "Code"
                      BuildAction = "Compile"
                  />
              </Include>
          </Files>
      </CSHARP>
  </VisualStudioProject>
  
  
  
  
  1.1                  avalon-sandbox/avalon-net/DynamicProxy/DynamicProxyTest/AssemblyInfo.cs
  
  Index: AssemblyInfo.cs
  ===================================================================
  // Copyright 2004 The Apache Software Foundation
  // 
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  // 
  //     http://www.apache.org/licenses/LICENSE-2.0
  // 
  // Unless required by applicable law or agreed to in writing, software
  // distributed under the License is distributed on an "AS IS" BASIS,
  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  // See the License for the specific language governing permissions and
  // limitations under the License.
  
  using System.Reflection;
  using System.Runtime.CompilerServices;
  
  [assembly: AssemblyTitle("Avalon DynamicProxy Test cases")]
  [assembly: AssemblyDescription("")]
  [assembly: AssemblyConfiguration("")]
  [assembly: AssemblyCompany("The Apache Software Foundation")]
  [assembly: AssemblyProduct("Avalon DynamicProxy Test cases")]
  [assembly: AssemblyCopyright("Copyright (c) 2004 The Apache Software Foundation")]
  [assembly: AssemblyTrademark("")]
  [assembly: AssemblyCulture("")]		
  [assembly: AssemblyVersion("1.0.0.0")]
  
  
  
  
  1.1                  avalon-sandbox/avalon-net/DynamicProxy/DynamicProxyTest/ProxyGeneratorTestCase.cs
  
  Index: ProxyGeneratorTestCase.cs
  ===================================================================
  // Copyright 2004 The Apache Software Foundation
  // 
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  // 
  //     http://www.apache.org/licenses/LICENSE-2.0
  // 
  // Unless required by applicable law or agreed to in writing, software
  // distributed under the License is distributed on an "AS IS" BASIS,
  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  // See the License for the specific language governing permissions and
  // limitations under the License.
  
  namespace Apache.Avalon.DynamicProxy.Test
  {
  	using System;
  	using System.Reflection;
  
  	using NUnit.Framework;
  
  	using Apache.Avalon.DynamicProxy;
  
  	/// <summary>
  	/// Summary description for ProxyGeneratorTestCase.
  	/// </summary>
  	[TestFixture]
  	public class ProxyGeneratorTestCase : Assertion, IInvocationHandler, IMyInterface
  	{
  		protected String nameProperty;
  
  		[Test]
  		public void TestSimpleCase()
  		{
  			object proxy = ProxyGenerator.CreateProxy( new Type[] { typeof(IMyInterface) }, this
);
  			AssertNotNull( proxy );
  			Assert( typeof(IMyInterface).IsAssignableFrom( proxy.GetType() ) );
  
  			IMyInterface inter = (IMyInterface) proxy;
  			inter.Calc(1, "ola");
  			inter.Nome = "opa";
  			AssertEquals( "opa", inter.Nome );
  			AssertEquals( 45, inter.Calc( 20, 25 ) );
  
  		}
  
  		#region IInvocationHandler Members
  
  		public object Invoke(object obj, MethodBase method, params object[] arguments)
  		{
  			Type[] parameters = new Type[arguments.Length];
  			
  			for(int i=0; i < arguments.Length; i++ )
  			{
  				parameters[i] = arguments[i].GetType();
  			}
  
  			MethodInfo ourMethod = this.GetType().GetMethod( method.Name, parameters );
  
  			AssertNotNull( ourMethod );
  			
  			return ourMethod.Invoke( this, arguments );
  		}
  
  		#endregion
  
  		#region IMyInterface Members
  
  		public String Nome
  		{
  			get
  			{
  				return nameProperty;
  			}
  			set
  			{
  				nameProperty = value;
  			}
  		}
  
  		public void Calc(int x, String y)
  		{
  		}
  
  		public void Calc(int x, String y, Single ip)
  		{
  		}
  
  		public int Calc(int x, int y)
  		{
  			return x + y;
  		}
  
  		public int Calc(int x, int y, int z, Single h)
  		{
  			return x + y + z + (int)h;
  		}
  
  		#endregion
  	}
  
  	/// <summary>
  	/// 
  	/// </summary>
  	public interface IMyInterface
  	{
  		String Nome
  		{
  			get;
  			set;
  		}
  
  		void Calc(int x, String y);
  
  		void Calc(int x, String y, Single ip);
  
  		int Calc(int x, int y);
  
  		int Calc(int x, int y, int z, Single h);
  	}
  
  	public class MyTest : IMyInterface
  	{
  		IInvocationHandler handler = null;
  
  		#region IMyInterface Members
  
  		public String Nome
  		{
  			get
  			{
  				// TODO:  Add MyTest.Nome getter implementation
  				return null;
  			}
  			set
  			{
  				// TODO:  Add MyTest.Nome setter implementation
  			}
  		}
  
  		public void Calc(int x, String y)
  		{
  			MethodBase method = MethodBase.GetCurrentMethod();
  			handler.Invoke( this, method, x, y );
  		}
  
  		public void Calc(int x, String y, Single ip)
  		{
  			MethodBase method = MethodBase.GetCurrentMethod();
  			handler.Invoke( this, method, x, y, ip );
  		}
  
  		public int Calc(int x, int y)
  		{
  			MethodBase method = MethodBase.GetCurrentMethod();
  			return (int) handler.Invoke( this, method, x, y );
  		}
  
  		public int Calc(int x, int y, int z, Single h)
  		{
  			MethodBase method = MethodBase.GetCurrentMethod();
  			return (int) handler.Invoke( this, method, x, y, h );
  		}
  
  		#endregion
  
  	}
  
  }
  
  
  
  

---------------------------------------------------------------------
To unsubscribe, e-mail: cvs-unsubscribe@avalon.apache.org
For additional commands, e-mail: cvs-help@avalon.apache.org


Mime
View raw message