c#中实现的万能变量类

最新推荐文章于 2021-09-02 12:39:30 发布
最新推荐文章于 2021-09-02 12:39:30 发布
阅读量2.4k 收藏 5
点赞数
分类专栏： c# 文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangjie6898862/article/details/52245856
版权

c#里面有一个很好的机制一切对象都继承自Object

废话少说直接上代码：第一个类Varient.cs文件

using System;
using UnityEngine;
using System.Collections;
using System.Collections.Generic;

/// <summary>
/// 公用的容器
/// </summary>
public class Variant
{
    public bool isNull
    {
        get{return m_value == null;}
        set{if (value == true){m_value = null;}}
    }

    public void set_bool(bool b)
    {m_value = b;}

    public void set_value(double b)
    {m_value = b;}

    public void set_int(int b)
    { m_value = b; }

    public void set_string(string b)
    {m_value = b;}

    public bool get_bool()
    {
        if (m_value == null || m_value.GetType() != typeof(bool))
        {return false;}
        return (bool)m_value;
    }

    public double get_value()
    {
        if (m_value == null || m_value.GetType() != typeof(double))
        {return 0;}
        return (double)m_value;
    }

    public int get_int()
    {
        if (m_value == null || m_value.GetType() != typeof(int))
        { return 0; }
        return (int)m_value;
    }

    public string get_string()
    {
        if (m_value == null)
        {return "";}
        return m_value.ToString();
    }

    public void set_object(object a)
    {m_value = a;}

    public void set_json(string data)
    {
        LitJson.JsonData js = LitJson.JsonMapper.ToObject(data);
        try
        {
            _json_add(js, this);
        }
        catch (System.Exception ex)
        {
            Logging.LogError(ex.ToString());
            m_value = null;
        }

    }

    public string to_json()
    {
        LitJson.JsonData js = _json_get(this);
        if (js == null){return "{}";}
        return js.ToJson();
    }

    static void _json_add(LitJson.JsonData js, Variant v)
    {
        if (js.IsObject){_json_add_obj(js, v);}
        else if (js.IsArray){_json_add_list(js, v);}
        else if (js.IsBoolean){_json_add_bool(js, v);}
        else if (js.IsInt){_json_add_int(js, v);}
        else if (js.IsDouble){_json_add_double(js, v);}
        else{_json_add_string(js, v);}
    }

    static void _json_add_obj(LitJson.JsonData js, Variant v)
    {
        Dictionary<string,  Variant> map = v.to_name_map();
        if (map == null)
        {return;}

        foreach (string vk in ((IDictionary)js).Keys)
        {
            LitJson.JsonData js_s = js[vk];
            map[vk] = new Variant();
            _json_add(js_s, map[vk]);
        }
    }

    static void _json_add_list(LitJson.JsonData js, Variant v)
    {
        var list = v.to_list();

        for(int i=0; i < js.Count; i++)
        {
            var sub = new Variant();
            list.Add(sub);
            _json_add(js[i], sub);
        }
    }

    static void _json_add_bool(LitJson.JsonData js, Variant v)
    {
        v.set_bool((bool)js);
    }

    static void _json_add_int(LitJson.JsonData js, Variant v)
    {
        v.m_value = ((int)js);
    }

    static void _json_add_double(LitJson.JsonData js, Variant v)
    {
        v.m_value = ((double)js);
    }

    static void _json_add_string(LitJson.JsonData js, Variant v)
    {
        v.m_value = js.ToString();
    }

    static LitJson.JsonData _json_get(Variant v)
    {
        if (v.m_value == null)
        {
            return null;
        }

        if (v.m_value.GetType() == typeof(Dictionary<string, Variant>))
        {
            LitJson.JsonData js = new LitJson.JsonData();
            foreach(var kv in ((Dictionary<string, Variant>)v.m_value))
            {
                js.SetJsonType(LitJson.JsonType.Object);
                ((IDictionary)js)[kv.Key] = _json_get(kv.Value);
            }
            return js;
        }
        else if (v.m_value.GetType() == typeof(List<Variant>))
        {
            LitJson.JsonData js = new LitJson.JsonData();
            js.SetJsonType(LitJson.JsonType.Array);
            foreach (var kv in ((List<Variant>)v.m_value))
            {
                js.Add(_json_get(kv));
            }
            return js;
        }
        else if (    
            v.m_value.GetType() == typeof(int)        ||
            v.m_value.GetType() == typeof(double)    ||
            v.m_value.GetType() == typeof(bool))
        {
            return new LitJson.JsonData(v.m_value);
        }
        else
        {
            return new LitJson.JsonData(v.m_value.ToString());
        }
    }

    public object get_object(string type)
    {
        Type t = Type.GetType(type);
        if (t == null){return null;}
        if (m_value == null){return null;}
        if (m_value.GetType() != t){return null;}
        return m_value;
    }

