මෙම ප්‍රශ්නයෙන් මම පහත කරුණු ඉගෙන ගත් පසු මෙය මගේ මතකයට නැඟුණි :

where T : struct

අපි, සී # සංවර්ධකයින්, සියල්ලන්ම සී # හි මූලික කරුණු දනිමු. මම අදහස් කළේ ප්‍රකාශන, කොන්දේසි, ලූප, ක්‍රියාකරුවන් යනාදියයි.

අපෙන් සමහරෙක් ජෙනරික්ස් , නිර්නාමික වර්ග , ලැම්බඩාස් , ලින්ක් , ...

C # පංකා, ඇබ්බැහි වූවන්, විශේෂ experts යන් පවා නොදන්නා C # හි වඩාත්ම සැඟවුණු අංග හෝ උපක්‍රම මොනවාද?

මෙතෙක් අනාවරණය වූ ලක්ෂණ මෙන්න:

මූල පද

• yieldවිසින් මයිකල් Stum
• varවිසින් මයිකල් Stum
• using()කොකොස්ගේ ප්‍රකාශය
• readonlyවිසින් kokos
• asවිසින් මයික් ගල්
• as/ isවිසින් එඩ් Swangren
• as/ is(වැඩි දියුණු කරන ලද්දේ) රොකට් පැන්ට්ස් විසිනි
• defaultdeathofrates විසින්
• global::pzycoman විසින්
• using()බ්ලොක් ඇලෙක්ස්කූස්
• volatileවිසින් Jakub Šturc
• extern aliasවිසින් Jakub Šturc

ගුණාංග

• DefaultValueAttributeවිසින් මයිකල් Stum
• ObsoleteAttributeවිසින් DannySmurf
• DebuggerDisplayAttributeවිසින් Stu
• DebuggerBrowsableහා DebuggerStepThroughවිසින් bdukes
• ThreadStaticAttributeවිසින් marxidad
• FlagsAttributeවිසින් මාටින් ක්ලාක්
• ConditionalAttributeවිසින් AndrewBurns

සින්ටැක්ස්

• ??(coalesce nulls) ක්‍රියාකරු කොකොස් විසිනි
• නික් බෙරාඩි විසින් අංක සලකුණු කිරීම
• where T:newවිසින් ලාස් Mæhlum
• කීත් විසින් ව්‍යංග ජනක විද්‍යාව
• කීත් විසින් එක් පරාමිති ලැම්බඩාස්
• කීත් විසින් ස්වයංක්‍රීය ගුණාංග
• කීත් විසින් නාම අවකාශ අන්වර්ථයන්
• පැට්‍රික් විසින් @ සමඟ වාචික වචන වචනාර්ථය
• enumඅගයන් lfoust
• මාක්සිඩෑඩ් විසින් වෙනස් කළ හැකි නම්
• eventමාක්සිඩාඩ් විසින් ක්‍රියාකරුවන්
• පෝට්මන් විසින් නූල් වරහන් ආකෘතිකරණය කරන්න
• Xanadont විසින් දේපල ප්‍රවේශවීමේ ප්‍රවේශ්‍යතා වෙනස් කිරීම්
• කොන්දේසි සහිත (තෘතීය) ක්‍රියාකරු ( ?:) ජේසන් විසිනි
• checkedසහ uncheckedක්‍රියාකරුවන් බිනෝජ් ඇන්ටනි විසිනි
• implicit and explicitෆ්ලෝරි විසින් ක්‍රියාකරුවන්

භාෂා විශේෂාංග

