testCode

最新推荐文章于 2024-06-12 09:48:34 发布
最新推荐文章于 2024-06-12 09:48:34 发布
阅读量110 收藏
点赞数
文章标签： c# 人工智能 大数据

博客代码高亮测试

AS3——

<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" 
			   xmlns:s="library://ns.adobe.com/flex/spark" 
			   xmlns:mx="library://ns.adobe.com/flex/mx" minWidth="400" minHeight="300"
			   initialize="initApp()" addedToStage="onAddedToStage()">
	<fx:Declarations>
		<!-- 将非可视元素（例如服务、值对象）放在此处 -->
	</fx:Declarations>
	<fx:Script>
		<![CDATA[
			import away3d.cameras.*;
			import away3d.core.base.*;
			import away3d.events.*;
			import away3d.materials.*;
			import away3d.primitives.*;
			
			import mx.core.UIComponent;
			
			private var m_world:WorldShow = null;
			private var m_worldCtl:UIComponent = null;
			
			private function initApp():void
			{
				doAdd();
			}
			
			private function onAddedToStage():void
			{
				//doAdd();
				if (null!=stage && null!=m_world)
				{
					stage.focus = m_world;
				}
			}
			
			private function doAdd():void
			{
				if (null!=m_world) return;
				m_world = new WorldShow();
				m_world.addEventListener(CameraEvent.CAMERA_UPDATED, onCameraUpdated, false, 0, true);
				m_world.addEventListener(WorldShow.SELECTED_CHANGED, onSelectedChanged, false, 0, true);
				
				//cvsWorld.addChild(pan);
				m_worldCtl = new UIComponent();
				m_worldCtl.addChild(m_world);
				//cvsWorld.addChildAt(m_worldCtl, 0);	// 最底层
				cvsWorld.addElementAt(m_worldCtl, 0);
				
				if (null!=stage)
				{
					stage.focus = m_world;
				}
			}
			
			private function doRemove():void
			{
				if (null==m_world)
					return;
				//
				m_worldCtl.removeChild(m_world);
				//cvsWorld.removeChild(m_worldCtl);
				cvsWorld.removeElement(m_worldCtl);
				m_world = null;
				m_worldCtl = null;
			}
			
			private function doFullScreen():void
			{
				if (stage.displayState == StageDisplayState.NORMAL)
				{
					stage.displayState = StageDisplayState.FULL_SCREEN;
				}
				else
				{
					stage.displayState = StageDisplayState.NORMAL;
				}
			}
			
			private function doSetPos():void
			{
				if (null==m_world) return;
				var nx:Number = Number(txtX.text);
				var ny:Number = Number(txtY.text);
				var nz:Number = Number(txtZ.text);
				var nrx:Number = Number(txtRX.text);
				var nry:Number = Number(txtRY.text);
				var nrz:Number = Number(txtRZ.text);
				
				var camera:Camera3D=m_world.camera;
				camera.rotationX = nrx;
				camera.rotationY = nry;
				camera.rotationZ = nrz;
				camera.position = new Vector3D(nx, ny, nz);
				camera.update();
				//camera.hover(true);
				m_world.notifyCameraUpdate();
			}
			
			// 镜头改变事件
			private function onCameraUpdated(e:CameraEvent):void
			{
				//
				if (null==e)	return;
				var camera:Camera3D = e.camera;
				//trace(camera.x);
				if (null==camera)	return;
				//
				txtX.text = String(camera.x.toFixed(2));
				txtY.text = String(camera.y.toFixed(2));
				txtZ.text = String(camera.z.toFixed(2));
				txtRX.text = String(camera.rotationX.toFixed(2));
				txtRY.text = String(camera.rotationY.toFixed(2));
				txtRZ.text = String(camera.rotationZ.toFixed(2));
				txtfov.text = String(camera.fov.toFixed(2));
				txtfocus.text = String(camera.focus.toFixed(2));
				txtzoom.text = String(camera.zoom.toFixed(2));
			}
			
			private function doSetFov():void
			{
				if (null==m_world) return;
				m_world.camera.fov = Number(txtfov.text);
				m_world.fovDefault = m_world.camera.fov;
				m_world.camera.update();
				m_world.notifyCameraUpdate();
			}
			
			private function doSetFocus():void
			{
				if (null==m_world) return;
				m_world.camera.focus = Number(txtfocus.text);
				var fov:Number = Number(txtfovDef.text);
				if (!isNaN(fov) && fov>0)
				{
					m_world.camera.update();
					m_world.camera.fov = fov;
					m_world.fovDefault = fov;
				}
				else
				{
					m_world.camera.update();
					m_world.fovDefault = m_world.camera.fov;
				}
				m_world.camera.update();
				m_world.notifyCameraUpdate();
			}
			
			private function doSetZoom():void
			{
				if (null==m_world) return;
				m_world.camera.zoom = Number(txtzoom.text);
				m_world.camera.update();
				m_world.fovDefault = m_world.camera.fov;
				m_world.camera.update();
				m_world.notifyCameraUpdate();
			}
			
			private function onSelectedChanged(e:MouseEvent3D):void
			{
				if (null==e)	return;
				if (null==e.object)	return;
				//trace(e.object.name);
				txtObjName.text = e.object.name;
				txtOX.text = String(e.object.x.toFixed(2));
				txtOY.text = String(e.object.y.toFixed(2));
				txtOZ.text = String(e.object.z.toFixed(2));
				txtORX.text = String(e.object.rotationX.toFixed(2));
				txtORY.text = String(e.object.rotationY.toFixed(2));
				txtORZ.text = String(e.object.rotationZ.toFixed(2));
			}
			
			private function doObjSetPos():void
			{
				if (null==m_world) return;
				if (null==m_world.selected)	return;
				var nx:Number = Number(txtOX.text);
				var ny:Number = Number(txtOY.text);
				var nz:Number = Number(txtOZ.text);
				var nrx:Number = Number(txtORX.text);
				var nry:Number = Number(txtORY.text);
				var nrz:Number = Number(txtORZ.text);
				m_world.selected.position = new Vector3D(nx, ny, nz, 1);
			}
			
			protected function chkmoveLockY_clickHandler(event:MouseEvent):void
			{
				// TODO Auto-generated method stub
				m_world.moveLockY = chkmoveLockY.selected;
			}
			
			protected function chklimitCamera_clickHandler(event:MouseEvent):void
			{
				// TODO Auto-generated method stub
				m_world.limitCamera = chklimitCamera.selected;
			}
			
		]]>
	</fx:Script>
	<s:Group id="cvsWorld" x="0" y="0" width="100%" height="100%">
		<s:Panel id="pnlTool" y="10" right="10" width="316" height="200" backgroundAlpha="0.60"
				 title="WorldShow">
			<mx:TabNavigator width="100%" height="100%" creationPolicy="all" backgroundAlpha="0.10">
				<s:NavigatorContent width="100%" height="100%" label="World">
					<s:VGroup x="0" y="0" width="100%" height="100%">
						<s:HGroup width="100%">
							<s:Button id="btnAdd" label="Add" click="doAdd()"/>
							<s:Button id="btnRemove" label="Remove" click="doRemove()"/>
							<s:Button id="btnFullScreen" label="FullScreen" click="doFullScreen()"/>
						</s:HGroup>
						<s:HGroup width="100%">
							<s:CheckBox id="chkmoveLockY" label="moveLockY(Y锁定移动)"
										click="chkmoveLockY_clickHandler(event)" selected="true"/>
							<s:CheckBox id="chklimitCamera" label="limitCamera(限制镜头)"
										click="chklimitCamera_clickHandler(event)" selected="true"/>
						</s:HGroup>
					</s:VGroup>
				</s:NavigatorContent>
				<s:NavigatorContent width="100%" height="100%" label="Camera">
					<s:VGroup x="0" y="0" width="100%" height="100%">
						<s:HGroup width="100%">
							<s:Button id="btnSetPos" label="SetPos" click="doSetPos()"/>
						</s:HGroup>
						<s:HGroup width="100%">
							<s:Label text="x:"/>
							<s:TextInput id="txtX" width="80"/>
							<s:Label text="y:"/>
							<s:TextInput id="txtY" width="80"/>
							<s:Label text="z:"/>
							<s:TextInput id="txtZ" width="80"/>
						</s:HGroup>
						<s:HGroup width="100%">
							<s:Label text="rx:"/>
							<s:TextInput id="txtRX" width="80"/>
							<s:Label text="ry:"/>
							<s:TextInput id="txtRY" width="80"/>
							<s:Label text="rz:"/>
							<s:TextInput id="txtRZ" width="80"/>
						</s:HGroup>
						<s:HGroup width="100%">
							<s:Label text="fov:"/>
							<s:TextInput id="txtfov" width="64"/>
							<s:Label text="focus:"/>
							<s:TextInput id="txtfocus" width="64"/>
							<s:Label text="zoom:"/>
							<s:TextInput id="txtzoom" width="64"/>
						</s:HGroup>
						<s:HGroup width="100%">
							<s:Button id="btnSetFov" label="set fov" click="doSetFov()"/>
							<s:Button id="btnSetFocus" label="set focus" click="doSetFocus()"/>
							<s:TextInput id="txtfovDef" width="80"
										 prompt="fov默认值。当按下“set foucs”时，同时会修改fov。若该文本框为空，就不修改。"/>
							<s:Button id="btnSetZoom" label="set zoom" click="doSetZoom()"/>
						</s:HGroup>
					</s:VGroup>
				</s:NavigatorContent>
				<s:NavigatorContent width="100%" height="100%" label="Object">
					<s:VGroup x="0" y="0" width="100%" height="100%">
						<s:HGroup width="100%">
							<s:Button id="btnObjSetPos" label="SetPos" click="doObjSetPos()"/>
							<s:TextInput id="txtObjName" width="100%"/>
						</s:HGroup>
						<s:HGroup width="100%">
							<s:Label text="x:"/>
							<s:TextInput id="txtOX" width="80"/>
							<s:Label text="y:"/>
							<s:TextInput id="txtOY" width="80"/>
							<s:Label text="z:"/>
							<s:TextInput id="txtOZ" width="80"/>
						</s:HGroup>
						<s:HGroup width="100%">
							<s:Label text="rx:"/>
							<s:TextInput id="txtORX" width="80"/>
							<s:Label text="ry:"/>
							<s:TextInput id="txtORY" width="80"/>
							<s:Label text="rz:"/>
							<s:TextInput id="txtORZ" width="80"/>
						</s:HGroup>
					</s:VGroup>
				</s:NavigatorContent>
			</mx:TabNavigator>
		</s:Panel>
	</s:Group>
