Syntax

Ang parehong mga wika ay gumagamit ng C programming language bilang isang syntactic na batayan Sa partikular, minana nila ito nang walang mga pagbabago.

• pagmamarka ng simula/pagtatapos ng isang bloke ng code na may mga kulot na braces;
• notasyon, pagkakaugnay at precedence ng karamihan sa mga built-in na operasyon (assignment, arithmetic, logical, bitwise, increment/decrement operations, ternary conditional operator " ?: »);
• syntax para sa paglalarawan at paggamit ng mga variable at function (order ng "type name", paggamit ng mga modifier, mandatory parentheses para sa mga function, paglalarawan ng mga pormal na parameter);
• syntax ng lahat ng pangunahing constructions: conditional operator, loops, multiple choice operator;
• kakulangan ng mga pamamaraan (pinapalitan sila ng mga pag-andar ng uri ng walang bisa);
• mga pangalan ng mga built-in na uri ng elementarya (maliban sa bool, sa Java ang ganitong uri ay tinatawag na boolean);
• gamit ang semicolon
• ... at maraming mas maliliit na feature.

Ang lahat ng ito ay humahantong sa katotohanan na ang mga programa sa Java at C# sa unang sulyap ay mukhang lubos na katulad sa mga programang C. Ang parehong mga wika ay gumawa ng magkatulad na mga extension at pagdaragdag sa C (o C++), sa partikular, ang alpabeto ay pinalawak at ang kanilang sariling syntax ay ipinakilala na sumusuporta sa mga pakete, pag-import ng mga paglalarawan, at pagtukoy ng mga yunit ng compilation.

Mayroon ding maraming pagkakaiba sa syntactic.

Syntax	Java	C#
Pag-import ng mga static na pangalan (static na import)	nagbibigay-daan sa iyong hiwalay na mag-import ng ilan o lahat ng mga static na pamamaraan at variable ng isang klase at gamitin ang kanilang mga pangalan nang walang kwalipikasyon sa module ng pag-import	Ang pagpupulong lamang ang na-import at sa bawat oras na gumamit ka ng mga na-import na static na pangalan ay dapat mong tukuyin ang klase
Mga Constant sa pahayag ng switch	ay dapat na alinman sa isang integer o isang uri ng enum (sa 1.7, ang mga string literal ay idinagdag sa listahan ng mga uri)	maaari kang gumamit ng mga string ng teksto
goto operator	sadyang inabandona nila ang paggamit ng goto, gayunpaman, mayroong isang mekanismo na nagpapahintulot sa iyo na lumabas sa panlabas na loop mula sa isang nested sa pamamagitan ng pagmamarka nito ng isang label at paggamit ng break at magpatuloy sa mga operator kasama ang label (magpatuloy<метка>;)	Nakaligtas si goto, ang karaniwang paggamit nito ay ang pagpasa ng kontrol sa iba't ibang mga label ng case sa isang switch statement at paglabas sa isang nested loop
Mga Constant	Walang mga pare-pareho; sa halip, ang mga static na variable ng klase na may panghuling modifier ang ginagamit - ang epekto ng kanilang paggamit ay eksaktong pareho	ang hiwalay na konsepto ng isang pinangalanang typed constant at ang const na keyword
Katumpakan ng floating point	Kasama sa Java ang isang strictfp construct na ginagarantiyahan ang parehong mga resulta ng floating-point sa lahat ng platform.	Ang C# ay umaasa sa pagpapatupad, walang garantiya ng mahigpit na magkaparehong resulta ng pagkalkula.
Hindi pagpapagana ng mga tseke	Sa Java, lahat ng mga dynamic na pagsusuri ay pinagana/naka-disable lamang sa antas ng package	Ang C# ay naglalaman ng mga naka-check at hindi naka-check na construct na nagbibigay-daan sa iyong lokal na paganahin o huwag paganahin ang dynamic na arithmetic overflow checking.

Sa pangkalahatan, ang syntax ng C# ay medyo mas malawak at mas mayaman kaysa sa Java sa partikular, naglalaman ito ng mga tampok tulad ng kakayahang hatiin ang paglalarawan ng isang klase sa ilang mga module, ang paglalarawan ng mga katangian, at ang kakayahang kontrolin ang virtuality ng; pamamaraan.

Mekanismo para sa pagtatrabaho sa dynamic na data at pagkolekta ng basura

Ang parehong mga wika ay nagpapatupad ng parehong modelo para sa pagtatrabaho sa dynamic na data: ang mga bagay ay dynamic na nilikha gamit ang bagong konstruksyon, ang runtime ay sinusubaybayan ang pagkakaroon ng mga sanggunian sa kanila, at ang kolektor ng basura ay pana-panahong nililimas ang memorya ng mga bagay na walang mga sanggunian. Upang ma-optimize ang pagkolekta ng basura, ang mga pagtutukoy ng mga wika at runtime na kapaligiran ay hindi naglalaman ng mga paghihigpit sa buhay ng isang bagay pagkatapos matanggal ang huling sanggunian dito - ang kolektor ay nagpapatakbo nang nakapag-iisa sa pagpapatupad ng programa, kaya ang aktwal na pagkasira ng bagay ay maaaring mangyari anumang oras pagkatapos matanggal ang huling sanggunian hanggang sa matapos ang programa. Sa katotohanan, ang mga tagakolekta ng basura ay nag-optimize ng pagpapatupad upang matiyak ang katanggap-tanggap na pagkonsumo ng memorya habang pinapaliit ang pagbagal ng programa.

Ang C# (mas tiyak, ang karaniwang runtime ng wika) ay nagbibigay-daan sa iyo na sugpuin ang pagpapatupad ng finalizer sa isang partikular na bagay gamit ang GC.SuppressFinalize(obj) na paraan (hal., isang SQL na koneksyon sa isang file stream). Ito ay maaaring maging kapaki-pakinabang dahil ang pag-finalize ay itinuturing na medyo mahal na operasyon sa koleksyon ng basura, at ang isang bagay na may finalizer ay mabubuhay nang mas matagal.

Mga Tool sa Bagay

Mga uri ng enum

Sa Java, mahigpit na pagsasalita, ang mga one-dimensional na array lang ang maaaring ideklara. Ang isang multidimensional na array sa Java ay isang array ng mga array. Ang C# ay may parehong tunay na multidimensional array at arrays ng arrays, na sa C# ay karaniwang tinatawag na "jagged" arrays. Multidimensional na mga array ay palaging "parihaba" (nagsasalita sa dalawang-dimensional na terminolohiya), habang ang mga array ng mga array ay maaaring mag-imbak ng mga string ng iba't ibang haba (muli sa dalawang-dimensional na kaso, katulad din sa multi-dimensional na kaso). Ang mga multidimensional na array ay nagpapabilis ng pag-access sa memory (kung saan ang pointer ay isang beses lang na-dereference), habang ang mga jagged array ay mas mabagal ngunit nakakatipid ng memory kapag hindi lahat ng mga row ay puno. Ang mga multidimensional na array ay nangangailangan lamang ng isang tawag upang makalikha bago ang operator, at ang mga staggered ay nangangailangan ng tahasang paglalaan ng memory sa isang loop para sa bawat linya.

Parameterized (generic) na mga uri

Sa parehong mga wika, maaaring i-parameter ang mga uri, na sumusuporta sa generic na paradigm sa programming. Sa syntactically, ang kahulugan ng mga uri ay medyo malapit - sa parehong mga wika ay minana ito mula sa mga template ng C++, kahit na may ilang mga pagbabago.

Ang mga generic na uri sa Java ay puro isang construct ng wika at ipinapatupad lamang sa compiler. Pinapalitan ng compiler ang lahat ng generic na uri ng kanilang upper bounds at naglalagay ng mga naaangkop na uri ng cast saanman ginagamit ang isang parameterized na uri. Ang resulta ay bytecode na hindi naglalaman ng mga sanggunian sa mga generic na uri at ang kanilang mga parameter. Ang pamamaraan na ito para sa pagpapatupad ng mga generic na uri ay tinatawag uri ng pagbura(type erasure). Nangangahulugan ito na ang impormasyon tungkol sa mga orihinal na generic na uri ay hindi magagamit sa runtime, at nagpapataw ng ilang mga limitasyon, tulad ng kawalan ng kakayahang lumikha ng mga bagong array instance mula sa mga generic na uri ng argumento. Miyerkules Java execution Hindi ako pamilyar sa generic na uri ng system, kaya naman ang mga bagong pagpapatupad ng JVM ay nangangailangan lamang ng kaunting mga update upang gumana sa bagong format ng klase.

Nagpunta ang C# sa ibang ruta. Ang pangkalahatang suporta ay isinama sa virtual na kapaligiran execution, unang lumabas sa .NET 2.0. Ang wika dito ay naging isang panlabas na interface lamang para sa pag-access sa mga kakayahan ng kapaligiran. Tulad ng sa Java, ang compiler ay nagsasagawa ng static type checking, ngunit bilang karagdagan dito, ang JIT ay nagsasagawa ng load-time correctness checking. Ang impormasyon tungkol sa mga generic na uri ay ganap na naroroon sa runtime at nagbibigay-daan sa buong suporta para sa pagmuni-muni ng mga generic na uri at ang paglikha ng mga bagong pagpapatupad ng mga ito.

Ang diskarte sa Java ay nangangailangan karagdagang mga tseke sa runtime, hindi ginagarantiyahan na susundin ng code client ang uri ng sulat, at hindi nagbibigay ng pagmuni-muni para sa mga generic na uri. Hindi pinapayagan ng Java ang mga generic na uri na maging dalubhasa sa mga primitive na uri (magagawa lamang ito sa pamamagitan ng pagbabalot mga primitive na uri sa mga klase), habang ang C# ay nagbibigay ng generalization para sa parehong mga uri ng sanggunian at halaga, kabilang ang mga primitive. Sa halip, iminumungkahi ng Java ang paggamit ng mga nakabalot na primitive na uri bilang mga parameter (hal. List sa halip na Listahan ), ngunit dumating ito sa halaga ng karagdagang dynamic na paglalaan ng memorya. Sa parehong Java at C#, ang mga generic na uri ng espesyalisasyon sa iba't ibang uri ng sanggunian ay gumagawa ng parehong code, ngunit para sa C#, ang runtime ay dynamic na bumubuo ng naka-optimize na code kapag nag-specialize sa mga uri ng halaga (halimbawa, List ), na nagpapahintulot sa mga ito na maimbak at maalis mula sa mga lalagyan nang walang paglo-load at pag-unroll ng mga operasyon.

Pangangasiwa ng Kaganapan

Kinakailangan ng Java ang programmer na manu-manong ipatupad ang pattern ng tagamasid, bagama't nagbibigay ito ng ilang syntactic na asukal sa anyo ng mga hindi kilalang nested na klase, na nagbibigay-daan sa iyong tukuyin ang katawan ng isang klase at agad itong i-instantiate sa isang punto sa code.

Nagbibigay ang C# ng malawak na suporta sa antas ng wika para sa pagprograma ng kaganapan, kabilang ang mga delegado ng .NET, multicasting, espesyal na syntax para sa pagtatakda ng mga kaganapan sa mga klase, mga operasyon para sa pagpaparehistro at pag-unregister ng mga tagapangasiwa ng kaganapan, delegate covariance, at mga hindi kilalang pamamaraan na may ganap na pagsasara ng mga semantika.

Ang mga pagsasara ay iminungkahi para sa pagsasama sa Java SE 8. Ang mga pagsasara na ito, tulad ng mga delegado sa C#, ay magkakaroon ganap na pag-access sa lahat ng lokal na variable sa isang naibigay na saklaw, sa halip na basahin lamang ang access sa mga variable na minarkahang pangwakas (tulad ng sa mga hindi kilalang nested na klase).

Overload ng operasyon

Mga Katangian

Sinusuportahan ng C# ang konsepto ng "properties" - mga pseudo-field ng isang klase na naa-access sa ganap na kontroladong paraan sa pamamagitan ng paglikha ng mga pamamaraan upang makuha at isulat ang halaga ng field. Ang mga deklarasyon ng ari-arian ay ginawa gamit ang get at set constructs.

Kasama rin sa C# ang isang bagay na tinatawag mga taga-index, na maaaring ituring na isang espesyal na kaso ng overloading ng operator (katulad ng overloading ng operator sa C++), o mga katangian ng parameter. Ang isang indexer ay isang property na pinangalanang ito na maaaring magkaroon ng isa o higit pang mga parameter (mga index), at ang mga index ay maaaring maging anumang uri. Nagbibigay-daan ito sa iyo na lumikha ng mga klase na ang mga pagkakataon ay kumikilos tulad ng mga array:

MyList[ 4 ] = 5 ;

pangalan ng string = xmlNode. Mga Katangian["pangalan"];

“Personal, hindi ko gusto ang mga pag-aari, at magiging masaya ako kung ang suporta para sa mga ito ay aalisin mula sa Microsoft .NET Framework at mga kaugnay na programming language. Ang dahilan ay ang mga pag-aari ay mukhang mga patlang ngunit sa katunayan ay mga pamamaraan."

Kasunod ng karaniwang istilo ng pagbibigay ng pangalan sa C#, ang mga pangalan ng ari-arian ay nakikitang nakikilala mula sa mga pangalan ng field dahil nagsisimula ang mga ito sa malaking titik.

Kondisyon na compilation

Ang C#, hindi tulad ng Java, ay sumusuporta sa conditional compilation gamit ang preprocessor directives. Mayroon din itong Conditional attribute, na nangangahulugan na ang tinukoy na paraan ay tinatawag lamang kapag ang ibinigay na compilation constant ay tinukoy. Sa ganitong paraan, maaari mong ipasok sa code, halimbawa, mga pagsusuri sa assertion, na gagana lamang sa bersyon ng pag-debug kapag ang DEBUG constant ay tinukoy. Sa .NET standard library, ito ang Debug.Assert() method.

Mga bersyon ng Java 1.4 at mas bago isama ang isang runtime na kakayahan para sa pagpapalagay ng pagsusuri sa wika. Bilang karagdagan, kung ang mga konstruksyon na may pare-parehong mga kondisyon ay maaaring mapalawak sa oras ng pag-compile. May mga third-party na pagpapatupad ng mga preprocessor para sa Java, ang mga ito ay pangunahing ginagamit kapag bumubuo ng mga application para sa mga mobile device.

Mga namespace, assemblies, packages

Gumagamit ang C# mga namespace(namespace), nakapagpapaalaala sa C++ na mekanismo ng parehong pangalan. Ang bawat klase ay kabilang sa isang namespace ang mga klase kung saan ang namespace ay hindi tahasang tinukoy ay nabibilang sa hindi pinangalanang namespace bilang default. Maaaring ilagay ang mga namespace sa bawat isa.

mayroon ang Java mga pakete, medyo katulad sa mga namespace ng C#. Ang mga pakete ay maaaring ma-nest, ang bawat inilarawan na klase ay kabilang sa isang partikular na pakete sa kawalan ng isang tahasang indikasyon ng pakete, ang klase ay kabilang sa isang pandaigdigang hindi pinangalanang pakete.

Sa parehong wika, upang ma-access ang isang bagay na idineklara sa ibang namespace o package, dapat mong ideklara ang kinakailangang package (namespace) sa program bilang ginagamit. Ang isang bagay ay na-access sa pamamagitan ng isang kwalipikadong pangalan; ang pangalan ng package (namespace) ay ginagamit bilang isang qualifier. Kung ang pag-access sa isang bagay na walang kwalipikasyon ay kinakailangan, ang module ng programa ay dapat maglaman ng isang dereference na direktiba: gamit sa C# at import sa Java.

Sa C#, hindi nauugnay ang mga namespace sa anumang paraan sa mga pinagsama-samang module (assemblies, o assembly sa terminolohiya ng Microsoft). Maaaring maglaman ng parehong namespace ang maramihang mga assemblies, at maaaring magdeklara ang isang assembly ng maraming namespaces, hindi kinakailangang naka-nest. Ang mga modifier ng saklaw ng C# ay walang kinalaman sa mga namespace. Sa Java, ang mga klase na idineklara sa parehong pakete bilang default ay bumubuo ng isang pinagsama-samang module. Nililimitahan ng default na scope modifier (walang tahasang detalye) ang saklaw ng mga field at pamamaraan ng isang klase sa mga hangganan ng package.

Sa Java, ang istraktura ng mga file at mga direktoryo ng source code ng isang package ay bilang default na nauugnay sa istraktura ng package - ang isang pakete ay tumutugma sa isang direktoryo, mga subpackage na kasama dito - mga subdirectory ng direktoryo na ito, ang mga source file ay matatagpuan sa mga direktoryo naaayon sa pakete o subpackage kung saan kasama ang mga ito. Kaya, ang pinagmulang puno ay sumusunod sa istraktura ng pakete. Sa C#, ang lokasyon ng file na may orihinal na teksto walang kinalaman sa namespace nito.

Lokasyon ng source text sa mga file

Sa C#, ang mga klase ay maaaring matatagpuan sa mga file sa anumang paraan. Ang pangalan ng source code file ay walang kinalaman sa mga pangalan ng mga klase na tinukoy dito. Pinapayagan na maglagay ng ilang pampublikong klase sa isang file. Dahil ang bersyon 2.0, pinapayagan ka rin ng C# na hatiin ang isang klase sa dalawa o higit pang mga file (ang bahagyang keyword). Ang huling tampok ay aktibong ginagamit ng mga visual na tool para sa pagbuo ng isang interface: ang bahagi ng klase na naglalaman ng mga patlang at mga pamamaraan na kinokontrol ng tagabuo ng interface ay naka-highlight sa hiwalay na file, upang hindi makalat ang file na direktang na-edit ng programmer na may awtomatikong nabuong code.

Sa Java, ang bawat file ay maaaring maglaman lamang ng isang pampublikong klase, at hinihiling ng Java na ang pangalan ng file ay kapareho ng pangalan ng klase na iyon, na nag-aalis ng kalituhan sa pagitan ng mga pangalan ng file at klase. Bukod dito, ayon sa inirekomendang coding convention ng Sun, ang laki ng source code file ay hindi dapat lumampas sa 2000 linya ng code, dahil ang mas malaking file ay mas mahirap i-parse. Malaking sukat Ang file ay itinuturing din na tanda ng hindi magandang desisyon sa disenyo.

Mga pagbubukod

Ang parehong mga wika ay sumusuporta sa isang exception handling na mekanismo, syntactically dinisenyo sa eksaktong parehong paraan: ang wika ay may exception generation operator itapon at exception handling block subukan()huli()()sa wakas(), na nagsisiguro ng pagharang ng mga pagbubukod na nangyayari sa loob ng isang bloke, ang pagpoproseso ng mga ito, at ang garantisadong pagpapatupad ng mga huling aksyon.

Sinusuportahan ng Java ang mga naka-check na eksepsiyon: dapat na tahasang tukuyin ng programmer para sa bawat pamamaraan ang mga uri ng mga eksepsiyon na maaaring ihagis ng pamamaraan, ang mga uri na ito ay nakalista sa deklarasyon ng pamamaraan pagkatapos ng mga throws na keyword. Kung ang isang pamamaraan ay gumagamit ng mga pamamaraan na nagtatapon ng mga may check na eksepsiyon, dapat na tahasan nitong mahuli ang lahat ng mga pagbubukod na iyon o maglaman ng mga ito sa sarili nitong deklarasyon. Kaya, ang code ay tahasang naglalaman ng isang listahan ng mga pagbubukod na maaaring ihagis ng bawat pamamaraan. Ang hierarchy ng mga uri ng exception ay naglalaman din ng dalawang uri (RuntimeException at Error), na ang mga inapo ay hindi naka-check at hindi dapat ilarawan. Ang mga ito ay nakalaan para sa mga runtime exception na maaaring mangyari kahit saan o hindi karaniwang mapangasiwaan ng programmer (gaya ng mga error sa runtime), at hindi dapat tukuyin sa isang throws declaration.

Hindi sinusuportahan ng C# ang mga naka-check na exception. Ang kanilang kawalan ay isang sadyang pagpili ng mga developer. Si Anders Hejlsberg, ang punong arkitekto ng C#, ay naniniwala na sa Java sila ay isang eksperimento at hindi binibigyang-katwiran ang kanilang sarili.

Parallel programming

Sa pangkalahatan, ang mga parallel na mekanismo ng programming sa C# ay katulad ng ibinigay ng Java, ang pagkakaiba ay nasa mga detalye ng pagpapatupad. Sa parehong mga kaso, mayroong isang library class na Thread na nagpapatupad ng konsepto ng isang "thread". Nagbibigay ang Java ng dalawang paraan upang lumikha ng sarili mong mga thread: alinman sa pamamagitan ng pagpapalawak ng klase ng Thread o sa pamamagitan ng pagpapatupad ng Runnable na interface. Sa parehong mga kaso, ang programmer ay dapat tukuyin ang isang minana (kasama sa interface) na pamamaraan run() na naglalaman ng katawan ng thread - ang code na ipapatupad dito. Sa halip ay ginagamit ng C# ang mekanismo ng delegado: upang lumikha ng isang thread, isang halimbawa ng karaniwang klase ng Thread ay nilikha, kung saan ang isang delegado na naglalaman ng isang pamamaraan - ang katawan ng thread - ay ipinasa bilang isang parameter ng constructor.

Ang parehong mga wika ay may kakayahang lumikha ng isang sabay-sabay na pinaandar na bloke ng code; sa Java ito ay ginagawa gamit ang synchronized() operator, sa C# - gamit ang lock() operator. Pinapayagan ka rin ng Java na magdeklara ng mga kasabay na pamamaraan gamit ang naka-synchronize na modifier sa header ng deklarasyon ng pamamaraan. Ang ganitong mga pamamaraan, kapag naisakatuparan, hinaharangan ang object ng kanilang may-ari (kaya, sa mga naka-synchronize na pamamaraan ng klase, para sa parehong halimbawa, isa lamang ang maaaring maisakatuparan sa isang pagkakataon, ang iba ay maghihintay). Ang isang katulad na tampok sa .NET ay ibinigay ng MethodImplAttribute MethodImplOptions.Synchronized method na katangian ng pagpapatupad, ngunit hindi katulad ng Java, ang tampok na ito ay hindi pormal na bahagi ng C# na wika.

Ang parehong mga wika ay nagbibigay din ng magkaparehong mga pasilidad sa pag-synchronize batay sa pagpapadala at paghihintay ng signal mula sa isang thread patungo sa isa pa. Sa Java ito ang mga pamamaraang notify(), notifyAll() at wait(), sa C# ito ang mga pamamaraang Pulse(), PulseAll(), Wait() (ang tatlong pamamaraan ay magkapareho sa pagganap sa mga pares). Ang pagkakaiba lamang ay sa Java ang mga pamamaraang ito (at, nang naaayon, ang pag-andar ng monitor) ay ipinatupad sa klase ng Object, kaya walang karagdagang mga aklatan ang kinakailangan para sa pag-synchronize, at sa C# ang mga pamamaraang ito ay ipinatupad bilang mga static na pamamaraan sa isang hiwalay na klase ng library Monitor . Sa C#, ang karaniwang aklatan ay naglalaman din ng ilang karagdagang mga primitive sa pag-synchronize para sa parallel na pagpapatupad ng mga thread: mutexes, semaphores, synchronizing timers. Mula noong bersyon 1.5, isinama ng JDK SE ang java.util.concurrent, java.util.concurrent.atomic at java.util.concurrent.locks na mga pakete na naglalaman ng komprehensibong hanay ng mga tool para sa pagpapatupad ng parallel computing.

Mababang antas ng code

Sa ngayon, walang bahagi Mga kapaligiran sa Java hindi standardized ng Ecma, ISO, ANSI o anumang iba pa ikatlong partido mga pamantayan. Habang ang Sun Microsystems ay nagpapanatili ng hindi pinaghihigpitan, eksklusibong mga legal na karapatan upang baguhin at bigyan ng lisensya ang mga Java trademark nito, ang Sun ay boluntaryong nakikilahok sa isang proseso na tinatawag na Java Community Process (JCP), na nagpapahintulot sa mga interesadong partido na magmungkahi ng mga pagbabago sa anumang teknolohiya ng Sun Java (wika, toolkit) , API) sa pamamagitan ng mga konsultasyon at mga pangkat ng dalubhasa. Ayon sa mga panuntunan ng JCP, anumang panukala para sa pagbabago sa JDK, Java Runtime, o detalye wikang Java maaaring unilaterally tanggihan ng Sun dahil nangangailangan ito ng "oo" na boto mula sa Sun upang maaprubahan. Ang JCP ay nangangailangan ng membership fee mula sa mga komersyal na miyembro, habang ang mga non-profit na organisasyon at indibidwal ay maaaring lumahok nang libre.

