应用程序运行, 每次 FIX: WebService 客户端生成序列化程序集

文章翻译 文章翻译
文章编号: 872800 - 查看本文应用于的产品
展开全部 | 关闭全部

本文内容

症状

花时间比预期长进行首次调用与后续调用相比, 调用 Web 服务应用程序。 每次运行应用程序出现延迟

注意 无法在运行 Microsoft NET Framework 1.1 Service Pack 1 系统上应用此修复程序。 如果安装了 NET Framework 1.1 Service Pack 1, 是遇到症状, 本文中描述请求修复程序总成包 890673 以获取解决 Microsoft 知识库文章中描述。 有关详细信息, 请单击下列文章编号以查看 Microsoft 知识库中相应:
890673 NET Framework 1.1 Service Pack 1 XML Web 服务和 XML 消息修复累积程序包 8 的可用性

原因

因为 Web 服务代理使用序列化程序集, 并且序列化程序集运行时动态编译您运行客户应用程序进行首次时发生延迟。 序列化程序集再序列化和 deserializes 信息来根据客户请求和服务器对请求返回结果。 首次调用上额外时间发生因编译的序列化程序集。

解决方案

还必须运行使用程序集 pregenerated 您应用程序的计算机上安装此修复程序 要解决此问题, 请按照下列步骤:
  1. 获取并再安装此修复程序。 要这样做, 请按照下列步骤操作:
    1. 从下列修复程序包修复程序:
      890673 NET Framework 1.1 Service Pack 1 XML Web 服务和 XML 消息修复累积程序包 8 的可用性
    2. 提取修补程序以文件夹。
    3. 双击修补程序以在计算机上安装此修复程序。
  2. pregenerate 程序序列化程序集。 以下是一个小, 示例控制台应用程序将生成序列化程序集对代理程序集。 有关复杂版本的应用程序, 请参见 " 其他信息 " 一节。 若要创建一个简单串行化程序 pregenerator, 请按照下列步骤:
    1. 创建新 .NET 控制台应用程序, 名为 PreGen MicrosoftVisualC #。
    2. 将 Class 1 .cs 文件重命名为 Pregen.cs。
    3. 将 PreGen.cs 文件中所有现有代码替换为以下代码。
      namespace PreGenNS {
          using System;
          using System.Collections;
          using System.IO;
          using System.Reflection;
          using System.Xml.Serialization;
          using System.Text;
          using System.Globalization;
          using System.Web.Services.Protocols;
          using System.Threading;
          using System.CodeDom.Compiler;
          
          public class Pregen {
              public static int Main(string[] args) {
                  if (args.Length != 1) {
                      Console.WriteLine("usage: ");
                      Console.WriteLine("  pregen assembly");
                      return 1;
                  }
                  Pregen pregen = new Pregen();
                  return pregen.Run(args[0]);
              }
      
              int Run(string assemblyName) {
                  
                  try {
                      GenerateAssembly(assemblyName);
                  }
                  catch (Exception e) {
                      if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) {
                          throw;
                      }
                      Error(e, "Error: ");
                      return 1;
                  }
                  return 0;
              }
      
              void GenerateAssembly(string assemblyName) {
                  Assembly assembly = LoadAssembly(assemblyName, true);
                  Type[] types = assembly.GetTypes();
                  ArrayList mappings = new ArrayList();
                  ArrayList importedTypes = new ArrayList();
                  XmlReflectionImporter importer = new XmlReflectionImporter();
                  for (int i = 0; i < types.Length; i++) {
                      Type type = types[i];
                      if (HttpWebClientProtocol.GenerateXmlMappings(type, mappings)) {
                          importedTypes.Add(type);
                      }
                  }
                  if (importedTypes.Count > 0) {
                      Type[] serializableTypes = (Type[])importedTypes.ToArray(typeof(Type));
                      XmlMapping[] allMappings = (XmlMapping[])mappings.ToArray(typeof(XmlMapping));
                      
                      bool gac = assembly.GlobalAssemblyCache;
                      string codePath = gac ? Environment.CurrentDirectory : Path.GetDirectoryName(assembly.Location);
                      string serializerName = assembly.GetName().Name + ".XmlSerializers" ;
                      string location = Path.Combine(codePath, serializerName + ".dll");
      
                      CompilerParameters parameters = new CompilerParameters();
                      parameters.TempFiles = new TempFileCollection(codePath);
                      parameters.GenerateInMemory = false;
                      parameters.IncludeDebugInformation = false;
                      parameters.TempFiles = new TempFileCollection(codePath, true);
                      Assembly serializer = XmlSerializer.GenerateSerializer(serializableTypes, allMappings, parameters);
                      if (serializer == null) {
                          Console.Out.WriteLine("Failed pregenerate serializer for '{0}'", assembly.Location);
                      }
                      else {
                          AssemblyName name = serializer.GetName();
                          Console.Out.WriteLine("Serialization Assembly Name: {0}", name.ToString());
                          Console.Out.WriteLine("Generated serialization assembly for assembly {0} --> '{1}'.", assembly.Location, location);
                      }
                  }
                  else {
                      Console.Out.WriteLine("Assembly '{0}' does not contain any serializable types.", assembly.Location);
                  }
              }
      
              static Assembly LoadAssembly(string assemblyName, bool throwOnFail) {
                  Assembly assembly = null;
                  string path = Path.GetFullPath(assemblyName).ToLower(CultureInfo.InvariantCulture);
                  if (File.Exists(path)) {
                      assembly = Assembly.LoadFrom(path);
                  }
                  else {
                      try {
                          assembly = Assembly.Load(assemblyName);
                      }
                      catch (Exception e) {
                          if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) {
                              throw;
                          }
                          Error(e, "Error: ");
                      }
                      if (assembly == null) {
                          string justName = Path.GetFileNameWithoutExtension(assemblyName);
                          try {
                              assembly = Assembly.Load(justName);
                          }
                          catch (Exception e) {
                              if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) {
                                  throw;
                              }
                              Error(e, "Error: ");
                          }
                      }
                  }
                  if (assembly == null) {
                      if (throwOnFail)
                          throw new InvalidOperationException("Cannot load assembly " + assemblyName);
                      return null;
                  }
                  return assembly;
              }
      
              static void Error(Exception e, string prefix) {
                  Console.Error.WriteLine(prefix + e.Message);
                  if (e.InnerException != null) {
                      Error(e.InnerException, "  - ");
                  }
              }
      
              static void Warning(Exception e) {
                  Console.Out.WriteLine("  - " + e.Message);
                  if (e.InnerException != null) {
                      Warning(e.InnerException);
                  }
              }
          }
      }
      
    4. 添加对 System.Web.Services.dll 文件引用。
    5. 生成项目。
    6. 将 PreGen.exe 文件复制到文件夹包含程序集具有代理代码。 例如, 将 PreGen.exe 文件复制到包含 Web 服务客户端代码程序集。
    7. 通过准备 PreGen.exe 文件 pregenerate serializers 用于 Web 服务。 例如, 如果代理代码位于 WindowsApplication1.exe 文件, 在命令提示符处运行以下命令:

      PreGen.exe WindowsApplication1.exe

      注意 A .dll 文件是生成在同一文件夹客户端程序集保存只要步骤 g 中运行命令。
    8. Microsoft Visual Studio .NET IDE 中打开客户代码。
    9. 在 SolutionExplorer@@, 展开 Web 引用 节点。 例如, 如果通过 localhost, 您添加对 service1 引用展开 LocalHost 。
    10. 展开 Reference.map , 并双击 Reference.cs 文件。
    11. 找到以下代码。
          [System.Diagnostics.DebuggerStepThroughAttribute()]
          [System.ComponentModel.DesignerCategoryAttribute("code")]
          [System.Web.Services.WebServiceBindingAttribute(Name="Service1Soap", Namespace="http://tempuri.org/")]
    12. 将步骤 k 中代码替换为以下代码。
      [System.Diagnostics.DebuggerStepThroughAttribute()]
      [System.ComponentModel.DesignerCategoryAttribute("code")]
      [System.Web.Services.WebServiceBindingAttribute(Name="Service1Soap", Namespace="http://tempuri.org/")]
      [System.Xml.Serialization.XmlSerializerAssemblyAttribute(CodeBase="< DLL 名")]
      
    13. 重建服务 Web 客户端。

      注意 您需要重建客户端因属性。 对程序集包含 MySerializers.dll serializers 客户现在具有运行时库相关性。 因此, 您必须与应用程序部署程序集并使程序集可以在其中客户加载位置。

