C # הדרכה: היסודות שאתה צריך כדי לשלוט ב- C #

C # היא לכל מטרה ושפת התכנות החזקה שפיתחה תאגיד מיקרוסופט בשנת 2000 כמתחרה קטלנית לג'אווה. היא פופולרית ביותר ושפת תכנות דומיננטית בכל הנוגע לפיתוח אתרים כמו גם לפיתוח יישומי שולחן עבודה.

במדריך C # זה נלמד את המושגים הבאים.

• יסודות C #
• תכנות מונחה עצמים
• מושגי C # מתקדמים
• שאלות ראיון על בסיס C #

יסודות C #

• מבוא לשפת תכנות C #
• תכונות של שפת תכנות C #
• הַתקָנָה
• מבנה תכנית C #
• סוגי מידע
• משתנים
• מפעילים
• לולאות
• מותנה
• מיתרים
• מערכים
• אוספים
  • רשימה
  • סט האש
  • סט ממוין
  • לַעֲרוֹם
  • תוֹר
  • רשימה מקושרת
  • מילון
  • מילון ממוין
  • מיון רשימה
• מִבְנֶה
• פונקציות

מבוא לשפת תכנות C #

עוד בתחילת שנות ה -90 ג'אווה הייתה שפת התכנות המובילה לפיתוח אתרים, פיתוח יישומי שולחן עבודה ותחומים רבים אחרים. מיקרוסופט רצתה להמציא מתחרה עם תכונות מתקדמות רבות שיכולות להשאיר את ג'אווה הרחק מאחור.

זה היה בשנת 2000, אנדרס הילסברג וצוות מיקרוסופט שלו העלו את הרעיון של C # הנקרא בכינויו C-Sharp. יוזמה זו אושרה על ידי ארגון התקנים הבינלאומי (גדול) והתאחדות יצרני המחשבים האירופית (ECMA). ולבסוף, ה- C # נכנס לעולם פיתוח התוכנה.

תכונות של שפת תכנות C #

• שפת תכנות מונחה עצמים

גישת תכנות מונחה עצמים היא שהופכת את C # לחדה לשפת התכנות הידידותית ביותר וקל לפיתוח ולתחזוקה.

• שפה בטוחה מסוג

המשמעות של Type-Safe היא שהמהדר יקבל גישה רק למיקום הזיכרון שיש לו הרשאה לבצע. תכונה זו משפרת את בטיחות הקוד לרמה אקספוננציאלית.

• יכולת פעולה הדדית

התכונה של יכולת פעולה הדדית הופכת את C # למספיק מספיק כדי לעשות את כל מה שמקורו ב- C ++ בצורה יעילה יותר שיכולה לעלות על C ++ עצמה.

• ספרייה עשירה

C # מספק גישה למספר רב של ספריות מובנות המספקות פונקציות שתוכננו מראש כדי להקטין את זמן ההשקעה בתהליך הפיתוח.

• ניתן להרחבה וניתנת לעדכון

C # תוכנן להיות מעולה יותר משאר שפות התכנות. לפיכך, הוא תמיד פתוח לעדכונים, והוא שומר על מדרגיות רבה בתכונותיו.

• רכיב מונחה

המפתחים במיקרוסופט השתמשו בגישה המבוססת על רכיבים לפיתוח C #. זו מתודולוגיית הפיתוח השולטת ביותר בכדי לשמור על C # מדרגית ומעודכנת ביותר.

• שפה מובנית

גישת התכנות המובנית מועדפת במהלך מחזור חיי פיתוח התוכנה מכיוון שהיא הופכת להיות קלה לפיתוח הידור והפריסה של התוכנה בהשוואה לגישת התכנות מונחית ההליך.

• מָהִיר

תכנות C # היא במקרה מהיר יותר באוסף וביצוע בהשוואה ל- C ++ ושפות תכנות אחרות.

הַתקָנָה

זה מוכח Microsoft Visual Studio הוא העורך הטוב בכיתה לתכנות C #. אנו נתקין ולהגדיר את Microsoft Visual Studio לביצוע תוכניות ה- C שלנו על ידי ביצוע השלבים המוזכרים להלן:

שלב 1 : הורד את Microsoft Visual Studio

גוגל עבור הגרסה האחרונה של Visual Studio ולהוריד את להתקין הקובץ למערכת המקומית שלך ואז לָרוּץ את קובץ ההתקנה כמו מנהל.

שלב 2: בחר בחבילת .NET Desktop Development

לאחר הפעלת המתקין, עורך Visual Studio יורד בהצלחה למערכת המקומית שלך, בהמשך תוצג תיבת דו-שיח על מסך שולחן העבודה שלך המבקש מאויב חבילה מסוימת שאתה צריך במערכת שלך. כאן, עליך לבחור את .NET פיתוח שולחן עבודה חֲבִילָה.

שלב 3: הגדר C # סביבה

ברגע שהחבילות שלך עבור .NET פיתוח מורידים, ואז תוצג תיבת דו-שיח נוספת על המסך שלך שתבקש את סביבת הפיתוח שאתה מחפש. הנה, אתה צריך בחר את הסביבה עבור C #.

שלב 4: צור את הפרויקט הראשון שלך

ברגע שהסביבה מוגדרת, כולכם יכולים ללכת. הפעל את Visual Studio ובחר ליצור פרויקט חדש אפשרות בתיבת הדו-שיח המוצגת.

תועבר לתיבת הדו-שיח הבאה ושם עליך לבחור בספריית הכיתה כ תקן .NET כפי שמוצג מטה.

בתיבת הדו-שיח הבאה תתבקש לעשות זאת הגדר את הפרויקט שלך . הגדר את התצורה ועכשיו אתה נמצא בעורך. כתוב את התוכנית הראשונה שלך ו לָרוּץ זה. הפלט יוצג בהצלחה ב- שורת פקודה.

באמצעות מחלקת מערכת Edureka {static void Main (string [] args) {Console.WriteLine ('ברוך הבא ל- Edureka !, Happy Learning ..!')}}

//תְפוּקָה:

בואו נבצע את תוכנית ה- C # הראשונה שלנו.

מבנה תכנית C #

כעת לאחר שביצענו את תוכנית ה- C # הראשונה שלנו, הבה נבין בפירוט את המבנה שלה. תוכנית C # פשוטה כוללת את החלקים הבאים.

באמצעות מרחב שמות מערכת ConsoleApplication1 {public class Edureka {public static void Main (string [] args) {Console.WriteLine ('Welcome to Edureka !, Happy Learning ..!')}}}

//תְפוּקָה:

ברוך הבא לאדוריקה !, למידה שמחה ..!

• מעמד: ניתן להגדיר בדרך כלל מחלקה כ- מילת מפתח המשמש להגדרת כיתה בתכנית C #.
• אדוריקה: זה שמו של ה- מעמד. הכיתה נחשבת לעיתים קרובות כמתווה המאחסן את החברים והשיטות הקשורות לכיתה.
• רָאשִׁי: בעיקרון הוא שיטה ראשונית של כל תוכנית ה- C #, היא משמשת כשער הכניסה לבקרה להיכנס לתוכנית. זה מבוצע לפני כל שיטה אחרת של התוכנית מבוצעת.
• בָּטֵל: קטע קוד זה מיועד ל- סוג החזרה של השיטה. זה יכול להיות כל סוג נתונים שאינו ריק. בטל פירושו שלשיטה אין נתונים שמוחזרים ממנה.
• סטָטִי: זה מילת מפתח האומר כי הנתונים המוצהרים על חבריהם הם סטטיים וזיכרון ייעודי מוקצה לחברים שהוכרזו.
• מחרוזת [] טוענת: זה דומה לארגומנטים של שורת הפקודה שבה אנו משתמשים בתוכנית שלנו. בזמן שאנחנו מבצעים את התוכנית שלנו, אנחנו בעצם מעבירים כמה ויכוחים, אשר תתקבל על ידי התוכנית בגלל הצהרה זו.
• System.Console.WriteLine ('ברוך הבא לאדוריקה !, למידה שמחה ..!') כאן, מערכת האם ה מרחב שמות. הקונסולההיא שהקטגוריה המתוארתבמרחב שמות מערכת. ה WriteLine () האם זה הסטָטִיטֶכנִיקָהשל המסוףקטגוריה המשמשת לרישוםאת הטקסט בקונסולה.

כעת, בואו נלמד את סוגי הנתונים הזמינים ב- C #.

סוגי מידע

סוגי הנתונים ב- C # מחולקים לשלוש קטגוריות מתוארים להלן.

סוגי נתונים ערכיים

ה סוגי נתונים ערכיים ממוקמים ב System.ValueType ספרייה ותמיד מוכנים לגישה ישירה וניתן להקצות משתנים ישירות לערך מסוים. נתוני הערך מסווגים עוד לשני סוגים כמוצג להלן:

• סוגי נתונים מוגדרים מראש
• סוגי נתונים המוגדרים על ידי המשתמש

סוגי נתונים מוגדרים מראש: אלה הם אלה שבדרך כלל אנו משתמשים בתכנות היומיומיות שלנו. סוגי נתונים אלה מוגדרים מראש על ידי מפתחי השפה ונשמרים מוכנים לשימוש עבור המתכנתים.

דוגמא:

int, float, char, קצר כפול וכו '

סוגי נתונים שהוגדרו על ידי המשתמש: ישנם מצבים בהם נצטרך לאחסן ערכים שונים מסוגי נתונים למשתנה יחיד אחד. במקרים אלה, סוגי נתונים מוגדרים מראש הם לא מספיק. משתמש הוגדר סוגי נתונים הם כמו סוגי נתונים הניתנים להתאמה אישית עבור המשתמש.

דוגמה: מבנה, Enum

סוג נתונים מצביע

סוג המצביע הוא סוג נתונים פשוט. הפונקציונליות שלו דומה לחלוטין לפוינטרים ב- C. הם מיועדים לאחסון כתובת של מצביע אחר.

צף * ptr

סוגי סימוכין

השם מסביר את עצמו. ה סוגי סימוכין למעשה לא לאחסן את המשתנים, במקום זאת, הם מאחסנים את ערך הייחוס למשתנה המסוים הזה. במילים אחרות, הם שומרים את כתובת המשתנה בפועל.

משתני ההתייחסות מסווגים לשלושה סוגים שונים כאמור להלן:

• סוג אובייקט

סוג הנתונים של האובייקט זמין ב מערכת. אובייקט מעמד.האובייקטסוגיםיכול להיותהוקצה לערכים שלשאר הסוגים,התייחסותסוגים, מוגדר מראש, מוגדר על ידי המשתמשסוגים. אבל לפנימְשִׁימָהערכים, זה דורש סוּג הֲמָרָה.

אובייקט abc abc = 50 // זה נקרא אגרוף

• סוג דינמי

משתני סוג דינמי נועדו לאחסן כמעט את כל סוגי הערכים. זה נקרא בשם סוג דינמי מכיוון שבדיקת הסוגים של הערכים מתרחשת בזמן ריצה