• බ්‍රැඩ් බාර්කර් විසින් අහෝසි කළ හැකි වර්ග
• කීත් විසින් නිර්නාමික වර්ග
• __makeref __reftype __refvalueවිසින් ජුදා Himango
• Lomaxx විසින් වස්තු ආරම්භකයින්
• ඩැකෝටා හි ඩේවිඩ් විසින් නූල් හැඩගස්වන්න
• මාක්සිඩාඩ් විසින් දිගු කිරීමේ ක්‍රම
• partialජෝන් එරික්සන්ගේ ක්‍රම
• ජෝන් ඇස්බෙක්ගේ පූර්ව සැකසුම් නියෝග
• DEBUGපූර්ව ප්‍රොසෙසර් නියෝගය රොබට් ඩර්ජින් විසිනි
• ක්‍රියාකරු අධි බර පැටවීම SefBkn
• අනුමානය චක්‍රිට් මගින් ටයිප් කරන්න
• බූලියන් ක්‍රියාකරුවන් ඊළඟ මට්ටමට ගෙන යන්නේ රොබ් ගොෆ් විසිනි
• රෝමන් බොයිකෝ විසින් බොක්සිං නොමැතිව අතුරු මුහුණතක් ලෙස අගය වර්ගයේ විචල්‍යය සමත් කරන්න
• රෝමානු බොයිකෝ විසින් ප්‍රකාශිත විචල්‍ය වර්ගය ක්‍රමලේඛිකව තීරණය කරන්න
• ස්ථිතික ඉදිකිරීම්කරුවන් ක්‍රිස් විසිනි
• රෝස්ටෙරොනාසිඩ් විසින් LINQ භාවිතා කරමින් ඇස්වලට පහසුවෙන් / ensed නීභූත ORM සිතියම් ගත කිරීම
• __arglistවිසින් Zac පන්දු යැවීමේ

දෘශ්‍ය ස්ටුඩියෝ විශේෂාංග

• හිමාද්‍රි විසින් සංස්කාරකයේ පෙළ කොටස තෝරන්න
• විසින් කොටස්වලින් DannySmurf

රාමුව

• TransactionScopeවිසින් KiwiBastard
• DependantTransactionවිසින් KiwiBastard
• Nullable<T>විසින් IainMH
• Mutexවිසින් Diago
• System.IO.Pathවිසින් ageektrapped
• WeakReferenceවිසින් ජුවාන් මැනුවෙල්

ක්‍රම සහ ගුණාංග

• String.IsNullOrEmpty()කිවිබැස්ටාර්ඩ්ගේ ක්‍රමය
• List.ForEach()කිවිබැස්ටාර්ඩ්ගේ ක්‍රමය
• BeginInvoke(), විල් ඩීන් ගේEndInvoke() ක්‍රම
• Nullable<T>.HasValueසහ Nullable<T>.Valueදේපල රිස්මෝ විසිනි
• GetValueOrDefaultක්‍රමය ජෝන් ෂීහාන් විසිනි

ඉඟි සහ උපක්‍රම

• සිදුවීම් හසුරුවන්නන් සඳහා කදිම ක්‍රමයක් ඇන්ඩ්‍රියාස් එච්.ආර්. නිල්සන් විසිනි
• ඉහළ අකුරු සැසඳීම් ජෝන් විසිනි
• Dp මගින් පරාවර්තනයකින් තොරව නිර්නාමික වර්ග වෙත පිවිසෙන්න
• විල් විසින් එකතු කිරීමේ ගුණාංග කම්මැලි ලෙස ක්ෂණික කිරීමට ඉක්මන් ක්‍රමයක්
• ජාවාස්ක්‍රිප්ට් වැනි නිර්නාමික පේළිගත කිරීම්- රෝස්ටෙරොනාසිඩ් විසින්

වෙනත්

• විසින් netmodules kokos
• LINQBridge විසින් ඩන්කන් ස්මාර්ට්
• සමාන්තර දිගු විසින් ජොයෙල් Coehoorn

මෙය C # per se නොවේ, නමුත් System.IO.Path.Combine()ඔවුන් කළ යුතු ප්‍රමාණයට සැබවින්ම භාවිතා කරන කිසිවෙකු මා දැක නැත . ඇත්ත වශයෙන්ම, මුළු පාත් පන්තිය සැබවින්ම ප්රයෝජනවත් වේ, නමුත් කිසිවෙකු එය භාවිතා නොකරයි!

සෑම නිෂ්පාදන යෙදුමකටම පහත කේතය ඇති බව මම ඔට්ටු ඇල්ලීමට කැමැත්තෙමි.

string path = dir + "\\" + fileName;