</s:Application>


C#——

using System;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;

namespace TryPointerCall
{
	/// <summary>
	/// 指针操作接口
	/// </summary>
	public interface IPointerCall
	{
		/// <summary>
		/// 指针操作
		/// </summary>
		/// <param name="p">源指针</param>
		/// <returns>修改后指针</returns>
		unsafe byte* Ptr(byte* p);
	}

#region 非泛型
	/// <summary>
	/// [非泛型] 指针操作基类
	/// </summary>
	public abstract class PointerCall : IPointerCall
	{
		public abstract unsafe byte* Ptr(byte* p);
	}

	/// <summary>
	/// [非泛型] 指针操作派生类: 指针+偏移
	/// </summary>
	public sealed class PointerCallAdd : PointerCall
	{
		/// <summary>
		/// 偏移值
		/// </summary>
		public int Offset = 0;

		public override unsafe byte* Ptr(byte* p)
		{
			return unchecked(p + Offset);
		}
	}

	/// <summary>
	/// [非泛型] 指针操作密封类: 指针+偏移
	/// </summary>
	public sealed unsafe class SldPointerCallAdd : IPointerCall
	{
		/// <summary>
		/// 偏移值
		/// </summary>
		public int Offset = 0;

		public unsafe byte* Ptr(byte* p)
		{
			return unchecked(p + Offset);
		}
	}

