יצירת תיעוד לשפות תיכנות

[eido300]

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

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

בקיצור הכרת הפונקציות יכולה למנוע הרבה כאב ראש.

לכן חשבתי על רעיון, ואני אשמח אם תשתפו פעולה.

יצירת מעין תיעוד של הפונקציות יכולה לפתור את הבעיה, כמו שיש תיעוד של msdn אפשר ליצור מעין תיעוד (לא מדריך) על הפונקציות בעברית שכל מי שירצה לחפש / לברר על פונקציה יוכל להכין בקלות.

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

אני התחלתי עם הפונקציות של המשתנים הפשוטים ב#c, אני אשמח אם תשתפו פעולה ותכתבו גם אתם, וכן תתנו הערות והארות:

Int

לint יש שלוש סוגים int16,int32,int64 ההבדל ביניהם הוא טווח הערכים שהם מקבלים, אבל בכללי יש להם את אותם שיטות. (בעיקרון שמשתמשים בint הכוונה לint32).

הצבה בint

1. הצבה רגילה

int name=virbale;/int name=number;

2. הצבת ערך שחוזר משיטה

int name=method();

3. הצבת קלט משתמש

int name=int.parse(console.readline());

הסבר: readline זה שיטה במחלקה console (המחלקה שאחראית על קלט, פלט ושגיאות) שאחראית על קבלת קלט מהמשתמש, וברגע שקוראים לה התוכנה מפסיקה ומחכה לקלט את הקלט הזה התוכנה מכניסה למשתנה, אבל הערך המוחזר מהשיטה הזאת הוא string וכדי שנוכל להציב אותו ב intצריך להמיר אותו דרך השיטה parse.

המרה לint

יש שתי סוגים של סוגי ערך: 1. שלם (בלי נקודה עשרונית), 2. ממשי( לא שלם - עם נקודה עשרונית).

השלמים הם: sbye, byte, short, ushort, int, uint, long, ulong.

הלא שלמים הם: float, double, decimal.

בint אפשר לשים רק מספרים שלמים (זאת אומרת שאין להם נקודה עשרונית)

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

ההמרה מתבצעת ככה: אחרי השווה(=) שמים בסוגריים את הסוג שאליו רוצים להמיר, לדוגמא: עכשיו הערך שיהיה שמור בb הוא 12 בגלל שint לא מקבל מספר אחרי הנקודה.

double a=12.3;   int b=(int)a;

אפשר להמיר דרך השיטה convert.ToInt32();. בסוגריים שמים את המשתנה שרוצים להמיר לint ואת הערך המוחזר מעבירים למשתנה int (כמו הצבה מספר 2).