lambdas සහ type inference අවතක්සේරු කර ඇත. ලැම්බඩාස්ට විවිධ ප්‍රකාශ තිබිය හැකි අතර ඒවා ස්වයංක්‍රීයව අනුකූල නියෝජිත වස්තුවක් මෙන් දෙගුණයක් වේ (අත්සන ගැලපෙන බවට වග බලා ගන්න):

Console.CancelKeyPress +=
    (sender, e) => {
        Console.WriteLine("CTRL+C detected!\n");
        e.Cancel = true;
    };

මා සතුව නැති බවත්, new CancellationEventHandlerමා හට වර්ග නියම කළ යුතු නැති senderබවත් e, ඒවා සිදුවීමෙන් නුසුදුසු බවත් සලකන්න. සමස්තයක් ලිවීමට මෙය අඩු කරදරකාරී වන්නේ එබැවිනි. delegate (blah blah)එමඟින් ඔබට පරාමිති වර්ග නියම කිරීමට අවශ්‍ය වේ.

ලැම්බඩාස්ට කිසිවක් ආපසු ලබා දීමට අවශ්‍ය නොවන අතර මේ ආකාරයේ සන්දර්භය තුළ අනුමාන කිරීම අතිශයින්ම බලවත්ය.

සහ BTW, ඔබට සෑම විටම ක්‍රියාකාරී ක්‍රමලේඛන අර්ථයෙන් ලැම්බඩාස් සාදන ලැම්බඩාස් ආපසු ලබා දිය හැකිය . උදාහරණයක් ලෙස, බොත්තමක් හසුරුවන ලැම්බඩා සාදන ලැම්බඩා මෙන්න. ක්ලික් කරන්න සිද්ධිය:

Func<int, int, EventHandler> makeHandler =
    (dx, dy) => (sender, e) => {
        var btn = (Button) sender;
        btn.Top += dy;
        btn.Left += dx;
    };

btnUp.Click += makeHandler(0, -1);
btnDown.Click += makeHandler(0, 1);
btnLeft.Click += makeHandler(-1, 0);
btnRight.Click += makeHandler(1, 0);

දම්වැල සටහන් කරන්න: (dx, dy) => (sender, e) =>

ක්‍රියාකාරී ක්‍රමලේඛන පන්තිය ගැනීමට ලැබීම ගැන දැන් මම සතුටු වෙමි :-)

සී හි දර්ශකයන් හැරුණු විට, ඔබ ඉගෙන ගත යුතු අනෙක් මූලික දෙය එය යැයි මම සිතමි :-)

රික් ස්ට්‍රාල් වෙතින් :

ඔබට දම්වැල දැමිය හැකිද ?? ක්‍රියාකරු එවිට ඔබට ශුන්‍ය සැසඳීම් රාශියක් කළ හැකිය.

string result = value1 ?? value2 ?? value3 ?? String.Empty;

අන්වර්ථ ජනක:

using ASimpleName = Dictionary<string, Dictionary<string, List<string>>>;

එය ASimpleNameවෙනුවට භාවිතා කිරීමට ඔබට ඉඩ සලසයිDictionary<string, Dictionary<string, List<string>>> .

ඔබ එකම සාමාන්‍ය විශාල දිගු සංකීර්ණ දේ බොහෝ ස්ථානවල භාවිතා කරන විට එය භාවිතා කරන්න.

සිට CLR C # හරහා :

නූල් සාමාන්‍යකරණය කිරීමේදී, ටොලර්වර් ඉන්වරියන්ට් වෙනුවට ටූපර්ඉන්වරියන්ට් භාවිතා කිරීම රෙකමදාරු කරනු ලැබේ .

සැසඳීමට පෙර මගේ සහායකයා සෑම විටම ලොකු අකුරට නූල් වෙනස් කළ බව මට මතකයි. ඔහු නිතරම එසේ කරන්නේ ඇයිදැයි මම නිතරම කල්පනා කර ඇත්තෙමි. පොත කියවීමෙන් පසු දැන් මම දන්නවා ඒ ඇයි කියලා.