	/// <summary>
	/// [非泛型] 指针操作结构体: 指针+偏移
	/// </summary>
	public struct SPointerCallAdd : IPointerCall
	{
		/// <summary>
		/// 偏移值
		/// </summary>
		public int Offset;

		public unsafe byte* Ptr(byte* p)
		{
			return unchecked(p + Offset);
		}
	}

#endregion

#region 泛型
	// !!! C#不支持将整数类型作为泛型约束 !!!
	//public abstract class GenPointerCall<T> : IPointerCall where T: int, long
	//{
	//    public abstract unsafe byte* Ptr(byte* p);

	//    void d()
	//    {
	//    }
	//}

#endregion

#region 全部测试
	/// <summary>
	/// 指针操作的一些常用函数
	/// </summary>
	public static class PointerCallTool
	{
#if DEBUG
		private const int CountLoop = 10000000;	// 循环次数
#else
		private const int CountLoop = 200000000;	// 循环次数
#endif

		/// <summary>
		/// 调用指针操作
		/// </summary>
		/// <typeparam name="T">具有IPointerCall接口的类型。</typeparam>
		/// <param name="ptrcall">调用者</param>
		/// <param name="p">源指针</param>
		/// <returns>修改后指针</returns>
		public static unsafe byte* CallPtr<T>(T ptrcall, byte* p) where T : IPointerCall
		{
			return ptrcall.Ptr(p);
		}
		public static unsafe byte* CallClassPtr<T>(T ptrcall, byte* p) where T : PointerCall
		{
			return ptrcall.Ptr(p);
		}
		public static unsafe byte* CallRefPtr<T>(ref T ptrcall, byte* p) where T : IPointerCall
		{
			return ptrcall.Ptr(p);
		}