Lisensya

Habang ang "Java" ay isang Sun trademark, at ang Sun lamang ang maaaring magbigay ng lisensya sa pangalang "Java", mayroong maraming mga libreng proyekto na bahagyang tugma sa Sun Java. Halimbawa, ang GNU Classpath at GNU Compiler para sa Java (GCJ) ay nagbibigay ng libreng library ng klase at compiler na bahagyang tugma sa kasalukuyang bersyon Sun Java. Noong huling bahagi ng 2006, inihayag ng Sun na ang lahat ng Java source code, hindi kasama ang proprietary code na hindi nila pinapanatili ang mga karapatan, ay ilalabas bilang libreng software sa ilalim ng binagong lisensya ng GPL sa Marso 2007. Kasalukuyang ipinamamahagi ng Sun ang HotSpot Virtual Machine at Java compiler nito sa ilalim Lisensya ng GPL, ngunit kasalukuyang walang libreng lisensya para sa karaniwang Java runtime . Dahil pananatilihin ng Sun ang pagmamay-ari ng Java source code nito, ang pagpapalabas nito sa ilalim ng GPL ay hindi makakapigil sa Sun sa pamamahagi ng pagmamay-ari o hindi pa nabubuksang mga bersyon ng Java, o paglilisensya nito sa iba.