更多信息

程序集绑定

参数, 您提供到 XmlSerializerAssemblyAttribute 属性的类型决定方式来序列化程序程序集被加载。 如果使用 CodeBase 参数, 序列化程序集将加载通过 LoadFrom 方法。 如果使用 AssemblyName 参数, 序列化程序集将加载通过 LoadWithPartialName 方法。 有关程序集加载, 请访问以下 Microsoft 网站:
http://blogs.msdn.com/suzcook/
如果要序列化程序程序集安装到全局程序集缓存 (GAC), 您必须使用 AssemblyName 参数, 并提供程序集完全限定名。

通过使用智能客户方法部署的应用程序

如果包含代理程序集加载并执行从本地计算机, 最好使用 CodeBase 语法对于 XmlSerializerAssemblyAttribute 属性。 此时, 程序序列化程序集应部署到同一文件夹作为程序集包含代理。 如果通过在智能客户部署方案, 使用 LoadFrom 方法通过 HTTP 加载程序集, 例如, 序列化程序集将不被正确加载由 XmlSerializerAssemblyAttribute 属性。 因为代替 Load 上下文, 公共语言运行时加载的 LoadFrom 上下文中存在代理程序集并不发生 probing 出现此问题。 要解决此问题, 请使用具有程序集虚拟名称属性是受其他 AssemblyName 语法。
[System.Xml.Serialization.XmlSerializerAssemblyAttribute(AssemblyName="LoadMySerializerAssemblyNow")]
应用程序然后实现对于来截取请求以加载程序序列化程序集并从正确位置加载 AppDomain 的 AssemblyResolve 事件处理程序
private void Form1_Load(object sender, System.EventArgs e)
{
			AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(MyResolveEventHandler);
}
static Assembly MyResolveEventHandler(object sender, ResolveEventArgs args)
 {
			Assembly a = null;
			string serializationAssemblyPartialName = "LoadMySerializerAssemblyNow";
if (args.Name == serializationAssemblyPartialName)
	{string sSerializersDLL = "<Name Of The Serializer DLL>";
string smartDeploymentHostLocation = "<Full path location to the Serializer DLL>";
a = Assembly.LoadFrom(smartDeploymentHostLocation + sSerializersDLL);
}
			return a;
		}