		// C#不允许将特定的结构体作为泛型约束。所以对于结构体只能采用上面那个方法，通过IPointerCall接口进行约束，可能会造成性能下降。
		//public static unsafe byte* SCallPtr<T>(T ptrcall, byte* p) where T : SPointerCallAdd
		//{
		//    return ptrcall.Ptr(p);
		//}

		private static int TryIt_Static_Offset;
		private static unsafe byte* TryIt_Static_Ptr(byte* p)
		{
			return unchecked(p + TryIt_Static_Offset);
		}
		/// <summary>
		/// 执行测试 - 静态调用
		/// </summary>
		/// <param name="sOut">文本输出</param>
		private static unsafe void TryIt_Static(StringBuilder sOut, int CountLoop)
		{
			TryIt_Static_Offset = 1;

			// == 性能测试 ==
			byte* p = null;
			Stopwatch sw = new Stopwatch();
			int i;
			unchecked
			{
				#region 测试
				// 硬编码.栈变量
				int iOffset = 1;
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = p + iOffset;
				}
				sw.Stop();
				sOut.AppendLine(string.Format("硬编码.栈变量:\t{0}", sw.ElapsedMilliseconds));

				// 硬编码.栈分配
				int* pOffset = stackalloc int[1];
				pOffset[0] = 1;
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = p + pOffset[0];
				}
				sw.Stop();
				sOut.AppendLine(string.Format("硬编码.栈分配:\t{0}", sw.ElapsedMilliseconds));

				// 硬编码.静态
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = p + TryIt_Static_Offset;
				}
				sw.Stop();
				sOut.AppendLine(string.Format("硬编码.静态:\t{0}", sw.ElapsedMilliseconds));

				// 静态调用
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = TryIt_Static_Ptr(p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("静态调用:\t{0}", sw.ElapsedMilliseconds));