Ang C#, ang CLI runtime, at karamihan sa nauugnay na library ng klase ay na-standardize at malayang maipapatupad nang walang lisensya. Maraming mga libreng C# system ang naipatupad na, kabilang ang Mono at DotGNU. Ang proyektong Mono ay nagpapatupad din ng maraming hindi karaniwang mga library ng Microsoft sa pamamagitan ng pag-aaral mula sa mga materyales ng Microsoft, katulad ng GNU Classpath at Java. Ang Mono Project ay naglalayon na maiwasan ang pagpasok sa anumang mga patent o copyright, at ang proyekto ay maaaring malayang ipamahagi at magamit sa ilalim ng lisensya ng GPL. Kasalukuyang namamahagi ang Microsoft ng isang -bersyon ng .NET runtime nito para sa hindi pangkomersyal na paggamit.

Paggamit

Komunidad

Ang Java ay binuo sa isang mas bukas na kultura na may mataas na mapagkumpitensyang kumpanya sa iba't ibang lugar ng functionality. Karamihan sa mga karagdagang aklatan ay magagamit sa ilalim ng mga libreng open source na lisensya. source code. Hinihikayat din ng Sun ang pagsasanay ng paglalarawan ng ilang functionality bilang isang detalye (tingnan ang proseso ng JCP), na iniiwan ang pagpapatupad mga developer ng third party(posibleng nagbibigay ng reference na pagpapatupad). Kaya, ang isyu ng kalayaan mula sa tagagawa ng software ay nalutas.

Sa kabila ng pagkakaroon ng Mono, mahigpit na iniuugnay ng C# ang mga developer sa platform ng Microsoft (kabilang ang OS, mga solusyon sa opisina). Kaya, ang gumagamit ng software na nakasulat sa .NET ay madalas na walang pagpipilian sa paggamit ng iba't ibang bahagi ng system. Ito ay humahantong sa tinatawag na vendor-locking, kung saan ang tagagawa ng third-party na software ay maaaring magdikta ng halos anumang kundisyon sa mamimili para sa pagsuporta sa ipinatupad na proyekto. Habang ang gumagamit ng Java application, bilang panuntunan, ay maaaring pumili ng supplier ng karagdagang software (tulad ng database, OS, application server, atbp.).

Popularidad at pag-unlad

Ang Java ay mas luma kaysa sa C# at binuo sa isang malaki at aktibong user base, nagiging lingua franca sa marami modernong mga lugar computer science, lalo na ang mga may kinalaman sa mga network. Ang Java ay nangingibabaw sa mga kurso sa programming sa mga unibersidad at kolehiyo sa Amerika, at mayroon na ngayong mas maraming literatura sa Java kaysa sa C#. Ang maturity at kasikatan ng Java ay humantong sa mas maraming library at API sa Java (marami sa mga ito ay open source) kaysa sa C#.