可选 pregenerator 示例

以下是复杂的序列化程序 pregenerator 示例应用程序版本。 此版本允许创建程序集签名序列化程序。 使用以下代码。
namespace PreGenNS 
{
	using System;
	using System.Collections;
	using System.IO;
	using System.Reflection;
	using System.Xml.Serialization;
	using System.Text;
	using System.Globalization;
	using System.Web.Services.Protocols;
	using System.Threading;
	using System.CodeDom.Compiler;
	using System.Diagnostics;
	using System.Text.RegularExpressions;

	public class Pregen 
	{
		private static bool _verbose = true;

		
		// We use this as the standard suffix on all the serializer DLLs.
		// It must match the short name of the proxy assembly class with 
		const string SerializerSuffix = ".Serializer.dll";

		
		/// Key in the app config file with path of AssemblyInfo file.
		private const string AssemblyInfoAppKey = "AssemblyInfoFile";

		//private const string CSCCmd = "csc.exe";
		// Obtain the full path for the compiler, just in case the path is not set correctly

		private readonly string CSCCmd = System.Runtime.InteropServices.RuntimeEnvironment.RuntimeDirectory() + "csc.exe";

		public static int Main(string[] args) {		
			// Are we in a recursive call?
			//TODO: could really use a single value -- use filesToDelete...
			if (AppDomain.CurrentDomain.GetData(CallingAppDomainKey) == null) {
				return RunSlave(args);
			}

			string dllName = "";
			bool invalidUsage = false;

			if(args.Length == 1)
			{
				dllName = args[0];
			}
			else if(args.Length == 2)
			{
				if(!(args[0] == "/Q" || args[0] == "/q"))
				{
					invalidUsage = true;
				}
				else
				{
					dllName = args[1];
					_verbose = false;
				}
			}
			else 
			{
				invalidUsage = true;
			}

			if (invalidUsage)
			{
				Console.WriteLine("usage: ");
				Console.WriteLine(" pregen [/Q] assembly");
				return 1;
			}
			

			// Update Private path setting in current application domain
			if (updatePrivatePath() != 0)
			{
				return 1;
			}
			
			Pregen pregen = new Pregen();
			int rc = pregen.Run(dllName);
			//Console.Read();
			return rc;
		}