				#endregion // 测试
			}
		}

		private static long TryIt_Static64_Offset;
		private static unsafe byte* TryIt_Static64_Ptr(byte* p)
		{
			return unchecked(p + TryIt_Static64_Offset);
		}
		/// <summary>
		/// 执行测试 - 静态调用
		/// </summary>
		/// <param name="sOut">文本输出</param>
		private static unsafe void TryIt_Static64(StringBuilder sOut, int CountLoop)
		{
			TryIt_Static64_Offset = 1;

			// == 性能测试 ==
			byte* p = null;
			Stopwatch sw = new Stopwatch();
			int i;
			unchecked
			{
				#region 测试
				// 硬编码.栈变量
				long iOffset = 1;
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = p + iOffset;
				}
				sw.Stop();
				sOut.AppendLine(string.Format("64硬编码.栈变量:\t{0}", sw.ElapsedMilliseconds));

				// 硬编码.栈分配
				long* pOffset = stackalloc long[1];
				pOffset[0] = 1;
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = p + pOffset[0];
				}
				sw.Stop();
				sOut.AppendLine(string.Format("64硬编码.栈分配:\t{0}", sw.ElapsedMilliseconds));

				// 硬编码.静态
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = p + TryIt_Static64_Offset;
				}
				sw.Stop();
				sOut.AppendLine(string.Format("64硬编码.静态:\t{0}", sw.ElapsedMilliseconds));

				// 静态调用
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = TryIt_Static64_Ptr(p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("64静态调用:\t{0}", sw.ElapsedMilliseconds));

				#endregion // 测试
			}
		}

		/// <summary>
		/// 执行测试 - 非泛型
		/// </summary>
		/// <param name="sOut">文本输出</param>
		private static unsafe void TryIt_NoGen(StringBuilder sOut, int CountLoop)
		{
			// 创建
			PointerCallAdd pca = new PointerCallAdd();
			SldPointerCallAdd dpca = new SldPointerCallAdd();
			SPointerCallAdd spca;
			pca.Offset = 1;
			spca.Offset = 1;

			// 转型
			PointerCall pca_base = pca;
			IPointerCall pca_itf = pca;
			IPointerCall dpca_itf = dpca;
			IPointerCall spca_itf = spca;

			// == 性能测试 ==
			byte* p = null;
			Stopwatch sw = new Stopwatch();
			int i;
			unchecked
			{
				#region 调用
				#region 直接调用
				// 调用派生类
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = pca.Ptr(p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("调用派生类:\t{0}", sw.ElapsedMilliseconds));

				// 调用密封类
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = dpca.Ptr(p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("调用密封类:\t{0}", sw.ElapsedMilliseconds));

				// 调用结构体
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = spca.Ptr(p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("调用结构体:\t{0}", sw.ElapsedMilliseconds));

				#endregion	// 直接调用

				#region 间接调用
				// 调用基类
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = pca_base.Ptr(p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("调用基类:\t{0}", sw.ElapsedMilliseconds));

				// 调用派生类的接口
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = pca_itf.Ptr(p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("调用派生类的接口:\t{0}", sw.ElapsedMilliseconds));

				// 调用密封类的接口
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = dpca_itf.Ptr(p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("调用密封类的接口:\t{0}", sw.ElapsedMilliseconds));

				// 调用结构体的接口
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = spca_itf.Ptr(p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("调用结构体的接口:\t{0}", sw.ElapsedMilliseconds));

				#endregion	// 间接调用

				#endregion	// 调用

				#region 泛型调用

				#region 泛型基类约束
				// 基类泛型调用派生类
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = CallClassPtr(pca, p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("基类泛型调用派生类:\t{0}", sw.ElapsedMilliseconds));

				// 基类泛型调用基类
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = CallClassPtr(pca_base, p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("基类泛型调用基类:\t{0}", sw.ElapsedMilliseconds));

				#endregion // 泛型基类约束

				#region 泛型接口约束 - 直接调用
				// 接口泛型调用派生类
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = CallPtr(pca, p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("接口泛型调用派生类:\t{0}", sw.ElapsedMilliseconds));

				// 接口泛型调用密封类
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = CallPtr(dpca, p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("接口泛型调用密封类:\t{0}", sw.ElapsedMilliseconds));

				// 接口泛型调用结构体
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = CallPtr(spca, p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("接口泛型调用结构体:\t{0}", sw.ElapsedMilliseconds));

				// 接口泛型调用结构体引用
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = CallRefPtr(ref spca, p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("接口泛型调用结构体引用:\t{0}", sw.ElapsedMilliseconds));

				#endregion	// 直接调用

				#region 间接调用
				// 接口泛型调用基类
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = CallPtr(pca_base, p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("接口泛型调用基类:\t{0}", sw.ElapsedMilliseconds));

				// 接口泛型调用派生类的接口
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = CallPtr(pca_itf, p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("接口泛型调用派生类的接口:\t{0}", sw.ElapsedMilliseconds));

				// 接口泛型调用密封类的接口
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = CallPtr(dpca_itf, p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("接口泛型调用密封类的接口:\t{0}", sw.ElapsedMilliseconds));

				// 接口泛型调用结构体的接口
				sw.Reset();
				sw.Start();
				for (i = 0; i < CountLoop; ++i)
				{
					p = CallPtr(spca_itf, p);
				}
				sw.Stop();
				sOut.AppendLine(string.Format("接口泛型调用结构体的接口:\t{0}", sw.ElapsedMilliseconds));

				#endregion	// 间接调用

				#endregion	// 泛型调用

			}
		}

		/// <summary>
		/// 执行测试 - 泛型
		/// </summary>
		/// <param name="sOut">文本输出</param>
		private static unsafe void TryIt_Gen(StringBuilder sOut, int CountLoop)
		{
			// !!! C#不支持将整数类型作为泛型约束 !!!
		}

		/// <summary>
		/// 执行测试
		/// </summary>
		public static string TryIt()
		{
			StringBuilder sOut = new StringBuilder();
			sOut.AppendLine("== PointerCallTool.TryIt() ==");
			TryIt_Static(sOut, CountLoop);
			TryIt_Static64(sOut, CountLoop);
			TryIt_NoGen(sOut, CountLoop);
			TryIt_Gen(sOut, CountLoop);
			sOut.AppendLine();
			return sOut.ToString();
		}

		/// <summary>
		/// 执行测试 - static
		/// </summary>
		public static string TryItStatic()
		{
			StringBuilder sOut = new StringBuilder();
			int cnt = CountLoop * 10;
			sOut.AppendLine("== PointerCallTool.TryItStatic() ==");
			TryIt_Static(sOut, cnt);
			TryIt_Static64(sOut, cnt);
			sOut.AppendLine();
			return sOut.ToString();
		}
	}