דינמי x = 10

• סוג מחרוזת

סוג המחרוזת זמין ב מערכת. מחרוזת מעמד. סוג המיתרים מיועד לאחסון מילולי מיתרים. ספרות המיתרים מאוחסנות בשתי צורות בתוךשתי צורות

• • מְצוּטָט
  • @מְצוּטָט.

מחרוזת S = 'אדוריקה'

• ה @מְצוּטָט מחרוזת ממש נראה כמו

@ 'אדוריקה'

עכשיו בואו נבין את המשתנים.

משתנים

משתנים הם השמות המוקצים למיקום הזיכרון השומרים נתונים מסוימים הניתנים על ידי המשתמש וניתן לגשת לנתונים באמצעות שם המשתנה. ישנם חמישה סוגים של משתנים הזמינים ב- C #

דוגמא:

int a, b כפול x לצוף p char abc

כללים שיש להקפיד עליהם כדי להכריז על משתנים ב- C #

• משתנה יכול לכלול אלפבית, ספרות וקווים תחתונים.
• שם משתנה יכול להתחיל רק עם אלפבית או קו תחתון בלבד.
• משתנים לא יכולים להתחיל בספרה או בתו מיוחד.
• אסור לרווחים לבנים בין שם המשתנה.
• מילות מפתח שמורות מוגבלות לשימוש כשמות משתנים.

מפעילים

ניתן להגדיר מפעיל כסמל מיוחד המסביר את המחשב לבצע מתמטיקה מסוימת הם פעולה לוגית על קבוצה של משתנים. C # כולל מגוון מפעילים המוזכרים להלן.

• מפעילי חשבון
• מפעילים יחסיים
• פעולות לוגיות
• מפעילים סיבית
• מפעילי מטלות

מפעילי חשבון

מפעילים יחסיים

פעולות לוגיות

מפעילים סיבית

מפעילי מטלות

לולאות

ל לוּלָאָה הצהרה משמשת לביצוע גוש הצהרות שוב ושוב עד שתנאי מסוים מתקיים. שפת C # מורכבת מהצהרות הלולאה הבאות.

• לולאה
• בעוד לולאה
• לעשות בזמן לולאה

לולאה

ה לולאה משמש לביצוע קטע קוד מסוים מספר רב של פעמים עד לתנאי הנתון.

תחביר

