namespace DObject.DType
{
/// <summary>
/// cd转换帮助c,静态方法实现。加入了~存机制Q减反次数?br />
/// </summary>
public static class StaticConvertor
{
private const string CONVERTMETHOD = "TryParse";
private static Dictionary<System.Type, MethodInfo> map = new Dictionary<System.Type, MethodInfo>(20);
private static MethodInfo prepareMethod(System.Type type)
{
lock (map)
{
if (!map.ContainsKey(type))
{
System.Type[] typeArray = new System.Type[2];
typeArray.SetValue(typeof(string), 0);
typeArray.SetValue(type.GetType().MakeByRefType(), 1);
MethodInfo method = type.GetType().GetMethod(CONVERTMETHOD, typeArray);
if (method != null)
{
map.Add(type, method);
}
else
return null;
}
return map[type];
}
} //end prepareMethod
/// <summary>
/// 转换Ҏ(gu)
/// </summary>
/// <typeparam name="T">转换后类?/span></typeparam>
/// <param name="raw">原始对象</param>
/// <param name="defaultValue">默认?/span></param>
/// <param name="convertSuccessful">是否转换成功</param>
/// <returns>q回?/span></returns>
public static T Convert<T>(object raw, T defaultValue, out bool convertSuccessful) where T : struct
{
convertSuccessful = false;
if (raw == null) //p|
return defaultValue;
else if (raw is T) //成功
{
convertSuccessful = true;
return (T)raw;
}
else
{
try
{
object[] parms = new object[2];
parms[0] = raw.ToString();
parms[1] = 0;
bool isparser = (bool)prepareMethod(typeof(T)).Invoke(null, parms);
if (isparser) //成功
{
convertSuccessful = true;
return (T)parms[1];
}
}
catch
{
}
return defaultValue;
}
} //end Convert<T>
}
}
以上代码的写法,适合DateTime,Int32,Int64,Int16,byte,bool{。只有是structl构Qƈ且有TryParseҎ(gu)可以用。而用v来呢也很单,如以下代?br />
namespace DObject.DType
{
/// <summary>
/// Int32cd保证
/// </summary>
public class DInt32 : DObject, IValuetable<Int32>, IConvertSuccess
{
private int target;
private int defaultValue = -1;
/// <summary>
/// 构造函敎ͼ对象初始化时Q就执行转换
/// </summary>
/// <param name="o"></param>
public DInt32(object o)
: base(o)
{
target = StaticConvertor.Convert<int>(base.raw, defaultValue, out convertSuccessful);
}
public static implicit operator DInt32(DType type)
{
return new DInt32(type.RawObject);
}
private bool convertSuccessful;
/// <summary>
/// q回转换?br />
/// </summary>
/// <returns>q回转换|如果转换成功则返回|转换p|q回默认?nbsp;-1</returns>
public int Value()
{
return Value(defaultValue);
}
/// <summary>
/// q回转换?br />
/// </summary>
/// <param name="defaultValue">默认?/span></param>
/// <returns>q回转换|如果转换成功则返回|转换p|q回默认?/span></returns>
public int Value(int defaultValue)
{
if (convertSuccessful)
return target;
return defaultValue;
}
/// <summary>
/// 是否转换成功
/// </summary>
public bool ConvertSuccess
{
get { return convertSuccessful; }
}
}
}
/// <summary>
/// 构造类型,为内|类型提供构造参数?br />
/// <example>
/// DInt32 int32 = DType.Default("123");
/// </example>
/// </summary>
public class DType
{
private object o;
private DType(object o)
{
this.o = o;
}
/// <summary>
/// 提供对象构造参?br />
/// </summary>
/// <param name="o"></param>
/// <returns></returns>
public static DType Default(object o)
{
return new DType(o);
}
/// <summary>
/// 原始对象
/// </summary>
public object RawObject
{
get { return o; }
}
}
使用h也是单:(x)
DInt32 int32 = DType.Default("123");
int val = int32.Value();
Java里就没这L(fng)了,使用try捕获错误q惌的。java里没有structQ但是有个类型Number是可以使用。当Ӟq就不能像C#一样将׃八糟的东襉K整一块了Q要分开来处理了?br />
/**
*
* @author yurow
*/
public class DNumber extends DObject {
/**
* Create new instance of DNumber
*/
protected DNumber() {
super();
}
protected DNumber(Object obj)
{
super(obj);
}
protected Boolean isconvert;
public Number Convert(Number defaultValue) {
isconvert = false;
if (obj == null) {
return defaultValue;
} else if (obj instanceof Number) {
isconvert = true;
return Number.class.cast(obj);
} else {
return defaultValue;
}
}
}
/**
*
* @author yurow
*/
public class DInt32 extends DNumber {
/**
* Create new instance of DInt32
*/
protected DInt32() {
super();
}
protected DInt32(Object obj) {
super(obj);
}
public static DInt32 newInt32(Object obj) {
return new DInt32(obj);
}
public int Convert()
{
return super.Convert(-1).intValue();
}
}
可以看出QJAVA的类型逻辑层次划分比C#要细_处理h当然要复杂一些。可见粒度ƈ非越l越好。道看来JAVA們于按逻辑划分Q而C#們于按内存布局划分?

]]>