AdWords API pierwszy projekt

Wbrew pozorom odpalenie pierwszego projektu w środowisku Visual Studio dla języka C# nie jest takie proste w AdWords API.

Po pierwsze należy ściągnąć przygotowany przez Google zestaw bibliotek Clients Library dl wybranego języka ( w tym przypadku dla C# i platformy .NET ). Ale na tym nie koniec. Kolejnym krokiem jest ściągnięcie pliku ICSharpCode.ShapZipLib oraz dodaniego jego referencji do projektu w VS. Oprócz tego należy jeszcze dodać referencję do System.Web.Services oraz do google-api-adwords-dotnet.

Na czas developingu oprogramowania przyda się jeszcze konto Sandbox w AdWords, wystarczy posiadać zwykłe konto na GMail - automatycznie mamy dostęp do Sandbox’a. Jeśli go nie mamy to należy założyć sobie takie konto.

Po tym możemy pisać już pierwsze programy do zarządzania kampaniami Google AdWords. Dla przykładu poniżej kod, który połączy się z Sandbox’em i wylistuje  dostępne konta klientów ( domyślnie w Sandbox’ie jest takich 5 ):

Hashtable headers = new Hashtable();
headers.Add( “email”, “mail@gmail.com” );
headers.Add( “password”, “haslo” );
headers.Add( “useragent”, “C# demo” );
headers.Add( “developerToken”, “mail@gmail.com++PLN” );
headers.Add( “applicationToken”, “1234567890123456789012″ );
headers.Add( “alternateUrl”, “https://sandbox.google.com/” );
AdWordsUser user = new AdWordsUser( headers );

AccountService account = ( AccountService )user.getService( “AccountService” );
String[] clientAccounts = account.getClientAccounts();

Console.Out.WriteLine( “++++ Users ++++” );
foreach ( String client in clientAccounts )
{
Console.Out.WriteLine( “Client account: ” + client );
}

Dla aplikacji w Sandbox’ie applicationToken jest dowolny natomiast developerToken to adres e-mail z dołączoną domyśłną walutą ( dla Polski jest to PLN ).

Mechanizm refleksji i własne DLL

Na potrzeby najbliższego projektu w C# musiałem nieco dowiedzieć się na temat refleksji ( Reflection ). Otóż przydaje się on w momencie gdy chcemy uruchamiać jakieś metody na poziomie wykonywanego programu a nie na poziomie kompilacji. Nie wiemy co to za obiekt, nie wiemy jakie ma metody i atrybuty.

Stworzyłem więc własną prościutką bibliotekę DLL, służy do tego wizard z Visual Studio. Kod poniżej:

namespace FirstDLL
{
public class Maths
{
public double Add( double d1, double d2 )
{
return d1+d2;
}

public double Substract( double d1, double d2 )
{
return d1-d2;
}
}
}

// a drugi plik:
namespace FirstDLL
{
class Writer
{
private string message = “heloł world”;

public string Message
{
get
{
return message;
}
set
{
message = value;
}
}

public void WriteMessage()
{
Console.WriteLine( message );
}
}
}

Są dwie klasy, żeby DLL nie składało się tylko z jednej ;) Zbudowanie projektu dało mi w efekcie plik FirstDLL.dll, który to umieściłem w projekcie z testowanym mechanizmem refleksji. Oto kod tej klasy ( bardzo zagmatwany, ale nieco się nakombinowałem ):

namespace ReflectionTest
{
class Program
{
static void Main( string[] args )
{
Assembly asem = Assembly.LoadFrom( “FirstDLL.dll” );
Type[] types = asem.GetTypes();
double result=0.0;

foreach ( Type t in types )
{
object my = Activator.CreateInstance( t );
if ( t.IsClass )
{
MethodInfo[] mem = t.GetMethods();
foreach ( MethodInfo m in mem )
{
if ( m.Name.CompareTo( “Add” ) == 0 )
{
object[] arg = new object[2];
arg[0] = 5.4;
arg[1] = 2;
result = (double)m.Invoke( my, arg );
}
}
}
}
Console.WriteLine( result.ToString() );

}
}
}

Oczywiście nie jest to kod niesamowity ani niosący jakieś szczególne zastosowanie w reflekcji - po prostu chciałem sprawdzić czy działa. Mam nadzieję, że ten prosty przykład pozwoli postawić pierwsze kroki w tej kwestii. Ja również dopiero się tego uczę i może za jakiś czas pojawi się bardziej praktyczny przykład.

Pobranie danych przez HTTP

Ta dziedzina przyda mi się wkrótce przy pisaniu nieco większego projektu więc dziś zabawiłem się w pierwsze rozeznanie. Jak się okazuje, C# udostępnia bardzo wygodne w użyciu klasy, umożliwiające prostą komunikację poprzez protokół HTTP. Poniżej fragment kodu:

HttpWebRequest request = WebRequest.Create( “http://p-zone.pl” ) as HttpWebRequest;// 1
request.Timeout = 10000;
request.UserAgent = “prawie Firefox :) “;
HttpWebResponse reponse = request.GetResponse() as HttpWebResponse;// 2

StreamReader stream = new StreamReader( reponse.GetResponseStream() );// 3
string html = stream.ReadToEnd();

txtContent.Text = html;

reponse.Close();// 4
stream.Close();

A teraz króciutki opis co się dzieje.

1. Stworzenie obiektu HttpWebRequest za pomocą statycznej metody klasy WebRequest i podanie adresu, skąd pobieramy dane
2. Uzyskanie obiektu HttpWebResponse - czyli odpowiedzi na wysłane żądanie
3. Pobranie strumienia danych i odczytanie go do końca
4. Zamknięcie połączenia i strumienia

Zmienna txtContent to obiekt RichTextBox, do którego wrzucam pobraną zawartość witryny.

Po pierwsze - używaj właściwości

Język C# ma sporą przewagę nad C++ i część z tych mechanizmów języka będę się starał opisywać co jakiś czas w kolejnych notkach. Tym razem coś co usprawni naszą pracę z klasami - atrybuty/właściwości/properties. Mechanizm ten był w C++ wykorzystywany na około - poprzez metody dostępu tzw settery i gettery a wyglądało to mniej więcej tak:

class tmp
{
private: int var;
public:
int getVar() const;
void setVar( int newVar );
};

Klasa używała metod aby udostępnić wewnętrzne zmienne i jednocześnie zachować enkalpsulację. Czyli praktycznie po dwie metody dla każdej zmiennej składowej co przy sporych rozmiarów obiekcie dawało niezliczoną ilość niepotrzebnych i robiących zamieszanie metod. Język C# rozwiązuje to tak:

public class tmp
{
private int var;
public int Var
{
get { return var; }
set { var = value; }
}
};

Jak widać zachowujemy enkapsulację a jednocześnie nie musimy pisać dodatkowych metod. Oprócz tego mamy tak samo jak w C++ możliwość, aby niejako zabronić zewnętrznego odczytu bądź zapisu danej zmiennej - wystarczy nie udostępniać get lub set we właściwości. Atrybuty są bardzo wygodne i sprawiają, że kod je wykorzystujący jest znacznie bardziej czytelny.

Poza opisanymi wyżej zaletami, są jeszcze inne. Przykładem jest mechanizm bardzo skojarzony z atrybutami, mianowicie są to indeksery. Możemy dzięki temu zapewnić dostęp do obiektu poprzez indeks jak do tablicy. Co więcej, może to być dostęp do zwykłej tablicy jak i do słownika:

public int this [ int index ]
{
get { return array[ index ] ; }
set { array[ index ] = value; }
}

Przy czym jak już wspominałem - zmienną indeksującą może być także typ string, wtedy mamy słownik.

Mam nadzieję, że udało mi się przybliżyć właściwości w klasach C# i zachęcić do ich używania.