在C＃中调用方法

Question

我在WCFService中调用方法时遇到问题。 我为下面的项目下载了文件，并希望在WCFService的SampleHttpResquestAndResponse类中调用一个方法（此外，我尝试在main方法中执行该操作，但也无法成功执行）。 但是我做不到，键入时找不到方法。 如何在SampleHttpResquestAndResponse类中调用这些方法？

using System;
using System.IO;
using System.Net;
using System.Text;
using System.IO.Compression;
using System.Xml.Serialization;

namespace Sample
{
    public class SampleHttpResquestAndResponse
    {
        /// <summary>
        /// Adonis servisi ile iletişim kurmayı sağlar.
        /// </summary>
        /// <typeparam name="T">T</typeparam>
        /// <param name="prm_ServiceName">string</param> SearchHotels //  BasketHotels //  ConfirmHotels
        /// <param name="prm_Criteria">object</param>
        /// <param name="prm_Url">string</param> "http://xmltest.adonis.com/AdonisServices"
        /// <returns>T</returns>
        public static T AdonisRequestResponseMethod<T>(string prm_ServiceName, object prm_Criteria, string prm_Url)
        {
            #region Variables
            HttpWebRequest HttpWebRequest;
            T ReturnValue;
            #endregion

            try
            {
                #region Xml Serializer
                var XmlString = SampleHttpResquestAndResponse.ConvertTypeToXml<object>(prm_Criteria).ToString();
                #endregion

                #region Http Web Request
                HttpWebRequest = (HttpWebRequest)WebRequest.Create(string.Format("{0}/{1}?prm_CurrentData={2}", prm_Url, prm_ServiceName, XmlString));
                HttpWebRequest.ContentType = "text/xml;charset=\"utf-8\"";
                HttpWebRequest.Method = "POST";
                HttpWebRequest.Timeout = 80000000;
                #endregion

                #region Http Web Response
                StreamWriter StreamWriterPost = new StreamWriter(HttpWebRequest.GetRequestStream());
                StreamWriterPost.Write(XmlString);

                StreamWriterPost.Close();
                HttpWebResponse HttpWebResponse = (HttpWebResponse)HttpWebRequest.GetResponse();
                StreamReader StreamReaderResponse = new StreamReader(HttpWebResponse.GetResponseStream(), Encoding.UTF8);
                string StringResponse = string.Empty;

                if (HttpWebResponse.ContentEncoding.ToLower().Contains("gzip"))
                {
                    using (GZipStream decompress = new GZipStream(HttpWebResponse.GetResponseStream(), CompressionMode.Decompress))
                    {
                        StreamReader reader = new StreamReader(decompress);
                        StringResponse = reader.ReadToEnd();
                    }
                }
                else
                {
                    StreamReader reader = new StreamReader(HttpWebResponse.GetResponseStream(), Encoding.UTF8);
                    StringResponse = reader.ReadToEnd();
                }
                #endregion

                #region Return Value Type Process (DESERIALIZE)
                ReturnValue = SampleHttpResquestAndResponse.ConvertXmlToType<T>(StringResponse.ToString()).Data;
                #endregion

                #region Return Value
                return ReturnValue;
                #endregion
            }
            catch (Exception ex)
            {
                #region Return Value
                return ReturnValue = SampleHttpResquestAndResponse.ConvertXmlToType<T>(ex.Message).Data;
                #endregion
            }
        }

