"send smtp mail from gmail, live, aol or yahoo accounts when my pc is connected via proxy or without proxy to internet" Code Answer

sending mails via proxy server was a little tricky but at the end solved the problem by using the code to send mails via socket.

late at posting answer but lets assume it might be helpful to others.

took help from code at link

attaching the code below, the smtpserver object is same as described in question,

   #region ..... socket mail .....

    private enum smtpresponse : int
    {
        /// <summary>
        /// 220
        /// </summary>
        connect_success = 220,
        /// <summary>
        /// 235
        /// </summary>
        cred_success = 235,
        /// <summary>
        /// 250
        /// </summary>
        generic_success = 250,
        /// <summary>
        /// 334
        /// </summary>
        auth_success = 334,
        /// <summary>
        /// 354
        /// </summary>
        data_success = 354,
        /// <summary>
        /// 221
        /// </summary>
        quit_success = 221
    }

    public static string encodeto64(string toencode)
    {

        byte[] toencodeasbytes = system.text.encoding.ascii.getbytes(toencode);

        string returnvalue = system.convert.tobase64string(toencodeasbytes, base64formattingoptions.none);

        return returnvalue;

    }

    public bool sendfromsocket(mailmessage message)
    {
        var requesturi = new system.uri("smtps://" +smtpserver.host +":"+smtpserver.port);

        uri proxy = null;
        //this is magic code which does your job for the proxy 
        using (var web = new system.net.webclient())
        {                
            proxy = web.proxy.getproxy(requesturi);                
        }

        using (var s = new tcpclient(proxy.dnssafehost, proxy.port  ))
        {               
            using (var stream = s.getstream())
            using (var cleartextreader = new streamreader(stream))
            using (var cleartextwriter = new streamwriter(stream) { autoflush = true })
            using (var sslstream = new sslstream(stream))
            {
                if (!check_response(cleartextreader, smtpresponse.connect_success))
                {
                    s.close();
                    return false;
                }

                cleartextwriter.writeline("helo");
                if (!check_response(cleartextreader, smtpresponse.generic_success))
                {
                    s.close();
                    return false;
                }

                cleartextwriter.writeline("starttls");
                if (!check_response(cleartextreader, smtpresponse.connect_success))
                {
                    s.close();
                    return false;
                }


                sslstream.authenticateasclient(smtpserver.host);
                bool flag = sslstream.isauthenticated;

                using (var reader = new streamreader(sslstream))
                using (var writer = new streamwriter(sslstream) { autoflush = true })
                {                       
                    writer.writeline(string.format("ehlo {0}", smtpserver.host));
                    if (!check_response(reader, smtpresponse.generic_success))
                    {
                        s.close();
                        return false;
                    }

                    writer.writeline("auth login");
                    if (!check_response(reader, smtpresponse.auth_success))
                    {
                        s.close();
                        return false;
                    }

                    writer.writeline(encodeto64(senderid));
                    if (!check_response(reader, smtpresponse.auth_success))
                    {
                        s.close();
                        return false;
                    }

                    writer.writeline(encodeto64(password));
                    if (!check_response(reader, smtpresponse.cred_success))
                    {
                        s.close();
                        return false;
                    }

                    writer.writeline("mail from: <{0}>", message.from);
                    if (!check_response(reader, smtpresponse.generic_success))
                    {

                        s.close();
                        return false;
                    }

                    foreach (mailaddress to in message.to)
                    {
                        writer.writeline("rcpt to: <{0}>", to.address);
                        if (!check_response(reader, smtpresponse.generic_success))
                        {
                            s.close();
                            return false;
                        }
                    }

                    if (message.cc != null)
                    {
                        foreach (mailaddress cc in message.cc)
                        {
                            writer.writeline(string.format("rcpt to: <{0}>", cc.address));
                            if (!check_response(reader, smtpresponse.generic_success))
                            {
                                s.close();
                                return false;
                            }
                        }
                    }

                    stringbuilder header = new stringbuilder();
                    header.append("from: " + message.from + "rn");
                    header.append("to: ");
                    for (int i = 0; i < message.to.count; i++)
                    {
                        header.append(i > 0 ? "," : "");
                        header.append(message.to[i].address);
                    }
                    header.append("rn");
                    if (message.cc != null)
                    {
                        header.append("cc: ");
                        for (int i = 0; i < message.cc.count; i++)
                        {
                            header.append(i > 0 ? "," : "");
                            header.append(message.cc[i].address);
                        }
                        header.append("rn");
                    }
                    header.append("date: ");
                    header.append(datetime.now.tostring("ddd, d m y h:m:s z"));
                    header.append("rn");
                    header.append("subject: " + message.subject + "rn");
                    header.append("x-mailer: smtpdirect v1rn");
                    string msgbody = message.body;
                    if (!msgbody.endswith("rn"))
                        msgbody += "rn";
                    if (message.attachments.count > 0)
                    {
                        header.append("mime-version: 1.0rn");
                        header.append("content-type: multipart/mixed; boundary=unique-boundary-1rn");
                        header.append("rn");
                        header.append("this is a multi-part message in mime format.rn");
                        stringbuilder sb = new stringbuilder();
                        sb.append("--unique-boundary-1rn");
                        sb.append("content-type: text/plainrn");
                        sb.append("content-transfer-encoding: 7bitrn");
                        sb.append("rn");
                        sb.append(msgbody + "rn");
                        sb.append("rn");

                        foreach (object o in message.attachments)
                        {
                            attachment a = o as attachment;
                            byte[] binarydata;
                            if (a != null)
                            {
                                //fileinfo f = new fileinfo(a.);
                                sb.append("--unique-boundary-1rn");
                                sb.append("content-type: application/octet-stream; file=" + a.name + "rn");
                                sb.append("content-transfer-encoding: base64rn");
                                sb.append("content-disposition: attachment; filename=" + a.name + "rn");
                                sb.append("rn");
                                stream fs = a.contentstream;
                                binarydata = new byte[fs.length];
                                long bytesread = fs.read(binarydata, 0, (int)fs.length);
                                fs.close();
                                string base64string = system.convert.tobase64string(binarydata, 0, binarydata.length);

                                for (int i = 0; i < base64string.length; )
                                {
                                    int nextchunk = 100;
                                    if (base64string.length - (i + nextchunk) < 0)
                                        nextchunk = base64string.length - i;
                                    sb.append(base64string.substring(i, nextchunk));
                                    sb.append("rn");
                                    i += nextchunk;
                                }
                                sb.append("rn");
                            }
                        }
                        msgbody = sb.tostring();
                    }

                    writer.writeline("datarn");
                    if (!check_response(reader, smtpresponse.data_success))
                    {
                        s.close();
                        return false;
                    }
                    header.append("rn");
                    header.append(msgbody);
                    header.append(".rn");
                    header.append("rn");
                    header.append("rn");
                    writer.writeline(header.tostring());
                    if (!check_response(reader, smtpresponse.generic_success))
                    {
                        s.close();
                        return false;
                    }

                    writer.writeline("quitrn");
                    check_response(reader, smtpresponse.quit_success);
                    s.close();
                    return true;
                }
            }

        }
    }

    private static bool check_response(streamreader netstream, smtpresponse response_expected)
    {

        int response;

        int read = 0;

        stringbuilder sresponse = new stringbuilder();
        do
        {
            char[] buffer = new char[1024];                
            read = netstream.read(buffer, 0, buffer.length);
            sresponse.append(buffer);                
        }
        while (read == 1024);

        response = convert.toint32(sresponse.tostring().substring(0, 3));

        if (response != (int)response_expected)
            return false;
        return true;
    }

    #endregion ..... socket mail .....