#endregion

}

表格——

环境分类基类派生类密封类结构体结构体的引用
A_2005直接调用566563161163 
 接口调用 7277211045 
 基类约束泛型调用902910   
 接口约束泛型调用 14071405566480
 接口约束泛型调用接口1409141014021617 
A_2010直接调用573568162161 
 接口调用 7317301134 
 基类约束泛型调用785795   
 接口约束泛型调用 733808160161
 接口约束泛型调用接口7287278081128 
B_2005直接调用668670101116 
 接口调用 7679571318 
 基类约束泛型调用10921274   
 接口约束泛型调用 16341733671700
 接口约束泛型调用接口1767170217191859 
B_2010直接调用660668103102 
 接口调用 8628621340 
 基类约束泛型调用676789   
 接口约束泛型调用 86295610198
 接口约束泛型调用接口7649669581499 
B64_2005直接调用675676102191 
 接口调用 8628701344 
 基类约束泛型调用13461256   
 接口约束泛型调用 16331743864769
 接口约束泛型调用接口1631173016352208 
B64_2010直接调用577580767772 
 接口调用 7707711253 
 基类约束泛型调用12501287   
 接口约束泛型调用 163316381250961
 接口约束泛型调用接口1635163416372117 

 

分类基类派生类密封类结构体结构体的引用
直接调用577580767772
接口调用7707711253
基类约束泛型调用12501287
接口约束泛型调用163316381250961
接口约束泛型调用接口1635163416372117

 