මගේ ප්‍රියතම උපක්‍රමය නම් මා සඳහා එකතු කිරීම් ස්වයංක්‍රීයව ක්ෂණිකව ලබා දීම සඳහා ශුන්‍ය කොලෙස් ක්‍රියාකරු සහ වරහන් භාවිතා කිරීමයි .

private IList<Foo> _foo;

public IList<Foo> ListOfFoo 
    { get { return _foo ?? (_foo = new List<Foo>()); } }

ශුන්‍ය සිදුවීම් හසුරුවන්නන් පරීක්ෂා කිරීමෙන් වළකින්න

ප්‍රකාශනයේ දී සිදුවීම් සඳහා හිස් නියෝජිතයෙකු එකතු කිරීම, එය ඇමතීමට පෙර සෑම විටම එය ශුන්‍ය ලෙස පරික්ෂා කිරීමේ අවශ්‍යතාවය යටපත් කරයි. උදාහරණයක්:

public delegate void MyClickHandler(object sender, string myValue);
public event MyClickHandler Click = delegate {}; // add empty delegate!

ඔබට මෙය කිරීමට ඉඩ දෙන්න

public void DoSomething()
{
    Click(this, "foo");
}

මේ වෙනුවට

public void DoSomething()
{
    // Unnecessary!
    MyClickHandler click = Click;
    if (click != null) // Unnecessary! 
    {
        click(this, "foo");
    }
}

මේ බලන්න කරුණාකර ආශ්රිත සාකච්ඡා සහ මෙම බ්ලොග් මෙම මාතෘකාව මත එරික් Lippert විසින් (සහ හැකි අර්ථයක්).

අනෙක් සියල්ල, ප්ලස්

1) ව්‍යංග ජනකතා (ඇයි ක්‍රම මත මිස පන්ති මත නොවන්නේ?)

void GenericMethod<T>( T input ) { ... }

//Infer type, so
GenericMethod<int>(23); //You don't need the <>.
GenericMethod(23);      //Is enough.

2) එක් පරාමිතියක් සහිත සරල ලැම්බඩාස්:

x => x.ToString() //simplify so many calls

3) නිර්නාමික වර්ග සහ ආරම්භකයින්:

//Duck-typed: works with any .Add method.
var colours = new Dictionary<string, string> {
    { "red", "#ff0000" },
    { "green", "#00ff00" },
    { "blue", "#0000ff" }
};

int[] arrayOfInt = { 1, 2, 3, 4, 5 };

තවත් එකක්:

4) ස්වයංක්‍රීය ගුණාංගවලට විවිධ විෂය පථ තිබිය හැකිය:

public int MyId { get; private set; }

මට මතක් කිරීම ගැන @pzycoman ට ස්තූතියි:

5) නාම අවකාශ අන්වර්ථයන් (ඔබට මෙම විශේෂ වෙනස අවශ්‍ය වනු ඇති බව නොවේ):

using web = System.Web.UI.WebControls;
using win = System.Windows.Forms;

web::Control aWebControl = new web::Control();
win::Control aFormControl = new win::Control();

මම "ලෙස" යන මූලික පදය සෑහෙන කාලයක් දැන සිටියේ නැත.

MyClass myObject = (MyClass) obj;

එදිරිව

MyClass myObject = obj as MyClass;

පංතියේ කාස්ට් ව්‍යතිරේකයක් විසි කරනවාට වඩා, ඕබ් මයික්ලාස් නොවේ නම් දෙවැන්න ශුන්‍ය වේ.

මා කැමති කාරණා දෙකක් ස්වයංක්‍රීය ගුණාංග වන බැවින් ඔබට ඔබේ කේතය තව දුරටත් බිඳ දැමිය හැකිය:

private string _name;
public string Name
{
    get
    {
        return _name;
    }
    set
    {
        _name = value;
    }
}

බවට පත්වේ

public string Name { get; set;}

වස්තු ආරම්භකයින් ද:

Employee emp = new Employee();
emp.Name = "John Smith";
emp.StartDate = DateTime.Now();

බවට පත්වේ

Employee emp = new Employee {Name="John Smith", StartDate=DateTime.Now()}

