需要原始XML请求和放大器;响应在UPS API（.NET） [英] Need Raw XML For Request & Response In UPS API (.Net)
本文介绍了需要原始XML请求和放大器;响应在UPS API（.NET）的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！
问题描述
这个问题的答案可能会非常明显。但需要一些帮助...
我目前使用的UPS API /服务生成测试标签。一切伟大的工作。但要获得它的认证，我要送UPS从请求和放大器的原始XML;响应。
我不发送原始XML，而是使用服务和它的各种属性。是否有出货的结果内的某处返回原始XML？或者，必须手动序列化的要求和放大器;回应只是为了满足什么UPS希望在他们的评论？
下面是我的code（一切正常，我能够生成标签但是我如何才能申请与放大器;？响应XML）
尝试
{
ShipService shpSvc =新ShipService（）;
ShipmentRequest shipmentRequest =新ShipmentRequest（）;
UPSSecurity的UPS =新UPSSecurity（）;
UPSSecurityServiceAccessToken upssSvcAccessToken =新UPSSecurityServiceAccessToken（）;
upssSvcAccessToken.AccessLicenseNumber = s.APIKey;
upss.ServiceAccessToken = upssSvcAccessToken;
UPSSecurityUsernameToken upssUsrNameToken =新UPSSecurityUsernameToken（）;
upssUsrNameToken.Username = s.Username;
upssUsrNameToken.Password = s.Password;
upss.UsernameToken = upssUsrNameToken;
shpSvc.UPSSecurityValue = UPS的;
请求类型请求=新的RequestType（）; 的String [] = REQUESTOPTION {nonvalidate};
request.RequestOption = REQUESTOPTION;
shipmentRequest.Request =请求; ShipmentType出货=新ShipmentType（）;
ShipperType托运人=新ShipperType（）;
shipper.ShipperNumber = s.ShipperAccountNumber;
PaymentInfoType paymentInfo =新PaymentInfoType（）; ShipmentChargeType shpmentCharge =新ShipmentChargeType（）;
BillShipperType billShipper =新BillShipperType（）;
billShipper.AccountNumber = s.ShipperAccountNumber;
shpmentCharge.BillShipper = billShipper;
shpmentCharge.Type =01; ShipmentChargeType [] = shpmentChargeArray {shpmentCharge};
paymentInfo.ShipmentCharge = shpmentChargeArray;
shipment.PaymentInformation = paymentInfo;
ShipWebReference.ShipAddressType shipperAddress =新ShipWebReference.ShipAddressType（）;
的String [] = addressLine {s.ShipperAddressLine}; shipperAddress.AddressLine = addressLine;
shipperAddress.City = s.ShipperCity;
shipperAddress.Postal code = s.ShipperZip;
shipperAddress.StateProvince code = s.ShipperState;
shipperAddress.Country code =US;
shipperAddress.AddressLine = addressLine;
shipper.Address = shipperAddress;
shipper.Name = s.ShipperName;
shipper.AttentionName = s.ShipperName;
ShipPhoneType shipperPhone =新ShipPhoneType（）;
shipperPhone.Number = s.ShipperPhone;
shipper.Phone = shipperPhone;
shipment.Shipper =托运人;
ShipFromType shipFrom =新ShipFromType（）; ShipWebReference.ShipAddressType shipFromAddress =新ShipWebReference.ShipAddressType（）;
的String [] = shipFromAddressLine {s.ShipperAddressLine};
shipFromAddress.AddressLine = addressLine;
shipFromAddress.City = s.ShipperCity;
shipFromAddress.Postal code = s.ShipperZip;
shipFromAddress.StateProvince code = s.ShipperState;
shipFromAddress.Country code =US;
shipFrom.Address = shipFromAddress;
shipFrom.AttentionName = s.ShipperName;
shipFrom.Name = s.ShipperName;
shipment.ShipFrom = shipFrom; ShipToType SHIPTO =新ShipToType（）;
ShipToAddressType shipToAddress =新ShipToAddressType（）;
的String [] = addressLine1 {s.ShipToAddressLine};
shipToAddress.AddressLine = addressLine1;
shipToAddress.City = s.ShipToCity;
shipToAddress.Postal code = s.ShipToZip;
shipToAddress.StateProvince code = s.ShipToState;
shipToAddress.Country code =US;
shipTo.Address = shipToAddress;
shipTo.AttentionName = s.ShipToName;
shipTo.Name = s.ShipToName; ShipPhoneType shipToPhone =新ShipPhoneType（）;
shipToPhone.Number = s.ShipToPhone;
shipTo.Phone = shipToPhone;
shipment.ShipTo = SHIPTO;
服务类型的服务=新的服务类型（）; 。服务code =03;
shipment.Service =服务;
PackageType包=新PackageType（）;
PackageWeightType packageWeight =新PackageWeightType（）;
packageWeight.Weight = s.PackageWeight;
ShipUnitOfMeasurementType计量单位=新ShipUnitOfMeasurementType（）;
。计量单位code =LBS
packageWeight.UnitOfMeasurement =计量单位;
package.PackageWeight = packageWeight;
包装形式packType =新的包装形式（）;
。packType code =02;
package.Packaging = packType;
PackageType [] = pkgArray {}包;
shipment.Package = pkgArray;
LabelSpecificationType labelSpec =新LabelSpecificationType（）;
LabelStockSizeType labelStockSize =新LabelStockSizeType（）;
labelStockSize.Height =6;
labelStockSize.Width =4;
labelSpec.LabelStockSize = labelStockSize;
LabelImageFormatType labelImageFormat =新LabelImageFormatType（）;
LabelDeliveryType labelDel =新LabelDeliveryType（）;
labelDel.LabelLinksIndicator =;
。labelImageFormat code =GIF; PackageServiceOptionsType packServiceOptions =新PackageServiceOptionsType（）;
PackageDeclaredValueType decType =新PackageDeclaredValueType（）;
decType.Currency code =USD;
decType.MonetaryValue = s.PackageValue;
packServiceOptions.DeclaredValue = decType;
package.PackageServiceOptions = packServiceOptions;
labelSpec.LabelImageFormat = labelImageFormat;
ShipmentTypeShipmentServiceOptions shipServOpt =新ShipmentTypeShipmentServiceOptions（）; shipment.ShipmentServiceOptions = shipServOpt;
shipmentRequest.LabelSpecification = labelSpec;
shipmentRequest.Shipment =发货; System.Net.ServicePointManager.CertificatePolicy =新TrustAllCertificatePolicy（）;
Console.WriteLine（shipmentRequest）; shipmentResponse = shpSvc.ProcessShipment（shipmentRequest）; }
解决方案
我面对pretty了同样的问题，幸运的是我解决了问题;）
您需要一些东西来注册一个SOAP扩展：
[性ReflectionPermission（SecurityAction.Demand，无限制= TRUE）]
公共静态无效RegisterSoapExtension（类型类型，INT优先级，PriorityGroup组）
{
如果（！type.IsSubclassOf（typeof运算（的SoapExtension）））
{
抛出新的ArgumentException（类型必须从的SoapException衍生。，类型）;
} 如果（优先级＆LT; 1）
{
抛出新ArgumentOutOfRangeException（优先，优先级，优先级必须大于或等于1）;
} //获取当前的Web服务设置...
WebServicesSection WSS = WebServicesSection.Current; //设置SoapExtensionTypes集合读/写...
字段信息readOnlyField = typeof运算（System.Configuration.ConfigurationElementCollection）.GetField（bReadOnly，BindingFlags.NonPublic可| BindingFlags.Instance）;
readOnlyField.SetValue（wss.SoapExtensionTypes，FALSE）; //注入的SoapExtension ...
//wss.SoapExtensionTypes.Add(new SoapExtensionTypeElement（类型，优先级，分组））; System.Web.Services.Configuration.SoapExtensionTypeElement soapInterceptor =新SoapExtensionTypeElement（）;
soapInterceptor.Type =类型;
soapInterceptor.Priority =优先;
soapInterceptor.Group =组;
wss.SoapExtensionTypes.Add（soapInterceptor）; //设置SoapExtensionTypes回为只读，并清除修改标志...
MethodInfo的resetModifiedMethod = typeof运算（System.Configuration.ConfigurationElement）.GetMethod（ResetModified，BindingFlags.NonPublic可| BindingFlags.Instance）;
resetModifiedMethod.Invoke（wss.SoapExtensionTypes，NULL）;
MethodInfo的setReadOnlyMethod = typeof运算（System.Configuration.ConfigurationElement）.GetMethod（通过setReadOnly，BindingFlags.NonPublic可| BindingFlags.Instance）;
setReadOnlyMethod.Invoke（wss.SoapExtensionTypes，NULL）;
}
您需要定义实际的分机：
///＆LT;总结＆gt;
///跟踪此SOAP请求SOAP扩展和
/// SOAP响应SOAP API的Web服务。
///＆LT; /总结＆gt;
公共类TraceExtension：的SoapExtension
{
专用流oldStream;
私人方通流; 私有静态的XmlDocument xmlRequest; ///＆LT;总结＆gt;
///获取传出的XML请求
///＆LT; /总结＆gt;
公共静态的XmlDocument XmlRequest
{
{返回xmlRequest; }
} 私有静态的XmlDocument xmlResponse; ///＆LT;总结＆gt;
///获取传入XML响应
///＆LT; /总结＆gt;
公共静态的XmlDocument XmlResponse
{
{返回xmlResponse; }
} ///＆LT;总结＆gt;
///保存流重新presenting SOAP请求
///或SOAP响应到本地内存缓冲区。
///＆LT; /总结＆gt;
///＆LT; PARAM NAME =流＆GT;＆LT; /参数＆GT;
///＆LT;＆回报GT;＆LT; /回报＆GT;
公共覆盖流ChainStream（流流）
{
oldStream =流;
=方通新的MemoryStream（）;
方通回报;
} ///＆LT;总结＆gt;
///如果SoapMessageStage使得在SOA prequest或
///健胃presponse仍然在SOAP格式被发送或接收，
///它保存到xmlRequest或xmlResponse财产。
///＆LT; /总结＆gt;
///＆LT; PARAM NAME =消息＆GT;＆LT; /参数＆GT;
公共覆盖无效ProcessMessage的（的SOAPMessage消息）
{
开关（message.Stage）
{
案例SoapMessageStage.BeforeSerialize：
打破;
案例SoapMessageStage.AfterSerialize：
xmlRequest = GetSoapEnvelope（方通）;
CopyStream（方通，oldStream）;
打破;
案例SoapMessageStage.BeforeDeserialize：
CopyStream（oldStream，方通）;
xmlResponse = GetSoapEnvelope（方通）;
打破;
案例SoapMessageStage.AfterDeserialize：
打破;
}
} ///＆LT;总结＆gt;
///返回SOAP信封的供应流中的XML重新presentation。
///重置流为零的位置。
///＆LT; /总结＆gt;
///＆LT; PARAM NAME =流＆GT;＆LT; /参数＆GT;
///＆LT;＆回报GT;＆LT; /回报＆GT;
私人的XmlDocument GetSoapEnvelope（流流）
{
VAR XML =新的XmlDocument（）;
stream.Position = 0;
VAR读者=新的StreamReader（流）;
xml.LoadXml（reader.ReadToEnd（））;
stream.Position = 0;
返回XML;
} ///＆LT;总结＆gt;
///复制流。
///＆LT; /总结＆gt;
///＆LT; PARAM NAME =从＆GT;＆LT; /参数＆GT;
///＆LT; PARAM NAME =到＆GT;＆LT; /参数＆GT;
私人无效CopyStream（从流，流于）
{
读者的TextReader =新的StreamReader（从）;
TextWriter的作家=新的StreamWriter（地）;
writer.WriteLine（reader.ReadToEnd（））;
writer.Flush（）;
}
///＆LT;总结＆gt;
///包括不仅是因为它必须执行。
///＆LT; /总结＆gt;
///＆LT; PARAM NAME =MethodInfo的＆GT;＆LT; /参数＆GT;
///＆LT; PARAM NAME =属性＆GT;＆LT; /参数＆GT;
///＆LT;＆回报GT;＆LT; /回报＆GT;
公众覆盖对象GetInitializer（LogicalMethodInfo的MethodInfo，
SoapExtensionAttribute属性）
{
返回null;
} ///＆LT;总结＆gt;
///包括不仅是因为它必须执行。
///＆LT; /总结＆gt;
///＆LT; PARAM NAME =WebServiceType＆GT;＆LT; /参数＆GT;
///＆LT;＆回报GT;＆LT; /回报＆GT;
公众覆盖对象GetInitializer（类型WebServiceType）
{
返回null;
} ///＆LT;总结＆gt;
///包括不仅是因为它必须执行。
///＆LT; /总结＆gt;
///＆LT; PARAM NAME =初始化＆GT;＆LT; /参数＆GT;
公共覆盖无效初始化（对象初始化）
{
}
}
然后，你需要注册扩展：
RegisterSoapExtension（typeof运算（TraceExtension），1，0）;
最后，您的请求/响应完成后，您需要保存XML：
TraceExtension.XmlRequest.Save（@C：\\ TEMP \\ ForwardRequest.xml）;
TraceExtension.XmlResponse.Save（@C：\\ TEMP \\ ForwardResponse {0}的.xml）;
警告：这实际上是pretty很多我以前穿过UPS的认证，但是这code只使用过一次。因此，它可能不是最大的质量，是pretty或比一个单一的事情，否则非常有用的其他
The answer to this may be painfully obvious. But need some help...
I'm currently using the UPS API/Service to generate test labels. Everything is working great. But to get it certified, I have to send UPS the raw XML from the requests & responses.
I'm not sending raw xml, but rather using the service and its various properties. Is there a raw XML returned somewhere within the shipment result? Or do have to manually serialize the request & responses just to satisfy what UPS wants in their review?
Here's my code (everything works, I'm able to generate a label. But how do I get request & response xml?)
try
{
ShipService shpSvc = new ShipService();
ShipmentRequest shipmentRequest = new ShipmentRequest();
UPSSecurity upss = new UPSSecurity();
UPSSecurityServiceAccessToken upssSvcAccessToken = new UPSSecurityServiceAccessToken();
upssSvcAccessToken.AccessLicenseNumber = s.APIKey;
upss.ServiceAccessToken = upssSvcAccessToken;
UPSSecurityUsernameToken upssUsrNameToken = new UPSSecurityUsernameToken();
upssUsrNameToken.Username = s.Username;
upssUsrNameToken.Password = s.Password;
upss.UsernameToken = upssUsrNameToken;
shpSvc.UPSSecurityValue = upss;
RequestType request = new RequestType();
String[] requestOption = { "nonvalidate" };
request.RequestOption = requestOption;
shipmentRequest.Request = request;
ShipmentType shipment = new ShipmentType();
ShipperType shipper = new ShipperType();
shipper.ShipperNumber = s.ShipperAccountNumber;
PaymentInfoType paymentInfo = new PaymentInfoType();
ShipmentChargeType shpmentCharge = new ShipmentChargeType();
BillShipperType billShipper = new BillShipperType();
billShipper.AccountNumber = s.ShipperAccountNumber;
shpmentCharge.BillShipper = billShipper;
shpmentCharge.Type = "01";
ShipmentChargeType[] shpmentChargeArray = { shpmentCharge };
paymentInfo.ShipmentCharge = shpmentChargeArray;
shipment.PaymentInformation = paymentInfo;
ShipWebReference.ShipAddressType shipperAddress = new ShipWebReference.ShipAddressType();
String[] addressLine = { s.ShipperAddressLine };
shipperAddress.AddressLine = addressLine;
shipperAddress.City = s.ShipperCity;
shipperAddress.PostalCode = s.ShipperZip;
shipperAddress.StateProvinceCode = s.ShipperState;
shipperAddress.CountryCode = "US";
shipperAddress.AddressLine = addressLine;
shipper.Address = shipperAddress;
shipper.Name = s.ShipperName;
shipper.AttentionName = s.ShipperName;
ShipPhoneType shipperPhone = new ShipPhoneType();
shipperPhone.Number = s.ShipperPhone;
shipper.Phone = shipperPhone;
shipment.Shipper = shipper;
ShipFromType shipFrom = new ShipFromType();
ShipWebReference.ShipAddressType shipFromAddress = new ShipWebReference.ShipAddressType();
String[] shipFromAddressLine = { s.ShipperAddressLine };
shipFromAddress.AddressLine = addressLine;
shipFromAddress.City = s.ShipperCity;
shipFromAddress.PostalCode = s.ShipperZip;
shipFromAddress.StateProvinceCode = s.ShipperState;
shipFromAddress.CountryCode = "US";
shipFrom.Address = shipFromAddress;
shipFrom.AttentionName = s.ShipperName;
shipFrom.Name = s.ShipperName;
shipment.ShipFrom = shipFrom;
ShipToType shipTo = new ShipToType();
ShipToAddressType shipToAddress = new ShipToAddressType();
String[] addressLine1 = { s.ShipToAddressLine };
shipToAddress.AddressLine = addressLine1;
shipToAddress.City = s.ShipToCity;
shipToAddress.PostalCode = s.ShipToZip;
shipToAddress.StateProvinceCode = s.ShipToState;
shipToAddress.CountryCode = "US";
shipTo.Address = shipToAddress;
shipTo.AttentionName = s.ShipToName;
shipTo.Name = s.ShipToName;
ShipPhoneType shipToPhone = new ShipPhoneType();
shipToPhone.Number = s.ShipToPhone;
shipTo.Phone = shipToPhone;
shipment.ShipTo = shipTo;
ServiceType service = new ServiceType();
service.Code = "03";
shipment.Service = service;
PackageType package = new PackageType();
PackageWeightType packageWeight = new PackageWeightType();
packageWeight.Weight = s.PackageWeight;
ShipUnitOfMeasurementType uom = new ShipUnitOfMeasurementType();
uom.Code = "LBS";
packageWeight.UnitOfMeasurement = uom;
package.PackageWeight = packageWeight;
PackagingType packType = new PackagingType();
packType.Code = "02";
package.Packaging = packType;
PackageType[] pkgArray = { package };
shipment.Package = pkgArray;
LabelSpecificationType labelSpec = new LabelSpecificationType();
LabelStockSizeType labelStockSize = new LabelStockSizeType();
labelStockSize.Height = "6";
labelStockSize.Width = "4";
labelSpec.LabelStockSize = labelStockSize;
LabelImageFormatType labelImageFormat = new LabelImageFormatType();
LabelDeliveryType labelDel = new LabelDeliveryType();
labelDel.LabelLinksIndicator = "";
labelImageFormat.Code = "GIF";
PackageServiceOptionsType packServiceOptions = new PackageServiceOptionsType();
PackageDeclaredValueType decType = new PackageDeclaredValueType();
decType.CurrencyCode = "USD";
decType.MonetaryValue = s.PackageValue;
packServiceOptions.DeclaredValue = decType;
package.PackageServiceOptions = packServiceOptions;
labelSpec.LabelImageFormat = labelImageFormat;
ShipmentTypeShipmentServiceOptions shipServOpt = new ShipmentTypeShipmentServiceOptions();
shipment.ShipmentServiceOptions = shipServOpt;
shipmentRequest.LabelSpecification = labelSpec;
shipmentRequest.Shipment = shipment;
System.Net.ServicePointManager.CertificatePolicy = new TrustAllCertificatePolicy();
Console.WriteLine(shipmentRequest);
shipmentResponse = shpSvc.ProcessShipment(shipmentRequest);
}
解决方案
I faced pretty the same problem, and luckily for you I resolved the problem ;)
You need something to register a SOAP Extension:
[ReflectionPermission(SecurityAction.Demand, Unrestricted = true)]
public static void RegisterSoapExtension(Type type, int priority, PriorityGroup group)
{
if (!type.IsSubclassOf(typeof(SoapExtension)))
{
throw new ArgumentException("Type must be derived from SoapException.", "type");
}
if (priority < 1)
{
throw new ArgumentOutOfRangeException("priority", priority, "Priority must be greater or equal to 1.");
}
// get the current web services settings...
WebServicesSection wss = WebServicesSection.Current;
// set SoapExtensionTypes collection to read/write...
FieldInfo readOnlyField = typeof(System.Configuration.ConfigurationElementCollection).GetField("bReadOnly", BindingFlags.NonPublic | BindingFlags.Instance);
readOnlyField.SetValue(wss.SoapExtensionTypes, false);
// inject SoapExtension...
//wss.SoapExtensionTypes.Add(new SoapExtensionTypeElement(type, priority, group));
System.Web.Services.Configuration.SoapExtensionTypeElement soapInterceptor = new SoapExtensionTypeElement();
soapInterceptor.Type = type;
soapInterceptor.Priority = priority;
soapInterceptor.Group = group;
wss.SoapExtensionTypes.Add(soapInterceptor);
// set SoapExtensionTypes collection back to readonly and clear modified flags...
MethodInfo resetModifiedMethod = typeof(System.Configuration.ConfigurationElement).GetMethod("ResetModified", BindingFlags.NonPublic | BindingFlags.Instance);
resetModifiedMethod.Invoke(wss.SoapExtensionTypes, null);
MethodInfo setReadOnlyMethod = typeof(System.Configuration.ConfigurationElement).GetMethod("SetReadOnly", BindingFlags.NonPublic | BindingFlags.Instance);
setReadOnlyMethod.Invoke(wss.SoapExtensionTypes, null);
}
You need to define the actual extension:
/// <summary>
/// SOAP Extension that traces the SOAP request and
/// SOAP response to a SOAP API Web service.
/// </summary>
public class TraceExtension : SoapExtension
{
private Stream oldStream;
private Stream newStream;
private static XmlDocument xmlRequest;
/// <summary>
/// Gets the outgoing XML request
/// </summary>
public static XmlDocument XmlRequest
{
get { return xmlRequest; }
}
private static XmlDocument xmlResponse;
/// <summary>
/// Gets the incoming XML response
/// </summary>
public static XmlDocument XmlResponse
{
get { return xmlResponse; }
}
/// <summary>
/// Save the Stream representing the SOAP request
/// or SOAP response into a local memory buffer.
/// </summary>
/// <param name="stream"></param>
/// <returns></returns>
public override Stream ChainStream(Stream stream)
{
oldStream = stream;
newStream = new MemoryStream();
return newStream;
}
/// <summary>
/// If the SoapMessageStage is such that the SoapRequest or
/// SoapResponse is still in the SOAP format to be sent or received,
/// save it to the xmlRequest or xmlResponse property.
/// </summary>
/// <param name="message"></param>
public override void ProcessMessage(SoapMessage message)
{
switch (message.Stage)
{
case SoapMessageStage.BeforeSerialize:
break;
case SoapMessageStage.AfterSerialize:
xmlRequest = GetSoapEnvelope(newStream);
CopyStream(newStream, oldStream);
break;
case SoapMessageStage.BeforeDeserialize:
CopyStream(oldStream, newStream);
xmlResponse = GetSoapEnvelope(newStream);
break;
case SoapMessageStage.AfterDeserialize:
break;
}
}
/// <summary>
/// Returns the XML representation of the Soap Envelope in the supplied stream.
/// Resets the position of stream to zero.
/// </summary>
/// <param name="stream"></param>
/// <returns></returns>
private XmlDocument GetSoapEnvelope(Stream stream)
{
var xml = new XmlDocument();
stream.Position = 0;
var reader = new StreamReader(stream);
xml.LoadXml(reader.ReadToEnd());
stream.Position = 0;
return xml;
}
/// <summary>
/// Copies a stream.
/// </summary>
/// <param name="from"></param>
/// <param name="to"></param>
private void CopyStream(Stream from, Stream to)
{
TextReader reader = new StreamReader(from);
TextWriter writer = new StreamWriter(to);
writer.WriteLine(reader.ReadToEnd());
writer.Flush();
}
/// <summary>
/// Included only because it must be implemented.
/// </summary>
/// <param name="methodInfo"></param>
/// <param name="attribute"></param>
/// <returns></returns>
public override object GetInitializer(LogicalMethodInfo methodInfo,
SoapExtensionAttribute attribute)
{
return null;
}
/// <summary>
/// Included only because it must be implemented.
/// </summary>
/// <param name="WebServiceType"></param>
/// <returns></returns>
public override object GetInitializer(Type WebServiceType)
{
return null;
}
/// <summary>
/// Included only because it must be implemented.
/// </summary>
/// <param name="initializer"></param>
public override void Initialize(object initializer)
{
}
}
Then you need to register the extension:
RegisterSoapExtension(typeof(TraceExtension), 1, 0);
Finally, after your requests/responses are done, you need to save the XML:
TraceExtension.XmlRequest.Save(@"c:\temp\ForwardRequest.xml");
TraceExtension.XmlResponse.Save(@"c:\temp\ForwardResponse{0}.xml");
Warning: this is actually pretty much what I used to pass through UPS certification, but this code has only been used once. As such, it may not be of the greatest quality, be pretty or otherwise very usable other than for that one single thing.
这篇关于需要原始XML请求和放大器;响应在UPS API（.NET）的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
查看全文