（完）

weixin_34018169
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
testcode
卷不动
01-11 425
// go语言运行shell命令 package main import ( &amp;amp;amp;amp;amp;quot;os/exec&amp;amp;amp;amp;amp;quot; &amp;amp;amp;amp;amp;quot;fmt&amp;amp;amp;amp;amp;quot; &amp;amp;amp;amp;amp;quot;os&amp;amp;amp;amp;amp;quot;
test code
wulafly的博客
10-30 507
#ifndef FT_EXPORT #ifdef __cplusplus #define FT_EXPORT( x ) extern "C" x #else #define FT_EXPORT( x ) extern x #endif /***************************************************************************/
TestCode
03-19
TestCode
11-2 testcode
06-04
11-2 testcode
test-code-9.rar_testcode 实验
09-14
达盛arm实验代码,初学者可以参考一下，基础
testcode图书管理系统样例
11-18
testcode图书管理系统样例 testcode图书管理系统样例 testcode图书管理系统样例
Test Code
iambic的专栏
11-08 1497
C++#include iostream>using namespace std;int main()...{    cout"Hello!"endl;    return 0;}没有C++标签？Perluse strict;print "Hello. ";Pythonwords = [Hello]for w in words:    print w,
Test.code
鹰击长空
01-27 556
국가코드 한글설정 call setEnvValue("SYSTEMID", getSystemID()) call setEnvValue("NA_CODE", "KOR") call setEnvValue("NA_NAME", "Korea") call setEnvValue("CHAR_SET", "euc-kr") call setEnvValue("CODE_P
代码测试（CodeTest）
weixin_34363171的博客
07-03 5374
1. 什么是代码测试？与传统的功能和接口测试有什么不同？ 　　代码测试的立足点是Code，是基于代码基础之上的，而传统的功能测试和接口测试是基于应用的，必须对应的测试系统是在运行中的。 　　代码测试不会特别注重接口测试的可持续性集成。 　　代码测试的特点是快捷高效准确的完成测试工作，快速推进产品的迭代。 　　2. CodeTest的方法： 　　...
codeTest(一)
AprilCC的博客
11-28 2119
一. Square Every DigitNote: The function accepts an integer and returns an integerfunction squareDigits(num){ return Number((''+num).split('').map(function(val){return val*val;}).join(''));study: j
进制转换TestCode
学习日志
09-24 151
[code="java"] //BYTE 型取值范围：0x00~0xFF //主要调用四个AIP，实现进制之间的相互转换。具体API 如下： //First Section:API definition&describe #ifndef CONVERT_TOOL_H #define CONVERT_TOOL_H /*** Include Files ************...
白盒测试工具CodeTest
LinSeeker85的博客
03-11 4080
转载自http://www.shangxueba.com/jingyan/97515.html 1．CodeTest概述 CodeTest是嵌入式系统测试工具，同时也能做嵌入式部分模块测试。要求：目标板和操作系统能正确运行 2．CodeTest的4大功能 (1) 性能分析：CodeTest能同时对128000个函数和1000个任务同时进行性能分析，可以精确的得出每个函数或任务执...
.NET C# 读写Excel及转换DataTable
最新发布
WineMonkBlog
06-12 450
【代码】.NET C# 读写Excel及转换DataTable。
C# String
3000bookworm
06-10 808
在C#中，String类型是一个非常常用的数据类型，用于表示文本数据。它是类的一个实例，位于System命名空间中。以下是一些关于C#中String。
功能强大的API函数FindFirstFile使用介绍（附源码）
dvlinker的技术专栏
06-11 36
功能强大的API函数FindFirstFile使用介绍（附源码）
c++ test code
09-10
以下是一个简单的 C++ 测试代码： ```cpp #include <iostream> int main() { std::cout << "Hello, world!" << std::endl; return 0; } ``` 这个程序将输出 "Hello, world!" 然后结束。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值