සාමාන්‍ය වර්ගවල 'පෙරනිමි' යතුර:

T t = default(T);

එහි ප්‍රති results ලය වන්නේ T යනු යොමු වර්ගය නම් 0 ක් වන අතර 0 එය int නම්, එය බූලියන් නම් අසත්‍යය යනාදියයි.

පොදුවේ ගුණාංග, නමුත් බොහෝ විට DebuggerDisplay . ඔබේ වසර ඉතිරි කරයි.

@ සම්පාදකයාට පවසන්නේ නූලක ඇති ගැලවීමේ අක්ෂර නොසලකා හරින ලෙසයි.

මෙය පැහැදිලි කර ගැනීමට අවශ්‍යය ... එයින් ගැලවීමේ අක්ෂර නොසලකා හැරීමට එය නොකියයි, එය සැබවින්ම සම්පාදකයාට පවසන්නේ වචනාර්ථය ලෙස අර්ථ නිරූපණය කරන ලෙසයි.

ඔබට තිබේ නම්

string s = @"cat
             dog
             fish"

එය සැබවින්ම මුද්‍රණය කරනු ඇත (එයට ඉන්ඩෙන්ටේෂන් සඳහා භාවිතා කරන සුදු අවකාශය පවා ඇතුළත් බව සලකන්න):

cat
             dog
             fish

මම හිතන්නේ C # (.NET 3.5) හි වඩාත්ම අගය නොකරන ලද සහ එතරම් නොදන්නා අංගයක් වන්නේ ප්‍රකාශන ගස් ය , විශේෂයෙන් ජෙනරික්ස් සහ ලැම්බඩාස් සමඟ සංයෝජනය වූ විට ය. මෙය NInject සහ Moq වැනි නව පුස්තකාල භාවිතා කරන API නිර්මාණය සඳහා ප්‍රවේශයකි.

උදාහරණයක් ලෙස, මට API සමඟ ක්‍රමයක් ලියාපදිංචි කිරීමට අවශ්‍ය බවත් ඒපීඅයි ක්‍රමයේ නම ලබා ගැනීමට අවශ්‍ය බවත් කියමු

මෙම පන්තිය ලබා දී ඇත:

public class MyClass
{
     public void SomeMethod() { /* Do Something */ }
}

මීට පෙර, සංවර්ධකයින් මෙය නූල් සහ වර්ග වලින් (හෝ වෙනත් බොහෝ දුරට නූල් මත පදනම් වූ) කරන බව දැකීම සාමාන්‍ය දෙයක් විය:

RegisterMethod(typeof(MyClass), "SomeMethod");

හොඳයි, ශක්තිමත් යතුරු ලියනය කිරීමේ lack නතාවය නිසා එය උරා ගනී. මා "සමමෙතඩ්" ලෙස නම් කළහොත් කුමක් කළ යුතුද? කෙසේ වෙතත්, දැන් 3.5 දී, මට මෙය තදින් ටයිප් කළ ආකාරයකින් කළ හැකිය:

RegisterMethod<MyClass>(cl => cl.SomeMethod());

රෙජිස්ටර් ක්‍රම පංතිය මේ ආකාරයෙන් භාවිතා කරන Expression<Action<T>>:

void RegisterMethod<T>(Expression<Action<T>> action) where T : class
{
    var expression = (action.Body as MethodCallExpression);

    if (expression != null)
    {
        // TODO: Register method
        Console.WriteLine(expression.Method.Name);
    }
}

මම දැන් ලැම්බඩාස් සහ ප්‍රකාශන ගස් සමඟ ආදරයෙන් බැඳී සිටීමට මෙය එක් ප්‍රධාන හේතුවකි.

" අස්වැන්න " මගේ මතකයට එයි. [DefaultValue ()] වැනි සමහර ගුණාංග මගේ ප්‍රියතමයන් අතර වේ.

" Var " මූල පදය තව ටිකක් දන්නා නමුත් ඔබට එය .NET 2.0 යෙදුම්වලද භාවිතා කළ හැකිය (ඔබ .NET 3.5 සම්පාදකය භාවිතා කර එය 2.0 කේතයට ප්‍රතිදානය කරන තාක් කල් ) එතරම් ප්‍රසිද්ධ නැති බව පෙනේ. හොඳින්.

