דף זה תורגם על ידי Cloud Translation API.

מדריך למפתחים: .NET

חשוב: נפסיק את התמיכה ב-Google Data API בגרסה 2.0 ב-30 בספטמבר 2024. כדי להבטיח פונקציונליות רציפה, צריך לעדכן את האפליקציות שמסתמכות על גרסה 2.0 של Google Data API לגרסה האחרונה של ה-API. כדי לקבל את הגרסה האחרונה, אפשר להשתמש בקישורים בסרגל הניווט הימני. הערה: בקשות GET (כמו פוסטים של כרטיסי מוצר) ימשיכו לתמוך בתור פיד בכתובות URL, יש הבדלים קלים בהתנהגות. מידע מפורט זמין מסמכי העזרה של Blogger.

Blogger Data API מאפשר לאפליקציות לקוח להציג ולעדכן את Blogger בצורה של פידים של Google Data API.

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

בנוסף למתן רקע מסוים על היכולות של Blogger ב-Data API, במסמך הזה מובאים דוגמאות לאינטראקציות בסיסיות ב-Data API באמצעות ספריית הלקוח.NET. למידע נוסף על הפרוטוקול הבסיסי שבו הספרייה משתמשת, אפשר לעיין בקטע Protocol במדריך למפתחים הזה.

תוכן עניינים

קהל
שימוש בפעם הראשונה
1. יצירת חשבון ב-Blogger
2. הרצת הקוד לדוגמה
אימות מול שירות Blogger
1. אימות שרת proxy של AuthSub
2. אימות שם משתמש/סיסמה של ClientLogin
אחזור רשימת בלוגים
יצירת פוסטים
1. פרסום פוסט בבלוג
2. יצירת טיוטה של פוסט בבלוג
אחזור פוסטים
1. אחזור כל הפוסטים בבלוג
2. אחזור פוסטים באמצעות פרמטרים של שאילתה
עדכון פוסטים
מחיקת פוסטים
תגובות

קהל

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

במסמך הזה אנו מביאים בחשבון שהקוראים מבינים את הרעיונות הכלליים שמאחורי פרוטוקול Google Data APIs.

למידע נוסף על המחלקות והשיטות שמסופקות על ידי לספריית הלקוח, ראו ממשק API של ספריית לקוח.NET . מידע כללי על Blogger Data API זמין במדריך העזרה של הפרוטוקול.

תחילת העבודה

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

כדי להשתמש בספריית הלקוח של ‎.NET, צריך את סביבת זמן הריצה של ‎.NET 1.1, וגם את כל התיקונים העדכניים. אחרי הורדת ספריית הלקוח, קובצי ה-DLL הנדרשים להתחלה נמצאים בתיקיית המשנה lib/Release של ההפצה.

יצירת חשבון Blogger

כדאי להירשם חשבון Blogger למטרות בדיקה. Blogger משתמש בחשבונות Google, כך שאם כבר יש לך חשבון Google, הכול מוכן.

הרצת הקוד לדוגמה

לקוח לדוגמה שפועל במלואו, שמכיל את כל הקוד לדוגמה שמוצג במסמך הזה, זמין בפרויקט של ספריית הלקוח ב-‎.NET. הדוגמה נמצאת בכתובת /trunk/clients/cs/samples/blogger/ConsoleSample.cs. בכרטיסייה Source (מקור) במאגר SVN.

לפני שמאגדים ומריצים את הדוגמה הזו, צריך לעדכן את הערכים של username,‏ password,‏ blogName ו-postId בערכים המתאימים. הערכים username ו-password מייצגים את פרטי הכניסה שמשמשים להתחברות ל-Blogger. הערך blogName מייצג את תחילת ה-blogspot בבלוג שלך כתובת URL.

לקוח לדוגמה מבצע כמה פעולות בבלוג שסופק כדי להדגים את השימוש ב-Blogger Data API.

כדי לקמפל את הדוגמאות במסמך הזה לקוד משלכם, תצטרכו את הצהרות using הבאות:

using Google.GData.Client;
using System.Net;
using System.Xml;
using System.Text.RegularExpressions;

אימות מול שירות Blogger

באמצעות ממשק ה-API של Blogger Data תוכלו לגשת אל פידים ציבוריים ופרטיים. לא נדרשת אימות כדי לגשת לפידים ציבוריים, אבל הם ניתנים לקריאה בלבד. אם רוצים לשנות בלוגים, הלקוח צריך לבצע אימות לפני שהוא מבקש פידים פרטיים. ניתן לבצע אימות באמצעות אחת משתי גישות: אימות שרת proxy של AuthSub או אימות שם משתמש/סיסמה של ClientLogin.