        public static ResultDTO<T> ConvertXmlToType<T>(string prm_Xml)
        {
            #region Variables
            T ReturnValue;
            #endregion

            try
            {
                #region Replace String Value
                prm_Xml = prm_Xml.Replace("xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\""
                                        , "xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"");
                prm_Xml = prm_Xml.Replace("&lt;", "<").Replace("&gt;", ">").Replace("&quot;", "\"");
                #endregion

                #region Deserialize
                using (MemoryStream MemoryStream = new MemoryStream())
                {
                    using (StreamWriter StreamWriter = new StreamWriter(MemoryStream))
                    {
                        StreamWriter.Write(prm_Xml);
                        StreamWriter.Flush();
                        MemoryStream.Position = 0;
                        XmlSerializer XmlSerializer = new XmlSerializer(typeof(T));
                        using (StreamReader StreamReader = new StreamReader(MemoryStream))
                        {
                            StreamReader.ReadLine();
                            #region Result Value (SET)
                            ReturnValue = (T)XmlSerializer.Deserialize(StreamReader);
                            #endregion
                        }
                    }
                }
                #endregion

                #region Return Value
                return new ResultDTO<T>
                {
                    Data = ReturnValue,
                    Success = true
                };
                #endregion
            }
            catch (Exception ex)
            {
                #region Return Value
                return new ResultDTO<T>
                {
                    Success = false,
                    Message = string.Format("Error Type : {0} Code : {1} Method Name : {2} Error Mesage : {3}", "Undetermined", "1000", "ConvertXmlToType", ex.Message),
                };
                #endregion
            }
        }

        public static string ConvertTypeToXml<T>(T prm_Criteria)
        {
            #region Variables
            XmlSerializer XmlSerializer;
            StringWriter StringWriter = new StringWriter();
            #endregion

            try
            {
                #region Xml Serializer
                XmlSerializer = new XmlSerializer(prm_Criteria.GetType());
                XmlSerializer.Serialize(StringWriter, prm_Criteria);
                var XmlString = StringWriter.ToString();
                #endregion

                #region Request Replace
                return XmlString = XmlString.Replace("<?xml version=\"1.0\" encoding=\"utf-16\"?>", "");
                #endregion
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                GC.SuppressFinalize(StringWriter);
            }

        }
    }

    public class ResultDTO
    {
        #region Properties
        /// <summary>
        /// İslem durumu.
        /// </summary>
        public bool Success { get; set; }
        /// <summary>
        /// İşlem mesajı.
        /// </summary>
        public string Message { get; set; }
        #endregion
    }

    public class ResultDTO<T> : ResultDTO
    {
        #region Fields
        /// <summary>
        /// Generic data tipi.
        /// </summary>
        private T data = Activator.CreateInstance<T>();
        #endregion

        #region Properties
        /// <summary>
        /// Generic data tipi
        /// </summary>
        public T Data
        {
            get
            {
                if (data == null)
                    return data = default(T);
                return data;
            }
            set { data = value; }
        }
        #endregion
    }
}

PS：我知道这是一个愚蠢的问题，但我不知道。 如果需要，下面是我尝试以简单方式调用此类中的任何方法的方法

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.IO;
using System.Net;
using System.Text;
using System.IO.Compression;
using System.Xml.Serialization;
using Sample;
namespace Adonis
{
    // NOTE: You can use the "Rename" command on the "Refactor" menu to change the class name "AdonisService" in code, svc and config file together.
    // NOTE: In order to launch WCF Test Client for testing this service, please select AdonisService.svc or AdonisService.svc.cs at the Solution Explorer and start debugging.
    public class AdonisService : IAdonisService
    {
        ResultDTO res = new ResultDTO();
        SampleHttpResquestAndResponse samp = new SampleHttpResquestAndResponse();

        public string results()
        {
            string a1 = "";
            object c = new object();
            c = 434;
            string b = "";
            string a = "";
            a= samp.AdonisRequestResponseMethod(a, c, b);
        }

    }
}

Answer 1

AdonisRequestResponseMethod是静态的，因此将这样称呼：

SampleHttpResquestAndResponse.AdonisRequestResponseMethod(a, b, c);

但是，它也是一种通用方法，因此您必须提供所需的类型：

SampleHttpResquestAndResponse.AdonisRequestResponseMethod<string>(a, b, c);

Answer 2

我在这里发现2处错误：

1. 该方法都是通用方法。

由于它是通用方法，因此必须为其提供一种类型：

SampleHttpResquestAndResponse samp = new SampleHttpResquestAndResponse ();
samp.AdonisRequestResponseMethod<SomeType>(a, b, c);

但是，这并不是完整的答案，

2. 这是一个静态方法，这意味着您不能从类的实例中引用该方法，而必须从类类型中引用它

SampleHttpResquestAndResponse.AdonisRequestResponseMethod<SomeType>(a, b, c);

哦，还有一件事... SampleHttpResquestAndResponse在名称的“请求”部分有一个额外的“ s”。 以后可能会让您头疼。 希望这可以帮助！