[WebService(Namespace = "http://tempuri.org/")]
    [WebServiceBinding(ConformsTo = WsiProfiles.None)]  
    //WsiProfiles.None这里注意了，要不会有一大堆错误，就是设置了也会有警告，运行调试后最下面会教你怎么做的[WebService1”不符合 WS-I Basic Profile v1.1]。
    [SoapRpcService]    //指定使用rpc方式
    public class WebService1 : System.Web.Services.WebService
    {
        [WebMethod(Description="<br><h3>用于调试本服务.</h3><p>输入参数：无；返回：string 。</p><br /></span>")]   //具体方法中也要指定rpc方式
        public string HelloWorld()
        {
            return "Hello World! " + Common.MD5.getMD5("admin");
        }
    
    [SoapRpcMethod, WebMethod]//具体方法中也要指定rpc方式，而且还必须SoapRpcMethod放在前面，很重要(这问题纠结了我2个多小时)。
        public User HelloWorld(User user)
        {
            User us = new User();
            us.Name = "Hello " + user.Name;
            us.Age = user.Age;
            return us;
        }

     }

public class User
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }

public class User implements KvmSerializable {

private String name = null;
private int age = 0;

@Override
public Object getProperty(int arg0) {
  // TODO Auto-generated method stub
  Object res = null;
  switch(arg0){
   case 0:
    res = this.name;
    break;
   case 1:
    res = this.age;
    break;
   default:
    break;
  }
  return res;
}

@Override
public int getPropertyCount() {
  // TODO Auto-generated method stub
  return 2;
}

@Override
public void getPropertyInfo(int arg0, Hashtable arg1, PropertyInfo arg2) {
  // TODO Auto-generated method stub
  switch(arg0){
  case 0:
   arg2.type = PropertyInfo.STRING_CLASS;
   arg2.name = "Name";    //这name的属性还真不知道他有什么意义，调试时反正随便都可以。
   break;
  case 1:
   arg2.type = PropertyInfo.INTEGER_CLASS;
   arg2.name = "Age";
   break;
  default:
   break;
}
}

@Override
public void setProperty(int arg0, Object arg1) {
  // TODO Auto-generated method stub
  if(arg1 == null) return;
  switch(arg0){
   case 0:
    this.name = arg1.toString();
    break;
   case 1:
    this.age = Integer.valueOf(arg1.toString());
    break;
   default:
    break;
  }
}
}

//调用webservice的具体方法

