[教程][Blogger][C#] Blogger API v3 教程#8——更改帖子标题

【这个系列中..】

[教程][Blogger][C#] Blogger API v3教程#1 —— 前言
[教程][Blogger][C#] Blogger API v3 教程#2 —— 申请 Blogger API 的使用权限
[教程][Blogger][C#] Blogger API v3 教程#3 —— 获取API Key、Client ID 和 Client Secret
[教程][Blogger][C#] Blogger API v3 教程#4 —— 设置开发环境、安装插件、添加Reference
[教程][Blogger][C#] Blogger API v3 教程#5 —— 获取Blog Id
[教程][Blogger][C#] Blogger API v3 教程#6——OAuth 2.0 认证
[教程][Blogger][C#] Blogger API v3 教程#7——获取帖子列表
[教程][Blogger][C#] Blogger API v3 教程#8——更改帖子标题

Blogger 有一个API 叫做blogger.pages.update
对应.net 库PostsResource中的.Update() 函数
返回一个PostsResource.UpdateRequest 类型



先拿出其中一个post：

Post postUpdate = postsListReq.Execute().Items[0];

然后更改标题：

postUpdate.Title = "Title Changed";

创建一个UpdateRequest
然后执行.Execute()

PostsResource.UpdateRequest blogUpdate = postRes.Update(postUpdate, blog.Id, postUpdate.Id);
blogUpdate.Execute();

完整代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using Google.Apis.Blogger.v3;
using Google.Apis.Blogger.v3.Data;
using Google.Apis.Services;
using System.Diagnostics;
using Google.Apis.Authentication.OAuth2;
using Google.Apis.Authentication.OAuth2.DotNetOpenAuth;
using DotNetOpenAuth.OAuth2;
using Google.Apis.Util;


namespace BloggerTest
{
    class Program
    {
        static void Main(string[] args)
        {
            string apiKey= "{API-KEY}";
            string blogUrl= "{BLOG-URL}";

            string clientID = "{CLIENT_ID}";
            string clientSec = "{CLIENT_SECRET}";

            NativeApplicationClient provider = new NativeApplicationClient(GoogleAuthenticationServer.Description)
            {
                ClientIdentifier = clientID,
                ClientSecret = clientSec
            };

            OAuth2Authenticator<NativeApplicationClient> auth = new OAuth2Authenticator<NativeApplicationClient>(provider, getAuth);

            BloggerService blogService = new BloggerService(new BaseClientService.Initializer()
            {
                Authenticator = auth,
                ApplicationName = "BloggerTest"
            });


            BlogsResource.GetByUrlRequest getReq = blogService.Blogs.GetByUrl(blogUrl);
            getReq.Key = apiKey;
            Blog blog = getReq.Execute();

            Console.WriteLine("Blog ID: " + blog.Id);
            Console.WriteLine();

            PostsResource postRes = new PostsResource(blogService);
            PostsResource.ListRequest postsListReq = postRes.List(blog.Id);

            string firstToken = "";

            while (true)
            {
                PostList posts = postsListReq.Execute();
                postsListReq.PageToken = posts.NextPageToken;

                if (firstToken == "")
                {
                    firstToken = posts.NextPageToken;
                }
                else if (firstToken != "" && posts.NextPageToken == firstToken)
                {
                    // repeated
                    break;
                }

                for (int i = 0; i < posts.Items.Count; i++)
                {
                    Console.WriteLine("Title: " + posts.Items[i].Title);
                    Console.WriteLine("URL: " + posts.Items[i].Url);
                }

            }

            Post postUpdate = postsListReq.Execute().Items[0];
            postUpdate.Title = "Title Changed";

            PostsResource.UpdateRequest blogUpdate = postRes.Update(postUpdate, blog.Id, postUpdate.Id);
            blogUpdate.Execute();

            Console.WriteLine();
            Console.WriteLine("Done...");

            Console.ReadKey();



        }

        private static IAuthorizationState getAuth(NativeApplicationClient arg)
        {
            IAuthorizationState state = new AuthorizationState(new[] { BloggerService.Scopes.Blogger.GetStringValue() })
                {
                    Callback = new Uri(NativeApplicationClient.OutOfBandCallbackUrl)
                };
            Uri authUri = arg.RequestUserAuthorization(state);
            Process.Start(authUri.ToString());
            Console.WriteLine("Please enter auth code:");
            string authCode = Console.ReadLine();
            return arg.ProcessUserAuthorization(authCode, state);
        }


    }
}

运行结果：

【后记】

这应该是这个系列的最后一个帖子了..当然还有很多API我没示范..
还有整个系列的完整源码我已经发在 Github 上了：

https://github.com/garyng/BloggerAPIv3Samples

[教程][Blogger][C#] Blogger API v3 教程#7——获取帖子列表

【这个系列中..】

[教程][Blogger][C#] Blogger API v3教程#1 —— 前言

[教程][Blogger][C#] Blogger API v3 教程#2 —— 申请 Blogger API 的使用权限

[教程][Blogger][C#] Blogger API v3 教程#3 —— 获取API Key、Client ID 和 Client Secret

[教程][Blogger][C#] Blogger API v3 教程#4 —— 设置开发环境、安装插件、添加Reference

[教程][Blogger][C#] Blogger API v3 教程#5 —— 获取Blog Id

[教程][Blogger][C#] Blogger API v3 教程#6——OAuth 2.0 认证

[教程][Blogger][C#] Blogger API v3 教程#7——获取帖子列表

[教程][Blogger][C#] Blogger API v3 教程#8——更改帖子标题

【获取帖子列表】

有BlogID 了万事好办..

Blogger API的数据模型是这样的：

Blogs Resource 下有Posts Resource

所以我们创建一个PostsResource变量，传入blogService

PostsResource postsRes = new PostsResource(blogService);

有一API 叫做 posts.list

如上面的GetByUrl Request 一般，PostsResource 也有ListRequest

呼叫PostsResouce 里面的 .List函数，返回一个PostsResource.ListRequest

然后呼叫PostsResource.ListRequest 的.Execute()函数，返回一个PostList 类型

PostsResource postsRes = new PostsResource(blogService);
PostsResource.ListRequest postsListReq = postsRes.List(blog.Id);
PostList posts = postsListReq.Execute();

Blogger API 默认返回10个posts，储存在Post.Items中

现在在遍历.Items 然后输出post的 Title

for (int i = 0; i < posts.Items.Count; i++)
{
    Console.WriteLine(posts.Items[i].Title);
}

完整代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using Google.Apis.Blogger.v3;
using Google.Apis.Blogger.v3.Data;
using Google.Apis.Services;
using System.Diagnostics;
using Google.Apis.Authentication.OAuth2;
using Google.Apis.Authentication.OAuth2.DotNetOpenAuth;
using DotNetOpenAuth.OAuth2;
using Google.Apis.Util;


namespace BloggerTest
{
    class Program
    {
        static void Main(string[] args)
        {
            string apiKey= "{API-KEY}";
            string blogUrl= "{BLOG-URL}";

            string clientID = "{CLIENT_ID}";
            string clientSec = "{CLIENT_SECRET}";

            NativeApplicationClient provider = new NativeApplicationClient(GoogleAuthenticationServer.Description)
            {
                ClientIdentifier = clientID,
                ClientSecret = clientSec
            };

            OAuth2Authenticator<NativeApplicationClient> auth = new OAuth2Authenticator<NativeApplicationClient>(provider, getAuth);

            BloggerService blogService = new BloggerService(new BaseClientService.Initializer()
            {
                Authenticator = auth,
                ApplicationName = "BloggerTest"
            });


            BlogsResource.GetByUrlRequest getReq = blogService.Blogs.GetByUrl(blogUrl);
            getReq.Key = apiKey;
            Blog blog = getReq.Execute();

            Console.WriteLine("Blog ID: " + blog.Id);
            Console.WriteLine();

            PostsResource postRes = new PostsResource(blogService);
            PostsResource.ListRequest postsListReq = postRes.List(blog.Id);
            PostList posts = postsListReq.Execute();

            for (int i = 0; i < posts.Items.Count; i++)
            {
                Console.WriteLine(posts.Items[i].Title);
            }

            Console.WriteLine();
            Console.WriteLine("Done...");

            Console.ReadKey();



        }

        private static IAuthorizationState getAuth(NativeApplicationClient arg)
        {
            IAuthorizationState state = new AuthorizationState(new[] { BloggerService.Scopes.Blogger.GetStringValue() })
                {
                    Callback = new Uri(NativeApplicationClient.OutOfBandCallbackUrl)
                };
            Uri authUri = arg.RequestUserAuthorization(state);
            Process.Start(authUri.ToString());
            Console.WriteLine("Please enter auth code:");
            string authCode = Console.ReadLine();
            return arg.ProcessUserAuthorization(authCode, state);
        }


    }
}

输出结果：

【获取所有帖子】

PostList 里面有个.PageToken和.NextPageToken、.PrevPageToken

基本上，含义是这样：





所以我们要遍历所有的帖子的话，

要把.PageToken 设置为 NextPageToken

然后还要检测当前的PageToken是否为第一个的PageToken （因为我们已经获取过了，所以不用获取了），如果是的话，就break 出 while loop

所以把之前代码中的

PostList posts = postsListReq.Execute();

删除掉

现在定义一个string为 firstToken

用来储存第一个NextPageToken

string firstToken = "";

现在就是while loop

现在就是while loop

while (true)
{
    PostList posts = postsListReq.Execute();
    postsListReq.PageToken = posts.NextPageToken;

    if (firstToken == "")
    {
        firstToken = posts.NextPageToken;
    }
    else if (firstToken != "" && posts.NextPageToken == firstToken)
    {
        // repeated
        break;
    }

    for (int i = 0; i < posts.Items.Count; i++)
    {
        Console.WriteLine("Title: " + posts.Items[i].Title);
        Console.WriteLine("URL: " + posts.Items[i].Url);
    }

}

}



完整代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using Google.Apis.Blogger.v3;
using Google.Apis.Blogger.v3.Data;
using Google.Apis.Services;
using System.Diagnostics;
using Google.Apis.Authentication.OAuth2;
using Google.Apis.Authentication.OAuth2.DotNetOpenAuth;
using DotNetOpenAuth.OAuth2;
using Google.Apis.Util;


namespace BloggerTest
{
    class Program
    {
        static void Main(string[] args)
        {
            string apiKey= "{API-KEY}"
            string blogUrl= "{BLOG-URL}"

            string clientID = "{CLIENT_ID}";
            string clientSec = "{CLIENT_SECRET}";
            
            NativeApplicationClient provider = new NativeApplicationClient(GoogleAuthenticationServer.Description)
            {
                ClientIdentifier = clientID,
                ClientSecret = clientSec
            };

            OAuth2Authenticator<NativeApplicationClient> auth = new OAuth2Authenticator<NativeApplicationClient>(provider, getAuth);

            BloggerService blogService = new BloggerService(new BaseClientService.Initializer()
            {
                Authenticator = auth,
                ApplicationName = "BloggerTest"
            });


            BlogsResource.GetByUrlRequest getReq = blogService.Blogs.GetByUrl(blogUrl);
            getReq.Key = apiKey;
            Blog blog = getReq.Execute();

            Console.WriteLine("Blog ID: " + blog.Id);
            Console.WriteLine();

            PostsResource postRes = new PostsResource(blogService);
            PostsResource.ListRequest postsListReq = postRes.List(blog.Id);

            string firstToken = "";

            while (true)
            {
                PostList posts = postsListReq.Execute();
                postsListReq.PageToken = posts.NextPageToken;

                if (firstToken == "")
                {
                    firstToken = posts.NextPageToken;
                }
                else if (firstToken != "" && posts.NextPageToken == firstToken)
                {
                    // repeated
                    break;
                }

                for (int i = 0; i < posts.Items.Count; i++)
                {
                    Console.WriteLine("Title: " + posts.Items[i].Title);
                    Console.WriteLine("URL: " + posts.Items[i].Url);
                }

            }

            Console.WriteLine();
            Console.WriteLine("Done...");

            Console.ReadKey();



        }

        private static IAuthorizationState getAuth(NativeApplicationClient arg)
        {
            IAuthorizationState state = new AuthorizationState(new[] { BloggerService.Scopes.Blogger.GetStringValue() })
                {
                    Callback = new Uri(NativeApplicationClient.OutOfBandCallbackUrl)
                };
            Uri authUri = arg.RequestUserAuthorization(state);
            Process.Start(authUri.ToString());
            Console.WriteLine("Please enter auth code:");
            string authCode = Console.ReadLine();
            return arg.ProcessUserAuthorization(authCode, state);
        }


    }
}

输出结果：

[教程][Blogger][C#] Blogger API v3 教程#5 —— 获取Blog Id

【这个系列中..】

[教程][Blogger][C#] Blogger API v3教程#1 —— 前言
[教程][Blogger][C#] Blogger API v3 教程#2 —— 申请 Blogger API 的使用权限
[教程][Blogger][C#] Blogger API v3 教程#3 —— 获取API Key、Client ID 和 Client Secret
[教程][Blogger][C#] Blogger API v3 教程#4 —— 设置开发环境、安装插件、添加Reference
[教程][Blogger][C#] Blogger API v3 教程#5 —— 获取Blog Id
[教程][Blogger][C#] Blogger API v3 教程#6——OAuth 2.0 认证
[教程][Blogger][C#] Blogger API v3 教程#7——获取帖子列表
[教程][Blogger][C#] Blogger API v3 教程#8——更改帖子标题

【获取API Key】

还记得API Key 我们现在需要用到：
登录这边获取API Key：https://code.google.com/apis/console/b/0/?noredirect
1、在API Access 找到 Simple API Access


2、记下API Key

【获取Blog ID】

blogID 和 postID 是最重要的，很多API操作都需要用到它
blogID 可以以Blog URL 来获取，所以我们创建两个string
一个储存API Key， 另一个储存blog URL

string apiKey = "{YOUR-API-KEY}";
string blogUrl = "{YOUR-BLOG-URL}";

要用到Blogger API 就需要创建一个Blogger Service，里面传入一个Initializer 参数：

BloggerService blogService = new BloggerService(new BaseClientService.Initializer()); 

Google APIs Explorer 里面有一个API 是：

所以从blogUrl 获取blogID的API 就会在BloggerService 下的 Blogs.GetByURL()

而Google 的 getByUrl referece（https://developers.google.com/blogger/docs/3.0/reference/blogs/getByUrl）

说GetByUrl 会返回一个GetByUrl

对应.net 的BlogResource.GetByUrlRequest

还需要执行.Execute()函数才能开始获取blogID

.Execute() 函数返回一个Blog类型

记得必须给GetUrlRequest 的变量传入API Key，要不然不会收到任何回复的

BloggerService blogService = new BloggerService(new BaseClientService.Initializer());
BlogsResource.GetByUrlRequest getReq = blogService.Blogs.GetByUrl(blogUrl);
getReq.Key = apiKey;
Blog blog = getReq.Execute();

然后返回的blog 变量里面就有一个参数叫Id,里面储存的就是Blog 的 ID了

Console.WriteLine(blog.Id);

完整代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Google.Apis.Blogger.v3;
using Google.Apis.Blogger.v3.Data;
using Google.Apis.Services;
using System.Diagnostics;
using Google.Apis.Authentication.OAuth2;
using Google.Apis.Authentication.OAuth2.DotNetOpenAuth;
using DotNetOpenAuth.OAuth2;
using Google.Apis.Util;

namespace BloggerTest
{
 class Program
 {
  static void Main(string[] args)
  {
   string apiKey = "{API-KEY}";
   string blogUrl = "{BLOG-URL}";

   BloggerService blogService = new BloggerService(new BaseClientService.Initializer());

   BlogsResource.GetByUrlRequest getReq = blogService.Blogs.GetByUrl(blogUrl);
   getReq.Key = apiKey;
   Blog blog = getReq.Execute();
   Console.WriteLine(blog.Id);

   Console.ReadKey();

  }
 }
}

当你第一次编译运行时，可能会出现这个Open File Dialog

找到下载回来的API dot net client 代码

去到Src/GoogleApis/Apis/Requests/

点击Open 就行了

PS：似乎不用这个file 也可以编译..

运行结果

[教程][Blogger][C#] Blogger API v3 教程#6——OAuth 2.0 认证

【这个系列中..】

[教程][Blogger][C#] Blogger API v3教程#1 —— 前言
[教程][Blogger][C#] Blogger API v3 教程#2 —— 申请 Blogger API 的使用权限
[教程][Blogger][C#] Blogger API v3 教程#3 —— 获取API Key、Client ID 和 Client Secret
[教程][Blogger][C#] Blogger API v3 教程#4 —— 设置开发环境、安装插件、添加Reference
[教程][Blogger][C#] Blogger API v3 教程#5 —— 获取Blog Id
[教程][Blogger][C#] Blogger API v3 教程#6——OAuth 2.0 认证
[教程][Blogger][C#] Blogger API v3 教程#7——获取帖子列表
[教程][Blogger][C#] Blogger API v3 教程#8——更改帖子标题

至于OAuth 是啥，这里不做详细介绍
就是类似这样的东东：


1、先到这边获取Client Id 和 Client Secret ：https://code.google.com/apis/console/b/0/?noredirect


2、创建两个string，储存Client ID 和 Secret

string clientID = "{CLIENT-ID}";
string clientSec = "{CLIENT-SECRET}";

3、Google Code Page 这里有个OAuth2.0 的 .net 版本例子，我们照搬改点东西就好了：


所以我们只要改一改我们的BloggerService 再加上一个function就行了：
先创建NativeApplicationClient

NativeApplicationClient provider = new NativeApplicationClient(GoogleAuthenticationServer.Description)
{
    ClientIdentifier = clientID,
    ClientSecret = clientSec
};

然后是增加一个函数

private static IAuthorizationState getAuth(NativeApplicationClient arg)
{
    IAuthorizationState state = new AuthorizationState(new [] {BloggerService.Scopes.Blogger.GetStringValue()})
        {
            Callback = new Uri(NativeApplicationClient.OutOfBandCallbackUrl)
        };
    Uri authUri = arg.RequestUserAuthorization(state);
    Process.Start(authUri.ToString());
    Console.WriteLine("Please enter auth code:");
    string authCode = Console.ReadLine();
    return arg.ProcessUserAuthorization(authCode, state);
}

创建OAuth2Authenticator

OAuth2Authenticator<NativeApplicationClient> auth = new OAuth2Authenticator<NativeApplicationClient>(provider, getAuth);

然后更改BloggerService

BloggerService blogService = new BloggerService(new BaseClientService.Initializer()
{
    Authenticator = auth,
    ApplicationName = "BloggerTest"
});

完整代码如下：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Google.Apis.Blogger.v3;
using Google.Apis.Blogger.v3.Data;
using Google.Apis.Services;
using System.Diagnostics;
using Google.Apis.Authentication.OAuth2;
using Google.Apis.Authentication.OAuth2.DotNetOpenAuth;
using DotNetOpenAuth.OAuth2;
using Google.Apis.Util;

namespace BloggerTest
{
 class Program
 {
  static void Main(string[] args)
  {
   string apiKey= "{API-KEY}";
   string blogUrl= "{BLOG-URL}";

   string clientID = "{CLIENT_ID}";
   string clientSec = "{CLIENT_SECRET}";

   NativeApplicationClient provider = new NativeApplicationClient(GoogleAuthenticationServer.Description)
   {
    ClientIdentifier = clientID,
    ClientSecret = clientSec
   };

   OAuth2Authenticator<NativeApplicationClient> auth = new OAuth2Authenticator<NativeApplicationClient>(provider, getAuth);

   BloggerService blogService = new BloggerService(new BaseClientService.Initializer()
   {
    Authenticator = auth,
    ApplicationName = "BloggerTest"
   });

   BlogsResource.GetByUrlRequest getReq = blogService.Blogs.GetByUrl(blogUrl);
   getReq.Key = apiKey;
   Blog blog = getReq.Execute();
   Console.WriteLine(blog.Id);

   Console.ReadKey();

  }

  private static IAuthorizationState getAuth(NativeApplicationClient arg)
  {
   IAuthorizationState state = new AuthorizationState(new[] { BloggerService.Scopes.Blogger.GetStringValue() })
    {
     Callback = new Uri(NativeApplicationClient.OutOfBandCallbackUrl)
    };
   Uri authUri = arg.RequestUserAuthorization(state);
   Process.Start(authUri.ToString());
   Console.WriteLine("Please enter auth code:");
   string authCode = Console.ReadLine();
   return arg.ProcessUserAuthorization(authCode, state);
  }
 }
}

编译运行后，程序会开启一个页面：
点击Accept



然后就有一长串字符，Copy 了 paste 进程序内 （[教程] 如何在CMD中Copy & Paste）


然后照常输出blog id


PS：Auth code 会过期的！

[教程][Blogger][C#] Blogger API v3 教程#4 —— 设置开发环境、安装插件、添加Reference

【这个系列中..】

[教程][Blogger][C#] Blogger API v3教程#1 —— 前言
[教程][Blogger][C#] Blogger API v3 教程#2 —— 申请 Blogger API 的使用权限
[教程][Blogger][C#] Blogger API v3 教程#3 —— 获取API Key、Client ID 和 Client Secret
[教程][Blogger][C#] Blogger API v3 教程#4 —— 设置开发环境、安装插件、添加Reference
[教程][Blogger][C#] Blogger API v3 教程#5 —— 获取Blog Id
[教程][Blogger][C#] Blogger API v3 教程#6——OAuth 2.0 认证
[教程][Blogger][C#] Blogger API v3 教程#7——获取帖子列表
[教程][Blogger][C#] Blogger API v3 教程#8——更改帖子标题

我的环境是：Visual Studio 2012 Update 3 @ Windows 7

【工具】

1、Visual Studio 2012
之前发过很多下载地址（多数是torrent的）：[分享][VS] Visual Studio 2010 + 2012 下载地址
 
2、NuGet
这个是一个非常好用的 Visual Studio 插件，用来管理packages的
下载地址：http://docs.nuget.org/docs/start-here/installing-nuget
 
3、Google API DotNet Client
下载地址：http://contrib.google-api-dotnet-client.googlecode.com/hg/1.5.0-beta/Generated/ZipFiles/google-api-dotnet-client-1.5.0-beta.source.zip

【安装NuGet】

1、到官网选择VS 版本，这里是2012


2、点击Download


3、运行点击Install


4、安装完毕，点击Close

【创建&设置Project】

1、打开Visual Studio
Ctrl + Shift + N 创建一个新的 Console Application


2、按下Ctrl + Shift + S 或者到File > Save All 保存project




3、点击Solution Explorer
双击Properties
然后将Target Framework 更换为.Net Framework 4
点击Yes



4、点击Solution Explorer
右键References
点击Manege NuGet Packages…



5、打开NuGet Packages Manager
在上方搜索 "Blogger"
选择Google.Apis.Blogger.v3 Client Library
点击Install


6、等待安装


7、点击Accept


8、安装完毕后，搜索 Google Apis
然后找到Google APIs OAuth2 Client Library
点击Install


9、点击Close 返回IDE


10、然后添加以下usings

using Google.Apis.Blogger.v3;
using Google.Apis.Blogger.v3.Data;
using Google.Apis.Services;
using System.Diagnostics;
using Google.Apis.Authentication.OAuth2;
using Google.Apis.Authentication.OAuth2.DotNetOpenAuth;
using DotNetOpenAuth.OAuth2;
using Google.Apis.Util;

[教程][Blogger][C#] Blogger API v3 教程#3 —— 获取API Key、Client ID 和 Client Secret

【这个系列中..】

[教程][Blogger][C#] Blogger API v3教程#1 —— 前言
[教程][Blogger][C#] Blogger API v3 教程#2 —— 申请 Blogger API 的使用权限
[教程][Blogger][C#] Blogger API v3 教程#3 —— 获取API Key、Client ID 和 Client Secret
[教程][Blogger][C#] Blogger API v3 教程#4 —— 设置开发环境、安装插件、添加Reference
[教程][Blogger][C#] Blogger API v3 教程#5 —— 获取Blog Id
[教程][Blogger][C#] Blogger API v3 教程#6——OAuth 2.0 认证
[教程][Blogger][C#] Blogger API v3 教程#7——获取帖子列表
[教程][Blogger][C#] Blogger API v3 教程#8——更改帖子标题

新版本创建的App 获得的Client ID 和 Client Secret 都似乎不能用..

【Client ID 和 Client Secret】

1、先登录：https://cloud.google.com/console#/project
2、点击下方的 Return to original console


3、点击API Access


4a、如果你看到的是这个的话：
点击Create an OAuth 2.0 Client ID


填入Product Name
点击Next


然后选择Installed Application
点击 Other
点击 Create client ID




4b、如果没有那个大大个的蓝色按钮，点击Create another client ID…


选择Installed application
点击 Other
点击 Create client ID

【获取API Key】

1、如果下方没有Simple API Access 没有一个API Key的话，点击Create New Server Key


2、点击Create


3、就会看到API Key 了

[教程][Blogger][C#] Blogger API v3 教程#2 —— 申请 Blogger API 的使用权限

【这个系列中..】

[教程][Blogger][C#] Blogger API v3教程#1 —— 前言
[教程][Blogger][C#] Blogger API v3 教程#2 —— 申请 Blogger API 的使用权限
[教程][Blogger][C#] Blogger API v3 教程#3 —— 获取API Key、Client ID 和 Client Secret
[教程][Blogger][C#] Blogger API v3 教程#4 —— 设置开发环境、安装插件、添加Reference
[教程][Blogger][C#] Blogger API v3 教程#5 —— 获取Blog Id
[教程][Blogger][C#] Blogger API v3 教程#6——OAuth 2.0 认证
[教程][Blogger][C#] Blogger API v3 教程#7——获取帖子列表
[教程][Blogger][C#] Blogger API v3 教程#8——更改帖子标题

【基本需求】

1、你需要一个Google 账户

【申请Blogger API 使用权限】

1、浏览：https://cloud.google.com/console#/project
2、点击 Create Project


3、填入Project 的基本资料
Project Name、Project ID
勾选 I have read and agree to all Terms of Service for the Google Cloud Platfom products.
然后点击Create


4、点击左边的APIs & auth


5、找到Blogger API v3，点击 OFF


6、然后就会有这个Quota Request 的申请表格
滑倒下面点击提交就行了


7、然后等待Google 发给你回复，通常一两天就能了：


8、点击email 中的 link，就可以了