Hindi tulad ng Java, ang C# ay medyo bagong wika. Pinag-aralan ng Microsoft ang mga umiiral na wika tulad ng Java, Delphi, at Visual Basic, at binago ang ilang aspeto ng wika upang mas maging angkop sa mga pangangailangan ng ilang uri ng mga application.

Ang isang kritisismo na maririnig tungkol sa Java ay ang pagiging mabagal sa pagbuo at kakulangan ng ilan sa mga tampok na nagpapadali sa mga naka-istilong pattern at pamamaraan ng programming. Ang isang pagpuna sa wikang C# ay ang mga developer nito ay maaaring masyadong sabik na tumanggap ng kasalukuyang mga uso sa programming sa kapinsalaan ng pokus at pagiging simple ng wika. Maliwanag, ang mga taga-disenyo ng Java ay gumawa ng isang mas konserbatibong diskarte sa pagdaragdag ng mga pangunahing bagong tampok sa syntax ng wika kaysa sa iba pang mga modernong wika—marahil ay hindi gustong italaga ang wika sa mga uso na maaaring humantong sa mga dead end sa katagalan. Sa paglabas ng Java 5.0, ang trend na ito ay higit na nasira, dahil ipinakilala nito ang ilang pangunahing mga bagong tampok ng wika: ang foreach loop, awtomatikong pagbabalot, mga pamamaraan na may variable na numero mga parameter, enumerated na uri, generic na uri, at anotasyon (lahat ay nasa C#).

Ang C# naman, ay mas mabilis na umuunlad, na nililimitahan ang sarili nito nang mas kaunti sa pagdaragdag ng mga bagong feature na partikular sa problema. Ang kalakaran na ito ay lalong maliwanag sa bersyon C# 3.0, kung saan, halimbawa, lumitaw ang mga query na tulad ng SQL. (Ang mga bagong feature ay binuo sa paraang nananatiling wika ang wika pangkalahatang layunin. Para sa karagdagang impormasyon tungkol sa C# 3.0, tingnan ang artikulo sa C#). Ang mga karagdagan na nakatuon sa problema sa Java ay isinasaalang-alang ngunit, hindi bababa sa ngayon, ay tinanggihan.

palengke

Mula noong ito ay nagsimula, ang C# ay patuloy na inihambing sa Java. Hindi maikakaila na malaki ang utang ng C# at ang pinamamahalaang CLR nito sa Java at sa JRE nito (Java Runtime Environment).

Ito ay mapagtatalunan kung ang pagbuo ng C# ay sa ilang paraan ay isang resulta ng pagkilala ng Microsoft na ang pinamamahalaang kapaligiran ng code, kasama ang Java na nangunguna sa paraan, ay may maraming mga pakinabang sa lumalaking online na mundo, lalo na sa pagdating ng Internet sa mga device maliban sa mga personal na computer, at sa lumalaking kahalagahan ng seguridad ng network. Bago nilikha ang C#, binago ng Microsoft ang Java (lumikha ng J++) upang magdagdag ng mga tampok na tumatakbo lamang sa Windows, sa gayon ay lumalabag sa kasunduan sa paglilisensya ng Sun Microsystems. Habang ang Microsoft ay nasa ikalawang yugto ng diskarte sa negosyo nito, na kilala bilang "Embrace, Extend, and Extinguish", ang pagbuo ng J++ ay napigilan ng isang demanda na inihain ng Sun. Hindi makagawa ng Java clone na may mga feature na gusto nito, gumawa ang Microsoft ng alternatibong mas angkop sa kanilang mga pangangailangan at pananaw para sa hinaharap.

Sa kabila ng magulong simulang ito, nagiging mas malinaw na ang dalawang wika ay bihirang makipagkumpitensya sa isa't isa sa pamilihan. Nangibabaw ang Java sa sektor ng mobile at maraming tagasunod sa merkado ng web application. Ang C# ay nakakuha ng magandang pagtanggap sa Windows desktop application market at salamat sa ASP.NET, ang C# ay isa ring manlalaro sa web application market.

Mga Application sa Desktop

Ang parehong mga wika ay may isang hanay ng mga aklatan na nagbibigay ng mga kakayahan ng user interface para sa mga desktop application. Sa kaso ng Java, ito ang mga multi-platform na aklatan na Swing at SWT, pati na rin ang ilang hindi gaanong karaniwan. Sa prinsipyo, pinapayagan ka ng alinman sa mga ito na lumikha ng mga cross-platform na desktop application sa Java.

Para sa C# sa Windows platform, ang pangunahing library na nagpapatupad GUI Ang user sa mga desktop application ay Windows.Forms, na pag-aari ng Microsoft at ipinatupad lamang para sa Windows, at para sa iba pang mga platform - gtk#, na ipinatupad bilang bahagi ng proyekto ng Mono. Ang mga pagtatangka na malayang ipatupad ang Windows.Forms ay ginawa at ginagawa na (halimbawa, sa proyekto ng DotGNU), gayunpaman, dahil sa saradong katangian ng orihinal, hindi maiiwasang magdusa ang mga ito sa pagiging pangalawa at hindi kumpleto, halos hindi makalaban sa pagpapatupad mula sa Ang Microsoft at samakatuwid ay magagamit lamang para sa naantalang pag-port ng mga application ng Windows sa ibang mga platform. Ang mga development na katutubong batay sa Windows ay karaniwang binuo sa Windows.Forms, at nagiging mahirap ang pag-port sa kanila sa ibang platform. Ang pag-unlad ng C# sa kapaligiran ng Mono gamit ang gtk# ay portable, ngunit mas kaunti ang mga ito.

Dahil sa likas na katangian ng wika, ang manu-manong paggamit ng mga library ng Java graphics ay medyo mas mahirap. Ang arkitektura ng mga library ng Java graphics ay mas mahirap para sa isang baguhan na developer na maunawaan, ngunit sa parehong oras, pinipilit siya nitong bumuo ng propesyonal. Ang C#, dahil sa pagkakaroon ng mga built-in na tool sa programming ng kaganapan, ay nagtatago ng mga detalye ng pagproseso ng kaganapan at ilang iba pang aspeto mula sa developer, na nagpapadali sa pagbuo ng interface. Ang .NET platform sa una ay gumawa ng malawak na paggamit ng mga visual na tagabuo ng interface. Ang lahat ng ito ay nagbibigay ng mga pagkakataon para sa mabilis na pag-unlad desktop application interface na may mababang kwalipikasyon ng programmer.

Sa nakalipas na ilang taon, nakatuon ang Sun Microsystems sa pagpapakilala ng Java nang mas malawak sa merkado ng desktop application. Sa bersyon ng platform ng JRE 6 (2006), ang diin ay inilagay sa pagpapabuti ng pakikipag-ugnayan sa graphical na kapaligiran ng gumagamit. Kasama sa pinakabagong bersyon ng JVM ng Sun (JDK 6 update 10) ang maraming pagpapahusay sa user interface. Sa partikular, ang mga transparent na form at hindi hugis-parihaba na bintana. Kasama rin sa mga kamakailang bersyon ng mga Java IDE (hal. NetBeans) ang makabuluhang pinahusay na mga tagabuo ng graphical na user interface.

Ang C#, kasama ang Java, ay unti-unting nagiging popular sa ilan mga operating system batay sa Linux at BSD. Ang pagpapatupad ng proyektong Mono ay isang legal na walang sakit na proseso dahil ang CLR at C# na wika ay na-standardize ng Ecma at ISO, at sinuman ay maaaring ipatupad ang mga ito nang hindi nababahala tungkol sa mga legal na isyu. Kasabay nito, dapat tandaan na ang aplikasyon ay nakasulat sa ilalim kapaligiran ng Windows maaaring magkaroon ng malalaking problema na tumatakbo sa ilalim ng isa pang OS.

Mga application ng server

Sa arena na ito, marahil ang dalawang wika ay pinakamalapit sa pagiging kakumpitensya. Ang Java kasama ang platform na J2EE nito (Java(2) Enterprise Edition) at C# kasama ang ASP.NET nito ay nakikipagkumpitensya sa larangan ng paglikha ng dynamic na nilalaman ng web at mga application.

Ang parehong mga wika ay malawakang ginagamit at sinusuportahan sa merkado na ito, kasama ang hanay ng mga tool at sumusuporta sa mga produkto na magagamit para sa JavaEE at .NET.

Mga mobile application

Ang J2ME (JavaME, Java(2) Micro Edition) ay may napakalawak na base ng merkado mga mobile phone at PDA, kung saan ang mga pinakamurang device lang ang kulang sa KVM (isang stripped-down na Java Virtual Machine para sa mga device na may limitadong mapagkukunan). Ang mga programa ng Java, kabilang ang maraming laro, ay matatagpuan sa lahat ng dako.

Habang halos lahat ng mga telepono ay may kasamang KVM, ang mga kakayahan na ito ay hindi masyadong ginagamit ng karamihan sa mga gumagamit. Mga Application ng Java sa karamihan ng mga telepono ay karaniwang binubuo ng mga sistema ng menu, maliliit na laro, atbp. Ang mga kumpletong aplikasyon para sa mga mobile phone ay bihira.

Mga advanced na teknolohiya

C Matalas- Ang terminong ito ay may iba pang kahulugan, tingnan ang C. Tamang pamagat itong C# na artikulo. Ito ay ipinapakita nang hindi tama dahil sa mga teknikal na limitasyon. C# Semantics: imperative Language class: multi-paradigm: object-oriented,... ... Wikipedia