למידע נוסף על אימות באמצעות Google Data APIs באופן כללי, תוכלו לעיין במסמכי העזרה בנושא אימות.

אימות שרת proxy של AuthSub

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

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

נניח שההיפר-קישור הבא ל-ASP מוגדר בדף:

<asp:HyperLink ID="GotoAuthSubLink" runat="server"/>

לאחר מכן, כדי ליצור את כתובת ה-URL של AuthSubRequest לאפליקציה, צריך לבצע קריאה לספריית לקוח של ‎.NET באופן הבא:

GotoAuthSubLink.Text = "Login to your Google Account";
GotoAuthSubLink.NavigateUrl =
  AuthSubUtil.getRequestUrl("http://www.example.com/RetrieveToken",
  "http://www.blogger.com/feeds/",
  false,
  true);

ה-method getRequestUrl משתמשת בפרמטרים הבאים (בהתאם לפרמטרים של השאילתה ששימשו את ה-handler של AuthSubRequest):

הבא: כתובת ה-URL של הדף ש-Google צריכה להפנות אליו את המשתמשים אחרי האימות.
היקף: מציין שהאפליקציה מבקשת אסימון כדי לגשת לפידים של Blogger. מחרוזת ההיקף שבה צריך להשתמש היא http://www.blogger.com/feeds/ (בקידוד כתובת URL, כמובן).
מאובטח: הערך הזה מציין אם הלקוח מבקש אסימון מאובטח.
ביקור: מראה אם ניתן להחליף את האסימון שהוחזר באסימון לשימוש רב-פעמי (סשן).

בדוגמה שלמעלה מוצגת קריאה שלא מבקשת אסימון מאובטח (הערך של secure הוא false). כתובת ה-URL שמתקבלת של הבקשה עשויה להיראות כך:

https://www.google.com/accounts/AuthSubRequest?scope=http%3A%2F%2Fwww.blogger.com%2Ffeeds%2F&session=1&secure=0&next=http%3A%2F%2Fwww.example.com%2FRetrieveToken

המשתמש עוקב אחרי הקישור לאתר של Google ומבצע אימות בחשבון Google שלו.

אחרי שהמשתמש עובר אימות, מערכת AuthSub מפנה אותו לכתובת ה-URL שציינתם בפרמטר השאילתה next בכתובת ה-URL של AuthSubRequest. מערכת AuthSub מצרפת אסימון אימות לכתובת האתר הזו, של פרמטר השאילתה token. לכן האסימון הוא ניתן לגשת אליו כמשתנה בRequest.QueryString של דף ה-ASP לאובייקט. המשתמש מופנה לכתובת URL שנראית כך:

http://www.example.com/RetrieveToken?token=yourAuthToken

ערך האסימון הזה מייצג אסימון AuthSub לשימוש יחיד. במשפט הזה, מאז שצוין session = true, ניתן להחליף את האסימון הזה אסימון סשן AuthSub, באופן הבא:

SessionsessionToken = AuthSubUtil.exchangeForSessionToken(Request.QueryStringtoken, null);

כלומר, מעבירים את האסימון החד-פעמי אמצעי תשלום exchangeForSessionToken, יחד עם null (למצב לא רשום) או מפתח פרטי (למצב רשום), ומפתח AuthSub הממשק מחזיר אסימון סשן. למידע נוסף על אפליקציות רשומות ומפתחות פרטיים, ראו את הקטע חתימה על בקשות במסמכי התיעוד של AuthSub.

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

GAuthSubRequestFactory authFactory = new GAuthSubRequestFactory("blogger", "BloggerSampleApp");
authFactory.Token = SessionsessionToken.ToString();
Service service = new Service(authFactory.ApplicationName);
service.RequestFactory = authFactory;

אימות שם משתמש/סיסמה של ClientLogin

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

Service service = new Service("blogger", "exampleCo-exampleApp-1");
service.Credentials = new GDataCredentials("user@example.com", "secretPassword");
GDataGAuthRequestFactory factory = (GDataGAuthRequestFactory) service.RequestFactory;
factory.AccountType = "GOOGLE";