		// Reads private path settings from config file and updates appdomain.  This permits configurable probing that is needed for preserialization.
		static int updatePrivatePath()
		{
			string defaultPrivatePath = System.Configuration.ConfigurationSettings.AppSettings["PregenDefaultPrivatePath"];
			string dynamicPrivatePath = System.Configuration.ConfigurationSettings.AppSettings["PregenDynamicPrivatePath"];
			string env_PREGEN_VALUES = Environment.GetEnvironmentVariable("PREGEN_VALUES");
			string [] replacementBlocks, temp;

			if (_verbose)
				Console.WriteLine("Read PREGEN_VALUES Env Variable, Value = " + env_PREGEN_VALUES);

			//process the dynamic path if the environment variable PREGEN_VALUES is present 
			if (env_PREGEN_VALUES == null || env_PREGEN_VALUES == "")
			{
				if (defaultPrivatePath != null && defaultPrivatePath != "")
				{
					AppDomain.CurrentDomain.AppendPrivatePath(defaultPrivatePath);

					if (_verbose)
						Console.WriteLine("Appended private path with: " + defaultPrivatePath);
				}
			}
			else
			{
				if (dynamicPrivatePath != null && dynamicPrivatePath != "")
				{
					//do substitutions in dynamic path
					replacementBlocks = env_PREGEN_VALUES.ToUpper().Split(";".ToCharArray());
					dynamicPrivatePath = dynamicPrivatePath.ToUpper();

					for(int i = 0; i < replacementBlocks.Length; i++)
					{
						temp = replacementBlocks[i].Split("=".ToCharArray());
						if(temp.Length != 2)
						{
							Console.Error.WriteLine("Invalid Environment Variable format - PREGEN_VALUES");
							return 1;
						}

						dynamicPrivatePath = dynamicPrivatePath.Replace(temp[0],temp[1]);
					}
					
					AppDomain.CurrentDomain.AppendPrivatePath(dynamicPrivatePath);

					if (_verbose )
						Console.WriteLine("Appended private path with: " + dynamicPrivatePath);
				}
			}
			return 0;
		}
		
		int Run(string assemblyName) 
		{

			try 
			{
				GenerateAssembly(assemblyName);
			}
			catch (Exception e) 
			{
				if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) 
				{
					throw;
				}
				Error(e, "Error processing " + assemblyName + ": ");
				return 1;
			}
			return 0;
		}