Visual J Sharp- Tamang pamagat ng artikulong ito ng Visual J#. Ito ay ipinapakita nang hindi tama dahil sa mga teknikal na limitasyon. Ang Visual J# ay isang pinagsama-samang development environment na nilikha ng Microsoft para sa .NET Framework sa isang Java-like na wika. Lalo na... ... Wikipedia

F Matalas- Ang terminong ito ay may iba pang kahulugan, tingnan ang F (mga kahulugan). Ang tamang pamagat para sa artikulong F# na ito. Ito ay ipinapakita nang hindi tama dahil sa mga teknikal na limitasyon. F# Language class: multi-paradigm: functional, object-oriented, ... ... Wikipedia

Kanta ng Sharp- Ang tamang pamagat ng artikulong ito ay Sing#. Ito ay ipinapakita nang hindi tama dahil sa mga teknikal na limitasyon. Sing# Language class: multi-paradigm: structural, imperative, object-oriented, event-oriented, functional, ... ... Wikipedia

M.C- MC# (basahin bilang "MC Sharp", mcsharp), Multiprocessor C# programming language. Ang MC# ay isang high-level object-oriented parallel programming language para sa .NET platform na sumusuporta sa paglikha ng mga program na tumatakbo sa ... ... Wikipedia

Visual C Sharp

Visual C Sharp .NET-Microsoft Visual Studio Hitsura Visual Studio 2008 SP1 na may C# program sa Windows Vista Uri ng Software development environment... Wikipedia

ECMAScript- Klase ng wika: multi-paradigm: object-oriented, generic, functional, imperative, aspect-oriented, event-oriented, prototype programming Lumitaw noong: 1995 (Mga) May-akda ... Wikipedia

At hindi tahasang tinukoy ang paglabas ng memorya. Parehong kasama ang mga mekanismo ng pag-synchronize sa kanilang syntax.

Parehong may malakas at mahinang object reference ang Java at C#. Binibigyang-daan ka ng Java na magrehistro ng isang tagapakinig na makakatanggap ng mga mensahe kapag ang isang link ay nakolektang basura, na nagpapabuti sa pagganap WeakHashMap, na wala sa C#. Ang parehong mga wika ay nagpapahintulot sa user code na maisakatuparan kapag ang isang bagay ay nakolektang basura. Sa C#, ang mekanismo para dito ay isang espesyal na paraan ng finalizer, na ipinahayag sa pamamagitan ng pamilyar na C++ destructor syntax. Sa Java, ito ay nakakamit sa pamamagitan ng pag-override sa paraan ng pag-finalize, na idineklara sa klase ng Bagay.

Mga Uri ng Data

