如何把OracleParameter序列化？（高分求助,顶者有分！）

在下做了一个remoting访问数据库的架构，在本地传递sql以及OracleParameter到远端执行。
结果OracleParameter由于不能序列化而报错，哪位大侠能提供一个demo将OracleParameter序列化？

或者是param[] 转化也行。

在线等...

35 个解决方案

#1

sf

#2

mark

#3

可以写一个与OracleParameter类相与转换的新类，把这个新类序列化传送，其实这个很容易实现，比如把一个OracleParameter里主要的参数信息，比如参数名，参数类型，值，传送方向，小数位等信息一一用新类来表示，其后再把新类的相应的信息传到OracleParameter的新实例里，这样来达到传递参数的目的。

#4

顶

#5

http://blog.csdn.net/zjj2816_163com/category/139315.aspx

#6

hbxtlhx :
你说的方式我也想到了，但是不晓得如何实现，能给一个例子吗？

#7

没用过，也顶一下

#8

把参数定义成类，然后传送时，转换成用逗号分隔的串，在远端进行解析，还原成类，在进行转换就可以了，两边都存在所谓的编码解码方法。

#9

net_boy :
希望有demo看一下，谢谢！

#10

这不跟Socket通讯类似么

#11

哦,其实用XML序列化类就很简单,因为OracleParameter有一个无参数的public构造函数,完全可以使用XML序列化类

#12

up

#13

UP

#14

进来看看...

#15

jupiter911 :
你能代码示范一下吗？

#16

			System.Xml.Serialization.XmlSerializer XMLSerializer = new System.Xml.Serialization.XmlSerializer((new MyClass()).GetType());
			MemoryStream ms = new MemoryStream();
			//序列化
			XMLSerializer.Serialize(ms,new MyClass());
			MyClass mc = (MyClass)XMLSerializer.Deserialize(ms);

#17

new MyClass()也可以用你的OracleParameter对象的

#18

jupiter911   : 
非常谢谢你，但是我用了报错：

"XML 文档(0, 0)中有错误。"
{"缺少根元素。"}

System.Xml.Serialization.XmlSerializer XMLSerializer = new System.Xml.Serialization.XmlSerializer((dpParams).GetType());
MemoryStream ms = new MemoryStream();
//序列化
 XMLSerializer.Serialize(ms, dpParams);

return DAL.DALFactory.EntityFactory.RemotingServer.ExecuteNonQuery(CommandType.Text, finalSQLQuery.ToString(), dpParams);

反序列化：
System.Xml.Serialization.XmlSerializer XMLSerializer = new System.Xml.Serialization.XmlSerializer((commandParameters).GetType());
MemoryStream ms = new MemoryStream();
OracleParameter[] mc = (OracleParameter[])XMLSerializer.Deserialize(ms);
//这里出错！

#19

很明显你序列化的时候使用的是OracleParameter对象,而在反序列化的时候用的是OracleParameter[]对象,这是对象转化错误了

#20

