private void Test3()
{
Log.Print("第3个测试，类似测试1，但这次是GTest<JsonTestClass>，这样会有3个字段，其中包含1个热更类型字段");
GTest <JsonTestClass> t3 = new GTest <JsonTestClass>()
{
a = 3,
b = new JsonTestClass()
{
intVal = 999,
hotVal = new DataClass()
{
gm = false,
Money = 10000,
id = 299,
name = "测试3"
}
}
};
var json = JsonMapper.ToJson(t3);
Log.Print($"序列化后的JSON: {json}");
Log.Print("现在反序列化json，转成一个新的GTest<HotData>");
var newT3 = JsonMapper.ToObject <GTest <JsonTestClass> >(json);
Log.Print(newT3);
}
public static void GenericMethodTest2()
{
GTest test = new GTest();
var t2 = test.SeekUI <TestCls>("abse");
Console.WriteLine(t2.TestVal2.ToString());
}
public static void PassGenericObject <DataType>(GTest <DataType> g1)
{
Helper.TS(g1.v); // wrong
g1.TS(g1.v); // wrong
g1.MyTS(new Helper());
Helper h = new Helper();
h.TS2(g1.v);
}
public static void GenericMethodTest1()
{
GTest test = new GTest();
List <Dictionary <string, object> > content = new List <Dictionary <string, object> >();
Dictionary <string, object> dic = new Dictionary <string, object>();
dic.Add("key1", 1000);
content.Add(dic);
test.SetValue(content);
}
private bool matchGTestStarted(BambooLogParser parser, Row row)
{
var match = regexGTestStarted.Match(row.Message);
if (match.Success)
{
var test = new GTest();
test.Time = row.Time;
setMatchedProperties(test, match.Groups, regexGTestStarted.GetGroupNames());
parser.Stack.Peek().Add(test);
parser.Stack.Push(test);
}
return(match.Success);
}
public static void UT()
{
GTest <DateTime> g1 = new GTest <DateTime>(new DateTime(2011, 1, 1));
Helper.TS(g1.v); // OK TS(DateTime) is invoked;
g1.TS(g1.v); // OK GTest<>::TS(DateTime) is invoked;
g1.MyTS(new Helper());
Helper h = new Helper();
h.TS2(g1.v);
// g1的Generic型別，只在這個區段中有用，只要進入其它區段就好像看不見一樣
PassGenericObject(g1);
}
static void Main(string[] args)
{
float Value = 1.1323232323f;
GTest.ConsolePrint(Value);
GTest.ConsolePrint("lolololololol");
GTest.ConsolePrint(13232313232);
GTest.ConsolePrint("zzzzzzzzzzzz", "kkkkkkkkkk");
//Inven<GameItem> NewGameItemInven = new Inven<GameItem>();
//GameItem NewItem = new GameItem();
//NewGameItemInven.ItemIn(NewGameItem)
//Inven<CashItem> NewCashItemInven = new Inven<CashItem>();
//CashItem NewItem = new CashItem();
//NewCashItemInven.ItemIn(NewCashItem);
}
private void Test1()
{
Log.Print("这是一个复杂的LitJson序列化的测试，别的ILRuntime版本的Litjson并不支持（除非我把这个提交到ILRuntime）");
Log.Print("首先实例化一个本地泛型<热更类型>，GTest<HotData>");
GTest <HotData> d = new GTest <HotData>()
{
a = 1,
b = new HotData()
{
v = 1,
k = "第一个"
}
};
var json = JsonMapper.ToJson(d);
Log.Print($"序列化后的JSON: {json}");
Log.Print("现在反序列化json，转成一个新的GTest<HotData>");
var newD = JsonMapper.ToObject <GTest <HotData> >(json);
Log.Print(newD);
}
static void Main(string[] args)
{
GTest.ConsolePrint("아아아아");
GTest.ConsolePrint <int>(3); // <>는 써도대고 안써도댐
GTest.ConsolePrint(3);
GTest.ConsolePrint(3.12345f);
int i = 20;
string s = "dkdkdk";
Console.WriteLine(s);
Console.WriteLine(i); // < - 얘네는 제네릭은 아님. 오버로딩을
// 여러개 해놓은 것.
// 이녀석은 무조건 <> 써줘야 대ㅔ
Inven <GameItem> NewGameInven = new Inven <GameItem>();
// 인벤은 인벤인데, <GameItem>을 담는 인벤이다!
Inven <Cashitem> NewCashInven = new Inven <Cashitem>();
// 인벤은 인벤인데, <Cashitem>을 담는 인벤이다!
// 제네릭 클래스를 만드는 이유
// 예를 들어보자 : Inven이라는 애가 있어.
// 얘는 item[] Arritem; 이란 필드를 가지고 있어.
// 근데 item을 두 가지로 나누고 싶은거야.
// Cashitem과 Gameitem으로.
// 그럼 Inven에다가 item[] 대신
// Cashitem[], Gameitem[] 두 개를 다 만들어놔?
// 아니면 아예 Inven을 GameInven, CashInven 두 개로 나눠?
// 두 가지 방법 모두 비효율적이지.
// 그 아이템타입 하나 빼면 다 똑같을텐데!
// 그래서 제네릭을 쓰는거야.
// Inven<Item_Type> 이런 식으로.
// 그럼 필드는 Item_Type[] ArrItem; 이라하면 되겠지.
NewCashInven.ItemIn(0, new Cashitem(10));
Inven <Cashitem> .Test(NewCashInven.GetItem(0));
// 여기서 생기는 궁금증.
// 만약 gameitem/cashitem이 item의 자식 클래스라고 하자.
// 그럼 부모인 Item을 넣으라고 표시한 곳에
// 자식인 CashItem을 넣어도 될까? 되겠지? 업캐스팅이니까?
Inven <Item> NewInven = new Inven <Item>();
NewInven.ItemIn(0, new GameItem(5));
Inven <Item> .Test(NewInven.GetItem(0));
// 대넹.
// NewInven.ItemIn(int _number, Item _Item)
// Item타입을 넣는 곳에 GameItem을 넣어도 작동된다.
// 반대는 불가능.
// NewCashInven.ItemIn(0, new Item(10));
// 다운캐스팅이니까.
Console.ReadKey();
}