Ang parehong wika ay sumusuporta sa ideya (kilala sa C# bilang mga uri ng halaga - mga uri ng halaga), at pareho para sa pagsasalin ng mga primitive na uri sa mga uri ng bagay ay nagbibigay ng kanilang awtomatikong "pagbabalot" sa mga bagay (boxing) at "unfolding" (unboxing). Ang C# ay may mas maraming primitive na uri kaysa sa Java, na may mga unsigned integer na uri na ipinares sa lahat ng nilagdaan at isang espesyal na uri ng decimal para sa high-precision na mga kalkulasyon ng floating point. Ang Java ay inabandona ang karamihan sa mga hindi naka-sign na uri para sa kapakanan ng pagiging simple. Sa partikular, ang Java ay walang primitive unsigned byte type.

Mga simbolo at espesyal na tampok

Ang Java ay may espesyal na import static syntax na nagbibigay-daan sa iyong gumamit ng mga pinaikling pangalan para sa ilan o lahat ng static na pamamaraan at variable ng isang klase. Ang C# ay may isang static na syntax ng klase na naghihigpit sa isang klase sa mga static na pamamaraan lamang, ngunit walang paraan upang tukuyin lamang ang mga pamamaraang iyon nang hindi tahasang tinutukoy ang klase sa bawat oras.

Mga Espesyal na Keyword

Keyword	Pagkakataon, halimbawa ng paggamit
kumuha, itakda	Sinusuportahan ng C# syntax ang .
labas, ref	Sinusuportahan ng C# ang mga parameter ng output ng pamamaraan, na nagpapahintulot sa iyo na magbalik ng maraming mga halaga.
lumipat	Sa C#, gumagana din ang switch statement sa mga string.
mahigpitfp	Gumagamit ang Java ng strictfp upang matiyak na ang mga resulta ng mga pagpapatakbo ng floating point ay hindi nababago sa lahat ng platform.
naka-check, hindi naka-check	Sa C#, ang mga naka-check na expression o block ay maaaring magsama ng arithmetic overflow checking sa oras ng pagtakbo.
gamit	Ang paggamit ng keyword sa C#"s ay nagsisiguro na ang nilikhang bagay ay itatapon o isinara kapag lumabas: gamit ang (StreamWriter file = new StreamWriter("test.txt")) ( file.Write("test"); )
goto	Sinusuportahan ng C# ang jump operator. Minsan ito ay maaaring maging kapaki-pakinabang, bagama't mas maraming nakabalangkas na paraan ng paglilipat ng kontrol ay karaniwang inirerekomenda (kaya naman kung bakit ito inabandona sa Java). Karaniwang Gamit goto keyword sa C# - paglipat ng kontrol sa iba't ibang mga label ng kaso sa isang switch statement.

Pangangasiwa ng Kaganapan

switch(color) ( case Color.Blue: Console.WriteLine("Color is blue"); break; case Color.DarkBlue: Console.WriteLine("Color is dark"); goto case Color.Blue; // ... )

Kinakailangan ng Java ang programmer na manu-manong ipatupad ang pattern ng observer, bagama't nagbibigay ito ng ilan sa anyo ng mga anonymous, na nagpapahintulot sa iyo na tukuyin ang katawan ng isang klase at agad na lumikha ng isang instance nito sa isang punto sa code. Ang tampok na ito ay karaniwang ginagamit upang lumikha ng mga tagamasid.

Nagbibigay ang C# ng malawak na suporta sa antas ng wika para sa pagprograma ng kaganapan, kabilang ang mga delegado ng .NET, multicasting, espesyal na syntax para sa pagtatakda ng mga kaganapan sa mga klase, mga operasyon para sa pagpaparehistro at pag-unregister sa mga tagapangasiwa ng kaganapan, delegate na covariance, at mga anonymous na pamamaraan na may ganap na semantika.

Overload ng operasyon

Ang mga pagsasara ay iminungkahi para sa pagsasama sa Java SE 7. Ang mga pagsasara na ito, tulad ng mga delegado sa C#, ay magkakaroon ng ganap na access sa lahat ng lokal na variable sa isang partikular na saklaw, sa halip na basahin lamang ang access sa mga variable na minarkahan ng final (tulad ng sa mga hindi kilalang nested na klase).

Kasama sa C# ang isang malaking hanay ng mga notation na kaginhawahan, na marami sa mga ito, tulad ng operator overloading at user-defined , ay pamilyar sa mga programmer ng C++. Mayroon din itong tahasang pagpapatupad ng mga pamamaraan ng interface, na nagpapahintulot sa isang klase na ipatupad ang mga pamamaraan ng interface nang hiwalay sa sarili nitong mga pamamaraan o magbigay ng iba't ibang mga pagpapatupad ng mga pamamaraan ng parehong pangalan na kabilang sa dalawang magkaibang mga interface.

Hindi kasama sa Java ang overloading ng operator dahil ang pag-abuso nito ay maaaring humantong sa code na mahirap basahin at mahirap i-debug. Kasabay nito, ang kakulangan ng labis na karga sa Java ay hindi gaanong nagagamit para sa ilang mga mathematical na programa.

Pamamaraan Sa C#, ang mga pamamaraan ay hindi default at dapat na tahasang ipahayag sa virtual na keyword upang magawa ito. Sa Java, sa kabaligtaran, lahat pampublikong pamamaraan , maliban sa mga static, ay virtual. Susi final ay isang analogue ng selyadong sa C# at nagbibigay-daan sa iyo na ipagbawal ang paglikha ng isang pamamaraan na may parehong lagda sa mga nagmula na klase. Ginagarantiyahan ng virtuality ang nais na overlap para sa pamamaraang tinatawag, ngunit nagpapataw ng ilang overhead ng pagpapatupad sa mga tawag, dahil ang mga tawag na ito ay karaniwang hindi sumasailalim sa inline na pagpapalit at nangangailangan ng karagdagang tawag sa . Gayunpaman, ang ilang mga pagpapatupad ng JVM, kabilang ang Sun's, ay nagpapatupad ng inline na pagpapalit ng pinakamadalas na tinatawag na mga virtual na pamamaraan.

Ang C# ay nangangailangan ng tahasang pagpapahayag ng layunin na i-override virtual na pamamaraan sa isang nagmula na klase. Ang layuning ito ay inilalarawan ng override na keyword. Kung ang overriding ay hindi intensyon ng programmer, at gusto lang ng isa na magpakilala ng bagong virtual na pamamaraan na may parehong pangalan at pirma upang lagyan ng anino ang luma, kailangan ng isa pang keyword, bago . Kung wala sa mga salitang ito ang tinukoy, nagreresulta ito sa isang error sa compilation. Sa Java, ang anumang pamamaraan ay palaging halos na-override ang isang base class method na may parehong pangalan at lagda, kung mayroon man. Ang pag-uugali na ito ay potensyal na mapanganib kung ang batayang klase ay ginawa ng isa pang developer, at ang bagong bersyon ay nagpapakilala ng parehong paraan na mayroon na sa nagmula na klase; sa kasong ito, i-override ng umiiral na pamamaraan mula sa nagmula na klase ang bagong ipinakilalang pamamaraan sa base class, na hindi intensyon ng parehong mga developer.

Kondisyon na compilation

Ang C#, hindi tulad ng Java, ay sumusuporta sa conditional compilation gamit ang . Mayroon din itong Conditional attribute, na nangangahulugan na ang tinukoy na paraan ay tinatawag lamang kapag ang ibinigay na compilation constant ay tinukoy. Sa ganitong paraan, maaari mong ipasok sa code, halimbawa, mga pagsusuri sa assertion, na gagana lamang sa bersyon ng pag-debug kapag ang DEBUG constant ay tinukoy. Sa .NET Standard Library, ito ang Debug.Assert() na paraan. Ang mga bersyon ng Java 1.4 at mas bago ay may kasamang tampok na pagsuri ng run-time assumption sa wika.

Mga namespace at source file

Ang mga namespace ng C# ay mas nakapagpapaalaala sa C++. Hindi tulad ng Java, ang lokasyon ng source file ay walang kinalaman sa namespace nito. Bagaman, sa mahigpit na pagsasalita, ang lokasyon ng mga source file sa Java ay hindi kinakailangang sumasalamin sa istraktura ng direktoryo ng package, ito ang default na pag-uugali.

Nangangailangan ng pangalan ang Java source file eksaktong tumutugma sa pangalan ng tanging pampublikong klase na tinukoy dito, habang pinapayagan ka ng C# na tukuyin ang ilang mga pampublikong klase sa isang file at hindi nagpapataw ng anumang mga paghihigpit sa pangalan ng file, at din (sa bersyon 2.0 at mas mataas) ay nagpapahintulot sa iyo na hatiin isang klase sa dalawa o higit pang mga file (mga keyword na bahagyang).

Mga pagbubukod

Sinusuri ang mga suporta ng Java sa pamamagitan ng pagpapatupad ng ganap na paghuli at paghawak sa lahat ng mga pagbubukod. Ang lahat ng mga pagbubukod na maaaring ihagis ng isang paraan ay dapat na nakalista sa deklarasyon nito gamit ang mga throws na keyword. Hindi sinusuportahan ng C# ang mga naka-check na exception. Nakikita ng ilang developer ang mga naka-check na exception na lubhang kapaki-pakinabang para sa pagtiyak magandang istilo programming. Ang iba, kabilang ang punong arkitekto ng C#, ay nangangatwiran na sa Java sila ay isang eksperimento at hindi binibigyang-katwiran ang kanilang sarili.

Ang isa sa mga argumento laban sa mga naka-check na eksepsiyon ay kapag ginamit ang mga ito, ang pagbabago sa panloob na code ng isang function ay maaaring humantong sa paghagis ng mga bagong eksepsiyon, na nangangailangan ng pagbabago sa deklarasyon ng function na ito at lahat ng iba pang tumatawag dito. Sa kalaunan, upang mapanatili ang pagiging tugma ng interface, karaniwan na ang simpleng pagdeklara ng mga function bilang throws Exception , kaya tinatanggihan ang buong ideya ng mga nasuri na exception. Ang isa pang paraan upang mapanatili ang pagiging tugma ng interface sa Java ay upang mahuli ang bagong ipinakilala na pagbubukod, balutin ito sa lumang ipinahayag na isa, at itapon muli. Halimbawa, kung ang isang paraan ay binago upang simulan nitong i-access ang database sa halip na file system, pagkatapos ay maaari nitong mahuli ang SQLException mismo at magtapon ng bagong itinapon na IOException sa halip, dahil hindi dapat malaman ng gumagamit ng pamamaraan ang mga detalye ng panloob na pagpapatupad nito.

Mababang antas ng code

Mga pagpapatupad

JVM at CLR

Ang Java ay nasa lahat ng dako sa lahat ng uri ng mga operating system at kapaligiran. Maraming pagpapatupad ang umiiral, minsan open source.

Ang teknolohiya ng ClickOnce ay nag-aalok ng katulad na pagpapagana sa Java Webstart, ngunit ito ay magagamit lamang para sa Mga kliyente sa Windows. Ang Internet Explorer sa Windows ay maaari ding magpakita. NET Windows Forms, na nagbibigay ng applet-like functionality ngunit limitado sa isang partikular na browser.

Standardisasyon

Ang wikang C# ay hindi tinukoy ng Microsoft, ngunit ng mga komite ng pamantayan at . Habang ang Sun ay nagpapanatili ng copyright at kapangyarihan sa pag-veto sa Java platform, ang huli ay higit na pinamamahalaan sa pamamagitan ng Java Community Process (JCP), na nagpapahintulot sa mga interesadong partido na makilahok sa pagtukoy ng mga bagong bersyon at tampok ng pagtutukoy ng teknolohiya ng Java.

Ang mga pamantayan ng ECMA at ISO para sa C# at .NET ay tumutukoy sa wika, CLI framework, at mga batayang klase(Base Class Library, o BCL). Hindi kasama sa mga pamantayan ang marami sa mga bagong aklatan na ipinatupad ng Microsoft sa itaas ng karaniwang balangkas, tulad ng mga aklatan para sa mga database, GUI, at web application ( , at ). Gayunpaman, pormal na sumang-ayon ang Microsoft na huwag usigin ang mga proyekto ng komunidad para sa pagpapatupad ng mga aklatang ito.

Paggamit

Komunidad

Ang Java ay binuo sa isang mas bukas na kultura na may mataas na mapagkumpitensyang kumpanya sa iba't ibang lugar ng functionality. Bagama't ganap nitong nilulutas ang problema ng pagsasarili ng software vendor, nagdaragdag ito ng karagdagang kumplikado sa wika. Upang matagumpay na magamit ang mga aklatan at mga bahagi, kailangan mong malaman hindi lamang ang Java, kundi pati na rin ang lahat ng iba't ibang nakikipagkumpitensya na mga shell at balangkas at iba't ibang "panlilinlang" ng mga pagpapatupad.

Popularidad at pag-unlad

Ang Java ay mas luma kaysa sa C# at binuo sa isang malaki at aktibong user base, nagiging sa maraming makabagong larangan ng computer science, lalo na doon sa . Ang Java ay nangingibabaw sa mga kurso sa programming sa mga unibersidad at kolehiyo sa Amerika, at mayroon na ngayong mas maraming literatura sa Java kaysa sa C#. Ang maturity at kasikatan ng Java ay humantong sa mas maraming library at API sa Java (marami sa mga ito ay open source) kaysa sa C#.

Hindi tulad ng Java, ang C# ay medyo bagong wika. Pinag-aralan ng Microsoft ang mga umiiral na wika tulad ng Java at , at binago ang ilang aspeto ng wika upang mas maging angkop sa mga pangangailangan ng ilang uri ng mga application. Sa paglipas ng panahon, ang pansamantalang kalamangan ng Java ay nagiging hindi gaanong makabuluhan.

Ang isang kritisismo na maririnig tungkol sa Java ay ang pagiging mabagal sa pagbuo at kakulangan ng ilang mga tampok na pinadali ng mga naka-istilong pattern at pamamaraan ng programming. Ang isang pagpuna sa wikang C# ay ang mga developer nito ay maaaring masyadong sabik na tumanggap ng mga kasalukuyang uso sa programming sa kapinsalaan ng pokus at pagiging simple ng wika. Ang mga taga-disenyo ng Java ay lumilitaw na gumamit ng isang mas konserbatibong diskarte sa pagdaragdag ng mga pangunahing bagong tampok sa syntax ng wika kaysa sa iba pang mga modernong wika-marahil ay hindi nais na italaga ang wika sa mga uso na maaaring humantong sa mga dead end sa katagalan. Na-buck ng Java 5.0 ang trend na ito sa maraming paraan, dahil ipinakilala nito ang ilang pangunahing bagong feature ng wika: ang foreach loop, automatic wrapping, variadic method, enumerated type, generics, at annotation (lahat ay nasa C#).

Ang C# naman, ay mas mabilis na umuunlad, na nililimitahan ang sarili nito nang mas kaunti sa pagdaragdag ng mga bagong feature na partikular sa problema. Ang kalakaran na ito ay lalong maliwanag sa paparating na bersyon ng C# 3.0, kung saan, halimbawa, -tulad ng mga query ay lumitaw. (Ang mga bagong tampok ay idinisenyo upang panatilihin ang wika bilang isang pangkalahatang layunin na wika. Para sa higit pang impormasyon sa C# 3.0, tingnan ang

Mapagdedebatehan kung ang pagbuo ng C# ay sa ilang paraan ay resulta ng pagkilala ng Microsoft na ang Java-led na pinamamahalaang code environment ay may maraming mga pakinabang sa isang lalong naka-network na mundo, lalo na sa pagdating ng Internet sa mga device maliban sa mga personal na computer at ang lumalaking kahalagahan ng seguridad ng network. Bago nilikha ang C#, binago ng Microsoft ang Java (sa pamamagitan ng paglikha ) upang magdagdag ng mga tampok na gumagana lamang sa OS, kaya lumalabag sa kasunduan sa lisensya. Habang ang Microsoft ay nasa ikalawang yugto ng diskarte sa negosyo nito, na kilala bilang , ang pagbuo ng J++ ay napigilan ng isang kaso na inihain ng Sun.

Sa kabila ng magulong simulang ito, nagiging mas malinaw na ang dalawang wika ay bihirang makipagkumpitensya sa isa't isa sa pamilihan. Nangibabaw ang Java sa sektor ng mobile at maraming tagasunod sa merkado ng web application. Ang C# ay nakatanggap ng mahusay na pagtanggap sa Windows desktop application market at itinutulak ng Microsoft bilang pangunahing wika para sa mga aplikasyon ng Windows. Salamat sa , C# ay isa ring manlalaro sa web application market.

Mga Application sa Desktop

Minsan ang Java ay inaakusahan ng labis na pangako at kulang sa paghahatid pagdating sa mga desktop application. Bagama't ang AWT (Abstract Windowing Toolkit) na mga windowing library nito ay ipinagmamalaki ang napakaraming kakayahan, kinailangan ng Java na lumaban upang maitatag ang sarili nito sa merkado ng desktop application. Ang kanyang mahigpit na pagsunod sa prinsipyo<пишем один раз, используем везде>nagpapahirap na sulitin ang mga partikular na kakayahan at mode ng pagpapatakbo sa bawat partikular na desktop system. Bilang resulta, ang mga desktop application na nakasulat sa Java ay kadalasang kamukha<чужие>sa plataporma kung saan sila pinapatay.

Sun Microsystems, sabi ng ilan, ay naging mabagal din sa pag-promote ng Java sa mga developer at user sa paraang ginagawa itong kaakit-akit sa mga desktop application. Kahit na ang mga teknolohiya tulad ng Java Web Start, na kakaunti ang mga kakumpitensya sa mga wika at platform, ay hindi gaanong na-promote.

Ang paglabas ng bersyon ng Java 6.0, na inaasahan noong 2006, ay muling nakatuon sa desktop market - na may malawak na hanay ng mga bago at kawili-wiling mga tool para sa mas mahusay at mas mahigpit na pagsasama sa desktop environment.

Mga advanced na teknolohiya

Ang Java ay pinagtibay bilang opisyal na software para magamit sa susunod na henerasyon ng pamantayan ng DVD, sa pamamagitan ng interactive na platform ng BD-J. Ibig sabihin, nasa lahat ng drive ang interactive na content gaya ng mga menu, laro, pag-download, atbp DVD Blu-ray ay malilikha sa platform ng Java.

Java vs. C#... Ano ang maaaring mas mahusay kaysa sa isang walang hanggang pagtatalo? Hindi, ang artikulong ito ay hindi nakatuon sa isa pang benchmark, at hindi kahit isang banal na digmaan, walang kahit isang tanong: "sino ang mas cool".

Mayroong isang tool para sa bawat gawain. Ang paghahambing ng C# at Ruby, halimbawa, ay walang saysay, dahil ang kanilang nilalayon na layunin ay ganap na naiiba, at gayundin ang kanilang kalikasan. Gayunpaman, ito ay C# at Java na pinakamalapit sa kanilang pilosopiya.

Kadalasan, ang mga kasamahan na nagsusulat sa Java ay hindi man lang alam ang maraming (!!!) mga bagay na ibinibigay ng C# (o, sa kabaligtaran, hindi ibinibigay).

Kung interesado ka sa pagtingin sa C# at Java walang subjectivity at alamin din panloob na istraktura ito o ang posibilidad na iyon, pagkatapos ay magpatuloy.

▌ Isang maliit na kasaysayan

Ang wikang C# ay lumitaw noong 2001, at nagsimula ang pag-unlad nito noong 1999. Noon ito ay halos kapareho sa Java 1.4. Gayunpaman, ang modernong C# na alam natin ay dapat magsimula sa bersyon 2.0 (na tumutugma sa paglabas ng Java 5).

Mayroong isang opinyon na ang C# ay humiram ng maraming mula sa Java. Gayunpaman, lubos akong hindi sumasang-ayon dito. Sa aking opinyon, ang C# ay sa maraming paraan C "na may mga bagay," o C++ "na may mukha ng tao."

Umaasa ako na ang artikulo at ang mga argumento dito ay kumpirmahin ang pahayag na ito.
Hindi ko na ikukuwento muli ang Wikipedia. Samakatuwid, agad tayong magpatuloy at maglakad pangunahing pagkakaiba at mga benepisyo.

Una, titingnan natin ang mga kakayahan ng JVM at CLR (Common Language Runtime) mismo, pagkatapos ay titingnan natin ang syntactic sugar ng C#.

▌ Episode I: Bytecode

Parehong gumagamit ng bytecode ang .NET at Java. Siyempre, bukod sa format mismo, mayroong isang napakahalagang pagkakaiba - polymorphism.

Ang CIL (Common Intermediate Language, na kilala rin bilang MSIL, na kilala rin bilang IL) ay bytecode na may polymorphic (generalized) na mga tagubilin.

Kaya, kung ang Java ay gumagamit ng isang hiwalay na pagtuturo para sa bawat uri ng operasyon na may iba't ibang uri(Halimbawa: fadd- pagdaragdag ng 2 float, iadd- pagdaragdag ng 2 integers), pagkatapos ay sa CIL para sa bawat uri ng operasyon mayroon lamang isang pagtuturo na may mga polymorphic parameter (halimbawa, mayroon lamang isang pagtuturo - idagdag, na nagdaragdag ng parehong mga float at integer). Ang desisyon na bumuo ng naaangkop na x86 na mga tagubilin ay nakasalalay sa JIT.

Ang bilang ng mga tagubilin para sa parehong mga platform ay halos pareho. Ang paghahambing sa listahan ng Java at CIL bytecode na mga utos, makikita mo na ang 206 ay para sa Java, at ang 232 ay para sa CIL, ngunit huwag kalimutan na sa Java maraming mga utos ang inuulit lamang ang pag-andar ng bawat isa.

▌ Episode III: Generics (parameterized na mga uri || parametric polymorphism)

Tulad ng alam mo, ginagamit ng Java ang mekanismo ng pagbubura ng uri, i.e. Ang suporta para sa generics ay ibinibigay lamang ng compiler, ngunit hindi ng runtime, at pagkatapos ng compilation, ang impormasyon tungkol sa mismong uri ay hindi magiging available.

Halimbawa, code:

Listahan strList = bagong ArrayList (); Listahan intList = bagong ArrayList (); bool areSame = strList.getClass() == intList.getClass(); System.out.println(areSame);
Ipapakita totoo.

Bukod dito, sa halip na ang pangkalahatang uri T isang halimbawa ng isang bagay ng uri ay nilikha java.lang.Object.

Listahan strList = bagong ArrayList (); strList.add("stringValue"); String str = strList.get(0);
Iko-convert sa:

Listahan ng listahan = bagong ArrayList(); list.add("stringValue"); String x = (String) list.get(0);
Kaya ang buong uri ng patakaran sa kaligtasan ay nawasak kaagad.

NET, sa kabaligtaran, ay may buong suporta generics parehong compile-time at run-time.

Kaya ano ang kailangang ipatupad upang ganap na suportahan ang mga generic sa Java? Sa halip, tingnan natin kung ano ang ginawa ng .NET development team:

• Sinusuportahan ng Generics sa antas ng Common Type System para sa cross-language interoperability
• Buong suporta mula sa Reflection API
• Pagdaragdag ng mga bagong klase/pamamaraan sa mga batayang klase (Base Class Library)
• Mga pagbabago sa mismong format at mga talahanayan ng metadata
• Mga pagbabago sa runtime memory allocation algorithm
• Pagdaragdag ng mga bagong istruktura ng data
• Generics support mula sa JIT (code-sharing)
• Mga pagbabago sa format ng CIL (mga bagong tagubilin sa bytecode)
• Suporta sa CIL code verifier

Yung. ang mga generic ay magagamit hindi lamang sa oras ng pag-compile, kundi pati na rin sa runtime nang hindi nawawala o binabago ang uri ng impormasyon. Nawawala din ang pangangailangan sa boxing/unboxing.

▌ Episode IV: Mga Uri

Ang Java ay isang ganap na OO na wika. Ito ay debatable. Narito kung bakit: ang mga primitive na uri (integer, float, atbp.) ay hindi nagmamana mula sa java.lang.Object. Samakatuwid, hindi sinusuportahan ng mga generic sa Java ang mga primitive na uri.

Ngunit sa isang tunay na OO na wika lahat ay bagay.

Hindi lang ito ang limitasyon. Hindi rin posible na lumikha ng iyong sariling mga primitive na uri.

Pinapayagan ka ng C# na gawin ito. Ang pangalan ng mga istrukturang ito ay struct.

Halimbawa:

Public struct Quad ( int X1; int X2; int Y1; int Y2; )
Gayundin, pinapayagan ka ng mga generic sa C# na gumamit ng mga uri ng halaga (int, float, atbp.)

Kung sa Java kailangan mong magsulat ng ganito:

Listahan intList = bagong ArrayList ();
Ngunit hindi mo magagawa ito:

Listahan intList = bagong ArrayList ();
Pinapayagan ng C# ang paggamit ng mga primitive na uri.

Ngayon ay dumating tayo sa paksa ng uri ng hierarchy sa .NET.

Mayroong 3 uri ng mga uri sa .NET: halaga, sanggunian at mga uri ng pointer.

Kaya, uri ng halaga– analogue ng primitive na uri mula sa Java. Gayunpaman, ito ay minana mula sa System.Object, nabubuhay hindi sa heap, ngunit sa stack (at ngayon ay isang disclaimer: ang lokasyon ng uri ng halaga ay nakasalalay sa ikot ng buhay, halimbawa, kapag nakikilahok sa isang pagsasara, awtomatikong nangyayari ang boksing).

Uri ng sanggunian– ay kapareho ng mga uri ng sanggunian sa Java.

Uri ng pointer– ay ang pinaka-hindi pangkaraniwang pag-aari ng .NET. Ang katotohanan ay ang CLR ay nagpapahintulot sa iyo na gumana nang direkta sa mga pointer!

Halimbawa:

Struct Point ( public int x; public int y; ) hindi ligtas na static void PointerMethod() ( Point point; Point* p = p->x = 100; p->y = 200; Point point2; Point* p2 = (*p2 ).x = 100; (*p2).y = 200;
Kamukhang-kamukha ng C++ code, hindi ba?

▌ Episode V: Mga Tampok ng C#

Una, tukuyin natin kung ano ang magagawa ng C#:

• Mga Property (kabilang ang awtomatiko)
• Mga delegado
• Mga kaganapan
• Mga hindi kilalang pamamaraan
• Mga expression ng Lambda
• Mga Puno ng Pagpapahayag
• Anonymous na klase
• Makapangyarihang uri ng hinuha
• Overloading ng operator
• Mga tagapag-index
• ... marami pa

Mga Katangian sa C# kinakatawan nila ang syntactic sugar, dahil kapag pinagsama-sama, nagiging mga pamamaraan ng uri Kumuha ngXXX, Itakda angXXX. Gayunpaman, ang impormasyon tungkol sa mismong konsepto ng ari-arian ay naka-imbak sa metadata, kaya mula sa anumang iba pang sumusuportang pag-aari ng wika ay maa-access lang namin ito bilang bagay.PropertyX, hindi object.GetPropertyX.

Halimbawa:

Public class TestClass ( public int TotalSum ( get ( return Count * Price; ) ) //awtomatikong property - bubuo ang compiler ng mismong mga field public int Count ( get; set; ) public int Price ( get ( return 50; ) ) )
Iko-convert ito sa:

Pampublikong klase TestClass ( /* *lahat ng iba pang code */ private int k__BackingField; //awtomatikong pag-aari - bubuo ng compiler ang mismong mga field public int Count ( get ( return k__BackingField; ) itakda (
k__BackingField = halaga; ) ) ) Mga delegado

ay mga analogue ng mga pointer sa mga pamamaraan sa C/C++. Gayunpaman, ang mga ito ay uri ng ligtas. Ang kanilang pangunahing layunin ay ang mga function ng callback, pati na rin ang pagtatrabaho sa mga kaganapan. Kasabay nito, ang mga delegado sa .NET ay.

Ang diskarte na ito ay pangunahing naiiba sa proyekto ng Da Vinci para sa Java, dahil sa huli sinusubukan nilang palawakin ang VM mismo.

Tingnan natin ang isang halimbawa sa C#:

Public class TestClass ( public delegate int BinaryOp(int arg1, int arg2); public int Add(int a, int b) ( return a + b; ) public int Multiply(int first, int second) ( return first * second; ) public void TestDelegates() ( BinaryOp op = bagong BinaryOp(Add); int result = op(1, 2); Console.WriteLine(result); //will output: 3 op = new BinaryOp(Multiply); resulta = op( 2 , 5);
At din sa C:

Int Add(int arg1, int arg2) ( return arg1 + arg2; ) void TestFP() ( int (*fpAdd)(int, int); fpAdd = //function pointer int three = fpAdd(1, 2); / / tawagan ang function sa pamamagitan ng isang pointer)
Kaya ano ang nakikita natin? Kung sa C maaari naming ipasa ang isang pointer sa isang function na may iba pang mga uri ng mga parameter (sabihin ang float arg1, float arg2), pagkatapos ay sa C # ito ay imposible. Sa C#, ang mga delegado ay sumasailalim hindi lamang sa signature at type checking sa yugto ng compilation, kundi pati na rin sa runtime.

Mga kaganapan kinakailangan upang ipatupad ang programming na hinimok ng kaganapan. Siyempre, makakayanan mo ang EventDispatcher o ang pattern ng Publisher/Subscriber. Gayunpaman, ang suporta sa katutubong wika ay nagbibigay ng mga makabuluhang pakinabang. Isa na rito ay uri ng kaligtasan.

Halimbawa:

Public class MyClass ( private string _value; public delegate void ChangingEventhandler(string oldValue); public event ChangingEventhandler Changing; public void OnChanging(string oldvalue) ( ​​​​ChangingEventhandler handler = Changing; if (handler != null) handler(oldvalue); ) public string Value ( get ( return _value; ) set ( OnChanging(_value); _value = value; ) ) public void TestEvent() ( MyClass instance = new MyClass(); instance.Changing += new ChangingEventhandler(instance_Changing);instance. Halaga = "bagong halaga ng string"; //будет вызван метод instance_Changing } void instance_Changing(string oldValue) { Console.WriteLine(oldValue); } } !}
Mga hindi kilalang pamamaraan makabuluhang pinasimple ang buhay - ang istraktura ng klase ay nananatiling malinis, i.e. hindi na kailangang lumikha ng hiwalay na mga karagdagang pamamaraan sa klase mismo.

Baguhin natin ang halimbawa sa itaas gamit ang mga binary operation gamit ang mga hindi kilalang pamamaraan:

Pampublikong klase TestClass ( public delegate int BinaryOp(int arg1, int arg2); public void TestDelegates() ( BinaryOp op = bagong BinaryOp(delegate(int a, int b) ( return a + b; )); int result = op( 1, 2); Console.WriteLine(resulta);
Hindi ba mas maikli at mas malinis?

Isaalang-alang natin ngayon mga expression ng lambda.

Ang lambda expression ay isang anonymous na function na naglalaman ng mga expression at operator at maaari ding gamitin para gumawa ng mga delegado o expression tree.

Pampublikong klase TestClass ( public delegate int BinaryOp(int arg1, int arg2); public void TestDelegates() ( BinaryOp op = new BinaryOp((a, b) => a + b); int result = op(1, 2); Console.WriteLine(resulta);
Ano ang magiging hitsura ng isang halimbawa ng mga kaganapan? Napakasimple:

Pampublikong klase MyClass ( /* * lahat ng iba pang code */ public void TestEvent() ( MyClass instance = new MyClass(); instance.Changing += (o) => Console.WriteLine(o); instance.Value = "(! LANG:bagong halaga ng string"; //будет вызван Console.WriteLine } } !}
Well, mas binawasan namin ang code at nagsisimula itong magmukhang isang functional na istilo (!!!). Oo, ang C# ay isa ring functional na wika, dahil... Ang mga function ay mga first class na bagay.

Ang mga expression ng Lambda, at kasama ang mga expression tree, ay nilikha gamit ang LINQ(Language Integrated Query).

Hindi pa rin pamilyar sa LINQ? Gustong makita kung ano ang magiging hitsura ng sikat na MapReduce sa LINQ?

Pampublikong static na klase MyClass ( public void MapReduceTest() ( var words = new ("...some text goes here..."); var wordOccurrences = words .GroupBy(w => w) .Select(intermediate => new ( Word = intermediate.Key, Frequency = intermediate.Sum(w => 1) ) .Where(w => w.Frequency > 10) .OrderBy(w => w.Frequency ) )
O gumamit ng SQL-like syntax:

Pampublikong void MapReduceTest() ( string words = bagong string ( "...may text na napupunta dito..." ); var wordOccurrences = from w in words group w by w into intermediate select new ( Word = intermediate.Key, Frequency = intermediate.Sum((string w) => 1) ) sa w kung saan w.Frequency > 10 orderby w.Frequency piliin w )
Sa halimbawang ito makikita natin ang parehong LINQ (GroupBy().Select().Where(), etc.) at anonymous na mga klase -

Bago ( Word = intermediate. Key, Frequency = intermediate.Sum(w => 1) )
Hmm...ano pa ba ang gamit dito? Ang sagot ay simple - isang malakas na uri ng inference system.

Ang pangunahing salita dito ay gumaganap ng isang pangunahing papel var. Ang C++11 ay may katulad na disenyo sasakyan.

Kaya't walang uri ng inference ay kailangan nating magsulat ng ganito:

Pampublikong void MapReduceTest() ( string words = bagong string ( "...may mga text na napupunta dito..." ); var wordOccurrences = Enumerable.OrderBy(Enumerable.Where(Enumerable.Select(Enumerable.GroupBy (mga salita, delegado (string w) ( return w; )), delegado (IGrouping intermediate) ( bumalik ng bago ( Word = intermediate. Key, Frequency = Enumerable.Sum (intermediate, (Func ) (w => 1)) );<>f__AnonymousType0 w) ( return w. Frequency > 10; )), delegate (<>f__AnonymousType0 w) ( return w.Frequency; )); )
[Ang pamamaraang ito binuo ito ng compiler para sa amin]

Upang ilarawan ang lahat ng iba pang mga tampok ng C#, mga setting ng compiler nito, atbp. Kinakailangang maglaan ng higit sa isang artikulo.

Samantala, ang C# 5 – na magagamit na at malapit nang magkaroon ng opisyal na paglabas nito, idinagdag asynchronous na programming, na lumabas din sa C++11!

▌ Konklusyon

Ang C# at Java ay makapangyarihang mga wika, pati na rin ang makapangyarihang mga platform (.NET at Java). Tulad ng naisulat ko na sa simula ng artikulo, mayroong isang tool para sa bawat gawain.

Ang C# ay hindi pagpapatuloy o kopya ng Java. Kahit na ito ay binuo sa Microsoft, ang pangalan ng code nito ay COOL (C-like Object Oriented Language). Ilang beses na binanggit ang pagkakatulad ng C/C++ sa artikulong ito? Sapat na dami.

Umaasa ako na ang aking artikulo ay nakatulong sa paglutas (kahit kaunti) ang isyu ng mga pagkakaiba sa pagitan ng mga wika at platform.

Salamat sa iyong pansin!