上班时间，只能写点粗的代码，好久没有coding了
刚才有事出去了，刚写完：
/// <summary>
    /// Oracle参数类
    /// </summary>
    public class OracleParameterClass
    {
        public string _ParameterName = string.Empty;
        public string _OracleTypeName = string.Empty;
        public string _ParameterValue = string.Empty;
        public string _ParameterSize = "0";
        public string ParameterName
        {
            get
            {
                return _ParameterName;
            }
            set
            {
                _ParameterName = value;
            }
        }
        public string OracleTypeName
        {
            get
            {
                return _OracleTypeName;
            }
            set
            {
                _OracleTypeName = value;
            }
        }
        public string ParameterValue
        {
            get
            {
                return _ParameterValue;
            }
            set
            {
                _ParameterValue = value;
            }
        }
        public string ParameterSize
        {
            get
            {
                return _ParameterSize;
            }
            set
            {
                _ParameterSize = value;
            }
        }
    }

    protected void Page_Load(object sender, EventArgs e)
    {
        string sendString = string.Empty;
        OracleParameter op = new OracleParameter();
        op.ParameterName = "a";
        op.OracleType = OracleType.Number;
        op.Value = 1;
        op.Size = 4;
        OracleParameterClass OPC = new OracleParameterClass();
        OPC.ParameterName = op.ParameterName;
        OPC.OracleTypeName = op.OracleType.ToString();
        OPC.ParameterValue = op.Value.ToString();
        OPC.ParameterSize = op.Size.ToString();

        sendString = EncodeOracleParameter(OPC);
        
    }

    /// <summary>
    /// Oracle参数编码
    /// </summary>
    /// <param name="OPC"></param>
    /// <returns></returns>
    public string EncodeOracleParameter(OracleParameterClass OPC)
    {
        string tempSendString = string.Empty;
        string tempSendString = OPC.ParameterName + "," + OPC.OracleTypeName + "," + OPC.ParameterValue + "," + OPC.ParameterSize;
        return tempSendString;
    }

    /// <summary>
    /// Oracle参数解码
    /// </summary>
    /// <param name="OPC"></param>
    /// <returns></returns>
    public OracleParameterClass DecodeOracleParameter(string sendString)
    {
        OracleParameterClass tempOracleParameterClass = new OracleParameterClass();
        tempOracleParameterClass.ParameterName = sendString.Split(",").GetValue(0).ToString();
        tempOracleParameterClass.OracleTypeName = sendString.Split(",").GetValue(1).ToString();
        tempOracleParameterClass.ParameterSize = sendString.Split(",").GetValue(2).ToString();
        tempOracleParameterClass.ParameterValue = sendString.Split(",").GetValue(3).ToString();
        return tempOracleParameterClass;
        //在下面可以添加给OracleParameter赋值的语句
    }

#21

另外还有一个问题,序列化之后数据是被保存在ms里的,而不是XMLSerializer里的,你用错流了

#22

jupiter911 :
你能不能将我的代码改一改？第一次用序列化。麻烦了。
你说的：OracleParameter对象,而在反序列化的时候用的是OracleParameter[]对象
其实我用的是同一个东西：都是 OracleParameter[]。
OracleParameter[] dpParams；

#23

谢谢net_boy ：
我会把你的方式好好的试一试，同时jupiter911 的方式我也不会放过。
继续等待好心人，

#24

哦对了,由于序列化的时候流被使用了,所以还要将流的位置设为0

如果你用的是OracleParameter[]对象的话,恐怕要转就难了,因为OracleParameter[]是一个Array对象,这个东西挺麻烦的
不过你可以遍历你的OracleParameter[],将每个元素都序列化一次,然后作为一个数组传出去.

#25

天啦，这么痛苦，
net_boy的方式也不是数组，我也要再转，没有现成的啊，
等待高手，
jupiter911 将流的位置设为0 ？怎么设置?

#26

刚才仔细看了下你的代码,发现你还是不熟悉这个流程.我在下面简单的画一下吧
排版可能不对你凑合着看吧

{OracleParameter[] mc} ->[XmlSerializer XMLSerializer1] -> 流
       |__________________________________________________↑

流 ->[XmlSerializer XMLSerializer2] ->{object}

OracleParameter[] newmc = (OracleParameter[])object;

也就是说,真正起到传输作用的,是流,而不是你的XmlSerializer对象.

#27

ms.Position=0;

#28

根据SqlHelper修改一个就行了.或者petshop4.0中找.

#29

petshop4.0?
没有实现远程传递oracleparameter[]

#30

UP

#31

关注

#32

mark

#33

本来想借用net_boy的方式，即字符串传递，但是
1.担心效率，
2.类型转化比较麻烦，例如oracletype->string就没有办法，
所以自己做了一个oracle参数类，贴出：

using System;
using System.Collections.Generic;
using System.Text;
using System.Data.OracleClient;
using System.Collections;
using System.Data;

namespace DAL.DBUtility
{
    [Serializable]
    public class DBParameter 
    {
        private OracleType oracleType;//参数类型
        private string parameterName;//参数名
        private int size;//参数大小
        private object parameterValue;//参数值
        public DBParameter()
        {
        }
        public DBParameter(string parameterName, OracleType dbType, int size)
        {
            if (parameterName != null)
            {
                this.parameterName = parameterName.Trim();
            }
            this.oracleType = dbType;
            this.size = size;
        }
        public DBParameter(string parameterName, OracleType dbType, int size, object value)
        {
            if (parameterName != null)
            {
                this.parameterName = parameterName.Trim();
            }
            this.oracleType = dbType;
            this.size = size;
            this.parameterValue = value;
        }