public String SayHello(){
  String nameSpace = "http://tempuri.org/";
  String methodName = "HelloWorld";
  String soapAction = "http://tempuri.org/HelloWorld";

  String url = "http://192.168.1.25/Default.asmx?wsdl";//后面加不加那个?wsdl参数影响都不大
  
  //建立webservice连接对象
  org.ksoap2.transport.HttpTransportSE transport = new HttpTransportSE(url);
  //new HttpTransportSE(url,3000)  //这可以设置时间？ 我设了好像没啥反应，有时还会timeout异常
  transport.debug = true;//是否是调试模式
  
  //设置连接参数
  SoapObject soapObject = new SoapObject(nameSpace, methodName);
  User user = new User();
  user.setProperty(0, "zhi");
  user.setProperty(1, 18);
  PropertyInfo pi = new PropertyInfo();
  pi.setName("user");//webservice接口的参数名,大小写必须跟dotnet中的webservice暴露出来的名字一致
  pi.setValue(user);
  pi.setType(user.getClass());
  soapObject.addProperty(pi);//将自定参数加入请求对象中
  
  //设置返回参数
  SoapSerializationEnvelope envelope = new SoapSerializationEnvelope(SoapEnvelope.VER11);//soap协议版本必须用SoapEnvelope.VER11（Soap V1.1）
  envelope.dotNet = false;//注意：这个属性是对dotnetwebservice协议的支持,如果dotnet的webservice 不指定rpc方式则用true否则要用false
  envelope.bodyOut = transport;
  envelope.setOutputSoapObject(soapObject);//设置请求参数
  envelope.addMapping(nameSpace, "User", user.getClass());//传对象时必须，参数namespace是webservice中指定的， name是服务器类型的名称， class是自定

义类的类型

  
  try {
       transport.call(soapAction, envelope);
       SoapObject sb = (SoapObject)envelope.bodyIn;//服务器返回的对象存在envelope的bodyIn中
       User us= (User)envelope.getResponse();//直接将返回值强制转换为已知对象
       return us.getName() + us.getAge();
  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch (XmlPullParserException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  } catch(Exception ex){
   ex.printStackTrace();
  }
  return "";
}

using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.IO;
using System.Text;
/// <summary>
/// 文件操作类
/// </summary>
namespace ZXL.Common
{
    public class FileOper
    {
        private string errMessage; //保存的错误信息
        public string ErrMessage
        {
            set
            {
                this.errMessage = value;
            }
            get
            {
                return this.errMessage;
            }
        }
        public FileOper()
        {
            //
            // TODO: 在此处添加构造函数逻辑
            //
        }

        
        /// <summary>
        /// 写文件操作,返回bool形数据
        /// </summary>
        /// <param name="fileDir">相对于根目录的文件路径，如update\</param>
        /// <param name="fileName">文件名，如temp.doc</param>
        /// <param name="txtStream">文本流，要输入的文本流信息</param>
        public bool writeOneFile(string fileDir, string fileName, string txtStream)
        {
            bool returnValue = true;
            string serverBasePath = HttpContext.Current.Request.ServerVariables["APPL_PHYSICAL_PATH"];//服务器根目录
            string strDirPath = serverBasePath + fileDir;//文件夹路径
            //如果文件夹不存在,则创建一个
            if (!Directory.Exists(strDirPath))
            {
                Directory.CreateDirectory(strDirPath);
            }
            StreamWriter sw = null;
            string fullPath = strDirPath + fileName;//完整目录
            Encoding encod = Encoding.GetEncoding("gb2312");//设置编码
            try  //开始写文件
            {
                sw = new StreamWriter(fullPath, false, encod);
                sw.Write(txtStream);
                sw.Flush();
            }
            catch (Exception exp)
            {
                this.errMessage = exp.ToString();
                returnValue = false;
            }
            finally
            {
                sw.Close();
            }
            return returnValue;
        }
        /// <summary>
        /// 读文件操作,返回string数据
        /// </summary>
        /// <param name="fileDir">根目录下的文件路径，如update\</param>
        /// <param name="fileName">文件名，如temp.doc</param>
        public string readOneFile(string fileDir, string fileName)
        {
            string returnValue = "没有读取到数据";
            string serverBasePath = HttpContext.Current.Request.ServerVariables["APPL_PHYSICAL_PATH"];//服务器根目录
            string fullPath = serverBasePath + fileDir + fileName;//完整目录
            Encoding encod = Encoding.GetEncoding("utf-8");//设置编码
            StreamReader sr = null;
            try  //读文件
            {
                if (ifHaveThisFile(fileDir + fileName))
                {
                    sr = new StreamReader(fullPath, encod);
                    returnValue = sr.ReadToEnd();
                    sr.Close();
                }
            }
            catch (Exception exp)
            {
                this.errMessage = exp.ToString();
                returnValue = returnValue + exp.ToString();
            }
            return returnValue;
        }
        /// <summary>
        /// 复制文件操作,返回bool形数据
        /// </summary>
        /// <param name="sourceFileFullPath">源文件完整路径</param>
        /// <param name="newFileFullPath">目的文件完整路径</param>
        public bool copyOneFile(string sourceFileFullPath, string newFileFullPath)
        {
            bool returnValue = false;
            string serverBasePath = HttpContext.Current.Request.ServerVariables["APPL_PHYSICAL_PATH"];//服务器根目录
            try
            {
                if (ifHaveThisFile(sourceFileFullPath))
                {
                    File.Copy(serverBasePath + sourceFileFullPath, serverBasePath + newFileFullPath, true);
                    returnValue = true;
                }
            }
            catch (Exception exp)
            {
                this.errMessage = exp.ToString();
            }
            return returnValue;
        }
        /// <summary>
        /// 删除文件操作,返回bool形数据
        /// </summary>
        /// <param name="fileFullPath">所要删除的文件的相对路径（相对根目录）</param>
        public bool deleteOneFile(string filePath)
        {
            bool returnValue = true;
            try
            {
                string fullPath = HttpContext.Current.Server.MapPath(filePath);
                File.Delete(fullPath);
            }
            catch (Exception exp)
            {
                this.errMessage = exp.ToString();
                returnValue = false;
            }
            return returnValue;  
        }
        /// <summary>
        /// 判断文件是否存在,返回bool形数据
        /// </summary>
        /// <param name="fileFullPath">文件完整路径</param>
        public bool ifHaveThisFile(string fileFullPath)
        {
            bool returnValue = false;
            string serverBasePath = HttpContext.Current.Request.ServerVariables["APPL_PHYSICAL_PATH"];//服务器根目录
            try
            {
                if (File.Exists(serverBasePath + fileFullPath))
                    returnValue = true;
            }
            catch (Exception exp)
            {
                this.errMessage = exp.ToString();
            }
            return returnValue;
        }

        ///   <summary>  
        ///   打开指定的文件  
        ///   </summary>  
        ///   <param   name="PathName">路径（相对路径）</param>  
        ///   <param   name="FileName">文件名（带扩展名）</param>  
        public void OpenFile(string PathName, string FileName)
        {
            try
            {
                string name = PathName + FileName;
                FileInfo aFile = new FileInfo(HttpContext.Current.Server.MapPath(name));
                string na = Path.GetFileName(name);
                HttpContext.Current.Response.Clear();
                HttpContext.Current.Response.ClearHeaders();
                HttpContext.Current.Response.BufferOutput = false;
                HttpContext.Current.Response.ContentType = "application/octet-stream";
                HttpContext.Current.Response.AppendHeader("Content-disposition", "attachment;filename=" + HttpUtility.UrlEncode(FileName, Encoding.UTF8));
                HttpContext.Current.Response.AddHeader("Content-Length", aFile.Length.ToString());
                HttpContext.Current.Response.WriteFile(name);
                HttpContext.Current.Response.Flush();
                HttpContext.Current.Response.End();
            }
            catch (Exception exp)
            {
                this.errMessage = exp.ToString();
            }
        }
    }
}