[{"data":1,"prerenderedAt":1386},["ShallowReactive",2],{"blog:2013:probable-c-6-0-features-illustrated":3,"blogMore-Development":1372,"comments-probable-c-6-0-features-illustrated":1385},{"id":4,"title":5,"body":6,"category":1354,"commentCount":1355,"date":1356,"description":1357,"excerpt":1358,"extension":1359,"filenames":1360,"hidden":1361,"image":1360,"meta":1362,"minutes":136,"navigation":102,"path":1363,"seo":1364,"showCategory":1360,"stem":1365,"tags":1366,"updated":1360,"url":1369,"wordCount":1370,"__hash__":1371},"content\u002Fblog\u002F2013\u002Fprobable-c-6-0-features-illustrated.md","Probable C# 6.0 features illustrated",{"type":7,"value":8,"toc":1306},"minimark",[9,22,37,40,45,48,53,164,168,208,212,225,228,252,255,259,262,265,298,301,319,322,330,334,337,340,378,381,430,433,441,445,448,451,500,503,539,542,550,554,557,560,618,621,668,671,674,678,681,684,735,738,783,786,794,798,806,809,902,905,948,951,954,958,961,964,1077,1080,1111,1114,1122,1126,1129,1132,1169,1172,1201,1204,1212,1216,1219,1296,1302],[10,11,12],"blockquote",{},[13,14,15,16,21],"p",{},"C# 6.0 is now available and the final list of features is well explained by ",[17,18,20],"a",{"href":19},"https:\u002F\u002Fwww.ahuwanya.net\u002Fblog\u002Fpost\u002FExploring-C-Sharp-6","Sunny Ahuwanya"," so go there and try it with his interactive samples page.",[13,23,24,30,31,36],{},[17,25,29],{"href":26,"rel":27},"https:\u002F\u002Fadamralph.com\u002F2013\u002F12\u002F06\u002Fndc-diary-day-3\u002F#more",[28],"nofollow","Adam Ralph has a list of the probable C# 6.0 features"," Mads Torgersen from the C# design team covered at ",[17,32,35],{"href":33,"rel":34},"https:\u002F\u002Fchannel9.msdn.com\u002FForums\u002FCoffeehouse\u002FMads-Torgersen--NDC-London--The-Future-of-C",[28],"new Developers Conference() NDC 2013 in London",".",[13,38,39],{},"I thought it would be fun to show some before and after syntax for comparison and in doing so ended up with a few thoughts and questions.",[41,42,44],"h2",{"id":43},"_1-primary-constructors","1. Primary Constructors",[13,46,47],{},"Shorter way to write a constructor that automatically assigns to private instance variables.",[49,50,52],"h3",{"id":51},"before","Before",[54,55,60],"pre",{"className":56,"code":57,"language":58,"meta":59,"style":59},"language-csharp shiki shiki-themes everforest-light dracula","public class Point {\n  private int x, y;\n\n  public Point(int x, int y)\n    this.x = x;\n    this.y = y;\n  }\n}\n","csharp","",[61,62,63,84,97,104,134,140,152,158],"code",{"__ignoreMap":59},[64,65,68,72,76,80],"span",{"class":66,"line":67},"line",1,[64,69,71],{"class":70},"s9HRq","public",[64,73,75],{"class":74},"smiwp"," class",[64,77,79],{"class":78},"sPLAf"," Point",[64,81,83],{"class":82},"s6Vpi"," {\n",[64,85,87,90,94],{"class":66,"line":86},2,[64,88,89],{"class":70},"  private",[64,91,93],{"class":92},"sXAHl"," int",[64,95,96],{"class":82}," x, y;\n",[64,98,100],{"class":66,"line":99},3,[64,101,103],{"emptyLinePlaceholder":102},true,"\n",[64,105,107,110,113,116,119,123,126,128,131],{"class":66,"line":106},4,[64,108,109],{"class":70},"  public",[64,111,79],{"class":112},"sS4Kt",[64,114,115],{"class":82},"(",[64,117,118],{"class":92},"int",[64,120,122],{"class":121},"s7cAX"," x",[64,124,125],{"class":82},", ",[64,127,118],{"class":92},[64,129,130],{"class":121}," y",[64,132,133],{"class":82},")\n",[64,135,137],{"class":66,"line":136},5,[64,138,139],{"class":82},"    this.x = x;\n",[64,141,143,146,149],{"class":66,"line":142},6,[64,144,145],{"class":82},"    this.y ",[64,147,148],{"class":70},"=",[64,150,151],{"class":82}," y;\n",[64,153,155],{"class":66,"line":154},7,[64,156,157],{"class":82},"  }\n",[64,159,161],{"class":66,"line":160},8,[64,162,163],{"class":82},"}\n",[49,165,167],{"id":166},"after","After",[54,169,171],{"className":56,"code":170,"language":58,"meta":59,"style":59},"public class Point(int x, int y) {\n  private int x, y;\n}\n",[61,172,173,196,204],{"__ignoreMap":59},[64,174,175,177,179,181,183,185,187,189,191,193],{"class":66,"line":67},[64,176,71],{"class":70},[64,178,75],{"class":74},[64,180,79],{"class":78},[64,182,115],{"class":82},[64,184,118],{"class":92},[64,186,122],{"class":121},[64,188,125],{"class":82},[64,190,118],{"class":92},[64,192,130],{"class":121},[64,194,195],{"class":82},") {\n",[64,197,198,200,202],{"class":66,"line":86},[64,199,89],{"class":70},[64,201,93],{"class":92},[64,203,96],{"class":82},[64,205,206],{"class":66,"line":99},[64,207,163],{"class":82},[49,209,211],{"id":210},"thoughts","Thoughts",[213,214,215,219,222],"ul",{},[216,217,218],"li",{},"Do you need to independently define x and y?",[216,220,221],{},"Can you still write a body?",[216,223,224],{},"How would you make the default private?",[13,226,227],{},"This solution feels too constrained, would have preferred something like:",[54,229,231],{"className":56,"code":230,"language":58,"meta":59,"style":59},"  public Point(set int x, set int y)\n",[61,232,233],{"__ignoreMap":59},[64,234,235,237,239,242,244,247,249],{"class":66,"line":67},[64,236,109],{"class":70},[64,238,79],{"class":112},[64,240,241],{"class":82},"(set ",[64,243,118],{"class":92},[64,245,246],{"class":82}," x, set ",[64,248,118],{"class":92},[64,250,251],{"class":82}," y)\n",[13,253,254],{},"That set the property and optionally created a private one if it didn’t. Would allow bodies, use on multiple constructors etc.",[41,256,258],{"id":257},"_2-readonly-auto-properties","2. Readonly auto properties",[13,260,261],{},"Readonly properties require less syntax.",[49,263,52],{"id":264},"before-1",[54,266,268],{"className":56,"code":267,"language":58,"meta":59,"style":59},"private readonly int x;\npublic int X { get { return x; } }\n",[61,269,270,283],{"__ignoreMap":59},[64,271,272,275,278,280],{"class":66,"line":67},[64,273,274],{"class":70},"private",[64,276,277],{"class":70}," readonly",[64,279,93],{"class":92},[64,281,282],{"class":82}," x;\n",[64,284,285,287,289,292,295],{"class":66,"line":86},[64,286,71],{"class":70},[64,288,93],{"class":92},[64,290,291],{"class":82}," X { get { ",[64,293,294],{"class":74},"return",[64,296,297],{"class":82}," x; } }\n",[49,299,167],{"id":300},"after-1",[54,302,304],{"className":56,"code":303,"language":58,"meta":59,"style":59},"public int X { get; } = x;\n",[61,305,306],{"__ignoreMap":59},[64,307,308,310,312,315,317],{"class":66,"line":67},[64,309,71],{"class":70},[64,311,93],{"class":92},[64,313,314],{"class":82}," X { get; } ",[64,316,148],{"class":70},[64,318,282],{"class":82},[49,320,211],{"id":321},"thoughts-1",[213,323,324,327],{},[216,325,326],{},"Love this.",[216,328,329],{},"Very useful for immutable classes.",[41,331,333],{"id":332},"_3-static-type-using-statements","3. Static type using statements;",[13,335,336],{},"Imports all the public static methods of a type into the current namespace.",[49,338,52],{"id":339},"before-2",[54,341,343],{"className":56,"code":342,"language":58,"meta":59,"style":59},"public double A { get { return Math.Sqrt(Math.Round(5.142)); } }\n",[61,344,345],{"__ignoreMap":59},[64,346,347,349,352,355,357,360,363,366,369,371,375],{"class":66,"line":67},[64,348,71],{"class":70},[64,350,351],{"class":92}," double",[64,353,354],{"class":82}," A { get { ",[64,356,294],{"class":74},[64,358,359],{"class":82}," Math.",[64,361,362],{"class":112},"Sqrt",[64,364,365],{"class":82},"(Math.",[64,367,368],{"class":112},"Round",[64,370,115],{"class":82},[64,372,374],{"class":373},"s3Ipq","5.142",[64,376,377],{"class":82},")); } }\n",[49,379,167],{"id":380},"after-2",[54,382,384],{"className":56,"code":383,"language":58,"meta":59,"style":59},"using System.Math;\n\npublic double A { get { return Sqrt(Round(5.142)); } }\n",[61,385,386,403,407],{"__ignoreMap":59},[64,387,388,391,395,397,400],{"class":66,"line":67},[64,389,390],{"class":74},"using",[64,392,394],{"class":393},"sjYfO"," System",[64,396,36],{"class":82},[64,398,399],{"class":393},"Math",[64,401,402],{"class":82},";\n",[64,404,405],{"class":66,"line":86},[64,406,103],{"emptyLinePlaceholder":102},[64,408,409,411,413,415,417,420,422,424,426,428],{"class":66,"line":99},[64,410,71],{"class":70},[64,412,351],{"class":92},[64,414,354],{"class":82},[64,416,294],{"class":74},[64,418,419],{"class":112}," Sqrt",[64,421,115],{"class":82},[64,423,368],{"class":112},[64,425,115],{"class":82},[64,427,374],{"class":373},[64,429,377],{"class":82},[49,431,211],{"id":432},"thoughts-2",[213,434,435,438],{},[216,436,437],{},"Not something I’ve run into often but no doubt very useful for Math-heavy classes.",[216,439,440],{},"Could be useful for Enumerable LINQ-heavy classes if it works with static extension methods.",[41,442,444],{"id":443},"_4-property-expressions","4. Property Expressions",[13,446,447],{},"Allows you to define a property using a shorthand syntax.",[49,449,52],{"id":450},"before-3",[54,452,454],{"className":56,"code":453,"language":58,"meta":59,"style":59},"public double Distance {\n  get { return Math.Sqrt((X * X) + (Y * Y)); }\n}\n",[61,455,456,465,496],{"__ignoreMap":59},[64,457,458,460,462],{"class":66,"line":67},[64,459,71],{"class":70},[64,461,351],{"class":92},[64,463,464],{"class":82}," Distance {\n",[64,466,467,470,472,474,476,479,482,485,488,491,493],{"class":66,"line":86},[64,468,469],{"class":82},"  get { ",[64,471,294],{"class":74},[64,473,359],{"class":82},[64,475,362],{"class":112},[64,477,478],{"class":82},"((X ",[64,480,481],{"class":70},"*",[64,483,484],{"class":82}," X) ",[64,486,487],{"class":70},"+",[64,489,490],{"class":82}," (Y ",[64,492,481],{"class":70},[64,494,495],{"class":82}," Y)); }\n",[64,497,498],{"class":66,"line":99},[64,499,163],{"class":82},[49,501,167],{"id":502},"after-3",[54,504,506],{"className":56,"code":505,"language":58,"meta":59,"style":59},"public double Distance => Math.Sqrt((X * X) + (Y * Y));\n",[61,507,508],{"__ignoreMap":59},[64,509,510,512,514,517,520,522,524,526,528,530,532,534,536],{"class":66,"line":67},[64,511,71],{"class":70},[64,513,351],{"class":92},[64,515,516],{"class":121}," Distance",[64,518,519],{"class":70}," =>",[64,521,359],{"class":82},[64,523,362],{"class":112},[64,525,478],{"class":82},[64,527,481],{"class":70},[64,529,484],{"class":82},[64,531,487],{"class":70},[64,533,490],{"class":82},[64,535,481],{"class":70},[64,537,538],{"class":82}," Y));\n",[49,540,211],{"id":541},"thoughts-3",[213,543,544,547],{},[216,545,546],{},"Small but useful syntax reduction.",[216,548,549],{},"Has nothing to do with System.Linq.Expression despite the name.",[41,551,553],{"id":552},"_5-method-expressions","5. Method Expressions",[13,555,556],{},"Allows you to define a method using a shorthand syntax.",[49,558,52],{"id":559},"before-4",[54,561,563],{"className":56,"code":562,"language":58,"meta":59,"style":59},"public Point Move(int dx, int dy) {\n  return new Point(X + dx1, Y + dy1);\n}\n",[61,564,565,591,614],{"__ignoreMap":59},[64,566,567,569,572,575,577,579,582,584,586,589],{"class":66,"line":67},[64,568,71],{"class":70},[64,570,79],{"class":571},"snuxY",[64,573,574],{"class":112}," Move",[64,576,115],{"class":82},[64,578,118],{"class":92},[64,580,581],{"class":121}," dx",[64,583,125],{"class":82},[64,585,118],{"class":92},[64,587,588],{"class":121}," dy",[64,590,195],{"class":82},[64,592,593,596,599,601,604,606,609,611],{"class":66,"line":86},[64,594,595],{"class":74},"  return",[64,597,598],{"class":74}," new",[64,600,79],{"class":571},[64,602,603],{"class":82},"(X ",[64,605,487],{"class":70},[64,607,608],{"class":82}," dx1, Y ",[64,610,487],{"class":70},[64,612,613],{"class":82}," dy1);\n",[64,615,616],{"class":66,"line":99},[64,617,163],{"class":82},[49,619,167],{"id":620},"after-4",[54,622,624],{"className":56,"code":623,"language":58,"meta":59,"style":59},"public Point Move(int dx, int dy) => new Point(X + dx, Y + dy);\n",[61,625,626],{"__ignoreMap":59},[64,627,628,630,632,634,636,638,640,642,644,646,649,652,654,656,658,660,663,665],{"class":66,"line":67},[64,629,71],{"class":70},[64,631,79],{"class":571},[64,633,574],{"class":112},[64,635,115],{"class":82},[64,637,118],{"class":92},[64,639,581],{"class":121},[64,641,125],{"class":82},[64,643,118],{"class":92},[64,645,588],{"class":121},[64,647,648],{"class":82},") ",[64,650,651],{"class":70},"=>",[64,653,598],{"class":74},[64,655,79],{"class":571},[64,657,603],{"class":82},[64,659,487],{"class":70},[64,661,662],{"class":82}," dx, Y ",[64,664,487],{"class":70},[64,666,667],{"class":82}," dy);\n",[49,669,211],{"id":670},"thoughts-4",[13,672,673],{},"Same as Property Expressions.",[41,675,677],{"id":676},"_6-params-for-enumerables","6. Params for enumerables",[13,679,680],{},"No longer need to define your params methods as an array and force early evaluation of the arguments.",[49,682,52],{"id":683},"before-5",[54,685,687],{"className":56,"code":686,"language":58,"meta":59,"style":59},"Do(someEnum.ToArray());\npublic void Do(params int[] values) { ... }\n",[61,688,689,703],{"__ignoreMap":59},[64,690,691,694,697,700],{"class":66,"line":67},[64,692,693],{"class":112},"Do",[64,695,696],{"class":82},"(someEnum.",[64,698,699],{"class":112},"ToArray",[64,701,702],{"class":82},"());\n",[64,704,705,707,710,713,715,718,720,723,726,729,732],{"class":66,"line":86},[64,706,71],{"class":70},[64,708,709],{"class":92}," void",[64,711,712],{"class":112}," Do",[64,714,115],{"class":82},[64,716,717],{"class":70},"params",[64,719,93],{"class":92},[64,721,722],{"class":82},"[] ",[64,724,725],{"class":121},"values",[64,727,728],{"class":82},") { ",[64,730,731],{"class":70},"..",[64,733,734],{"class":82},". }\n",[49,736,167],{"id":737},"after-5",[54,739,741],{"className":56,"code":740,"language":58,"meta":59,"style":59},"Do(someEnum);\npublic void Do(params IEnumerable\u003CPoint> points) { ... }\n",[61,742,743,750],{"__ignoreMap":59},[64,744,745,747],{"class":66,"line":67},[64,746,693],{"class":112},[64,748,749],{"class":82},"(someEnum);\n",[64,751,752,754,756,758,760,762,765,768,771,774,777,779,781],{"class":66,"line":86},[64,753,71],{"class":70},[64,755,709],{"class":92},[64,757,712],{"class":112},[64,759,115],{"class":82},[64,761,717],{"class":70},[64,763,764],{"class":571}," IEnumerable",[64,766,767],{"class":82},"\u003C",[64,769,770],{"class":571},"Point",[64,772,773],{"class":82},"> ",[64,775,776],{"class":121},"points",[64,778,728],{"class":82},[64,780,731],{"class":70},[64,782,734],{"class":82},[49,784,211],{"id":785},"thoughts-5",[213,787,788,791],{},[216,789,790],{},"Can have params methods for IEnumerable and array side-by-side? Probably not.",[216,792,793],{},"Is evaluation deferred until evaluated if you pass a single IEnumerable instead of a params?",[41,795,797],{"id":796},"_7-monadic-null-checking","7. Monadic null checking",[13,799,800,801,36],{},"Removes the need to check for nulls before accessing properties or methods. Known as the ",[17,802,805],{"href":803,"rel":804},"http:\u002F\u002Fgroovy.codehaus.org\u002FOperators#Operators-SafeNavigationOperator(?.)",[28],"Safe Navigation Operator in Groovy",[49,807,52],{"id":808},"before-6",[54,810,812],{"className":56,"code":811,"language":58,"meta":59,"style":59},"if (points != null) {\n  var next = points.FirstOrDefault();\n  if (next != null && next.X != null) return next.X;\n}\nreturn -1;\n",[61,813,814,830,849,886,890],{"__ignoreMap":59},[64,815,816,819,822,825,828],{"class":66,"line":67},[64,817,818],{"class":74},"if",[64,820,821],{"class":82}," (points ",[64,823,824],{"class":70},"!=",[64,826,827],{"class":373}," null",[64,829,195],{"class":82},[64,831,832,835,838,840,843,846],{"class":66,"line":86},[64,833,834],{"class":92},"  var",[64,836,837],{"class":82}," next ",[64,839,148],{"class":70},[64,841,842],{"class":82}," points.",[64,844,845],{"class":112},"FirstOrDefault",[64,847,848],{"class":82},"();\n",[64,850,851,854,857,859,861,864,867,871,874,876,878,880,882,884],{"class":66,"line":99},[64,852,853],{"class":74},"  if",[64,855,856],{"class":82}," (next ",[64,858,824],{"class":70},[64,860,827],{"class":373},[64,862,863],{"class":70}," &&",[64,865,866],{"class":82}," next.",[64,868,870],{"class":869},"sSKRk","X",[64,872,873],{"class":70}," !=",[64,875,827],{"class":373},[64,877,648],{"class":82},[64,879,294],{"class":74},[64,881,866],{"class":82},[64,883,870],{"class":869},[64,885,402],{"class":82},[64,887,888],{"class":66,"line":106},[64,889,163],{"class":82},[64,891,892,894,897,900],{"class":66,"line":136},[64,893,294],{"class":74},[64,895,896],{"class":70}," -",[64,898,899],{"class":373},"1",[64,901,402],{"class":82},[49,903,167],{"id":904},"after-6",[54,906,908],{"className":56,"code":907,"language":58,"meta":59,"style":59},"var bestValue = points?.FirstOrDefault()?.X ?? -1;\n",[61,909,910],{"__ignoreMap":59},[64,911,912,915,918,920,923,926,928,930,933,935,937,939,942,944,946],{"class":66,"line":67},[64,913,914],{"class":92},"var",[64,916,917],{"class":82}," bestValue ",[64,919,148],{"class":70},[64,921,922],{"class":82}," points",[64,924,925],{"class":70},"?",[64,927,36],{"class":82},[64,929,845],{"class":112},[64,931,932],{"class":82},"()",[64,934,925],{"class":70},[64,936,36],{"class":82},[64,938,870],{"class":869},[64,940,941],{"class":70}," ??",[64,943,896],{"class":70},[64,945,899],{"class":373},[64,947,402],{"class":82},[49,949,211],{"id":950},"thoughts-6",[13,952,953],{},"Love it. Will reduce noise in code and hopefully reduce null reference errors everywhere!",[41,955,957],{"id":956},"_8-constructor-type-parameter-inference","8. Constructor type parameter inference",[13,959,960],{},"Removes the need to create static factory methods to infer generic types. This is helpful with Tuples etc.",[49,962,52],{"id":963},"before-7",[54,965,967],{"className":56,"code":966,"language":58,"meta":59,"style":59},"var x = MyClass.Create(1, \"X\");\n\npublic MyClass\u003CT1, T2> Create\u003CT1, T2>(T1 a, T2 b) {\n    return new MyClass\u003CT1, T2>(a, b);\n}\n",[61,968,969,1002,1006,1053,1073],{"__ignoreMap":59},[64,970,971,973,976,978,981,984,986,988,990,994,997,999],{"class":66,"line":67},[64,972,914],{"class":92},[64,974,975],{"class":82}," x ",[64,977,148],{"class":70},[64,979,980],{"class":82}," MyClass.",[64,982,983],{"class":112},"Create",[64,985,115],{"class":82},[64,987,899],{"class":373},[64,989,125],{"class":82},[64,991,993],{"class":992},"sciFF","\"",[64,995,870],{"class":996},"sJQOs",[64,998,993],{"class":992},[64,1000,1001],{"class":82},");\n",[64,1003,1004],{"class":66,"line":86},[64,1005,103],{"emptyLinePlaceholder":102},[64,1007,1008,1010,1013,1015,1018,1020,1023,1025,1027,1029,1032,1034,1036,1039,1041,1044,1046,1048,1051],{"class":66,"line":99},[64,1009,71],{"class":70},[64,1011,1012],{"class":571}," MyClass",[64,1014,767],{"class":82},[64,1016,1017],{"class":571},"T1",[64,1019,125],{"class":82},[64,1021,1022],{"class":571},"T2",[64,1024,773],{"class":82},[64,1026,983],{"class":112},[64,1028,767],{"class":82},[64,1030,1017],{"class":1031},"sAO9U",[64,1033,125],{"class":82},[64,1035,1022],{"class":1031},[64,1037,1038],{"class":82},">(",[64,1040,1017],{"class":571},[64,1042,1043],{"class":121}," a",[64,1045,125],{"class":82},[64,1047,1022],{"class":571},[64,1049,1050],{"class":121}," b",[64,1052,195],{"class":82},[64,1054,1055,1058,1060,1062,1064,1066,1068,1070],{"class":66,"line":106},[64,1056,1057],{"class":74},"    return",[64,1059,598],{"class":74},[64,1061,1012],{"class":571},[64,1063,767],{"class":82},[64,1065,1017],{"class":571},[64,1067,125],{"class":82},[64,1069,1022],{"class":571},[64,1071,1072],{"class":82},">(a, b);\n",[64,1074,1075],{"class":66,"line":136},[64,1076,163],{"class":82},[49,1078,167],{"id":1079},"after-7",[54,1081,1083],{"className":56,"code":1082,"language":58,"meta":59,"style":59},"var x = new MyClass(1, \"X\");\n",[61,1084,1085],{"__ignoreMap":59},[64,1086,1087,1089,1091,1093,1095,1097,1099,1101,1103,1105,1107,1109],{"class":66,"line":67},[64,1088,914],{"class":92},[64,1090,975],{"class":82},[64,1092,148],{"class":70},[64,1094,598],{"class":74},[64,1096,1012],{"class":571},[64,1098,115],{"class":82},[64,1100,899],{"class":373},[64,1102,125],{"class":82},[64,1104,993],{"class":992},[64,1106,870],{"class":996},[64,1108,993],{"class":992},[64,1110,1001],{"class":82},[49,1112,211],{"id":1113},"thoughts-7",[213,1115,1116,1119],{},[216,1117,1118],{},"Another great addition.",[216,1120,1121],{},"Does it understand list and collection initializers to automatically determine the generic types too?",[41,1123,1125],{"id":1124},"_9-inline-declarations-for-out-params","9. Inline declarations for out params",[13,1127,1128],{},"Lets you declare the out variables inline with the call.",[49,1130,52],{"id":1131},"before-8",[54,1133,1135],{"className":56,"code":1134,"language":58,"meta":59,"style":59},"int x;\nint.TryParse(\"123\", out x);\n",[61,1136,1137,1143],{"__ignoreMap":59},[64,1138,1139,1141],{"class":66,"line":67},[64,1140,118],{"class":92},[64,1142,282],{"class":82},[64,1144,1145,1147,1149,1152,1154,1156,1159,1161,1163,1166],{"class":66,"line":86},[64,1146,118],{"class":92},[64,1148,36],{"class":82},[64,1150,1151],{"class":112},"TryParse",[64,1153,115],{"class":82},[64,1155,993],{"class":992},[64,1157,1158],{"class":996},"123",[64,1160,993],{"class":992},[64,1162,125],{"class":82},[64,1164,1165],{"class":70},"out",[64,1167,1168],{"class":82}," x);\n",[49,1170,167],{"id":1171},"after-8",[54,1173,1175],{"className":56,"code":1174,"language":58,"meta":59,"style":59},"int.TryParse(\"123\", out int x);\n",[61,1176,1177],{"__ignoreMap":59},[64,1178,1179,1181,1183,1185,1187,1189,1191,1193,1195,1197,1199],{"class":66,"line":67},[64,1180,118],{"class":92},[64,1182,36],{"class":82},[64,1184,1151],{"class":112},[64,1186,115],{"class":82},[64,1188,993],{"class":992},[64,1190,1158],{"class":996},[64,1192,993],{"class":992},[64,1194,125],{"class":82},[64,1196,1165],{"class":70},[64,1198,93],{"class":92},[64,1200,1168],{"class":82},[49,1202,211],{"id":1203},"thoughts-8",[213,1205,1206,1209],{},[216,1207,1208],{},"Not a particularly large syntax reduction.",[216,1210,1211],{},"Shorter code for Try methods and DirectX.",[41,1213,1215],{"id":1214},"wrapping-up","Wrapping up",[13,1217,1218],{},"Hopefully there are a few more gems to come that would help reduce noise. Would especially like to see syntax that wired up an interface to an internal instance variable where not specifically overridden to aid in encapsulation, e.g.",[54,1220,1222],{"className":56,"code":1221,"language":58,"meta":59,"style":59},"public MyClass : IList => myList {\n  private IList myList;\n\n  public Add(object item) {\n    \u002F\u002F Do something first\n    myList.Add(item);\n  }\n}\n",[61,1223,1224,1239,1250,1254,1271,1277,1288,1292],{"__ignoreMap":59},[64,1225,1226,1228,1230,1233,1236],{"class":66,"line":67},[64,1227,71],{"class":70},[64,1229,1012],{"class":869},[64,1231,1232],{"class":82}," : IList ",[64,1234,1235],{"class":70},"=&",[64,1237,1238],{"class":82},"gt; myList {\n",[64,1240,1241,1244,1247],{"class":66,"line":86},[64,1242,1243],{"class":82},"  private ",[64,1245,1246],{"class":571},"IList",[64,1248,1249],{"class":82}," myList;\n",[64,1251,1252],{"class":66,"line":99},[64,1253,103],{"emptyLinePlaceholder":102},[64,1255,1256,1258,1261,1263,1266,1269],{"class":66,"line":106},[64,1257,109],{"class":571},[64,1259,1260],{"class":112}," Add",[64,1262,115],{"class":82},[64,1264,1265],{"class":92},"object",[64,1267,1268],{"class":121}," item",[64,1270,195],{"class":82},[64,1272,1273],{"class":66,"line":136},[64,1274,1276],{"class":1275},"sSX4p","    \u002F\u002F Do something first\n",[64,1278,1279,1282,1285],{"class":66,"line":142},[64,1280,1281],{"class":82},"    myList.",[64,1283,1284],{"class":112},"Add",[64,1286,1287],{"class":82},"(item);\n",[64,1289,1290],{"class":66,"line":154},[64,1291,157],{"class":82},[64,1293,1294],{"class":66,"line":160},[64,1295,163],{"class":82},[13,1297,1298],{},[1299,1300,1301],"em",{},"[)amien",[1303,1304,1305],"style",{},"html pre.shiki code .s9HRq, html code.shiki .s9HRq{--shiki-default:#F57D26;--shiki-dark:#FF79C6}html pre.shiki code .smiwp, html code.shiki .smiwp{--shiki-default:#F85552;--shiki-dark:#FF79C6}html pre.shiki code .sPLAf, html code.shiki .sPLAf{--shiki-default:#3A94C5;--shiki-dark:#8BE9FD}html pre.shiki code .s6Vpi, html code.shiki .s6Vpi{--shiki-default:#5C6A72;--shiki-dark:#F8F8F2}html pre.shiki code .sXAHl, html code.shiki .sXAHl{--shiki-default:#3A94C5;--shiki-dark:#FF79C6}html pre.shiki code .sS4Kt, html code.shiki .sS4Kt{--shiki-default:#8DA101;--shiki-dark:#50FA7B}html pre.shiki code .s7cAX, html code.shiki .s7cAX{--shiki-default:#5C6A72;--shiki-default-font-style:inherit;--shiki-dark:#FFB86C;--shiki-dark-font-style:italic}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html pre.shiki code .s3Ipq, html code.shiki .s3Ipq{--shiki-default:#DF69BA;--shiki-dark:#BD93F9}html pre.shiki code .sjYfO, html code.shiki .sjYfO{--shiki-default:#DF69BA;--shiki-default-font-style:inherit;--shiki-dark:#8BE9FD;--shiki-dark-font-style:italic}html pre.shiki code .snuxY, html code.shiki .snuxY{--shiki-default:#3A94C5;--shiki-default-font-style:inherit;--shiki-dark:#8BE9FD;--shiki-dark-font-style:italic}html pre.shiki code .sSKRk, html code.shiki .sSKRk{--shiki-default:#35A77C;--shiki-dark:#F8F8F2}html pre.shiki code .sciFF, html code.shiki .sciFF{--shiki-default:#8DA101;--shiki-dark:#E9F284}html pre.shiki code .sJQOs, html code.shiki .sJQOs{--shiki-default:#8DA101;--shiki-dark:#F1FA8C}html pre.shiki code .sAO9U, html code.shiki .sAO9U{--shiki-default:#3A94C5;--shiki-default-font-style:inherit;--shiki-dark:#FFB86C;--shiki-dark-font-style:italic}html pre.shiki code .sSX4p, html code.shiki .sSX4p{--shiki-default:#939F91;--shiki-default-font-style:italic;--shiki-dark:#6272A4;--shiki-dark-font-style:inherit}",{"title":59,"searchDepth":86,"depth":86,"links":1307},[1308,1313,1318,1323,1328,1333,1338,1343,1348,1353],{"id":43,"depth":86,"text":44,"children":1309},[1310,1311,1312],{"id":51,"depth":99,"text":52},{"id":166,"depth":99,"text":167},{"id":210,"depth":99,"text":211},{"id":257,"depth":86,"text":258,"children":1314},[1315,1316,1317],{"id":264,"depth":99,"text":52},{"id":300,"depth":99,"text":167},{"id":321,"depth":99,"text":211},{"id":332,"depth":86,"text":333,"children":1319},[1320,1321,1322],{"id":339,"depth":99,"text":52},{"id":380,"depth":99,"text":167},{"id":432,"depth":99,"text":211},{"id":443,"depth":86,"text":444,"children":1324},[1325,1326,1327],{"id":450,"depth":99,"text":52},{"id":502,"depth":99,"text":167},{"id":541,"depth":99,"text":211},{"id":552,"depth":86,"text":553,"children":1329},[1330,1331,1332],{"id":559,"depth":99,"text":52},{"id":620,"depth":99,"text":167},{"id":670,"depth":99,"text":211},{"id":676,"depth":86,"text":677,"children":1334},[1335,1336,1337],{"id":683,"depth":99,"text":52},{"id":737,"depth":99,"text":167},{"id":785,"depth":99,"text":211},{"id":796,"depth":86,"text":797,"children":1339},[1340,1341,1342],{"id":808,"depth":99,"text":52},{"id":904,"depth":99,"text":167},{"id":950,"depth":99,"text":211},{"id":956,"depth":86,"text":957,"children":1344},[1345,1346,1347],{"id":963,"depth":99,"text":52},{"id":1079,"depth":99,"text":167},{"id":1113,"depth":99,"text":211},{"id":1124,"depth":86,"text":1125,"children":1349},[1350,1351,1352],{"id":1131,"depth":99,"text":52},{"id":1171,"depth":99,"text":167},{"id":1203,"depth":99,"text":211},{"id":1214,"depth":86,"text":1215},"Development",79,"2013-12-09T11:27:44+00:00","Before-and-after code samples for the probable C# 6.0 features Mads Torgersen presented at NDC London 2013, with my thoughts and questions on each one.","[object Object]","md",null,false,{},"\u002Fblog\u002F2013\u002Fprobable-c-6-0-features-illustrated",{"title":5,"description":1357},"blog\u002F2013\u002Fprobable-c-6-0-features-illustrated",[1367,1368],".NET","C#","\u002Fblog\u002F2013\u002Fprobable-c-6-0-features-illustrated\u002F",970,"utfKa6BwdNa3vQBujF8mVDbsvf0yFnXTztFN78sc59I",[1373,1377,1381],{"title":1374,"date":1375,"url":1376},"Transactions in the MongoDB EF Core Provider","2025-10-25","\u002Fblog\u002F2025\u002Fmongodb-explicit-transactions\u002F",{"title":1378,"date":1379,"url":1380},"Queryable Encryption with the MongoDB EF Core Provider","2025-09-22","\u002Fblog\u002F2025\u002Fmongodb-queryable-encryption\u002F",{"title":1382,"date":1383,"url":1384},"Lazy Loading with EF Core Proxies","2025-04-02","\u002Fblog\u002F2025\u002Fef-proxies\u002F",[],1780900526795]