        public OracleType DBType
        {
            get
            {
                return oracleType;
            }
            set
            {
                this.oracleType = value;
            }
        }
        public string ParameterName
        {
            get
            {
                return this.parameterName;
            }
            set
            {
                if (value != null)
                {
                    this.parameterName = value;
                }
                else
                {
                    this.parameterName = null;
                }
            }
        }
        public int Size
        {
            get
            {
                return this.size;
            }
            set
            {
                this.size = value;
            }
        }
        public object Value
        {
            get
            {
                return parameterValue;
            }
            set
            {
                this.parameterValue = value;
            }
        }

        public override bool Equals(object obj)
        {
            if (obj == null || obj.GetType() != this.GetType())
            {
                return false;
            }
            DBParameter p = (DBParameter)obj;
            return ((this.oracleType == p.oracleType) && (string.Compare(this.parameterName, p.parameterName, true, System.Globalization.CultureInfo.CurrentCulture) == 0) && (this.parameterValue.GetHashCode() == p.parameterValue.GetHashCode()) && (this.size == p.size));
        }
        public override int GetHashCode()
        {
            return this.oracleType.GetHashCode() ^ this.parameterName.GetHashCode() ^ this.size.GetHashCode() ^ this.parameterValue.GetHashCode();
        }
    }
}

然后就开始编码，解码：测试代码：

        private List<DBParameter> Convert2DBP(OracleParameter[] oracleparam)
        {
            List<DBParameter> dbParameter = new List<DBParameter>();
            if (oracleparam != null)
            {
                foreach (OracleParameter parm in oracleparam)
                {
                    DBParameter OPC = new DBParameter();
                    OPC.ParameterName = parm.ParameterName;
                    OPC.DBType = parm.OracleType ;
                    OPC.Value = parm.Value ;
                    OPC.Size = parm.Size ;
                    dbParameter.Add(OPC);
                }
            }
            return dbParameter;
        }

        private IList<OracleParameter> Convert2Oracle(IList<DBParameter> dbParameter)
        {
            IList<OracleParameter> oralceParameter = new List<OracleParameter>();

            if (dbParameter != null)
            {
                foreach (DBParameter parm in dbParameter)
                {
                    OracleParameter OPC = new OracleParameter();
                    OPC.ParameterName = parm.ParameterName;
                    OPC.OracleType = parm.DBType;
                    OPC.Value = parm.Value;
                    OPC.Size = parm.Size;
                    oralceParameter.Add(OPC);
                }
            }
            return oralceParameter;
        }

        private void button8_Click(object sender, EventArgs e)
        {
            IList<DBParameter> dbParameter = null;
            OracleParameter[] parms = null;
            //创建oracle参数数组
            parms = new OracleParameter[] {												 
					new OracleParameter("Test1", OracleType.Number, 10),
					new OracleParameter("Test2", OracleType.VarChar, 30),
					new OracleParameter("Test3", OracleType.Number, 10)};

            parms[0].Value = 1;
            parms[1].Value = "122222";
            parms[2].Value = 123;
            //转化成序列化的参数
            dbParameter = Convert2DBP(parms);

            //反序列化
            IList<OracleParameter> oralceParameter = null;
            oralceParameter =Convert2Oracle(dbParameter);
            foreach (OracleParameter p in oralceParameter)
            {
                System.Console.WriteLine(p.ParameterName + p.OracleType.ToString()+p.Size.ToString()+p.Value.ToString());
            }
        }

说两点：
1,整个测试没有问题
2,上面那个封装的类，大家帮我看看需要修改不？
3,还没有做远程测试，应该可以传递吧？？

大家继续讨论！我个人觉得这种方式效率要高些！

#34

呵呵，自己做了测试，远程调用没有问题，
太高兴了，终于攻克了这个问题，庆祝一下，可以不能自己给自己加分！
但是我还是希望大家能帮我看看我的代码有什么问题没有啊！

#35

Mark