בקטע הקוד שלמעלה, אנחנו מעבירים שני פרמטרים אל Service constructor. הפרמטר הראשון הוא שם השירות שאנחנו רוצים לבצע איתו אינטראקציה. הפרמטר השני הוא שם האפליקציה שלנו בצורת companyName-applicationName-versionID אנחנו גם להגדיר את Service.RequestFactory להשתמש רק ב-GOOGLE סוג החשבון כדי לאפשר אימות תקין למשתמשי G Suite.

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

הערה: צריך להשתמש באותו אסימון לכל הבקשות בסשן נתון, ולא לקבל אסימון חדש לכל בקשה ב-Blogger.

הערה: כפי שמתואר במסמכי העזרה של ClientLogin, ייתכן שבקשת האימות תיכשל ותתבקש השלמת אתגר CAPTCHA. אם רוצים ש-Google תיצור את האתגר של CAPTCHA ותטפל בו, צריך לשלוח את המשתמש אל https://www.google.com/accounts/DisplayUnlockCaptcha?service=blogger (במקום לכתובת ה-URL לטיפול ב-CAPTCHA שמופיעה במסמכי העזרה של ClientLogin).

המערכת מאחזרת רשימה של בלוגים

ה-API של נתוני Blogger מספק פיד שמפרט את הבלוגים של משתמש מסוים. הפיד הזה נקרא 'מטא-פיד'.

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

query.Uri = new Uri("http://www.blogger.com/feeds/default/blogs");
AtomFeed feed = null;
try
{
  feed = service.Query(query);
  foreach (AtomEntry entry in feed.Entries)
  {
    Console.WriteLine("Blog Title: " + entry.Title.Text);
  }
}

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

יצירת פוסטים

Blogger Data API מאפשר לך ליצור ולפרסם רשומות חדשות בבלוג, וגם יצירת טיוטות של רשומות.

בכל הדוגמאות הבאות מניחים שיש לכם אובייקט Service מאומת.

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

פרסום פוסט בבלוג

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

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

AtomEntry newPost = new AtomEntry();
newPost.Title.Text = "Marriage!";
newPost.Content = new AtomContent();
newPost.Content.Content = "<div xmlns='http://www.w3.org/1999/xhtml'>" +
  "<p>Mr. Darcy has <em>proposed marriage</em> to me!</p>" +
  "<p>He is the last man on earth I would ever desire to marry.</p>" +
  "<p>Whatever shall I do?</p>" +
  "</div>";
newPost.Content.Type = "xhtml";

Uri blogFeedUri = new Uri("http://www.blogger.com/feeds/" + blogId + "/posts/default");
AtomEntry createdEntry = service.Insert(blogFeedUri, newPost);

השיטה Insert מקבלת את כתובת ה-URL לפרסום של השירות כפרמטר. לאחר מכן, השיטה מחזירה את הרשומה כפי שנשמרה ב-Blogger. הרשומה מוחזר אותו פריט ששלחתם, אבל הוא גם מכיל אלמנטים שונים שנוספו של Blogger, כגון מזהה פוסט.

אם הבקשה נכשלת מסיבה כלשהי, יכול להיות ש-Blogger יחזיר קוד סטטוס אחר. מידע על קודי הסטטוס זמין במסמך העזרה של פרוטוקול Google Data API.

יצירת טיוטה של פוסט בבלוג

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

AtomEntry newPost = new AtomEntry();
newPost.Title.Text = "Marriage!";
newPost.Content = new AtomContent();
newPost.Content.Content = "<div xmlns='http://www.w3.org/1999/xhtml'>" +
    "<p>Mr. Darcy has <em>proposed marriage</em> to me!</p>" +
    "<p>He is the last man on earth I would ever desire to marry.</p>" +
    "<p>Whatever shall I do?</p>" +
    "</div>";
newPost.Content.Type = "xhtml";
newPost.IsDraft = true;

Uri blogFeedUri = new Uri("http://www.blogger.com/feeds/" + blogId + "/posts/default");
AtomEntry createdEntry = service.Insert(blogFeedUri, newPost);

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

אחזור פוסטים

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

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

אחזור כל פוסטי הבלוג

כדי לאחזר את הפוסטים של המשתמש, קוראים לאותה שיטה של getFeed שבה השתמשתם כדי לאחזר את המטא-פיד של הבלוגים, אבל הפעם צריך לשלוח את כתובת ה-URL של פיד הפוסטים בבלוג:

query.Uri = new Uri("http://www.blogger.com/feeds/" + blogId + "/posts/default");
feed = service.Query(query);
Console.WriteLine(feed.Title.Text);
foreach (AtomEntry entry in feed.Entries)
{
  Console.WriteLine("Entry Title: " + entry.Title.Text);
}