יש עוד דרכים להמיר (השיטות Parseו-(TryPrase ואותם נראה בהמשך.

אופרטורים נתמכים

אופרטור הצבה – (=).

אופרטורים אריתמטיים - (+,-,*,/,%).

אופרטור הצבה מורכבת - (=+,=-,=*,=/,=%).

אופרטור הגדלה/הקטנה – (++,--).

האופרטורים bitwise, shift – (~,>>,<<,|,&,^).

השיטות של int

השיטות MaxValue/MinValue

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

דוגמא:

int name = int.MaxValue;

השיטה CompareTo

השיטה הזו משווה בין שני משתנים ומחזירה ערך מסוג int, הערך הוא או אפס או גדול/קטן מאפס,

אפס אומר שהם שווים, גדול מאפס אומר שהמשתנה שקרא לשיטה גדול מהמשתנה השני, קטן מאפס אומר שהמשתנה השני גדול מהמשתנה שקרא לשיטה. דוגמא:

int a = 12;  int b = 34;   int c = b.CompareTo(a);

כאן b קרא לשיטה ובגלל שהוא יותר גדול מa הערך שיושם בc יהיה 1, שזה אומר שהמשתנה שקרא לשיטה יותר גדול מהמשתנה השני.

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

object a = 12;   int b = 34; int c = b.CompareTo(a);

הערה: אפשר להפעיל על object את השיטה, אבל object לא יכול לקרוא לה.

השיטה Equals

השיטה משווה בין 2 משתנים ומחזירה ערך מסוג בוליאני, true אם הם שווים וfalse אם הם לא שווים. דוגמא:

int a = 12;    int b = 34; bool c = b.Equals(a);

אפשר להפעיל את השיטה גם על משתנה מסוג object.

השיטה parse

השיטה הזו ממירה ערך מסוג string לערך מסוג int, (כמובן צריך שהערך יהיה עשוי מספרות).

דוגמא: string a = "123456"; int b = int.Parse(a);

אם הstring מכיל גם פסיקים, נקודה עשרונית (שאחריה 0), סימן של מטבע וכו' אפשר להשתמש בNumberStyles וכך להגיד לו להתעלם מהם, וכן ב-IFormatProvider כדי לקבוע לפי כללים של איזה מדינה להשתמש. (מידע יותר מפורט אפשר למצוא בתיעוד עליהם כאן וכאן).

עושים זאת ע"י הוספת פסיק אחרי המשתנה שממירים והוספת מה שרוצים. אם רוצים להוסיף כמה NumberStyles מפרידים ביניהם ע"י הסימן הזה | .

השיטה ToString

השיטה הזו ממירה משתנה מסוג int למשתנה מסוג string. דוגמא:

int a = 123;  string b = a.ToString();

יש אפשרות להמיר לפי כללים של מדינה מסוימת (ע"י הוספת IFormatProvider) ו/או לפי עיצוב (על העיצוב אפשר לקרוא כאן וכאן).

לדוגמא:

int a = 123;    string b = a.ToString("c");

העיצוב הזה (האות c) מוסיף סמל של המטבע של המדינה, זאת אומרת שעכשיו b מכיל- 123₪.

השיטה TryParse

השיטה הזו ממירה מstring לint, השיטה הזו מחזירה 2 ערכים: 1. את הערך שאנחנו ממירים. 2.ערך מסוג בוליאני(true אם ההמרה הצליחה, false אם ההמרה לא הצליחה).

דוגמא:

 string a = "1234";                                                       int b;                                                                          
bool c = int.TryParse(a, out b); 

הסבר: שמים ב-c את הערך המוחזר מהשיטה, a זה המשתנה שרוצים להמיר, אחר כך שמים פסיק, כותבים את המילה out ואת המשתנה שאליו הstring יומר (במקרה שלנו b).

כמו בשיטה parse אם יש פסיק/סימן וכו' אפשר להוסיף NumberStyles ו- IFormatProvider (כותבים אותם לפני ה-out), (מידע יותר מפורט אפשר למצוא בתיעוד עליהם כאן וכאן).

Boolean(bool)

משתנה בוליאני הוא משתנה שיכול לקבל רק את הערכים false(שקר) ו-true(אמת).

הצבה bool

הצבה פשוטה

:bool name=false/true; 

הצבה מקלט משתמש

bool name= bool.parse(console.readline()); 

הסבר: readline זה שיטה במחלקה console (המחלקה שאחראית על קלט, פלט ושגיאות) שאחראית על קבלת קלט מהמשתמש, וברגע שקוראים לה התוכנה מפסיקה ומחכה לקלט את הקלט הזה התוכנה מכניסה למשתנה, אבל הערך המוחזר מהשיטה הזאת הוא string וכדי שנוכל להציב אותו ב bool צריך להמיר אותו דרך השיטה parse. כמובן שגם כאן אם המשתמש יכניס קלט שהוא לא true או false תהיה שגיאה.

הצבה ממשתנה אחר: אם הוא בוליאני – לא צריך להמיר אותו, לגבי לא בוליאני – (השיטות TryParse,Parse) אותם נראה בהמשך.

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

Bool name=method();

אופרטורים נתמכים

אופרטור בוליאני (!).

השיטות של bool

השיטה CompareTo

משווה בין שני משתנים ומחזירה ערך מסוג int, אם הם שווים (שניהם true או שניהם false) הערך יהיה אפס, אם המשתנה שקרא לשיטה הוא false התוצאה תהיה פחות מאפס, ואם המשתנה שקרא לשיטה יהיה true הערך יהיה מעל אפס. אפשר להשוות משתנה בוליאני גם לobject בתנאי שהוא מכיל או true או false או null.

דוגמא:

bool a = true;  bool b = false;  int c = b.CompareTo(a); 

השיטה equals

משווה בין שני מתנים ומחזירה ערך בוליאני , אמת – אם שניהם שווים, שקר – אם הם לא שווים.

אפשר להשוות משתנה בוליאני גם לobject. דוגמא:

object a = false;  bool b = false;  bool c = b.Equals(a);

השיטה GetTypeCode/GetCode

מחזירה את סוג המשתנה, אפשר:

או להציב בobject כך: bool a = true; object c=a.GetType();

או בstring תוך כדי המרה, כך: bool a = true; string c=a.GetType().ToString();

השיטה parse

ממירה משתנה מסוג string לסוג bool, בתנאי שהוא מכיל את אחד הערכים שbool מקבל. דוגמא:

string a = "true";  bool b = bool.Parse(a);

השיטה ToString

ממירה משתנה בוליאני לstring, כך:

bool a = true;  string b = a.ToString();

השיטה TryPrase

מנסה להמיר משתנה מסוג stringלbool, ומחזיר ערך בוליאני לפי ההצלחה, אם הצליח מחזיר אמת ואם לא מחזיר שקר. התחביר הוא כמו בparse רק שכאן בסוגריים כותבים outואחרי זה מכניסים משתנה שרוצים שהתוצאה (אם זה הצליח או לא) תעבור אליו. כך:

string a = "true";  bool c;  bool b = bool.TryParse(a, out c);

השיטה FalseString/TrueString

שמה במשתנה string את הערך false/True. דוגמא:

string a = bool.FalseString;

String

משתנה מסוג מחרוזת (string) יכול להכיל "מחרוזת" של תווים, תווים יכולים להיות מספרים, אותיות וסמלים.

סוגי הצבה וגישה במחרוזת

אפשר להציב ערכים בstring בכמה צורות:

1.ההצבה הרגילה

String name ="chars";  /string name= Variable;

2.אפשר להציב מערך של char (המערך יכול להכיל גם קוד Unicode)

 char[] name = { '1', 'd', '!' };  string name1 = new string(name);

אפשר לקצר את זה וליצור את המערך בתוך הסוגריים של הstring כך:

string name1 = new string(new char[]{ '1', 'd', '!' });

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

אחרי המערך שמים פסיק מספר (המספר הזה יקבע מאיזה תא יתחיל לשים, ומה שיש בתאים שלפני זה הוא לא ישים במשתנה) פסיק ומספר (המספר הזה יקבע כמה תאים הוא יכניס), כך:

(גם כאן אפשר להכניס קוד Unicode)

string name1 = new string(new char[]{ '1', 'd', '!' },0,1); 

4.אפשר להציב תו מספר פעמים. התחביר הוא כזה:

כותבים תו פסיק ומספר (המספר הזה יקבע כמה פעמים התו הזה יהיה רשום), כך:

string name =new string ('s',3);

5.אפשר להציב במשתנה ערך שהוחזר משיטה. התחביר הוא:

String name=method();

6.אפשר להציב קלט מהמשתמש (זאת אומרת מה שהמשתמש לחץ במקלדת). התחביר הוא:

string name = Console.ReadLine();

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

יש עוד כמה אפשרויות, אפשר לראות את זה כאן.

אפשר לגשת למחרוזת ב2 צורות:

1.בתור משתנה רגיל, ואז ניגשים אליו כמו אל כל משתנה.

2.בתור מערך של char, ואז ניגשים אליו כמו על מערך וכל תו הוא בעצם תא.

אופרטורים

על string אפשר להשתמש בכמה אופרטורים:

1. אופרטור הצבה - (=).

2. אופרטור הצבה מורכבת - (=+).

3. אופרטור לחיבור מחרוזות (שרשור) – (+)

4. אופרטור השוואה - (שווה ל ==).

5. אופרטור השוואה – (לא שווה ל =!).

שיטות של מחרוזות

לstring יש כמה שיטות מעניינות:

השיטה length

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

Name.length; int name1=

השיטה clone

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

Name.clone(); object copy=.

השיטה compareהשיטה compare משווה בין שתי מחרוזות ובודקת איזה מהם יותר ארוכה. השיטה מחזירה ערך מסוג int, התחביר הוא :

String a="abcdef";
String b="ghijklmno";
Int c=string. Compare(a,b);

אם לא רוצים שהוא ישווה את כל המחרוזת אלא יתחיל מתו מסוים ויבדוק רק מספר מסוים של תווים עושים כך:

String a = "abcdef";
 String b = "ghijklmno";
int c = string.Compare(a,2,b,3,3);

האות הראשונה זה המחרוזת, המספר שאחריו זה מספר התו שממנו מתחילים, האות השנייה זה המחרוזת השנייה, המספר שאחריה הוא התו שממנו מתחילים, המספר שאחריו הוא מספר התאים שישוו.

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

(יש עוד אפשרויות אפשר לבדוק כאן.)

השיטות StartWith/EndWithהשיטות StartWith/ EndWith מאפשרות לבדוק האם המחרוזת א' מסתיימת/מתחילה במחרוזת ב', הערך המוחזר הוא בולאיני, כך:

string a="c b c d c f h";

string b = "c";

bool c = a.StartsWith(b);

וכן בשיטה endwith. (יש לזה עוד כמה אפשרויות אפשר לבדוק כאן).

השיטה Replace

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

string a="c b c d c f h";
        string b = a.Replace('c','w');

עכשיו כל מקום שהיה בו c יהיה בו w.

השיטה IexOfnd

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

String a="adskjkubslkh";
char b = 's';
int c = a.IndexOf(b,0,12);

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

השיטה LastIndexOf

השיטה lastindexof כמו indexof רק שמחזיר את מיקום התו האחרון שנמצא.

השיטה IndexOfAny

השיטה indexofany מחפשת תווים מתוך מערך char במחרוזת ומחזירה את המיקום של התו הראשון שנמצא,כך:

String a="zplokmnajusd";
char[] b = {'f','a','s','d','f','g'};
int c = a.IndexOfAny(b);

כמו בindexof אפשר להגדיר לו איפה להתחיל וכמה לחפש ע"י הוספת פסיקים וספרות.

השיטה LastIndexOfAny

השיטה lastindexofany היא כמו indexofany רק שמחזיר את המיקום של התו האחרון שנמצא.

השיטה Substring

השיטה Substring מחזירה חלק ממחרוזת, יש 2 אפשרויות או מתו מסוים עד הסוף, או מתו מסוים עד תו מסוים. כך:

String a = "abcdef";
String b =a.Substring(3); 

כך מעתיקים מתו מסוים עד הסוף

String b =a.Substring(0,5);

וכך מעתיקים מתו מסוים עד תו מסוים

השיטה CompareTo

השיטה CompareTo מאפשרת להשוות בין שתי מחרוזות לפי סדר ההופעה שלהם במילון.כך:

String a = "abcdef";
String b ="ghij";
int c = b.CompareTo(a);

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

השיטות Trim/TrimEnd/TrimStart

השיטות trim/trimend/trimstart עוזרות למחוק את הרווחים שלפני ו/או אחרי המחרוזת (אם יש כאלה), הם פשוט מחזירות בתור ערך מחרוזת חדשה בלי רווחים לפניה ו/אחריה. כך:

String a = " abcdef ";
String b = a.Trim();

אפשר להעביר לזה מחרוזת char והשיטות האלה יחזירו מחרוזת "נקייה" מכל התווים האלה, כך:

String a = " @ab1cde@f ";
String b = a.Trim(new char []{'a','1','@'});

השיטות ToLower/ToUpper

השיטות tolower/toupper הופכות את כל האותיות במחרוזת לקטנות/גדולות ומחזירות את זה בתור ערך, כך: String a = "

abcDEF ";
            String b = a.ToLower();

השיטה CopyTo

השיטה copyto מעתיקה תווים מ stringלמחרוזת של char, כך:

המספר: הראשון הוא מאיזה תו מתחילים להעביר, השני זה לאיזה תא מתחילים להעביר, השלישי זה כמה תווים מעבירים

והאות זה שם המערך שאליו מעבירים.

string a="asdfzxcv";
char[] b=new char[12];
a.copyto(0,b,0,5);

השיטה Copy

השיטה copy פשוט מעתיקה משתנה אחד לאחר.

השיטה Contains

השיטה Contains בודקת אם בתוך משתנה א' יש את משתנה ב', ומחזיר ערך בוליאני.כך:

string a = "abddsfdgfgdf";
string b = "dd";
bool c = a.Contains(b);

השיטה Equals

השיטה Equals בודקת האם שתי מחרוזות שוות, ומחזירה ערך בוליאני.

Bool c= a.equals(b);

אפשרויות נוספות של השיטה אפשר לראות כאן.

השיטה Format

השיטה format מאפשרת להכניס תוכן של משתנים לתוך string כמו בעזרת{0},כך:

String a="asd";
Int b=123;
String c=strin.format("abc {0} 123 {1}",a,b);

השיטה GetType

השיטה gettype מחזירה את סוג הערך של המשתנה.

כך: הערך המוחזר הוא לא stringלכן צריך להמיר אותו לstring.

String a = " abcDEF ";
string b =a.GetType().ToString();

השיטה Insert

השיטה insert מכניסה מחרוזת א' בתוך מחרוזת ב' לפי אינדקס ומחזירה את זה בתור מחרוזת חדשה, כך:

string a="def";
string b = "abcghi";
string c = b.Insert(3, a);

מכניסים את מחרוזת a' בתוך מחרוזת b' באות הרביעית (בגלל שהספירה של התווים מתחילה באפס, 3 הוא בעצם הרביעי)

השיטה PadRight

השיטה padright מוסיפה רווחים מימין המחרוזת,כך:

string a="d";
 Console.Write(a.PadRight(23)); 

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

השיטה PadLeft

השיטה padleft כנ"ל רק שמוסיפה רווחים/תווים משמאל.

השיטה Remove

השיטה remove מוחקת תו ממחרוזת ומחזירה את זה בתור מחרוזת חדשה, כך:

string a="abcdefghijkl";
string b = a.Remove(5);

כאן הוא מוריד את התו השישי (זה מתחיל מ0, זוכרים?) כדי שהוא יוריד כמה תווים ולא רק אחד צריך להוסיף פסיק ומספר והוא יוריד תווים לפי המספר.כך:

string b = a.Remove(5,2);

השיטה Split

השיטה split מאפשרת לפצל מחרוזת אחת למערך של מחרוזות, ע"י מערך של char, זאת אומרת שכל פעם שהוא יראה במחרוזת את אחד מהתווים שבמחרוזת char הוא יפצל את המחרוזת ויכניס את זה לתא נפרד. כך:

string a="abc,defg.hijk@lmnopq#rstu,vwxyz";
string[] b = a.Split(new char[] {',','@','#','.'});

זאת אומרת שabc יהיו בתא אחד, defg יהיו בתא אחר, hijk יהיו בתא אחר, וכו'..(בסה"כ 6 תאים)

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

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

דוגמא:

string[] b = a.Split(new char[] { ',', '@', '#', '.' },StringSplitOptions.RemoveEmptyEntries);

הסבר: StringSplitOptions אחראי על החלק של התאים הריקים ויש לו שתי אפשרויות או none שזה אומר שהוא לא ימחק את הריקים, או RemoveEmptyEntries שזה אומר שהוא ימחק את הריקים.

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

השיטה IsNullOrEmpty

השיטה isNullOrEmpty בודקת אם במשתנה יש ערך או שהוא רק אוnull, הערך המוחזר הוא בוליאני, כך:

bool b = string.IsNullOrEmpty(value);

השיטה IsNullOrWhiteSpace

השיטה IsNullOrWhiteSpace בודקת אם במשתנה יש ערך או שהוא ריק/null/יש בו תו לבן ("רווח") הערך המוחזר הוא בוליאני. כך:

bool b = string.IsNullOrWhiteSpace(a);

השיטה ToCharArray

השיטה toCharArray הופכת מחרוזת למערך char, כך:

String a = " abcDEF12@#";
char[] b = a.ToCharArray();

אפשר גם להמיר רק חלק מהמחרוזת ע"י הוספת מספר פסיק מספר בסוגריים ואז הוא ימיר מהמספר למשך המספר, כך:

char[] b = a.ToCharArray(2,5);

השיטה Join

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

String [] a = { " abcDEF12@#", "dsgfd", "rfvgt", "156", "8oi#%", "(*&^hkf210"};
string b = string.Join("$",a);

אפשר גם להגביל את זה, ולגרום לו שיתחיל את המחרוזת מתא מסוים למשך מספר תאים מסוים, כך:

String [] a = { " abcDEF12@#", "dsgfd", "rfvgt", "156", "8oi#%", "*&^hkf210"};
string b = string.Join("$",a,1,4);

[Gil28]

כל הכבוד על המאמץ. אבל מי שלא מבין אנגלית, אין לו מה לחפש בתכנות.

[-LosNir-]

כבר חשבו על הסטארט אפ הזה לפניך.

http://msdn.microsoft.com/en-us/library/618ayhy6.aspx

[eido300]

כל הכבוד על המאמץ. אבל מי שלא מבין אנגלית, אין לו מה לחפש בתכנות.

לא בהכרח, אני לא מבין כ"כ אנגלית ואני מסתדר די טוב, חוץ מזה, לא יותר קל לך ללמוד על פונקציה בעברית? זה נראה לי יותר נוח.

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

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

בכל אופן תודה רבה על ההערה.

כבר חשבו על הסטארט אפ הזה לפניך.

http://msdn.microsoft.com/en-us/library/618ayhy6.aspx

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

וכן אני אשמח אם גם אתה תוכל לעזור.