C# Google Goggles API/或解决方案

我已经读过了 . 来自 使用示例代码创建了一个c#实现。最近有人能让它工作吗？我知道API没有文档化，因此可能已经更改，因此代码可能工作了，但现在没有，或者我的代码有错误。我不断得到一个异常抛出给我一个协议错误。（异常中的错误500和异常状态中的协议错误）代码如下

 using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
public class Goggles
{         // The POST body required to validate the CSSID.         
    private static byte[] CssidPostBody = new byte[] { 34, 0, 98, 60, 10, 19, 34,
        2, 101, 110, 186, 211, 240, 59, 10, 8, 1, 16, 1, 40, 1, 48, 0, 56, 1, 18,             
        29, 10, 9, 105, 80, 104, 111, 110, 101, 32, 79, 83, 18, 3, 52, 46, 49,              
        26, 0, 34, 9, 105, 80, 104, 111, 110, 101, 51, 71, 83, 26, 2, 8, 2, 34,             
        2, 8, 1 };
    // Bytes trailing the image byte array. Look at the next code snippet to see         
    // where it is used in SendPhoto() method.         
    private static byte[] TrailingBytes = new byte[] { 24, 75, 32, 1, 48, 0, 146,
        236, 244, 59, 9, 24, 0, 56, 198, 151, 220, 223, 247, 37, 34, 0 };
    // Generates a cssid.         
    private static string Cssid
    {
        get
        {
            Random random = new Random((int)DateTime.Now.Ticks);
            return string.Format(
                "{0}{1}",
                random.Next().ToString("X8"),
                random.Next().ToString("X8"));
        }
    }
    static void Main(string[] args)
    {
        string cssid = Goggles.Cssid;
        Goggles.ValidateCSSID(cssid);
        // See next code snippet for SendPhoto()             
        //Goggles.SendPhoto(cssid, yourImageByteArray);             
        Console.ReadLine();
    }
    // Validates the CSSID we just created, by POSTing it to Goggles.         
    private static void ValidateCSSID(string cssid)
    {
        HttpWebRequest request = (HttpWebRequest)WebRequest.Create(string.Format("http://www.google.com/goggles/container_proto?cssid={0}", cssid));
        Goggles.AddHeaders(request); request.Method = "POST";
        using (Stream stream = request.GetRequestStream())
        {
            stream.Write(Goggles.CssidPostBody, 0, Goggles.CssidPostBody.Length);
            stream.Flush();
        } 
        HttpWebResponse response = (HttpWebResponse)request.GetResponse();
    }
    private static byte[] imageToByteArray(System.Drawing.Image imageIn)
    {
        MemoryStream ms = new MemoryStream();
        imageIn.Save(ms, System.Drawing.Imaging.ImageFormat.Gif);
        return ms.ToArray();
    }
    private static void AddHeaders(HttpWebRequest request)
    {
        request.ContentType = "application/x-protobuffer";
        request.Headers["Pragma"] = "no-cache";
        request.KeepAlive = true;
    }
    public static HttpWebResponse SendPhoto(string file)
    {
        System.Drawing.Image oimg = System.Drawing.Image.FromFile(file);

        return (SendPhoto(imageToByteArray(oimg)));
    }
    public static   HttpWebResponse  SendPhoto(byte[] image)
    {
        string cssid = null;
        HttpWebResponse response;
        SendPhoto(ref cssid, image, out response);
        return response;
    }
    public static void SendPhoto( ref string cssid, byte[] image, out HttpWebResponse pHttpWebResponse) 
    { 
        if (cssid == null || cssid == "") 
                cssid = Goggles.Cssid;

        HttpWebRequest request = (HttpWebRequest)WebRequest.Create(

            string.Format(        
            "http://www.google.com/goggles/container_proto?cssid={0}",
            cssid));
        Goggles.AddHeaders(request);
        request.Method = "POST";       
        // x = image size
        int x = image.Length;
        byte[] xVarint = Goggles.ToVarint32(x).ToArray<byte>();
        // a = x + 32     
        byte[] aVarint = Goggles.ToVarint32(x + 32).ToArray<byte>();
        // b = x + 14     
        byte[] bVarint = Goggles.ToVarint32(x + 14).ToArray<byte>();
        // c = x + 10     
        byte[] cVarint = Goggles.ToVarint32(x + 10).ToArray<byte>();
        // 0A [a] 0A [b] 0A [c] 0A [x] [image bytes]     
        using (Stream stream = request.GetRequestStream())     
        {         
            // 0x0A         
            stream.Write(new byte[] { 10 }, 0, 1);
                // a         
            stream.Write(aVarint, 0, aVarint.Length);
            // 0x0A         
            stream.Write(new byte[] { 10 }, 0, 1);
            // b         
            stream.Write(bVarint, 0, bVarint.Length);           
            // 0x0A         
            stream.Write(new byte[] { 10 }, 0, 1);
            // c         
            stream.Write(cVarint, 0, cVarint.Length);
            // 0x0A         
            stream.Write(new byte[] { 10 }, 0, 1);
            // x         
            stream.Write(xVarint, 0, xVarint.Length);
            // Write image          
            stream.Write(image, 0, image.Length);
            // Write trailing bytes         
            stream.Write(             
                Goggles.TrailingBytes,
                0,              Goggles.TrailingBytes.Length);
            stream.Flush();
        } try
        {
            pHttpWebResponse = null;
            pHttpWebResponse = (HttpWebResponse)request.GetResponse();
        }
        catch (Exception ex)
        {
            pHttpWebResponse = null;

        }
    }
    // Encodes an int32 into varint32. 
    public static IEnumerable<byte> ToVarint32(int value) 
    {     
        int index = 0;
        while ((0x7F & value) != 0)
        {         
            int i = (0x7F & value);
            if ((0x7F & (value >> 7)) != 0)
            {             
                i += 128;         
            }     

            yield return ((byte)i);         
            value = value >> 7;
            index++;     
        } 
    }
}