אחזור פוסטים באמצעות פרמטרי שאילתה

Blogger Data API מאפשר לך לבקש קבוצת רשומות שתואמות לקריטריונים שצוינו קריטריונים, כמו שליחת בקשה לפוסטים בבלוג שיפורסמו או עודכנו בתאריך נתון. טווח. כדי לעשות זאת, יוצרים אובייקט FeedQuery ומעבירים אותו ל-method‏ Service.Query().

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

FeedQuery query = new FeedQuery();
query.Uri = new Uri("http://www.blogger.com/feeds/" + blogId + "/posts/default");
query.MinPublication = new DateTime(2006, 1, 1);
query.MaxPublication = new DateTime(2007, 4, 12);
AtomFeed feed = service.Query(query);
foreach (AtomEntry entry in feed.Entries)
{
  Console.WriteLine("  Entry Title: " + entry.Title.Text);
}

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

Blogger Data API תומך בפרמטרים הבאים של שאילתות:

alt: סוג הפיד שיוחזר, למשל atom (ברירת המחדל) או rss.
/category: מציינים קטגוריות (שנקראות גם תוויות) כדי לסנן את תוצאות הפיד. לדוגמה, הפונקציה http://www.blogger.com/feeds/blogID/posts/default/-/Fritz/Laurie מחזירה רשומות עם התוויות Fritz וגם עם Laurie.
מקסימום תוצאות: המספר המקסימלי של הרשומות להחזרה.
לפי סדר: הסדר שבו יש להחזיר רשומות, למשל lastmodified (ברירת המחדל), starttime או updated.
published-min,‏ published-max: הגבלות על תאריכי פרסום של רשומות.
start-index: האינדקס שמתחיל ב-1 של התוצאה הראשונה שאוחזרה (לצורך דפדוף).
מעודכן דקות, מעודכן-מקסימום: הגבולות לתאריכי עדכון של רשומות. המערכת מתעלמת מהפרמטרים האלה של שאילתות, אלא אם הפרמטר orderby מוגדר ל-updated.

מידע נוסף על פרמטרים של שאילתות זמין במדריך העזרה של Blogger Data API ובמדריך העזרה של Google Data APIs.

עדכון פוסטים

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

static AtomEntry EditEntry(AtomEntry toEdit)
{
  // Edit the entry by changing the Title and calling Update().
  if (toEdit != null)
  {
    toEdit.Title.Text = "Marriage Woes!";
    toEdit = toEdit.Update();
  }
  return toEdit;
}

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

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

מחיקת פוסטים

כדי למחוק פוסט, יש להפעיל את השיטה Delete בחשבון קיים אובייקט AtomEntry, כך:

static void DeleteEntry(AtomEntry toDelete)
{
  // Delete the edited entry
  if (toDelete != null)
  {
    toDelete.Delete();
  }
}

תגובות

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

יצירת תגובות

כדי לפרסם תגובה, יוצרים אובייקט AtomEntry ומוסיפים אותו באופן הבא:

AtomEntry comment;
comment = new AtomEntry();
comment.Title.Text = "This is my first comment";
comment.Content.Content = "This is my first comment";
Uri commentPostUri = new Uri("http://www.blogger.com/feeds/" + blogId + "/" + entryId + "/comments/default");
postedComment = service.Insert(commentPostUri, comment);

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

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

המערכת מאחזרת תגובות

ניתן לאחזר את התגובות לפוסט מסוים מהתגובות של הפוסט כתובת ה-URL של הפיד:

static void ListEntryComments(Service service, Uri commentUri)
{
  if (commentUri != null)
  {
    // Retrieve all comments on a blog entry
    FeedQuery query = new FeedQuery();
    query.Uri = commentUri;
    AtomFeed feed = service.Query(query);
    foreach (AtomEntry entry in feed.Entries)
    {
      Console.WriteLine("  Comment Title: " + entry.Title.Text);
    }
  }
}

לחלופין, אפשר לקבל את התגובות מכל הפוסטים דרך פיד התגובות של הבלוג כתובת ה-URL:

http://www.blogger.com/feeds/blogID/comments/default

מחיקת תגובות

כדי למחוק תגובה, יש להפעיל את השיטה Delete() באפליקציה קיימת תגובה AtomEntry אובייקט כך:

static void DeleteComment(AtomEntry commentEntry)
{
  if (commentEntry != null)
  {
    // Delete the comment.
    commentEntry.Delete();
  }
}

חזרה למעלה