Mercurial > pub > bltoolkit

comparison Source/Common/Convert.tt @ 0:f990fcb411a9

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Копия текущей версии из github
author cin
date Thu, 27 Mar 2014 21:46:09 +0400
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:f990fcb411a9
1 <#@ template language="C#v3.5" debug="True" #>
2 <#@ output extension="generated.cs" #>
3 <#@ assembly name="System.Core" #>
4 <#@ import namespace="System.Collections.Generic" #>
5 <#@ import namespace="System.Linq" #>
6 //---------------------------------------------------------------------------------------------------
7 // <auto-generated>
8 // This code was generated by BLToolkit template for T4.
9 // Changes to this file may cause incorrect behavior and will be lost if the code is regenerated.
10 // </auto-generated>
11 //---------------------------------------------------------------------------------------------------
12 using System;
13 using System.Data.Linq;
14 using System.Data.SqlTypes;
15 using System.Globalization;
16 using System.IO;
17 using System.Xml;
18 #if !SILVERLIGHT
19 using System.Xml.Linq;
20 #endif
21
22 namespace BLToolkit.Common
23 {
24 using Properties;
25
26 public partial class Convert
27 {
28 <#
29 GenerationEnvironment.Remove(GenerationEnvironment.Length - 2, 2);
30
31 _types =
32 Set(_ => { _.Group = "Simple"; _.Method = "To" + _.Name; }, new[]
33 {
34 new ToType { Name = "Boolean", NullValue = "Configuration.NullableValues.Boolean", Froms = { { "Char", null } } },
35 new ToType { Name = "Byte", NullValue = "Configuration.NullableValues.Byte" },
36 new ToType { Name = "Char", NullValue = "Configuration.NullableValues.Char" },
37 new ToType { Name = "DateTime", NullValue = "Configuration.NullableValues.DateTime" },
38 new ToType { Name = "DateTimeOffset", NullValue = "DateTimeOffset.MinValue" },
39 new ToType { Name = "Decimal", NullValue = "Configuration.NullableValues.Decimal", Froms = { { "Byte[]", null }, { "Binary", null } } },
40 new ToType { Name = "Double", NullValue = "Configuration.NullableValues.Double" },
41 new ToType { Name = "Guid", NullValue = "Configuration.NullableValues.Guid" },
42 new ToType { Name = "Int16", NullValue = "Configuration.NullableValues.Int16" },
43 new ToType { Name = "Int32", NullValue = "Configuration.NullableValues.Int32" },
44 new ToType { Name = "Int64", NullValue = "Configuration.NullableValues.Int64" },
45 new ToType { Name = "Single", NullValue = "Configuration.NullableValues.Single" },
46 new ToType { Name = "String", NullValue = "Configuration.NullableValues.String", FromObjectReturn = "return p.ToString();" },
47 new ToType { Name = "TimeSpan", NullValue = "Configuration.NullableValues.TimeSpan" },
48 }.Concat(Set(_ => _.NonCompliant = true, new[]
49 {
50 new ToType { Name = "SByte", NullValue = "Configuration.NullableValues.SByte" },
51 new ToType { Name = "UInt16", NullValue = "Configuration.NullableValues.UInt16" },
52 new ToType { Name = "UInt32", NullValue = "Configuration.NullableValues.UInt32" },
53 new ToType { Name = "UInt64", NullValue = "Configuration.NullableValues.UInt64" },
54 })))
55 .Concat(Set(_ => { _.Group = "Nullable"; _.Method = "ToNullable" + _.Name; _.Name += "?"; }, new[]
56 {
57 new ToType { Name = "Boolean" },
58 new ToType { Name = "Byte" },
59 new ToType { Name = "Char" },
60 new ToType { Name = "DateTime" },
61 new ToType { Name = "DateTimeOffset" },
62 new ToType { Name = "Decimal" },
63 new ToType { Name = "Double" },
64 new ToType { Name = "Guid" },
65 new ToType { Name = "Int16" },
66 new ToType { Name = "Int32" },
67 new ToType { Name = "Int64" },
68 new ToType { Name = "Single" },
69 new ToType { Name = "TimeSpan" },
70 }.Concat(Set(_ => _.NonCompliant = true, new[]
71 {
72 new ToType { Name = "SByte" },
73 new ToType { Name = "UInt16" },
74 new ToType { Name = "UInt32" },
75 new ToType { Name = "UInt64" },
76 }))))
77 .Concat(Set(_ => { _.Group = "Sql"; _.Method = "To" + _.Name; _.NonSilverlightable = true; _.NullValue = _.Name + ".Null"; }, new[]
78 {
79 new ToType { Name = "SqlString" },
80 new ToType { Name = "SqlByte" },
81 new ToType { Name = "SqlInt16" },
82 new ToType { Name = "SqlInt32" },
83 new ToType { Name = "SqlInt64" },
84 new ToType { Name = "SqlSingle" },
85 new ToType { Name = "SqlDouble" },
86 new ToType { Name = "SqlBoolean" },
87 new ToType { Name = "SqlDecimal" },
88 new ToType { Name = "SqlMoney" },
89 new ToType { Name = "SqlDateTime" },
90 new ToType { Name = "SqlGuid" },
91 new ToType { Name = "SqlBinary" },
92 new ToType { Name = "SqlBytes" },
93 new ToType { Name = "SqlChars" },
94 new ToType { Name = "SqlXml" },
95 }))
96 .Concat(Set(_ => { _.Group = "Other"; }, new[]
97 {
98 new ToType { Name = "Type", Method = "ToType", NonSLMethods = { "Guid", "Guid?", "Binary", "Byte[]" } },
99 new ToType { Name = "Stream", Method = "ToStream", NullValue = "Stream.Null" },
100 new ToType { Name = "Byte[]", Method = "ToByteArray", NonSLMethods = { "DateTime", "DateTime?", "DateTimeOffset", "DateTimeOffset?" }, Froms = { { "Decimal", null }, { "Stream", null }, { "Char[]", null } } },
101 new ToType { Name = "Char[]", Method = "ToCharArray", },
102 new ToType { Name = "Binary", Method = "ToLinqBinary", },
103 new ToType { Name = "XmlReader", Method = "ToXmlReader", NonSilverlightable = true },
104 new ToType { Name = "XmlDocument", Method = "ToXmlDocument", NonSilverlightable = true },
105 new ToType { Name = "XElement", Method = "ToXElement", NonSilverlightable = true },
106 }))
107 .ToDictionary(_ => _.Name);
108
109
110 // To Boolean
111 //
112 ConvertFrom("String", "p == null? {2} : p.Length == 1 ? ToBoolean(p[0]) : Boolean.Parse(p)", "Boolean", "Boolean?", "SqlBoolean");
113 ConvertFrom("Byte[]", "p == null || p.Length == 0 ? {2} : BitConverter.ToBoolean(p, 0)", "Boolean", "Boolean?", "SqlBoolean");
114 ConvertFrom("Binary", "p == null || p.Length == 0 ? {2} : BitConverter.ToBoolean(p.ToArray(), 0)", "Boolean", "Boolean?", "SqlBoolean");
115
116 ConvertTo ("Boolean", "p.HasValue && p.Value", "Boolean?");
117 ConvertToNull("Boolean", "p != 0", "p.HasValue && p.Value != 0", "SByte", "Int16", "Int32", "Int64", "Byte", "UInt16", "UInt32", "UInt64", "Single", "Double", "Decimal");
118 ConvertTo ("Boolean", "p.HasValue && ToBoolean(p.Value)", "Char?");
119 ConvertTo ("Boolean", "!p.IsNull && p.Value", "SqlBoolean");
120 ConvertTo ("Boolean", "!p.IsNull && ToBoolean(p.Value)", Sql("String", "Byte", "Int16", "Int32", "Int64", "Single", "Double", "Decimal", "Money"));
121
122 ConvertFrom("Boolean", "p", "Boolean?", "SqlBoolean");
123 ConvertFrom("Char", "ToBoolean(p)", "Boolean?", "SqlBoolean");
124 ConvertFrom("Char?", "p.HasValue && ToBoolean(p.Value)", "Boolean?", "SqlBoolean");
125
126 // To Boolean?
127 //
128 ConvertToNull("Boolean?", "p != 0", "p.HasValue ? p.Value != 0 : {2}", "SByte", "Int16", "Int32", "Int64", "Byte", "UInt16", "UInt32", "UInt64", "Single", "Double", "Decimal");
129 ConvertTo ("Boolean?", "p.IsNull ? {2} : p.Value", "SqlBoolean");
130 ConvertTo ("Boolean?", "p.IsNull ? {2} : ToBoolean(p.Value)", Sql("String", "Byte", "Int16", "Int32", "Int64", "Single", "Double", "Decimal", "Money"));
131
132 // SqlBoolean
133 //
134 ConvertTo ("SqlBoolean", "p.HasValue ? p.Value : {2}", "Boolean?");
135 ConvertToNull("SqlBoolean", "p != 0", "p.HasValue ? p.Value != 0 : {2}", "SByte", "Int16", "Int32", "Int64", "Byte", "UInt16", "UInt32", "UInt64", "Single", "Double", "Decimal");
136 ConvertTo ("SqlBoolean", "p.IsNull ? {2} : ToBoolean(p.Value)", Sql("String", "Byte", "Int16", "Int32", "Int64", "Single", "Double", "Decimal", "Money"));
137
138 // To Byte
139 //
140 ConvertNumber("Byte",
141 new string[] { "Byte" },
142 new string[] { "SByte", "Int16", "Int32", "Int64", "UInt16", "UInt32", "UInt64", "Single", "Double", "Decimal", "Char" },
143 new string[] { "Byte" },
144 new string[] { "String", "Int16", "Int32", "Int64", "Single", "Double", "Decimal", "Money", "Boolean" });
145
146 ConvertFrom("Byte[]", "p == null || p.Length == 0 ? {2} : p[0]", "Byte", "Byte?", "SqlByte");
147 ConvertFrom("Binary", "p == null || p.Length == 0 ? {2} : p.ToArray()[0]", "Byte", "Byte?", "SqlByte");
148
149 // To Char
150 //
151 ConvertNumber("Char",
152 new string[] { "Char" },
153 new string[] { "SByte", "Int16", "Int32", "Int64", "Byte", "UInt16", "UInt32", "UInt64", "Single", "Double", "Decimal" },
154 new string[] { },
155 new string[] { "String", "Byte", "Int16", "Int32", "Int64", "Single", "Double", "Decimal", "Money", "Boolean" });
156
157 ConvertFrom("String", "string.IsNullOrEmpty(p)? ({0})0 : p[0]", "Char", "Char?");
158
159 // To DateTime
160 //
161 ConvertTo(new[] { "DateTime", "SqlDateTime" }, "p.HasValue ? p.Value : {2}", "DateTime?");
162 ConvertTo(new[] { "DateTime?", "SqlDateTime" }, "p", "DateTime");
163 ConvertTo(new[] { "DateTime", "DateTime?" }, "p.IsNull ? {2} : p.Value", "SqlDateTime");
164
165 ConvertFrom("String", "p == null ? {2} : {3}.Parse(p, null, DateTimeStyles.NoCurrentDateDefault)", "DateTime", "DateTime?", "SqlDateTime");
166 ConvertFrom("TimeSpan", "{3}.MinValue + p", "DateTime", "DateTime?", "SqlDateTime");
167 ConvertFrom("Int64", "{3}.MinValue + TimeSpan.FromTicks(p)", "DateTime", "DateTime?", "SqlDateTime");
168 ConvertFrom("Double", "{3}.MinValue + TimeSpan.FromDays (p)", "DateTime", "DateTime?", "SqlDateTime");
169 ConvertFrom("DateTimeOffset", "p.LocalDateTime", "DateTime", "DateTime?", "SqlDateTime");
170 ConvertFrom("DateTimeOffset?", "p.HasValue ? p.Value.LocalDateTime : {2}", "DateTime", "DateTime?", "SqlDateTime");
171 ConvertFrom("TimeSpan?", "p.HasValue ? {3}.MinValue + p.Value : {2}", "DateTime", "DateTime?", "SqlDateTime");
172 ConvertFrom("Int64?", "p.HasValue ? {3}.MinValue + TimeSpan.FromTicks(p.Value): {2}", "DateTime", "DateTime?", "SqlDateTime");
173 ConvertFrom("Double?", "p.HasValue ? {3}.MinValue + TimeSpan.FromDays (p.Value): {2}", "DateTime", "DateTime?", "SqlDateTime");
174 ConvertFrom("SqlDateTime", "p.IsNull ? {2} : p.Value", "DateTime", "DateTime?", "SqlDateTime");
175 ConvertFrom("SqlString", "p.IsNull ? {2} : To{3}(p.Value)", "DateTime", "DateTime?", "SqlDateTime");
176 ConvertFrom("SqlInt64", "p.IsNull ? {2} : {3}.MinValue + TimeSpan.FromTicks(p.Value)", "DateTime", "DateTime?", "SqlDateTime");
177 ConvertFrom("SqlDouble", "p.IsNull ? {2} : {3}.MinValue + TimeSpan.FromDays (p.Value)", "DateTime", "DateTime?", "SqlDateTime");
178 ConvertFrom("Byte[]", "p == null || p.Length == 0 ? {2} : {3}.FromBinary(ToInt64(p))", "DateTime", "DateTime?", "SqlDateTime");
179 ConvertFrom("Binary", "p == null || p.Length == 0 ? {2} : {3}.FromBinary(ToInt64(p.ToArray()))", "DateTime", "DateTime?", "SqlDateTime");
180
181 // To DateTimeOffset
182 //
183 ConvertTo("DateTimeOffset", "p.HasValue ? p.Value : {2}", "DateTimeOffset?");
184 ConvertTo("DateTimeOffset?", "p", "DateTimeOffset");
185
186 ConvertFrom("TimeSpan", "{3}.MinValue + p", "DateTimeOffset", "DateTimeOffset?");
187 ConvertFrom("Int64", "{3}.MinValue + TimeSpan.FromTicks(p)", "DateTimeOffset", "DateTimeOffset?");
188 ConvertFrom("Double", "{3}.MinValue + TimeSpan.FromDays (p)", "DateTimeOffset", "DateTimeOffset?");
189 ConvertFrom("DateTime", "p", "DateTimeOffset", "DateTimeOffset?");
190 ConvertFrom("DateTime?", "p.HasValue ? p.Value : {2}", "DateTimeOffset", "DateTimeOffset?");
191 ConvertFrom("TimeSpan?", "p.HasValue ? {3}.MinValue + p.Value : {2}", "DateTimeOffset", "DateTimeOffset?");
192 ConvertFrom("Int64?", "p.HasValue ? {3}.MinValue + TimeSpan.FromTicks(p.Value): {2}", "DateTimeOffset", "DateTimeOffset?");
193 ConvertFrom("Double?", "p.HasValue ? {3}.MinValue + TimeSpan.FromDays (p.Value): {2}", "DateTimeOffset", "DateTimeOffset?");
194 ConvertFrom("SqlDateTime", "p.IsNull ? {2} : p.Value", "DateTimeOffset", "DateTimeOffset?");
195 ConvertFrom("SqlString", "p.IsNull ? {2} : ToDateTimeOffset(p.Value)", "DateTimeOffset", "DateTimeOffset?");
196 ConvertFrom("SqlInt64", "p.IsNull ? {2} : {3}.MinValue + TimeSpan.FromTicks(p.Value)", "DateTimeOffset", "DateTimeOffset?");
197 ConvertFrom("SqlDouble", "p.IsNull ? {2} : {3}.MinValue + TimeSpan.FromDays (p.Value)", "DateTimeOffset", "DateTimeOffset?");
198 ConvertFrom("Byte[]", "p == null || p.Length == 0 ? {2} : new {0}(ToDateTime(p))", "DateTimeOffset", "DateTimeOffset?");
199 ConvertFrom("Binary", "p == null || p.Length == 0 ? {2} : new {0}(ToDateTime(p.ToArray()))", "DateTimeOffset", "DateTimeOffset?");
200
201 // To Decimal
202 //
203 ConvertNumber("Decimal",
204 new string[] { "SByte", "Int16", "Int32", "Int64", "Byte", "UInt16", "UInt32", "Char", "UInt64", "Decimal" },
205 new string[] { "Single", "Double" },
206 new string[] { "Byte", "Int16", "Int32", "Int64", "Decimal", "Money" },
207 new string[] { "String", "Single", "Double", "Boolean" });
208
209 ConvertNumber("Money",
210 new string[] { "SByte", "Int16", "Int32", "Int64", "Byte", "UInt16", "UInt32", "Char", "UInt64", "Decimal" },
211 new string[] { "Single", "Double" },
212 new string[] { "Byte", "Int16", "Int32", "Int64", "Decimal", "Money" },
213 new string[] { "String", "Single", "Double", "Boolean" });
214
215 ConvertTo(new[] { "Decimal?", "SqlDecimal", "SqlMoney" }, "p == null || p.Length == 0 ? {2} : ToDecimal(p)", "Byte[]", "Binary");
216
217 // To Double
218 //
219 ConvertTo(new[] { "Double", "Double?", "SqlDouble" }, "(p - {1}.MinValue).TotalDays", "DateTime", "DateTimeOffset");
220 ConvertTo("SqlDouble", "p.IsNull? {0}.Null: ToDouble(p.Value)", "SqlDateTime");
221
222 ConvertNumber("Double",
223 new string[] { "SByte", "Int16", "Int32", "Int64", "Byte", "UInt16", "UInt32", "Char", "UInt64", "Single", "Double" },
224 new string[] { "Decimal" },
225 new string[] { "Byte", "Int16", "Int32", "Int64", "Single", "Double" },
226 new string[] { "String", "Decimal", "Money", "Boolean", "DateTime" });
227
228 ConvertTo(new[] { "Double", "Double?", "SqlDouble" }, "p.HasValue ? (p.Value - {4}.MinValue).TotalDays : {2}", "DateTime?", "DateTimeOffset?");
229
230 ConvertFrom("TimeSpan", "p.TotalDays", "Double", "Double?", "SqlDouble");
231 ConvertFrom("TimeSpan?", "p.HasValue ? p.Value.TotalDays : {2}", "Double", "Double?", "SqlDouble");
232
233 // To Guid
234 //
235 ConvertTo(new[] { "Guid", "SqlGuid" }, "p.HasValue ? p.Value : {2}", "Guid?");
236 ConvertTo(new[] { "Guid?", "SqlGuid" }, "p", "Guid");
237 ConvertTo(new[] { "Guid", "Guid?" }, "p.IsNull ? {2} : p.Value", "SqlGuid");
238
239 ConvertTo(new[] { "Guid", "Guid?", "SqlGuid" }, "p == null ? {2} : new Guid(p)", "String", "Byte[]");
240
241 ConvertFrom("SqlGuid", "p.IsNull ? {2} : p.Value", "Guid", "Guid?", "SqlGuid");
242 ConvertFrom("SqlString", "p.IsNull ? {2} : new Guid(p.Value)", "Guid", "Guid?", "SqlGuid");
243 ConvertFrom("SqlBinary", "p.IsNull ? {2} : p.ToSqlGuid().Value", "Guid", "Guid?", "SqlGuid");
244 ConvertFrom("Binary", "p == null ? {2} : new Guid(p.ToArray())", "Guid", "Guid?", "SqlGuid");
245 ConvertFrom("Type", "p == null ? {2} : p.GUID", "Guid", "Guid?", "SqlGuid");
246
247 // To Int16
248 //
249 ConvertNumber("Int16",
250 new string[] { "SByte", "Int16", "Byte" },
251 new string[] { "Int32", "Int64", "UInt16", "UInt32", "UInt64", "Single", "Double", "Decimal", "Char" },
252 new string[] { "Byte", "Int16" },
253 new string[] { "String", "Int32", "Int64", "Single", "Double", "Decimal", "Money", "Boolean" });
254
255 // To Int32
256 //
257 ConvertNumber("Int32",
258 new string[] { "SByte", "Int16", "Int32", "Byte", "UInt16", "Char" },
259 new string[] { "Int64", "UInt32", "UInt64", "Single", "Double", "Decimal" },
260 new string[] { "Byte", "Int16", "Int32" },
261 new string[] { "String", "Int64", "Single", "Double", "Decimal", "Money", "Boolean" });
262
263 // To Int64
264 //
265 ConvertTo("Int64", "(p - DateTime.MinValue).Ticks", "DateTime", "DateTimeOffset");
266 ConvertTo("Int64?", "(p - DateTime.MinValue).Ticks", "DateTime", "DateTimeOffset");
267 ConvertTo("SqlInt64", "(p - DateTime.MinValue).Ticks", "DateTime", "DateTimeOffset");
268 ConvertTo("SqlInt64", "p.IsNull? {0}.Null: ToInt64(p.Value)", "SqlDateTime");
269
270 ConvertNumber("Int64",
271 new string[] { "SByte", "Int16", "Int32", "Int64", "Byte", "UInt16", "UInt32", "Char" },
272 new string[] { "UInt64", "Single", "Double", "Decimal" },
273 new string[] { "Byte", "Int16", "Int32", "Int64" },
274 new string[] { "String", "Single", "Double", "Decimal", "Money", "Boolean", "DateTime" });
275
276 ConvertTo("Int64", " p.HasValue ? (p.Value - DateTime.MinValue).Ticks : 0", "DateTime?", "DateTimeOffset?");
277 ConvertTo("Int64?", "p.HasValue ? (p.Value - DateTime.MinValue).Ticks : 0", "DateTime?", "DateTimeOffset?");
278 ConvertTo("SqlInt64", "p.HasValue ? (p.Value - DateTime.MinValue).Ticks : 0", "DateTime?", "DateTimeOffset?");
279
280 ConvertFrom("TimeSpan", "p.Ticks", "Int64", "Int64?", "SqlInt64");
281 ConvertFrom("TimeSpan?", "p.HasValue ? p.Value.Ticks : 0", "Int64", "Int64?", "SqlInt64");
282
283 // To SByte
284 //
285 ConvertNumber("SByte",
286 new string[] { "SByte" },
287 new string[] { "Int16", "Int32", "Int64", "Byte", "UInt16", "UInt32", "UInt64", "Single", "Double", "Decimal", "Char" },
288 new string[] { },
289 new string[] { "String", "Byte", "Int16", "Int32", "Int64", "Single", "Double", "Decimal", "Money", "Boolean" });
290
291 ConvertFrom("Byte[]", "p == null || p.Length == 0 ? {2} : checked(({0})p[0])", "SByte", "SByte?");
292 ConvertFrom("Binary", "p == null || p.Length == 0 ? {2} : checked(({0})p.ToArray()[0])", "SByte", "SByte?");
293
294 // To Single
295 //
296 ConvertNumber("Single",
297 new string[] { "SByte", "Int16", "Int32", "Int64", "Byte", "UInt16", "UInt32", "Char", "UInt64", "Single" },
298 new string[] { "Double", "Decimal" },
299 new string[] { "Byte", "Int16", "Int32", "Int64", "Single" },
300 new string[] { "String", "Double", "Decimal", "Money", "Boolean" });
301
302 // To String
303 //
304 ConvertToNull(new[] { "String", "SqlString" },
305 "p.To{3}()",
306 "p.HasValue ? p.Value.To{3}() : {2}",
307 "SByte", "Int16", "Int32", "Int64", "Byte", "UInt16", "UInt32", "UInt64",
308 "Single", "Double", "Boolean", "Decimal", "Char", "TimeSpan", "DateTime", "DateTimeOffset", "Guid");
309
310 ConvertTo(new[] { "String", "SqlString" }, "p == null ? {2} : p.FullName", "Type");
311 ConvertTo(new[] { "String", "SqlString" }, "p == null ? {2} : System.Text.Encoding.UTF8.GetString(p, 0, p.Length)", "Byte[]");
312 ConvertTo(new[] { "String", "SqlString" }, "To{0}(p.ToArray())", "Binary");
313
314 ConvertTo(new[] { "String", "SqlString" }, "p.To{0}()",
315 Sql("String", "Byte", "Int16", "Int32", "Int64", "Single", "Double", "Decimal", "Money", "Boolean", "Guid"));
316
317 ConvertTo( "String", "p.IsNull ? {2} : p.ToSqlString().Value", "SqlChars");
318 ConvertTo(new[] { "String", "SqlString" }, "p.IsNull ? {2} : p.Value", "SqlXml");
319 ConvertTo(new[] { "String", "SqlString" }, "p == null ? {2} : p.InnerXml", "XmlDocument");
320 ConvertTo(new[] { "String", "SqlString" }, "p == null ? {2} : p.ToString()", "XElement");
321
322 ConvertTo("SqlString", "p ?? {2}", "String");
323 ConvertTo("SqlString", "p.To{0}()", "SqlChars");
324
325 // To TimeSpan
326 //
327 ConvertTo("TimeSpan", "p.HasValue ? p.Value : {2}", "TimeSpan?");
328 ConvertTo("TimeSpan?", "p", "TimeSpan");
329
330 ConvertFrom("DateTime", "p - DateTime.MinValue", "TimeSpan", "TimeSpan?");
331 ConvertFrom("DateTimeOffset", "p - DateTimeOffset.MinValue", "TimeSpan", "TimeSpan?");
332 ConvertFrom("Int64", "TimeSpan.FromTicks(p)", "TimeSpan", "TimeSpan?");
333 ConvertFrom("Double", "TimeSpan.FromDays (p)", "TimeSpan", "TimeSpan?");
334 ConvertFrom("DateTime?", "p.HasValue ? p.Value - DateTime.MinValue : {2}", "TimeSpan", "TimeSpan?");
335 ConvertFrom("DateTimeOffset?", "p.HasValue ? p.Value - DateTimeOffset.MinValue : {2}", "TimeSpan", "TimeSpan?");
336 ConvertFrom("Int64?", "p.HasValue ? {3}.FromTicks(p.Value) : {2}", "TimeSpan", "TimeSpan?");
337 ConvertFrom("Double?", "p.HasValue ? {3}.FromDays (p.Value) : {2}", "TimeSpan", "TimeSpan?");
338 ConvertFrom("SqlString", "p.IsNull ? {2} : {3}.Parse(p.Value)", "TimeSpan", "TimeSpan?");
339 ConvertFrom("SqlDateTime", "p.IsNull ? {2} : p.Value - DateTime.MinValue", "TimeSpan", "TimeSpan?");
340 ConvertFrom("SqlInt64", "p.IsNull ? {2} : {3}.FromTicks(p.Value)", "TimeSpan", "TimeSpan?");
341 ConvertFrom("SqlDouble", "p.IsNull ? {2} : {3}.FromDays(p.Value)", "TimeSpan", "TimeSpan?");
342 ConvertFrom("Byte[]", "p == null || p.Length == 0? {2} : {3}.FromTicks(ToInt64(p))", "TimeSpan", "TimeSpan?");
343 ConvertFrom("Binary", "p == null || p.Length == 0? {2} : {3}.FromTicks(ToInt64(p.ToArray()))", "TimeSpan", "TimeSpan?");
344
345 // To UInt16
346 //
347 ConvertNumber("UInt16",
348 new string[] { "UInt16", "Byte" },
349 new string[] { "SByte", "Int16", "Int32", "Int64", "UInt32", "UInt64", "Single", "Double", "Decimal", "Char" },
350 new string[] { "Byte" },
351 new string[] { "String", "Int16", "Int32", "Int64", "Single", "Double", "Decimal", "Money", "Boolean" });
352
353 // To UInt32
354 //
355 ConvertNumber("UInt32",
356 new string[] { "Byte", "UInt16", "UInt32" },
357 new string[] { "SByte", "Int16", "Int32", "Int64", "UInt64", "Single", "Double", "Decimal", "Char" },
358 new string[] { "Byte" },
359 new string[] { "String", "Int16", "Int32", "Int64", "Single", "Double", "Decimal", "Money", "Boolean" });
360
361 // To UInt64
362 //
363 ConvertNumber("UInt64",
364 new string[] { "Byte", "UInt16", "UInt32", "UInt64" },
365 new string[] { "SByte", "Int16", "Int32", "Int64", "Single", "Double", "Decimal", "Char" },
366 new string[] { "Byte" },
367 new string[] { "String", "Int16", "Int32", "Int64", "Single", "Double", "Decimal", "Money", "Boolean" });
368
369 // To SqlBinary
370 //
371 ConvertTo("SqlBinary", "p", "Byte[]");
372 ConvertTo("SqlBinary", "p == null ? {2} : p.ToArray()", "Binary");
373 ConvertTo("SqlBinary", "p == Guid.Empty? {2} : new SqlGuid(p).To{0}()", "Guid");
374 ConvertTo("SqlBinary", "p.HasValue ? new SqlGuid(p.Value).ToSqlBinary(): {2}", "Guid?");
375 ConvertTo("SqlBinary", "p.To{0}()", "SqlBytes" , "SqlGuid");
376
377 // To SqlXml
378 //
379 ConvertTo("SqlXml", "p == null ? {2} : new {0}(new XmlTextReader(new StringReader(p)))", "String");
380 ConvertTo("SqlXml", "p == null ? {2} : new {0}(p)", "Stream", "XmlReader");
381 ConvertTo("SqlXml", "p == null ? {2} : new {0}(new XmlTextReader(new StringReader(p.InnerXml)))", "XmlDocument");
382 ConvertTo("SqlXml", "p == null ? {2} : new {0}(new XmlTextReader(new StringReader(p.ToString())))", "XElement");
383 ConvertTo("SqlXml", "p == null ? {2} : new {0}(new XmlTextReader(new StringReader(new string(p))))", "Char[]");
384 ConvertTo("SqlXml", "p == null ? {2} : new {0}(new MemoryStream(p))", "Byte[]");
385 ConvertTo("SqlXml", "p == null ? {2} : new {0}(new MemoryStream(p.ToArray()))", "Binary");
386 ConvertTo("SqlXml", "p.IsNull ? {2} : new {0}(new XmlTextReader(new StringReader(p.Value)))", "SqlString");
387 ConvertTo("SqlXml", "p.IsNull ? {2} : new {0}(new XmlTextReader(new StringReader(p.ToSqlString().Value)))", "SqlChars");
388 ConvertTo("SqlXml", "p.IsNull ? {2} : new {0}(new MemoryStream(p.Value))", "SqlBinary");
389 ConvertTo("SqlXml", "p.IsNull ? {2} : new {0}(p.Stream)", "SqlBytes");
390
391 // To Stream
392 //
393 ConvertTo("Stream", "p == Guid.Empty ? {2} : new MemoryStream(p.ToByteArray())", "Guid");
394 ConvertTo("Stream", "p == null ? {2} : new MemoryStream(p)", "Byte[]");
395 ConvertTo("Stream", "p == null ? {2} : new MemoryStream(p.ToArray())", "Binary");
396 ConvertTo("Stream", "p.HasValue ? new MemoryStream(p.Value.ToByteArray()) : {2}", "Guid?");
397 ConvertTo("Stream", "p.IsNull ? {2} : p.Stream", "SqlBytes");
398 ConvertTo("Stream", "p.IsNull ? {2} : new MemoryStream(p.Value)", "SqlBinary");
399 ConvertTo("Stream", "p.IsNull ? {2} : new MemoryStream(p.Value.ToByteArray())", "SqlGuid");
400
401 // To Type
402 //
403 ConvertTo("Type", "p == null ? {2} : Type.GetType(p)", "String");
404 ConvertTo("Type", "p == null ? {2} : Type.GetType(new string(p))", "Char[]");
405 ConvertTo("Type", "p == null ? {2} : Type.GetTypeFromCLSID(ToGuid(p))", "Byte[]");
406 ConvertTo("Type", "p == null ? {2} : Type.GetTypeFromCLSID(ToGuid(p.ToArray()))", "Binary");
407 ConvertTo("Type", "p == Guid.Empty ? {2} : Type.GetTypeFromCLSID(p)", "Guid");
408 ConvertTo("Type", "p.HasValue ? Type.GetTypeFromCLSID(p.Value) : {2}", "Guid?");
409 ConvertTo("Type", "p.IsNull ? {2} : Type.GetType(p.Value)", "SqlString");
410 ConvertTo("Type", "p.IsNull ? {2} : Type.GetType(new string(p.Value))", "SqlChars");
411 ConvertTo("Type", "p.IsNull ? {2} : Type.GetTypeFromCLSID(p.Value)", "SqlGuid");
412
413 // To Byte[]
414 //
415 ConvertTo("Byte[]", "p == null ? {2} : System.Text.Encoding.UTF8.GetBytes(p)", "String");
416 ConvertTo("Byte[]", "new[] {{ p }}", "Byte");
417 ConvertTo("Byte[]", "new[] {{ checked((Byte)p) }}", "SByte");
418 ConvertTo("Byte[]", "ToByteArray(p.ToBinary())", "DateTime");
419 ConvertTo("Byte[]", "ToByteArray(p.LocalDateTime.ToBinary())", "DateTimeOffset");
420 ConvertTo("Byte[]", "p == null ? {2} : p.ToArray()", "Binary");
421 ConvertTo("Byte[]", "ToByteArray(p.Ticks)", "TimeSpan");
422 ConvertTo("Byte[]", "p == Guid.Empty ? {2} : p.ToByteArray()", "Guid");
423
424 ConvertTo("Byte[]", "BitConverter.GetBytes(p)",
425 "Int16", "Int32", "Int64", "UInt16", "UInt32", "UInt64", "Single", "Double", "Boolean", "Char");
426 ConvertTo("Byte[]", "p.HasValue ? ToByteArray(p.Value) : {2}",
427 "SByte?", "Int16?", "Int32?", "Int64?", "Byte?", "UInt16?", "UInt32?", "UInt64?", "Single?", "Double?", "Boolean?", "Decimal?", "Char?", "DateTime?", "DateTimeOffset?", "TimeSpan?", "Guid?");
428
429 ConvertTo("Byte[]", "p.IsNull ? {2} : p.Value", "SqlBinary", "SqlBytes");
430 ConvertTo("Byte[]", "p.IsNull ? {2} : p.ToByteArray()", "SqlGuid");
431 ConvertTo("Byte[]", "p.IsNull ? {2} : ToByteArray(p.Value)",
432 "SqlString", "SqlByte", "SqlInt16", "SqlInt32", "SqlInt64", "SqlSingle", "SqlDouble", "SqlDecimal", "SqlMoney", "SqlBoolean");
433
434 // To SqlBytes
435 //
436 ConvertTo("SqlBytes", "p == null ? {2} : new {0}(p)", "Byte[]", "Stream");
437 ConvertTo("SqlBytes", "p == null ? {2} : new {0}(p.ToArray())", "Binary");
438 ConvertTo("SqlBytes", "p == Guid.Empty ? {2}: new {0}(p.ToByteArray())", "Guid");
439 ConvertTo("SqlBytes", "p.HasValue ? new {0}(p.Value.ToByteArray()) : {2}", "Guid?");
440 ConvertTo("SqlBytes", "p.IsNull ? {2} : new {0}(p)", "SqlBinary");
441 ConvertTo("SqlBytes", "p.IsNull ? {2} : new {0}(p.ToByteArray())", "SqlGuid");
442
443 ConvertTo("SqlBytes", "p == null ? {2} : new {0}(ToByteArray(p))", "String");
444
445 ConvertTo("SqlBytes", "new {0}(ToByteArray(p))",
446 "Byte", "SByte", "DateTime", "DateTimeOffset", "TimeSpan", "Int16", "Int32", "Int64", "UInt16", "UInt32", "UInt64", "Single", "Double", "Boolean", "Char");
447 ConvertTo("SqlBytes", "p.HasValue ? ToSqlBytes(p.Value) : {2}",
448 "SByte?", "Int16?", "Int32?", "Int64?", "Byte?", "UInt16?", "UInt32?", "UInt64?", "Single?", "Double?", "Boolean?", "Decimal?", "Char?", "DateTime?", "DateTimeOffset?", "TimeSpan?", "Guid?");
449
450 ConvertTo("Byte[]", "p.IsNull ? {2} : ToSqlBytes(p.Value)",
451 "SqlString", "SqlByte", "SqlInt16", "SqlInt32", "SqlInt64", "SqlSingle", "SqlDouble", "SqlDecimal", "SqlMoney", "SqlBoolean");
452
453
454
455 string[] numberTypes1 = new string[] { "Int16", "Int32", "Int64", "UInt16", "UInt32", "UInt64", "Char", "Single", "Double", "SqlByte", "SqlInt16", "SqlInt32", "SqlInt64", "SqlSingle", "SqlDouble", "SqlDecimal", "SqlMoney" };
456 string[] numberTypes2 = Add(numberTypes1, "SByte", "Byte");
457 string[] numberTypes1n = numberTypes1.Where(_ => !_.StartsWith("Sql")).Select(_ => _ + "?").ToArray();
458 string[] numberTypes2n = numberTypes2.Where(_ => !_.StartsWith("Sql")).Select(_ => _ + "?").ToArray();
459
460 // From String
461 //
462 ConvertFrom("String", "p == null? {2} : {3}.Parse(p)",
463 Add(Add(numberTypes2, numberTypes2n), "Decimal", "DateTimeOffset", "TimeSpan", "Decimal?", "DateTimeOffset?", "TimeSpan?"));
464
465 // From Boolean
466 //
467 ConvertFrom("Boolean", "p ? ({0})1 : ({0})0", Add(Add(numberTypes2, numberTypes2n), "Decimal", "Decimal?"));
468
469 // From Boolean?
470 //
471 ConvertFrom("Boolean?", "p.HasValue && p.Value ? ({0})1: ({0})0", Add(Add(numberTypes2, numberTypes2n), "Decimal", "Decimal?"));
472
473 // From Byte[]
474 //
475 ConvertFrom("Byte[]", "p == null || p.Length == 0 ? {2} : BitConverter.To{3}(p, 0)", Add(numberTypes1, numberTypes1n));
476
477 // From Binary
478 //
479 ConvertFrom("Binary", "p == null || p.Length == 0 ? {2} : BitConverter.To{3}(p.ToArray(), 0)", Add(numberTypes1, numberTypes1n));
480
481 Generate();
482 #>
483 }
484 }
485 <#+
486 class ToType
487 {
488 public string Group;
489 public string Name;
490 public string Method;
491 public bool NonCompliant;
492 public bool NonSilverlightable; // :)
493 public string NullValue;
494 public string FromObjectReturn;
495
496 public Dictionary<string,string> Froms = new Dictionary<string,string>();
497 public HashSet<string> NonSLMethods = new HashSet<string>();
498 }
499
500 Dictionary<string,ToType> _types;
501
502 void ConvertTo(string toType, string convertText, params string[] fromTypes)
503 {
504 foreach (string fromType in fromTypes)
505 {
506 if (toType == fromType)
507 continue;
508
509 if (!_types.ContainsKey(fromType))
510 throw new InvalidOperationException(fromType);
511
512 if (!_types[toType].Froms.ContainsKey(fromType))
513 _types[toType].Froms.Add(fromType, string.Format(
514 convertText,
515 toType,
516 fromType,
517 _types[toType].NullValue ?? "(" + toType + ")null",
518 toType. TrimEnd('?').Replace("Sql", "").Replace("Money", "Decimal"),
519 fromType.TrimEnd('?').Replace("Sql", "").Replace("Money", "Decimal")));
520 }
521 }
522
523 void ConvertTo(string[] toTypes, string convertText, params string[] fromTypes)
524 {
525 foreach (var t in toTypes)
526 ConvertTo(t, convertText, fromTypes);
527 }
528
529 void ConvertFrom(string fromType, string convertText, params string[] toTypes)
530 {
531 foreach (string toType in toTypes)
532 ConvertTo(toType, convertText, fromType);
533 }
534
535 void ConvertToNull(string toType, string convertText, string convertTextNull, params string[] fromTypes)
536 {
537 ConvertTo(toType, convertText, fromTypes);
538 ConvertTo(toType, convertTextNull, fromTypes.Select(_ => _ + "?").ToArray());
539 }
540
541 void ConvertToNull(string[] toTypes, string convertText, string convertTextNull, params string[] fromTypes)
542 {
543 foreach (var t in toTypes)
544 ConvertToNull(t, convertText, convertTextNull, fromTypes);
545 }
546
547 void ConvertNumber(string toType, string[] types1, string[] types2, string[] types3, string[] types4)
548 {
549 if (toType != "Money")
550 {
551 ConvertToNull(toType,
552 "p",
553 "p.HasValue ? p.Value : {2}",
554 types1);
555 ConvertToNull(toType,
556 "checked(({0})p)",
557 "p.HasValue ? checked(({0})p.Value) : {2}",
558 types2);
559 ConvertTo(toType, "p.IsNull ? {2} : p.Value", Sql(types3));
560 ConvertTo(toType, "p.IsNull ? {2} : To{0}(p.Value)", Sql(types4));
561
562 ConvertToNull(toType + "?",
563 "p",
564 "p.HasValue ? p.Value : {2}",
565 types1);
566 ConvertToNull(toType + "?",
567 "checked(({0})p)",
568 "p.HasValue ? checked(({0})p.Value) : {2}",
569 types2);
570 ConvertTo(toType + "?", "p.IsNull ? {2} : p.Value", Sql(types3));
571 ConvertTo(toType + "?", "p.IsNull ? {2} : To{3}(p.Value)", Sql(types4));
572 }
573
574 if (_types.ContainsKey("Sql" + toType))
575 {
576 ConvertToNull("Sql" + toType,
577 "p",
578 "p.HasValue ? p.Value : {2}",
579 types1);
580 ConvertToNull("Sql" + toType,
581 "checked(({3})p)",
582 "p.HasValue ? checked(({3})p.Value) : {2}",
583 types2);
584 ConvertTo("Sql" + toType, "p.To{0}()", Sql(types3));
585 ConvertTo("Sql" + toType, "p.To{0}()", Sql(types4));
586 }
587 }
588
589 string[] Sql(params string[] types)
590 {
591 return types.Select(_ => "Sql" + _).ToArray();
592 }
593
594 string[] Add(string[] str1, params string[] str2)
595 {
596 return str1.Concat(str2).ToArray();
597 }
598
599 IEnumerable<ToType> Set(Action<ToType> action, IEnumerable<ToType> types)
600 {
601 foreach (var t in types)
602 {
603 action(t);
604 yield return t;
605 }
606 }
607
608 string LenDiff(int max, string str)
609 {
610 var s = "";
611
612 while (max-- > str.Length)
613 s += " ";
614
615 return s;
616 }
617
618 Dictionary<string,int> _groupOrder = new Dictionary<string,int>
619 {
620 { "Simple", 1 },
621 { "Nullable", 2 },
622 { "Sql", 3 },
623 { "Other", 4 },
624 };
625
626 HashSet<string> _codedTypes = new HashSet<string>
627 {
628 "Boolean", "Char", "SByte", "Byte", "Int16", "UInt16", "Int32", "UInt32", "Int64", "UInt64", "Single", "Double", "Decimal", "DateTime", "String",
629 };
630
631 void Generate()
632 {
633 PushIndent("\t\t");
634
635 foreach (var gr in _types.Values.Select(_ => _.Group).Distinct())
636 {
637 WriteLine("");
638 WriteLine("#region {0} Types", gr);
639
640 foreach (var to in
641 from t in _types.Values
642 where t.Group == gr
643 orderby t.Name
644 select t)
645 {
646 WriteLine("");
647 WriteLine("#region {0}", to.Name);
648
649 var froms = from f in to.Froms.Keys select f;
650
651 if (to.NonSilverlightable)
652 {
653 ClearIndent();
654 WriteLine("");
655 WriteLine("#if !SILVERLIGHT");
656 PushIndent("\t\t");
657
658 froms =
659 from f in froms
660 orderby _groupOrder[_types[f].Group], _types[f].Name
661 select f;
662 }
663 else
664 {
665 froms =
666 from f in froms
667 orderby _types[f].NonSilverlightable, _groupOrder[_types[f].Group], _types[f].Name
668 select f;
669 }
670
671 var group = "";
672 var sl = false;
673 var len = froms.Concat(new[] { "" }).Select(_ => _.Length).Max();
674 var lcode = to.Froms.Values.Concat(new[] { "" }).Select(_ => (_ ?? "").Length).Max();
675
676 foreach (var f in froms)
677 {
678 var code = to.Froms[f];
679
680 if (code == null)
681 continue;
682
683 var fr = _types[f];
684
685 if (!to.NonSilverlightable && sl != fr.NonSilverlightable)
686 {
687 sl = fr.NonSilverlightable;
688
689 ClearIndent();
690 WriteLine("");
691 WriteLine("#if !SILVERLIGHT");
692 PushIndent("\t\t");
693 }
694
695 if (fr.Group != group)
696 {
697 group = fr.Group;
698
699 WriteLine("");
700 WriteLine("// {0} Types", group);
701 WriteLine("//");
702 }
703
704 if (to.NonSLMethods.Contains(fr.Name))
705 {
706 ClearIndent();
707 WriteLine("#if !SILVERLIGHT");
708 PushIndent("\t\t");
709 }
710
711 WriteLine("/// <summary>Converts the value from <c>{0}</c> to an equivalent <c>{1}</c> value.</summary>", fr.Name, to.Name);
712
713 if (to.NonCompliant || fr.NonCompliant)
714 WriteLine("[CLSCompliant(false)]");
715
716 WriteLine("public static {0} {1}({2}{3} p) {{ return {4};{5} }}",
717 to.Name, to.Method, fr.Name, LenDiff(len, fr.Name), code, LenDiff(lcode, code));
718
719 if (to.NonSLMethods.Contains(fr.Name))
720 {
721 ClearIndent();
722 WriteLine("#endif");
723 PushIndent("\t\t");
724 }
725 }
726
727 if (sl)
728 {
729 ClearIndent();
730 WriteLine("");
731 WriteLine("#endif");
732 PushIndent("\t\t");
733 }
734
735 // From Object
736 //
737 if (to.Froms.Count > 0)
738 {
739 WriteLine("");
740 WriteLine("// From Object");
741 WriteLine("//");
742
743 WriteLine("/// <summary>Converts the value from <c>Object</c> to an equivalent <c>{0}</c> value.</summary>", to.Name);
744
745 if (to.NonCompliant)
746 WriteLine("[CLSCompliant(false)]");
747
748 WriteLine("public static {0} {1}(object p)", to.Name, to.Method);
749 WriteLine("{");
750
751 PushIndent("\t");
752
753 var defType = false;
754
755 var tc =
756 from f in to.Froms.Keys
757 where _codedTypes.Contains(f)
758 select f;
759
760 if (tc.Any())
761 {
762 WriteLine("if (p == null) return {0};", to.NullValue ?? "null");
763 WriteLine("");
764
765 if (!_codedTypes.Contains(to.Name))
766 {
767 WriteLine("if (p is {0}) return ({0})p;", to.Name);
768 WriteLine("");
769 }
770
771 defType = true;
772
773 WriteLine("var type = p.GetType();");
774 WriteLine("");
775 WriteLine("// Primitive types");
776 WriteLine("//");
777 WriteLine("switch (Type.GetTypeCode(type))");
778 WriteLine("{");
779 PushIndent("\t");
780
781 len = new[] { to.Name, "DBNull" }.Concat(tc).Select(_ => _.Length).Max();
782
783 WriteLine("case TypeCode.DBNull{0} : return {1};", LenDiff(len, "DBNull"), to.NullValue ?? "null");
784
785 if (_codedTypes.Contains(to.Name))
786 WriteLine("case TypeCode.{0}{1} : return ({0})p;", to.Name, LenDiff(len, to.Name));
787
788 foreach (var t in tc)
789 {
790 if (to.NonSLMethods.Contains(t))
791 {
792 ClearIndent();
793 WriteLine("#if !SILVERLIGHT");
794 PushIndent("\t\t");
795 PushIndent("\t");
796 PushIndent("\t");
797 }
798
799 WriteLine("case TypeCode.{0}{1} : return {2}(({0}){1}p);", t, LenDiff(len, t), to.Method);
800
801 if (to.NonSLMethods.Contains(t))
802 {
803 ClearIndent();
804 WriteLine("#endif");
805 PushIndent("\t\t");
806 PushIndent("\t");
807 PushIndent("\t");
808 }
809 }
810
811 PopIndent();
812 WriteLine("}");
813 }
814 else
815 {
816 WriteLine("if (p == null || p is DBNull) return {0};", to.NullValue ?? "null");
817 WriteLine("");
818 WriteLine("if (p is {0}) return ({0})p;", to.Name);
819 }
820
821 tc =
822 from f in to.Froms.Keys
823 where !_codedTypes.Contains(f)
824 select f;
825
826 if (to.NonSilverlightable)
827 {
828 tc =
829 from f in tc
830 orderby _groupOrder[_types[f].Group], _types[f].Name
831 select f;
832 }
833 else
834 {
835 tc =
836 from f in tc
837 orderby _types[f].NonSilverlightable, _groupOrder[_types[f].Group], _types[f].Name
838 select f;
839 }
840
841 var openGroupBlock = false;
842
843 group = "";
844 sl = false;
845 len = new[] { "" }.Concat(tc).Select(_ => _.Length).Max();
846
847 foreach (var f in tc)
848 {
849 var fr = _types[f];
850
851 if (!to.NonSilverlightable && sl != fr.NonSilverlightable)
852 {
853 sl = fr.NonSilverlightable;
854
855 ClearIndent();
856 WriteLine("");
857 WriteLine("#if !SILVERLIGHT");
858 PushIndent("\t\t");
859 PushIndent("\t");
860 }
861
862 if (fr.Group != group)
863 {
864 group = fr.Group;
865
866 if (openGroupBlock)
867 {
868 openGroupBlock = false;
869 PopIndent();
870 WriteLine("}");
871 }
872
873 WriteLine("");
874 WriteLine("// {0} Types", group);
875 WriteLine("//");
876
877 if (group == "Nullable")
878 {
879 openGroupBlock = true;
880
881 if (!defType)
882 {
883 defType = true;
884 WriteLine("var type = p.GetType();");
885 WriteLine("");
886 }
887
888 WriteLine("if (type.IsGenericType)");
889 WriteLine("{");
890
891 PushIndent("\t");
892 }
893 else if (group == "Sql")
894 {
895 openGroupBlock = true;
896
897 WriteLine("if (p is INullable)");
898 WriteLine("{");
899
900 PushIndent("\t");
901 }
902 }
903
904 if (to.NonSLMethods.Contains(fr.Name))
905 {
906 ClearIndent();
907 WriteLine("#if !SILVERLIGHT");
908 PushIndent("\t\t");
909 PushIndent("\t");
910 if (openGroupBlock)
911 PushIndent("\t");
912 }
913
914 WriteLine("if (p is {0}){1} return {2}(({0}){1}p);", fr.Name, LenDiff(len, fr.Name), to.Method);
915
916 if (to.NonSLMethods.Contains(fr.Name))
917 {
918 ClearIndent();
919 WriteLine("#endif");
920 PushIndent("\t\t");
921 PushIndent("\t");
922 if (openGroupBlock)
923 PushIndent("\t");
924 }
925 }
926
927 if (openGroupBlock)
928 {
929 PopIndent();
930 WriteLine("}");
931 }
932
933 if (sl)
934 {
935 ClearIndent();
936 WriteLine("");
937 WriteLine("#endif");
938 PushIndent("\t\t");
939 PushIndent("\t");
940 }
941
942 if (_codedTypes.Contains(to.Name))
943 {
944 WriteLine("");
945 WriteLine("if (p is IConvertible) return ((IConvertible)p).To{0}(null);", to.Name);
946 }
947
948 WriteLine("");
949
950 if (to.FromObjectReturn != null)
951 WriteLine(to.FromObjectReturn);
952 else
953 WriteLine("throw CreateInvalidCastException(p.GetType(), typeof({0}));", to.Name);
954
955 PopIndent();
956
957 WriteLine("}");
958 }
959
960 if (to.NonSilverlightable)
961 {
962 ClearIndent();
963 WriteLine("");
964 WriteLine("#endif");
965 PushIndent("\t\t");
966 }
967
968 WriteLine("");
969 WriteLine("#endregion");
970 }
971
972 WriteLine("");
973 WriteLine("#endregion");
974 }
975
976 ClearIndent();
977 }
978 #>