using System;
using System.Collections.Generic;
using Google.GData.Client;

namespace BloggerAutoPoster
{
    public class BloggerAutoPoster
    {
        public string UserName { set; get; }

        public string Password { set; get; }

        public string PostTitle { set; get; }

        public IList<string> PostTags { set; get; }

        public string PostBody { set; get; }

        public string BlogUrl { set; get; }

        public bool PostAsDraft { set; get; }

        public bool PostNewEntry()
        {
            var service = new Service("blogger", "blogger-example")
                {
                    Credentials = new GDataCredentials(UserName, Password)
                };
            var newPost = constructNewEntry();
            var result = service.Insert(new Uri(BlogUrl), newPost);
            return result != null;
        }

        private AtomEntry constructNewEntry()
        {
            var newPost = new AtomEntry
                {
                    Title = { Text = PostTitle },
                    Content = new AtomContent
                              {
                                  Content = string.Format(@"<div xmlns=""http://www.w3.org/1999/xhtml"">{0}</div>", PostBody),
                                  Type = "xhtml"
                              },
                    IsDraft = PostAsDraft
                };

            foreach (var tag in PostTags)
            {
                newPost.Categories.Add(
                    new AtomCategory
                    {
                        Term = tag,
                        Scheme = "http://www.blogger.com/atom/ns#"
                    });
            }

            return newPost;
        }
    }
}

new BloggerAutoPoster
{
      BlogUrl = "https://www.blogger.com/feeds/number/posts/default",
      UserName = "name@gmail.com",
      Password = "pass",
      PostTitle = "بررسی ارسل خودکار-3",
      PostTags = new List<string> { "بررسی ارسال خودکار" },
      PostBody = "تست می‌شود123",
      PostAsDraft = false
}.PostNewEntry();

using System;
using System.Collections.Generic;
using System.Linq;
using Google.GData.Client;

namespace BloggerAutoPoster
{
    public class BlogInfo
    {
        public string Title { set; get; }
        public string Url { set; get; }
    }

    public class BloggerInfo
    {
        public static IList<BlogInfo> FindMyBlogsUrls(string username, string password)
        {
            var result = new List<BlogInfo>();

            var service = new Service("blogger", "blogger-example")
            {
                Credentials = new GDataCredentials(username, password)
            };

            var query = new FeedQuery { Uri = new Uri("https://www.blogger.com/feeds/default/blogs") };
            var feed = service.Query(query);

            if (feed == null)
                throw new NotSupportedException("You don't have any blogs!");

            foreach (var entry in feed.Entries)
            {
                result.AddRange(entry.Links.Where(t => t.Rel.Equals("http://schemas.google.com/g/2005#post"))
                                           .Select(t => new BlogInfo
                                                        {
                                                            Url = new Uri(t.HRef.ToString()).AbsoluteUri,
                                                            Title = entry.Title.Text
                                                        }));
            }

            return result;
        }
    }
}

public class PropertiesValidator<TK, T> where T : new() where TK : new()
{
    static TK _instance;

    public static TK Instance
    {
        get
        {
            if (_instance == null)
            {
                _instance = new TK();
            }
            return _instance;
        }
    }

    public void Validate(T expectedObject, T realObject, params string[] propertiesNotToCompare)
    {
        var properties = realObject.GetType().GetProperties();
        foreach (var currentRealProperty in properties)
        {
            if (!propertiesNotToCompare.Contains(currentRealProperty.Name))
            {
                var currentExpectedProperty = expectedObject.GetType().GetProperty(currentRealProperty.Name);
                var exceptionMessage = $"The property {currentRealProperty.Name} of class {currentRealProperty.DeclaringType?.Name} was not as expected.";

                if (currentRealProperty.PropertyType != typeof(DateTime) && currentRealProperty.PropertyType != typeof(DateTime?))
                {
                    Assert.AreEqual( currentExpectedProperty.GetValue( expectedObject,
                                                                        null ),
                                        currentRealProperty.GetValue( realObject,
                                                                    null ),
                                        exceptionMessage );
                }
                else
                {
                    DateTimeAssert.Validate( currentExpectedProperty.GetValue( expectedObject,
                                                                                null ) as DateTime?,
                                                currentRealProperty.GetValue( realObject,
                                                                            null ) as DateTime?,
                                                TimeSpan.FromMinutes( 5 ) );
                }
            }
        }
    }
}

public class ObjectToAssert
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public DateTime LastVisit { get; set; }
}

var expectedObject = new ObjectToAssert
                        {
                            FirstName = "Vahid",
                            LastName = "Mohammad Taheri",
                            LastVisit = new DateTime( 2016, 11, 14, 0, 10, 50 )
                        };
var actualObject = new ObjectToAssert
                        {
                            FirstName = "Vahid",
                            LastName = "Mohammad Taheri",
                            LastVisit = new DateTime( 2016, 11, 14, 0, 13, 50 )
                        };

public interface ICacheStorage
{
    void Remove(string key);
    void Store(string key, object data);
    T Retrieve<T>(string key);
}