עבור (תוספת / הקטנת תנאי אתחול) {// קטע קוד}

תרשים זרימה:

דוגמא:

באמצעות מחלקה ציבורית מערכת ForExample {public static void Main (string [] args) {for (int i = 1 i<= 5 i++) { Console.WriteLine(i) } } } 

//תְפוּקָה:

אחד
2
3
4
5

בעוד לולאה

ה תוך כדי לולאה משמש לביצוע קטע קוד למספר רב של פעמים עד שתנאי מסוים מתקיים.

תחביר

בעוד (תנאי) {// קוד לביצוע}

תרשים זרימה:

דוגמא:

באמצעות לולאות מרחב שמות מערכת {class Program {static void Main (string [] args) {int x = 5 while (x<= 10) { Console.WriteLine('The value of a: {0}', x) x++ } Console.ReadLine() } } } 

//תְפוּקָה:

הערך של a: 5
הערך של a: 6
הערך של a: 7
הערך של a: 8
הערך של a: 9
הערך של a: 10

לעשות בזמן לולאה

Do while loop דומה לחלוטין ל- While Loop אך ההבדל היחיד הוא שהתנאי ממוקם בסוף הלולאה. לפיכך, הלולאה מבוצעת לפחות פעם אחת.

תחביר

בצע {// קוד לביצוע} בזמן (תנאי)

תרשים זרימה:

דוגמא:

באמצעות מרחב שמות המערכת אדוריקה {class DoWhileLoop {public static void Main (string [] args) {int i = 1, n = 5, product do {product = n * i Console.WriteLine ('{0} * {1} = { 2} ', n, i, product) i ++} בעוד (i<= 10) } } } 

//תְפוּקָה:

5 * 1 = 5
5 * 2 = 10
5 * 3 = 15
5 * 4 = 20
5 * 5 = 25
5 * 6 = 30
5 * 7 = 35
5 * 8 = 40
5 * 9 = 45
5 * 10 = 50

מותנה

הצהרות מותנות משמשים לביצוע הַצהָרָה או קבוצה של הצהרות מבוסס על מצב כלשהו. אם ה מַצָב נכון אז הצהרות C # מבוצעים אחרת הבא הַצהָרָה יבוצע.

סוגים שונים של הצהרות מותנות בשפת C ++ הם כדלקמן:

1. הצהרה אם
2. הצהרה אם-אחרת
3. הצהרה מקוננת אם-אחרת
4. אם-אחרת אם סולם
5. החלף הצהרה

הצהרה אם

הרווק אם משפט בשפת C # משמש לביצוע הקוד אם תנאי אמיתי. זה נקרא גם הצהרת בחירה חד כיוונית.

תחביר

אם (ביטוי בוליאני) {// משפטים שבוצעו אם ביטוי בוליאני נכון}

תרשים זרימה:

מערך אובייקטים בתוכנית דוגמה של Java

דוגמא:

שימוש במרחב שמות מערכת מותנה {class IfStatement {public static void Main (string [] args) {int number = 2 if (number<5) { Console.WriteLine('{0} is less than 5', number) } Console.WriteLine('This statement is always executed.') } } } 

//תְפוּקָה:

2 הוא פחות מ -5
הצהרה זו מתבצעת תמיד.

הצהרה אם-אחרת

ה אחרת משפט בשפה C משמש לביצוע הקוד אם התנאי נכון או לא נכון. זה נקרא גם הצהרת בחירה דו-כיוונית.

תחביר

אם (ביטוי בוליאני) {// משפטים שבוצעו אם ביטוי בוליאני נכון} אחר {// משפטים שבוצעו אם ביטוי בוליאני הוא שקר}

תרשים זרימה:

דוגמא:

באמצעות מרחב שמות מערכת מותנה {class IfElseStatement {public static void Main (string [] args) {int number = 12 if (number<5) { Console.WriteLine('{0} is less than 5', number) } else { Console.WriteLine('{0} is greater than or equal to 5', number) } Console.WriteLine('This statement is always executed.') } } } 

//תְפוּקָה:

12 גדול או שווה ל -5
הצהרה זו מתבצעת תמיד.

הצהרה מקוננת אם-אחרת

המקונן אחרת הצהרה משמשת כאשר תוכנית דורשת יותר מביטוי בדיקה אחד. זה נקרא גם הצהרת בחירה רב-כיוונית. כאשר סדרה של ההחלטה מעורבת בהצהרה, אנו משתמשים בה אחרת הצהרה בצורה מקוננת.

תחביר

אם (ביטוי בוליאני) {if (nested-expression-1) {// קוד לביצוע} אחר {// קוד לביצוע}} אחר {if (nested-expression-2) {// קוד לביצוע } אחר {// קוד לביצוע}}

תרשים זרימה:

דוגמא:

באמצעות מרחב שמות מערכת מותנה {class Nested {public static void Main (string [] args) {int first = 7, second = -23, third = 13 if (first & gt second) {if (first
 //תְפוּקָה: 
13 הוא הגדול ביותר
 סולם אחר אם 
ה  אם-אם-אם  משפט משמש להוצאת קוד אחד ממספר תנאים. זה נקרא גם הצהרת החלטה מרובת נתיבים. זוהי שרשרת של הצהרות if..else בהן כל הצהרת if קשורה לאמירה אחרת אם הצהרה אחרונה תהיה הצהרה אחרת.
 תחביר 
אם (תנאי 1) {// קוד לביצוע אם תנאי 1 נכון} אחרת אם (תנאי 2) {// קוד לביצוע אם תנאי 2 אמיתי} אחרת אם (תנאי 3) {// קוד שיש לבצע אם תנאי 3 אמיתי} ... אחרת {// קוד שיש לבצע אם כל התנאים כוזבים}
 תרשים זרימה: 
 דוגמא: 
באמצעות מחלקת מערכת Edureka {public static void Main (String [] args) {int i = 20 if (i == 10) Console.WriteLine ('i is 10') אחרת if (i == 15) Console.WriteLine (' אני 15 ') אחר אם (i == 20) Console.WriteLine (' i is 20 ') אחר Console.WriteLine (' אני לא קיים ')}}
 //תְפוּקָה: 
אני בן 20
 החלף הצהרה 
 החלף  הצהרה משמשת כתחליף לסולם ארוך אם-אם-אחר שמשמש לבדיקת רשימת מקרים. משפט מתג מכיל תווית מקרה אחת או יותר שנבדקות על פי ביטוי המתג. כאשר הביטוי תואם למקרה, ההצהרות הקשורות למקרה זה יבוצעו.
 תחביר 
switch (משתנה / ביטוי) {case value1: // משפטים מבוצעים אם ביטוי (או משתנה) = value1 break value case2: // משפטים מבוצעים אם ביטוי (או משתנה) = value1 break ... ... ... .. ... ... ברירת מחדל: // הצהרות מבוצעות אם אין מקרה שתואם}
 תרשים זרימה: 
 דוגמא: 
באמצעות מרחב שמות מערכת מותנה {class SwitchCase {public static void Main (string [] args) {char ch Console.WriteLine ('Enter alphabet') ch = Convert.ToChar (Console.ReadLine ()) switch (Char.ToLower (ch )) {case 'a': Console.WriteLine ('Vowel') case case break 'e': Console.WriteLine ('Vowel') case break 'i': Console.WriteLine ('Vowel') case case break 'o': Console.WriteLine ('Vowel') case break 'u': Console.WriteLine ('Vowel') break default: Console.WriteLine ('Not a vowel') break}}}}
 //תְפוּקָה: 
הזן אלפבית 
 הוא 
 תְנוּעָה
 מיתרים 
 חוּט סוג הנתונים הוא חבר ב- מערכת. מחרוזת מעמד. הוא מסוגל לאחסן את סוג הדמות של הנתונים. אנו יכולים לבצע פעולות שונות על סטינגס כגוןשרשור, השוואה, קבלת תשתית, חיפוש, גזירה, החלפה ועוד רבים אחרים.
 האנלוגיה של מחרוזת ומיתר 
ב- C # חוּט ו חוּט שווים. המילה מחרוזת היא a מילת מפתח ומתנהג כמו מערכת. מחרוזת מעמד. אנו יכולים להשתמש באחת הגרסאות כדי להכריז על מחרוזות.
 תחביר: 
מחרוזת s1 = 'אדוריקה' // יצירת מחרוזת באמצעות מילת מפתח מחרוזת מחרוזת s2 = 'למידה שמחה' // יצירת מחרוזת באמצעות מחלקה מחרוזת
 דוגמא: 
באמצעות מחלקה ציבורית מערכת StringExample {public static void Main (string [] args) {string s1 = 'Edureka' char [] ch = {'C', 's', 'h', 'a', 'r', ' p ',' ',' T ',' u ',' t ',' o ',' r ',' i ',' a ',' l '} מחרוזת s2 = מחרוזת חדשה (ch) Console.WriteLine ( s1) Console.WriteLine (s2)}}
 //תְפוּקָה: 
אדוריקה 
 הדרכה של קשארפ
 שיטות מחרוזת ב- C # 
 שיטה 
 תיאור 
 שיבוט () 
משמש להחזרת הפניה למופע זה של String.
 השווה (מחרוזת, מחרוזת) 
משמש להשוואה בין שני אובייקטי מחרוזת שצוינו.
 קונקאט (מחרוזת, מחרוזת) 
לשרשר שני מופעים שצוינו של מחרוזת.
 מכיל (מחרוזת) 
החזר ערך המציין מחרוזת משנה שצוינה
 העתק (מחרוזת) 
משמש ליצירת מופע חדש של מחרוזת עם אותו ערך
 CopyTo (Int, Char [], Int, Int) 
מעתיק תווים ממיקום מוגדר
 שווה (מחרוזת, מחרוזת) 
קובע כי שני אובייקטים מחרוזת הם בעלי אותו ערך.
 פורמט (מחרוזת, אובייקט) 
החלף פריט פורמט אחד או יותר במחרוזת שצוינה
 IndexOf (מחרוזת) 
מדווח על האינדקס מבוסס האפס של ההתרחשות הראשונה
 הכנס (Int32, מחרוזת) 
מחזיר מחרוזת חדשה בה מחרוזת מוכנסת לאינדקס.
 IsInterned (מחרוזת) 
מציין כי מחרוזת זו נמצאת בצורת נורמליזציה של Unicode C.
 IsNullOrEmpty (מחרוזת) 
מציין שהמחרוזת שצוינה היא null או מחרוזת ריקה.
 IsNullOrWhiteSpace (מחרוזת) 
משמש לציין אם מחרוזת שצוינה היא ריק, ריק,
 הצטרף (מחרוזת, מחרוזת []) 
משמש לשרשור כל האלמנטים של מערך מחרוזות
 LastIndexOf (Char) 
מדווח על מיקום אינדקס מבוסס אפס של התו האחרון
 LastIndexOfAny (Char []) 
מדווח על מיקום אינדקס מבוסס אפס של התו האחרון
 הסר (Int32) 
מחזירה מחרוזת חדשה בה כל התווים
 החלף (מחרוזת, מחרוזת) 
מחזירה מחרוזת חדשה שבה כל המופעים של מחרוזת
 פיצול (אות []) 
הוא משמש לפיצול מחרוזת למיתרים
 StartsWith (מחרוזת) 
הוא משמש כדי לבדוק אם תחילת מחרוזת זו
 מיתר (Int32) 
הוא משמש לאחזור מצע ממופע זה.
 ToCharArray () 
מעתיק את התווים במקרה זה למערך Unicode.
 ToString () 
הוא משמש להחזרת המופע של String.
 מְטוּפָּח() 
גוזם את החוט
  
מערכים 
בדומה לשפות תכנות אחרות, ל- C # יש מערכים. מערכים הם מבני הנתונים הפשוטים שנועדו לאחסן את אותו סוג נתונים של אלמנטים במיקום זיכרון רציף.
C # תומך בסוגי המערך הבאים.
מערך יחיד ממדי
מערך רב מימדי
מערך משונן
 מערך יחיד ממדי 
מערך יחיד מימדי מאחסן אלמנטים בצורת שורה אחת אחת.
 תחביר 
int [] arr = int int [5] // יצירת מערך
 דוגמא: 
באמצעות מחלקה ציבורית מערכת ArrayExample {public static void Main (string [] args) {int [] arr = new int [5] arr [0] = 10 arr [1] = 20 arr [2] = 30 arr [3] = 40 arr [4] = 50 עבור (int i = 0 i 
 //תְפוּקָה: 
10 
 עשרים 
 30 
 40 
 חמישים
 מערך רב מימדי 
מערך רב מימדי מאחסן אלמנטים בצורת ממדים מרובים כמו מטריצה ​​וקוביה וכו '.
 תחביר 
int val = a [2,3]
 דוגמא: 
באמצעות מרחב שמות מערכת ArrayApplication {class MyArray {static void Main (string [] args) {int [,] a = new int [5, 2] {{0, 0}, {1, 2}, {2, 4}, {3, 6}, {4, 8}} int i, j עבור (i = 0 i<5 i++) { for (j = 0 j < 2 j++) { Console.WriteLine('a[{0},{1}] = {2}', i, j, a[i, j]) } } Console.ReadKey() } } } 
 //תְפוּקָה: 
a [0,0] = 0 
 a [0,1] = 0 
 a [1,0] = 1 
 a [1,1] = 2 
 a [2,0] = 2 
 [2,1] = 4 
 [3,0] = 3 
 [3,1] = 6 
 [4,0] = 4 
 [4,1] = 8
  
 מערך משונן 
מערך משונן הוא פשוט מערך מערכים.
 דוגמא: 
באמצעות מרחב שמות מערכת ArrayApplication {class MyArray {static void Main (string [] args) {int [] [] a = new int [] [] {new int [] {0,0}, int int [] {1,2 }, int int [] {2,4}, int int [] {3, 6}, int int [] {4, 8}} int i, j for (i = 0 i<5 i++) { for (j = 0 j < 2 j++) { Console.WriteLine('a[{0}][{1}] = {2}', i, j, a[i][j]) } } Console.ReadKey() } } } 
 //תְפוּקָה: 
[0] [0] = 0 
 [0] [1] = 0 
 [1] [0] = 1 
 [1] [1] = 2 
 [2] [0] = 2 
 [2] [1] = 4 
 [3] [0] = 3 
 [3] [1] = 6 
 [4] [0] = 4 
 [4] [1] = 8
 אוספים 
איסוף יכול להיחשב פשוט כקבוצת אובייקטים שנאספה יחד כדי להחיל כמה פונקציות על הנתונים שנאספו. הפעולות שאפשר לבצע פעם אחת באוסף הן,
חפץ חנות
עדכון אובייקט
מחק אובייקט
אחזר אובייקט
אובייקט חיפוש, ו
למיין אובייקט
 סוגי אוספים 
ישנן שלוש אפשרויות שונות לעבוד עם אוספים. שלושת מרחבי השמות מוזכרים להלן:
 מערכת. אוספים. גנריים  שיעורים
 מערכת. אוספים  שיעורים
 מערכת.קולקציות.מקביל  שיעורים
למחלקה System.Collections.Generic יש את סוגי המחלקות הבאים:
רשימה
לַעֲרוֹם
תוֹר
רשימה מקושרת
HashSet
SortedSet
מילון
מיון מילון
SortedList
ה מערכת. אוספים שיעורים נחשבים כשיעורי מורשת. הם כוללים את השיעורים הבאים.
רשימת מערך
לַעֲרוֹם
תוֹר
טבלת גיבוב
ה מערכת.קולקציות.מקביל  שיעוריםמרחב השמות מספק שיעורים לפעולות הבטוחות בחוט. כעת מספר אשכולות לא ייצרו בעיה בגישה לפריטי האוסף. השיעורים הקיימים בזה הם,
BlockingCollection
ConcurrentBag
ConcurrentStack
ConcurrentQueue
במקביל מילון
מחיצות
מחיצות
ניתן להזמנה
 רשימה 
ה רשימה נחשב כמבנה נתונים הקיים ב System.Collection.Generics מרחב שמות. זה יכול לאחסן ולהביא אלמנטים. הרשימה מסוגלת לאחסן אלמנטים כפולים.
 דוגמא: 
שימוש במערכת באמצעות System.Collections. מחלקה ציבורית כללית אדוריקה {חלל סטטי ציבורי Main (string [] args) {var names = new List () names.Add ('Sandhya') names. Add ('Arun') names.Add ( שמות 'פרשנת'). הוסף ('קיראן') foreach (שם שם בשמות) {Console.WriteLine (שם)}}}
 //תְפוּקָה: 
סנדייה 
 ארון 
 פרשנת 
 קירן
 סט האש 
C # HashSetקטגוריה נהוגה לעתים קרובותחנות,להסיראוֹלקרוא רכיבים. זהלאשכפול חנותרכיבים.זה דחוףלהשתמש HashSet  קטגוריהאםיש לךלאחסןאך ורק  מְיוּחָד   רכיבים . שֶׁלָה נמצא במרחב השמות System.Collections.Generic.
 דוגמא: 
באמצעות מערכת באמצעות System.Collections. מחלקה ציבורית כללית אדוריקה {public static void Main (string [] args) {var names = new HashSet () names.Add ('Sunil') names. Add ('Amar') names.Add ( שמות 'Pujari'). הוסף ('Imran') שמות. הוסף ('karan') foreach (var name in names) {Console.WriteLine (name)}}}
 //תְפוּקָה: 
סוניל 
 עמר 
 פוג'ארי 
 עמרן 
 קראן
 סט ממוין 
C # SortedSetהכיתה רגילה לעיתים קרובותחנות, לְהַסִיר אוֹ לקרוא   אלמנטים . זה שומר על סדר עולהלאשכפול חנותאלמנטים.זה מהירלהשתמש ב- SortedSetקטגוריהאםיש לךלאחסן מְיוּחָד   רכיבים ולשמור על סדר עולה.שֶׁלָהנמצא במרחב השמות System.Collections.Generic.
 דוגמא: 
שימוש במערכת באמצעות System.Collections. מחלקה ציבורית כללית אדוריקה {public static void Main (string [] args) {var names = new SortedSet () names.Add ('Sanjay') names. Add ('Anuradha') names.Add ( שמות 'Praveen'). הוסף ('Ravi') שמות. הוסף ('Kajol') foreach (var name in names) {Console.WriteLine (name)}}}
 //תְפוּקָה: 
Anuradha 
 קאג'ול 
 פראווין 
 ראווי 
 סנג'אי
 לַעֲרוֹם 
ה לַעֲרוֹם הוא אוסף פשוט שאחריו קָצֶה או תחילה בהליך החוצה האחרון בעת ​​עיבוד האלמנטים המאוחסנים בו.
 דוגמא: 
שימוש במערכת באמצעות System.Collections.Generic public class Edureka {public static void Main (string [] args) {שמות מחסנית = שמות מחסנית חדשים () שמות. ('צ'אנדאן') שמות. שמות דחיפה ('פוג'ה'). שמות 'ג'יימס'. דחוף ('ראג'ש') שמות. דחף ('קומאר') foreach (שם מחרוזת בשמות) {Console.WriteLine (name)} Console.WriteLine ('אלמנט הצצה:' + names.Peek () ) Console.WriteLine ('Pop:' + names.Pop ()) Console.WriteLine ('אחרי פופ, אלמנט מציץ:' + names.Peek ())}}
 //תְפוּקָה: 
קומאר 
 ראג'ש 
 ג'יימס 
 פוג'ה 
 צ'אנדן 
 אלמנט מציץ: קומאר 
 פופ: קומאר 
 אחרי פופ, אלמנט הצצה: ראג'ש
 תוֹר 
התור דומה לחלוטין ל- Stack אך ההבדל היחיד הוא שהתור עוקב אחריו פיפו או עיקרון ראשונה והתחלה בזמן עיבוד האלמנטים המאוחסנים בו.
 דוגמא: 
שימוש במערכת באמצעות System.Collections. מחלקה ציבורית כללית אדוריקה {חלל סטטי ציבורי ראשי (מחרוזת [] args) {שמות תורים = שמות תורים חדשים (). שמות אנקווה ('סרוג'אן') שמות אנקווה ('פראג'אט'). אנקווה ( שמות 'ג'ון'. שמות Enqueue ('Raju'). Enqueue ('Hari') foreach (שם מחרוזת בשמות) {Console.WriteLine (name)} Console.WriteLine ('אלמנט מציץ:' + names.Peek () ) Console.WriteLine ('Dequeue:' + names.Dequeue ()) Console.WriteLine ('After Dequeue, Peek element:' + names.Peek ())}}
 //תְפוּקָה: 
סרוג'אן 
 Prajat 
 ג'ון 
 עַז 
 יְוֹם 
 אלמנט מציץ: סרוג'אן 
 דקו: סרוג'אן 
 אחרי דקו, אלמנט מציץ: פראג'אט
 רשימה מקושרת 
הרשימה המקושרת היא אוסף זיכרון דינמי. האלמנטים ברשימה המקושרים נשמרים על ידי גישה לזיכרון מהערמה ואחסון האלמנטים בסדר רציף על ידי קישור כתובותיהם.
 דוגמא: 
שימוש במערכת באמצעות System.Collections. מחלקה ציבורית כללית אדוריקה {public static void Main (string [] args) {var names = new LinkedList () names.AddLast ('Rajat') names.AddLast ('Arun') names.AddLast ( שמות 'Prakash' ).AddLast ('jay') names.AddFirst ('sai') foreach (var name in names) {Console.WriteLine (name)}}}
 //תְפוּקָה: 
סיי 
 גבולות 
 ארון 
 פראקש 
 עוֹרְבָנִי
 מילון 
 מילון  קטגוריהמשתמש ב-רַעְיוֹןשל החשיפה. זה שומר על ערכיםהנחת היסודשל המפתח. זה מכילמְיוּחָדמקשיםאך ורק. על ידיהסיועשל מפתח,אנחנו פשוטחיפוש אולקחת אלמנטים.שֶׁלָהנמצא במרחב השמות System.Collections.Generic.
 דוגמא: 
שימוש במערכת באמצעות System.Collections. מחלקה ציבורית כללית Edureka {public static void Main (string [] args) {שמות מילון = שמות מילון חדשים (). הוסף שמות ('1', 'שיווה'). הוסף ('2', שמות 'Prasad'). הוסף ('3', 'Preetam') שמות. הוסף ('4', 'Roy') שמות. הוסף ('5', 'Akash') foreach (KeyValuePair kv בשמות) {Console. WriteLine (kv.Key + '' + kv.Value)}}}
 //תְפוּקָה: 
שיווה 1 
 2 פרסאד 
 3 פרתאם 
 4 רוי 
 5אקש
 מילון ממוין 
ה מיון מילון  קטגוריהמשתמש ב-לְעַצֵבשל החשיפה. זה שומר על ערכיםהרעיוןשל המפתח. זה מכילמְיוּחָדמקשים ושומרים על סדר עולה בהרעיוןשל המפתח. על ידיהסיועשל מפתח,אנחנו פשוטחיפוש אולקחת אלמנטים.שֶׁלָהנמצא במרחב השמות System.Collections.Generic.
 דוגמא: 
שימוש במערכת באמצעות System.Collections. מחלקה ציבורית כללית אדוריקה {public static void Main (string [] args) {SortedDictionary names = new SortedDictionary () names. Add ('1', 'Arun') names.Add ('4', שמות 'Vishal'). הוסף ('5', 'Ramesh') שמות. הוסף ('3', 'Vidya') שמות. הוסף ('2', 'Pallavi') foreach (KeyValuePair kv בשמות) {Console. WriteLine (kv.Key + '' + kv.Value)}}}
 //תְפוּקָה: 
שיווה 1 
 2 פרסאד 
 3 פרתאם 
 4 רוי 
 5אקש
 מיון רשימה 
ה SortedList הואanמערך זוגות מפתח / ערך. זה שומר על ערכיםהנחת היסודשל המפתח. רשימת ה- SortedListקטגוריהמכילמְיוּחָדמקשים ושומרים על סדר עולה בהנחת היסודשל המפתח. על ידיהסיועשל מפתח,אנחנו מסוגלים בפשטותחפש או הסראלמנטים.שֶׁלָהנמצא ב מערכת. אוספים. גנריים מרחב שמות.
כיצד ליישם hashmap
 דוגמא: 
שימוש במערכת באמצעות System.Collections. מחלקה ציבורית כללית אדוריקה {public static void Main (string [] args) {SortedDictionary names = new SortedDictionary () names. Add ('1', 'Arun') names.Add ('4', שמות 'Vishal'). הוסף ('5', 'Ramesh') שמות. הוסף ('3', 'Vidya') שמות. הוסף ('2', 'Pallavi') foreach (KeyValuePair kv בשמות) {Console. WriteLine (kv.Key + '' + kv.Value)}}}
 //תְפוּקָה: 
1 ארון 
 2 פלאווי 
 3 וידיה 
 4 וישאל 
 5ראמש
 מִבְנֶה 
המבנה הוא סוג נתונים מוגדר על ידי המשתמש שנועד לאחסן מספר אלמנטים מסוג הנתונים השונה. המבנה מוכרז באמצעות מילת המפתח struct. 
 דוגמא: 
שימוש במערכת Struct Books ספרים {כותרת מחרוזת ציבורית מחרוזת ציבורית מחבר מחרוזת ציבורית נושא public int book_id} מחלקה ציבורית אדוריקה {public static void Main (string [] args) {Books Book1 Books Book2 Book1.title = 'C # Programming' Book1.author = ' Ramchandra Kumar 'Book1.subject =' C ++ Tutorial Programming 'Book1.book_id = 95908978 Book2.title =' חיוב בטלקום 'Book2.author =' Karan 'Book2.subject =' מדריך חיוב בטלקום 'Book2.book_id = 18674900 Console.WriteLine ( 'כותרת של ספר 1: {0}', Book1.title) Console.WriteLine ('Book 1 Author: {0}', Book1.author) Console.WriteLine ('ספר 1 נושא: {0}', Book1.subject) Console.WriteLine ('ספר 1 של ספר: {0}', Book1.book_id) Console.WriteLine ('כותרת ספר 2: {0}', Book2.title) Console.WriteLine ('ספר 2 מחבר: {0}', Book2.author) Console.WriteLine ('נושא ספר 2: {0}', Book2.subject) Console.WriteLine ('ספר 2 book_id: {0}', Book2.book_id) Console.ReadKey ()}}
 //תְפוּקָה: 
כותרת ספר 1: C # Programming 
 ספר 1 מחבר: רמצ'נדרה קומאר 
 נושא ספר 1: הדרכת תכנות C ++ 
 ספר 1 ספר_יד: 95908978 
 כותרת ספר 2: חיוב טלקום 
 ספר 2 מחבר: קארן 
 נושא ספר 2: מדריך חיוב בטלקום 
 ספר 2 ספר_יד: 18674900
 פונקציות 
הפונקציה מוגדרת כגוש קוד של הקוד הראשי. הפונקציה משמשת לביצוע הצהרות שצוינו בבלוק הקוד. פונקציה מורכבת מהרכיבים הבאים.
 שם פונקציה:  זהו שם ייחודי המשמש לביצוע שיחת פונקציה.
 סוג החזרה:  הוא מציין את סוג הנתונים של ערך החזרת הפונקציה.
 גוּף:  הוא מכיל הצהרות הפעלה.
 מפרט גישה:  זה מציין נגישות פונקציות ביישום.
 פרמטרים:  זוהי רשימת טיעונים שנוכל להעביר לפונקציה במהלך השיחה.
 תחביר 
FunctionName () {// body function // statement return}
 דוגמא: 
באמצעות מרחב שמות מערכת פונקציה לדוגמא {class Edureka {מחרוזת ציבורית Show (מחרוזת הודעה) {Console.WriteLine ('Inside Show Function') הודעה חוזרת} ריק ריק סטטי Main (string [] args) {Edureka program = new Edureka () message string = program .Show ('To Edureka') Console.WriteLine ('ברוך הבא' + הודעה)}}}
 //תְפוּקָה: 
פונקציית מופע פנים 
 ברוך הבא לאדוריקה
ניתן לבצע פונקציות בשלוש דרכים שונות:
התקשר לפי ערך
התקשר לפי הפניה
פרמטר החוצה
 התקשר לפי ערך 
ב- C #, ערך  -סוּג פרמטריםהםזה עוברהעתקבעל ערך מקורי לפונקציה במקוםהתייחסות. זהלאלְשַׁנוֹתהערך הראשון. Anהתיקון נוצרעברערך לאגילהערך המסוים.בתוך ההדוגמה הבאה,יש לנולַעֲבוֹרערך לאורך כל הדרךהשִׂיחָה.
 דוגמא: 
באמצעות מרחב שמות מערכת CallByValue {class Edureka {Public void Show (int val) {val * = val Console.WriteLine ('הערך בתוך פונקציית ההצגה' + val)} ריק סטטי Main (string [] args) {int val = 50 תוכנית Edureka = תוכנית Edureka () חדשה Console.WriteLine ('ערך לפני קריאת הפונקציה' + val). Show (val) Console.WriteLine ('ערך לאחר קריאה לפונקציה' + val)}}
//תְפוּקָה:
ערך לפני קריאה לפונקציה 50 
 הערך בתוך פונקציית ההצגה 2500 
 ערך לאחר קריאה לפונקציה 50
 התקשר לפי הפניה 
בשיטת שיחה לפי הפניה,ל נ'צ מילת מפתח כדי להעביר את הטיעון כסוג הפניה. זה מעביר את התייחסות הטיעונים לפונקציה ולא להעתק של הערך המקורי. השינויים בערכים שעברו הם קבועים ו לְשַׁנוֹת ערך המשתנה המקורי.
 דוגמא: 
באמצעות מרחב שמות מערכת CallByReference {class Edureka {Show public void (ref int val) {val * = val Console.WriteLine ('הערך בתוך פונקציית show' + val)} ריק סטטי Main (string [] args) {int val = 50 תוכנית אדוריקה = תכנית Edureka () חדשה Console.WriteLine ('ערך לפני קריאת הפונקציה' + val). הצגת (ref val) Console.WriteLine ('ערך לאחר קריאת הפונקציה' + val)}}
//תְפוּקָה:
ערך לפני קריאה לפונקציה 50 
 הערך בתוך פונקציית ההצגה 2500 
 ערך לאחר קריאה לפונקציה 2500
 פרמטר החוצה 
הפרמטר החוצהמספק הַחוּצָה מילת מפתח להעברת טיעונים כ- out-type. זה כמו סוג הפניה, אלא שהוא לא דורש לאתחל את המשתנה לפני המעבר. אנחנו חייבים להשתמש הַחוּצָה מילת מפתח להעביר את הטיעון כ- out-type. זה שימושי כאשר אנו רוצים שפונקציה תחזיר מספר ערכים.
 דוגמא: 
באמצעות מרחב שמות מערכת OutParameter {class Edureka {public void Show (out int val) {int square = 5 val = square val * = val} ריק סטטי Main (string [] args) {int val = 50 תוכנית Edureka = Edureka new () תוכנית Console.WriteLine ('ערך לפני העברת משתנה' + val). Show (out val) Console.WriteLine ('ערך לאחר קבלת המשתנה החוצה' + val)}}
//תְפוּקָה:
ערך לפני העברת משתנה 50
ערךלאחר קבלת משתנה החוצה 25
עכשיו בואו נעבור לתכנות מונחה עצמים
 תכנות מונחה עצמים 
 תכנות מונחה עצמים מערכתהיא פרדיגמת תכנות המבוססת על הרעיון של חפצים המכילים חברי נתונים ו שיטות קשור אליהם. המטרה העיקרית של תכנות מונחה עצמים היא להגדיל את הגמישות ותחזוקת התוכניות
 תכונות של תכנות מונחה עצמים: 
זה שם דגש יותר על נתונים ולא על הליך.
התוכניות מחולקות לאובייקטים ובכך קל לעבוד איתן.
מבני נתונים מתוכננים בצורה כזו שהם מאפיינים את האובייקטים.
פונקציות שעובדות עַלהנתונים של אובייקט ממוקמים יחד במבנה הנתונים.
נתונים מוסתרים ולא ניתן לגשת אליהם באמצעות פונקציות חיצוניות ללא הרשאה.
תקשורת בין אובייקטים יכולה להתרחש בעזרת פונקציות.
הוספת נתונים ופונקציות חדשים הפכה להיות קלה.
עוקב אחר הגישה מלמטה למעלה בעיצוב התוכניות.
הפרדיגמות המכוונות עצמים ב- C # הן כדלקמן
 ספירה ב- C # 
 גישת תכנות מונחה עצמים 
 כימוס 
 הַפשָׁטָה 
 מִמְשָׁק 
 רב צורתיות 
 יְרוּשָׁה 
 עומס יתר ועקיפות 
 מרחב שמות 
 פעולות קבצים 
 אירועים 
 גנריות 
 צירים 
 הִשׁתַקְפוּת 
 ספירה ב- C # 
 Enum או נקרא גם בשם ספירה ב- C # משמש לאחסון ערכים קבועים ללא צורך לשנות אותם במהלך כל הביצוע של תוכנית C #. זהמשמש לאחסון קבוצה של קבועים בשם, כגון עונה, ימים, חודש, גודל וכו '
 דוגמא: 
שימוש בכיתה ציבורית מערכת Enum דוגמה {שבוע enum ציבורי {שני, שלישי, יום רביעי, חמישי, שישי, שבת, ראשון} ריק סטטי ציבורי ראשי () {int x = (int) שבוע. יום שני int y = (int) שבוע. יום שישי המסוף .WriteLine ('יום שני = {0}', x) Console.WriteLine ('יום שישי = {0}', y)}}
 //תְפוּקָה: 
יום שני = 0 
 יום שישי = 4
 גישת תכנות מונחה עצמים 
ניתן להשיג את סגנון התכנות מונחה האובייקטים על ידי ביצוע השיטות שנקבעו להלן.
 כימוס 
  
 כימוס היא שיטה לשלב את שיטות יחד עם שלהם חברי נתונים. 
 דוגמא: 
באמצעות מרחב שמות מערכת Edureka {class מלבן {אורך כפול ציבורי רוחב כפול ציבורי כפול ציבורי GetArea () {אורך החזרה * רוחב} ציבורי ריק ריק () {Console.WriteLine ('אורך: {0}', אורך) Console.WriteLine (' רוחב: {0} ', רוחב) Console.WriteLine (' אזור: {0} ', GetArea ())}} מחלקה ExecuteRectangle {סטטי ריק ריק (מחרוזת [] טענות) {מלבן r = מלבן חדש () r.length = 50 r.width = 35 r.Display () Console.ReadLine ()}}}
 //תְפוּקָה: 
אורך: 50 
 רוחב: 35 
 אזור: 1750
 הַפשָׁטָה 
 הַפשָׁטָה היא שיטה ל להתחבא חלק הקידוד המורכב מהמשתמש בכך שהוא מספק לו רק את המידע הדרוש לו הוא זקוק.
 דוגמא: 
באמצעות מערכת ציבורי מופשט ציבורי מערכת ציבורי {ציבורי תקציר ריק ()} מחלקה ציבורית מלבן: צורה {צירוף ציבורי בטל ציבורי () {Console.WriteLine ('מלבן ציור ...')}} מעמד ציבורי מעגל: צורה {ביטול ציבורי בטל צייר () {Console.WriteLine ('מעגל ציור ...')}} מחלקה ציבורית TestAbstract {חלל סטטי ציבורי ראשי () {צורה ss = מלבן חדש () s.draw () s = מעגל חדש () s.draw ()}}
 //תְפוּקָה: 
מלבן ציור ... 
 מעגל ציור ...
 מִמְשָׁק 
  
ה מִמְשָׁק דומה לחלוטין להפשטה. הפונקציונליות של ממשק היא להסתיר את הנתונים הלא חשובים מהמשתמש ולספק לו את הנתונים החשובים היחידים שהוא זקוק להם.
 דוגמא: 
באמצעות ממשק ציבורי של מערכת שרטוט {void draw ()} class public מלבן: Drawable {public void draw () {Console.WriteLine ('מלבן ציור ...')}} מחלקה ציבורית מעגל: Drawable {צייר חלל ציבורי () {Console .WriteLine ('ציור מעגל ...')}} מחלקה ציבורית TestInterface {public static void Main () {Drawable dd = new מלבן () d.draw () d = מעגל חדש () d.draw ()}}
 //תְפוּקָה: 
מלבן ציור ... 
 מעגל ציור ...
 רב צורתיות 
רב צורתיותהוא השילוב של 'פולי' + 'מורפס' שמשמעותו צורות רבות. זו מילה יוונית. המשמעות היא שקטע הקוד יכול ללבוש מספר צורות. יש לנו שני סוגים של פולימורפיזם.
הידור פולימורפיזם זמן
הפעל פולימורפיזם זמן
 דוגמא: 
באמצעות מערכת מחלקה ציבורית חיה {ציבור מחרוזת color = 'לבן'} מחלקה ציבורית כלב: חיה {מחרוזת ציבורית color = 'black'} מחלקה ציבורית TestSealed {public static void Main () {Animal d = new Dog () Console.WriteLine ( d.color)}}
 //תְפוּקָה: 
לבן
 יְרוּשָׁה 
 יְרוּשָׁה הוא תהליך בו אובייקט אחד רוכש את כל המאפיינים וההתנהגויות של האובייקט האב שלו באופן אוטומטי. אתה יכול לעשות שימוש חוזר, להרחיב או לשנות את התכונות וההתנהגויות המוגדרים במחלקה אחרת. הכיתה אשר יורשת את חברי כיתה אחרת נקראת מחלקה נגזרת והמעמד שחבריו עוברים בירושה נקרא בסיס מעמד. המחלקה הנגזרת היא המחלקה המיוחדת למחלקת הבסיס.
מחלוקת על בינה מלאכותית יתרונות וחסרונות
 דוגמה לירושה ברמה יחידה 
באמצעות מרחב שמות של המערכת RectangleApplication {class Rectangle {מוגן כפול אורך מוגן רוחב כפול ציבורי מלבן (כפול l, כפול w) {אורך = l רוחב = w} ציבורי כפול GetArea () {אורך חזרה * רוחב} ציבורי ריק ריק () {קונסולה. WriteLine ('אורך: {0}', אורך) Console.WriteLine ('רוחב: {0}', רוחב) Console.WriteLine ('אזור: {0}', GetArea ())}} מחלקה שולחן: מלבן {פרטי עלות כפולה ציבורית שולחן (כפול l, כפול w): בסיס (l, w) {} כפול ציבורי GetCost () {עלות כפול = GetArea () * 70 עלות החזרה} תצוגה בטלנית ציבורית () {base.Display () מסוף .WriteLine ('Cost: {0}', GetCost ())}} class ExecuteRectangle {static void Main (string [] args) {שולחן t = שולחן חדש (4.5, 7.5) t.Display () Console.ReadLine () }}}
 //תְפוּקָה: 
אורך: 4.5 
 רוחב: 7.5 
 שטח: 33.75 
 עלות: 2362.5
 דוגמה לירושה מרובת רמות 
שימוש במרחב שמות המערכת InheritanceApplication {class Shape {public void setWidth (int w) {width = w} public void setHeight (int h) {height = h} מוגן int רוחב מוגן int גובה} ממשק ציבורי PaintCost {int getCost (אזור int)} מלבן מחלקה: Shape, PaintCost {public int getArea () {return (width * height)} public int getCost (area int) {return area * 70}} class RectangleTester {static void Main (string [] args) {Rectangle Rect = אזור מלבן חדש () int Rect.setWidth (5) Rect.setHeight (7) אזור = Rect.getArea () Console.WriteLine ('שטח כולל: {0}', Rect.getArea ()) Console.WriteLine ('סה'כ עלות צבע: $ {0} ', Rect.getCost (אזור)) Console.ReadKey ()}}}
 //תְפוּקָה: 
סה'כ שטח: 35 
 עלות צבע כוללת: 2450 דולר
 עומס יתר 
עומס יתר הוא מצב שיש לנו שניים או חברים המוצהרים באמצעות אותו שם. עומס יתר אפשרי גם כאשר אנו מצהירים על שתי שיטות או יותר עם אותו שם. הבה נבדוק דוגמאות לשניהם.
 העמסת יתר של חברים 
 דוגמא: 
שימוש בכיתה ציבורית מערכת אדוריקה {הוסף ציבורי סטטי ציבורי (int a, int b) {החזר a + b} הוסף סטטי ציבורי int (int a, int b, int c) {החזר a + b + c}} מחלקה ציבורית TestMemberOverloading { ריק סטטי ציבורי Main () {Console.WriteLine (Edureka.add (12, 23)) Console.WriteLine (Edureka.add (12, 23, 25))}}
 //תְפוּקָה: 
35 
 60
 שיטת עומס יתר 
 דוגמא: 
שימוש במחלקה ציבורית ציבורית מערכת אדוריקה {הוסף ציבורי סטטי int (int a, int b) {החזר a + b} צף סטטי ציבורי הוסף (float a, float b) {return a + b}} class public TestMemberOverloading {public static void Main ( ) {Console.WriteLine (Edureka.add (12, 23)) Console.WriteLine (Edureka.add (12.4f, 21.3f))}}
 //תְפוּקָה: 
35 
 33.699997
 שׁוֹלֵט 
עקיפה היא מצב שבו כיתת ילדים מגדירה את אותה השיטה אותה מגדיר ההורה גם כן. הבה נבין זאת באמצעות דוגמא קטנה.
 דוגמא: 
שימוש במחלקה ציבורית מערכת אדוריקה {public virtual void eat () {Console.WriteLine ('Eating')}} class public Dog: Edureka {public override void eat () {Console.WriteLine ('אכילת אוכל')}} class public Overriding {public static void Main () {Dog d = Dog new () d.eat ()}}
 //תְפוּקָה: 
לאכול אוכל
 מרחב שמות 
ה מרחב שמות משמש בעצם לטיפול בכיתות מרובות הקיימות בתוכנית. מרחב השמות זמין בדרכים שונות.
 מערכת.קונסולה: הנה ה מערכת הופך למרחב השמות
כדי לגשת למחלקה של מרחב שמות, עלינו להשתמש namespacename.classname. 
אנחנו יכולים להשתמש ב- באמצעות מילת מפתח גם כן.
 דוגמא: 
שימוש במערכת באמצעות ראשית באמצעות מרחב שמות שני ראשון {מחלקה ציבורית אדוריקה {חלל ציבורי ריק אומרWelcome () {Console.WriteLine ('ברוך הבא לאדוריקה')}}} מרחב שמות שני {מחלקה ציבורית Happy_Learning {חלל ציבורי sayWishes () {Console.WriteLine (' למידה מאושרת ')}}} מרחב שמות ציבורי {public static void Main () {Edureka h1 = new Edureka () Happy_Learning w1 = new Happy_Learning () h1.sayWelcome () w1.sayWishes ()}}
 //תְפוּקָה: 
ברוך הבא לאדוריקה 
 למידה מאושרת
 פעולות קבצים 
ה פעולות קבצים זמינים ב- C # הם כדלקמן:
 פעולה 
 תיאור 
 BinaryReader 
קורא נתונים פרימיטיביים מזרם בינארי.
 BinaryWriter 
כותב נתונים פרימיטיביים בפורמט בינארי.
 BufferedStream 
אחסון זמני לזרם בתים.
 מַדרִיך 
מסייע במניפולציה של מבנה ספריות.
 DirectoryInfo 
משמש לביצוע פעולות בספריות.
 DriveInfo 
מספק מידע על הכוננים.
 קוֹבֶץ 
עוזר במניפולציה של קבצים.
 FileInfo 
משמש לביצוע פעולות בקבצים.
 FileStream 
משמש לקריאה וכתיבה לכל מקום בקובץ.
 MemoryStream 
משמש לגישה אקראית לנתונים מוזרמים המאוחסנים בזיכרון.
 נָתִיב 
מבצע פעולות על מידע נתיב.
 StreamReader 
משמש לקריאת דמויות מזרם בתים.
 StreamWriter 
משמש לכתיבת דמויות לזרם.
 StringReader 
משמש לקריאה ממאגר מחרוזות.
 StringWriter 
משמש לכתיבה למאגר מחרוזות.
 FileMode 
ה FileMode הוא מונה המגדיר מספר שיטות לפתיחת קבצים. חברי ה- FileMode Enumerator מתוארים כדלקמן:
 לְצַרֵף: הוא פותח קובץ קיים ומציב את הסמן בסוף הקובץ, או יוצר את הקובץ אם הקובץ אינו קיים.
 לִיצוֹר: הוא נועד ליצור קובץ חדש.
 צור חדש: הוא נועד לציין למערכת ההפעלה כי עליה ליצור קובץ חדש.
 לִפְתוֹחַ: הוא נועד לפתיחת קובץ קיים.
 OpenOrCreate: הוא נועד לציין את מערכת ההפעלה שעליה לפתוח קובץ אם הוא קיים, אחרת עליו ליצור קובץ חדש.
 לחתוך: חתוך פותח קובץ קיים ומקצר את גודלו לאפס בתים.
 FileAccess 
 FileAccess Enumerator משמש להשגת גישה לקובץ מסוים. יש בו את החברים הבאים.
 לקרוא 
 לִכתוֹב 
 קרוא וכתוב 
 שיתוף קובץ 
ה שיתוף קובץ Enumerator משמש לשיתוף קובץ מסוים. יש בו את החברים הבאים.
 עוֹבֵר בִּירוּשָׁה: תורשתי מאפשר לטפל בתיקים להעביר ירושה לתהליכי הילד.
 אף אחד: אף אחד לא דוחה את שיתוף הקובץ הנוכחי
 לקרוא: קריאה מאפשרת פתיחת הקובץ לקריאה.
 קרוא וכתוב: ReadWrite מאפשר פתיחת הקובץ לקריאה וכתיבה.
 לִכתוֹב: כתיבה מאפשרת פתיחת הקובץ לכתיבה.
 אירועים 
אירוע ידוע בדרך כלל כפעולה שנוצרת על ידי המשתמש. זה יכול להיות לחיצת עכבר ואפילו לחיצת מקש אחת מהמקלדת. באופן דומה, בתוכניות C # יש גם אירועים. המחולל של האירוע נקרא מוֹצִיא לָאוֹר ומקבל האירוע נקרא מָנוּי. 
 מוֹצִיא לָאוֹר 
ל מוֹצִיא לָאוֹר מכיל את הגדרת האירוע והנציג. ה נציג אירוע האסוציאציה מוגדרת באובייקט זה. א מוֹצִיא לָאוֹר אובייקט מחלקה קורא לאירוע והוא מודיע לאובייקטים אחרים.
 מָנוּי 
ל מָנוּי מקבל את האירוע ומספק מנהל אירועים. ה נָצִיג בכיתת המו'ל קוראת לשיטה / אירוע מטפל של מחלקת המנויים.
 דוגמא: 
באמצעות מרחב שמות מערכת Edureka {מחרוזת ציבורי ציבורית Del (string str) class EventBlock {event Del NewEvent public EventBlock () {this.NewEvent + = new Del (this.WelcomeUser)} public string WelcomeUser (שם משתמש מחרוזת) {return 'Welcome to Edureka . '+ שם משתמש} ריק סטטי Main (string [] args) {EventBlock obj1 = new EventBlock () string result = obj1.NewEvent (' Happy Learning ') Console.WriteLine (result)}}}
 //תְפוּקָה: 
ברוך הבא לאדוריקה. למידה מאושרת
 גנריות 
 גנריות הוא מושג של מתן חברים ושיטות בכיתה עם מחזיקי מקום זמן ריצה. אנו יכולים להגדיר גנריות באמצעות סוֹגְרַיִם. הבה נבדוק את הדוגמאות הבאות.
 גנריות בכיתה 
באמצעות מרחב שמות מערכת Edureka {class GenericClass {public GenericClass (T msg) {Console.WriteLine (msg)}} מחלקת תוכנית {static void Main (string [] args) {GenericClass gen = new GenericClass ('ההודעה הזו היא מהמחלקה הכללית') ) GenericClass genI = GenericClass חדש (123) GenericClass getCh = GenericClass חדש ('E')}}
 //תְפוּקָה: 
המסר הזה הוא ממעמד גנרי 
 123 
 IS
 גנריות בשיטה 
באמצעות מרחב שמות מערכת Edureka {class GenericClass {Public void Show (T msg) {Console.WriteLine (msg)}} Program class {static void Main (string [] args) {GenericClass genC = new GenericClass () genC.Show ('This ההודעה היא מהשיטה הגנרית ') genC.Show (321) genC.Show (' H ')}}}
 //תְפוּקָה: 
המסר הזה הוא מהשיטה הגנרית 
 321 
 ה
 צירים 
ה נָצִיג משמש כהתייחסות לשיטה. בעיקרון זה כמו א מצביע פונקציה ב- C ו- C ++ אבל הרבה יותר טובים ובטוחים מסוגים. הנציג ב שיטה סטטית שיטת תמצית בלבד. בעוד הנציג ב למשל השיטה מכילה גם את השיטה וגם את המופע. השימוש הטוב ביותר בנציג הוא להשתמש בתור מִקרֶה. 
 דוגמא: 
שימוש במחשב אינטל ציבורי מחשבון (int n) מחלקה ציבורית אדוריקה {מספר int intic = 25 int intic public add (int n) {number = number + n return number} intic public stat (int n) {number = number * n return number} public static int getNumber () {return number} public static public ריק (מחרוזת [] args) {Calculator c1 = new Calculator (add) Calculator c2 = new Calculator (mul) c1 (20) Console.WriteLine ('After calculator נציג אחד, המספר החדש הוא: '+ getNumber ()) c2 (3) Console.WriteLine (' אחרי מחשבון שני נציג, המספר החדש הוא: '+ getNumber ())}}
 //תְפוּקָה: 
לאחר מחשבון נציג אחד, המספר החדש הוא: 45 
 לאחר מחשבון שניים שנציג, המספר החדש הוא: 135
 הִשׁתַקְפוּת 
ההשתקפות נדרשת כדי להשיג את המטא-נתונים בזמן ריצה. ההפניה זמינה ב מערכת. השתקפות מרחב שמות. זה דורש לבצע את השיעורים הבאים.
סוּג
MemberInfo
ConstructorInfo
MethodInfo
FieldInfo
PropertyInfo
TypeInfo
EventInfo
מודול
הַרכָּבָה
AssemblyName
מַצבִּיעַ
 סוג מחלקה 
מחלקה מסוג C # מייצגת הצהרות סוגים עבור סוגי מחלקות, סוגי ממשקים, סוגי ספירה, סוגי מערכים, סוגי ערכים
הקלד מאפיינים
רשימה של מאפיינים חשובים של מחלקות סוג מוזכרת להלן.
 תכונה 
 תיאור 
 הַרכָּבָה 
מקבל את האסיפה לסוג זה.
 AssemblyQualifiedName 
מקבל שם מוסמך לאסיפה לסוג זה.
 תכונות 
מקבל את התכונות המשויכות לסוג.
 BaseType 
מקבל את סוג הבסיס או ההורה.
 שם מלא 
מקבל את השם המלא של הסוג.
 IsAbstract 
משמש כדי לבדוק אם הסוג מופשט.
 IsArray 
משמש כדי לבדוק אם הסוג הוא מערך.
 IsClass 
משמש כדי לבדוק אם הסוג הוא Class.
 IsEnum 
משמש כדי לבדוק אם הסוג הוא Enum.
 IsInterface 
משמש כדי לבדוק אם הסוג הוא ממשק.
 IsNested 
משמש כדי לבדוק אם הסוג מקונן.
 פרימיטיבי 
משמש כדי לבדוק אם הסוג פרימיטיבי.
 IsPointer 
משמש כדי לבדוק אם הסוג הוא מצביע.
 IsNotPublic 
משמש כדי לבדוק אם הסוג אינו ציבורי.
 IsPublic 
משמש כדי לבדוק אם הסוג הוא ציבורי.
 IsSealed 
משמש כדי לבדוק אם הסוג אטום.
 ניתן לסדר 
משמש כדי לבדוק אם הסוג ניתן לסידור.
 MemberType 
משמש כדי לבדוק אם הסוג הוא סוג חבר מהסוג המקונן.
 מודול 
מקבל את המודול מהסוג.
 שֵׁם 
מקבל את שם הסוג.
 מרחב שמות 
מקבל את מרחב השמות של הסוג.
 תכונה 
 תיאור 
 GetConstructors () 
מחזירה את כל הבונים הציבוריים לסוג.
 GetConstructors (BindingFlags) 
מחזירה את כל הבונים לסוג עם BindingFlags שצוינו.
 GetFields () 
מחזירה את כל השדות הציבוריים עבור הסוג.
 GetFields (BindingFlags) 
מחזירה את כל הבונים הציבוריים עבור הסוג עם BindingFlags שצוינו.
 GetMembers () 
מחזיר את כל חברי הציבור לסוג.
 GetMembers (BindingFlags) 
מחזיר את כל החברים לסוג עם BindingFlags שצוינו.
 GetMethods () 
מחזירה את כל השיטות הציבוריות עבור הסוג.
 GetMethods (BindingFlags) 
מחזיר את כל השיטות לסוג עם BindingFlags שצוינו.
 GetProperties () 
מחזירה את כל הנכסים הציבוריים עבור הסוג.
 GetProperties (BindingFlags) 
מחזירה את כל המאפיינים עבור הסוג עם BindingFlags שצוינו.
 GetType () 
מקבל את הסוג הנוכחי.
 GetType (מחרוזת) 
מקבל את הסוג עבור השם הנתון.
 דוגמאות להשתקפות: 
 קבל סוג 
 דוגמא: 
באמצעות מחלקה ציבורית ציבורית GetType {public static void Main () {int a = 10 Type type = a.GetType () Console.WriteLine (type)}}
 //תְפוּקָה: 
מערכת. Int32
 
 קבל הרכבה 
 דוגמא: 
שימוש במערכת באמצעות מחלקה ציבורית System.Reflection GetAssembly {public static void Main () {Type t = typeof (System.String) Console.WriteLine (t.Assembly)}}
 //תְפוּקָה: 
System.Private.CoreLib, גרסה = 4.0.0.0, תרבות = ניטראלית, PublicKeyToken = 7cec85d7bea7798e
 
 מידע על סוג ההדפסה 
 דוגמא: 
שימוש במערכת באמצעות מחלקה ציבורית System.Reflection PrintType {public static void Main () {Type t = typeof (System.String) Console.WriteLine (t.FullName) Console.WriteLine (t.BaseType) Console.WriteLine (t.IsClass) Console.WriteLine (t.IsEnum) Console.WriteLine (t.IsInterface)}}
 //תְפוּקָה: 
נָכוֹן 
 שֶׁקֶר 
 שֶׁקֶר
 
 בוני הדפסה 
 דוגמא: 
שימוש במערכת באמצעות System.Reflection בכיתה ציבורית PrintConstructors {public static void Main () {Type t = typeof (System.String) Console.WriteLine ('Constructors of {0} type ...', t) ConstructorInfo [] ci = t .GetConstructors (BindingFlags.Public | BindingFlags.Instance) foreach (ConstructorInfo c in ci) {Console.WriteLine (c)}}}
 //תְפוּקָה: 
בונים מסוג מערכת מיתרים ... 
 בטל .ctor (Char []) 
 בטל .ctor (Char [], Int32, Int32) 
 בטל .ctor (Char *) 
 בטל .ctor (Char *, Int32, Int32) 
 Void .ctor (SByte *) 
 Void .ctor (SByte *, Int32, Int32) 
 בטל .ctor (SByte *, Int32, Int32, System.Text.Encoding) 
 בטל .ctor (Char, Int32) 
 Void .ctor (System.ReadOnlySpan`1 [System.Char])
 
 שיטות הדפסה 
 דוגמא: 
שימוש במערכת באמצעות System.Reflection בכיתה ציבורית PrintMethods {public static void Main () {Type t = typeof (System.String) Console.WriteLine ('Methods of {0} type ...', t) MethodInfo [] ci = t .GetMethods (BindingFlags.Public | BindingFlags.Instance) foreach (MethodInfo m in ci) {Console.WriteLine (m)}}}
 //תְפוּקָה: 
שיטות מערכת מחרוזת ... 
 System.String החלף (System.String, System.String) 
 System.String [] פיצול (Char, System.StringSplitOptions) 
 System.String [] פיצול (Char, Int32, System.StringSplitOptions) 
 System.String [] פיצול (Char []) 
 System.String [] פיצול (Char [], Int32) 
 System.String [] פיצול (Char [], System.StringSplitOptions) 
 System.String [] פיצול (Char [], Int32, System.StringSplitOptions) 
 System.String [] פיצול (System.String, System.StringSplitOptions) 
 System.String [] פיצול (System.String, Int32, System.StringSplitOptions) 
 System.String [] פיצול (System.String [], System.StringSplitOptions) 
 System.String [] פיצול (System.String [], Int32, System.StringSplitOptions) ......
 
 הדפס שדות 
 
 דוגמא: 
שימוש במערכת באמצעות System.Reflection מחלקה ציבורית PrintFields {public static void Main () {Type t = typeof (System.String) Console.WriteLine ('שדות מסוג {0} סוג ...', t) FieldInfo [] ci = t .GetFields (BindingFlags.Public | BindingFlags.Static | BindingFlags.NonPublic) foreach (FieldInfo f in ci) {Console.WriteLine (f)}}}
 //תְפוּקָה: 
שדות מערכת. סוג מחרוזת ... 
 מערכת. מחרוזת ריקה
כעת, נעבור לכמה מושגי תכנות מתקדמים מסוג C #
 מושגי C # מתקדמים 
 פונקציה אנונימית 
 השחלה מרובה 
 טיפול בחריגים 
 סִנכְּרוּן 
 תכונות חדשות 
 פונקציה אנונימית 
הפונקציה שחסרה שם ספציפי נקראת בעילום שם פונקציות. קיימים שני סוגים של פונקציות אנונימיות ב- C #
ביטויים למבדה
שיטות אנונימיות
 דוגמא: 
באמצעות מרחב שמות מערכת LambdaExpressions {class Edureka {delegate int Square (int num) static void Main (string [] args) {Square GetSquare = x => x * x int j = GetSquare (25) Console.WriteLine ('Square:' + י)}}}
 //תְפוּקָה: 
כיכר: 625
 שיטות אנונימיות 
ה שיטה אנונימית מספק את אותה פונקציונליות כמו ביטוי למבדה, אלא שהיא מאפשרת לנו להתעלם מרשימת הפרמטרים.
 דוגמא: 
שימוש במרחב השמות של המערכת AnonymousMethods {class program {delegate public void AnonymousFun () static void Main (string [] args) {AnonymousFun fun = delegate () {Console.WriteLine ('This is anonymous function')} fun ()}}}
 //תְפוּקָה: 
זו פונקציה אנונימית
 השחלה מרובה 
Multithreading הוא תהליך בו נוצרים מספר שרשורים ומוקצים למשימות שונות. זה חוסך זמן על ידי ביצוע מספר עבודות בכל פעם. הכיתה ריבוי הליכי זמין ב מערכת הברגה מרחב שמות.
 מערכת. Threading שמות 
ה מערכת הברגה מרחב השמות מכיל מחלקות וממשקים כדי להקל על ריבוי הליכי משנה. הוא מספק שיעורים לסנכרון משאב השרשור. רשימה של שיעורים נפוצים מובאת להלן:
פְּתִיל
מנעול
שָׁעוֹן עֶצֶר
צג
סֵמָפוֹר
ThreadLocal
ThreadPool
נָדִיף
 תהליך והשחיל 
התהליך הוא למעשה ו יישום וזה נחשב לא כָּבֵד מִשְׁקָל רְכִיב. מצד שני, החוט הוא יחיד מודול של כל היישום. זה קל בהשוואה לתהליך
 מחזור החיים של חוט 
לכל שרשור יש מחזור חיים. מחזור החיים של השרשור מוגדר במחלקה System.Threading.Thread. להלן השלבים במחזור החיים של כל חוט.
לא התחיל
ניתן להפעיל (מוכן להפעלה)
רץ
לא ניתן לרוץ
מֵת
מחלקת החוטים מספקת את המאפיינים והשיטות הבאים כדלקמן.
 מאפייני חוט 
 תכונה 
 תיאור 
 זרם זרם 
מחזיר את המופע של השרשור הפועל כעת.
 בחיים 
בודק אם החוט הנוכחי חי או לא.
 IsBackground 
כדי להשיג / להגדיר את הערך של השרשור הנוכחי הוא ברקע או לא.
 ManagedThreadId 
משמש לקבלת המזהה הייחודי לשרשור המנוהל כרגע.
 שֵׁם 
משמש כדי להשיג או להגדיר את שם השרשור הנוכחי.
 עדיפות 
משמש כדי לקבל או להגדיר את העדיפות של השרשור הנוכחי.
 ThreadState 
משמש להחזרת ערך המייצג את מצב השרשור.
 שיטות הברגה 
 שיטה 
 תיאור 
 הפלה() 
משמש לסיום החוט. זה מעלה את ThreadAbortException.
 פסיקת() 
משמש להפסקת שרשור הנמצא במצב WaitSleepJoin.
 לְהִצְטַרֵף() 
משמש לחסימת כל שרשורי השיחות עד לסיום החוט הזה.
 ResetAbort () 
משמש לביטול בקשת הביטול עבור השרשור הנוכחי.
 קורות חיים() 
משמש לחידוש החוט המושעה. זה מיושן.
 שינה (Int32) 
משמש להשעיית החוט הנוכחי באלפיות השנייה שצוינו.
 הַתחָלָה() 
משנה את המצב הנוכחי של השרשור ל- Runnable.
 לְהַשְׁעוֹת() 
משעה את החוט הנוכחי אם הוא לא מושעה. זה מיושן.
 תְשׁוּאָה() 
משמש להפקת הביצוע של השרשור הנוכחי לשרשור אחר.
 דוגמא לשרשור החוטים 
באמצעות מערכת באמצעות מערכת. Threading מחלקה ציבורית אדוריקה {public static void Main (string [] args) {Thread t = Thread.CurrentThread t.Name = 'MainThread' Console.WriteLine (t.Name)}}
 //תְפוּקָה: 
חוט ראשי
 
 טיפול בחריגים 
ה יוצא מן הכלל הינה שגיאה שנזרקה על ידי התוכנית בזמן הריצה שלה. אנו מבצעים טיפול בחריגים על מנת להפוך את התוכנית לחריגה בחינם.
 יוצא מן הכלל 
 תיאור 
 System.DivideByZeroException 
שגיאה שנוצרה על ידי חלוקת מספר באפס.  
  
 System.NullReferenceException 
מטפל בשגיאה שנוצרת על ידי הפניה לאובייקט null.  
  
 System.InvalidCastException 
מטפל בשגיאה שנוצרה על ידי טקסטים לא חוקיים.  
  
 System.IO.IOException 
מטפל בשגיאות קלט / פלט.
 System.FieldAccessException 
שגיאה שנוצרה על ידי גישה פרטית / מוגנת לא חוקית.
 
ב- C # אנו משתמשים לביצועים בארבע מילות מפתח טיפול בחריגים: 
לְנַסוֹת
לתפוס
לבסוף, ו
לזרוק
  דוגמא:  
שימוש במחלקה ציבורית ציבורית EdurekExample {public static void Main (string [] args) {try {int a = 10 int b = 0 int x = a / b} catch (Exception e) {Console.WriteLine (e)} Console.WriteLine ('ההודעה הזו היא מבלוק תפוס')}}
 
 //תְפוּקָה: 
System.DivideByZeroException: ניסה לחלק באפס. 
 ב- ExExaEdurekample.Main (String [] args) ב- F: C # TutorialC # ProgramsConsoleApp1ConsoleApp1Program.cs: שורה 10 
 הודעה זו היא מחסימת תפיסה
 דוגמה לחריגה מותאמת אישית 
באמצעות מחלקה ציבורית מערכת InvalidAgeException: חריג {public InvalidAgeException (הודעת מחרוזת): בסיס (הודעה) {}} מחלקה ציבורית מותאמת אישית {valid void validate (int age) {if (age<18) { throw new InvalidAgeException('Sorry, Age is expected to be greater than 18') } } public static void Main(string[] args) { try { validate(12) } catch (InvalidAgeException e) { Console.WriteLine(e) } Console.WriteLine('Catch block is being executed now.') } } 
 //תְפוּקָה: 
InvalidAgeException: מצטערים, גיל צפוי להיות גדול מ- 18 
 ב- Customised.validate (גיל Int32) ב- F: C # TutorialC # ProgramsConsoleApp1ConsoleApp1Program.cs: line 18 
 ב- Customised.Main (String [] args) ב- F: C # TutorialC # ProgramsConsoleApp1ConsoleApp1Program.cs: line 23 
 חסימת תפיסה מתבצעת כעת.
 
 סוף סוף לחסום דוגמה 
שימוש בכיתה ציבורית מערכת FinalExecption {public static void Main (string [] args) {try {int a = 10 int b = 0 int x = a / b} catch (Exception e) {Console.WriteLine (e)} finally {Console .WriteLine ('לבסוף מתבצעת חסימה')} Console.WriteLine ('בלוק תפוס מתבצע')}}
 //תְפוּקָה: 
System.DivideByZeroException: ניסה לחלק באפס. 
 ב- FinalExecption.Main (String [] args) ב- F: C # TutorialC # ProgramsConsoleApp1ConsoleApp1Program.cs: שורה 10 
 סוף סוף החסימה מבוצעת 
 חסימת תפיסה מתבצעת
 חתימת חריגה ממערכת 
[SerializableAttribute] [ComVisibleAttribute (true)] מחלקה ציבורית SystemException: Exception
 בוני חריגים למערכת 
 בּוֹנֶה 
 תיאור 
 SystemException () 
הוא משמש לאתחול מופע חדש של מחלקת SystemException.
 SystemException 
 (SerializationInfo, StreamingContext) 
הוא משמש לאתחול מופע חדש של מחלקת SystemException עם נתונים סדרתיים.
 SystemException (מחרוזת) 
הוא משמש לאתחול מופע חדש של מחלקת SystemException עם הודעת שגיאה שצוינה.
 SystemException (מחרוזת, חריג) 
הוא משמש לאתחול מופע חדש של מחלקת SystemException עם הודעת שגיאה שצוינה והפניה לחריג הפנימי שגורם לחריג זה.
 מאפייני חריגת מערכת 
 תכונה 
 תיאור 
 נתונים 
הוא משמש לקבלת אוסף של זוגות מפתח / ערך המספקים מידע מוגדר משתמש נוסף על החריג.
 HelpLink 
הוא משמש כדי להשיג או להגדיר קישור לקובץ העזרה המשויך לחריג זה.
 תוצאת HR 
הוא משמש כדי לקבל או להגדיר HRESULT, ערך מספרי מקודד המוקצה לחריג ספציפי.
 InnerException 
הוא משמש לקבלת מופע החריגה שגרם לחריג הנוכחי.
 הוֹדָעָה 
הוא משמש לקבלת הודעה המתארת ​​את החריג הנוכחי.
 מָקוֹר 
הוא משמש כדי לקבל או להגדיר את שם היישום שגורם לשגיאה.
 StackTrace 
הוא משמש לקבלת ייצוג מחרוזת של המסגרות המיידיות על ערימת השיחה.
 TargetSite 
הוא משמש כדי לקבל את השיטה שמטילה את החריג הנוכחי.
 שיטות חריגות מערכת 
 שיטות 
 תיאור 
 שווה (אובייקט) 
הוא משמש כדי לבדוק שהאובייקט שצוין שווה לאובייקט הנוכחי או לא.
 לְסַכֵּם() 
הוא משמש לפינוי משאבים ולביצוע פעולות ניקוי.
 GetBaseException () 
הוא משמש בכדי לקבל חריג בשורש.
 GetHashCode () 
הוא משמש לקבלת קוד ה- hash.
 GetObjectData 
 (SerializationInfo, StreamingContext) 
הוא משמש לקבלת נתוני אובייקט.
 GetType () 
הוא משמש לקבלת סוג זמן הריצה של המופע הנוכחי.
 MemberwiseClone () 
הוא משמש ליצירת עותק רדוד של האובייקט הנוכחי.
 ToString () 
הוא משמש ליצירה והחזרת ייצוג מחרוזות של החריג הנוכחי.
 דוגמה לחריגת מערכת 
באמצעות מרחב שמות מערכת CSharpProgram {class SystemExceptionExample {static void Main (string [] args) {try {int [] arr = new int [5] arr [10] = 25} catch (SystemException e) {Console.WriteLine (e)} }}}
 //תְפוּקָה: 
System.IndexOutOfRangeException: האינדקס היה מחוץ לתחום המערך. 
 ב- CSharpProgram.SystemExceptionExample.Main (String [] args) ב- F: C # TutorialC # ProgramsConsoleApp1ConsoleApp1Program.cs: שורה 11
 
 סִנכְּרוּן 
סנכרון עשוי להיות טכניקה המאפשרת לשרשור אחד בלבד לגשת למשאב לזמן מסוים. שום חוט חלופי לא יפריע עד שהחוט המיועד יסיים את משימתו.
בתוכנית ריבוי הליכי משנה, מותר לשרשורכדי לגשת לכל משאב עבור ה-ביצוע שצויןזְמַן. האשכולות חולקות משאבים ומבוצעות בצורה אסינכרונית. גישה למשאבים משותפים (נתונים)עשויה להיות משימה חשובהשבאופן כללייכול לעצורהמערכת.יש לנו נטייה להשפיע על זהעל ידי יצירת חוטים באופן סינכרוני.
 דוגמה ללא סנכרון 
באמצעות מערכת באמצעות System.Threading בכיתה Edureka {public void PrintTable () {עבור (int i = 1 i<= 10 i++) { Thread.Sleep(100) Console.WriteLine(i) } } } class Program { public static void Main(string[] args) { Edureka p = new Edureka() Thread t1 = new Thread(new ThreadStart(p.PrintTable)) Thread t2 = new Thread(new ThreadStart(p.PrintTable)) t1.Start() t2.Start() } } 
 //תְפוּקָה: 
 
אחד 
 אחד 
 2 
 2 
 3 
 3 
 4 
 4 
 5 
 5 
 6 
 6 
 7 
 7 
 8 
 8 
 9 
 9 
 10 
 10
 
 דוגמה עם סנכרון 
באמצעות מערכת באמצעות System.Threading class Edureka {public void PrintTable () {lock (this) {for (int i = 1 i<= 10 i++) { Thread.Sleep(100) Console.WriteLine(i) } } } } class Program { public static void Main(string[] args) { Edureka p = new Edureka() Thread t1 = new Thread(new ThreadStart(p.PrintTable)) Thread t2 = new Thread(new ThreadStart(p.PrintTable)) t1.Start() t2.Start() } } 
 //תְפוּקָה: 
אחד 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 אחד 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10
 תכונות חדשות 
מיקרוסופט הוסיפה תכונות עדכניות רבות לשפת C #, חלקן מוזכרות להלן.
C # 6.0
שימוש בהנחיה סטטית
מסנני חריגים
המתן לתפוס / סוף סוף חסימות
אתחול נכסים אוטומטי
ערכי ברירת מחדל עבור מאפיינים הנגטים בלבד
חברים בגוף הבעה
מפץ אפס
אינטרפולציית מיתרים
שם המפעיל
אתחול מילון
מהדר כשירות (רוזלין)
C # 7.0
התאמת תבנית
צינורות
דקונסטרוקציה
פונקציות מקומיות
מפריד ספרות
מילוליות בינאריות
רף חוזר ומקומיים
קונסטרוקציות וגופי גוף עם ביטוי
גטרים וקובעי גוף עם ביטוי
משתנים החוצה
סוגי החזרת אסינכרון כללים
C # 7.1
ראשי אסינכרון
ביטויי ברירת מחדל
 שאלות ראיון על בסיס C # 
הראיון החשוב ששאלות המבוססות על שפת תכנות C # ניתן למצוא בעדכון זה  .
עם זאת, אנו מגיעים לסוף מאמר זה 'C # Tutorial'. אני מקווה שהבנת את החשיבות של מבני נתונים, תחביר, פונקציונליות ופעולות המבוצעות באמצעותם. כעת לאחר שהבנתם את יסודות התכנות ב- C # באמצעות זהC # הדרכה, לבדוק את  הכשרה הניתנת  מאת אדוריקה בטכנולוגיות רבות כמו ג'אווה, אביב ורביםיותר מכך, חברת למידה מקוונת מהימנה עם רשת של יותר מ -250,000 לומדים מרוצים הפרוסים ברחבי העולם קיבלה  שאלה עבורנו? ציין זאת בסעיף ההערות בבלוג 'C # Tutorial' ונחזור אליך בהקדם האפשרי.