Unity.CSProject/UnityCSProject.cs at master · zcyemi/Unity.CSProject · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
usingSystem;
usingSystem.Xml;
usingSystem.Xml.Linq;
usingSystem.IO;
usingSystem.Collections.Generic;

namespaceUnity.CSProject
{
publicclassUnityCSProject
{

publicPropertyGroupPropertyDebug;
publicPropertyGroupPropertyRelease;

publicstringProductVersion;
publicstringSchemaVersion;
publicstringAssemblyName;
publicstringTargetFrameworkVersion;
publicstringFileAlignment;
publicstringBaseDirectory;
publicstringOutputType;
publicstringProjectGuid;

publicList<CompileItem>CompileItems;
publicList<ReferenceItem>ReferenceItems;

privateUnityCSProject()
{

}

publicstaticUnityCSProjectParse(stringpath)
{

if(string.IsNullOrEmpty(path))returnnull;
if(!path.ToLower().EndsWith(".csproj"))returnnull;
if(!File.Exists(path))returnnull;

XElementxproject=XElement.Load(path);
stringxns=xproject.Name.NamespaceName;

UnityCSProjectcsproj=newUnityCSProject();

try
{
//Compile files
List<CompileItem>compileFiles=newList<CompileItem>();
List<ReferenceItem>referenceItems=newList<ReferenceItem>();
varitemgroups=xproject.Elements(XName.Get("ItemGroup",xns));
foreach(varitemgroupinitemgroups)
{
varcompiles=itemgroup.Elements(XName.Get("Compile",xns));
foreach(varcompileincompiles)
{
varcompilePath=compile.Attribute(XName.Get("Include"));
if(compilePath==null)continue;
compileFiles.Add(newCompileItem(compilePath.Value));
}

varreferences=itemgroup.Elements(XName.Get("Reference",xns));
foreach(varreferenceinreferences)
{
varattrName=reference.Attribute(XName.Get("Include"))?.Value;
varhintPath=reference.Element(XName.Get("HintPath",xns))?.Value;
referenceItems.Add(newReferenceItem(attrName,hintPath));
}
}

csproj.CompileItems=compileFiles;
csproj.ReferenceItems=referenceItems;

//PropettyGroup

varpropertyGroups=xproject.Elements(XName.Get("PropertyGroup",xns));
foreach(varpropertyGroupinpropertyGroups)
{
varcondition=propertyGroup.Attribute(XName.Get("Condition"));
if(condition==null)
{
//parse main config
csproj.AssemblyName=propertyGroup.Element(XName.Get(nameof(AssemblyName),xns))?.Value;
csproj.BaseDirectory=propertyGroup.Element(XName.Get(nameof(BaseDirectory),xns))?.Value;
csproj.FileAlignment=propertyGroup.Element(XName.Get(nameof(FileAlignment),xns))?.Value;
csproj.OutputType=propertyGroup.Element(XName.Get(nameof(OutputType),xns))?.Value;
csproj.ProductVersion=propertyGroup.Element(XName.Get(nameof(ProductVersion),xns))?.Value;
csproj.ProjectGuid=propertyGroup.Element(XName.Get(nameof(ProjectGuid),xns))?.Value;
csproj.SchemaVersion=propertyGroup.Element(XName.Get(nameof(SchemaVersion),xns))?.Value;
csproj.TargetFrameworkVersion=propertyGroup.Element(XName.Get(nameof(TargetFrameworkVersion),xns))?.Value;
}
else
{
varconditionDesc=condition.Value;
if(conditionDesc.Contains("Debug"))
{
csproj.PropertyDebug=newPropertyGroup(propertyGroup,xns);
}
elseif(conditionDesc.Contains("Release"))
{
csproj.PropertyRelease=newPropertyGroup(propertyGroup,xns);
}
}
}
}
catch(Exceptione)
{
Console.WriteLine(e.Message+"\n"+e.StackTrace);
}


returncsproj;
}
}

publicclassCompileItem
{
publicstringPath;

publicCompileItem(stringpath)
{
this.Path=path;
}
}

publicclassPropertyGroup
{
publicstringDebugSymbols;
publicstringDebugType;
publicstringOptimize;
publicstringOutputPath;
publicstringDefineConstants;
publicstringErrorReport;
publicstringWarningLevel;
publicstringAllowUnsafeBlocks;
publicPropertyGroup(XElementproperty,stringxns)
{
DebugSymbols=property.Element(XName.Get(nameof(DebugSymbols),xns))?.Value;
DebugType=property.Element(XName.Get(nameof(DebugType),xns))?.Value;
Optimize=property.Element(XName.Get(nameof(Optimize),xns))?.Value;
OutputPath=property.Element(XName.Get(nameof(OutputPath),xns))?.Value;
DefineConstants=property.Element(XName.Get(nameof(DefineConstants),xns))?.Value;
ErrorReport=property.Element(XName.Get(nameof(ErrorReport),xns))?.Value;
WarningLevel=property.Element(XName.Get(nameof(WarningLevel),xns))?.Value;
AllowUnsafeBlocks=property.Element(XName.Get(nameof(AllowUnsafeBlocks),xns))?.Value;
}
}

publicclassReferenceItem
{
publicstringName;
publicstringHintPath;

publicReferenceItem(stringname,stringhintpath)
{
this.Name=name;
this.HintPath=hintpath;
}
}
}