සංස්කරණය කරන්න: කොකොස්, පෙන්වා දීමට ස්තූතියි ?? ක්‍රියාකරු, එය ඇත්තෙන්ම ප්‍රයෝජනවත්. ඒ සඳහා ගූගල් කිරීම තරමක් අපහසු බැවින් (?? දැන් නොසලකා හැර ඇති පරිදි), මෙන්න එම ක්‍රියාකරු සඳහා MSDN ප්‍රලේඛන පිටුව: ?? ක්රියාකරු (C # යොමුව)

බොහෝ C # සංවර්ධකයින් 'අහෝසි කළ හැකි' වර්ග ගැන නොදන්නා බව මම සොයා ගතිමි. මූලික වශයෙන්, ශුන්‍ය අගයක් තිබිය හැකි ප්‍රාථමිකයන්.

double? num1 = null; 
double num2 = num1 ?? -100;

එය nullable ද්විත්ව, සකසන්න num1 , ශුන්ය කිරීමට, එවකට නිත්ය ද්විත්ව, සකස් num2 වෙත num1 හෝ -100 නම් num1 ශූන්ය විය.

http://msdn.microsoft.com/en-us/library/1t3y8s4s(VS.80).aspx

නුසුදුසු වර්ගය ගැන තවත් එක් දෙයක්:

DateTime? tmp = new DateTime();
tmp = null;
return tmp.ToString();

එය ආපසු නූල් වේ. වැඩි විස්තර සඳහා මෙම සබැඳිය පරීක්ෂා කරන්න

ලේඛනගත නොකළ C # මූල පද ස්වරූපයෙන් සැඟවුණු C # විශේෂාංග කිහිපයක් මෙන්න:

__makeref

__reftype

__refvalue

__arglist

මේවා ලේඛනගත නොකළ C # මූල පද (දෘශ්‍ය ස්ටුඩියෝ පවා ඒවා හඳුනා ගනී!) ජනක විද්‍යාවට පෙර වඩාත් කාර්යක්ෂම බොක්සිං / බොක්සිං සඳහා එකතු කරන ලදී. ඒවා System.TypedReference struct සමඟ සම්බන්ධීකරණයෙන් ක්‍රියා කරයි.

විචල්ය දිග පරාමිති ලැයිස්තු සඳහා භාවිතා කරන __arglist ද ඇත.

බොහෝ දෙනා නොදන්නා එක් දෙයක් වන්නේ System.WeakReference - ඉතා ප්‍රයෝජනවත් පන්තියක් වන අතර එය වස්තුවක් පිළිබඳව සොයා බලන නමුත් කසළ එකතු කරන්නාට එය එකතු කිරීමට ඉඩ දෙයි.

වඩාත්ම ප්‍රයෝජනවත් "සැඟවුණු" ලක්ෂණය වනුයේ අස්වැන්න ආපසු ලබා දෙන යතුරයි. එය සැබවින්ම සැඟවී නැත, නමුත් බොහෝ දෙනෙක් ඒ ගැන නොදනිති. මේ මත ලින්ක් ඉදිකර ඇත; එය හුඩ් යටතේ රාජ්‍ය යන්ත්‍රයක් ජනනය කිරීමෙන් ප්‍රමාදයෙන් ක්‍රියාත්මක කළ විමසුම් සඳහා ඉඩ ලබා දේ. රේමන්ඩ් චෙන් මෑතකදී අභ්‍යන්තර, අමිහිරි තොරතුරු ගැන පළ කළේය .

පිරිසිදු, ආරක්ෂිත C # වලින් වෘත්තීය සමිති (C ++ හවුල් මතක වර්ගය)

අනාරක්ෂිත මාදිලිය සහ දර්ශකයන් වෙත යොමුවීමකින් තොරව, ඔබට පන්ති සාමාජිකයින්ට පන්තියේ / ව්‍යුහයක මතක අවකාශය බෙදා ගත හැකිය. පහත පන්තිය ලබා දී ඇත:

[StructLayout(LayoutKind.Explicit)]
public class A
{
    [FieldOffset(0)]
    public byte One;

    [FieldOffset(1)]
    public byte Two;

    [FieldOffset(2)]
    public byte Three;

    [FieldOffset(3)]
    public byte Four;

    [FieldOffset(0)]
    public int Int32;
}

Int32 ක්ෂේත්‍රය හැසිරවීමෙන් ඔබට බයිට් ක්ෂේත්‍රවල අගයන් වෙනස් කළ හැකිය. උදාහරණයක් ලෙස, මෙම වැඩසටහන:

    static void Main(string[] args)
    {
        A a = new A { Int32 = int.MaxValue };

        Console.WriteLine(a.Int32);
        Console.WriteLine("{0:X} {1:X} {2:X} {3:X}", a.One, a.Two, a.Three, a.Four);

        a.Four = 0;
        a.Three = 0;
        Console.WriteLine(a.Int32);
    }

මෙය ප්‍රතිදානය කරයි:

2147483647
FF FF FF 7F
65535

System.Runtime.InteropServices භාවිතයෙන් එක් කරන්න;

මූල පද වන විචල්ය නම් සඳහා @ භාවිතා කිරීම.

var @object = new object();
var @string = "";
var @if = IpsoFacto(); 

අවසාන වශයෙන් වාරණයන් හෝ අවසන් කරන්නන් ඇමතීමෙන් තොරව ඔබේ වැඩසටහනෙන් පිටවීමට ඔබට අවශ්‍ය නම් FailFast භාවිතා කරන්න :

Environment.FailFast()

ක්‍රමයකින් නිර්නාමික වර්ග නැවත ලබා දීම සහ පරාවර්තනයකින් තොරව සාමාජිකයින්ට ප්‍රවේශ වීම.

// Useful? probably not.
private void foo()
{
    var user = AnonCast(GetUserTuple(), new { Name = default(string), Badges = default(int) });
    Console.WriteLine("Name: {0} Badges: {1}", user.Name, user.Badges);
}

object GetUserTuple()
{
    return new { Name = "dp", Badges = 5 };
}    

// Using the magic of Type Inference...
static T AnonCast<T>(object obj, T t)
{
   return (T) obj;
}

සාමාන්‍ය ප්‍රකාශන සහ ගොනු මාර්ග සඳහා මෙන්න ප්‍රයෝජනවත් එකක්:

"c:\\program files\\oldway"
@"c:\program file\newway"

@ සම්පාදකයාට පවසන්නේ නූලක ඇති ගැලවීමේ අක්ෂර නොසලකා හරින ලෙසයි.

මික්සින්. මූලික වශයෙන්, ඔබට පන්ති කිහිපයකට අංගයක් එක් කිරීමට අවශ්‍ය නම්, නමුත් ඒ සියල්ලටම එක් මූලික පන්තියක් භාවිතා කළ නොහැකි නම්, එක් එක් පන්තියට අතුරු මුහුණතක් ක්‍රියාත්මක කිරීමට ලබා ගන්න (සාමාජිකයන් නොමැතිව). ඉන්පසු, අතුරු මුහුණත සඳහා දිගු කිරීමේ ක්‍රමයක් ලියන්න , එනම්

public static DeepCopy(this IPrototype p) { ... }

ඇත්ත වශයෙන්ම, යම් පැහැදිලි කිරීමක් කැප කර ඇත. නමුත් එය ක්රියා කරයි!

කිසිවෙකු කවදාවත් Nullable <bool> භාවිතා කිරීමට කැමති ඇයිදැයි විශ්වාස නැත. :-)