    public string to_string()
    {
        if (m_value == null){return "";}
        return m_value.ToString();
    }

    public double to_double(double def)
    {
        string sv = to_string();
        double ret = def;
        if (double.TryParse(sv, out ret))
        {return ret;}
        return def;
    }

    public float to_float(float def)
    {
        return (float)to_double((double)def);
    }

    public int to_int(int def)
    {
        return (int)to_double((double)def);
    }

    public object[] list_to_params()
    {
        if (m_value == null || m_value.GetType() != typeof(List<Variant>))
        {return new object[0];}
        var l = to_list();
        if (l == null || l.Count == 0)
        {return new object[0];}
        object[] pl = new object[l.Count];
        for (int i = 0; i < l.Count; i++)
        {pl[i] = l[i].m_value;}
        return pl;
    }

    public List<Variant> to_list()
    {
        if(m_value != null && m_value.GetType() == typeof(List<Variant>))
        {return (List<Variant>)m_value;}
        List<Variant> l  = new List<Variant>();
        m_value = l;
        return l;
    }

    public Dictionary<int,  Variant> to_map()
    {
        if(m_value != null && m_value.GetType() == typeof(Dictionary<int,Variant>))
        {return (Dictionary<int,  Variant>)m_value;}
        Dictionary<int,  Variant> l  = new Dictionary<int,  Variant>();
        m_value = l;
        return l;
    }

    public Dictionary<string, Variant> to_name_map()
    {
        if (m_value != null && m_value.GetType() == typeof(Dictionary<string, Variant>))
        {return (Dictionary<string,  Variant>)m_value;}
        Dictionary<string,  Variant> l  = new Dictionary<string,  Variant>();
        m_value = l;
        return l;
    }

    public Variant push_in_list()
    {
        var n = new Variant();
        to_list().Add(n);
        return n;
    }

    public Variant get_in_list(int id)
    {
        List<Variant> v = to_list();
        if (v == null)
        {
            return null;
        }

        if (id < 0 || id >= v.Count)
        {
            return null;
        }

        return v[id];
    }

    public Variant apply_in_map(int id)
    {
        var v = to_map();
        if (!v.ContainsKey(id))
        {v[id] = new Variant();}
        return v[id];
    }

    public Variant apply_in_name_map(string n)
    {
        var v = to_name_map();
        if (!v.ContainsKey(n))
        { v[n] = new Variant(); }
        return v[n];
    }

    public override string ToString()
    {
        if (m_value == null)
        { return "Variant:null"; }
        return "Variant:" + m_value.GetType().Name + ":" + m_value.ToString();
    }

    object    m_value = null;
}
//第二个类文件 cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;



namespace vs2015demo
{
    public class  Person
    {

        public string Name { set; get; }
        public int Age { set; get; }
        public string Birthday { set; get; }

    }

    class Program
    {

        static void Main(string[] args)
        {
            Variant my = new Variant();
            string json = @"
            {
               ""Name""    : ""YANGJIE"",//测试了下单引号和双引号都可以
                'Age'      : 24,
                'Birthday' : '1990'
            }";

            string json2 = @"
            {
               ""Name""    : ""WUGANG"",
                'Age'      : 25,
                'Birthday' : '1990'
            }";


            //Person per = LitJson.JsonMapper.ToObject<Person>(json);
            //LitJson.JsonData js = LitJson.JsonMapper.ToObject(json);

            //Console.WriteLine(js["Name"].ToString() + js["Age"].ToString() + 
            //    js["Birthday"].ToString());

            string[] arrstr = { "yangjie", "wugang" };
            string[] jsonstr = { json, json2 };

            for (int i = 0; i < arrstr.Length; i++)
            {
                my.apply_in_name_map(arrstr[i]).set_json(jsonstr[i]);
            }

            //my.apply_in_map("yangjie").set_json(json);
            //my.apply_in_map("wugang").set_json(json2);


            for (int i = 0; i < arrstr.Length; i++)
            {
                var it = my.apply_in_name_map(arrstr[i]);
                Console.WriteLine(it.to_name_map()["Name"].get_string());
                Console.WriteLine(it.to_name_map()["Age"].get_int());
                Console.WriteLine(it.to_name_map()["Birthday"].get_string());
            }







           // my.apply_in_name_map("yangjie").set_int(25);
          //  var age = my.apply_in_name_map("yangjie").get_int();


            //my.push_in_list();
            //my.push_in_list();
            //my.get_in_list(0).set_int(100);
            //my.get_in_list(1).set_int(101);
            //for (int i = 0; i < 2; i++)
            //{
            //    Console.WriteLine(my.get_in_list(i).get_int());
            //}


            // Console.WriteLine(age);
            Console.ReadKey(); 

        }
    }
}