使用系统；
使用System.Collections.Generic；
使用System.IO；
使用System.Linq；
Net系统；
公共级护目镜
{//验证CSSID所需的POST正文。
私有静态字节[]CssidPostBody=新字节[]{34,0,98,60,10,19,34，
2, 101, 110, 186, 211, 240, 59, 10, 8, 1, 16, 1, 40, 1, 48, 0, 56, 1, 18,             
29, 10, 9, 105, 80, 104, 111, 110, 101, 32, 79, 83, 18, 3, 52, 46, 49,              
26, 0, 34, 9, 105, 80, 104, 111, 110, 101, 51, 71, 83, 26, 2, 8, 2, 34,             
2, 8, 1 };
//图像字节数组后面的字节。请查看下一个代码段
//在SendPhoto（）方法中使用。
私有静态字节[]TrailingBytes=新字节[]{24,75,32,1,48,0,146，
236, 244, 59, 9, 24, 0, 56, 198, 151, 220, 223, 247, 37, 34, 0 };
//生成cssid。
私有静态字符串Cssid
{
得到
{
Random Random=新随机（（int）DateTime.Now.Ticks）；
返回字符串格式(
"{0}{1}",
random.Next（）.ToString（“X8”），
random.Next（）.ToString（“X8”）；
}
}
静态void Main（字符串[]参数）
{
字符串cssid=Goggles.cssid；
护目镜。验证ECSSID（cssid）；
//请参阅SendPhoto（）的下一个代码段
//护目镜。发送照片（cssid，yourImageByteArray）；
Console.ReadLine（）；
}
//通过将其发布到Goggles来验证我们刚刚创建的CSSID。
私有静态void ValidateCSSID（字符串cssid）
{
HttpWebRequest请求=（HttpWebRequest）WebRequest.Create（string.Format（“http://www.google.com/goggles/container_proto?cssid={0}（cssid））；
Goggles.AddHeaders（请求）；request.Method=“POST”；
使用（Stream=request.GetRequestStream（））
{
stream.Write（Goggles.CssidPostBody，0，Goggles.CssidPostBody.Length）；
stream.Flush（）；
} 
HttpWebResponse=（HttpWebResponse）request.GetResponse（）；
}
专用静态字节[]imageToByteArray（System.Drawing.Image imageIn）
{
MemoryStream ms=新的MemoryStream（）；
保存（ms，System.Drawing.Imaging.ImageFormat.Gif）；
返回ToArray女士（）；
}
私有静态void AddHeaders（HttpWebRequest请求）
{
request.ContentType=“应用程序/x-protobuffer”；
request.Headers[“Pragma”]=“无缓存”；
request.KeepAlive=true；
}
公共静态HttpWebResponse SendPhoto（字符串文件）
{
System.Drawing.Image oimg=System.Drawing.Image.FromFile（文件）；
返回（SendPhoto（imageToByteArray（oimg））；
}
公共静态HttpWebResponse SendPhoto（字节[]图像）
{
字符串cssid=null；
HttpWebResponse；
SendPhoto（参考cssid、图像、输出响应）；
返回响应；
}
公共静态void SendPhoto（参考字符串cssid，字节[]图像，输出HttpWebResponse pHttpWebResponse）
{ 
如果（cssid==null | | cssid==“”）
cssid=护目镜。cssid；
HttpWebRequest请求=（HttpWebRequest）WebRequest.Create(
字符串格式（
"http://www.google.com/goggles/container_proto?cssid={0}",
cssid）；
护目镜。添加标题（请求）；
request.Method=“POST”；
//x=图像大小
int x=图像长度；
字节[]xVarint=Goggles.ToVarint32（x）.ToArray（）；
//a=x+32
字节[]aVarint=Goggles.ToVarint32（x+32）.ToArray（）；
//b=x+14
字节[]bVarint=Goggles.ToVarint32（x+14）.ToArray（）；
//c=x+10
字节[]cVarint=Goggles.ToVarint32（x+10）.ToArray（）；
//0A[a]0A[b]0A[c]0A[x][图像字节]
使用（Stream=request.GetRequestStream（））
{         
//0x0A
写入（新字节[]{10}，0，1）；
//a
stream.Write（aVarint，0，aVarint.Length）；
//0x0A
写入（新字节[]{10}，0，1）；
//b
stream.Write（bVarint，0，bVarint.Length）；
//0x0A
写入（新字节[]{10}，0，1）；
//c
流写入（cVarint，0，cVarint.Length）；
//0x0A
写入（新字节[]{10}，0，1）；
//x
stream.Write（xVarint，0，xVarint.Length）；
//书写图像
stream.Write（image，0，image.Length）；
//写入尾随字节
stream.Write（
护目镜，追踪字节，
0，Goggles.TrailingBytes.Length）；
stream.Flush（）；
}试一试
{
pHttpWebResponse=null；
pHttpWebResponse=（HttpWebResponse）request.GetResponse（）；
}
捕获（例外情况除外）
{
pHttpWebResponse=null；
}
}
//将int32编码为varint32。
公共静态IEnumerable to Varint32（int值）
{     
int指数=0；
而（（0x7F和值）！=0）
{         
int i=（0x7F&value）；
如果（（0x7F&（值>>7））！=0）
{             
i+=128；
}     
收益率返回（（字节）i）；