ඇත්ත, අසත්‍ය, FileNotFound ?

මෙය වැරදි ලෙස නම් කර ඇති තරමට "සැඟවී" නැත.

"සිතියම", "අඩු කිරීම" සහ "පෙරණය" යන ඇල්ගොරිතම කෙරෙහි වැඩි අවධානයක් යොමු කෙරේ. බොහෝ දෙනා නොදන්නා දෙය නම් .නෙට් 3.5 මෙම ඇල්ගොරිතම තුනම එකතු කළ නමුත් එය ඔවුන්ට ලින්ක් හි කොටසක් යන කාරණය මත පදනම්ව ඔවුන්ට SQL-ish නම් ලබා දී ඇත.

"map" =>
දත්ත එක් ආකාරයකින් තවත් ආකාරයකට පරිවර්තනය කිරීම තෝරන්න

"අඩු කරන්න" =>
සමස්ථ අගයන් තනි ප්‍රති .ලයකට එකතු කරයි

"filter" =>
නිර්ණායකයක් මත දත්ත පෙරහන් කරන තැන

පුනරාවර්තනය සහ කොන්දේසි ලබා ගැනීමට භාවිතා කළ එකතු කිරීම් සඳහා පේළිගත වැඩ කිරීමට ලින්ක් භාවිතා කිරීමේ හැකියාව ඇදහිය නොහැකි තරම් වටිනා ය. සියලුම ලින්ක් දිගු කිරීමේ ක්‍රම මඟින් ඔබේ කේතය වඩාත් සංයුක්ත හා නඩත්තු කළ හැකි අයුරු ඉගෙන ගැනීම වටී.