yj爆裂鼓手
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#类中static变量用法分析
09-03
本篇文章将深入探讨C#类中的`static`变量用法，以及其初始化和生命周期。 首先，让我们看看`static`变量的初始化时机。对于一个类，`static`变量的初始化发生在类的首次被引用时，而不是在创建类的实例时。这意味着...
用实例讲解Variant类型在VB、C#、VC中的参数传递
cuibinmo3519的博客
02-25 453
　几年前我用VB开发了一个西门子PPI通信控件，由于VB开发的控件是标准的COM组件，所以想当然的认为VC、C#、Delphi等开发语言可以非常容易的使用。 　　前段时间由于该控件基于微软的MSCOMM控件，这个控件如果系统没...
C# 关于变体
eskimoer的专栏
03-31 2283
关于协变和逆变 协变和逆变统称为变体，这是用于数组类型，委托类型，泛型参数类型间进行隐式引用转换用的语法规则，有点类似多态。 泛型接口中的变体 协变 接口中声明的方法的泛型返回类型，它可以接受派程度更大的返回类型 interface ICovariant { R GetSomething(); // The following statement generate
c# 万能模型类型转换
橙-极纪元-cplvfx-JJY.Cheng
09-02 668
调用 //获取一条User数据 UserModel model=GetUser(); //把UserModel类型转换成UserInfoModel类型 var userInfoModel = ModelTypeConvert.Convert<UserModel, UserInfoModel>(model); 核心代码 /// <summary> /// 模型类型转换 /// </summary> public class Mo.
C#万能类型转换
hejisan的专栏
11-08 1800
public static class Extension { public static T ParseTo(this object source, T defvalue) { if (source == null || source.ToString() == "") return defvalue; try { return
C#中变量的类型
qq_951274168的博客
08-02 1911
文章目录值类型引用类型值类型与引用类型的区别枚举类型变量的作用域 值类型 C#中值类型的变量主要包括整数类型、浮点类型、decimal和bool类型等。值类型的变量都在堆栈中进行分配，因此效率很高。所以使用值类型的主要目的是为了提高性能。 整数类型 整数类型代表的就是一个整数。当用户声明一个int类型时，系统就会分配内存来存储值。 浮点类型 浮点类型的变量主要是对带有小数点的数据进行处理。 decimal类型 decimal关键字指示128位数据类型。与其他浮点型相比，decimal类型具有更高的精度和更
C#中static静态变量的用法实例
12-31
本文实例讲述了C#中static静态变量的用法。分享给大家供大家参考。具体如下： 使用 static 修饰符声明属于类型本身而不是属于特定对象的静态成员static修饰符可用于类、字段、方法、属性、运算符、事件和构造函数，...
C#中的局部变量冲突问题
08-25
今天小编就为大家分享一篇C#中的局部变量冲突问题，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
万能查询,万能查询数据库
03-01
单击“查询”按钮，进入“查询”模块，如图1.2所示。在“表达式”中可以手动输入查询语句，也可以在查询条件中设置条件，然后单击“查询”按钮，显示查询结果。
variant 用法
08-21
variant 用法,包括函数，变量如何使用
万能查询模块,C# ,Visual
07-21
（1）将DataBase文件夹中的两个文件拷贝到SQL Server 2000安装路径下的Data文件夹中。 （2）打开SQL Server 2000中的“企业管理器”，然后展开本地服务器，在“数据库”数据项上单击鼠标右键，在弹出的快捷菜单中选择“所有任务”/“附加数据库”菜单项。 （3）将弹出“附加数据库”对话框，在该对话框中单击“ ”按钮，选择所要附加数据库的.mdf文件，单击“确定”按钮，即可完成数据库的附加操作。
VARIANT数据类型详解
kilvdn的专栏
02-19 5720
VARIANT 数据类型在文件OAIDL.IDL中定义如下：struct tagVARIANT {     union {         struct __tagVARIANT {             VARTYPE vt;             WORD     wReserved1;             WORD     wReserved2;             WORD  
C# 通用类型系统
写给自己看的博客
08-03 1186
参考文章：  https://www.cnblogs.com/bakuhert/articles/5878086.html http://www.cnblogs.com/anytao/archive/2007/05/11/must_net_07.html   .NET技术可以以规范和实现两部分来划分： 规范：公共语言架构（CLI）：通用类型系统（CTS），公共语言规范（ CLS），通用中间...
C#通用类型转换方法
qjwqjwqjw3的专栏
05-30 1568
static public object ChangeType(object value, Type type) { if (value == null && type.IsGenericType) return Activator.CreateInstance(type); if (value == null) return nul
c#中不同类中变量的引用方法
最新发布
05-24
在C#中，如果要在不同的类之间引用变量，可以通过以下几种方法： 1. 通过构造函数传递变量引用 在类A中创建一个构造函数，该构造函数接受类B的实例作为参数，并将类B的实例中的变量引用传递给类A中的变量，如下所...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值