		// Generates the serializer assembly for the proxy assembly specified
		void GenerateAssembly(string assemblyName) 
		{
			Assembly assembly = LoadAssembly(assemblyName, true);
			Type[] types = assembly.GetTypes();
			ArrayList mappings = new ArrayList();
			ArrayList importedTypes = new ArrayList();
			XmlReflectionImporter importer = new XmlReflectionImporter();

			
			//Obtain the imported serializable types
			for (int i = 0; i < types.Length; i++) 
			{
				Type type = types[i];
				if (HttpWebClientProtocol.GenerateXmlMappings(type, mappings)) 
				{
					importedTypes.Add(type);
				}
			}
			if (importedTypes.Count <= 0) {
				Console.Out.WriteLine("Assembly '{0}' does not contain any serializable types.", assembly.Location);
				return;
			}
 
			{
				Type[] serializableTypes = (Type[])importedTypes.ToArray(typeof(Type));
				XmlMapping[] allMappings = (XmlMapping[])mappings.ToArray(typeof(XmlMapping));

				bool wasError = false;
				bool gac = assembly.GlobalAssemblyCache;
				string codePath = gac ? Environment.CurrentDirectory : Path.GetDirectoryName(assembly.Location);

				//adjust compiler params
				CompilerParameters parameters = new CompilerParameters();
				parameters.GenerateInMemory = false;
				parameters.IncludeDebugInformation = false;
				parameters.TempFiles = new TempFileCollection(codePath, true);
				
				//generate the serializer
				Assembly serializer = XmlSerializer.GenerateSerializer(serializableTypes, allMappings, parameters);
				if (serializer == null) {
					Console.Out.WriteLine("Failed pregenerate serializer for '{0}'", assembly.Location);
					wasError = true;
				}
				else 
				{
					serializer = null;
				}

				// Determine whether there is an assemblyInfoFile in the config file.
				string assemblyInfoFile = System.Configuration.ConfigurationSettings.AppSettings[AssemblyInfoAppKey];
				if (assemblyInfoFile != null) { 
					if (! File.Exists(assemblyInfoFile)) {
						Console.WriteLine("ERROR: AssemblyInfo file: {0} does not exist.", assemblyInfoFile);
						wasError = true;
					}
				}

				if (!wasError) {
					// Recompile the Serializer, same options, except to include the assemblyInfo file and
					// adjust the output name.

					// We have to find 
					//		1. a .cs file (the serializer source)
					//		2. a .cmdline file (the compiler options used)
					// among the temp files from the first compile.
					
					string csFile		= null;
					string cmdlineFile	= null;

					foreach (string curFile in parameters.TempFiles ) {
						string fileNameLC = curFile.ToLower();
						if (fileNameLC.EndsWith(".cs") ) {
							csFile = curFile;
						}
						else if (fileNameLC.EndsWith(".cmdline")) {
							cmdlineFile = curFile;
						}
						//Do not care about the other files...
					}
					if (csFile == null || cmdlineFile == null) {
						Console.WriteLine("Error: needed to rebuild, but cannot find either .cs or .cmdline file\n");
						DeleteTempFiles(parameters);
						return;
					}

					// So now we have found the file and the cmdline args.  We only need run the compiled application after 
					// adjusting the parameters to include the AssemblyInfo file and to change the output.
					
					// Typical calling options to csc for this sequence are:
					//		csc /noconfig @xxx.cmdline
					// we'll change this to expand the contents of the cmdline file

					// build the right name for the target serializer.
					//TODO: we should be able to read the attribute from the proxy DLL and match our output
					// to that name.
					string serializerName = Path.GetDirectoryName(assembly.Location) + @"\" 
											+ assembly.GetName().Name + SerializerSuffix;

					string cmdLine = AdjustCmdLine(cmdlineFile, assemblyInfoFile, serializerName);

					ProcessStartInfo ps = new ProcessStartInfo(CSCCmd, cmdLine);
					ps.WindowStyle = ProcessWindowStyle.Hidden;
					Process p = Process.Start(ps);
					p.WaitForExit();
					int rc = p.ExitCode;
					if (rc > 0) {
						//TODO: put useful handling here...
						Console.WriteLine("ERROR: Compiler problem, rc = {0}", rc);
						wasError = true;
					}

					//TODO: Cannot ditch temp assembly because the assembly is now loaded.
					DeleteTempFiles(parameters);

					if (!wasError) {
						Console.Out.WriteLine("Generated Serialization Assembly Name: {0}", serializerName);
					}
					Console.Out.WriteLine("Done");
				}
			}
		}