Environment.NewLine

පද්ධති ස්වාධීන නව රේඛා සඳහා.

ඔබ සංගීත භාණ්ඩයක් තුළ කැරලි වරහන් භාවිතා කිරීමට උත්සාහ කරන්නේ නම්.

int foo = 3;
string bar = "blind mice";
String.Format("{{I am in brackets!}} {0} {1}", foo, bar);
//Outputs "{I am in brackets!} 3 blind mice"

1. ?? - සමතුලිත ක්‍රියාකරු
2. භාවිතා කිරීම ( ප්‍රකාශය / විධානය ) - විසුරුවා හැරීම ඇමතීමට වඩා භාවිතා කළ හැකි විශිෂ්ට වචන පදය
3. readonly - වැඩිපුර භාවිතා කළ යුතුය
4. netmodules - ඉතා නරකයි Visual Studio හි කිසිදු සහායක් නොමැත

D එඩ්, මම මෙය පළ කිරීම ගැන ටිකක් පසුබට වෙමි. කෙසේ වෙතත්, මම ඔබේ කේත සාම්පලයේ එය පෙන්වා දෙමි:

MyClass c;
  if (obj is MyClass)
    c = obj as MyClass

ඔබ 'is' භාවිතා කිරීමට යන්නේ නම්, 'as' භාවිතා කරමින් ආරක්ෂිත වාත්තු කිරීමක් සමඟ එය අනුගමනය කරන්නේ ඇයි? ඔබ ඇත්ත වශයෙන්ම මයික්ලාස් බව තහවුරු කර ඇත්නම්, ව්‍යාජ සම්මත වාත්තු:

c = (MyClass)obj

... කිසි විටෙකත් අසාර්ථක නොවනු ඇත.

ඒ හා සමානව, ඔබට මෙසේ පැවසිය හැකිය:

MyClass c = obj as MyClass;
if(c != null)
{
   ...
}

.NET හි අභ්‍යන්තරය ගැන මට ප්‍රමාණවත් දැනුමක් නැත, නමුත් මගේ සහජ බුද්ධිය මට පවසන්නේ මෙය උපරිම ආකාරයේ වර්ග දෙකක මෙහෙයුම් උපරිම එකක් දක්වා අඩු කරන බවයි. සැකසුම් බැංකුව දෙයාකාරයෙන්ම බිඳ දැමිය නොහැක. පුද්ගලිකව, මම හිතන්නේ අවසාන ස්වරූපය ද පිරිසිදු බව පෙනේ.

සමහර විට දියුණු තාක්ෂණයක් නොව, මා නිතරම පිස්සු වට්ටවන දෙයක් මා දකිනවා:

if (x == 1)
{
   x = 2;
}
else
{
   x = 3;
}

ensed නීභවනය කළ හැක්කේ:

x = (x==1) ? 2 : 3;