		// Delete temporary files from a CompilerParameters list.
		private void DeleteTempFiles(CompilerParameters cp) {
			ArrayList unDeletedFiles = new ArrayList(10);
			foreach(string fileName in cp.TempFiles) {
				try {
					File.Delete(fileName);
				}
				catch(Exception) {
					unDeletedFiles.Add(fileName);
					//Console.WriteLine("Warning: Unable to delete temp file: {0}, exception={1}(\"{2}\")",
					//	Path.GetFileName(fileName), e.GetType().FullName, e.Message);
				}
			}
			if (unDeletedFiles.Count > 0) {
				// put the list into the calling appDomain's environment for later deletion
				string[] files = new string[unDeletedFiles.Count];
				unDeletedFiles.CopyTo(files);

				//TODO: should really be concatenating to any existing value -- maybe leave as an ArrayList?
				AppDomain.CurrentDomain.SetData(FilesToDeleteKey, files);
			}
		}


		/// Rebuild a commandline for csc, adding assemblyInfoFile to the end of the line and adjusting the 
		/// output file name as specified.
		private string AdjustCmdLine(string cmdlineFile, string assemblyInfoFile, string outputFile) {	
			// Obtain the text from the @ response file that is used by the Framework Serialization builder
			StreamReader file = File.OpenText(cmdlineFile);
			string cmdLine = file.ReadToEnd();
			file.Close();

			// add the assemblyInfo file at the end of the command if it was specified
			if (assemblyInfoFile != null)
				cmdLine = String.Format(@"/noconfig {0} ""{1}""", cmdLine, assemblyInfoFile);

			// replace the /OUT option with our value.
			Regex re = new Regex(@"/OUT:""[^""]+.", RegexOptions.IgnoreCase);
			cmdLine = re.Replace(cmdLine, @"/OUT:""" + outputFile + @"""");

			return cmdLine;
		}

		static Assembly LoadAssembly(string assemblyName, bool throwOnFail) 
		{
			Assembly assembly = null;
			string path = Path.GetFullPath(assemblyName).ToLower(CultureInfo.InvariantCulture);
			if (File.Exists(path)) 
			{
				assembly = Assembly.LoadFrom(path);
			}
			else 
			{
				try 
				{
					assembly = Assembly.Load(assemblyName);
				}
				catch (Exception e) 
				{
					if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) 
					{
						throw;
					}
					Error(e, "Error: ");
				}
				if (assembly == null) 
				{
					string justName = Path.GetFileNameWithoutExtension(assemblyName);
					try 
					{
						assembly = Assembly.Load(justName);
					}
					catch (Exception e) 
					{
						if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) 
						{
							throw;
						}
						Error(e, "Error: ");
					}
				}
			}
			if (assembly == null) 
			{
				if (throwOnFail)
					throw new InvalidOperationException("Cannot load assembly " + assemblyName);
				return null;
			}
			return assembly;
		}

		static void Error(Exception e, string prefix) 
		{
			Console.Error.WriteLine(prefix + e.Message);
			if (e.InnerException != null) 
			{
				Error(e.InnerException, " - ");
			}
		}

		static void Warning(Exception e) 
		{
			Console.Out.WriteLine(" - " + e.Message);
			if (e.InnerException != null) 
			{
				Warning(e.InnerException);
			}
		}

		private static AppDomain DuplicateAppDomain(AppDomain template, string newName) {
			AppDomain res = AppDomain.CreateDomain(newName, template.Evidence, template.SetupInformation);
			return res;
		}

		// keys in AppDomain properties
		private const string CallingAppDomainKey	= "__Calling_AppDomain__";
		private const string FilesToDeleteKey		= "__Files_To_Delete__";

		// Called from Main to set up and run the second copy of the program.
		// args: command-line arguments for second execution
		private static int RunSlave(string[] args) {

			// Start a copy of this program in another application domain
			AppDomain ad = DuplicateAppDomain(AppDomain.CurrentDomain, "serializerAD");
			Assembly ca = Assembly.GetExecutingAssembly();

			// set a marker so target domain knows that it is the subordinate.
			ad.SetData(CallingAppDomainKey, AppDomain.CurrentDomain.FriendlyName);
			ad.SetData(FilesToDeleteKey, new string[0]);

			int rc = ad.ExecuteAssembly(ca.Location, ca.Evidence, args);

			// Now delete any files
			string[] fileList = (string[])ad.GetData(FilesToDeleteKey);

			AppDomain.Unload(ad);

			if (fileList != null) {
				foreach(string fileName in fileList) {
					try {
						File.Delete(fileName);
					}
					catch(Exception e) {
						Console.WriteLine("Warning: Unable to delete temp file: {0}, exception={1}(\"{2}\")",
							Path.GetFileName(fileName), e.GetType().FullName, e.Message);
					}
				}
			}
			return rc;  
		}

	}
}

参考

有关详细信息, 请访问以下 MSDNWeb 站点:
http://msdn2.microsoft.com/en-us/library/y92e0td0(vs.71).aspx
http://msdn2.microsoft.com/en-us/library/hk7y1596(vs.71).aspx

属性

文章编号: 872800 - 最后修改: 2007年5月18日 - 修订: 3.4
这篇文章中的信息适用于:
  • Microsoft .NET Framework 1.1
  • Microsoft .NET Framework 1.1 Service Pack 1
  • Microsoft Visual Studio .NET 2003 Enterprise Architect
  • Microsoft Visual Studio .NET 2003 Enterprise Developer
  • Microsoft Visual Studio .NET 2003 Professional Edition
  • Microsoft Visual Studio .NET 2003 Academic Edition
关键字:?
kbqfe kbhotfixserver kbtshoot kbdll kbwebservices kbuser kbarchitecture kbfix KB872800 KbMtzh kbmt
机器翻译
注意:这篇文章是由无人工介入的微软自动的机器翻译软件翻译完成。微软很高兴能同时提供给您由人工翻译的和由机器翻译的文章, 以使您能使用您的语言访问所有的知识库文章。然而由机器翻译的文章并不总是完美的。它可能存在词汇,语法或文法的问题,就像是一个外国人在说中文时总是可能犯这样的错误。虽然我们经常升级机器翻译软件以提高翻译质量,但是我们不保证机器翻译的正确度,也不对由于内容的误译或者客户对它的错误使用所引起的任何直接的, 或间接的可能的问题负责。如果您发现了错误并希望帮助我们提高机器翻译技术,请完成文章末尾的在线调查。
点击这里察看该文章的英文版: 872800
Microsoft和/或其各供应商对于为任何目的而在本服务器上发布的文件及有关图形所含信息的适用性,不作任何声明。 所有该等文件及有关图形均"依样"提供,而不带任何性质的保证。Microsoft和/或其各供应商特此声明,对所有与该等信息有关的保证和条件不负任何责任,该等保证和条件包括关于适销性、符合特定用途、所有权和非侵权的所有默示保证和条件。在任何情况下,在由于使用或运行本服务器上的信息所引起的或与该等使用或运行有关的诉讼中,Microsoft和/或其各供应商就因丧失使用、数据或利润所导致的任何特别的、间接的、衍生性的损害或任何因使用而丧失所导致的之损害、数据或利润不负任何责任。

提供反馈

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com